Bump version to 0.0.7

Option semantics: handlers, shared syntax, RaParam interface validation
- Add IOptionSemanticHandler implementations for DNS/DHCP/auth/interface options - Add shared syntax helpers (DnsmasqRrTypeSyntax, DnsmasqScopedDomainSyntax, etc.) - Wire semantics and registry for multi/single options; metadata-only semantics - RaParam: use DnsmasqRelaySyntax.IsInterfaceNameWithOptionalTrailingWildcard so interface names allow only trailing *, not asterisks in the middle (eth*0, *eth0) - Tests: RaParam trailing-wildcard and invalid-asterisk cases
2026-10-03 22:12:00 +10:00 · 2026-03-11 09:44:40 +10:00 · 2026-03-11 09:38:36 +10:00 · 2026-03-10 23:44:51 +10:00 · 2026-03-10 22:33:11 +10:00 · 2026-03-10 18:12:28 +10:00
405 changed files with 16303 additions and 61733 deletions
@@ -2,7 +2,15 @@
 # Both run as root; file permissions work because config dirs are in the container.
 # For dnsmasq on the host, use the self-contained publish (scripts/publish-self-contained.sh)
 # or run the app on the host; see DnsmasqOptions XML doc for permissions and ReloadCommand scope.
+#
+# Dnsmasq install mode for the test harness:
+# - DNSMASQ_VERSION=latest (default): build the latest stable upstream dnsmasq release.
+# - DNSMASQ_VERSION=<version>       : build that exact upstream release (e.g. 2.91).
+# - DNSMASQ_VERSION=distro          : use the distro package from apt.
+#
+# This keeps day-to-day harness use close to upstream while still allowing pinned-version testing.

+ARG DNSMASQ_VERSION=
 FROM mcr.microsoft.com/dotnet/aspnet:10.0 AS base
 WORKDIR /app
 EXPOSE 8080
@@ -19,15 +27,37 @@ RUN dotnet build "DnsmasqWebUI.csproj" -c Release -o /app/build
 FROM build AS publish
 RUN dotnet publish "DnsmasqWebUI.csproj" -c Release -o /app/publish /p:UseAppHost=false

-FROM base AS app
+FROM base AS final
+ARG DNSMASQ_VERSION=latest
 WORKDIR /app
 ENV ASPNETCORE_URLS=http://+:8080
-COPY --from=publish /app/publish .
-
-FROM app AS final
-RUN apt-get update && apt-get install -y --no-install-recommends dnsmasq procps \
-    && rm -rf /var/lib/apt/lists/*
-COPY scripts/entrypoint.sh .
-COPY scripts/dnsmasq-status.sh .
+# Install dnsmasq either from the distro package or by building an upstream release.
+RUN if [ "$DNSMASQ_VERSION" = "distro" ]; then \
+    apt-get update && apt-get install -y --no-install-recommends dnsmasq procps \
+    && rm -rf /var/lib/apt/lists/*; \
+    else \
+    apt-get update && apt-get install -y --no-install-recommends procps curl build-essential xz-utils ca-certificates \
+    && rm -rf /var/lib/apt/lists/* \
+    && if [ "$DNSMASQ_VERSION" = "latest" ]; then \
+         DNSMASQ_VERSION="$(curl -fsSL https://thekelleys.org.uk/dnsmasq/ | grep -o 'dnsmasq-[0-9][0-9.]*\.tar\.xz' | sed 's/^dnsmasq-//; s/\.tar\.xz$//' | sort -V | tail -n1)"; \
+       fi \
+    && test -n "$DNSMASQ_VERSION" \
+    && echo "Building dnsmasq $DNSMASQ_VERSION from upstream source" \
+    && curl -fsSL "https://thekelleys.org.uk/dnsmasq/dnsmasq-${DNSMASQ_VERSION}.tar.xz" -o /tmp/dnsmasq.tar.xz \
+    && tar -C /tmp -xJf /tmp/dnsmasq.tar.xz \
+    && make -C /tmp/dnsmasq-${DNSMASQ_VERSION} -j"$(nproc)" \
+    && make -C /tmp/dnsmasq-${DNSMASQ_VERSION} install PREFIX=/usr \
+    && rm -rf /tmp/dnsmasq-${DNSMASQ_VERSION} /tmp/dnsmasq.tar.xz \
+    && apt-get purge -y build-essential curl xz-utils \
+    && apt-get autoremove -y --purge \
+    && rm -rf /var/lib/apt/lists/*; \
+    fi
+COPY scripts/entrypoint.sh scripts/dnsmasq-status.sh ./
 RUN chmod +x entrypoint.sh dnsmasq-status.sh
+# curl for HEALTHCHECK (aspnet image has no curl/wget)
+RUN apt-get update && apt-get install -y --no-install-recommends curl && rm -rf /var/lib/apt/lists/*
+# .NET publish last - only this layer invalidates when code changes
+COPY --from=publish /app/publish .
 ENTRYPOINT ["./entrypoint.sh"]
+HEALTHCHECK --interval=30s --timeout=5s --start-period=5s --retries=3 \
+  CMD curl -f -s http://localhost:8080/healthz/ready || exit 1
@@ -19,6 +19,8 @@ A self-hosted web UI for managing [dnsmasq](https://thekelleys.org.uk/dnsmasq/do
 - **DHCP host entries** (reservations) if you use DHCP; edit in the UI, written into the managed config.
 - **Reload dnsmasq** after config changes (configurable command, e.g. `systemctl reload dnsmasq` or `pkill -HUP -x dnsmasq`).
 - Optional **status** and **recent logs** commands (e.g. systemctl/journalctl or custom scripts) shown on the Dnsmasq page.
+- **Minimum dnsmasq version** check (configurable; e.g. 2.91). The UI can refuse to start or block config save if the detected version is too old. Version is shown on the Dnsmasq page with a link to release notes.
+- **Readiness endpoint** `GET /healthz/ready` for orchestration (Kubernetes, Docker, load balancers). Returns healthy when dnsmasq version meets the minimum and, if configured, dnsmasq is running. The Docker image includes a HEALTHCHECK that uses this endpoint.
 - **Self-contained Linux binaries** per OS/arch (RID); no .NET install required. Can run in Docker or directly on the host.

 <!-- SUGGESTED SCREENSHOT: MAIN CONFIG OR CONFIG EDITOR PAGE IN THE BROWSER -->
@@ -163,7 +165,7 @@ COPY entrypoint.sh /entrypoint.sh
 ENTRYPOINT ["/entrypoint.sh"]
 ```

-Set `Dnsmasq__MainConfigPath`, `Dnsmasq__ReloadCommand`, and other options via environment variables or an `appsettings.json` in `/app`. Mount your config dir and expose 8080.
+Set `Dnsmasq__MainConfigPath`, `Dnsmasq__ReloadCommand`, and other options via environment variables or an `appsettings.json` in `/app`. Mount your config dir and expose 8080. The image includes a **HEALTHCHECK** that calls `GET /healthz/ready`; orchestration (e.g. Kubernetes readiness probe, or Compose `depends_on: condition: service_healthy`) can use the same endpoint.

 **Config summary for containers:**

@@ -173,8 +175,11 @@ Set `Dnsmasq__MainConfigPath`, `Dnsmasq__ReloadCommand`, and other options via e
 | `Dnsmasq__MainConfigPath` | `/data/dnsmasq.conf` | Main dnsmasq config path (required) |
 | `Dnsmasq__ReloadCommand` | `pkill -HUP -x dnsmasq` | Run after config changes |
 | `Dnsmasq__StatusShowCommand` | `/app/dnsmasq-status.sh` | Optional status output (e.g. our script in test harness) |
+| `Dnsmasq__MinimumVersion` | `2.91` | Minimum dnsmasq version (optional; default 2.91). Set `Dnsmasq__EnforceMinimumVersion=false` to allow older versions. |
 | `ASPNETCORE_URLS` | `http://+:8080` | Port the app listens on |

+**Readiness:** `GET http://localhost:8080/healthz/ready` returns JSON `{"status":"ok"}` when dnsmasq version meets the minimum and (if `StatusCommand` is set) dnsmasq is running. Use this for Kubernetes readiness probes, Docker HEALTHCHECK, or load balancer health checks.
+
 See [Configuration](#configuration) for all options.

 <!-- SUGGESTED SCREENSHOT: EXAMPLE DOCKERFILE SNIPPET OR DOCKER RUN COMMAND SHOWING DNSMASQ + APP IN ONE CONTAINER -->
@@ -205,6 +210,9 @@ The app is configured via **appsettings.json**, **environment variables**, and *
 | `StatusCommand` | Optional: check if dnsmasq is running | `pgrep -x dnsmasq` |
 | `StatusShowCommand` | Optional: full status output (e.g. systemctl status) | `systemctl status dnsmasq --no-pager` |
 | `LogsCommand` | Optional: recent logs (e.g. journalctl) | `journalctl -u dnsmasq -n 100 --no-pager` |
+| `VersionCommand` | Command to probe dnsmasq version (used for minimum-version check and UI display) | `dnsmasq --version` |
+| `MinimumVersion` | Minimum dnsmasq version required (e.g. 2.91). Some options need newer dnsmasq. | `2.91` |
+| `EnforceMinimumVersion` | If true, app fails to start when version probe fails or version is below minimum. If false, only save and readiness checks enforce. | `true` |

 **Application options** (use `Application__` prefix for env, `Application` section in JSON):

@@ -391,7 +399,7 @@ sudo ./scripts/install.sh --uninstall --purge --system

 ### scripts/prepare-test-mount.sh

-**Purpose:** Prepare the testdata mount and optionally start or stop the Docker test harness (app + dnsmasq + DHCP clients). Syncs a source dir (default: `testdata`) into a mount dir (default: `testdata-mount`), cleans up previous test data, then runs `docker compose -f docker-compose.test.yml up -d` (or only prepares the mount with `--prepare-only`).
+**Purpose:** Prepare the testdata mount and optionally start or stop the Docker test harness (app + dnsmasq + DHCP clients). Syncs a source dir (default: `testdata`) into a mount dir (default: `testdata-mount`), cleans up previous test data, then runs `docker compose -f docker-compose.test.yml up -d` (or only prepares the mount with `--prepare-only`). By default the script resolves and uses the **latest stable upstream dnsmasq version**; you can pin a specific version (or use the distro package) for compatibility testing.

 **Usage:** `./scripts/prepare-test-mount.sh [OPTIONS] [--]`

@@ -401,9 +409,11 @@ sudo ./scripts/install.sh --uninstall --purge --system
 |--------|-------------|
 | `--source DIR` | Source to copy from (default: `testdata`). |
 | `--mount DIR` | Target mount directory (default: `testdata-mount`). Compose uses `TESTDATA_MOUNT`; script exports it when you use `--mount`. |
-| `--no-clear` | Do not clear mount dir; only sync over existing contents (e.g. preserve leases between runs). |
+| `--dnsmasq-version V` | Dnsmasq version for the harness image: `latest` (default), `distro`, or an exact upstream version like `2.91`. |
+| `--clear` | Clear the mount dir completely before sync for a clean run. Default: preserve existing contents and sync over them. |
 | `--prepare-only` | Only prepare the mount; do not run docker compose. |
 | `--build` | Pass `--build` to docker compose (rebuild images). Default: use existing images. |
+| `--no-cache-build` | Run `docker compose build --pull --no-cache` before start. Use to force a fresh image build and refresh the resolved latest dnsmasq version. |
 | `--no-build` | Do not rebuild (default). |
 | `--recreate` | Pass `--force-recreate` to docker compose. |
 | `--stop` | Stop the harness: `docker compose down` (no prepare, no start). |
@@ -419,12 +429,22 @@ sudo ./scripts/install.sh --uninstall --purge --system
 # Rebuild images then start
 ./scripts/prepare-test-mount.sh --build

+# Force a fresh image build with no Docker build cache
+./scripts/prepare-test-mount.sh --no-cache-build
+
+# Rebuild with a specific dnsmasq version
+./scripts/prepare-test-mount.sh --dnsmasq-version 2.91 --build
+
+# Use the distro package instead of an upstream build
+./scripts/prepare-test-mount.sh --dnsmasq-version distro --build
+
 # Only prepare the mount; start manually later
 ./scripts/prepare-test-mount.sh --prepare-only
-# Then: TESTDATA_MOUNT=./testdata-mount docker compose -f docker-compose.test.yml up -d
+# Then use the version printed by the script, e.g.:
+# TESTDATA_MOUNT=./testdata-mount DNSMASQ_VERSION=<resolved-version> docker compose -f docker-compose.test.yml up -d

-# Preserve mount contents, sync over it, start
-./scripts/prepare-test-mount.sh --no-clear
+# Preserve mount contents, sync over it, start (default behavior)
+./scripts/prepare-test-mount.sh

 # Stop the harness
 ./scripts/prepare-test-mount.sh --stop
@@ -449,6 +469,21 @@ sudo ./scripts/install.sh --uninstall --purge --system

 **Usage:** Set `DNSMASQ_CONF` to the path of the dnsmasq config file inside the container (e.g. `/data/dnsmasq-test.conf`). No CLI arguments.

+---
+
+### scripts/extract-option-help.sh
+
+**Purpose:** Fetch the dnsmasq man page HTML and extract per-option help fragments into `src/DnsmasqWebUI/wwwroot/option-help/*.html`. The Effective Config UI loads these when the user clicks an option label (tooltip is from code; full help is from these files). Requires Docker (uses a temporary `python:3-slim` container). When adding new options to the UI, add the option key to the script’s `OPTION_KEYS` list (keep in sync with `EffectiveConfigSections` / `DnsmasqOptionTooltips`), then run this script so help is available for the new option (if it exists in the man page).
+
+**Usage:** `./scripts/extract-option-help.sh [--url URL] [--output-dir DIR]`
+
+| Option | Description |
+|--------|-------------|
+| `--url URL` | Man page URL (default: https://thekelleys.org.uk/dnsmasq/docs/dnsmasq-man.html). |
+| `--output-dir DIR` | Output directory (default: `src/DnsmasqWebUI/wwwroot/option-help`). |
+
+Run from the repo root. Writes one `.html` file per option that appears in the man page OPTIONS section; options in `OPTION_KEYS` but not in the man page are skipped.
+
 <!-- SUGGESTED SCREENSHOT: TERMINAL WITH PREPARE-TEST-MOUNT.SH USAGE OR DOCKER COMPOSE UP OUTPUT -->

 ---
@@ -17,17 +17,20 @@ From the repo root:

 This will:

-1. Clear `testdata-mount/` (unless you pass `--no-clear`)
-2. Sync `testdata/` → `testdata-mount/`
-3. Remove any `*dnsmasq-webui*.conf` in the mount so dnsmasq starts clean
+1. Sync `testdata/` to `testdata-mount/` (preserving existing contents unless you pass `--clear`)
+2. Remove any `*dnsmasq-webui*.conf` in the mount so dnsmasq starts clean
+3. Resolve the requested dnsmasq version (`latest` by default) to a concrete value when needed
 4. Run `docker compose -f docker-compose.test.yml up -d --build`

 - **Quick restart (no image rebuild):** `./scripts/prepare-test-mount.sh --no-build`
+- **Force a fresh image build:** `./scripts/prepare-test-mount.sh --no-cache-build`
+- **Pin dnsmasq version:** `./scripts/prepare-test-mount.sh --dnsmasq-version 2.91 --build`
+- **Use distro package:** `./scripts/prepare-test-mount.sh --dnsmasq-version distro --build`
 - **Prepare mount only (no start):** `./scripts/prepare-test-mount.sh --prepare-only`  
-  Then start manually: `TESTDATA_MOUNT=./testdata-mount docker compose -f docker-compose.test.yml up -d [--build]`
- **Preserve mount (e.g. keep leases):** `./scripts/prepare-test-mount.sh --no-clear --no-build`
+  Then start manually with the version printed by the script: `TESTDATA_MOUNT=./testdata-mount DNSMASQ_VERSION=<resolved-version> docker compose -f docker-compose.test.yml up -d [--build]`
+- **Preserve mount (e.g. keep leases):** `./scripts/prepare-test-mount.sh --no-build` (default mount behavior)

-App is at **http://localhost:8080**. Main config path in the container is `/data/dnsmasq-test.conf`; managed file is `zz-dnsmasq-webui.conf` in the same directory.
+App is at **http://localhost:8080**. Main config path in the container is `/data/dnsmasq-test.conf`; managed file is `zz-dnsmasq-webui.conf` in the same directory. The app service has a healthcheck (`GET /healthz/ready`); DHCP client services use `depends_on: app: condition: service_healthy` so they start only after the app (and dnsmasq) is ready.

 ### Stop the harness

@@ -49,6 +52,8 @@ Stops the harness and deletes the contents of `testdata-mount/` so the next run

 - `--source DIR` — Source to sync from (default: `testdata`)
 - `--mount DIR` — Mount directory (default: `testdata-mount`). The script exports `TESTDATA_MOUNT=./DIR` when you use `--mount`, so compose uses it.
+- `--dnsmasq-version V` — Dnsmasq version for the harness image: `latest` (default), `distro`, or an exact upstream version like `2.91`.
+- `--no-cache-build` — Force a fresh image build with `docker compose build --pull --no-cache` before start.

 Example: sync from a custom dir and start:

@@ -76,5 +81,12 @@ Build only: `dotnet build`

 - **testdata/** — Source for the harness mount. Synced to `testdata-mount/` by `prepare-test-mount.sh`. Unit tests read from the copy in the test output dir. See **testdata/README** for the full layout.
 - **testdata/dnsmasq-test.conf** — Harness main config (`/data/dnsmasq-test.conf`). Richer config: multiple `server=`, `addn-hosts=`, `address=`, `listen-address=`, `conf-dir=/data/dnsmasq.d`.
- **testdata/dnsmasq.d/** — Included configs (01-other.conf, 02-servers.conf, dhcp.conf). App creates `zz-dnsmasq-webui.conf` here when running.
+- **testdata/dnsmasq.d/** — Included configs (01-other.conf, 02-servers.conf, 03-more.conf, dhcp.conf). App creates `zz-dnsmasq-webui.conf` here when running.
 - **testdata/hosts**, **testdata/hosts.extra** — Addn-hosts files so effective config has multiple addn-hosts; UI can show source per path.
+
+## When adding new effective-config options
+
+When adding a new dnsmasq option to the Effective Config UI (new key in `DnsmasqConfKeys`, section, kind map, parser/write behavior, tooltip, etc.):
+
+1. **Option help:** Add the option key (lowercase, e.g. `no-round-robin`) to the `OPTION_KEYS` list in `scripts/extract-option-help.sh` (keep in sync with `EffectiveConfigSections`). Then run `./scripts/extract-option-help.sh` so `wwwroot/option-help/<key>.html` is generated if the option exists in the dnsmasq man page.
+2. **Testdata (optional):** To show the option in the UI when using the harness or testdata, add a line to e.g. `testdata/dnsmasq.d/03-more.conf` and update `testdata/README` if needed.
@@ -1,7 +1,8 @@
 # Run the app with real dnsmasq and several DHCP clients so hosts/leases are real.
 # Some clients also make periodic DNS requests so the DNS cache and logs show activity.
-# Prepare mount: ./scripts/prepare-test-mount.sh [--prepare-only | --no-build | --recreate | --source DIR | --mount DIR]
+# Prepare mount: ./scripts/prepare-test-mount.sh [--minimal-conf | --prepare-only | ...]
 # Or set TESTDATA_MOUNT to override the data volume (default: ./testdata-mount).
+# Set TEST_DNSMASQ_CONF to override main config path (default: /data/dnsmasq-test.conf; use /data/dnsmasq-test-minimal.conf for minimal).
 #
 # No systemd in container (dnsmasq runs as a process from entrypoint, like most dnsmasq images).
 # StatusShowCommand/LogsCommand use ps so the Service status / Recent logs sections show something
@@ -13,14 +14,24 @@ services:
  app:
    build:
      context: .
+      args:
+        DNSMASQ_VERSION: ${DNSMASQ_VERSION:-latest}
    ports:
      - "8080:8080"
+    healthcheck:
+      test: ["CMD", "curl", "-f", "-s", "http://localhost:8080/healthz/ready"]
+      interval: 30s
+      timeout: 5s
+      start_period: 5s
+      retries: 3
    cap_add:
      - NET_ADMIN
    environment:
-      DNSMASQ_CONF: /data/dnsmasq-test.conf
-      Dnsmasq__MainConfigPath: /data/dnsmasq-test.conf
+      DNSMASQ_CONF: ${TEST_DNSMASQ_CONF:-/data/dnsmasq-test.conf}
+      Dnsmasq__MainConfigPath: ${TEST_DNSMASQ_CONF:-/data/dnsmasq-test.conf}
      Dnsmasq__ManagedFileName: zz-dnsmasq-webui.conf
+      # No systemd in container: restart by killing and re-running dnsmasq (same as entrypoint.sh). Config path must match DNSMASQ_CONF/MainConfigPath.
+      Dnsmasq__RestartCommand: "pkill -x dnsmasq || true; sleep 1; dnsmasq --test --conf-file=${TEST_DNSMASQ_CONF:-/data/dnsmasq-test.conf} && dnsmasq --conf-file=${TEST_DNSMASQ_CONF:-/data/dnsmasq-test.conf}"
      Dnsmasq__ReloadCommand: "pkill -HUP -x dnsmasq"
      Dnsmasq__StatusCommand: "pgrep -x dnsmasq"
      # Simulated systemctl status + real logs (dnsmasq logs to /data/dnsmasq.log via log-facility in dnsmasq-test.conf)
@@ -41,7 +52,8 @@ services:
    networks:
      testnet: {}
    depends_on:
-      - app
+      app:
+        condition: service_healthy

  # DHCP + periodic DNS lookups (every 20s) so DNS cache/logs show activity.
  dhcp-client-dns-a:
@@ -60,7 +72,8 @@ services:
    networks:
      testnet: {}
    depends_on:
-      - app
+      app:
+        condition: service_healthy

  # DHCP + periodic DNS lookups (every 45s); different interval for variety.
  dhcp-client-dns-b:
@@ -79,7 +92,8 @@ services:
    networks:
      testnet: {}
    depends_on:
-      - app
+      app:
+        condition: service_healthy

  # Third DHCP-only client so the leases table has more entries.
  dhcp-client-2:
@@ -88,7 +102,8 @@ services:
    networks:
      testnet: {}
    depends_on:
-      - app
+      app:
+        condition: service_healthy

 networks:
  testnet:
@@ -1,12 +1,22 @@
 #!/bin/sh
 # Simulates "systemctl status dnsmasq" output when run in a container without systemd.
 # Uses ps/pgrep. Memory is RSS. Uptime line omitted; Active line has break after semicolon with continuation indented.
+# When dnsmasq is not running, runs dnsmasq --test to show config/startup errors (use DNSMASQ_CONF for config path).

 pid=$(pgrep -x dnsmasq)
 if [ -z "$pid" ]; then
  echo "● dnsmasq.service - dnsmasq - A lightweight DHCP and caching DNS server"
  echo "     Loaded: (container, no systemd)"
  echo "     Active: inactive (dead)"
+  conf="${DNSMASQ_CONF:-/etc/dnsmasq.conf}"
+  if [ -f "$conf" ]; then
+    err=$(dnsmasq --test --conf-file="$conf" 2>&1)
+    if [ -n "$err" ]; then
+      echo ""
+      echo "     Config test (dnsmasq --test):"
+      echo "$err" | sed 's/^/       /'
+    fi
+  fi
  echo ""
  exit 0
 fi
@@ -50,7 +50,7 @@ except ImportError:
 OUT_DIR = "/out"
 URL = os.environ.get("URL", "https://thekelleys.org.uk/dnsmasq/docs/dnsmasq-man.html")

-# One per line; keep in sync with DnsmasqOptionTooltips / EffectiveConfigSections. server + local = one UI row.
+# One per line; keep in sync with DnsmasqOptionTooltips / EffectiveConfigSections.
 OPTION_KEYS = [
    "no-hosts",
    "addn-hosts",
@@ -122,6 +122,7 @@ OPTION_KEYS = [
    "dhcp-hostsfile",
    "dhcp-optsfile",
    "dhcp-hostsdir",
+    "dhcp-optsdir",
    "dhcp-boot",
    "dhcp-ignore",
    "dhcp-vendorclass",
@@ -171,6 +172,59 @@ OPTION_KEYS = [
    "keep-in-foreground",
    "no-daemon",
    "conntrack",
+    "connmark-allowlist-enable",
+    "no-round-robin",
+    "dns-forward-max",
+    "connmark-allowlist",
+    "do-0x20-encode",
+    "caa-record",
+    "dns-rr",
+    "synth-domain",
+    "auth-zone",
+    "auth-soa",
+    "auth-sec-servers",
+    "auth-peer",
+    "leasequery",
+    "dhcp-generate-names",
+    "dhcp-broadcast",
+    "dhcp-sequential-ip",
+    "dhcp-ignore-clid",
+    "bootp-dynamic",
+    "no-ping",
+    "script-arp",
+    "script-on-renewal",
+    "dhcp-no-override",
+    "dhcp-alternate-port",
+    "dhcp-duid",
+    "dhcp-luascript",
+    "dhcp-scriptuser",
+    "dhcp-relay",
+    "dhcp-circuitid",
+    "dhcp-remoteid",
+    "dhcp-subscrid",
+    "dhcp-proxy",
+    "tag-if",
+    "bridge-interface",
+    "shared-network",
+    "dhcp-pxe-vendor",
+    "dhcp-option-pxe",
+    "dnssec-no-timecheck",
+    "dnssec-debug",
+    "add-cpe-id",
+    "dnssec-timestamp",
+    "dnssec-limits",
+    "dumpfile",
+    "dumpmask",
+    "use-stale-cache",
+    "add-mac",
+    "strip-mac",
+    "add-subnet",
+    "strip-subnet",
+    "umbrella",
+    "quiet-dhcp",
+    "quiet-dhcp6",
+    "quiet-ra",
+    "quiet-tftp",
 ]

 long_opt_re = re.compile(r"--([a-z][a-z0-9-]*)(?:=[^,\s]*)?", re.IGNORECASE)
@@ -15,12 +15,15 @@ COMPOSE_FILE="docker-compose.test.yml"

 SOURCE_DIR=""
 MOUNT_DIR=""
+DNSMASQ_VERSION=""
 PREPARE_ONLY=false
 BUILD=false
+NO_CACHE_BUILD=false
 RECREATE=false
 CLEAR=false
 STOP=false
 TIDY=false
+MINIMAL_CONF=false

 usage() {
  echo "Usage: $0 [OPTIONS] [--]"
@@ -37,17 +40,25 @@ usage() {
  echo "  --source DIR        Source to copy from (default: testdata)"
  echo "  --mount DIR         Target mount directory (default: testdata-mount)"
  echo "                      Compose uses TESTDATA_MOUNT; script exports it if you use --mount."
+  echo "  --dnsmasq-version V Dnsmasq version for the harness image:"
+  echo "                      latest (default), distro, or an exact upstream version like 2.91."
+  echo "                      Non-default values require --build or --no-cache-build; script fails with --no-build."
  echo ""
  echo "Mount behaviour:"
  echo "  (default)           Preserve mount dir; sync source over existing contents."
  echo "  --clear             Clear mount dir completely before sync. Use for a clean run."
  echo ""
  echo "Compose behaviour:"
+  echo "  --minimal-conf     Use minimal dnsmasq config (dnsmasq-test-minimal.conf) so effective"
+  echo "                      config has few readonly options; good for testing reload/restart failure flows."
  echo "  --prepare-only      Only prepare the mount; do not run docker compose."
  echo "                      Use to inspect or edit the mount before starting containers."
  echo "  --build             Pass --build to docker compose (rebuild images before starting)."
  echo "                      Use after changing the app or Dockerfile. Default: use existing images."
+  echo "  --no-cache-build    Rebuild images with --pull --no-cache before starting."
+  echo "                      Use to force a fresh image build and refresh 'latest' dnsmasq."
  echo "  --no-build          Do not rebuild (default). Use existing images for a quick restart."
+  echo "                      With --no-build, 'latest' is not resolved (no network)."
  echo "  --recreate          Pass --force-recreate to docker compose (recreate containers)."
  echo "                      Use to ensure fresh container state and mounts."
  echo ""
@@ -69,6 +80,9 @@ usage() {
  echo "  $0 --recreate"
  echo "                      Sync, then up -d --force-recreate (fresh containers)."
  echo ""
+  echo "  $0 --no-cache-build"
+  echo "                      Force a fresh image build (no Docker build cache), then start containers."
+  echo ""
  echo "  $0 --clear"
  echo "                      Clear mount, sync testdata, start (clean run, no rebuild)."
  echo ""
@@ -85,6 +99,38 @@ usage() {
  echo ""
  echo "  $0 --tidy"
  echo "                      Stop harness and clear testdata-mount for a clean next run."
+  echo ""
+  echo "  $0 --minimal-conf"
+  echo "                      Use dnsmasq-test-minimal.conf (single file, few options) and start."
+  echo ""
+  echo "  $0 --dnsmasq-version 2.91 --build"
+  echo "                      Rebuild the harness image with dnsmasq 2.91."
+}
+
+fetch_url() {
+  if command -v curl >/dev/null 2>&1; then
+    curl -fsSL "$1"
+    return $?
+  fi
+  if command -v wget >/dev/null 2>&1; then
+    wget -qO- "$1"
+    return $?
+  fi
+  echo "Error: need curl or wget to resolve the latest upstream dnsmasq version." >&2
+  return 1
+}
+
+resolve_dnsmasq_version() {
+  if [ "$DNSMASQ_VERSION" != "latest" ]; then
+    return 0
+  fi
+
+  RESOLVED_VERSION="$(fetch_url "https://thekelleys.org.uk/dnsmasq/" | sed -n 's/.*LATEST_IS_\([0-9][0-9.]*\).*/\1/p' | head -n1)"
+  if [ -z "$RESOLVED_VERSION" ]; then
+    echo "Error: could not resolve the latest upstream dnsmasq version." >&2
+    exit 1
+  fi
+  DNSMASQ_VERSION="$RESOLVED_VERSION"
 }

 while [ $# -gt 0 ]; do
@@ -105,6 +151,12 @@ while [ $# -gt 0 ]; do
      MOUNT_DIR="$1"
      shift
      ;;
+    --dnsmasq-version)
+      shift
+      [ $# -gt 0 ] || { echo "Error: --dnsmasq-version requires VERSION" >&2; exit 1; }
+      DNSMASQ_VERSION="$1"
+      shift
+      ;;
    --clear)
      CLEAR=true
      shift
@@ -117,14 +169,24 @@ while [ $# -gt 0 ]; do
      BUILD=true
      shift
      ;;
+    --no-cache-build)
+      NO_CACHE_BUILD=true
+      BUILD=true
+      shift
+      ;;
    --no-build)
      BUILD=false
+      NO_CACHE_BUILD=false
      shift
      ;;
    --recreate)
      RECREATE=true
      shift
      ;;
+    --minimal-conf)
+      MINIMAL_CONF=true
+      shift
+      ;;
    --stop)
      STOP=true
      shift
@@ -160,6 +222,7 @@ cd "$REPO_ROOT"

 : "${SOURCE_DIR:=testdata}"
 : "${MOUNT_DIR:=testdata-mount}"
+: "${DNSMASQ_VERSION:=latest}"

 # Stop and/or tidy: no prepare, no start
 if [ "$STOP" = true ] || [ "$TIDY" = true ]; then
@@ -182,6 +245,17 @@ if [ ! -d "$SOURCE_DIR" ]; then
  exit 1
 fi

+# Resolve "latest" only when we will build; avoid network when doing a no-build run.
+WILL_BUILD=false
+[ "$BUILD" = true ] || [ "$NO_CACHE_BUILD" = true ] && WILL_BUILD=true
+if [ "$WILL_BUILD" = false ] && [ "$DNSMASQ_VERSION" != "latest" ] && [ "$DNSMASQ_VERSION" != "distro" ]; then
+  echo "Error: --dnsmasq-version $DNSMASQ_VERSION has no effect without --build or --no-cache-build. Add --build or omit --dnsmasq-version for a no-build run." >&2
+  exit 1
+fi
+if [ "$WILL_BUILD" = true ]; then
+  resolve_dnsmasq_version
+fi
+
 # Take the harness down so all containers (including one-shot DHCP clients) are recreated on up.
 echo "Stopping test harness: docker compose -f $COMPOSE_FILE down"
 docker compose -f "$COMPOSE_FILE" down
@@ -210,7 +284,16 @@ if [ "$PREPARE_ONLY" = true ]; then
    /*) MOUNT_EXPORT="$MOUNT_DIR" ;;
    *)  MOUNT_EXPORT="./$MOUNT_DIR" ;;
  esac
-  echo "To start the harness: TESTDATA_MOUNT=$MOUNT_EXPORT docker compose -f $COMPOSE_FILE up -d [--build]"
+  START_PREFIX="TESTDATA_MOUNT=$MOUNT_EXPORT DNSMASQ_VERSION=$DNSMASQ_VERSION"
+  if [ "$MINIMAL_CONF" = true ]; then
+    START_PREFIX="$START_PREFIX TEST_DNSMASQ_CONF=/data/dnsmasq-test-minimal.conf"
+  fi
+  if [ "$NO_CACHE_BUILD" = true ]; then
+    START_CMD="$START_PREFIX docker compose -f $COMPOSE_FILE build --pull --no-cache && $START_PREFIX docker compose -f $COMPOSE_FILE up -d"
+  else
+    START_CMD="$START_PREFIX docker compose -f $COMPOSE_FILE up -d [--build]"
+  fi
+  echo "To start the harness: $START_CMD"
  exit 0
 fi

@@ -220,8 +303,30 @@ case "$MOUNT_DIR" in
  *)  export TESTDATA_MOUNT="./$MOUNT_DIR" ;;
 esac

+export DNSMASQ_VERSION
+
+case "$DNSMASQ_VERSION" in
+  distro)
+    echo "Using distro-packaged dnsmasq for the harness image."
+    ;;
+  *)
+    echo "Using dnsmasq $DNSMASQ_VERSION for the harness image."
+    ;;
+esac
+
+if [ "$MINIMAL_CONF" = true ]; then
+  export TEST_DNSMASQ_CONF="/data/dnsmasq-test-minimal.conf"
+  echo "Using minimal config: $TEST_DNSMASQ_CONF"
+fi
+
+if [ "$NO_CACHE_BUILD" = true ]; then
+  BUILD_CMD="docker compose -f $COMPOSE_FILE build --pull --no-cache"
+  echo "Running: $BUILD_CMD"
+  $BUILD_CMD
+fi
+
 COMPOSE_CMD="docker compose -f $COMPOSE_FILE up -d"
-if [ "$BUILD" = true ]; then
+if [ "$BUILD" = true ] && [ "$NO_CACHE_BUILD" != true ]; then
  COMPOSE_CMD="$COMPOSE_CMD --build"
 fi
 if [ "$RECREATE" = true ]; then
@@ -0,0 +1,137 @@
+using DnsmasqWebUI.Infrastructure.Helpers.Config;
+using DnsmasqWebUI.Infrastructure.Services.Dnsmasq.Config;
+using DnsmasqWebUI.Models.Config;
+using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig;
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.Extensions.Options;
+
+namespace DnsmasqWebUI.Tests;
+
+/// <summary>
+/// Tests effective-config resolution in ConfigSetCache (BuildEffectiveConfig / BuildEffectiveConfigSources).
+/// Verifies no-0x20-encode precedence and source attribution per dnsmasq docs.
+/// </summary>
+public class ConfigSetCacheEffectiveConfigTests
+{
+    private static (string Dir, string MainPath, string ManagedPath, ConfigSetCache Cache) CreateCacheWithManaged(string managedContent)
+    {
+        var dir = Path.Combine(Path.GetTempPath(), "dnsmasq-cache-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(dir);
+        var mainPath = Path.Combine(dir, "dnsmasq.conf");
+        var managedName = "zz-managed.conf";
+        var managedPath = Path.Combine(dir, managedName);
+        File.WriteAllText(mainPath, "port=53\n");
+        File.WriteAllText(managedPath, managedContent);
+        var options = Options.Create(new DnsmasqOptions { MainConfigPath = mainPath, ManagedFileName = managedName });
+        var cache = new ConfigSetCache(options, NullLogger<ConfigSetCache>.Instance);
+        return (dir, mainPath, managedPath, cache);
+    }
+
+    [Fact]
+    public async Task Do0x20_BothPresent_No0x20Wins()
+    {
+        var (dir, _, managedPath, cache) = CreateCacheWithManaged("do-0x20-encode\nno-0x20-encode\n");
+        try
+        {
+            var snapshot = await cache.GetSnapshotAsync();
+            Assert.Equal(ExplicitToggleState.Disabled, snapshot.Config.Do0x20EncodeState);
+            Assert.NotNull(snapshot.Sources.Do0x20Encode);
+            Assert.Equal(Path.GetFullPath(managedPath), snapshot.Sources.Do0x20Encode.FilePath, StringComparer.OrdinalIgnoreCase);
+        }
+        finally
+        {
+            cache.Dispose();
+            if (Directory.Exists(dir)) Directory.Delete(dir, recursive: true);
+        }
+    }
+
+    [Fact]
+    public async Task Do0x20_OnlyDo_Enabled()
+    {
+        var (dir, _, _, cache) = CreateCacheWithManaged("do-0x20-encode\n");
+        try
+        {
+            var snapshot = await cache.GetSnapshotAsync();
+            Assert.Equal(ExplicitToggleState.Enabled, snapshot.Config.Do0x20EncodeState);
+        }
+        finally
+        {
+            cache.Dispose();
+            if (Directory.Exists(dir)) Directory.Delete(dir, recursive: true);
+        }
+    }
+
+    [Fact]
+    public async Task Do0x20_OnlyNo_Disabled()
+    {
+        var (dir, _, managedPath, cache) = CreateCacheWithManaged("no-0x20-encode\n");
+        try
+        {
+            var snapshot = await cache.GetSnapshotAsync();
+            Assert.Equal(ExplicitToggleState.Disabled, snapshot.Config.Do0x20EncodeState);
+            Assert.NotNull(snapshot.Sources.Do0x20Encode);
+            Assert.Equal(Path.GetFullPath(managedPath), snapshot.Sources.Do0x20Encode.FilePath, StringComparer.OrdinalIgnoreCase);
+        }
+        finally
+        {
+            cache.Dispose();
+            if (Directory.Exists(dir)) Directory.Delete(dir, recursive: true);
+        }
+    }
+
+    [Fact]
+    public async Task Do0x20_Neither_Default()
+    {
+        var (dir, _, _, cache) = CreateCacheWithManaged("port=53\n");
+        try
+        {
+            var snapshot = await cache.GetSnapshotAsync();
+            Assert.Equal(ExplicitToggleState.Default, snapshot.Config.Do0x20EncodeState);
+            Assert.Null(snapshot.Sources.Do0x20Encode);
+        }
+        finally
+        {
+            cache.Dispose();
+            if (Directory.Exists(dir)) Directory.Delete(dir, recursive: true);
+        }
+    }
+
+    [Fact]
+    public async Task Do0x20_SourceAttribution_WhenBothPresent_IsNo0x20Line()
+    {
+        var (dir, _, managedPath, cache) = CreateCacheWithManaged("no-0x20-encode\ndo-0x20-encode\n");
+        try
+        {
+            var snapshot = await cache.GetSnapshotAsync();
+            Assert.Equal(ExplicitToggleState.Disabled, snapshot.Config.Do0x20EncodeState);
+            Assert.NotNull(snapshot.Sources.Do0x20Encode);
+            Assert.Equal(Path.GetFullPath(managedPath), snapshot.Sources.Do0x20Encode.FilePath, StringComparer.OrdinalIgnoreCase);
+        }
+        finally
+        {
+            cache.Dispose();
+            if (Directory.Exists(dir)) Directory.Delete(dir, recursive: true);
+        }
+    }
+
+    [Fact]
+    public async Task StripFlags_ParseState_And_Source()
+    {
+        var (dir, _, managedPath, cache) = CreateCacheWithManaged("strip-mac\nstrip-subnet\n");
+        try
+        {
+            var snapshot = await cache.GetSnapshotAsync();
+            Assert.True(snapshot.Config.StripMac);
+            Assert.True(snapshot.Config.StripSubnet);
+            Assert.NotNull(snapshot.Sources.StripMac);
+            Assert.NotNull(snapshot.Sources.StripSubnet);
+            Assert.Equal(Path.GetFullPath(managedPath), snapshot.Sources.StripMac!.FilePath, StringComparer.OrdinalIgnoreCase);
+            Assert.Equal(Path.GetFullPath(managedPath), snapshot.Sources.StripSubnet!.FilePath, StringComparer.OrdinalIgnoreCase);
+        }
+        finally
+        {
+            cache.Dispose();
+            if (Directory.Exists(dir)) Directory.Delete(dir, recursive: true);
+        }
+    }
+}
@@ -0,0 +1,72 @@
+using DnsmasqWebUI.Infrastructure.Helpers.Dnsmasq;
+using DnsmasqWebUI.Models.Dnsmasq;
+
+namespace DnsmasqWebUI.Tests;
+
+/// <summary>
+/// Tests for parsing "Compile time options: ..." from dnsmasq --version output.
+/// </summary>
+public class DnsmasqCompileOptionsParserTests
+{
+    [Fact]
+    public void Parse_WhenNoCompileLine_ReturnsAllCapabilitiesFalse()
+    {
+        var result = DnsmasqCompileOptionsParser.Parse("Dnsmasq version 2.89\nCopyright ...", null);
+        Assert.False(result.Dhcp);
+        Assert.False(result.Tftp);
+        Assert.False(result.Dnssec);
+        Assert.False(result.Dbus);
+        Assert.NotNull(result.RawTokens);
+        Assert.Empty(result.RawTokens);
+    }
+
+    [Fact]
+    public void Parse_WhenCompileLineHasDnssec_SetsDnssecTrue()
+    {
+        var stdout = "Dnsmasq version 2.89\nCompile time options: IPv6 GNU-getopt no-DBus no-Idn DHCP DHCPv6 TFTP DNSSEC auth";
+        var result = DnsmasqCompileOptionsParser.Parse(stdout, null);
+        Assert.True(result.Dnssec);
+        Assert.True(result.Dhcp);
+        Assert.True(result.Tftp);
+        Assert.False(result.Dbus);
+        Assert.Contains("DNSSEC", result.RawTokens, StringComparer.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public void Parse_WhenCompileLineHasDhcpOnly_SetsDhcpTrueOthersFalse()
+    {
+        var result = DnsmasqCompileOptionsParser.Parse(null, "Compile time options: DHCP no-DBus no-DNSSEC");
+        Assert.True(result.Dhcp);
+        Assert.False(result.Tftp);
+        Assert.False(result.Dnssec);
+        Assert.False(result.Dbus);
+    }
+
+    [Fact]
+    public void Parse_WhenCompileLineHasDhcpv6_SetsDhcpTrue()
+    {
+        var result = DnsmasqCompileOptionsParser.Parse("Compile time options: DHCPv6", null);
+        Assert.True(result.Dhcp);
+    }
+
+    [Fact]
+    public void Parse_WhenCompileLineHasTftp_SetsTftpTrue()
+    {
+        var result = DnsmasqCompileOptionsParser.Parse("Compile time options: TFTP", null);
+        Assert.True(result.Tftp);
+    }
+
+    [Fact]
+    public void Parse_WhenCompileLineHasDbus_SetsDbusTrue()
+    {
+        var result = DnsmasqCompileOptionsParser.Parse("Compile time options: DBus", null);
+        Assert.True(result.Dbus);
+    }
+
+    [Fact]
+    public void Parse_CombinesStdoutAndStderr()
+    {
+        var result = DnsmasqCompileOptionsParser.Parse("Version line\n", "Compile time options: DNSSEC");
+        Assert.True(result.Dnssec);
+    }
+}
@@ -283,7 +283,7 @@ public class DnsmasqConfIncludeParserDhcpTftpDnssecTests
    }

    [Fact]
-    public void GetFlagFromConfigFiles_DnssecCheckUnsigned_WhenPresent_ReturnsTrue()
+    public void GetLastValueFromConfigFiles_DnssecCheckUnsigned_WhenPresent_ReturnsValue()
    {
        var dir = Path.Combine(Path.GetTempPath(), "dnsmasq-dnsseccu-" + Guid.NewGuid().ToString("N"));
        Directory.CreateDirectory(dir);
@@ -291,8 +291,26 @@ public class DnsmasqConfIncludeParserDhcpTftpDnssecTests
        try
        {
            File.WriteAllText(conf, "dnssec-check-unsigned\n");
-            var result = DnsmasqConfIncludeParser.GetFlagFromConfigFiles(new[] { conf }, DnsmasqConfKeys.DnssecCheckUnsigned);
-            Assert.True(result);
+            var (value, _) = DnsmasqConfIncludeParser.GetLastValueFromConfigFiles(new[] { conf }, DnsmasqConfKeys.DnssecCheckUnsigned);
+            Assert.NotNull(value);
+        }
+        finally
+        {
+            Directory.Delete(dir, recursive: true);
+        }
+    }
+
+    [Fact]
+    public void GetLastValueFromConfigFiles_DnssecCheckUnsigned_WhenEqualsNo_ReturnsNo()
+    {
+        var dir = Path.Combine(Path.GetTempPath(), "dnsmasq-dnsseccu-no-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(dir);
+        var conf = Path.Combine(dir, "dnsmasq.conf");
+        try
+        {
+            File.WriteAllText(conf, "dnssec-check-unsigned=no\n");
+            var (value, _) = DnsmasqConfIncludeParser.GetLastValueFromConfigFiles(new[] { conf }, DnsmasqConfKeys.DnssecCheckUnsigned);
+            Assert.Equal("no", value);
        }
        finally
        {
@@ -26,7 +26,7 @@ public class DnsmasqConfIncludeParserHostsAndLeaseTests
        var mainPath = TestDataHelper.GetPath("dnsmasq-test.conf");
        Assert.True(File.Exists(mainPath), "Testdata dnsmasq-test.conf required");
        var paths = new[] { mainPath };
-        var servers = DnsmasqConfIncludeParser.GetMultiValueFromConfigFiles(paths, DnsmasqConfKeys.ServerLocalKeys);
+        var servers = DnsmasqConfIncludeParser.GetMultiValueFromConfigFiles(paths, DnsmasqConfKeys.Server);
        var addnHosts = DnsmasqConfIncludeParser.GetAddnHostsPathsFromConfigFiles(paths);
        var addresses = DnsmasqConfIncludeParser.GetMultiValueFromConfigFiles(paths, DnsmasqConfKeys.Address);
        var listenAddrs = DnsmasqConfIncludeParser.GetMultiValueFromConfigFiles(paths, DnsmasqConfKeys.ListenAddress);
@@ -79,6 +79,137 @@ public class DnsmasqConfIncludeParserNewOptionsTests
        WriteFlagAndAssertTrue(DnsmasqConfKeys.ProxyDnssec);
    }

+    [Fact]
+    public void GetLastValueFromConfigFiles_ConnmarkAllowlistEnable_WhenPresent_ReturnsValue()
+    {
+        WriteLastWinsKeyOnlyAndAssertPresent(DnsmasqConfKeys.ConnmarkAllowlistEnable);
+    }
+
+    [Fact]
+    public void GetFlagFromConfigFiles_NoRoundRobin_WhenPresent_ReturnsTrue()
+    {
+        WriteFlagAndAssertTrue(DnsmasqConfKeys.NoRoundRobin);
+    }
+
+    [Fact]
+    public void GetFlagFromConfigFiles_DnssecNoTimecheck_WhenPresent_ReturnsTrue()
+    {
+        WriteFlagAndAssertTrue(DnsmasqConfKeys.DnssecNoTimecheck);
+    }
+
+    [Fact]
+    public void GetFlagFromConfigFiles_DnssecDebug_WhenPresent_ReturnsTrue()
+    {
+        WriteFlagAndAssertTrue(DnsmasqConfKeys.DnssecDebug);
+    }
+
+    [Fact]
+    public void GetMultiValueFromConfigFiles_Leasequery_WhenPresent_ReturnsValues()
+    {
+        var dir = CreateTempDir();
+        var conf = Path.Combine(dir, "dnsmasq.conf");
+        try
+        {
+            File.WriteAllText(conf, "leasequery\n");
+            var result = DnsmasqConfIncludeParser.GetMultiValueFromConfigFiles(new[] { conf }, DnsmasqConfKeys.Leasequery);
+            Assert.Single(result);
+            Assert.Equal("", result[0]);
+        }
+        finally { Directory.Delete(dir, recursive: true); }
+    }
+
+    [Fact]
+    public void GetMultiValueFromConfigFiles_Leasequery_WithValue_IsParsed()
+    {
+        var dir = CreateTempDir();
+        var conf = Path.Combine(dir, "dnsmasq.conf");
+        try
+        {
+            File.WriteAllText(conf, "leasequery=10.0.0.0/24\n");
+            var result = DnsmasqConfIncludeParser.GetMultiValueFromConfigFiles(new[] { conf }, DnsmasqConfKeys.Leasequery);
+            Assert.Equal("10.0.0.0/24", Assert.Single(result));
+        }
+        finally { Directory.Delete(dir, recursive: true); }
+    }
+
+    [Fact]
+    public void GetFlagFromConfigFiles_QuietDhcp_WhenPresent_ReturnsTrue()
+    {
+        WriteFlagAndAssertTrue(DnsmasqConfKeys.QuietDhcp);
+    }
+
+    [Fact]
+    public void GetFlagFromConfigFiles_QuietTftp_WhenPresent_ReturnsTrue()
+    {
+        WriteFlagAndAssertTrue(DnsmasqConfKeys.QuietTftp);
+    }
+
+    [Fact]
+    public void GetLastValueFromConfigFiles_DhcpGenerateNames_WhenPresent_ReturnsValue()
+    {
+        WriteLastWinsKeyOnlyAndAssertPresent(DnsmasqConfKeys.DhcpGenerateNames);
+    }
+
+    [Fact]
+    public void GetLastValueFromConfigFiles_DhcpBroadcast_WhenPresent_ReturnsValue()
+    {
+        WriteLastWinsKeyOnlyAndAssertPresent(DnsmasqConfKeys.DhcpBroadcast);
+    }
+
+    [Fact]
+    public void GetFlagFromConfigFiles_DhcpSequentialIp_WhenPresent_ReturnsTrue()
+    {
+        WriteFlagAndAssertTrue(DnsmasqConfKeys.DhcpSequentialIp);
+    }
+
+    [Fact]
+    public void GetFlagFromConfigFiles_DhcpIgnoreClid_WhenPresent_ReturnsTrue()
+    {
+        WriteFlagAndAssertTrue(DnsmasqConfKeys.DhcpIgnoreClid);
+    }
+
+    [Fact]
+    public void GetLastValueFromConfigFiles_BootpDynamic_WhenPresent_ReturnsValue()
+    {
+        WriteLastWinsKeyOnlyAndAssertPresent(DnsmasqConfKeys.BootpDynamic);
+    }
+
+    [Fact]
+    public void GetFlagFromConfigFiles_NoPing_WhenPresent_ReturnsTrue()
+    {
+        WriteFlagAndAssertTrue(DnsmasqConfKeys.NoPing);
+    }
+
+    [Fact]
+    public void GetFlagFromConfigFiles_ScriptArp_WhenPresent_ReturnsTrue()
+    {
+        WriteFlagAndAssertTrue(DnsmasqConfKeys.ScriptArp);
+    }
+
+    [Fact]
+    public void GetFlagFromConfigFiles_ScriptOnRenewal_WhenPresent_ReturnsTrue()
+    {
+        WriteFlagAndAssertTrue(DnsmasqConfKeys.ScriptOnRenewal);
+    }
+
+    [Fact]
+    public void GetFlagFromConfigFiles_DhcpNoOverride_WhenPresent_ReturnsTrue()
+    {
+        WriteFlagAndAssertTrue(DnsmasqConfKeys.DhcpNoOverride);
+    }
+
+    [Fact]
+    public void GetFlagFromConfigFiles_QuietDhcp6_WhenPresent_ReturnsTrue()
+    {
+        WriteFlagAndAssertTrue(DnsmasqConfKeys.QuietDhcp6);
+    }
+
+    [Fact]
+    public void GetFlagFromConfigFiles_QuietRa_WhenPresent_ReturnsTrue()
+    {
+        WriteFlagAndAssertTrue(DnsmasqConfKeys.QuietRa);
+    }
+
    // --- Multi-value (6): key=value line(s) → GetMultiValue returns value(s) ---

    [Fact]
@@ -258,16 +389,27 @@ public class DnsmasqConfIncludeParserNewOptionsTests
    }

    [Fact]
-    public void GetLastValueFromConfigFiles_Conntrack_WhenSet_ReturnsValue()
+    public void GetFlagFromConfigFiles_Conntrack_WhenPresent_ReturnsTrue()
    {
        var dir = CreateTempDir();
        var conf = Path.Combine(dir, "dnsmasq.conf");
-        var value = "42";
        try
        {
-            File.WriteAllText(conf, $"conntrack={value}\n");
-            var (result, _) = DnsmasqConfIncludeParser.GetLastValueFromConfigFiles(new[] { conf }, DnsmasqConfKeys.Conntrack);
-            Assert.Equal(value, result);
+            File.WriteAllText(conf, "conntrack\n");
+            Assert.True(DnsmasqConfIncludeParser.GetFlagFromConfigFiles(new[] { conf }, DnsmasqConfKeys.Conntrack));
+        }
+        finally { Directory.Delete(dir, recursive: true); }
+    }
+
+    [Fact]
+    public void GetFlagFromConfigFiles_Conntrack_WhenAbsent_ReturnsFalse()
+    {
+        var dir = CreateTempDir();
+        var conf = Path.Combine(dir, "dnsmasq.conf");
+        try
+        {
+            File.WriteAllText(conf, "port=53\n");
+            Assert.False(DnsmasqConfIncludeParser.GetFlagFromConfigFiles(new[] { conf }, DnsmasqConfKeys.Conntrack));
        }
        finally { Directory.Delete(dir, recursive: true); }
    }
@@ -284,6 +426,19 @@ public class DnsmasqConfIncludeParserNewOptionsTests
        finally { Directory.Delete(dir, recursive: true); }
    }

+    private static void WriteLastWinsKeyOnlyAndAssertPresent(string key)
+    {
+        var dir = CreateTempDir();
+        var conf = Path.Combine(dir, "dnsmasq.conf");
+        try
+        {
+            File.WriteAllText(conf, key + "\n");
+            var (value, _) = DnsmasqConfIncludeParser.GetLastValueFromConfigFiles(new[] { conf }, key);
+            Assert.NotNull(value);
+        }
+        finally { Directory.Delete(dir, recursive: true); }
+    }
+
    private static string CreateTempDir()
    {
        var dir = Path.Combine(Path.GetTempPath(), "dnsmasq-newopts-" + Guid.NewGuid().ToString("N"));
@@ -45,7 +45,8 @@ public class DnsmasqConfIncludeParserOfficialExampleTests
    {
        var mainPath = GetOfficialExamplePath();
        var paths = new[] { mainPath };
-        var servers = DnsmasqConfIncludeParser.GetMultiValueFromConfigFiles(paths, DnsmasqConfKeys.ServerLocalKeys);
+        var servers = DnsmasqConfIncludeParser.GetMultiValueFromConfigFiles(paths, DnsmasqConfKeys.Server);
+        var locals = DnsmasqConfIncludeParser.GetMultiValueFromConfigFiles(paths, DnsmasqConfKeys.Local);
        var dhcpOptionForce = DnsmasqConfIncludeParser.GetMultiValueFromConfigFiles(paths, DnsmasqConfKeys.DhcpOptionForce);
        var ipset = DnsmasqConfIncludeParser.GetMultiValueFromConfigFiles(paths, DnsmasqConfKeys.Ipset);
        var nftset = DnsmasqConfIncludeParser.GetMultiValueFromConfigFiles(paths, DnsmasqConfKeys.Nftset);
@@ -53,6 +54,7 @@ public class DnsmasqConfIncludeParserOfficialExampleTests
        var dhcpNameMatch = DnsmasqConfIncludeParser.GetMultiValueFromConfigFiles(paths, DnsmasqConfKeys.DhcpNameMatch);
        var dhcpIgnoreNames = DnsmasqConfIncludeParser.GetMultiValueFromConfigFiles(paths, DnsmasqConfKeys.DhcpIgnoreNames);
        Assert.Empty(servers);
+        Assert.Empty(locals);
        Assert.Empty(dhcpOptionForce);
        Assert.Empty(ipset);
        Assert.Empty(nftset);
@@ -23,11 +23,13 @@ public class DnsmasqConfIncludeParserServerAndResolvTests
        {
            File.WriteAllText(f1, $"server={v1}\nlocal={v2}\n");
            File.WriteAllText(f2, $"server={v3}\n");
-            var result = DnsmasqConfIncludeParser.GetMultiValueFromConfigFiles(new[] { f1, f2 }, DnsmasqConfKeys.ServerLocalKeys);
-            Assert.Equal(3, result.Count);
-            Assert.Equal(v1, result[0]);
-            Assert.Equal(v2, result[1]);
-            Assert.Equal(v3, result[2]);
+            var resultServer = DnsmasqConfIncludeParser.GetMultiValueFromConfigFiles(new[] { f1, f2 }, DnsmasqConfKeys.Server);
+            var resultLocal = DnsmasqConfIncludeParser.GetMultiValueFromConfigFiles(new[] { f1, f2 }, DnsmasqConfKeys.Local);
+            Assert.Equal(2, resultServer.Count);
+            Assert.Equal(v1, resultServer[0]);
+            Assert.Equal(v3, resultServer[1]);
+            Assert.Single(resultLocal);
+            Assert.Equal(v2, resultLocal[0]);
        }
        finally
        {
@@ -0,0 +1,564 @@
+using DnsmasqWebUI.Infrastructure.Helpers.Config;
+using DnsmasqWebUI.Infrastructure.Services.Dnsmasq.Config;
+using DnsmasqWebUI.Models.Config;
+using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig;
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.Extensions.Options;
+
+namespace DnsmasqWebUI.Tests;
+
+/// <summary>
+/// Save-path tests for DnsmasqConfigService.ApplyEffectiveConfigChangesAsync.
+/// Verifies that pending changes produce the correct managed config lines.
+/// </summary>
+public class DnsmasqConfigServiceApplyChangesTests
+{
+    [Fact]
+    public async Task ApplyEffectiveConfigChangesAsync_ConntrackTrue_WritesBareFlagLine()
+    {
+        var dir = Path.Combine(Path.GetTempPath(), "dnsmasq-apply-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(dir);
+        var mainPath = Path.Combine(dir, "dnsmasq.conf");
+        var managedName = "zz-managed.conf";
+        var managedPath = Path.Combine(dir, managedName);
+        ConfigSetCache? cache = null;
+        try
+        {
+            File.WriteAllText(mainPath, "port=53\n");
+            var options = Options.Create(new DnsmasqOptions { MainConfigPath = mainPath, ManagedFileName = managedName });
+            cache = new ConfigSetCache(options, NullLogger<ConfigSetCache>.Instance);
+            var setService = new DnsmasqConfigSetService(cache);
+            var configService = new DnsmasqConfigService(setService, cache, NullLogger<DnsmasqConfigService>.Instance);
+
+            var changes = new List<PendingEffectiveConfigChange>
+            {
+                new(EffectiveConfigSections.SectionResolver, DnsmasqConfKeys.Conntrack, false, true, null)
+            };
+            await configService.ApplyEffectiveConfigChangesAsync(changes);
+
+            Assert.True(File.Exists(managedPath));
+            var content = await File.ReadAllTextAsync(managedPath);
+            var lines = content.TrimEnd().Split('\n').Select(l => l.Trim()).Where(l => l.Length > 0).ToList();
+            Assert.Contains(lines, l => l == "conntrack");
+        }
+        finally
+        {
+            cache?.Dispose();
+            if (Directory.Exists(dir))
+                Directory.Delete(dir, recursive: true);
+        }
+    }
+
+    [Fact]
+    public async Task ApplyEffectiveConfigChangesAsync_ConntrackFalse_RemovesFlagLine()
+    {
+        var dir = Path.Combine(Path.GetTempPath(), "dnsmasq-apply-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(dir);
+        var mainPath = Path.Combine(dir, "dnsmasq.conf");
+        var managedName = "zz-managed.conf";
+        var managedPath = Path.Combine(dir, managedName);
+        ConfigSetCache? cache = null;
+        try
+        {
+            File.WriteAllText(mainPath, "port=53\n");
+            File.WriteAllText(managedPath, "conntrack\n");
+            var options = Options.Create(new DnsmasqOptions { MainConfigPath = mainPath, ManagedFileName = managedName });
+            cache = new ConfigSetCache(options, NullLogger<ConfigSetCache>.Instance);
+            cache.Invalidate();
+            var setService = new DnsmasqConfigSetService(cache);
+            var configService = new DnsmasqConfigService(setService, cache, NullLogger<DnsmasqConfigService>.Instance);
+
+            var changes = new List<PendingEffectiveConfigChange>
+            {
+                new(EffectiveConfigSections.SectionResolver, DnsmasqConfKeys.Conntrack, true, false, null)
+            };
+            await configService.ApplyEffectiveConfigChangesAsync(changes);
+
+            var content = await File.ReadAllTextAsync(managedPath);
+            var lines = content.TrimEnd().Split('\n').Select(l => l.Trim()).Where(l => l.Length > 0).ToList();
+            Assert.DoesNotContain(lines, l => l == "conntrack" || l.StartsWith("conntrack=", StringComparison.Ordinal));
+        }
+        finally
+        {
+            cache?.Dispose();
+            if (Directory.Exists(dir))
+                Directory.Delete(dir, recursive: true);
+        }
+    }
+
+    [Fact]
+    public async Task ApplyEffectiveConfigChangesAsync_StripMacTrue_WritesBareFlagLine()
+    {
+        var dir = Path.Combine(Path.GetTempPath(), "dnsmasq-apply-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(dir);
+        var mainPath = Path.Combine(dir, "dnsmasq.conf");
+        var managedName = "zz-managed.conf";
+        var managedPath = Path.Combine(dir, managedName);
+        ConfigSetCache? cache = null;
+        try
+        {
+            File.WriteAllText(mainPath, "port=53\n");
+            var options = Options.Create(new DnsmasqOptions { MainConfigPath = mainPath, ManagedFileName = managedName });
+            cache = new ConfigSetCache(options, NullLogger<ConfigSetCache>.Instance);
+            var setService = new DnsmasqConfigSetService(cache);
+            var configService = new DnsmasqConfigService(setService, cache, NullLogger<DnsmasqConfigService>.Instance);
+
+            var changes = new List<PendingEffectiveConfigChange>
+            {
+                new(EffectiveConfigSections.SectionCache, DnsmasqConfKeys.StripMac, false, true, null)
+            };
+            await configService.ApplyEffectiveConfigChangesAsync(changes);
+
+            Assert.True(File.Exists(managedPath));
+            var content = await File.ReadAllTextAsync(managedPath);
+            var lines = content.TrimEnd().Split('\n').Select(l => l.Trim()).Where(l => l.Length > 0).ToList();
+            Assert.Contains(lines, l => l == DnsmasqConfKeys.StripMac);
+        }
+        finally
+        {
+            cache?.Dispose();
+            if (Directory.Exists(dir))
+                Directory.Delete(dir, recursive: true);
+        }
+    }
+
+    [Fact]
+    public async Task ApplyEffectiveConfigChangesAsync_StripSubnetFalse_RemovesFlagLine()
+    {
+        var dir = Path.Combine(Path.GetTempPath(), "dnsmasq-apply-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(dir);
+        var mainPath = Path.Combine(dir, "dnsmasq.conf");
+        var managedName = "zz-managed.conf";
+        var managedPath = Path.Combine(dir, managedName);
+        ConfigSetCache? cache = null;
+        try
+        {
+            File.WriteAllText(mainPath, "port=53\n");
+            File.WriteAllText(managedPath, "strip-subnet\n");
+            var options = Options.Create(new DnsmasqOptions { MainConfigPath = mainPath, ManagedFileName = managedName });
+            cache = new ConfigSetCache(options, NullLogger<ConfigSetCache>.Instance);
+            cache.Invalidate();
+            var setService = new DnsmasqConfigSetService(cache);
+            var configService = new DnsmasqConfigService(setService, cache, NullLogger<DnsmasqConfigService>.Instance);
+
+            var changes = new List<PendingEffectiveConfigChange>
+            {
+                new(EffectiveConfigSections.SectionCache, DnsmasqConfKeys.StripSubnet, true, false, null)
+            };
+            await configService.ApplyEffectiveConfigChangesAsync(changes);
+
+            var content = await File.ReadAllTextAsync(managedPath);
+            var lines = content.TrimEnd().Split('\n').Select(l => l.Trim()).Where(l => l.Length > 0).ToList();
+            Assert.DoesNotContain(lines, l => l == DnsmasqConfKeys.StripSubnet || l.StartsWith($"{DnsmasqConfKeys.StripSubnet}=", StringComparison.Ordinal));
+        }
+        finally
+        {
+            cache?.Dispose();
+            if (Directory.Exists(dir))
+                Directory.Delete(dir, recursive: true);
+        }
+    }
+
+    [Fact]
+    public async Task ApplyEffectiveConfigChangesAsync_DnssecCheckUnsignedNo_WritesEqualsNo()
+    {
+        var dir = Path.Combine(Path.GetTempPath(), "dnsmasq-apply-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(dir);
+        var mainPath = Path.Combine(dir, "dnsmasq.conf");
+        var managedName = "zz-managed.conf";
+        var managedPath = Path.Combine(dir, managedName);
+        ConfigSetCache? cache = null;
+        try
+        {
+            File.WriteAllText(mainPath, "port=53\n");
+            var options = Options.Create(new DnsmasqOptions { MainConfigPath = mainPath, ManagedFileName = managedName });
+            cache = new ConfigSetCache(options, NullLogger<ConfigSetCache>.Instance);
+            var setService = new DnsmasqConfigSetService(cache);
+            var configService = new DnsmasqConfigService(setService, cache, NullLogger<DnsmasqConfigService>.Instance);
+
+            var changes = new List<PendingEffectiveConfigChange>
+            {
+                new(EffectiveConfigSections.SectionDnssec, DnsmasqConfKeys.DnssecCheckUnsigned, null, "no", null)
+            };
+            await configService.ApplyEffectiveConfigChangesAsync(changes);
+
+            Assert.True(File.Exists(managedPath));
+            var text = await File.ReadAllTextAsync(managedPath);
+            Assert.Contains("dnssec-check-unsigned=no", text);
+        }
+        finally
+        {
+            cache?.Dispose();
+            if (Directory.Exists(dir))
+                Directory.Delete(dir, recursive: true);
+        }
+    }
+
+    [Fact]
+    public async Task ApplyEffectiveConfigChangesAsync_KeyOnlyOrValue_KeyOnly_WritesBareKey()
+    {
+        var dir = Path.Combine(Path.GetTempPath(), "dnsmasq-apply-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(dir);
+        var mainPath = Path.Combine(dir, "dnsmasq.conf");
+        var managedName = "zz-managed.conf";
+        var managedPath = Path.Combine(dir, managedName);
+        ConfigSetCache? cache = null;
+        try
+        {
+            File.WriteAllText(mainPath, "port=53\n");
+            var options = Options.Create(new DnsmasqOptions { MainConfigPath = mainPath, ManagedFileName = managedName });
+            cache = new ConfigSetCache(options, NullLogger<ConfigSetCache>.Instance);
+            var setService = new DnsmasqConfigSetService(cache);
+            var configService = new DnsmasqConfigService(setService, cache, NullLogger<DnsmasqConfigService>.Instance);
+
+            var changes = new List<PendingEffectiveConfigChange>
+            {
+                new(EffectiveConfigSections.SectionCache, DnsmasqConfKeys.UseStaleCache, null, "", null)
+            };
+            await configService.ApplyEffectiveConfigChangesAsync(changes);
+
+            Assert.True(File.Exists(managedPath));
+            var content = await File.ReadAllTextAsync(managedPath);
+            Assert.Contains("use-stale-cache", content);
+            Assert.DoesNotContain("use-stale-cache=", content);
+        }
+        finally
+        {
+            cache?.Dispose();
+            if (Directory.Exists(dir))
+                Directory.Delete(dir, recursive: true);
+        }
+    }
+
+    [Fact]
+    public async Task ApplyEffectiveConfigChangesAsync_InversePair_Enabled_WritesDo0x20Encode()
+    {
+        var dir = Path.Combine(Path.GetTempPath(), "dnsmasq-apply-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(dir);
+        var mainPath = Path.Combine(dir, "dnsmasq.conf");
+        var managedName = "zz-managed.conf";
+        var managedPath = Path.Combine(dir, managedName);
+        ConfigSetCache? cache = null;
+        try
+        {
+            File.WriteAllText(mainPath, "port=53\n");
+            var options = Options.Create(new DnsmasqOptions { MainConfigPath = mainPath, ManagedFileName = managedName });
+            cache = new ConfigSetCache(options, NullLogger<ConfigSetCache>.Instance);
+            var setService = new DnsmasqConfigSetService(cache);
+            var configService = new DnsmasqConfigService(setService, cache, NullLogger<DnsmasqConfigService>.Instance);
+
+            var changes = new List<PendingEffectiveConfigChange>
+            {
+                new(EffectiveConfigSections.SectionResolver, DnsmasqConfKeys.Do0x20Encode, ExplicitToggleState.Default, ExplicitToggleState.Enabled, null)
+            };
+            await configService.ApplyEffectiveConfigChangesAsync(changes);
+
+            Assert.True(File.Exists(managedPath));
+            var content = await File.ReadAllTextAsync(managedPath);
+            Assert.Contains("do-0x20-encode", content);
+            Assert.DoesNotContain("no-0x20-encode", content);
+        }
+        finally
+        {
+            cache?.Dispose();
+            if (Directory.Exists(dir))
+                Directory.Delete(dir, recursive: true);
+        }
+    }
+
+    [Fact]
+    public async Task ApplyChanges_Do0x20_Default_RemovesBothLines()
+    {
+        var dir = Path.Combine(Path.GetTempPath(), "dnsmasq-apply-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(dir);
+        var mainPath = Path.Combine(dir, "dnsmasq.conf");
+        var managedName = "zz-managed.conf";
+        var managedPath = Path.Combine(dir, managedName);
+        ConfigSetCache? cache = null;
+        try
+        {
+            File.WriteAllText(mainPath, "port=53\n");
+            File.WriteAllText(managedPath, "do-0x20-encode\nno-0x20-encode\n");
+            var options = Options.Create(new DnsmasqOptions { MainConfigPath = mainPath, ManagedFileName = managedName });
+            cache = new ConfigSetCache(options, NullLogger<ConfigSetCache>.Instance);
+            cache.Invalidate();
+            var setService = new DnsmasqConfigSetService(cache);
+            var configService = new DnsmasqConfigService(setService, cache, NullLogger<DnsmasqConfigService>.Instance);
+
+            var changes = new List<PendingEffectiveConfigChange>
+            {
+                new(EffectiveConfigSections.SectionResolver, DnsmasqConfKeys.Do0x20Encode, ExplicitToggleState.Disabled, ExplicitToggleState.Default, null)
+            };
+            await configService.ApplyEffectiveConfigChangesAsync(changes);
+
+            var content = await File.ReadAllTextAsync(managedPath);
+            var lines = content.TrimEnd().Split('\n').Select(l => l.Trim()).Where(l => l.Length > 0).ToList();
+            Assert.DoesNotContain(lines, l => l == "do-0x20-encode" || l == "no-0x20-encode");
+        }
+        finally
+        {
+            cache?.Dispose();
+            if (Directory.Exists(dir))
+                Directory.Delete(dir, recursive: true);
+        }
+    }
+
+    [Fact]
+    public async Task ApplyChanges_Do0x20_Disabled_WritesNo0x20Encode()
+    {
+        var dir = Path.Combine(Path.GetTempPath(), "dnsmasq-apply-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(dir);
+        var mainPath = Path.Combine(dir, "dnsmasq.conf");
+        var managedName = "zz-managed.conf";
+        var managedPath = Path.Combine(dir, managedName);
+        ConfigSetCache? cache = null;
+        try
+        {
+            File.WriteAllText(mainPath, "port=53\n");
+            var options = Options.Create(new DnsmasqOptions { MainConfigPath = mainPath, ManagedFileName = managedName });
+            cache = new ConfigSetCache(options, NullLogger<ConfigSetCache>.Instance);
+            var setService = new DnsmasqConfigSetService(cache);
+            var configService = new DnsmasqConfigService(setService, cache, NullLogger<DnsmasqConfigService>.Instance);
+
+            var changes = new List<PendingEffectiveConfigChange>
+            {
+                new(EffectiveConfigSections.SectionResolver, DnsmasqConfKeys.Do0x20Encode, ExplicitToggleState.Default, ExplicitToggleState.Disabled, null)
+            };
+            await configService.ApplyEffectiveConfigChangesAsync(changes);
+
+            var content = await File.ReadAllTextAsync(managedPath);
+            Assert.Contains("no-0x20-encode", content);
+            Assert.DoesNotContain("do-0x20-encode", content);
+        }
+        finally
+        {
+            cache?.Dispose();
+            if (Directory.Exists(dir))
+                Directory.Delete(dir, recursive: true);
+        }
+    }
+
+    [Fact]
+    public async Task ApplyChanges_UseStaleCache_Value_WritesKeyEqualsValue()
+    {
+        var dir = Path.Combine(Path.GetTempPath(), "dnsmasq-apply-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(dir);
+        var mainPath = Path.Combine(dir, "dnsmasq.conf");
+        var managedName = "zz-managed.conf";
+        var managedPath = Path.Combine(dir, managedName);
+        ConfigSetCache? cache = null;
+        try
+        {
+            File.WriteAllText(mainPath, "port=53\n");
+            var options = Options.Create(new DnsmasqOptions { MainConfigPath = mainPath, ManagedFileName = managedName });
+            cache = new ConfigSetCache(options, NullLogger<ConfigSetCache>.Instance);
+            var setService = new DnsmasqConfigSetService(cache);
+            var configService = new DnsmasqConfigService(setService, cache, NullLogger<DnsmasqConfigService>.Instance);
+
+            var changes = new List<PendingEffectiveConfigChange>
+            {
+                new(EffectiveConfigSections.SectionCache, DnsmasqConfKeys.UseStaleCache, null, "60", null)
+            };
+            await configService.ApplyEffectiveConfigChangesAsync(changes);
+
+            var content = await File.ReadAllTextAsync(managedPath);
+            Assert.Contains("use-stale-cache=60", content);
+        }
+        finally
+        {
+            cache?.Dispose();
+            if (Directory.Exists(dir))
+                Directory.Delete(dir, recursive: true);
+        }
+    }
+
+    [Fact]
+    public async Task ApplyChanges_AddMac_KeyOnly_WritesBareKey()
+    {
+        var dir = Path.Combine(Path.GetTempPath(), "dnsmasq-apply-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(dir);
+        var mainPath = Path.Combine(dir, "dnsmasq.conf");
+        var managedName = "zz-managed.conf";
+        var managedPath = Path.Combine(dir, managedName);
+        ConfigSetCache? cache = null;
+        try
+        {
+            File.WriteAllText(mainPath, "port=53\n");
+            var options = Options.Create(new DnsmasqOptions { MainConfigPath = mainPath, ManagedFileName = managedName });
+            cache = new ConfigSetCache(options, NullLogger<ConfigSetCache>.Instance);
+            var setService = new DnsmasqConfigSetService(cache);
+            var configService = new DnsmasqConfigService(setService, cache, NullLogger<DnsmasqConfigService>.Instance);
+
+            var changes = new List<PendingEffectiveConfigChange>
+            {
+                new(EffectiveConfigSections.SectionCache, DnsmasqConfKeys.AddMac, null, "", null)
+            };
+            await configService.ApplyEffectiveConfigChangesAsync(changes);
+
+            var content = await File.ReadAllTextAsync(managedPath);
+            Assert.Contains("add-mac", content);
+            Assert.DoesNotContain("add-mac=", content);
+        }
+        finally
+        {
+            cache?.Dispose();
+            if (Directory.Exists(dir))
+                Directory.Delete(dir, recursive: true);
+        }
+    }
+
+    [Fact]
+    public async Task ApplyChanges_AddMac_ValueBase64_WritesKeyEqualsValue()
+    {
+        var dir = Path.Combine(Path.GetTempPath(), "dnsmasq-apply-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(dir);
+        var mainPath = Path.Combine(dir, "dnsmasq.conf");
+        var managedName = "zz-managed.conf";
+        var managedPath = Path.Combine(dir, managedName);
+        ConfigSetCache? cache = null;
+        try
+        {
+            File.WriteAllText(mainPath, "port=53\n");
+            var options = Options.Create(new DnsmasqOptions { MainConfigPath = mainPath, ManagedFileName = managedName });
+            cache = new ConfigSetCache(options, NullLogger<ConfigSetCache>.Instance);
+            var setService = new DnsmasqConfigSetService(cache);
+            var configService = new DnsmasqConfigService(setService, cache, NullLogger<DnsmasqConfigService>.Instance);
+
+            var changes = new List<PendingEffectiveConfigChange>
+            {
+                new(EffectiveConfigSections.SectionCache, DnsmasqConfKeys.AddMac, null, "base64", null)
+            };
+            await configService.ApplyEffectiveConfigChangesAsync(changes);
+
+            var content = await File.ReadAllTextAsync(managedPath);
+            Assert.Contains("add-mac=base64", content);
+        }
+        finally
+        {
+            cache?.Dispose();
+            if (Directory.Exists(dir))
+                Directory.Delete(dir, recursive: true);
+        }
+    }
+
+    [Fact]
+    public async Task ApplyChanges_AddSubnet_KeyOnly_WritesBareKey()
+    {
+        var dir = Path.Combine(Path.GetTempPath(), "dnsmasq-apply-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(dir);
+        var mainPath = Path.Combine(dir, "dnsmasq.conf");
+        var managedName = "zz-managed.conf";
+        var managedPath = Path.Combine(dir, managedName);
+        ConfigSetCache? cache = null;
+        try
+        {
+            File.WriteAllText(mainPath, "port=53\n");
+            var options = Options.Create(new DnsmasqOptions { MainConfigPath = mainPath, ManagedFileName = managedName });
+            cache = new ConfigSetCache(options, NullLogger<ConfigSetCache>.Instance);
+            var setService = new DnsmasqConfigSetService(cache);
+            var configService = new DnsmasqConfigService(setService, cache, NullLogger<DnsmasqConfigService>.Instance);
+
+            var changes = new List<PendingEffectiveConfigChange>
+            {
+                new(EffectiveConfigSections.SectionCache, DnsmasqConfKeys.AddSubnet, null, "", null)
+            };
+            await configService.ApplyEffectiveConfigChangesAsync(changes);
+
+            var content = await File.ReadAllTextAsync(managedPath);
+            Assert.Contains("add-subnet", content);
+            Assert.DoesNotContain("add-subnet=", content);
+        }
+        finally
+        {
+            cache?.Dispose();
+            if (Directory.Exists(dir))
+                Directory.Delete(dir, recursive: true);
+        }
+    }
+
+    [Fact]
+    public async Task ApplyChanges_Umbrella_KeyOnly_WritesBareKey()
+    {
+        var dir = Path.Combine(Path.GetTempPath(), "dnsmasq-apply-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(dir);
+        var mainPath = Path.Combine(dir, "dnsmasq.conf");
+        var managedName = "zz-managed.conf";
+        var managedPath = Path.Combine(dir, managedName);
+        ConfigSetCache? cache = null;
+        try
+        {
+            File.WriteAllText(mainPath, "port=53\n");
+            var options = Options.Create(new DnsmasqOptions { MainConfigPath = mainPath, ManagedFileName = managedName });
+            cache = new ConfigSetCache(options, NullLogger<ConfigSetCache>.Instance);
+            var setService = new DnsmasqConfigSetService(cache);
+            var configService = new DnsmasqConfigService(setService, cache, NullLogger<DnsmasqConfigService>.Instance);
+
+            var changes = new List<PendingEffectiveConfigChange>
+            {
+                new(EffectiveConfigSections.SectionCache, DnsmasqConfKeys.Umbrella, null, "", null)
+            };
+            await configService.ApplyEffectiveConfigChangesAsync(changes);
+
+            var content = await File.ReadAllTextAsync(managedPath);
+            Assert.Contains("umbrella", content);
+            Assert.DoesNotContain("umbrella=", content);
+        }
+        finally
+        {
+            cache?.Dispose();
+            if (Directory.Exists(dir))
+                Directory.Delete(dir, recursive: true);
+        }
+    }
+
+    [Fact]
+    public async Task ApplyEffectiveConfigChangesAsync_Leasequery_MultiKeyOnlyOrValue_DoesNotDuplicateReadonlyValues()
+    {
+        var dir = Path.Combine(Path.GetTempPath(), "dnsmasq-apply-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(dir);
+        var mainPath = Path.Combine(dir, "dnsmasq.conf");
+        var readonlyPath = Path.Combine(dir, "readonly.conf");
+        var managedName = "zz-managed.conf";
+        var managedPath = Path.Combine(dir, managedName);
+        ConfigSetCache? cache = null;
+        try
+        {
+            File.WriteAllText(mainPath, $"port=53\nconf-file={readonlyPath}\n");
+            File.WriteAllText(readonlyPath, "leasequery\nleasequery=10.0.0.0/24\n");
+            File.WriteAllText(managedPath, "leasequery=172.16.0.0/16\n");
+
+            var options = Options.Create(new DnsmasqOptions { MainConfigPath = mainPath, ManagedFileName = managedName });
+            cache = new ConfigSetCache(options, NullLogger<ConfigSetCache>.Instance);
+            cache.Invalidate();
+            var setService = new DnsmasqConfigSetService(cache);
+            var configService = new DnsmasqConfigService(setService, cache, NullLogger<DnsmasqConfigService>.Instance);
+
+            // Simulate UI effective values (readonly + managed). Save should write only managed-only values.
+            var changes = new List<PendingEffectiveConfigChange>
+            {
+                new(
+                    EffectiveConfigSections.SectionDhcp,
+                    DnsmasqConfKeys.Leasequery,
+                    null,
+                    new List<string> { "", "10.0.0.0/24", "192.168.50.0/24" },
+                    null)
+            };
+
+            await configService.ApplyEffectiveConfigChangesAsync(changes);
+
+            var lines = (await File.ReadAllLinesAsync(managedPath))
+                .Select(l => l.Trim())
+                .Where(l => l.StartsWith("leasequery", StringComparison.Ordinal))
+                .ToList();
+
+            Assert.Single(lines);
+            Assert.Equal("leasequery=192.168.50.0/24", lines[0]);
+        }
+        finally
+        {
+            cache?.Dispose();
+            if (Directory.Exists(dir))
+                Directory.Delete(dir, recursive: true);
+        }
+    }
+}
@@ -1,7 +1,7 @@
 using DnsmasqWebUI.Models.Config;
 using DnsmasqWebUI.Models.Dnsmasq;
 using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig;
-using DnsmasqWebUI.Infrastructure.Services;
+using DnsmasqWebUI.Infrastructure.Services.Dnsmasq.Config;
 using Microsoft.Extensions.Logging.Abstractions;
 using Microsoft.Extensions.Options;

@@ -25,7 +25,8 @@ public class DnsmasqConfigSetServiceTests
        Assert.Empty(config.AddnHostsPaths);
        Assert.NotNull(sources);
        Assert.Empty(sources.AddnHostsPaths);
-        Assert.Empty(sources.ServerLocalValues);
+        Assert.Empty(sources.ServerValues);
+        Assert.Empty(sources.LocalValues);
        Assert.Empty(sources.DhcpRanges);
        Assert.Null(sources.NoHosts);
        Assert.Null(sources.Port);
@@ -59,7 +60,8 @@ public class DnsmasqConfigSetServiceTests
            Assert.Equal(cacheSize, config.CacheSize);
            Assert.Single(config.AddnHostsPaths);
            Assert.Equal(Path.GetFullPath(addnHostsPath), config.AddnHostsPaths[0]);
-            Assert.Empty(config.ServerLocalValues);
+            Assert.Empty(config.ServerValues);
+            Assert.Empty(config.LocalValues);
            Assert.Empty(config.DhcpRanges);

            Assert.NotNull(sources);
@@ -0,0 +1,42 @@
+using DnsmasqWebUI.Infrastructure.Helpers.Config;
+using DnsmasqWebUI.Infrastructure.Services.Dnsmasq.Config;
+
+namespace DnsmasqWebUI.Tests;
+
+public class DnsmasqDhcpRangeValueParserTests
+{
+    [Fact]
+    public void TryParse_ValidRange_ReturnsStructuredTokens()
+    {
+        var ok = DnsmasqDhcpRangeValueParser.TryParse(
+            "tag:guest,set:known,192.168.1.50,192.168.1.150,12h",
+            out var parsed,
+            out var error);
+
+        Assert.True(ok);
+        Assert.Null(error);
+        Assert.NotNull(parsed);
+        Assert.Equal(["tag:guest", "set:known"], parsed!.Tags);
+        Assert.Equal("192.168.1.50", parsed.StartToken);
+        Assert.Equal("192.168.1.150", parsed.SecondToken);
+        Assert.Equal(["12h"], parsed.RemainingTokens);
+    }
+
+    [Fact]
+    public void TryParse_MalformedTrailingComma_ReturnsError()
+    {
+        var ok = DnsmasqDhcpRangeValueParser.TryParse("172.28.0.10,", out var parsed, out var error);
+
+        Assert.False(ok);
+        Assert.Null(parsed);
+        Assert.Equal("dhcp-range contains an empty comma-separated segment.", error);
+    }
+
+    [Fact]
+    public void GetIPv4StartEnd_ReturnsParsedIpv4Range()
+    {
+        var result = DnsmasqDhcpRangeValueParser.GetIPv4StartEnd("tag:guest,192.168.1.50,192.168.1.150,12h");
+
+        Assert.Equal(("192.168.1.50", "192.168.1.150"), result);
+    }
+}
@@ -0,0 +1,32 @@
+using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig;
+
+namespace DnsmasqWebUI.Tests;
+
+/// <summary>
+/// Documents and guards the Do0x20 display label rule: Default and Disabled both show "Disabled" (product choice).
+/// Do not "fix" the display to show "Default" for unset without updating this test and the component comment.
+/// </summary>
+public class Do0x20EncodeDisplayLabelTests
+{
+    /// <summary>Same logic as Do0x20EncodeDisplay.razor view mode: Enabled → "Enabled", else "Disabled".</summary>
+    private static string GetDisplayLabel(ExplicitToggleState state) =>
+        state == ExplicitToggleState.Enabled ? "Enabled" : "Disabled";
+
+    [Fact]
+    public void Do0x20_Default_ShowsDisabled()
+    {
+        Assert.Equal("Disabled", GetDisplayLabel(ExplicitToggleState.Default));
+    }
+
+    [Fact]
+    public void Do0x20_Disabled_ShowsDisabled()
+    {
+        Assert.Equal("Disabled", GetDisplayLabel(ExplicitToggleState.Disabled));
+    }
+
+    [Fact]
+    public void Do0x20_Enabled_ShowsEnabled()
+    {
+        Assert.Equal("Enabled", GetDisplayLabel(ExplicitToggleState.Enabled));
+    }
+}
@@ -0,0 +1,22 @@
+using DnsmasqWebUI.Infrastructure.Helpers.Config;
+
+namespace DnsmasqWebUI.Tests;
+
+/// <summary>
+/// Ensures effective-config editable options list includes supported cache flags.
+/// </summary>
+public class EffectiveConfigEditableOptionsTests
+{
+    /// <summary>
+    /// strip-mac and strip-subnet are supported in the effective-config UI and should be listed in cache options.
+    /// </summary>
+    [Fact]
+    public void EditableOptions_Include_StripMac_And_StripSubnet()
+    {
+        var allOptionNames = EffectiveConfigSections.GetSectionsInOrder()
+            .SelectMany(t => EffectiveConfigSections.GetOptionsInSection(t.SectionId))
+            .ToHashSet(StringComparer.Ordinal);
+        Assert.Contains(DnsmasqConfKeys.StripMac, allOptionNames);
+        Assert.Contains(DnsmasqConfKeys.StripSubnet, allOptionNames);
+    }
+}
@@ -0,0 +1,142 @@
+using DnsmasqWebUI.Infrastructure.Helpers.Config;
+using DnsmasqWebUI.Models.Dnsmasq;
+using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig;
+
+namespace DnsmasqWebUI.Tests;
+
+/// <summary>
+/// Tests for option -> feature mapping and capability checks.
+/// </summary>
+public class EffectiveConfigFeatureRequirementsTests
+{
+    [Theory]
+    [InlineData(DnsmasqConfKeys.Dnssec, DnsmasqFeature.Dnssec)]
+    [InlineData(DnsmasqConfKeys.DnssecCheckUnsigned, DnsmasqFeature.Dnssec)]
+    [InlineData(DnsmasqConfKeys.TrustAnchor, DnsmasqFeature.Dnssec)]
+    [InlineData(DnsmasqConfKeys.DhcpRange, DnsmasqFeature.Dhcp)]
+    [InlineData(DnsmasqConfKeys.EnableTftp, DnsmasqFeature.Tftp)]
+    [InlineData(DnsmasqConfKeys.EnableDbus, DnsmasqFeature.Dbus)]
+    public void GetRequiredFeature_ReturnsExpectedFeature(string optionName, DnsmasqFeature expected)
+    {
+        var feature = EffectiveConfigFeatureRequirements.GetRequiredFeature(optionName);
+        Assert.NotNull(feature);
+        Assert.Equal(expected, feature.Value);
+    }
+
+    [Fact]
+    public void GetRequiredFeature_ForUnknownOption_ReturnsNull()
+    {
+        var feature = EffectiveConfigFeatureRequirements.GetRequiredFeature("no-such-option");
+        Assert.Null(feature);
+    }
+
+    [Fact]
+    public void IsSupportedByCapabilities_WhenCapabilityPresent_ReturnsTrue()
+    {
+        var caps = new DnsmasqCompileCapabilities(true, true, true, false,
+            new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "DHCP", "TFTP", "DNSSEC" });
+        Assert.True(EffectiveConfigFeatureRequirements.IsSupportedByCapabilities(DnsmasqConfKeys.DnssecCheckUnsigned, caps));
+        Assert.True(EffectiveConfigFeatureRequirements.IsSupportedByCapabilities(DnsmasqConfKeys.DhcpRange, caps));
+    }
+
+    [Fact]
+    public void IsSupportedByCapabilities_WhenDnssecMissing_ReturnsFalseForDnssecOptions()
+    {
+        var caps = new DnsmasqCompileCapabilities(true, true, false, false,
+            new HashSet<string>(StringComparer.OrdinalIgnoreCase));
+        Assert.False(EffectiveConfigFeatureRequirements.IsSupportedByCapabilities(DnsmasqConfKeys.Dnssec, caps));
+        Assert.False(EffectiveConfigFeatureRequirements.IsSupportedByCapabilities(DnsmasqConfKeys.DnssecCheckUnsigned, caps));
+    }
+
+    [Fact]
+    public void IsSupportedByCapabilities_ForOptionWithNoRequiredFeature_ReturnsTrue()
+    {
+        var caps = new DnsmasqCompileCapabilities(false, false, false, false,
+            new HashSet<string>(StringComparer.OrdinalIgnoreCase));
+        Assert.True(EffectiveConfigFeatureRequirements.IsSupportedByCapabilities(DnsmasqConfKeys.Port, caps));
+    }
+
+    [Fact]
+    public void GetCapabilityDisabled_WhenStatusSupportsFeature_ReturnsNotDisabled()
+    {
+        var status = CreateStatusWithCapabilities(dnssec: true);
+        var (isDisabled, reason) = EffectiveConfigFeatureRequirements.GetCapabilityDisabled(DnsmasqConfKeys.DnssecCheckUnsigned, status);
+        Assert.False(isDisabled);
+        Assert.Null(reason);
+    }
+
+    [Fact]
+    public void GetCapabilityDisabled_WhenStatusMissingDnssec_ReturnsDisabledWithReason()
+    {
+        var status = CreateStatusWithCapabilities(dnssec: false);
+        var (isDisabled, reason) = EffectiveConfigFeatureRequirements.GetCapabilityDisabled(DnsmasqConfKeys.DnssecCheckUnsigned, status);
+        Assert.True(isDisabled);
+        Assert.NotNull(reason);
+        Assert.Contains("DNSSEC", reason, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public void GetCapabilityDisabled_WhenStatusNull_ReturnsNotDisabled()
+    {
+        var (isDisabled, _) = EffectiveConfigFeatureRequirements.GetCapabilityDisabled(DnsmasqConfKeys.DnssecCheckUnsigned, null);
+        Assert.False(isDisabled);
+    }
+
+    /// <summary>
+    /// Save path uses IsSupportedByCapabilities(optionName, version.Capabilities) to reject changes before write.
+    /// This test asserts that logic: a build without DNSSEC would reject dnssec-check-unsigned.
+    /// </summary>
+    [Fact]
+    public void SaveGuard_WhenBuildHasNoDnssec_DnssecOptionChangesWouldBeRejected()
+    {
+        var noDnssecCaps = new DnsmasqCompileCapabilities(true, true, false, false,
+            new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "DHCP", "TFTP" });
+        Assert.False(EffectiveConfigFeatureRequirements.IsSupportedByCapabilities(DnsmasqConfKeys.DnssecCheckUnsigned, noDnssecCaps));
+        var reason = EffectiveConfigFeatureRequirements.GetUnsupportedReason(DnsmasqFeature.Dnssec);
+        Assert.Contains("DNSSEC", reason, StringComparison.OrdinalIgnoreCase);
+    }
+
+    private static DnsmasqServiceStatus CreateStatusWithCapabilities(bool dhcp = true, bool tftp = true, bool dnssec = true, bool dbus = false)
+    {
+        return new DnsmasqServiceStatus(
+            SystemHostsPath: null,
+            SystemHostsPathExists: false,
+            ManagedHostsFilePath: null,
+            ManagedHostsPathExists: false,
+            NoHosts: false,
+            AddnHostsPaths: Array.Empty<string>(),
+            EffectiveConfig: null,
+            EffectiveConfigSources: null,
+            MainConfigPath: null,
+            ManagedFilePath: null,
+            LeasesPath: null,
+            MainConfigPathExists: false,
+            ManagedFilePathExists: false,
+            LeasesPathConfigured: false,
+            LeasesPathExists: false,
+            ConfigFiles: null,
+            ReloadCommandConfigured: false,
+            StatusCommandConfigured: false,
+            StatusShowConfigured: false,
+            LogsConfigured: false,
+            LogsPath: null,
+            StatusShowCommand: null,
+            LogsCommand: null,
+            DnsmasqStatus: "active",
+            StatusCommandExitCode: null,
+            StatusCommandStdout: null,
+            StatusCommandStderr: null,
+            StatusShowOutput: null,
+            LogsOutput: null,
+            DhcpRangeStart: null,
+            DhcpRangeEnd: null,
+            DnsmasqVersion: "2.91",
+            MinimumSupportedDnsmasqVersion: "2.91",
+            DnsmasqVersionSupported: true,
+            DnsmasqVersionError: null,
+            DnsmasqSupportsDhcp: dhcp,
+            DnsmasqSupportsTftp: tftp,
+            DnsmasqSupportsDnssec: dnssec,
+            DnsmasqSupportsDbus: dbus);
+    }
+}
@@ -0,0 +1,104 @@
+using DnsmasqWebUI.Infrastructure.Helpers.Config;
+using DnsmasqWebUI.Models.Dnsmasq;
+using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig;
+
+namespace DnsmasqWebUI.Tests;
+
+/// <summary>
+/// Tests that field descriptors get IsCapabilityDisabled set when the status indicates the option is not supported by the dnsmasq build.
+/// </summary>
+public class EffectiveConfigFieldBuilderCapabilityTests
+{
+    [Fact]
+    public void GetSingleDescriptor_WhenDnssecOptionAndStatusHasNoDnssec_ReturnsDescriptorWithCapabilityDisabled()
+    {
+        var status = CreateStatusWithCapabilities(dnssec: false);
+        var descriptor = EffectiveConfigFieldBuilder.GetSingleDescriptor(
+            null,
+            DnsmasqConfKeys.DnssecCheckUnsigned,
+            status,
+            _ => null,
+            _ => null,
+            null);
+
+        Assert.True(descriptor.IsCapabilityDisabled);
+        Assert.NotNull(descriptor.CapabilityDisabledReason);
+        Assert.Contains("DNSSEC", descriptor.CapabilityDisabledReason, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public void GetSingleDescriptor_WhenDnssecOptionAndStatusHasDnssec_ReturnsDescriptorWithCapabilityNotDisabled()
+    {
+        var status = CreateStatusWithCapabilities(dnssec: true);
+        var descriptor = EffectiveConfigFieldBuilder.GetSingleDescriptor(
+            null,
+            DnsmasqConfKeys.DnssecCheckUnsigned,
+            status,
+            _ => null,
+            _ => null,
+            null);
+
+        Assert.False(descriptor.IsCapabilityDisabled);
+        Assert.Null(descriptor.CapabilityDisabledReason);
+    }
+
+    [Fact]
+    public void GetSingleDescriptor_WhenOptionWithNoFeatureRequirement_ReturnsDescriptorWithCapabilityNotDisabled()
+    {
+        var status = CreateStatusWithCapabilities(dnssec: false);
+        var descriptor = EffectiveConfigFieldBuilder.GetSingleDescriptor(
+            null,
+            DnsmasqConfKeys.Port,
+            status,
+            _ => null,
+            _ => null,
+            null);
+
+        Assert.False(descriptor.IsCapabilityDisabled);
+        Assert.Null(descriptor.CapabilityDisabledReason);
+    }
+
+    private static DnsmasqServiceStatus CreateStatusWithCapabilities(bool dhcp = true, bool tftp = true, bool dnssec = true, bool dbus = false)
+    {
+        return new DnsmasqServiceStatus(
+            SystemHostsPath: null,
+            SystemHostsPathExists: false,
+            ManagedHostsFilePath: null,
+            ManagedHostsPathExists: false,
+            NoHosts: false,
+            AddnHostsPaths: Array.Empty<string>(),
+            EffectiveConfig: null,
+            EffectiveConfigSources: null,
+            MainConfigPath: null,
+            ManagedFilePath: null,
+            LeasesPath: null,
+            MainConfigPathExists: false,
+            ManagedFilePathExists: false,
+            LeasesPathConfigured: false,
+            LeasesPathExists: false,
+            ConfigFiles: null,
+            ReloadCommandConfigured: false,
+            StatusCommandConfigured: false,
+            StatusShowConfigured: false,
+            LogsConfigured: false,
+            LogsPath: null,
+            StatusShowCommand: null,
+            LogsCommand: null,
+            DnsmasqStatus: "active",
+            StatusCommandExitCode: null,
+            StatusCommandStdout: null,
+            StatusCommandStderr: null,
+            StatusShowOutput: null,
+            LogsOutput: null,
+            DhcpRangeStart: null,
+            DhcpRangeEnd: null,
+            DnsmasqVersion: "2.91",
+            MinimumSupportedDnsmasqVersion: "2.91",
+            DnsmasqVersionSupported: true,
+            DnsmasqVersionError: null,
+            DnsmasqSupportsDhcp: dhcp,
+            DnsmasqSupportsTftp: tftp,
+            DnsmasqSupportsDnssec: dnssec,
+            DnsmasqSupportsDbus: dbus);
+    }
+}
@@ -0,0 +1,56 @@
+using DnsmasqWebUI.Infrastructure.Helpers.Config;
+using DnsmasqWebUI.Infrastructure.Services.EffectiveConfig;
+using DnsmasqWebUI.Infrastructure.Services.EffectiveConfig.Validation;
+using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig;
+
+namespace DnsmasqWebUI.Tests;
+
+/// <summary>
+/// Wiring tests that ensure special-option semantics actually feed parser and registry behavior.
+/// </summary>
+public class EffectiveConfigSemanticsWiringTests
+{
+    [Fact]
+    public void ParserBehaviorMap_UsesSpecialSemantics_ForAllSpecialOptions()
+    {
+        foreach (var option in EffectiveConfigSpecialOptionSemantics.GetAllOptionNames())
+        {
+            var semantics = EffectiveConfigSpecialOptionSemantics.TryGetSemantics(option)!;
+            Assert.Equal(semantics.ParserBehavior, EffectiveConfigParserBehaviorMap.GetBehavior(option));
+        }
+    }
+
+    [Fact]
+    public void Registry_WiresLeasequeryMultiValidator_FromSpecialSemantics()
+    {
+        var registry = new EffectiveConfigRenderFragmentRegistry(new OptionSemanticValidator([new LeasequerySemanticHandler()]));
+        var factory = registry.GetMultiDescriptorFactory(EffectiveConfigFieldBuilder.SectionDhcp, DnsmasqConfKeys.Leasequery);
+        Assert.NotNull(factory);
+
+        var descriptor = factory!(
+            EffectiveConfigFieldBuilder.SectionDhcp,
+            DnsmasqConfKeys.Leasequery,
+            status: null,
+            getItems: _ => null);
+
+        Assert.NotNull(descriptor.Validator);
+        Assert.NotNull(descriptor.Validator!.ValidateItem("not-an-ip", Array.Empty<string>()));
+        Assert.Null(descriptor.Validator.ValidateItem("10.0.0.0/24", Array.Empty<string>()));
+    }
+
+    /// <summary>Pre-save semantic blocking: invalid leasequery value produces errors; SaveService uses this and returns SemanticValidationFailed before write.</summary>
+    [Fact]
+    public void SemanticValidationService_InvalidLeasequery_ReturnsError()
+    {
+        var validator = new OptionSemanticValidator([new LeasequerySemanticHandler()]);
+        var service = new EffectiveConfigSemanticValidationService(validator);
+        var changes = new List<PendingEffectiveConfigChange>
+        {
+            new(EffectiveConfigSections.SectionDhcp, DnsmasqConfKeys.Leasequery, null,
+                new List<string> { "not-an-ip" }, null)
+        };
+        var issues = service.Validate(changes);
+        Assert.NotEmpty(issues);
+        Assert.Contains(issues, i => i.Severity == FieldIssueSeverity.Error);
+    }
+}
@@ -12,7 +12,8 @@ public class EffectiveDnsmasqConfigTests
            NoHosts: false,
            AddnHostsPaths: Array.Empty<string>(),
            HostsdirPath: null,
-            ServerLocalValues: Array.Empty<string>(),
+            ServerValues: Array.Empty<string>(),
+            LocalValues: Array.Empty<string>(),
            RevServerValues: Array.Empty<string>(),
            AddressValues: Array.Empty<string>(),
            Interfaces: Array.Empty<string>(),
@@ -53,6 +54,24 @@ public class EffectiveDnsmasqConfigTests
            DhcpHostsfilePaths: Array.Empty<string>(),
            DhcpOptsfilePaths: Array.Empty<string>(),
            DhcpHostsdirPaths: Array.Empty<string>(),
+            DhcpOptsdirPaths: Array.Empty<string>(),
+            ConnmarkAllowlistValues: Array.Empty<string>(),
+            CaaRecordValues: Array.Empty<string>(),
+            DnsRrValues: Array.Empty<string>(),
+            SynthDomainValues: Array.Empty<string>(),
+            AuthZoneValues: Array.Empty<string>(),
+            AuthSoaValues: Array.Empty<string>(),
+            AuthSecServersValues: Array.Empty<string>(),
+            AuthPeerValues: Array.Empty<string>(),
+            DhcpRelayValues: Array.Empty<string>(),
+            DhcpCircuitidValues: Array.Empty<string>(),
+            DhcpRemoteidValues: Array.Empty<string>(),
+            DhcpSubscridValues: Array.Empty<string>(),
+            DhcpProxyValues: Array.Empty<string>(),
+            TagIfValues: Array.Empty<string>(),
+            BridgeInterfaceValues: Array.Empty<string>(),
+            SharedNetworkValues: Array.Empty<string>(),
+            DhcpOptionPxeValues: Array.Empty<string>(),
            ExpandHosts: false,
            BogusPriv: false,
            StrictOrder: false,
@@ -79,7 +98,7 @@ public class EffectiveDnsmasqConfigTests
            TftpNoFail: false,
            TftpNoBlocksize: false,
            Dnssec: false,
-            DnssecCheckUnsigned: false,
+            DnssecCheckUnsigned: null,
            ReadEthers: false,
            DhcpRapidCommit: false,
            Localmx: false,
@@ -89,6 +108,24 @@ public class EffectiveDnsmasqConfigTests
            KeepInForeground: false,
            NoDaemon: false,
            ProxyDnssec: false,
+            ConnmarkAllowlistEnable: null,
+            NoRoundRobin: false,
+            DnssecNoTimecheck: false,
+            DnssecDebug: false,
+            LeasequeryValues: Array.Empty<string>(),
+            DhcpGenerateNames: null,
+            DhcpBroadcast: null,
+            DhcpSequentialIp: false,
+            DhcpIgnoreClid: false,
+            BootpDynamic: null,
+            NoPing: false,
+            ScriptArp: false,
+            ScriptOnRenewal: false,
+            DhcpNoOverride: false,
+            QuietDhcp: false,
+            QuietDhcp6: false,
+            QuietRa: false,
+            QuietTftp: false,
            DhcpLeaseFilePath: null,
            CacheSize: null,
            Port: null,
@@ -119,7 +156,25 @@ public class EffectiveDnsmasqConfigTests
            FastDnsRetry: null,
            DhcpScriptPath: null,
            MxTarget: null,
-            Conntrack: null
+            DnsForwardMax: null,
+            DumpfilePath: null,
+            Dumpmask: null,
+            AddCpeId: null,
+            DnssecTimestamp: null,
+            DnssecLimits: null,
+            DhcpAlternatePort: null,
+            DhcpDuid: null,
+            DhcpLuascriptPath: null,
+            DhcpScriptuser: null,
+            DhcpPxeVendor: null,
+            UseStaleCache: null,
+            AddMac: null,
+            StripMac: false,
+            AddSubnet: null,
+            StripSubnet: false,
+            Umbrella: null,
+            Do0x20EncodeState: ExplicitToggleState.Default,
+            Conntrack: false
        );

    [Fact]
@@ -0,0 +1,938 @@
+using DnsmasqWebUI.Infrastructure.Helpers.Config;
+using DnsmasqWebUI.Infrastructure.Services.EffectiveConfig.Validation;
+using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig;
+
+namespace DnsmasqWebUI.Tests;
+
+/// <summary>
+/// Tests for the central semantic validator (handler dispatch and generic kind validation).
+/// </summary>
+public class OptionSemanticValidatorTests
+{
+    private readonly IOptionSemanticValidator _validator = new OptionSemanticValidator([
+        new LeasequerySemanticHandler(),
+        new ServerSemanticHandler(),
+        new LocalSemanticHandler(),
+        new RevServerSemanticHandler(),
+        new AddressSemanticHandler(),
+        new TrustAnchorSemanticHandler(),
+        new AliasSemanticHandler(),
+        new IpsetSemanticHandler(),
+        new NftsetSemanticHandler(),
+        new IgnoreAddressSemanticHandler(),
+        new ConnmarkAllowlistSemanticHandler(),
+        new DhcpRangeSemanticHandler(),
+        new DhcpHostSemanticHandler(),
+        new DhcpOptionSemanticHandler(),
+        new DhcpMatchSemanticHandler(),
+        new DhcpMacSemanticHandler(),
+        new DhcpRelaySemanticHandler(),
+        new DhcpProxySemanticHandler(),
+        new RaParamSemanticHandler(),
+        new DhcpNameMatchSemanticHandler(),
+        new DhcpIgnoreSemanticHandler(),
+        new DhcpVendorclassSemanticHandler(),
+        new DhcpUserclassSemanticHandler(),
+        new TagIfSemanticHandler(),
+        new BridgeInterfaceSemanticHandler(),
+        new SharedNetworkSemanticHandler(),
+        new DhcpOptionPxeSemanticHandler(),
+        new RebindDomainOkSemanticHandler(),
+        new BogusNxdomainSemanticHandler(),
+        new DhcpIgnoreNamesSemanticHandler(),
+        new DhcpBootSemanticHandler(),
+        new SlaacSemanticHandler(),
+        new PxeServiceSemanticHandler(),
+        new DhcpCircuitidSemanticHandler(),
+        new DhcpRemoteidSemanticHandler(),
+        new DhcpSubscridSemanticHandler(),
+        new FilterRrSemanticHandler(),
+        new CacheRrSemanticHandler(),
+        new InterfaceNameSemanticHandler(),
+        new AuthServerSemanticHandler(),
+        new CnameSemanticHandler(),
+        new MxHostSemanticHandler(),
+        new PtrRecordSemanticHandler(),
+        new InterfaceNameRecordSemanticHandler(),
+        new CaaRecordSemanticHandler(),
+        new SrvHostSemanticHandler(),
+        new NaptrRecordSemanticHandler(),
+        new DnsRrSemanticHandler(),
+        new DynamicHostSemanticHandler(),
+        new AuthSoaSemanticHandler(),
+        new AuthSecServersSemanticHandler(),
+        new AuthPeerSemanticHandler(),
+        new HostRecordSemanticHandler(),
+        new TxtRecordSemanticHandler(),
+        new DomainSemanticHandler(),
+        new SynthDomainSemanticHandler(),
+        new AuthZoneSemanticHandler(),
+    ]);
+
+    [Fact]
+    public void ValidateMultiItem_LeasequeryHandler_InvalidIp_ReturnsError()
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex);
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.Leasequery, "not-an-ip", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.Leasequery, "10.0.0.0/24", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.Leasequery, "", semantics));
+    }
+
+    [Theory]
+    [InlineData("1.2.3.4", true)]
+    [InlineData("::1", true)]
+    [InlineData("", true)]
+    [InlineData("x.y.z", false)]
+    public void ValidateMultiItem_IpAddressKind_AcceptsValid_RejectsInvalid(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.IpAddress, allowEmpty: true);
+        var err = _validator.ValidateMultiItem("option", value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("", true, true)]
+    [InlineData("x", true, true)]
+    [InlineData("", false, false)]
+    public void ValidateMultiItem_StringKind_RespectsAllowEmpty(string value, bool allowEmpty, bool expectValid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.String, allowEmpty: allowEmpty);
+        var err = _validator.ValidateMultiItem("option", value, semantics);
+        Assert.Equal(expectValid, err is null);
+    }
+
+    [Theory]
+    [InlineData("8.8.8.8", true)]
+    [InlineData("dns.example.com", true)]
+    [InlineData("/internal.lan/192.168.2.1", true)]
+    [InlineData("/google.com/#", true)]
+    [InlineData("//", true)]
+    [InlineData("", false)]
+    [InlineData("http://bad", false)]
+    [InlineData("/internal$lan/192.168.2.1", false)]
+    [InlineData("/google.com/192.168.2.1#70000", false)]
+    [InlineData("/google.com/@eth0", false)]
+    public void ValidateMultiItem_Server_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.Server, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("192.168.1.1", true)]
+    [InlineData("::1", true)]
+    [InlineData("", false)]
+    [InlineData("dns.example.com", false)]
+    public void ValidateMultiItem_ListenAddress_UsesIpAddressSemantics(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.IpAddress, allowEmpty: false);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.ListenAddress, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("1.2.3.0/24,192.168.1.1", true)]
+    [InlineData("2001:db8::/64,2001:4860:4860::8888", true)]
+    [InlineData("1.2.3.0/33,192.168.1.1", false)]
+    [InlineData("not-an-ip/24,192.168.1.1", false)]
+    [InlineData("1.2.3.0/x,192.168.1.1", false)]
+    [InlineData("1.2.3.0/24,", false)]
+    public void ValidateMultiItem_RevServer_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.RevServer, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("/example.local/192.168.1.10", true)]
+    [InlineData("/#/1.2.3.4", true)]
+    [InlineData("/example.local/#", true)]
+    [InlineData("/example.local/", true)]
+    [InlineData("example.local/192.168.1.10", false)]
+    [InlineData("//192.168.1.10", true)]
+    [InlineData("/example.local/not-an-ip", false)]
+    public void ValidateMultiItem_Address_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.Address, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("/example.local/", true)]
+    [InlineData("//", true)]
+    [InlineData("/*.example.local/", true)]
+    [InlineData("/internal$lan/", false)]
+    [InlineData("/example.local/192.168.1.1", false)]
+    public void ValidateMultiItem_Local_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.Local, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData(".,20326,8,2,abcdef", true)]
+    [InlineData("example.com", true)]
+    [InlineData("example.com,IN", true)]
+    [InlineData("example.com,IN,20326,8,2,abcdef", true)]
+    [InlineData("", false)]
+    [InlineData("example.com,BOGUS", false)]
+    [InlineData("example.com,IN,tag,8,2,abcdef", false)]
+    public void ValidateMultiItem_TrustAnchor_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.TrustAnchor, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("1.2.3.0,6.7.8.0,255.255.255.0", true)]
+    [InlineData("192.168.0.10-192.168.0.40,10.0.0.0,255.255.255.0", true)]
+    [InlineData("192.168.0.10-,10.0.0.1", false)]
+    [InlineData("not-an-ip,10.0.0.1", false)]
+    public void ValidateMultiItem_Alias_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.Alias, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("/example.local/ipset1", true)]
+    [InlineData("/example.local/example.org/ipset1,ipset2", true)]
+    [InlineData("/internal$lan/ipset1", false)]
+    [InlineData("/example.local/", false)]
+    public void ValidateMultiItem_Ipset_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.Ipset, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("/example.local/inet#filter#set1", true)]
+    [InlineData("/example.local/4#inet#filter#set1", true)]
+    [InlineData("/example.local/6#inet#filter#set1", true)]
+    [InlineData("/example.local/not#enough", false)]
+    [InlineData("/internal$lan/inet#filter#set1", false)]
+    public void ValidateMultiItem_Nftset_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.Nftset, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("64.94.110.11", true)]
+    [InlineData("10.0.0.0/24", true)]
+    [InlineData("2001:db8::/64", true)]
+    [InlineData("not-an-ip", false)]
+    public void ValidateMultiItem_IgnoreAddress_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.IgnoreAddress, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("example.com", true)]
+    [InlineData("/domain1/domain2/", true)]
+    [InlineData("/domain1//", false)]
+    [InlineData("internal$lan", false)]
+    public void ValidateMultiItem_RebindDomainOk_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.RebindDomainOk, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("64.94.110.11", true)]
+    [InlineData("64.94.110.11/24", true)]
+    [InlineData("not-an-ip", false)]
+    public void ValidateMultiItem_BogusNxdomain_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.BogusNxdomain, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("0xff,example.com", true)]
+    [InlineData("0xff/0xff,*", true)]
+    [InlineData("0xff,*.example.com/api.example.com", true)]
+    [InlineData("not-a-mark,example.com", false)]
+    [InlineData("0xff,local", false)]
+    public void ValidateMultiItem_ConnmarkAllowlist_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.ConnmarkAllowlist, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("192.168.1.50,192.168.1.150", true)]
+    [InlineData("tag:guest,set:known,192.168.1.50,192.168.1.150,12h", true)]
+    [InlineData("constructor:eth0,::,static", true)]
+    [InlineData("172.28.0.10,", false)]
+    [InlineData("172.28.0.10", false)]
+    [InlineData("tag:guest,", false)]
+    [InlineData("not-an-ip,192.168.1.150", false)]
+    public void ValidateMultiItem_DhcpRange_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.DhcpRange, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("00:20:e0:3b:13:af,wap,infinite", true)]
+    [InlineData("lap,192.168.0.199", true)]
+    [InlineData("id:clientid,set:known,192.168.1.10,host1,12h", true)]
+    [InlineData("ignore", false)]
+    [InlineData("00:20:e0:3b:13:af,,host1", false)]
+    public void ValidateMultiItem_DhcpHost_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.DhcpHost, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("3,192.168.4.4", true)]
+    [InlineData("option:router,192.168.4.4", true)]
+    [InlineData("vendor:PXEClient,1,0.0.0.0", true)]
+    [InlineData("encap:175,190,iscsi-client0", true)]
+    [InlineData("option:", false)]
+    [InlineData("vendor:,", false)]
+    public void ValidateMultiItem_DhcpOption_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.DhcpOption, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("set:efi-ia32,option:client-arch,6", true)]
+    [InlineData("set:known,93", true)]
+    [InlineData("option:client-arch,6", false)]
+    [InlineData("set:,option:client-arch,6", false)]
+    public void ValidateMultiItem_DhcpMatch_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.DhcpMatch, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("set:3com,01:34:23:*:*:*", true)]
+    [InlineData("set:vendor,aa:bb:cc:dd:ee:ff", true)]
+    [InlineData("01:34:23:*:*:*", false)]
+    [InlineData("set:,01:34:23:*:*:*", false)]
+    public void ValidateMultiItem_DhcpMac_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.DhcpMac, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("set:tag,hostname*", true)]
+    [InlineData("set:tag,hostname", true)]
+    [InlineData("set:tag,*host*", false)]
+    [InlineData("hostname*", false)]
+    public void ValidateMultiItem_DhcpNameMatch_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.DhcpNameMatch, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("", true)]
+    [InlineData("tag:guest", true)]
+    [InlineData("tag:guest,tag:lab", true)]
+    [InlineData("guest", false)]
+    public void ValidateMultiItem_DhcpIgnoreNames_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.DhcpIgnoreNames, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("tag:blocked", true)]
+    [InlineData("tag:blocked,tag:!known", true)]
+    [InlineData("blocked", false)]
+    public void ValidateMultiItem_DhcpIgnore_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.DhcpIgnore, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("set:printers,Hewlett-Packard JetDirect", true)]
+    [InlineData("printers,enterprise:32473,VendorClass", true)]
+    [InlineData("set:printers,enterprise:notnum,VendorClass", false)]
+    public void ValidateMultiItem_DhcpVendorclass_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.DhcpVendorclass, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("set:userclass,ExampleClient", true)]
+    [InlineData("userclass,ExampleClient", true)]
+    [InlineData("set:,ExampleClient", false)]
+    public void ValidateMultiItem_DhcpUserclass_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.DhcpUserclass, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("set:ppp,tag:ppp*", true)]
+    [InlineData("set:guest,tag:!known", true)]
+    [InlineData("tag:known", false)]
+    public void ValidateMultiItem_TagIf_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.TagIf, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("192.168.1.1,192.168.2.1", true)]
+    [InlineData("192.168.1.1,192.168.2.1#1067,eth1", true)]
+    [InlineData("192.168.1.1,eth1", true)]
+    [InlineData("not-an-ip,192.168.2.1", false)]
+    [InlineData("192.168.1.1,server.example.com", false)]
+    public void ValidateMultiItem_DhcpRelay_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.DhcpRelay, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("192.168.1.1", true)]
+    [InlineData("192.168.1.1,192.168.1.2", true)]
+    [InlineData("not-an-ip", false)]
+    public void ValidateMultiItem_DhcpProxy_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.DhcpProxy, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("br0,eth0", true)]
+    [InlineData("br0,tap*", true)]
+    [InlineData("br0", false)]
+    public void ValidateMultiItem_BridgeInterface_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.BridgeInterface, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("pxelinux.0", true)]
+    [InlineData("tag:pxe,pxelinux.0,,192.168.1.2", true)]
+    [InlineData("tag:,pxelinux.0", false)]
+    [InlineData("", false)]
+    public void ValidateMultiItem_DhcpBoot_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.DhcpBoot, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("sharednet,192.168.10.0,255.255.255.0", true)]
+    [InlineData("eth0,192.168.10.1", true)]
+    [InlineData("sharednet", false)]
+    public void ValidateMultiItem_SharedNetwork_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.SharedNetwork, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("eth0,::10", true)]
+    [InlineData("slaac", true)]
+    [InlineData("ra-names,eth0", true)]
+    [InlineData("bad value", false)]
+    public void ValidateMultiItem_Slaac_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.Slaac, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("eth0,60", true)]
+    [InlineData("eth0,mtu:1280,low,60,1200", true)]
+    [InlineData("eth0,high", true)]
+    [InlineData("eth*,60", true)]
+    [InlineData("eth*0,60", false)]
+    [InlineData("*eth0,60", false)]
+    [InlineData(",60", false)]
+    [InlineData("eth0,mtu:", false)]
+    public void ValidateMultiItem_RaParam_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.RaParam, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("x86PC,\"PXE Boot\",pxelinux", true)]
+    [InlineData("tag:pxe,x86PC,\"PXE Boot\",pxelinux,192.168.1.2", true)]
+    [InlineData("x86PC", false)]
+    [InlineData("bad-csa,\"PXE Boot\",pxelinux", false)]
+    public void ValidateMultiItem_PxeService_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.PxeService, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("vendor:PXEClient,1,0.0.0.0", true)]
+    [InlineData("encap:175,190,iscsi-client0", true)]
+    [InlineData("option:router,192.168.1.1", false)]
+    [InlineData("vendor:,1,0.0.0.0", false)]
+    public void ValidateMultiItem_DhcpOptionPxe_UsesHandler(string value, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex, allowEmpty: true);
+        var err = _validator.ValidateMultiItem(DnsmasqConfKeys.DhcpOptionPxe, value, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Fact]
+    public void ValidateSingle_UseStaleCache_UsesEngineRule()
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.KeyOnlyOrValue, allowEmpty: true);
+        Assert.Null(_validator.ValidateSingle(DnsmasqConfKeys.UseStaleCache, "", semantics));
+        Assert.Null(_validator.ValidateSingle(DnsmasqConfKeys.UseStaleCache, "0", semantics));
+        Assert.NotNull(_validator.ValidateSingle(DnsmasqConfKeys.UseStaleCache, "x", semantics));
+    }
+
+    [Fact]
+    public void ValidateSingle_AddMac_UsesEngineRule()
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.KeyOnlyOrValue, allowEmpty: true);
+        Assert.Null(_validator.ValidateSingle(DnsmasqConfKeys.AddMac, "", semantics));
+        Assert.Null(_validator.ValidateSingle(DnsmasqConfKeys.AddMac, "base64", semantics));
+        Assert.NotNull(_validator.ValidateSingle(DnsmasqConfKeys.AddMac, "bogus", semantics));
+    }
+
+    [Theory]
+    [InlineData("")]
+    [InlineData("24,96")]
+    [InlineData("0/0")]
+    public void ValidateSingle_AddSubnet_RemainsIntentionallyPermissive(string input)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.KeyOnlyOrValue, allowEmpty: true);
+        Assert.Null(_validator.ValidateSingle(DnsmasqConfKeys.AddSubnet, input, semantics));
+    }
+
+    [Theory]
+    [InlineData("")]
+    [InlineData("org-id,asset-id")]
+    [InlineData("device-123")]
+    public void ValidateSingle_Umbrella_RemainsIntentionallyPermissive(string input)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.KeyOnlyOrValue, allowEmpty: true);
+        Assert.Null(_validator.ValidateSingle(DnsmasqConfKeys.Umbrella, input, semantics));
+    }
+
+    [Theory]
+    [InlineData("", true)]
+    [InlineData("0xff", true)]
+    [InlineData("255", true)]
+    [InlineData("0xZZ", false)]
+    [InlineData("-1", false)]
+    public void ValidateSingle_ConnmarkAllowlistEnable_UsesEngineRule(string input, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.KeyOnlyOrValue, allowEmpty: true);
+        var err = _validator.ValidateSingle(DnsmasqConfKeys.ConnmarkAllowlistEnable, input, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Theory]
+    [InlineData("", true)]
+    [InlineData("no", true)]
+    [InlineData("yes", false)]
+    public void ValidateSingle_DnssecCheckUnsigned_UsesEngineRule(string input, bool valid)
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.KeyOnlyOrValue, allowEmpty: true);
+        var err = _validator.ValidateSingle(DnsmasqConfKeys.DnssecCheckUnsigned, input, semantics);
+        Assert.Equal(valid, err is null);
+    }
+
+    [Fact]
+    public void ValidateSingle_IntKind_AcceptsIntOrNumericString()
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Int);
+        Assert.Null(_validator.ValidateSingle("option", 42, semantics));
+        Assert.Null(_validator.ValidateSingle("option", "99", semantics));
+        Assert.NotNull(_validator.ValidateSingle("option", "abc", semantics));
+    }
+
+    [Fact]
+    public void OptionValidationSemantics_PathPolicy_OnNonPathKind_Throws()
+    {
+        Assert.Throws<ArgumentException>(() =>
+            new OptionValidationSemantics(
+                OptionValidationKind.Int,
+                pathPolicy: PathExistencePolicy.MustExist));
+    }
+
+    [Fact]
+    public void ValidateMultiItem_PathFile_RejectsDirectoryPath()
+    {
+        var validator = _validator;
+        var semantics = new OptionValidationSemantics(
+            OptionValidationKind.PathFile,
+            allowEmpty: true,
+            pathPolicy: PathExistencePolicy.MustExist);
+
+        var dir = Directory.CreateTempSubdirectory("dnsmasq-webui-pathfile-");
+        try
+        {
+            var err = validator.ValidateMultiItem(DnsmasqConfKeys.DhcpHostsfile, dir.FullName, semantics);
+            Assert.Equal("File does not exist.", err);
+        }
+        finally
+        {
+            dir.Delete(recursive: true);
+        }
+    }
+
+    [Fact]
+    public void ValidateMultiItem_PathDirectory_RejectsFilePath()
+    {
+        var validator = _validator;
+        var semantics = new OptionValidationSemantics(
+            OptionValidationKind.PathDirectory,
+            allowEmpty: true,
+            pathPolicy: PathExistencePolicy.MustExist);
+
+        var filePath = Path.Combine(Path.GetTempPath(), $"dnsmasq-webui-pathdir-{Guid.NewGuid():N}.txt");
+        File.WriteAllText(filePath, "test");
+        try
+        {
+            var err = validator.ValidateMultiItem(DnsmasqConfKeys.DhcpHostsdir, filePath, semantics);
+            Assert.Equal("Directory does not exist.", err);
+        }
+        finally
+        {
+            File.Delete(filePath);
+        }
+    }
+
+    [Fact]
+    public void ValidateMultiItem_PathFile_AcceptsExistingFile()
+    {
+        var validator = _validator;
+        var semantics = new OptionValidationSemantics(
+            OptionValidationKind.PathFile,
+            allowEmpty: true,
+            pathPolicy: PathExistencePolicy.MustExist);
+
+        var filePath = Path.Combine(Path.GetTempPath(), $"dnsmasq-webui-pathfile-{Guid.NewGuid():N}.txt");
+        File.WriteAllText(filePath, "test");
+        try
+        {
+            var err = validator.ValidateMultiItem(DnsmasqConfKeys.DhcpHostsfile, filePath, semantics);
+            Assert.Null(err);
+        }
+        finally
+        {
+            File.Delete(filePath);
+        }
+    }
+
+    [Fact]
+    public void ValidateMultiItem_PathDirectory_AcceptsExistingDirectory()
+    {
+        var validator = _validator;
+        var semantics = new OptionValidationSemantics(
+            OptionValidationKind.PathDirectory,
+            allowEmpty: true,
+            pathPolicy: PathExistencePolicy.MustExist);
+
+        var dir = Directory.CreateTempSubdirectory("dnsmasq-webui-pathdir-");
+        try
+        {
+            var err = validator.ValidateMultiItem(DnsmasqConfKeys.DhcpHostsdir, dir.FullName, semantics);
+            Assert.Null(err);
+        }
+        finally
+        {
+            dir.Delete(recursive: true);
+        }
+    }
+
+    [Fact]
+    public void ValidateMultiItem_DhcpCircuitid_RequiresSetTagValue()
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex);
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.DhcpCircuitid, "set:uplink,aa:bb:cc", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.DhcpCircuitid, "set:mytag,simple-string", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.DhcpCircuitid, "", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.DhcpCircuitid, "tag:uplink,id", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.DhcpCircuitid, "set:only", semantics));
+    }
+
+    [Fact]
+    public void ValidateMultiItem_DhcpRemoteid_RequiresSetTagValue()
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex);
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.DhcpRemoteid, "set:uplink,remote-id", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.DhcpRemoteid, "set:tag,", semantics));
+    }
+
+    [Fact]
+    public void ValidateMultiItem_DhcpSubscrid_RequiresSetTagValue()
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex);
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.DhcpSubscrid, "set:sub,subscriber-id", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.DhcpSubscrid, "bad", semantics));
+    }
+
+    [Fact]
+    public void ValidateMultiItem_FilterRr_AcceptsRrTypes()
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex);
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.FilterRr, "A", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.FilterRr, "A,AAAA,TXT,MX", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.FilterRr, "ANY", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.FilterRr, "255", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.FilterRr, "", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.FilterRr, "A,,B", semantics));
+    }
+
+    [Fact]
+    public void ValidateMultiItem_CacheRr_AcceptsRrTypes()
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex);
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.CacheRr, "TXT", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.CacheRr, "A,AAAA,CNAME,SRV", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.CacheRr, "ANY", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.CacheRr, "", semantics));
+    }
+
+    [Fact]
+    public void ValidateMultiItem_InterfaceNameOptions_AcceptInterfaceNameWithOptionalTrailingWildcard()
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex);
+        foreach (var key in new[] { DnsmasqConfKeys.Interface, DnsmasqConfKeys.ExceptInterface, DnsmasqConfKeys.NoDhcpInterface, DnsmasqConfKeys.NoDhcpv4Interface, DnsmasqConfKeys.NoDhcpv6Interface })
+        {
+            Assert.Null(_validator.ValidateMultiItem(key, "eth0", semantics));
+            Assert.Null(_validator.ValidateMultiItem(key, "eth0*", semantics));
+            Assert.Null(_validator.ValidateMultiItem(key, "br-lan", semantics));
+            Assert.NotNull(_validator.ValidateMultiItem(key, "", semantics));
+            Assert.NotNull(_validator.ValidateMultiItem(key, "eth*0", semantics));
+        }
+    }
+
+    [Fact]
+    public void ValidateMultiItem_AuthServer_RequiresDomain_AcceptsInterfaceOrIp()
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex);
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.AuthServer, "example.com", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.AuthServer, "example.com,eth0", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.AuthServer, "example.com,192.168.1.1,eth1/4", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.AuthServer, "ns.example.com,::1,eth0/6", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.AuthServer, "", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.AuthServer, ",eth0", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.AuthServer, "example.com,invalid@", semantics));
+    }
+
+    [Fact]
+    public void ValidateMultiItem_Cname_RequiresCnameAndTarget_AcceptsOptionalTtl()
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex);
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.Cname, "router.example.local,router", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.Cname, "cname1,cname2,target", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.Cname, "alias,host.example.com,60", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.Cname, "", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.Cname, "only", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.Cname, "bad..name,target", semantics));
+    }
+
+    [Fact]
+    public void ValidateMultiItem_MxHost_AcceptsMxNameWithOptionalHostnameAndPreference()
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex);
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.MxHost, "example.local", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.MxHost, "example.local,mail.example.local,10", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.MxHost, "mx.local,5", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.MxHost, "", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.MxHost, "bad..name", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.MxHost, "mx.local,mail,99999", semantics));
+    }
+
+    [Fact]
+    public void ValidateMultiItem_PtrRecord_NameAndOptionalTarget()
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex);
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.PtrRecord, "1.0.168.192.in-addr.arpa,host.example.com", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.PtrRecord, "name.only", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.PtrRecord, "", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.PtrRecord, "bad..name,target", semantics));
+    }
+
+    [Fact]
+    public void ValidateMultiItem_InterfaceNameRecord_NameAndInterface()
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex);
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.InterfaceName, "router.example.local,eth0", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.InterfaceName, "host.local,eth1/4", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.InterfaceName, "name", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.InterfaceName, "name,", semantics));
+    }
+
+    [Fact]
+    public void ValidateMultiItem_CaaRecord_FourParts()
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex);
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.CaaRecord, "example.com,0,issue,letsencrypt.org", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.CaaRecord, "a,b", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.CaaRecord, "x,y,z,w", semantics)); // 4 but invalid name possible - "x" is valid DNS name
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.CaaRecord, "x,256,tag,val", semantics));
+    }
+
+    [Fact]
+    public void ValidateMultiItem_SrvHost_ServiceNameAndOptionalTargetPortPriorityWeight()
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex);
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.Srv, "_sip._udp.example.com", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.Srv, "_sip._udp,sip.example.com,5060,0,0", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.Srv, "", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.Srv, "_sip._udp,host,70000", semantics));
+    }
+
+    [Fact]
+    public void ValidateMultiItem_NaptrRecord_SixOrSevenParts()
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex);
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.NaptrRecord, "name.example.com,0,0,s,a,x,replacement", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.NaptrRecord, "n.zone,1,10,flags,svc,regex", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.NaptrRecord, "a,b,c", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.NaptrRecord, "bad..name,0,0,f,s,r", semantics));
+    }
+
+    [Fact]
+    public void ValidateMultiItem_DnsRr_NameAndRrNumber_OptionalHex()
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex);
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.DnsRr, "example.com,255", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.DnsRr, "name.example,1,01:02:03", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.DnsRr, "x", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.DnsRr, "x,99999", semantics));
+    }
+
+    [Fact]
+    public void ValidateMultiItem_DynamicHost_FourFields_NameAndInterface()
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex);
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.DynamicHost, "example.com,0.0.0.8,eth0", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.DynamicHost, "example.com,,,eth0", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.DynamicHost, "host.local,0.0.0.8,,eth0", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.DynamicHost, "x,y", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.DynamicHost, "x,1.2.3.4,::1,bad if", semantics));
+    }
+
+    [Fact]
+    public void ValidateMultiItem_AuthSoa_SerialAndOptionalFields()
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex);
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.AuthSoa, "1", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.AuthSoa, "1,hostmaster.example.com,3600,600,86400", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.AuthSoa, "", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.AuthSoa, "x", semantics));
+    }
+
+    [Fact]
+    public void ValidateMultiItem_AuthSecServers_OneOrMoreDomains()
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex);
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.AuthSecServers, "ns1.example.com", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.AuthSecServers, "a.com,b.com", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.AuthSecServers, "", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.AuthSecServers, "bad..name", semantics));
+    }
+
+    [Fact]
+    public void ValidateMultiItem_AuthPeer_OneOrMoreIps()
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex);
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.AuthPeer, "192.168.1.1", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.AuthPeer, "::1,10.0.0.1", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.AuthPeer, "", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.AuthPeer, "not-an-ip", semantics));
+    }
+
+    [Fact]
+    public void ValidateMultiItem_HostRecord_AtLeastOneName_OptionalIpv4Ipv6Ttl()
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex);
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.HostRecord, "laptop,192.168.0.1", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.HostRecord, "host.example.com,192.168.0.1,::1,60", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.HostRecord, "", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.HostRecord, "bad..name,1.2.3.4", semantics));
+    }
+
+    [Fact]
+    public void ValidateMultiItem_TxtRecord_NameRequired()
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex);
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.TxtRecord, "example.com", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.TxtRecord, "name.example.com,some text", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.TxtRecord, "", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.TxtRecord, "bad..name,text", semantics));
+    }
+
+    [Fact]
+    public void ValidateMultiItem_Domain_DomainOrHash_OptionalRangeOrInterface()
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex);
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.Domain, "thekelleys.org.uk", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.Domain, "#", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.Domain, "lan,192.168.0.0/24,local", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.Domain, "local.zone,eth0", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.Domain, "", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.Domain, "bad..name", semantics));
+    }
+
+    [Fact]
+    public void ValidateMultiItem_SynthDomain_DomainAndRange_OptionalPrefix()
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex);
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.SynthDomain, "zone.example.com,192.168.0.50,192.168.0.70", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.SynthDomain, "zone,192.168.0.0/24,internal-*", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.SynthDomain, "only", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.SynthDomain, "bad..name,1.2.3.4", semantics));
+    }
+
+    [Fact]
+    public void ValidateMultiItem_AuthZone_DomainRequired_OptionalSubnets()
+    {
+        var semantics = new OptionValidationSemantics(OptionValidationKind.Complex);
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.AuthZone, "example.com", semantics));
+        Assert.Null(_validator.ValidateMultiItem(DnsmasqConfKeys.AuthZone, "zone,192.168.0.0/24", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.AuthZone, "", semantics));
+        Assert.NotNull(_validator.ValidateMultiItem(DnsmasqConfKeys.AuthZone, "bad..name", semantics));
+    }
+}
@@ -23,7 +23,7 @@

 <body>
    <Routes @rendermode="InteractiveServer" />
-    <script src="js/ec-option-help.js"></script>
+    <script src="js/copy-to-clipboard.js"></script>
    <script src="_framework/blazor.web.js"></script>
 </body>

@@ -1,4 +1,4 @@
-@namespace DnsmasqWebUI.Components.Dnsmasq
+@namespace DnsmasqWebUI.Components.Dnsmasq.AppLogs
@inject ILoggingClient LoggingClient
@inject IJSRuntime JSRuntime
@implements IAsyncDisposable
@@ -16,7 +16,7 @@
                <div class="input-group input-group-sm mb-2">
                    <input type="text" class="form-control" placeholder="e.g. Microsoft.AspNetCore."
                           @bind="_newPrefix" @bind:event="oninput" @onkeydown="OnNewPrefixKeydown" />
-                    <button type="button" class="btn btn-outline-primary" @onclick="AddPrefix" disabled="@string.IsNullOrWhiteSpace(_newPrefix)">Add</button>
+                    <button type="button" class="btn btn-outline-primary" @onclick="AddPrefix" disabled="@string.IsNullOrWhiteSpace(_newPrefix)"><i class="bi bi-plus me-1" aria-hidden="true"></i>Add</button>
                </div>
                <ul class="list-group list-group-flush" style="max-height: 12rem; overflow-y: auto;">
                    @foreach (var prefix in _prefixes)
@@ -35,10 +35,10 @@
                </ul>
            </div>
            <div class="modal-footer d-flex justify-content-between align-items-center">
-                <button type="button" class="btn btn-secondary" @onclick="RestoreDefaults" disabled="@_saving">Restore defaults</button>
+                <button type="button" class="btn btn-secondary" @onclick="RestoreDefaults" disabled="@_saving"><i class="bi bi-arrow-counterclockwise me-1" aria-hidden="true"></i>Restore defaults</button>
                <div>
-                    <button type="button" class="btn btn-secondary" @onclick="Close">Cancel</button>
-                    <button type="button" class="btn btn-primary" @onclick="Save" disabled="@_saving">@(_saving ? "Saving…" : "Save")</button>
+                    <button type="button" class="btn btn-secondary" @onclick="Close"><i class="bi bi-x me-1" aria-hidden="true"></i>Cancel</button>
+                    <button type="button" class="btn btn-primary" @onclick="Save" disabled="@_saving">@if (_saving) { <span class="spinner-border spinner-border-sm me-1" role="status" aria-hidden="true"></span> } else { <i class="bi bi-floppy-fill me-1" aria-hidden="true"></i> }@(_saving ? "Saving…" : "Save")</button>
                </div>
            </div>
        </div>
@@ -1,9 +1,10 @@
+using DnsmasqWebUI.Extensions.Interop;
 using DnsmasqWebUI.Infrastructure.Client.Abstractions;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Web;
 using Microsoft.JSInterop;

-namespace DnsmasqWebUI.Components.Dnsmasq;
+namespace DnsmasqWebUI.Components.Dnsmasq.AppLogs;

 public partial class AppLogsFiltersModal : IAsyncDisposable
 {
@@ -53,7 +54,7 @@ public partial class AppLogsFiltersModal : IAsyncDisposable
        {
            try
            {
-                _jsModule = await JSRuntime.InvokeAsync<IJSObjectReference>("import", "./js/settings-modal.js");
+                _jsModule = await JSRuntime.InvokeAsync<IJSObjectReference>("import", "./js/dialog.js");
                _dotNetRef = DotNetObjectReference.Create(this);
                _moduleLoaded = true;
            }
@@ -66,17 +67,17 @@ public partial class AppLogsFiltersModal : IAsyncDisposable
        {
            if (!_dialogInitialized)
            {
-                await _jsModule.InvokeVoidAsync("initDialog", _dialogRef, _dotNetRef);
+                await _jsModule.InvokeVoidAsyncSafe("initDialog", _dialogRef, _dotNetRef);
                _dialogInitialized = true;
            }
-            await _jsModule.InvokeVoidAsync("showModal", _dialogRef);
+            await _jsModule.InvokeVoidAsyncSafe("showModal", _dialogRef);
        }
    }

    private async Task Close()
    {
        if (_jsModule != null)
-            await _jsModule.InvokeVoidAsync("closeModal", _dialogRef);
+            await _jsModule.InvokeVoidAsyncSafe("closeModal", _dialogRef);
        await OnClose.InvokeAsync();
    }

@@ -145,10 +146,6 @@ public partial class AppLogsFiltersModal : IAsyncDisposable
        _cts.Cancel();
        _cts.Dispose();
        _dotNetRef?.Dispose();
-        if (_jsModule != null)
-        {
-            try { await _jsModule.DisposeAsync(); }
-            catch { /* ignore */ }
-        }
+        await _jsModule.DisposeAsyncSafe();
    }
 }
@@ -1,4 +1,4 @@
-@namespace DnsmasqWebUI.Components.Dnsmasq
+@namespace DnsmasqWebUI.Components.Dnsmasq.AppLogs
@* App logs — live view via SignalR from ILogger *@
@using DnsmasqWebUI.Models.Logs
@using Microsoft.AspNetCore.SignalR.Client
@@ -31,3 +31,7 @@
 </p>
 <AppLogsFiltersModal IsVisible="_filtersModalVisible" OnClose="CloseFiltersModal" />
 <LogsPreView Id="app-logs-pre" Placeholder="@_initialPlaceholder" Freeze="_logsContentReceived" />
+<div class="mt-2 d-flex flex-wrap gap-2 align-items-center">
+    <button class="btn btn-primary btn-sm" @onclick="RequestRefreshAsync" disabled="@_refreshing"><i class="bi bi-arrow-repeat me-1" aria-hidden="true"></i>Refresh</button>
+    <a href="api/logging/logs/download" download="app.log" class="btn btn-primary btn-sm"><i class="bi bi-download me-1" aria-hidden="true"></i>Download logs</a>
+</div>
@@ -1,10 +1,11 @@
+using DnsmasqWebUI.Extensions.Interop;
 using DnsmasqWebUI.Infrastructure.Client.Abstractions;
 using DnsmasqWebUI.Models.Logs;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.SignalR.Client;
 using Microsoft.JSInterop;

-namespace DnsmasqWebUI.Components.Dnsmasq;
+namespace DnsmasqWebUI.Components.Dnsmasq.AppLogs;

 /// <summary>
 /// App logs block: connects to LogsHub, receives AppLogsUpdate pushes, polls at interval as fallback.
@@ -18,6 +19,7 @@ public partial class AppLogsSection : IAsyncDisposable

    private bool _justUpdated;
    private bool _logsContentReceived;
+    private bool _refreshing;
    private int _intervalSeconds;
    private string _logLevel = "Information";
    private bool _logLevelDisabled;
@@ -90,6 +92,25 @@ public partial class AppLogsSection : IAsyncDisposable
    private void OpenFiltersModal() => _filtersModalVisible = true;
    private void CloseFiltersModal() => _filtersModalVisible = false;

+    private async Task RequestRefreshAsync()
+    {
+        if (_hubConnection?.State != HubConnectionState.Connected)
+            return;
+        _refreshing = true;
+        StateHasChanged();
+        try
+        {
+            await _hubConnection.InvokeAsync("RequestAppLogsSnapshot", _cts.Token);
+        }
+        catch (OperationCanceledException) { }
+        catch (Exception) { /* ignore */ }
+        finally
+        {
+            _refreshing = false;
+            StateHasChanged();
+        }
+    }
+
    private async Task OnLogLevelChanged()
    {
        if (string.IsNullOrEmpty(_logLevel)) return;
@@ -137,19 +158,13 @@ public partial class AppLogsSection : IAsyncDisposable
            await InvokeAsync(async () =>
            {
                if (_logsJs == null) return;
-                try
-                {
-                    if (payload.Mode == "replace")
-                        await _logsJs.InvokeVoidAsync("replaceLogs", AppLogsPreId, payload.Content, LogsOptions);
-                    else
-                        await _logsJs.InvokeVoidAsync("appendLogs", AppLogsPreId, payload.Content, LogsOptions);
-                    _logsContentReceived = true;
-                    SetJustUpdated();
-                    StateHasChanged();
-                }
-                catch (JSDisconnectedException) { /* Circuit disconnected; ignore */ }
-                catch (InvalidOperationException) { /* Prerender or circuit disposed; ignore */ }
-                catch (JSException) { /* JS error; ignore */ }
+                if (payload.Mode == "replace")
+                    await _logsJs.InvokeVoidAsyncSafe("replaceLogs", AppLogsPreId, payload.Content, LogsOptions);
+                else
+                    await _logsJs.InvokeVoidAsyncSafe("appendLogs", AppLogsPreId, payload.Content, LogsOptions);
+                _logsContentReceived = true;
+                SetJustUpdated();
+                StateHasChanged();
            });
        }
        catch (ObjectDisposedException) { /* Component disposed; ignore */ }
@@ -183,13 +198,7 @@ public partial class AppLogsSection : IAsyncDisposable
            await _hubConnection.DisposeAsync();
            _hubConnection = null;
        }
-        if (_logsJs != null)
-        {
-            try { await _logsJs.DisposeAsync(); }
-            catch (InvalidOperationException ex) { Logger.LogDebug(ex, "AppLogsSection: DisposeAsync skipped (prerender)"); }
-            catch (JSDisconnectedException ex) { Logger.LogDebug(ex, "AppLogsSection: DisposeAsync skipped (circuit disconnected)"); }
-            catch (JSException ex) { Logger.LogDebug(ex, "AppLogsSection: DisposeAsync failed"); }
-            _logsJs = null;
-        }
+        await _logsJs.DisposeAsyncSafe();
+        _logsJs = null;
    }
 }
@@ -0,0 +1,74 @@
+@namespace DnsmasqWebUI.Components.Dnsmasq
+@using DnsmasqWebUI.Models.Dnsmasq
+@using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig
+
+<div class="config-file-list">
+    @{
+        var configFileList = Status.ConfigFiles?.Count > 0 ? Status.ConfigFiles : ConfigSet?.Files;
+        var hasList = configFileList != null && configFileList.Count > 0;
+        var mainEntry = hasList ? configFileList![0] : null;
+        var hasMoreThanOne = hasList && configFileList!.Count > 1;
+        var fileCount = hasList ? configFileList!.Count : 2;
+        var showToggle = hasMoreThanOne || (!hasList && Status.ManagedFilePath != null);
+    }
+    <div class="config-file-list-header">
+        <p class="config-file-list-title mb-0">Config files (load order)</p>
+        @if (showToggle)
+        {
+            <button type="button"
+                    class="config-file-list-toggle"
+                    @onclick="ToggleExpanded"
+                    aria-expanded="@_expanded"
+                    aria-label="@(_expanded ? "Show only main config" : "Show all config files")">
+                <i class="bi @(_expanded ? "bi-chevron-up" : "bi-chevron-down")" aria-hidden="true"></i>
+                <span>@(_expanded ? "Show less" : $"Show all ({fileCount} files)")</span>
+            </button>
+        }
+    </div>
+    <div class="config-file-list-content-row">
+        <div class="config-file-list-list">
+            <ul class="list-unstyled config-file-list-main">
+                @if (hasList)
+                {
+                    <ConfigFileListItem Entry="@mainEntry" Status="Status" />
+                }
+                else
+                {
+                    <li><strong>Main config:</strong> @(Status.MainConfigPath ?? "—") @(Status.MainConfigPathExists ? "✓" : "(missing)")</li>
+                }
+            </ul>
+            @if (showToggle)
+            {
+                <div class="config-file-list-expandable @(_expanded ? "expanded" : null)">
+                    <div class="config-file-list-expandable-inner">
+                        <ul class="list-unstyled">
+                            @if (hasList)
+                            {
+                                @foreach (var f in configFileList!.Skip(1))
+                                {
+                                    <ConfigFileListItem Entry="f" Status="Status" />
+                                }
+                            }
+                            else
+                            {
+                                <li><strong>Managed file:</strong> @(Status.ManagedFilePath ?? "—") @(Status.ManagedFilePathExists ? "✓" : "(not created yet)")</li>
+                            }
+                        </ul>
+                    </div>
+                </div>
+            }
+        </div>
+    </div>
+</div>
+
+@code {
+    [Parameter, EditorRequired]
+    public DnsmasqServiceStatus Status { get; set; } = null!;
+
+    [Parameter]
+    public DnsmasqConfigSet? ConfigSet { get; set; }
+
+    private bool _expanded;
+
+    private void ToggleExpanded() => _expanded = !_expanded;
+}
@@ -0,0 +1,106 @@
+/* Config file list: card-style block with expandable list */
+.config-file-list {
+    --cfl-radius: var(--app-radius, 0.375rem);
+    --cfl-spacing: var(--app-spacing-md, 1rem);
+    --cfl-border: 1px solid #e9ecef;
+    --cfl-bg: #f8f9fa;
+    --cfl-bg-hover: #e9ecef;
+}
+
+.config-file-list {
+    border-radius: var(--cfl-radius);
+    border: var(--cfl-border);
+    background: var(--cfl-bg);
+    padding: var(--cfl-spacing);
+    margin-top: 0.5rem;
+}
+
+.config-file-list-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 0.75rem;
+    margin-bottom: 0.5rem;
+}
+
+.config-file-list .config-file-list-title {
+    font-size: 0.9375rem;
+    font-weight: 600;
+    color: #212529;
+    margin-bottom: 0;
+}
+
+.config-file-list ul {
+    margin: 0;
+    padding-left: 1.25rem;
+    font-size: 0.875rem;
+    line-height: 1.6;
+    color: #495057;
+}
+
+.config-file-list ul li {
+    padding: 0.2rem 0;
+}
+
+/* List content row (toggle is in header now) */
+.config-file-list-content-row {
+    display: flex;
+    align-items: flex-start;
+    gap: 0.75rem;
+}
+
+.config-file-list-list {
+    flex: 1;
+    min-width: 0;
+}
+
+.config-file-list .config-file-list-toggle {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.35rem;
+    flex-shrink: 0;
+    padding: 0.35rem 0.5rem;
+    font-size: 0.8125rem;
+    font-weight: 500;
+    color: #0d6efd;
+    background: transparent;
+    border: none;
+    border-radius: var(--cfl-radius);
+    cursor: pointer;
+    transition: background-color 0.15s ease, color 0.15s ease;
+}
+
+.config-file-list .config-file-list-toggle:hover {
+    background: var(--cfl-bg-hover);
+    color: #0a58ca;
+}
+
+.config-file-list .config-file-list-toggle:focus-visible {
+    outline: 0;
+    box-shadow: 0 0 0 0.2rem rgba(13, 110, 253, 0.25);
+}
+
+.config-file-list .config-file-list-toggle .bi {
+    font-size: 0.875rem;
+    transition: transform 0.2s ease;
+}
+
+/* Expandable section: animate height with grid 0fr → 1fr */
+.config-file-list-expandable {
+    display: grid;
+    grid-template-rows: 0fr;
+    transition: grid-template-rows 0.25s ease-out;
+}
+
+.config-file-list-expandable.expanded {
+    grid-template-rows: 1fr;
+}
+
+.config-file-list-expandable-inner {
+    min-height: 0;
+    overflow: hidden;
+}
+
+.config-file-list-expandable-inner ul {
+    padding-top: 0.15rem;
+}
@@ -0,0 +1,30 @@
+@namespace DnsmasqWebUI.Components.Dnsmasq
+@using DnsmasqWebUI.Models.Dnsmasq
+@using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig
+
+<li>
+    @if (Entry.IsManaged)
+    {
+        <StatusBadge Kind="StatusBadgeKind.Managed" Text="managed" Class="me-1" />
+    }
+    else
+    {
+        <StatusBadge Kind="StatusBadgeKind.SourceMain" Text="@(Entry.Source.ToString().ToLowerInvariant())" Class="me-1" />
+    }
+    @Entry.Path
+    @{
+        var isMain = string.Equals(Entry.Path, Status.MainConfigPath, StringComparison.Ordinal);
+        var isManaged = Entry.IsManaged;
+        var exists = isMain ? Status.MainConfigPathExists : (isManaged ? Status.ManagedFilePathExists : (bool?)null);
+    }
+    @if (exists == true) { <text> ✓</text> }
+    @if (exists == false) { <text> @(isManaged ? "(not created yet)" : "(missing)")</text> }
+</li>
+
+@code {
+    [Parameter, EditorRequired]
+    public DnsmasqConfigSetEntry Entry { get; set; } = null!;
+
+    [Parameter, EditorRequired]
+    public DnsmasqServiceStatus Status { get; set; } = null!;
+}
@@ -1,24 +0,0 @@
-@namespace DnsmasqWebUI.Components.Dnsmasq.EffectiveConfig.CustomDisplays
-@using DnsmasqWebUI.Models.Dnsmasq
-
-@* Reusable value-only display for boolean/flag options. Edit mode: checkbox (unless readonly); View: "Enabled" / "Disabled". *@
-@if (DisplayMode == EffectiveConfigDisplayMode.Edit && Descriptor.GetSource()?.IsReadOnly != true)
-{
-    var isSet = Descriptor.GetValue() is bool b && b;
-    <input type="checkbox" class="form-check-input" checked="@isSet" @onchange="OnCheckedChange" />
-}
-else
-{
-    @(Descriptor.GetValue() is bool isSet && isSet ? "Enabled" : "Disabled")
-}
-
-@code {
-    [Parameter] public EffectiveConfigFieldDescriptor Descriptor { get; set; } = null!;
-    [CascadingParameter] public EffectiveConfigDisplayMode DisplayMode { get; set; } = EffectiveConfigDisplayMode.View;
-    [Parameter] public EventCallback<bool> CheckedChanged { get; set; }
-
-    private async Task OnCheckedChange(ChangeEventArgs e)
-    {
-        await CheckedChanged.InvokeAsync(e.Value is true);
-    }
-}
@@ -1,27 +0,0 @@
-@namespace DnsmasqWebUI.Components.Dnsmasq.EffectiveConfig.CustomDisplays
-@using DnsmasqWebUI.Models.Dnsmasq
-
-@* Value-only display for the port option. Edit mode: number input (unless readonly); View: text with "(default DNS port)". *@
-@if (DisplayMode == EffectiveConfigDisplayMode.Edit && Descriptor.GetSource()?.IsReadOnly != true)
-{
-    var port = Descriptor.GetValue() is int p ? p : 53;
-    <input type="number" class="form-control form-control-sm" style="max-width: 6rem;" min="1" max="65535" value="@port" @oninput="OnPortInput" />
-}
-else
-{
-    @(Descriptor.GetValue() is int port ? $"{port} (default DNS port)" : "(not set)")
-}
-
-@code {
-    [Parameter] public EffectiveConfigFieldDescriptor Descriptor { get; set; } = null!;
-    [CascadingParameter] public EffectiveConfigDisplayMode DisplayMode { get; set; } = EffectiveConfigDisplayMode.View;
-    [Parameter] public EventCallback<int?> PortChanged { get; set; }
-
-    private async Task OnPortInput(ChangeEventArgs e)
-    {
-        if (int.TryParse(e.Value?.ToString(), out var port) && port >= 1 && port <= 65535)
-            await PortChanged.InvokeAsync(port);
-        else
-            await PortChanged.InvokeAsync(null);
-    }
-}
@@ -1,60 +0,0 @@
-@namespace DnsmasqWebUI.Components.Dnsmasq.EffectiveConfig
-@using DnsmasqWebUI.Models.Dnsmasq
-@using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig
-@using DnsmasqWebUI.Models.Config
-@using DnsmasqWebUI.Infrastructure.Helpers.Config
-@using DnsmasqWebUI.Infrastructure.Services.Abstractions
-@inject IEffectiveConfigRenderFragmentRegistry RenderFragmentRegistry
-
-@* Custom fragment renders only the value; we keep the row shell (label + value slot + badge) here for consistency. *@
-@if (_customFragment is { } fragment)
-{
-    var labelTooltip = DnsmasqOptionTooltips.Get(Descriptor.OptionName);
-    <li class="ec-field" title="@(Descriptor.GetSource()?.GetReadOnlyTooltip())">
-        <span id="@_anchorId" class="ec-field-label @(_optionHelpKey != null ? "ec-field-label-help" : null)" title="@(labelTooltip ?? Descriptor.GetSource()?.GetReadOnlyTooltip())" @onclick="RaiseOptionHelpRequested" @onmouseleave="RaiseLabelMouseLeave"><strong>@Descriptor.OptionName:</strong></span>
-        <span class="ec-field-value">
-            @fragment(Descriptor)
-            @if (Descriptor.GetSource()?.IsReadOnly == true)
-            {
-                <span class="badge bg-secondary ec-badge-inline">readonly</span>
-            }
-        </span>
-    </li>
-}
-else if (Descriptor.IsMultiValue)
-{
-    var items = Descriptor.GetItems();
-    <EffectiveConfigMultiValueRow Label="@Descriptor.OptionName" Items="@items" LabelTooltip="@_labelTooltip" OptionHelpKey="@_optionHelpKey" OptionHelpAnchorId="@_anchorId" OnOptionHelpRequested="@OnOptionHelpRequested" />
-}
-else
-{
-    var value = Descriptor.GetValue();
-    var displayValue = value == null ? "(not set)" : (value is IReadOnlyList<string> list ? (list.Count == 0 ? "(none)" : string.Join(", ", list)) : value.ToString());
-    <EffectiveConfigOptionItem Label="@Descriptor.OptionName" DisplayValue="@(displayValue ?? "(not set)")" Source="@Descriptor.GetSource()" LabelTooltip="@_labelTooltip" OptionHelpKey="@_optionHelpKey" OptionHelpAnchorId="@_anchorId" OnOptionHelpRequested="@OnOptionHelpRequested" />
-}
-
-@code {
-    [Parameter] public EffectiveConfigFieldDescriptor Descriptor { get; set; } = null!;
-    [CascadingParameter] public EffectiveConfigDisplayMode DisplayMode { get; set; } = EffectiveConfigDisplayMode.View;
-    [Parameter] public EventCallback<ConfigOptionHelpRequestEventArgs> OnOptionHelpRequested { get; set; }
-
-    private readonly string _anchorId = "ec-help-" + Guid.NewGuid().ToString("N")[..8];
-    private RenderFragment<EffectiveConfigFieldDescriptor>? _customFragment;
-    private string? _labelTooltip;
-    private string? _optionHelpKey;
-
-    protected override void OnParametersSet()
-    {
-        _customFragment = RenderFragmentRegistry.GetDisplayFragment(Descriptor.SectionId, Descriptor.OptionName);
-        _labelTooltip = DnsmasqOptionTooltips.Get(Descriptor.OptionName);
-        _optionHelpKey = DnsmasqOptionTooltips.GetOptionHelpKey(Descriptor.OptionName);
-    }
-
-    private async Task RaiseOptionHelpRequested()
-    {
-        if (string.IsNullOrEmpty(_optionHelpKey)) return;
-        await OnOptionHelpRequested.InvokeAsync(new ConfigOptionHelpRequestEventArgs { HelpKey = _optionHelpKey, OptionLabel = Descriptor.OptionName, AnchorId = _anchorId });
-    }
-
-    private async Task RaiseLabelMouseLeave() => await OnOptionHelpRequested.InvokeAsync(new ConfigOptionHelpRequestEventArgs { AnchorId = _anchorId, IsLabelMouseLeave = true });
-}
@@ -1,15 +0,0 @@
-@namespace DnsmasqWebUI.Components.Dnsmasq.EffectiveConfig
-@using DnsmasqWebUI.Models.Dnsmasq
-
-<span class="ec-field-value-item" title="@(Source?.GetReadOnlyTooltip())">
-    @Value
-    @if (Source?.IsReadOnly == true)
-    {
-        <span class="badge bg-secondary ec-badge-inline">readonly</span>
-    }
-</span>
-
-@code {
-    [Parameter] public string Value { get; set; } = "";
-    [Parameter] public ConfigValueSource? Source { get; set; }
-}
@@ -1,72 +0,0 @@
-@namespace DnsmasqWebUI.Components.Dnsmasq.EffectiveConfig
-@using DnsmasqWebUI.Models.Dnsmasq
-@using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig
-
-<li class="ec-field">
-    <span id="@OptionHelpAnchorId" class="ec-field-label @(OptionHelpKey != null ? "ec-field-label-help" : null)" title="@LabelTooltip" @onclick="RaiseOptionHelpRequested" @onmouseleave="RaiseLabelMouseLeave"><strong>@Label:</strong></span>
-    @if (DisplayMode == EffectiveConfigDisplayMode.Edit)
-    {
-        <span class="ec-field-value ec-field-value-multi">
-            <textarea class="form-control form-control-sm" rows="@(Math.Max(2, (Items?.Count ?? 0) + 1))" @oninput="OnLinesInput" placeholder="One value per line">@_editLines</textarea>
-        </span>
-    }
-    else
-    {
-        <span class="ec-field-value ec-field-value-multi">
-            @if (Items?.Count > 0)
-            {
-                <ol class="ec-field-value-list">
-                    @foreach (var item in Items!)
-                    {
-                        <li><EffectiveConfigMultiValueItem Value="@item.Value" Source="@item.Source" /></li>
-                    }
-                </ol>
-            }
-            else
-            {
-                <span class="text-muted">(none)</span>
-            }
-        </span>
-    }
-</li>
-
-@code {
-    [Parameter] public string Label { get; set; } = "";
-    [Parameter] public IReadOnlyList<ValueWithSource>? Items { get; set; }
-    [Parameter] public EventCallback<IReadOnlyList<string>> ItemsChanged { get; set; }
-    [Parameter] public string? LabelTooltip { get; set; }
-    [Parameter] public string? OptionHelpKey { get; set; }
-    [Parameter] public string? OptionHelpAnchorId { get; set; }
-    [CascadingParameter] public EffectiveConfigDisplayMode DisplayMode { get; set; } = EffectiveConfigDisplayMode.View;
-    [Parameter] public EventCallback<ConfigOptionHelpRequestEventArgs> OnOptionHelpRequested { get; set; }
-
-    private string _editLines = "";
-
-    private async Task RaiseOptionHelpRequested()
-    {
-        if (string.IsNullOrEmpty(OptionHelpKey) || string.IsNullOrEmpty(OptionHelpAnchorId)) return;
-        await OnOptionHelpRequested.InvokeAsync(new ConfigOptionHelpRequestEventArgs { HelpKey = OptionHelpKey, OptionLabel = Label, AnchorId = OptionHelpAnchorId });
-    }
-
-    private async Task RaiseLabelMouseLeave()
-    {
-        if (string.IsNullOrEmpty(OptionHelpAnchorId)) return;
-        await OnOptionHelpRequested.InvokeAsync(new ConfigOptionHelpRequestEventArgs { AnchorId = OptionHelpAnchorId, IsLabelMouseLeave = true });
-    }
-
-    protected override void OnParametersSet()
-    {
-        if (Items != null && Items.Count > 0)
-            _editLines = string.Join("\n", Items.Select(i => i.Value));
-        else
-            _editLines = "";
-    }
-
-    private async Task OnLinesInput(ChangeEventArgs e)
-    {
-        var text = e.Value?.ToString() ?? "";
-        _editLines = text;
-        var lines = text.Split('\n', StringSplitOptions.RemoveEmptyEntries).Select(l => l.Trim()).Where(l => l.Length > 0).ToList();
-        await ItemsChanged.InvokeAsync(lines);
-    }
-}
@@ -1,55 +0,0 @@
-@namespace DnsmasqWebUI.Components.Dnsmasq.EffectiveConfig
-@using DnsmasqWebUI.Models.Dnsmasq
-@using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig
-
-<li class="ec-field" title="@(Source?.GetReadOnlyTooltip())">
-    <span id="@OptionHelpAnchorId" class="ec-field-label @(OptionHelpKey != null ? "ec-field-label-help" : null)" title="@(LabelTooltip ?? Source?.GetReadOnlyTooltip())" @onclick="RaiseOptionHelpRequested" @onmouseleave="RaiseLabelMouseLeave"><strong>@Label:</strong></span>
-    @if (DisplayMode == EffectiveConfigDisplayMode.Edit && Source?.IsReadOnly != true)
-    {
-        <span class="ec-field-value">
-            <input type="text" class="form-control form-control-sm" value="@DisplayValue" @oninput="OnValueInput" />
-        </span>
-    }
-    else
-    {
-        <span class="ec-field-value">
-            @DisplayValue
-            @if (Source?.IsReadOnly == true)
-            {
-                <span class="badge bg-secondary ec-badge-inline">readonly</span>
-            }
-        </span>
-    }
-</li>
-
-@code {
-    [Parameter] public string Label { get; set; } = "";
-    [Parameter] public string DisplayValue { get; set; } = "";
-    [Parameter] public ConfigValueSource? Source { get; set; }
-    /// <summary>Optional explainer shown on hover over the label (e.g. from DnsmasqOptionTooltips).</summary>
-    [Parameter] public string? LabelTooltip { get; set; }
-    [Parameter] public string? OptionHelpKey { get; set; }
-    [Parameter] public string? OptionHelpAnchorId { get; set; }
-    /// <summary>When Edit and not readonly: raised when the user changes the value. Not yet wired to save.</summary>
-    [Parameter] public EventCallback<string> DisplayValueChanged { get; set; }
-    [CascadingParameter] public EffectiveConfigDisplayMode DisplayMode { get; set; } = EffectiveConfigDisplayMode.View;
-    [Parameter] public EventCallback<ConfigOptionHelpRequestEventArgs> OnOptionHelpRequested { get; set; }
-
-    private async Task RaiseOptionHelpRequested()
-    {
-        if (string.IsNullOrEmpty(OptionHelpKey) || string.IsNullOrEmpty(OptionHelpAnchorId)) return;
-        await OnOptionHelpRequested.InvokeAsync(new ConfigOptionHelpRequestEventArgs { HelpKey = OptionHelpKey, OptionLabel = Label, AnchorId = OptionHelpAnchorId });
-    }
-
-    private async Task RaiseLabelMouseLeave()
-    {
-        if (string.IsNullOrEmpty(OptionHelpAnchorId)) return;
-        await OnOptionHelpRequested.InvokeAsync(new ConfigOptionHelpRequestEventArgs { AnchorId = OptionHelpAnchorId, IsLabelMouseLeave = true });
-    }
-
-    private async Task OnValueInput(ChangeEventArgs e)
-    {
-        var value = e.Value?.ToString() ?? "";
-        await DisplayValueChanged.InvokeAsync(value);
-    }
-}
@@ -1,144 +0,0 @@
-@namespace DnsmasqWebUI.Components.Dnsmasq.EffectiveConfig
-@using DnsmasqWebUI.Models.Dnsmasq
-@using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig
-@implements IAsyncDisposable
-
-@if (Status != null)
-{
-<div class="ec-container">
-    <ConfigOptionHelpModal HelpKey="@_optionHelpKey" AnchorId="@_optionHelpAnchorId" Visible="@_showOptionHelp" Title="@_optionHelpTitle"
-        OnClose="CloseOptionHelp" OnMouseEnterModal="CancelCloseTimerAsync" OnMouseLeaveModal="ScheduleCloseAsync" />
-    @if (ShowSearchBox)
-    {
-        <div class="ec-toolbar">
-            <input type="search" id="ec-search-input" class="form-control form-control-sm" placeholder="Search..." autocomplete="off"
-                   @bind="_searchTerm" @bind:event="oninput" @bind:after="StateHasChanged" />
-            <button type="button" class="btn btn-sm btn-outline-secondary" @onclick="CollapseAll" title="Collapse all sections" aria-label="Collapse all sections">
-                <i class="bi bi-arrows-collapse" aria-hidden="true"></i>
-            </button>
-        </div>
-    }
-    <div class="ec-sections small">
-        @{
-            var views = EffectiveConfigViews.GetViewsForContext(Context);
-            var descriptorsBySection = EffectiveConfigViews.GetDescriptorsBySection(Status, views);
-            var hasSearch = !string.IsNullOrWhiteSpace(_searchTerm);
-            var term = _searchTerm?.Trim() ?? "";
-        }
-        @foreach (var view in views)
-        {
-            if (!descriptorsBySection.TryGetValue(view.SectionId, out var contextDescriptors))
-                continue;
-            var sectionDescriptors = hasSearch
-                ? contextDescriptors.Where(d => DescriptorMatchesSearch(d, term)).ToList()
-                : contextDescriptors.ToList();
-            if (sectionDescriptors.Count == 0)
-                continue;
-            var isOpen = hasSearch ? true : IsOpen(view.SectionId);
-            <EffectiveConfigSectionPanel SectionId="@view.SectionId" Title="@view.Title" Descriptors="@sectionDescriptors" IsOpen="@isOpen" OnToggle="@OnSectionToggle" DisplayMode="@DisplayMode" OnOptionHelpRequested="@HandleOptionHelpRequested" />
-        }
-    </div>
-</div>
-}
-
-@code {
-    [Parameter] public DnsmasqServiceStatus? Status { get; set; }
-    [Parameter] public EffectiveConfigContext Context { get; set; } = EffectiveConfigContext.All;
-    [Parameter] public bool ShowSearchBox { get; set; } = true;
-    /// <summary>View = read-only; Edit = editable (future). Cascaded to field displays.</summary>
-    [Parameter] public EffectiveConfigDisplayMode DisplayMode { get; set; } = EffectiveConfigDisplayMode.View;
-
-    private string _searchTerm = "";
-    private HashSet<string> _openPanels = new();
-    private string? _optionHelpKey;
-    private string? _optionHelpAnchorId;
-    private string _optionHelpTitle = "Option help";
-    private bool _showOptionHelp;
-    private CancellationTokenSource? _closeCts;
-
-    private bool IsOpen(string id) => _openPanels.Contains(id);
-
-    private async Task HandleOptionHelpRequested(ConfigOptionHelpRequestEventArgs args)
-    {
-        if (args.IsLabelMouseLeave)
-        {
-            if (args.AnchorId == _optionHelpAnchorId)
-                ScheduleClose();
-            return;
-        }
-        _optionHelpKey = args.HelpKey;
-        _optionHelpTitle = args.OptionLabel;
-        _optionHelpAnchorId = args.AnchorId;
-        _showOptionHelp = true;
-        CancelCloseTimer();
-        await InvokeAsync(StateHasChanged);
-    }
-
-    private void CancelCloseTimer()
-    {
-        _closeCts?.Cancel();
-        _closeCts = null;
-    }
-
-    private Task CancelCloseTimerAsync() { CancelCloseTimer(); return Task.CompletedTask; }
-
-    private void ScheduleClose()
-    {
-        _closeCts?.Cancel();
-        _closeCts = new CancellationTokenSource();
-        var token = _closeCts.Token;
-        _ = Task.Run(async () =>
-        {
-            try
-            {
-                await Task.Delay(300, token);
-            }
-            catch (OperationCanceledException) { return; }
-            await InvokeAsync(() =>
-            {
-                if (token.IsCancellationRequested) return;
-                _showOptionHelp = false;
-                _closeCts = null;
-                StateHasChanged();
-            });
-        }, token);
-    }
-
-    private Task ScheduleCloseAsync() { ScheduleClose(); return Task.CompletedTask; }
-
-    private void CloseOptionHelp()
-    {
-        CancelCloseTimer();
-        _showOptionHelp = false;
-        StateHasChanged();
-    }
-
-    private void OnSectionToggle(string id)
-    {
-        if (_openPanels.Contains(id))
-            _openPanels.Remove(id);
-        else
-            _openPanels.Add(id);
-    }
-
-    private void CollapseAll()
-    {
-        _openPanels.Clear();
-        StateHasChanged();
-    }
-
-    private static bool DescriptorMatchesSearch(EffectiveConfigFieldDescriptor d, string term)
-    {
-        if (string.IsNullOrEmpty(term)) return true;
-        var searchable = (d.OptionName + " " + (DnsmasqOptionTooltips.Get(d.OptionName) ?? "")).Trim();
-        return searchable.Contains(term, StringComparison.OrdinalIgnoreCase);
-    }
-
-    public ValueTask DisposeAsync()
-    {
-        _closeCts?.Cancel();
-        _closeCts?.Dispose();
-        _closeCts = null;
-        return ValueTask.CompletedTask;
-    }
-}
@@ -1,4 +1,4 @@
-@namespace DnsmasqWebUI.Components.Dnsmasq
+@namespace DnsmasqWebUI.Components.Dnsmasq.Logs
@* Renders a pre element for logs. Once Freeze is true, stops re-rendering so Blazor does not overwrite JS-owned content. *@
 <pre id="@Id" class="pre-block mb-0" style="max-height: 24rem;">@Placeholder</pre>

@@ -1,4 +1,4 @@
-@namespace DnsmasqWebUI.Components.Dnsmasq
+@namespace DnsmasqWebUI.Components.Dnsmasq.Logs
@* Recent logs — live view via SignalR from LogsCommand; client polls at interval, server pushes deltas *@
@using DnsmasqWebUI.Models.Logs
@using Microsoft.AspNetCore.SignalR.Client
@@ -27,14 +27,14 @@
        <LogsPreView Id="dnsmasq-logs-pre" Placeholder="@_initialPlaceholder" Freeze="_logsContentReceived" />
    }
    <div class="mt-2 d-flex flex-wrap gap-2 align-items-center">
-        <button class="btn btn-primary btn-sm" @onclick="RequestRefreshAsync" disabled="@_refreshing">Refresh</button>
+        <button class="btn btn-primary btn-sm" @onclick="RequestRefreshAsync" disabled="@_refreshing"><i class="bi bi-arrow-repeat me-1" aria-hidden="true"></i>Refresh</button>
        @if (_status.LogsPath != null)
        {
-            <a href="api/status/logs/download" download="dnsmasq.log" class="btn btn-primary btn-sm">Download logs</a>
+            <a href="api/status/logs/download" download="dnsmasq.log" class="btn btn-primary btn-sm"><i class="bi bi-download me-1" aria-hidden="true"></i>Download logs</a>
        }
        else
        {
-            <button type="button" class="btn btn-primary btn-sm" disabled title="No log file path detected. Set log-facility=/path/to/file in your dnsmasq config to enable download.">Download logs</button>
+            <button type="button" class="btn btn-primary btn-sm" disabled title="No log file path detected. Set log-facility=/path/to/file in your dnsmasq config to enable download."><i class="bi bi-download me-1" aria-hidden="true"></i>Download logs</button>
        }
    </div>
 }
@@ -1,10 +1,11 @@
+using DnsmasqWebUI.Extensions.Interop;
 using DnsmasqWebUI.Models.Dnsmasq;
 using DnsmasqWebUI.Models.Logs;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.SignalR.Client;
 using Microsoft.JSInterop;

-namespace DnsmasqWebUI.Components.Dnsmasq;
+namespace DnsmasqWebUI.Components.Dnsmasq.Logs;

 /// <summary>
 /// Recent logs block: connects to LogsHub, polls at interval via RequestDnsmasqLogs,
@@ -123,19 +124,13 @@ public partial class LogsSection : IAsyncDisposable
            await InvokeAsync(async () =>
            {
                if (_logsJs == null) return;
-                try
-                {
-                    if (payload.Mode == "replace")
-                        await _logsJs.InvokeVoidAsync("replaceLogs", LogsPreId, payload.Content, LogsOptions);
-                    else
-                        await _logsJs.InvokeVoidAsync("appendLogs", LogsPreId, payload.Content, LogsOptions);
-                    _logsContentReceived = true;
-                    SetJustUpdated();
-                    StateHasChanged();
-                }
-                catch (JSDisconnectedException) { /* Circuit disconnected; ignore */ }
-                catch (InvalidOperationException) { /* Prerender or circuit disposed; ignore */ }
-                catch (JSException) { /* JS error; ignore */ }
+                if (payload.Mode == "replace")
+                    await _logsJs.InvokeVoidAsyncSafe("replaceLogs", LogsPreId, payload.Content, LogsOptions);
+                else
+                    await _logsJs.InvokeVoidAsyncSafe("appendLogs", LogsPreId, payload.Content, LogsOptions);
+                _logsContentReceived = true;
+                SetJustUpdated();
+                StateHasChanged();
            });
        }
        catch (ObjectDisposedException) { /* Component disposed; ignore */ }
@@ -169,13 +164,7 @@ public partial class LogsSection : IAsyncDisposable
            await _hubConnection.DisposeAsync();
            _hubConnection = null;
        }
-        if (_logsJs != null)
-        {
-            try { await _logsJs.DisposeAsync(); }
-            catch (InvalidOperationException ex) { Logger.LogDebug(ex, "LogsSection: DisposeAsync skipped (prerender)"); }
-            catch (JSDisconnectedException ex) { Logger.LogDebug(ex, "LogsSection: DisposeAsync skipped (circuit disconnected)"); }
-            catch (JSException ex) { Logger.LogDebug(ex, "LogsSection: DisposeAsync failed"); }
-            _logsJs = null;
-        }
+        await _logsJs.DisposeAsyncSafe();
+        _logsJs = null;
    }
 }
@@ -1,4 +1,4 @@
-@namespace DnsmasqWebUI.Components.Dnsmasq
+@namespace DnsmasqWebUI.Components.Dnsmasq.Status
@* Service status — output of StatusShowCommand; only this component re-renders on its timer *@
@if (_status != null && _status.StatusShowConfigured)
 {
@@ -24,7 +24,21 @@
    {
        <pre class="pre-block mb-0" style="max-height: 22rem;">@_status.StatusShowOutput</pre>
    }
-    <div class="mt-2">
-        <button class="btn btn-primary btn-sm" @onclick="RefreshAsync" disabled="@_refreshing">Refresh</button>
+    <div class="mt-2 d-flex align-items-center gap-2 flex-wrap">
+        <button class="btn btn-primary btn-sm" @onclick="RefreshAsync" disabled="@_refreshing"><i class="bi bi-arrow-repeat me-1" aria-hidden="true"></i>Refresh</button>
+        @if (ReloadCommandConfigured && OnReloadRequested.HasDelegate)
+        {
+            <button class="btn btn-primary btn-sm" @onclick="InvokeReloadAsync" disabled="@IsReloading" title="Reload dnsmasq config (e.g. SIGHUP)">
+                @if (IsReloading)
+                {
+                    <span class="spinner-border spinner-border-sm me-1" role="status" aria-hidden="true"></span>
+                }
+                else
+                {
+                    <i class="bi bi-arrow-repeat me-1" aria-hidden="true"></i>
+                }
+                Reload
+            </button>
+        }
    </div>
 }
@@ -2,7 +2,7 @@ using DnsmasqWebUI.Infrastructure.Client.Abstractions;
 using DnsmasqWebUI.Models.Dnsmasq;
 using Microsoft.AspNetCore.Components;

-namespace DnsmasqWebUI.Components.Dnsmasq;
+namespace DnsmasqWebUI.Components.Dnsmasq.Status;

 /// <summary>
 /// Service status block: polls StatusShowCommand output at its own interval and re-renders only itself.
@@ -19,6 +19,11 @@ public partial class StatusSection : IDisposable

    [Parameter] public bool IsReloading { get; set; }

+    /// <summary>When set and reload is configured, show a "Reload config" button next to Refresh.</summary>
+    [Parameter] public EventCallback OnReloadRequested { get; set; }
+
+    [Parameter] public bool ReloadCommandConfigured { get; set; }
+
    [Parameter] public EventCallback OnOpenSettings { get; set; }

    [Inject] private IStatusClient StatusClient { get; set; } = null!;
@@ -55,6 +60,8 @@ public partial class StatusSection : IDisposable

    private static readonly TimeSpan MinUpdatingDuration = TimeSpan.FromSeconds(1);

+    private Task InvokeReloadAsync() => OnReloadRequested.InvokeAsync();
+
    private async Task RefreshAsync()
    {
        var started = DateTime.UtcNow;
@@ -0,0 +1,27 @@
+@namespace DnsmasqWebUI.Components.EffectiveConfig
+@inject IJSRuntime JSRuntime
+
+<div class="d-flex align-items-center gap-1 @CssClass">
+    <code class="flex-grow-1 text-break @CodeCssClass">@Text</code>
+    <button type="button" class="btn btn-sm btn-outline-secondary py-0" @onclick="CopyAsync" title="@CopyTitle"><i class="bi bi-clipboard me-1" aria-hidden="true"></i>Copy</button>
+</div>
+
+@code {
+    [Parameter] public string Text { get; set; } = "";
+    [Parameter] public string? CssClass { get; set; }
+    [Parameter] public string? CodeCssClass { get; set; }
+    [Parameter] public string CopyTitle { get; set; } = "Copy";
+
+    private async Task CopyAsync()
+    {
+        if (string.IsNullOrEmpty(Text)) return;
+        try
+        {
+            await JSRuntime.InvokeVoidAsync("copyToClipboard", Text);
+        }
+        catch
+        {
+            // Clipboard not available or failed
+        }
+    }
+}
@@ -0,0 +1,39 @@
+using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components.Web;
+using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig;
+using DnsmasqWebUI.Infrastructure.Services.EffectiveConfig.Abstractions;
+
+namespace DnsmasqWebUI.Components.EffectiveConfig;
+
+/// <summary>
+/// Base for effective-config custom value displays. Provides shared parameters,
+/// <see cref="NotifyValueChanged"/>, and <see cref="GetEffectiveDisplayValue"/> so pending changes are shown before save.
+/// </summary>
+public abstract class EffectiveConfigValueDisplayBase : ComponentBase
+{
+    [Parameter]
+    public EffectiveConfigFieldDescriptor Descriptor { get; set; } = null!;
+
+    [CascadingParameter]
+    public bool IsActiveEditor { get; set; }
+
+    [CascadingParameter]
+    public EventCallback<FocusEventArgs> OnCommitRequested { get; set; }
+
+    [Parameter]
+    public EventCallback<object?> ValueChanged { get; set; }
+
+    [CascadingParameter]
+    public IEffectiveConfigEditSession? Session { get; set; }
+
+    protected Task NotifyValueChanged(object? value) => ValueChanged.InvokeAsync(value);
+
+    /// <summary>Returns the value to display: pending change NewValue if this field has one, else descriptor value (not yet written to disk).</summary>
+    protected object? GetEffectiveDisplayValue()
+    {
+        var pending = Session?.PendingChanges.FirstOrDefault(c =>
+            string.Equals(c.SectionId, Descriptor.SectionId, StringComparison.OrdinalIgnoreCase) &&
+            string.Equals(c.OptionName, Descriptor.OptionName, StringComparison.OrdinalIgnoreCase));
+        return pending != null ? pending.NewValue : Descriptor.GetValue();
+    }
+}
@@ -0,0 +1,47 @@
+@namespace DnsmasqWebUI.Components.EffectiveConfig
+@using DnsmasqWebUI.Models.Dnsmasq
+@using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig
+@using DnsmasqWebUI.Infrastructure.Helpers.Config
+@inject IEffectiveConfigRenderFragmentRegistry RenderFragmentRegistry
+
+<div class="ec-sections small">
+    @{
+        var views = EffectiveConfigViews.GetViewsForContext(Context);
+        var descriptorsBySection = EffectiveConfigViews.GetDescriptorsBySection(Status, views, RenderFragmentRegistry);
+        var hasSearch = !string.IsNullOrWhiteSpace(SearchTerm);
+        var term = SearchTerm?.Trim() ?? "";
+    }
+    @foreach (var view in views)
+    {
+        if (!descriptorsBySection.TryGetValue(view.SectionId, out var contextDescriptors))
+            continue;
+        var sectionDescriptors = hasSearch
+            ? contextDescriptors.Where(d => DescriptorMatchesSearch(d, term)).ToList()
+            : contextDescriptors.ToList();
+        if (sectionDescriptors.Count == 0)
+            continue;
+        var isOpen = hasSearch || IsSectionOpen(view.SectionId);
+        <EffectiveConfigSectionPanel SectionId="@view.SectionId" Title="@view.Title" Descriptors="@sectionDescriptors" IsOpen="@isOpen" OnToggle="@OnSectionToggle"
+            DisplayMode="@( IsEditMode ? EffectiveConfigDisplayMode.Edit : EffectiveConfigDisplayMode.View )"
+            IsEditMode="@IsEditMode" ActiveFieldKey="@ActiveFieldKey" />
+    }
+</div>
+
+@code {
+    [Parameter] public DnsmasqServiceStatus? Status { get; set; }
+    [Parameter] public EffectiveConfigContext Context { get; set; } = EffectiveConfigContext.All;
+    [Parameter] public string SearchTerm { get; set; } = "";
+    [Parameter] public HashSet<string> OpenSectionIds { get; set; } = new();
+    [Parameter] public EventCallback<string> OnSectionToggle { get; set; }
+    [Parameter] public bool IsEditMode { get; set; }
+    [Parameter] public string? ActiveFieldKey { get; set; }
+
+    private bool IsSectionOpen(string id) => OpenSectionIds.Contains(id);
+
+    private static bool DescriptorMatchesSearch(EffectiveConfigFieldDescriptor d, string term)
+    {
+        if (string.IsNullOrEmpty(term)) return true;
+        var searchable = (d.OptionName + " " + (DnsmasqOptionTooltips.Get(d.OptionName) ?? "")).Trim();
+        return searchable.Contains(term, StringComparison.OrdinalIgnoreCase);
+    }
+}
@@ -0,0 +1,233 @@
+@namespace DnsmasqWebUI.Components.EffectiveConfig
+@using DnsmasqWebUI.Models.Dnsmasq
+@using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig
+@using DnsmasqWebUI.Infrastructure.Helpers.Config
+@using DnsmasqWebUI.Infrastructure.Services.EffectiveConfig.Abstractions
+@using DnsmasqWebUI.Infrastructure.Services.EffectiveConfig.Validation
+@inject IEffectiveConfigEditSession Session
+@inject IJSRuntime JSRuntime
+
+@if (Status != null)
+{
+<div class="ec-container" @onclick="DeactivateActiveFieldIfClicked">
+    <OptionHelpController @ref="_optionHelpControllerRef" Visible="@_showOptionHelp" HelpKey="@_optionHelpKey" AnchorId="@_optionHelpAnchorId" Title="@_optionHelpTitle" OnCloseRequested="CloseOptionHelp" />
+    <ReadonlyPopoverController @ref="_readonlyPopoverControllerRef" Visible="@_showReadonlyPopover" AnchorId="@_readonlyPopoverAnchorId" Source="@_readonlyPopoverSource" OptionName="@(_readonlyPopoverOptionName ?? "")" Value="@_readonlyPopoverValue" ManagedFilePath="@(Status?.ManagedFilePath)" OnCloseRequested="CloseReadonlyPopover" />
+    @{
+        var _sectionViews = EffectiveConfigViews.GetViewsForContext(Context);
+        var _allSectionsExpanded = _sectionViews.Count > 0 && _sectionViews.All(v => _openPanels.Contains(v.SectionId));
+    }
+    <EffectiveConfigToolbar ShowSearchBox="@ShowSearchBox" SearchTerm="@_searchTerm" SearchTermChanged="@OnSearchTermChanged"
+        IsEditMode="@Session.IsEditMode" PendingChangesCount="@Session.PendingChanges.Count"
+        ValidationSummary="@Session.GetValidationSummary()"
+        AllSectionsExpanded="@_allSectionsExpanded"
+        OnExpandAll="ExpandAll" OnCollapseAll="CollapseAll" OnEnterEditMode="EnterEditMode" OnExitEditModeWithConfirm="ExitEditModeWithConfirmAsync" OnOpenSaveModal="OpenSaveModal" />
+    <CascadingValue Value="@Session">
+    <CascadingValue Value="@_uiContext">
+        <EffectiveConfigPanels Status="@Status" Context="@Context" SearchTerm="@_searchTerm" OpenSectionIds="@_openPanels"
+            OnSectionToggle="OnSectionToggle" IsEditMode="@Session.IsEditMode" ActiveFieldKey="@Session.ActiveFieldKey" />
+    </CascadingValue>
+    </CascadingValue>
+    <EffectiveConfigSaveFlow ShowModal="@_showSaveModal" PendingChanges="@Session.PendingChanges" Status="@Status" Session="@Session"
+        OnClose="CloseSaveModal" OnRevertedNotify="OnRevertedFromSaveModal" OnSaveCompleted="OnSaveCompleted" OnContinueEditingAfterSavedFailure="ContinueEditingAfterSavedFailureAsync" OnCloseAndEndEdit="CloseSaveModalAndEndEdit" />
+</div>
+}
+
+@code {
+    [Parameter] public DnsmasqServiceStatus? Status { get; set; }
+    [Parameter] public EffectiveConfigContext Context { get; set; } = EffectiveConfigContext.All;
+    [Parameter] public bool ShowSearchBox { get; set; } = true;
+    [Parameter] public EventCallback OnSaveCompleted { get; set; }
+
+    private string _searchTerm = "";
+    private HashSet<string> _openPanels = new();
+    private bool _showSaveModal;
+
+    private string? _optionHelpKey;
+    private string? _optionHelpAnchorId;
+    private string _optionHelpTitle = "Option help";
+    private bool _showOptionHelp;
+    private OptionHelpController? _optionHelpControllerRef;
+
+    private bool _showReadonlyPopover;
+    private ReadonlyPopoverController? _readonlyPopoverControllerRef;
+    private string? _readonlyPopoverAnchorId;
+    private ConfigValueSource? _readonlyPopoverSource;
+    private string? _readonlyPopoverOptionName;
+    private object? _readonlyPopoverValue;
+
+    private EffectiveConfigUiContext? _uiContext;
+
+    protected override void OnInitialized()
+    {
+        _uiContext = new EffectiveConfigUiContext
+        {
+            RequestOptionHelpAsync = HandleOptionHelpRequested,
+            RequestReadonlyPopoverAsync = HandleReadonlyBadgeClicked,
+            ScheduleReadonlyPopoverCloseAsync = () =>
+            {
+                _readonlyPopoverControllerRef?.ScheduleCloseFromBadgeLeave();
+                return Task.CompletedTask;
+            },
+            ActivateFieldAsync = fieldKey => { ActivateField(fieldKey); return Task.CompletedTask; },
+            DeactivateFieldAsync = () => { Session.DeactivateField(); return InvokeAsync(StateHasChanged); },
+            CommitFieldAsync = args => { HandleFieldEditCommitted(args); return Task.CompletedTask; },
+            RevertFieldAsync = (sectionId, optionName) => { Session.RevertChange(sectionId, optionName); RunCrossOptionEvaluator(); return InvokeAsync(StateHasChanged); }
+        };
+    }
+
+    private async Task OnSearchTermChanged(string value)
+    {
+        _searchTerm = value ?? "";
+        await InvokeAsync(StateHasChanged);
+    }
+
+    private void CloseOptionHelp()
+    {
+        _showOptionHelp = false;
+        StateHasChanged();
+    }
+
+    private async Task HandleOptionHelpRequested(ConfigOptionHelpRequestEventArgs args)
+    {
+        if (args.IsLabelMouseLeave)
+        {
+            if (args.AnchorId == _optionHelpAnchorId)
+                _optionHelpControllerRef?.ScheduleCloseFromLabelLeave();
+            await InvokeAsync(StateHasChanged);
+            return;
+        }
+        _optionHelpControllerRef?.CancelCloseFromLabelEnter();
+        _optionHelpKey = args.HelpKey;
+        _optionHelpTitle = args.OptionLabel;
+        _optionHelpAnchorId = args.AnchorId;
+        _showOptionHelp = true;
+        await InvokeAsync(StateHasChanged);
+    }
+
+    private void CloseReadonlyPopover()
+    {
+        _showReadonlyPopover = false;
+        StateHasChanged();
+    }
+
+    private async Task HandleReadonlyBadgeClicked(ReadonlyBadgeClickedEventArgs args)
+    {
+        _readonlyPopoverControllerRef?.CancelCloseFromBadgeEnter();
+        _readonlyPopoverAnchorId = args.AnchorId;
+        _readonlyPopoverSource = args.Source;
+        _readonlyPopoverOptionName = args.OptionName;
+        _readonlyPopoverValue = args.Value;
+        _showReadonlyPopover = true;
+        await InvokeAsync(StateHasChanged);
+    }
+
+    private void OnSectionToggle(string id)
+    {
+        if (_openPanels.Contains(id))
+            _openPanels.Remove(id);
+        else
+            _openPanels.Add(id);
+        StateHasChanged();
+    }
+
+    private void ExpandAll()
+    {
+        foreach (var view in EffectiveConfigViews.GetViewsForContext(Context))
+            _openPanels.Add(view.SectionId);
+        StateHasChanged();
+    }
+
+    private void CollapseAll()
+    {
+        _openPanels.Clear();
+        StateHasChanged();
+    }
+
+    private void EnterEditMode()
+    {
+        Session.EnterEditMode();
+        StateHasChanged();
+    }
+
+    private async Task ExitEditModeWithConfirmAsync()
+    {
+        if (Session.PendingChanges.Count > 0)
+        {
+            var module = await JSRuntime.InvokeAsync<IJSObjectReference>("import", "./js/dialog.js");
+            try
+            {
+                var confirmed = await module.InvokeAsync<bool>("confirmMessage", "Discard unsaved changes and exit edit mode?");
+                if (!confirmed) return;
+            }
+            finally
+            {
+                await module.DisposeAsync();
+            }
+        }
+        Session.ExitEditModeDiscard();
+        StateHasChanged();
+    }
+
+    private void DeactivateActiveFieldIfClicked()
+    {
+        if (Session.IsEditMode && Session.ActiveFieldKey != null)
+        {
+            Session.DeactivateField();
+            StateHasChanged();
+        }
+    }
+
+    private void ActivateField(string fieldKey)
+    {
+        Session.ActivateField(fieldKey);
+        StateHasChanged();
+    }
+
+    private void HandleFieldEditCommitted(EffectiveConfigEditCommittedArgs args)
+    {
+        Session.TrackCommit(args);
+        RunCrossOptionEvaluator();
+        StateHasChanged();
+    }
+
+    private void RunCrossOptionEvaluator()
+    {
+        var issues = EffectiveConfigCrossOptionEvaluator.Evaluate(Status, Session.PendingChanges);
+        Session.SetCrossOptionIssues(issues);
+    }
+
+    private void OnRevertedFromSaveModal()
+    {
+        RunCrossOptionEvaluator();
+        StateHasChanged();
+    }
+
+    private void OpenSaveModal()
+    {
+        if (Session.PendingChanges.Count == 0) return;
+        _showSaveModal = true;
+        StateHasChanged();
+    }
+
+    private void CloseSaveModal()
+    {
+        _showSaveModal = false;
+        StateHasChanged();
+    }
+
+    private async Task ContinueEditingAfterSavedFailureAsync()
+    {
+        _showSaveModal = false;
+        Session.ExitEditModeDiscard();
+        await OnSaveCompleted.InvokeAsync();
+        Session.EnterEditMode();
+        StateHasChanged();
+    }
+
+    private void CloseSaveModalAndEndEdit()
+    {
+        _showSaveModal = false;
+        Session.ExitEditModeDiscard();
+        StateHasChanged();
+    }
+}
@@ -13,16 +13,37 @@
    overflow: visible;
 }

-.ec-toolbar {
+/* Toolbar: single row, search left and actions right. Use ::deep so styles apply to EffectiveConfigToolbar (child) markup. */
+::deep .ec-toolbar {
    display: flex;
+    flex-wrap: nowrap;
    align-items: center;
    gap: 0.5rem;
    margin-bottom: 0.75rem;
+    min-width: 0;
 }

-.ec-toolbar input[type="search"] {
-    flex: 1;
+::deep .ec-toolbar-search {
+    flex: 1 1 auto;
    min-width: 0;
+    max-width: 24rem;
+}
+
+::deep .ec-toolbar-actions {
+    display: flex;
+    flex-wrap: nowrap;
+    flex-shrink: 0;
+    align-items: center;
+    gap: 0.5rem;
+    margin-left: auto;
+}
+
+::deep .ec-toolbar-changes-link {
+    cursor: pointer;
+}
+
+::deep .ec-toolbar-changes-link:hover {
+    text-decoration: underline;
 }

 .ec-sections {
@@ -104,6 +125,22 @@
    opacity: 1;
 }

+/* Animated expand/collapse: grid 0fr → 1fr */
+::deep .ec-section-collapse {
+    display: grid;
+    grid-template-rows: 0fr;
+    transition: grid-template-rows 0.25s ease-out;
+}
+
+::deep .ec-section-collapse-open {
+    grid-template-rows: 1fr;
+}
+
+::deep .ec-section-collapse-inner {
+    min-height: 0;
+    overflow: hidden;
+}
+
 ::deep .ec-section-body {
    padding: 0.25rem 1rem 0.5rem 1rem;
    padding-left: 1rem;
@@ -156,10 +193,40 @@
 }

 ::deep .ec-field-value {
+    display: flex;
+    flex-wrap: wrap;
+    align-items: center;
    flex: 1 1 auto;
    min-width: 0;
    overflow-wrap: break-word;
    word-break: break-word;
+    gap: 0.25rem;
+}
+
+/* When a field is active: value + badges in one block so any click inside (checkbox, input, ok/cancel) doesn't deactivate */
+::deep .ec-field-value-when-editing {
+    display: inline-flex;
+    flex-wrap: wrap;
+    align-items: center;
+    gap: 0.25rem;
+    min-width: 0;
+    max-width: 100%;
+}
+
+/* Edit wrapper (checkbox/input) shrinks to content */
+::deep .ec-field-edit-wrapper {
+    flex: 0 1 auto;
+    display: inline-flex;
+    align-items: center;
+    min-width: 0;
+    max-width: 100%;
+}
+
+/* Input/select in value area can shrink so the editable badge stays on the same line */
+::deep .ec-field-value > .form-control,
+::deep .ec-field-value > .form-select {
+    flex: 1 1 auto;
+    min-width: 0;
 }

 /* Multi-value: full width below label, indented ordered list. min-width: 0 so flex doesn't prevent wrapping. */
@@ -172,6 +239,11 @@
    word-break: break-word;
 }

+/* Row-level ok/cancel (and revert) for multi-value: right-align on the row below the list */
+::deep .ec-field .ec-field-value-multi + .status-badge-inline {
+    margin-left: auto;
+}
+
 ::deep .ec-field-value-list {
    margin: 0;
    padding-left: 1.25rem;
@@ -201,18 +273,27 @@
    margin-right: 0.25rem;
 }

-/* Badge: vertically centered, inline with value so when it wraps it stays part of the value flow */
-::deep .ec-field .badge,
-::deep .ec-field-value-item .badge {
+/* StatusBadge inside field rows: alignment; spacing comes from StatusBadge .status-badge-inline */
+::deep .ec-field .status-badge,
+::deep .ec-field-value-item .status-badge {
    display: inline-flex;
    align-items: center;
    line-height: 1;
 }

-/* Inline badge (inside value): gap from text; when it wraps to own line the margin gives a subtle indent */
-::deep .ec-badge-inline {
-    margin-left: 0.35rem;
+/* Only when field is in edit mode: push ok/cancel/revert to end and allow them to wrap first on narrow widths */
+::deep .ec-field-value-when-editing > .status-badge-inline {
+    flex: 0 0 auto;
    white-space: nowrap;
+    margin-left: auto;
+}
+
+@media (max-width: 991.98px) {
+    ::deep .ec-field-value-when-editing > .status-badge-inline {
+        flex-basis: 100%;
+        margin-left: 0;
+        margin-top: 0.15rem;
+    }
 }

@media (max-width: 767.98px) {
@@ -1,4 +1,4 @@
-@namespace DnsmasqWebUI.Components.Dnsmasq.EffectiveConfig
+@namespace DnsmasqWebUI.Components.EffectiveConfig
@using DnsmasqWebUI.Models.Dnsmasq
@using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig

@@ -8,14 +8,18 @@
            <span class="ec-section-title fw-bold">@Title</span>
            <i class="bi @(IsOpen ? "bi-chevron-down" : "bi-chevron-right") ec-section-chevron" aria-hidden="true"></i>
        </button>
-        <div class="collapse @(IsOpen ? "show" : "")">
-            <div class="ec-section-body">
+        <div class="ec-section-collapse @(IsOpen ? "ec-section-collapse-open" : "")">
+            <div class="ec-section-collapse-inner">
+                <div class="ec-section-body">
                <ul class="list-unstyled mb-0">
                    @foreach (var f in Descriptors)
                    {
-                        <EffectiveConfigFieldDisplay Descriptor="@f" OnOptionHelpRequested="@OnOptionHelpRequested" />
+                        var fieldKey = $"{SectionId}:{f.OptionName}";
+                        <EffectiveConfigFieldDisplay Descriptor="@f" FieldKey="@fieldKey"
+                            IsEditMode="@IsEditMode" IsActive="@(ActiveFieldKey == fieldKey)" />
                    }
                </ul>
+                </div>
            </div>
        </div>
    </div>
@@ -27,10 +31,10 @@
    [Parameter] public IReadOnlyList<EffectiveConfigFieldDescriptor> Descriptors { get; set; } = null!;
    [Parameter] public bool IsOpen { get; set; }
    [Parameter] public EventCallback<string> OnToggle { get; set; }
-    /// <summary>Raised when user requests option help (click or mouse leave from label). Passed through from Section.</summary>
-    [Parameter] public EventCallback<ConfigOptionHelpRequestEventArgs> OnOptionHelpRequested { get; set; }
-    /// <summary>Cascaded from EffectiveConfigSection. View = read-only; Edit = editable (future).</summary>
+    /// <summary>Cascaded from EffectiveConfigSection. View = read-only; Edit = editable.</summary>
    [Parameter] public EffectiveConfigDisplayMode DisplayMode { get; set; } = EffectiveConfigDisplayMode.View;
+    [Parameter] public bool IsEditMode { get; set; }
+    [Parameter] public string? ActiveFieldKey { get; set; }

    private async Task ToggleSection() => await OnToggle.InvokeAsync(SectionId);
 }
@@ -0,0 +1,111 @@
+@namespace DnsmasqWebUI.Components.EffectiveConfig
+
+<div class="ec-toolbar @(IsEditMode ? "ec-edit-toolbar" : "")">
+    @if (ShowSearchBox)
+    {
+        <input type="search" id="ec-search-input" class="form-control form-control-sm ec-toolbar-search" placeholder="Search..." autocomplete="off"
+               value="@SearchTerm" @oninput="OnSearchInput" />
+    }
+    <div class="ec-toolbar-actions">
+        <button type="button" class="btn btn-sm btn-outline-secondary" @onclick="OnToggleExpandCollapse"
+                title="@(AllSectionsExpanded ? "Collapse all sections" : "Expand all sections")"
+                aria-label="@(AllSectionsExpanded ? "Collapse all sections" : "Expand all sections")">
+            <i class="bi @(AllSectionsExpanded ? "bi-arrows-collapse" : "bi-arrows-expand")" aria-hidden="true"></i>
+        </button>
+        @if (IsEditMode)
+        {
+            <button type="button" class="btn btn-sm btn-primary" @onclick="OnOpenSaveModal" disabled="@(PendingChangesCount == 0)" title="Save changes to managed config" aria-label="Save">
+                <i class="bi bi-floppy-fill" aria-hidden="true"></i>
+            </button>
+            <button type="button" class="btn btn-sm btn-outline-secondary" @onclick="OnExitEditModeWithConfirm" title="Exit edit mode" aria-label="Exit edit mode">
+                <i class="bi bi-box-arrow-right" aria-hidden="true"></i>
+            </button>
+            @if (PendingChangesCount > 0)
+            {
+                <span class="text-muted small ec-toolbar-changes-link" role="button" tabindex="0"
+                      @onclick="OnOpenSaveModal"
+                      @onkeydown="OnChangesLinkKeyDown"
+                      title="Open save dialog"
+                      aria-label="Open save dialog">
+                    @PendingChangesCount change(s)
+                </span>
+            }
+            @if (ValidationErrorCount > 0 || ValidationWarningCount > 0)
+            {
+                <span class="small ec-toolbar-validation-count" aria-live="polite">
+                    @if (ValidationErrorCount > 0)
+                    {
+                        <span class="text-danger fw-medium ec-toolbar-changes-link" role="button" tabindex="0"
+                              title="@ValidationErrorTooltip"
+                              aria-label="Open save dialog"
+                              @onclick="OnOpenSaveModal"
+                              @onkeydown="OnValidationLinkKeyDown">
+                            @ValidationErrorCount error(s)
+                        </span>
+                    }
+                    @if (ValidationErrorCount > 0 && ValidationWarningCount > 0) { <span class="text-muted">·</span> }
+                    @if (ValidationWarningCount > 0)
+                    {
+                        <span class="text-warning ec-toolbar-changes-link" role="button" tabindex="0"
+                              title="@ValidationWarningTooltip"
+                              aria-label="Open save dialog"
+                              @onclick="OnOpenSaveModal"
+                              @onkeydown="OnValidationLinkKeyDown">
+                            @ValidationWarningCount warning(s)
+                        </span>
+                    }
+                </span>
+            }
+        }
+        else
+        {
+            <button type="button" class="btn btn-sm btn-outline-secondary" @onclick="OnEnterEditMode" title="Edit effective config" aria-label="Edit">
+                <i class="bi bi-pencil" aria-hidden="true"></i>
+            </button>
+        }
+    </div>
+</div>
+
+@code {
+    [Parameter] public bool ShowSearchBox { get; set; } = true;
+    [Parameter] public string SearchTerm { get; set; } = "";
+    [Parameter] public EventCallback<string> SearchTermChanged { get; set; }
+    [Parameter] public bool IsEditMode { get; set; }
+    [Parameter] public int PendingChangesCount { get; set; }
+    [Parameter] public IReadOnlyList<FieldIssue>? ValidationSummary { get; set; }
+    private int ValidationErrorCount => ValidationSummary?.Count(i => i.Severity == FieldIssueSeverity.Error) ?? 0;
+    private int ValidationWarningCount => ValidationSummary?.Count(i => i.Severity == FieldIssueSeverity.Warning) ?? 0;
+    private string ValidationErrorTooltip => ValidationSummary == null ? "" : string.Join("\n", ValidationSummary.Where(i => i.Severity == FieldIssueSeverity.Error).Select(i => i.Message));
+    private string ValidationWarningTooltip => ValidationSummary == null ? "" : string.Join("\n", ValidationSummary.Where(i => i.Severity == FieldIssueSeverity.Warning).Select(i => i.Message));
+    [Parameter] public bool AllSectionsExpanded { get; set; }
+    [Parameter] public EventCallback OnExpandAll { get; set; }
+    [Parameter] public EventCallback OnCollapseAll { get; set; }
+
+    private async Task OnToggleExpandCollapse()
+    {
+        if (AllSectionsExpanded)
+            await OnCollapseAll.InvokeAsync();
+        else
+            await OnExpandAll.InvokeAsync();
+    }
+    [Parameter] public EventCallback OnEnterEditMode { get; set; }
+    [Parameter] public EventCallback OnExitEditModeWithConfirm { get; set; }
+    [Parameter] public EventCallback OnOpenSaveModal { get; set; }
+
+    private async Task OnSearchInput(ChangeEventArgs e)
+    {
+        await SearchTermChanged.InvokeAsync(e.Value?.ToString() ?? "");
+    }
+
+    private async Task OnChangesLinkKeyDown(KeyboardEventArgs e)
+    {
+        if (e.Key == "Enter" || e.Key == " ")
+            await OnOpenSaveModal.InvokeAsync();
+    }
+
+    private async Task OnValidationLinkKeyDown(KeyboardEventArgs e)
+    {
+        if (e.Key == "Enter" || e.Key == " ")
+            await OnOpenSaveModal.InvokeAsync();
+    }
+}
@@ -0,0 +1,68 @@
+@namespace DnsmasqWebUI.Components.EffectiveConfig.CustomDisplays
+@using DnsmasqWebUI.Models.Dnsmasq
+@using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig
+@inherits EffectiveConfigValueDisplayBase
+
+@* do-0x20-encode / no-0x20-encode: tri-state. Switch shows Enabled vs not-Enabled; uncheck maps back to Default when that was the value at activation, else Disabled. *@
+@if (IsActiveEditor && Descriptor.GetSource()?.IsReadOnly != true)
+{
+    var isOn = GetState() == ExplicitToggleState.Enabled;
+    <div class="form-check form-switch ec-effective-switch">
+        <input type="checkbox"
+               class="form-check-input"
+               checked="@isOn"
+               aria-label="Enable @Descriptor.OptionName"
+               title="Set @Descriptor.OptionName"
+               @onchange="OnCheckedChange"
+               @onfocusout="OnCommitRequested" />
+    </div>
+}
+else
+{
+    @* Intentionally show both Default and Disabled as "Disabled" (product choice: collapse unset and off). Do not "fix" to show "Default" for unset. *@
+    @(GetState() == ExplicitToggleState.Enabled ? "Enabled" : "Disabled")
+}
+
+@code {
+    private ExplicitToggleState _stateAtActivation;
+    private bool _wasActiveEditor;
+
+    private ExplicitToggleState GetState()
+    {
+        var v = GetEffectiveDisplayValue();
+        if (v is ExplicitToggleState s) return s;
+        return ExplicitToggleState.Default;
+    }
+
+    protected override void OnParametersSet()
+    {
+        if (!IsActiveEditor)
+            _stateAtActivation = GetState();
+        else if (!_wasActiveEditor)
+            _stateAtActivation = GetState();
+        _wasActiveEditor = IsActiveEditor;
+    }
+
+    private async Task OnCheckedChange(ChangeEventArgs e)
+    {
+        var isChecked = e.Value is true;
+        if (isChecked)
+        {
+            await NotifyValueChanged(ExplicitToggleState.Enabled);
+            return;
+        }
+
+        var pending = Session?.PendingChanges.FirstOrDefault(c =>
+            string.Equals(c.SectionId, Descriptor.SectionId, StringComparison.OrdinalIgnoreCase) &&
+            string.Equals(c.OptionName, Descriptor.OptionName, StringComparison.OrdinalIgnoreCase));
+        if (pending?.OldValue is ExplicitToggleState previousState)
+        {
+            await NotifyValueChanged(previousState);
+            return;
+        }
+
+        // No existing pending edit for this field: map unchecked based on the state at activation.
+        // Default and Disabled both display as "Disabled" in view mode, so we preserve true intent here.
+        await NotifyValueChanged(_stateAtActivation == ExplicitToggleState.Default ? ExplicitToggleState.Default : ExplicitToggleState.Disabled);
+    }
+}
@@ -0,0 +1,29 @@
+@namespace DnsmasqWebUI.Components.EffectiveConfig.CustomDisplays
+@using DnsmasqWebUI.Models.Dnsmasq
+@inherits EffectiveConfigValueDisplayBase
+
+@* Reusable value-only display for boolean/flag options. When active editor: switch (unless readonly); View: "Enabled" / "Disabled". Pending value shown until save. *@
+@if (IsActiveEditor && Descriptor.GetSource()?.IsReadOnly != true)
+{
+    var isSet = GetEffectiveDisplayValue() is bool b && b;
+    <div class="form-check form-switch ec-effective-switch">
+        <input type="checkbox"
+               class="form-check-input"
+               checked="@isSet"
+               aria-label="Enable @Descriptor.OptionName"
+               title="Set @Descriptor.OptionName"
+               @onchange="OnCheckedChange"
+               @onfocusout="OnCommitRequested" />
+    </div>
+}
+else
+{
+    @(GetEffectiveDisplayValue() is bool isSet && isSet ? "Enabled" : "Disabled")
+}
+
+@code {
+    private async Task OnCheckedChange(ChangeEventArgs e)
+    {
+        await NotifyValueChanged(e.Value is true);
+    }
+}
@@ -0,0 +1,53 @@
+@namespace DnsmasqWebUI.Components.EffectiveConfig.CustomDisplays
+@using DnsmasqWebUI.Models.Dnsmasq
+@inherits EffectiveConfigValueDisplayBase
+
+@* Value-only display for int? options. Pending value shown until save. *@
+@if (IsActiveEditor && Descriptor.GetSource()?.IsReadOnly != true)
+{
+    var current = GetEffectiveDisplayValue() is int i ? i : DefaultValue;
+    <input type="number" class="form-control form-control-sm" style="max-width: 8rem;"
+           min="@Min" max="@Max" value="@(current?.ToString() ?? "")" @oninput="OnInput" @onfocusout="OnCommitRequested" />
+}
+else
+{
+    var v = GetEffectiveDisplayValue() is int n ? n : (int?)null;
+    if (v is null)
+    {
+        @("(not set)")
+    }
+    else
+    {
+        @v
+        @if (!string.IsNullOrEmpty(ViewSuffix)) { <text> @ViewSuffix</text> }
+        @if (!string.IsNullOrEmpty(Unit)) { <text> @Unit</text> }
+    }
+}
+
+@code {
+    private EffectiveIntegerConfigFieldDescriptor? IntDescriptor => Descriptor as EffectiveIntegerConfigFieldDescriptor;
+    private string? ViewSuffix => IntDescriptor?.ViewSuffix;
+    private string? Unit => IntDescriptor?.Unit;
+    private int Min => IntDescriptor?.Min ?? 0;
+    private int Max => IntDescriptor?.Max ?? int.MaxValue;
+    private int? DefaultValue => IntDescriptor?.DefaultValue;
+
+    private async Task OnInput(ChangeEventArgs e)
+    {
+        var raw = e.Value?.ToString();
+        object? value = null;
+        if (string.IsNullOrWhiteSpace(raw))
+        {
+            value = null;
+        }
+        else if (int.TryParse(raw, out var num))
+        {
+            value = num;
+        }
+        else
+        {
+            value = raw;
+        }
+        await NotifyValueChanged(value);
+    }
+}
@@ -0,0 +1,85 @@
+@namespace DnsmasqWebUI.Components.EffectiveConfig.CustomDisplays
+@using DnsmasqWebUI.Infrastructure.Helpers.Config
+@using DnsmasqWebUI.Models.Dnsmasq
+@inherits EffectiveConfigValueDisplayBase
+
+@* Options that can be: not set, key-only (e.g. use-stale-cache), or key=value (e.g. use-stale-cache=60). Checkbox to enable; when enabled, optional value input. *@
+@if (IsActiveEditor && Descriptor.GetSource()?.IsReadOnly != true)
+{
+    var isEnabled = _editorValue != null;
+    var valuePart = _editorValue is { Length: > 0 } ? _editorValue : "";
+    <div class="ec-key-only-or-value-editor">
+        <div class="form-check form-switch mb-0 ec-key-only-or-value-switch">
+            <input type="checkbox"
+                   class="form-check-input"
+                   checked="@isEnabled"
+                   aria-label="Enable @Descriptor.OptionName"
+                   title="Set @Descriptor.OptionName"
+                   @onchange="OnCheckedChange" />
+        </div>
+        @if (isEnabled)
+        {
+            <input type="text"
+                   class="form-control form-control-sm ec-key-only-or-value-input"
+                   placeholder="@(DnsmasqOptionPlaceholders.Get(Descriptor.OptionName) ?? "Optional value")"
+                   value="@valuePart"
+                   @oninput="OnValueInput" />
+        }
+    </div>
+}
+else
+{
+    var v = GetEffectiveDisplayValue() as string;
+    if (v is null)
+    {
+        @("(not set)")
+    }
+    else if (v.Length == 0)
+    {
+        @("Enabled")
+    }
+    else
+    {
+        @v
+    }
+}
+
+@code {
+    private string? _editorValue;
+    private bool _wasActiveEditor;
+
+    protected override void OnParametersSet()
+    {
+        var effective = GetEffectiveDisplayValue() as string;
+        if (!IsActiveEditor)
+        {
+            _editorValue = effective;
+        }
+        else if (!_wasActiveEditor)
+        {
+            _editorValue = effective;
+        }
+
+        _wasActiveEditor = IsActiveEditor;
+    }
+
+    private async Task OnCheckedChange(ChangeEventArgs e)
+    {
+        var isChecked = e.Value switch
+        {
+            bool b => b,
+            string s when bool.TryParse(s, out var parsed) => parsed,
+            _ => false
+        };
+
+        _editorValue = isChecked ? "" : null;
+        await NotifyValueChanged(_editorValue);
+    }
+
+    private async Task OnValueInput(ChangeEventArgs e)
+    {
+        var raw = e.Value?.ToString()?.Trim();
+        _editorValue = string.IsNullOrEmpty(raw) ? "" : raw;
+        await NotifyValueChanged(_editorValue);
+    }
+}
@@ -0,0 +1,31 @@
+.ec-key-only-or-value-editor {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.5rem;
+    min-width: 0;
+    max-width: 100%;
+    white-space: nowrap;
+}
+
+.ec-key-only-or-value-switch {
+    display: inline-flex;
+    align-items: center;
+    flex: 0 0 auto;
+    min-height: 1.25rem;
+    padding-left: 0;
+}
+
+.ec-key-only-or-value-switch .form-check-input {
+    float: none;
+    margin: 0;
+    cursor: pointer;
+    position: relative;
+    top: 2px;
+}
+
+.ec-key-only-or-value-input {
+    flex: 1 1 7rem;
+    min-width: 0;
+    width: 7rem;
+    max-width: 9rem;
+}
@@ -0,0 +1,27 @@
+@namespace DnsmasqWebUI.Components.EffectiveConfig.CustomDisplays
+@using DnsmasqWebUI.Models.Dnsmasq
+@inherits EffectiveConfigValueDisplayBase
+
+@* local-service: net | host. Pending value shown until save. *@
+@if (IsActiveEditor && Descriptor.GetSource()?.IsReadOnly != true)
+{
+    <select class="form-select form-select-sm" style="max-width: 10rem;" value="@(GetEffectiveDisplayValue() as string ?? "")" @onchange="OnChange" @onfocusout="OnCommitRequested">
+        <option value="">(not set)</option>
+        <option value="net">net</option>
+        <option value="host">host</option>
+    </select>
+}
+else
+{
+    var v = GetEffectiveDisplayValue() as string;
+    @(string.IsNullOrEmpty(v) ? "(not set)" : (v.Trim().ToLowerInvariant() is "net" or "host" ? v.Trim() : v))
+}
+
+@code {
+    private async Task OnChange(ChangeEventArgs e)
+    {
+        var v = e.Value?.ToString()?.Trim();
+        var value = string.IsNullOrEmpty(v) ? null : (v == "net" || v == "host" ? v : null);
+        await NotifyValueChanged(value);
+    }
+}
@@ -0,0 +1,59 @@
+@namespace DnsmasqWebUI.Components.EffectiveConfig.CustomDisplays
+@using DnsmasqWebUI.Models.Dnsmasq
+@inherits EffectiveConfigValueDisplayBase
+
+@* log-queries: optional value extra|proto|auth. View: Off / On / On (extra|proto|auth). When active editor: dropdown. *@
+@if (IsActiveEditor && Descriptor.GetSource()?.IsReadOnly != true)
+{
+    <select class="form-select form-select-sm" style="max-width: 12rem;" value="@GetEditValue()" @onchange="OnChange" @onfocusout="OnCommitRequested">
+        <option value="">Off</option>
+        <option value="on">On</option>
+        <option value="extra">On (extra)</option>
+        <option value="proto">On (proto)</option>
+        <option value="auth">On (auth)</option>
+    </select>
+}
+else
+{
+    @GetViewText()
+}
+
+@code {
+    private string GetEditValue()
+    {
+        var v = GetEffectiveDisplayValue() as string;
+        if (string.IsNullOrEmpty(v)) return "";
+        var lower = v.Trim().ToLowerInvariant();
+        if (lower is "extra" or "proto" or "auth") return lower;
+        return "on";
+    }
+
+    private string GetViewText()
+    {
+        var v = GetEffectiveDisplayValue() as string;
+        if (string.IsNullOrEmpty(v)) return "Off";
+        var lower = v.Trim().ToLowerInvariant();
+        return lower switch
+        {
+            "extra" => "On (extra)",
+            "proto" => "On (proto)",
+            "auth" => "On (auth)",
+            _ => "On"
+        };
+    }
+
+    private async Task OnChange(ChangeEventArgs e)
+    {
+        var sel = e.Value?.ToString()?.Trim().ToLowerInvariant();
+        string? newValue = sel switch
+        {
+            "" or "off" => null,
+            "on" => "",
+            "extra" => "extra",
+            "proto" => "proto",
+            "auth" => "auth",
+            _ => null
+        };
+        await NotifyValueChanged(newValue);
+    }
+}
@@ -0,0 +1,24 @@
+@namespace DnsmasqWebUI.Components.EffectiveConfig.CustomDisplays
+@using DnsmasqWebUI.Models.Dnsmasq
+@inherits EffectiveConfigValueDisplayBase
+
+@* Value-only display for the port option. Pending value shown until save. *@
+@if (IsActiveEditor && Descriptor.GetSource()?.IsReadOnly != true)
+{
+    var port = GetEffectiveDisplayValue() is int p ? p : 53;
+    <input type="number" class="form-control form-control-sm" style="max-width: 6rem;" min="1" max="65535" value="@port" @oninput="OnPortInput" @onfocusout="OnCommitRequested" />
+}
+else
+{
+    @(GetEffectiveDisplayValue() is int port ? $"{port} (default DNS port)" : "(not set)")
+}
+
+@code {
+    private async Task OnPortInput(ChangeEventArgs e)
+    {
+        if (int.TryParse(e.Value?.ToString(), out var port) && port >= 1 && port <= 65535)
+            await NotifyValueChanged(port);
+        else
+            await NotifyValueChanged(null);
+    }
+}
@@ -0,0 +1,330 @@
+@namespace DnsmasqWebUI.Components.EffectiveConfig
+@using DnsmasqWebUI.Models.Dnsmasq
+@using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig
+@using DnsmasqWebUI.Models.Config
+@using DnsmasqWebUI.Infrastructure.Helpers.Config
+@using DnsmasqWebUI.Infrastructure.Services.EffectiveConfig.Abstractions
+@using DnsmasqWebUI.Infrastructure.Services.UI.Notifications.Abstractions
+@inject IEffectiveConfigRenderFragmentRegistry RenderFragmentRegistry
+@inject INotificationService NotificationService
+
+@* Custom fragment renders only the value; we keep the row shell (label + value slot + badge) here for consistency. Pending value shown until save. *@
+@if (_customFragment is { } fragment)
+{
+    var labelTooltip = DnsmasqOptionTooltips.Get(Descriptor.OptionName);
+    var isReadonly = Descriptor.GetSource()?.IsReadOnly == true;
+    var showEditableBadge = !isReadonly && !Descriptor.IsCapabilityDisabled;
+    var isActiveEditor = IsEditMode && IsActive && !Descriptor.IsCapabilityDisabled;
+    var fragmentWithCallback = isActiveEditor ? _fragmentWithCallback : null;
+    var effectiveValue = _effectiveValue;
+    <li class="ec-field @(isActiveEditor ? "ec-field-editing" : "")" title="@(Descriptor.GetSource()?.GetReadOnlyTooltip())">
+        <OptionHelpLabel AnchorId="@_anchorId" HelpKey="@_optionHelpKey" OptionLabel="@Descriptor.OptionName" Title="@(labelTooltip ?? Descriptor.GetSource()?.GetReadOnlyTooltip())"><strong>@Descriptor.OptionName:</strong></OptionHelpLabel>
+        <span class="ec-field-value">
+            @if (isActiveEditor)
+            {
+                <div class="ec-field-value-when-editing" @onclick:stopPropagation="true">
+                    <div class="ec-field-edit-wrapper">
+                        <CascadingValue Value="@true">
+                            <CascadingValue Value="@(EventCallback.Factory.Create<FocusEventArgs>(this, OnBlur))">
+                                @((fragmentWithCallback ?? fragment)(Descriptor))
+                            </CascadingValue>
+                        </CascadingValue>
+                    </div>
+                    <OptionStateBadge AnchorId="@_readonlyBadgeAnchorId" Source="@Descriptor.GetSource()" OptionName="@Descriptor.OptionName" Value="@effectiveValue" IsInteractive="@IsEditMode" ShowEditableBadge="@showEditableBadge" HasPendingChange="@_hasPendingChange" EditableAsButton="true" FieldKey="@FieldKey" IsActiveEditor="@isActiveEditor" IsCapabilityDisabled="@Descriptor.IsCapabilityDisabled" CapabilityDisabledReason="@Descriptor.CapabilityDisabledReason" OnConfirmRequested="@HandleConfirmEdit" OnCancelRequested="@HandleCancelEdit" OnRevertRequested="@HandleRevertEdit" />
+                </div>
+            }
+            else
+            {
+                <CascadingValue Value="@false">
+                    @fragment(Descriptor)
+                </CascadingValue>
+                <OptionStateBadge AnchorId="@_readonlyBadgeAnchorId" Source="@Descriptor.GetSource()" OptionName="@Descriptor.OptionName" Value="@effectiveValue" IsInteractive="@IsEditMode" ShowEditableBadge="@showEditableBadge" HasPendingChange="@_hasPendingChange" EditableAsButton="true" FieldKey="@FieldKey" IsActiveEditor="@isActiveEditor" IsCapabilityDisabled="@Descriptor.IsCapabilityDisabled" CapabilityDisabledReason="@Descriptor.CapabilityDisabledReason" OnConfirmRequested="@HandleConfirmEdit" OnCancelRequested="@HandleCancelEdit" OnRevertRequested="@HandleRevertEdit" />
+            }
+        </span>
+    </li>
+}
+else if (Descriptor.IsMultiValue)
+{
+    var customMulti = RenderFragmentRegistry.BuildMultiFieldComponentFragment(Descriptor.SectionId, Descriptor.OptionName, EventCallback.Factory.Create<IReadOnlyList<string>>(this, HandleMultiValueChanged));
+    if (customMulti is not null)
+    {
+        @* Custom multi editor (e.g. server): same row shell as generic multi, value slot uses custom fragment. *@
+        <li class="ec-field @(IsEditMode && IsActive && !Descriptor.IsCapabilityDisabled ? "ec-field-editing" : "")">
+            <OptionHelpLabel AnchorId="@_anchorId" HelpKey="@_optionHelpKey" OptionLabel="@Descriptor.OptionName" Title="@(_labelTooltip ?? Descriptor.GetSource()?.GetReadOnlyTooltip())"><strong>@Descriptor.OptionName:</strong></OptionHelpLabel>
+            <span class="ec-field-value">
+                <CascadingValue Value="@(IsEditMode && IsActive && !Descriptor.IsCapabilityDisabled)">
+                    <CascadingValue Value="@IsEditMode">
+                        @customMulti(Descriptor)
+                    </CascadingValue>
+                </CascadingValue>
+            </span>
+            <OptionStateBadge AnchorId="@_readonlyBadgeAnchorId" Source="@_multiValueRowSource" OptionName="@Descriptor.OptionName" Value="@_multiValueItems"
+                IsInteractive="@(IsEditMode && !Descriptor.IsCapabilityDisabled)" ShowEditableBadge="@(IsEditMode && !Descriptor.IsCapabilityDisabled)" HasPendingChange="@_multiValueHasPendingOrDraft" EditableAsButton="true" FieldKey="@FieldKey" IsActiveEditor="@(IsEditMode && IsActive && !Descriptor.IsCapabilityDisabled)"
+                IsCapabilityDisabled="@Descriptor.IsCapabilityDisabled" CapabilityDisabledReason="@Descriptor.CapabilityDisabledReason"
+                OnConfirmRequested="@HandleConfirmEdit" OnCancelRequested="@HandleCancelEdit" OnRevertRequested="@HandleRevertEdit" />
+        </li>
+    }
+    else
+    {
+        @* Multi-value state is computed in OnParametersSet and in HandleMultiValueChanged; we only read cached fields here. *@
+        <EffectiveConfigMultiValueRow Descriptor="@Descriptor" Label="@Descriptor.OptionName" Items="@_multiValueItems" LabelTooltip="@_labelTooltip" OptionHelpKey="@_optionHelpKey" OptionHelpAnchorId="@_anchorId"
+            IsActiveEditor="@(IsEditMode && IsActive && !Descriptor.IsCapabilityDisabled)" IsEditMode="@IsEditMode" ReadonlyBadgeAnchorIdBase="@_readonlyBadgeAnchorId"
+            Source="@_multiValueRowSource" ShowEditableBadge="@(IsEditMode && !Descriptor.IsCapabilityDisabled)" HasPendingChange="@_multiValueHasPendingOrDraft" FieldKey="@FieldKey"
+            ItemsChanged="@HandleMultiValueChanged" OnConfirmRequested="@HandleConfirmEdit" OnCancelRequested="@HandleCancelEdit" OnRevertRequested="@HandleRevertEdit" />
+    }
+}
+else
+{
+    var value = _effectiveValue;
+    var displayValue = value == null ? "(not set)" : (value is IReadOnlyList<string> list ? (list.Count == 0 ? "(none)" : string.Join(", ", list)) : value.ToString());
+    var editValue = value?.ToString() ?? "";
+    var isReadonly = Descriptor.GetSource()?.IsReadOnly == true;
+    var showReadonlyHint = IsEditMode && isReadonly;
+    var isActiveEditor = IsEditMode && IsActive && !Descriptor.IsCapabilityDisabled;
+    var showEditableForDefault = !Descriptor.IsCapabilityDisabled;
+    @if (showReadonlyHint)
+    {
+        <li class="ec-field" title="@(Descriptor.GetSource()?.GetReadOnlyTooltip())">
+            <EffectiveConfigOptionItem Label="@Descriptor.OptionName" DisplayValue="@(displayValue ?? "(not set)")" Source="@Descriptor.GetSource()" LabelTooltip="@_labelTooltip" OptionHelpKey="@_optionHelpKey" OptionHelpAnchorId="@_anchorId"
+                FieldKey="@FieldKey" ReadonlyBadgeAnchorId="@_readonlyBadgeAnchorId" RawValue="@value" HasPendingChange="@_hasPendingChange" />
+        </li>
+    }
+    else
+    {
+        <li class="ec-field @(isActiveEditor ? "ec-field-editing" : "")" title="@(Descriptor.GetSource()?.GetReadOnlyTooltip())">
+            <EffectiveConfigOptionItem Label="@Descriptor.OptionName" DisplayValue="@(displayValue ?? "(not set)")" Source="@Descriptor.GetSource()" LabelTooltip="@_labelTooltip" OptionHelpKey="@_optionHelpKey" OptionHelpAnchorId="@_anchorId"
+                EditValue="@editValue"
+                ShowEditableBadge="@showEditableForDefault" FieldKey="@FieldKey" IsActive="@IsActive"
+                ReadonlyBadgeAnchorId="@_readonlyBadgeAnchorId" RawValue="@value" HasPendingChange="@_hasPendingChange"
+                IsCapabilityDisabled="@Descriptor.IsCapabilityDisabled" CapabilityDisabledReason="@Descriptor.CapabilityDisabledReason"
+                DisplayValueChanged="@HandleDefaultValueChanged" OnBlur="@HandleDefaultBlur" OnConfirmRequested="@HandleConfirmEdit" OnCancelRequested="@HandleCancelEdit" OnRevertRequested="@HandleRevertEdit" />
+        </li>
+    }
+}
+
+@code {
+    [Parameter] public EffectiveConfigFieldDescriptor Descriptor { get; set; } = null!;
+    [Parameter] public string FieldKey { get; set; } = "";
+    [Parameter] public bool IsEditMode { get; set; }
+    [Parameter] public bool IsActive { get; set; }
+    [CascadingParameter] public IEffectiveConfigEditSession? Session { get; set; }
+
+    private readonly string _anchorId = "ec-help-" + Guid.NewGuid().ToString("N")[..8];
+    private readonly string _readonlyBadgeAnchorId = "ec-readonly-" + Guid.NewGuid().ToString("N")[..8];
+    private RenderFragment<EffectiveConfigFieldDescriptor>? _customFragment;
+    private RenderFragment<EffectiveConfigFieldDescriptor>? _fragmentWithCallback;
+    private string? _labelTooltip;
+    private string? _optionHelpKey;
+    private object? _effectiveValue;
+    private bool _hasPendingChange;
+    private object? _valueAtActivation;
+    private object? _draftValue;
+    private bool _hasDraftValue;
+    private bool _wasActive;
+    private ExitAction _exitAction = ExitAction.None;
+
+    /// <summary>Cached for multi-value: items to pass to the row (with sources preserved for draft merge).</summary>
+    private IReadOnlyList<ValueWithSource>? _multiValueItems;
+    /// <summary>Cached for multi-value: true when there is an uncommitted draft list.</summary>
+    private bool _multiValueHasDraft;
+    /// <summary>Cached for multi-value: row-level source for badge (readonly when all items readonly and not edit mode).</summary>
+    private ConfigValueSource? _multiValueRowSource;
+    /// <summary>Cached for multi-value: whether row should show ok/cancel (session pending or local draft).</summary>
+    private bool _multiValueHasPendingOrDraft;
+
+    protected override void OnParametersSet()
+    {
+        _customFragment = RenderFragmentRegistry.BuildFieldComponentFragment(Descriptor.SectionId, Descriptor.OptionName);
+        _fragmentWithCallback = RenderFragmentRegistry.BuildFieldComponentFragment(Descriptor.SectionId, Descriptor.OptionName, EventCallback.Factory.Create<object?>(this, HandleValueChanged));
+        _labelTooltip = DnsmasqOptionTooltips.Get(Descriptor.OptionName);
+        _optionHelpKey = Descriptor.OptionName;
+        var pending = Session?.PendingChanges.FirstOrDefault(c =>
+            string.Equals(c.SectionId, Descriptor.SectionId, StringComparison.OrdinalIgnoreCase) &&
+            string.Equals(c.OptionName, Descriptor.OptionName, StringComparison.OrdinalIgnoreCase));
+        var descriptorValue = Descriptor.IsMultiValue
+            ? (Descriptor.GetItems()?.Select(i => i.Value).ToList() ?? new List<string>())
+            : Descriptor.GetValue();
+        _hasPendingChange = pending != null;
+        _effectiveValue = pending != null ? pending.NewValue : descriptorValue;
+        if (Descriptor.IsMultiValue)
+            ComputeMultiValueState(Descriptor.GetItems(), pending?.NewValue as IReadOnlyList<string>, _draftValue as IReadOnlyList<string>);
+        if (!_wasActive && IsActive)
+        {
+            // Use pending.OldValue when present so "revert to original" clears the pending change (e.g. do-0x20-encode: Disabled → Enable → Disable).
+            _valueAtActivation = pending != null ? pending.OldValue : descriptorValue;
+            _hasDraftValue = false;
+            _draftValue = null;
+        }
+        if (_wasActive && !IsActive && _exitAction == ExitAction.None)
+            _ = InvokeAsync(CommitIfChangedAsync);
+        if (_wasActive && !IsActive)
+            _exitAction = ExitAction.None;
+        _wasActive = IsActive;
+    }
+
+    private void ComputeMultiValueState(IReadOnlyList<ValueWithSource>? descriptorItems, IReadOnlyList<string>? pendingList, IReadOnlyList<string>? draftList)
+    {
+        var descriptorValues = descriptorItems?.Select(i => i.Value).ToList() ?? new List<string>();
+        _multiValueHasDraft = draftList != null && !ValuesEqual(descriptorValues, draftList);
+        if (_multiValueHasDraft && draftList != null)
+        {
+            _multiValueItems = BuildItemsWithSource(descriptorItems, draftList);
+        }
+        else if (_hasPendingChange && pendingList != null)
+        {
+            _multiValueItems = BuildItemsWithSource(descriptorItems, pendingList);
+        }
+        else
+        {
+            _multiValueItems = descriptorItems;
+        }
+        var allReadonly = _multiValueItems != null && _multiValueItems.Count > 0 && _multiValueItems.All(i => i.Source?.IsReadOnly == true);
+        _multiValueRowSource = allReadonly && !IsEditMode ? _multiValueItems?.FirstOrDefault()?.Source : null;
+        _multiValueHasPendingOrDraft = _hasPendingChange || _multiValueHasDraft;
+    }
+
+    private static IReadOnlyList<ValueWithSource> BuildItemsWithSource(IReadOnlyList<ValueWithSource>? descriptorItems, IReadOnlyList<string> values)
+    {
+        var pool = descriptorItems?.ToList() ?? new List<ValueWithSource>();
+        var list = new List<ValueWithSource>(values.Count);
+        foreach (var s in values)
+        {
+            var idx = pool.FindIndex(x => string.Equals(x.Value, s, StringComparison.Ordinal));
+            if (idx >= 0)
+            {
+                list.Add(pool[idx]);
+                pool.RemoveAt(idx);
+            }
+            else
+                list.Add(new ValueWithSource(s, null));
+        }
+        return list;
+    }
+
+    private void HandleValueChanged(object? value)
+    {
+        _draftValue = value;
+        _hasDraftValue = true;
+    }
+
+    private async Task OnBlur(FocusEventArgs _)
+    {
+        if (!IsActive) return;
+        await CommitIfChangedAsync();
+    }
+
+    private async Task<bool> CommitIfChangedAsync()
+    {
+        var newValue = _hasDraftValue ? _draftValue : _effectiveValue;
+        if (IsDefaultSingleValueField)
+            newValue = NormalizeDefaultSingleCommitValue(newValue);
+        if (ValuesEqual(_valueAtActivation, newValue))
+        {
+            _draftValue = null;
+            _hasDraftValue = false;
+            if (_hasPendingChange && Ui?.RevertFieldAsync != null)
+                await Ui.RevertFieldAsync(Descriptor.SectionId, Descriptor.OptionName);
+            return true;
+        }
+        var validationError = Descriptor.Validate(newValue);
+        if (validationError != null)
+        {
+            NotificationService.ShowError(validationError);
+            return false;
+        }
+
+        var source = Descriptor.GetSource();
+        object? valueToCommit = newValue;
+        if (newValue is IReadOnlyList<string> list)
+        {
+            var deduped = list.Distinct(StringComparer.Ordinal).ToList();
+            valueToCommit = deduped;
+        }
+        var args = new EffectiveConfigEditCommittedArgs(Descriptor.SectionId, Descriptor.OptionName, _valueAtActivation, valueToCommit, source?.FilePath);
+        if (Ui != null)
+            await Ui.CommitFieldAsync(args);
+        _draftValue = null;
+        _hasDraftValue = false;
+        return true;
+    }
+
+    private bool IsDefaultSingleValueField =>
+        !Descriptor.IsMultiValue && _customFragment is null;
+
+    [CascadingParameter] private EffectiveConfigUiContext? Ui { get; set; }
+
+    private void HandleDefaultValueChanged(string value)
+    {
+        _draftValue = value;
+        _hasDraftValue = true;
+    }
+
+    private async Task HandleDefaultBlur(string? value)
+    {
+        if (!IsActive) return;
+        _draftValue = NormalizeDefaultSingleCommitValue(value);
+        _hasDraftValue = true;
+        if (!await CommitIfChangedAsync() && Ui != null)
+            await Ui.ActivateFieldAsync(FieldKey);
+    }
+
+    private static object? NormalizeDefaultSingleCommitValue(object? value)
+    {
+        if (value is string s && string.IsNullOrWhiteSpace(s))
+            return null;
+        return value;
+    }
+
+    private void HandleMultiValueChanged(IReadOnlyList<string> values)
+    {
+        _draftValue = values.ToList();
+        _hasDraftValue = true;
+        if (Descriptor.IsMultiValue)
+            ComputeMultiValueState(Descriptor.GetItems(), _effectiveValue as IReadOnlyList<string>, _draftValue as IReadOnlyList<string>);
+        StateHasChanged();
+    }
+
+    private async Task HandleConfirmEdit()
+    {
+        if (!await CommitIfChangedAsync())
+            return;
+        _exitAction = ExitAction.Confirm;
+        if (Ui != null)
+            await Ui.DeactivateFieldAsync();
+    }
+
+    private async Task HandleCancelEdit()
+    {
+        _draftValue = null;
+        _hasDraftValue = false;
+        _exitAction = ExitAction.Cancel;
+        if (Ui != null)
+            await Ui.DeactivateFieldAsync();
+    }
+
+    private async Task HandleRevertEdit()
+    {
+        _draftValue = null;
+        _hasDraftValue = false;
+        Session?.RevertChange(Descriptor.SectionId, Descriptor.OptionName);
+        _exitAction = ExitAction.Revert;
+        if (Ui != null)
+            await Ui.DeactivateFieldAsync();
+    }
+
+    private static IReadOnlyList<string>? AsStringList(object? value)
+    {
+        return value as IReadOnlyList<string>;
+    }
+
+    private static bool ValuesEqual(object? oldValue, object? newValue)
+    {
+        var oldList = AsStringList(oldValue);
+        var newList = AsStringList(newValue);
+        if (oldList != null || newList != null)
+            return (oldList ?? Array.Empty<string>()).SequenceEqual(newList ?? Array.Empty<string>(), StringComparer.Ordinal);
+        return Equals(oldValue, newValue);
+    }
+
+    private enum ExitAction { None, Confirm, Cancel, Revert }
+}
@@ -0,0 +1,22 @@
+@namespace DnsmasqWebUI.Components.EffectiveConfig
+@using DnsmasqWebUI.Models.Dnsmasq
+@using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig
+
+<span class="ec-field-value-item" title="@(ReadonlyClickActivatesField ? ReadonlyTitleOverride : Source?.GetReadOnlyTooltip())">
+    @Value
+    <OptionStateBadge AnchorId="@(ReadonlyBadgeAnchorId ?? "")" Source="@Source" OptionName="@OptionName" Value="@Value"
+                     IsInteractive="@(IsEditMode && !ReadonlyClickActivatesField && !string.IsNullOrEmpty(ReadonlyBadgeAnchorId))"
+                     ShowEditableBadge="@(Source?.IsReadOnly != true)" EditableAsButton="true"
+                     FieldKey="@FieldKey" ReadonlyClickActivatesField="@ReadonlyClickActivatesField" ReadonlyTitleOverride="@ReadonlyTitleOverride" />
+</span>
+
+@code {
+    [Parameter] public string Value { get; set; } = "";
+    [Parameter] public ConfigValueSource? Source { get; set; }
+    [Parameter] public string OptionName { get; set; } = "";
+    [Parameter] public bool IsEditMode { get; set; }
+    [Parameter] public string? ReadonlyBadgeAnchorId { get; set; }
+    [Parameter] public string? FieldKey { get; set; }
+    [Parameter] public bool ReadonlyClickActivatesField { get; set; }
+    [Parameter] public string? ReadonlyTitleOverride { get; set; }
+}
@@ -0,0 +1,276 @@
+@namespace DnsmasqWebUI.Components.EffectiveConfig
+@using DnsmasqWebUI.Infrastructure.Helpers.Config
+@using DnsmasqWebUI.Models.Dnsmasq
+@using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig
+@using Microsoft.AspNetCore.Components.Web
+@using DnsmasqWebUI.Infrastructure.Services.EffectiveConfig.Validation
+@using DnsmasqWebUI.Infrastructure.Services.UI.Notifications.Abstractions
+@inject IJSRuntime JSRuntime
+@inject INotificationService NotificationService
+
+<div class="ec-field-value ec-field-value-multi ec-multi-list-editor" @onclick:stopPropagation="true">
+    <ol class="ec-field-value-list">
+        @if (_displayItems.Count > 0)
+        {
+            @for (var i = 0; i < _displayItems.Count; i++)
+            {
+                var item = _displayItems[i];
+                var anchorId = $"{ReadonlyBadgeAnchorIdBase}-{i}";
+                var itemReadonly = item.Source?.IsReadOnly == true;
+                var rowIndex = i;
+                var rowValue = item.Value;
+
+                <li class="ec-multi-list-row @(_editingIndex == rowIndex && !itemReadonly ? "ec-multi-list-row-with-controls" : "")" @key="anchorId">
+                    @if (_editingIndex == rowIndex && !itemReadonly)
+                    {
+                        <div class="ec-multi-list-row-controls">
+                            <div class="ec-multi-list-input-group">
+                                <input class="form-control form-control-sm ec-multi-list-input"
+                                       placeholder="@(DnsmasqOptionPlaceholders.Get(OptionName) ?? "Value")"
+                                       @bind="_draftValue" @bind:event="oninput" />
+                            </div>
+                            <span class="status-badge-inline">
+                                <StatusBadge Kind="StatusBadgeKind.ActionOk" Text="save" Clickable="true"
+                                             Title="Apply change" AriaLabel="Apply change"
+                                             PreventBlurOnMouseDown="true" OnClick="@(() => SaveEdit(rowIndex))" Class="status-badge-inline" />
+                                <StatusBadge Kind="StatusBadgeKind.ActionCancel" Text="cancel" Clickable="true"
+                                             Title="Discard edit" AriaLabel="Cancel edit"
+                                             PreventBlurOnMouseDown="true" OnClick="CancelInline" Class="status-badge-inline" />
+                            </span>
+                        </div>
+                    }
+                    else
+                    {
+                        <span class="ec-field-value-item">@rowValue</span>
+
+                        <span class="status-badge-inline">
+                            <OptionStateBadge
+                                AnchorId="@anchorId"
+                                Source="@item.Source"
+                                OptionName="@OptionName"
+                                Value="@rowValue"
+                                IsInteractive="@IsEditMode"
+                                ShowEditableBadge="@(!itemReadonly)"
+                                EditableAsButton="@(!itemReadonly)"
+                                OnEditableClickRequested="@(!itemReadonly ? EventCallback.Factory.Create(this, () => { BeginEdit(rowIndex, rowValue); return Task.CompletedTask; }) : default)" />
+                            @if (!itemReadonly)
+                            {
+                                <StatusBadge Kind="StatusBadgeKind.ActionRevert" Text="remove" Clickable="true"
+                                             Title="Remove this value" AriaLabel="Remove"
+                                             PreventBlurOnMouseDown="true"
+                                             OnClick="@(() => RemoveAt(rowIndex))" Class="status-badge-inline" />
+                            }
+                        </span>
+                    }
+                </li>
+            }
+        }
+        else if (!AllowAddManagedValue)
+        {
+            <li class="ec-multi-list-row ec-multi-list-empty-hint">
+                <span class="text-muted">(none)</span>
+            </li>
+        }
+
+        @if (AllowAddManagedValue)
+        {
+            <li class="ec-multi-list-row ec-multi-list-add-item @(_addingNew ? "ec-multi-list-row-with-controls" : "")" @key="AddItemKey">
+                @if (_addingNew)
+                {
+                    <div class="ec-multi-list-row-controls">
+                        <div class="ec-multi-list-input-group">
+                            <input @ref="_addNewInputRef" class="form-control form-control-sm ec-multi-list-input"
+                                   placeholder="@(DnsmasqOptionPlaceholders.Get(OptionName) ?? "Value")"
+                                   @bind="_draftValue" @bind:event="oninput" />
+                        </div>
+                        <span class="status-badge-inline">
+                            <StatusBadge Kind="StatusBadgeKind.ActionOk" Text="add" Clickable="true"
+                                         Title="Add this value" AriaLabel="Add"
+                                         PreventBlurOnMouseDown="true" OnClick="SaveNew" Class="status-badge-inline" />
+                            <StatusBadge Kind="StatusBadgeKind.ActionCancel" Text="cancel" Clickable="true"
+                                         Title="Discard" AriaLabel="Cancel"
+                                         PreventBlurOnMouseDown="true" OnClick="CancelInline" Class="status-badge-inline" />
+                        </span>
+                    </div>
+                }
+                else
+                {
+                    <StatusBadge Kind="StatusBadgeKind.Editable" Text="add item" Clickable="true"
+                                 Title="Add a new value" AriaLabel="Add item"
+                                 OnClick="BeginAdd" Class="status-badge-inline ec-multi-list-add-btn" />
+                }
+            </li>
+        }
+    </ol>
+</div>
+
+@code {
+    [Parameter] public IReadOnlyList<ValueWithSource>? SourceItems { get; set; }
+    [Parameter] public string OptionName { get; set; } = "";
+    [Parameter] public string ReadonlyBadgeAnchorIdBase { get; set; } = "";
+
+    [Parameter] public bool IsEditMode { get; set; }
+    [Parameter] public bool AllowAddManagedValue { get; set; } = true;
+
+    [Parameter] public IMultiValueEditBehavior? Behavior { get; set; }
+    [Parameter] public IMultiValueOptionValidator? Validator { get; set; }
+    [Parameter] public string? FieldKey { get; set; }
+
+    [Parameter] public EventCallback<IReadOnlyList<string>> OnValuesChanged { get; set; }
+
+    private const string AddItemKey = "add-item";
+    private static readonly TimeSpan ValidationToastDedupeWindow = TimeSpan.FromSeconds(2);
+
+    private int? _editingIndex;
+    private bool _addingNew;
+    private string _draftValue = "";
+    private bool _didAutoOpenAdd;
+    private bool _shouldFocusAddInput;
+    private ElementReference _addNewInputRef;
+    private string? _lastValidationErrorMessage;
+    private DateTime _lastValidationErrorUtc;
+
+    private List<ValueWithSource> _displayItems = new();
+    private IReadOnlyList<string> _currentValues => _displayItems.Select(x => x.Value).ToList();
+
+    protected override void OnParametersSet()
+    {
+        _displayItems = (SourceItems ?? Array.Empty<ValueWithSource>()).ToList();
+
+        if (!_didAutoOpenAdd && (SourceItems?.Count ?? 0) == 0 && AllowAddManagedValue)
+        {
+            _didAutoOpenAdd = true;
+            _addingNew = true;
+            _shouldFocusAddInput = true;
+        }
+    }
+
+    protected override async Task OnAfterRenderAsync(bool firstRender)
+    {
+        if (_shouldFocusAddInput && _addingNew)
+        {
+            _shouldFocusAddInput = false;
+            try
+            {
+                await _addNewInputRef.FocusAsync();
+            }
+            catch
+            {
+                // Focus can fail if the element is not yet in the DOM (e.g. prerender)
+            }
+        }
+    }
+
+    private void BeginEdit(int index, string current)
+    {
+        _addingNew = false;
+        _editingIndex = index;
+        _draftValue = current;
+    }
+
+    private void BeginAdd()
+    {
+        _editingIndex = null;
+        _addingNew = true;
+        _draftValue = "";
+        _shouldFocusAddInput = true;
+    }
+
+    private void CancelInline()
+    {
+        _editingIndex = null;
+        _addingNew = false;
+        _draftValue = "";
+        _lastValidationErrorMessage = null;
+    }
+
+    private void ShowValidationError(string message)
+    {
+        var now = DateTime.UtcNow;
+        if (string.Equals(_lastValidationErrorMessage, message, StringComparison.Ordinal) &&
+            (now - _lastValidationErrorUtc) < ValidationToastDedupeWindow)
+            return;
+        _lastValidationErrorMessage = message;
+        _lastValidationErrorUtc = now;
+        NotificationService.ShowError(message);
+    }
+
+    private async Task SaveEdit(int index)
+    {
+        var current = _currentValues;
+        var next = current.ToList();
+        if (index < 0 || index >= next.Count) return;
+
+        var raw = _draftValue ?? "";
+        var normalized = Behavior?.Normalize(raw) ?? raw.Trim();
+        if (normalized.Length == 0)
+        {
+            ShowValidationError("Value cannot be empty.");
+            return;
+        }
+
+        var validationError = Validator?.ValidateItem(normalized, current, index);
+        if (validationError != null)
+        {
+            ShowValidationError(validationError);
+            return;
+        }
+
+        if (Behavior?.AllowDuplicates == false && next.Where((v, i) => i != index).Any(v => string.Equals(v, normalized, StringComparison.Ordinal)))
+        {
+            ShowValidationError("Duplicate values are not allowed.");
+            return;
+        }
+
+        next[index] = normalized;
+        _displayItems[index] = _displayItems[index] with { Value = normalized };
+        await OnValuesChanged.InvokeAsync(next);
+        CancelInline();
+    }
+
+    private async Task SaveNew()
+    {
+        var raw = _draftValue ?? "";
+        var normalized = Behavior?.Normalize(raw) ?? raw.Trim();
+        if (normalized.Length == 0)
+        {
+            ShowValidationError("Value cannot be empty.");
+            return;
+        }
+
+        var current = _currentValues;
+        var validationError = Validator?.ValidateItem(normalized, current, null);
+        if (validationError != null)
+        {
+            ShowValidationError(validationError);
+            return;
+        }
+
+        if (Behavior?.AllowDuplicates == false && current.Contains(normalized, StringComparer.Ordinal))
+        {
+            ShowValidationError("Duplicate values are not allowed.");
+            return;
+        }
+
+        var next = current.ToList();
+        next.Add(normalized);
+        _displayItems.Add(new ValueWithSource(normalized, null));
+        await OnValuesChanged.InvokeAsync(next);
+        CancelInline();
+    }
+
+    private async Task RemoveAt(int index)
+    {
+        if (index < 0 || index >= _displayItems.Count) return;
+        var item = _displayItems[index];
+        if (item?.Source?.IsReadOnly == true) return;
+
+        var next = _displayItems.Select(x => x.Value).ToList();
+        if (index < 0 || index >= next.Count) return;
+
+        next.RemoveAt(index);
+        _displayItems.RemoveAt(index);
+        await OnValuesChanged.InvokeAsync(next);
+        StateHasChanged();
+    }
+}
@@ -0,0 +1,95 @@
+/* Editor block: distinct from display mode (border + background) */
+.ec-multi-list-editor {
+    display: block;
+    padding: 0.75rem 1rem;
+    margin-top: 0.25rem;
+    border: 1px solid var(--bs-border-color, #dee2e6);
+    border-radius: 0.375rem;
+    background-color: var(--bs-body-bg, #fff);
+}
+
+.ec-multi-list-editor .ec-field-value-list {
+    margin-bottom: 0;
+}
+
+.ec-multi-list-row {
+    display: flex;
+    align-items: center;
+    flex-wrap: wrap;
+    gap: 0.5rem;
+    min-height: 2rem;
+}
+
+.ec-multi-list-row.ec-multi-list-row-with-controls {
+    align-items: flex-start;
+}
+
+.ec-multi-list-row-controls {
+    display: flex;
+    align-items: flex-start;
+    gap: 0.5rem;
+    flex-wrap: nowrap;
+    min-width: 0;
+    width: 100%;
+}
+
+.ec-multi-list-input-group {
+    display: flex;
+    flex: 1 1 auto;
+    flex-direction: column;
+    min-width: 0;
+    max-width: 28rem;
+}
+
+.ec-multi-list-invalid-feedback {
+    margin-top: 0.25rem;
+    margin-bottom: 0;
+    width: 100%;
+}
+
+.ec-multi-list-row .ec-field-value-item {
+    min-width: 0;
+}
+
+.ec-multi-list-row .status-badge-inline {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.25rem;
+    flex-shrink: 0;
+}
+
+.ec-multi-list-row .form-control.ec-multi-list-input {
+    max-width: none;
+    flex-shrink: 0;
+    width: 100%;
+}
+
+.ec-multi-list-empty-hint {
+    list-style: none;
+    margin-left: -1.25rem;
+}
+
+.ec-multi-list-add-item {
+    list-style: none;
+    margin-left: -1.25rem;
+    margin-top: 0.25rem;
+    padding-top: 0.25rem;
+    border-top: 1px dashed var(--bs-border-color, #dee2e6);
+    flex-wrap: nowrap;
+}
+
+.ec-multi-list-add-item .form-control.ec-multi-list-input {
+    min-width: 12rem;
+}
+
+.ec-multi-list-add-item .ec-multi-list-input-group {
+    max-width: none;
+}
+
+.ec-multi-list-add-item .status-badge-inline {
+    margin-left: auto;
+}
+
+.ec-multi-list-add-btn {
+    font-size: 0.875rem;
+}
@@ -0,0 +1,68 @@
+@namespace DnsmasqWebUI.Components.EffectiveConfig
+@using DnsmasqWebUI.Models.Dnsmasq
+@using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig
+
+<li class="ec-field">
+    <OptionHelpLabel AnchorId="@(OptionHelpAnchorId ?? "")" HelpKey="@OptionHelpKey" OptionLabel="@Label" Title="@LabelTooltip"><strong>@Label:</strong></OptionHelpLabel>
+    @if (IsActiveEditor)
+    {
+        <EffectiveConfigMultiValueListEditor
+            SourceItems="@(Items ?? Array.Empty<ValueWithSource>())"
+            OptionName="@Label"
+            ReadonlyBadgeAnchorIdBase="@(ReadonlyBadgeAnchorIdBase ?? "")"
+            IsEditMode="@IsEditMode"
+            AllowAddManagedValue="@IsEditMode"
+            FieldKey="@FieldKey"
+            Behavior="@(_multiDesc?.Behavior)"
+            Validator="@(_multiDesc?.Validator)"
+            OnValuesChanged="@ItemsChanged" />
+        <OptionStateBadge AnchorId="@(ReadonlyBadgeAnchorIdBase ?? "")" Source="@Source" OptionName="@Label" Value="@Items"
+                         IsInteractive="@IsEditMode" ShowEditableBadge="@ShowEditableBadge" HasPendingChange="@HasPendingChange"
+                         EditableAsButton="true" FieldKey="@FieldKey" IsActiveEditor="@IsActiveEditor"
+                         IsCapabilityDisabled="@(Descriptor?.IsCapabilityDisabled == true)" CapabilityDisabledReason="@Descriptor?.CapabilityDisabledReason"
+                         OnConfirmRequested="@OnConfirmRequested" OnCancelRequested="@OnCancelRequested" OnRevertRequested="@OnRevertRequested" />
+    }
+    else
+    {
+        <div class="ec-field-value ec-field-value-multi">
+            @if (Items?.Count > 0)
+            {
+                <ol class="ec-field-value-list">
+                    @foreach (var (item, index) in Items!.Select((item, index) => (item, index)))
+                    {
+                        var anchorId = ReadonlyBadgeAnchorIdBase != null ? ReadonlyBadgeAnchorIdBase + "-" + index : "";
+                        <li><EffectiveConfigMultiValueItem Value="@item.Value" Source="@item.Source" OptionName="@Label" IsEditMode="@IsEditMode" ReadonlyBadgeAnchorId="@anchorId" FieldKey="@FieldKey" ReadonlyClickActivatesField="true" ReadonlyTitleOverride="New values can still be added. Click to edit." /></li>
+                    }
+                </ol>
+            }
+            else
+            {
+                <span class="text-muted">(none)</span>
+                <OptionStateBadge OptionName="@Label" ShowEditableBadge="@(!(Descriptor?.IsCapabilityDisabled == true))" EditableAsButton="true"
+                    FieldKey="@FieldKey" IsActiveEditor="false" IsInteractive="true" IsCapabilityDisabled="@(Descriptor?.IsCapabilityDisabled == true)" CapabilityDisabledReason="@Descriptor?.CapabilityDisabledReason" />
+            }
+        </div>
+    }
+</li>
+
+@code {
+    [Parameter] public string Label { get; set; } = "";
+    [Parameter] public EffectiveConfigFieldDescriptor? Descriptor { get; set; }
+    [Parameter] public IReadOnlyList<ValueWithSource>? Items { get; set; }
+    [Parameter] public EventCallback<IReadOnlyList<string>> ItemsChanged { get; set; }
+    [Parameter] public string? LabelTooltip { get; set; }
+    [Parameter] public string? OptionHelpKey { get; set; }
+    [Parameter] public string? OptionHelpAnchorId { get; set; }
+    [Parameter] public bool IsActiveEditor { get; set; }
+    [Parameter] public bool IsEditMode { get; set; }
+    [Parameter] public string? ReadonlyBadgeAnchorIdBase { get; set; }
+    [Parameter] public ConfigValueSource? Source { get; set; }
+    [Parameter] public bool ShowEditableBadge { get; set; }
+    [Parameter] public bool HasPendingChange { get; set; }
+    [Parameter] public string FieldKey { get; set; } = "";
+    [Parameter] public EventCallback OnConfirmRequested { get; set; }
+    [Parameter] public EventCallback OnCancelRequested { get; set; }
+    [Parameter] public EventCallback OnRevertRequested { get; set; }
+
+    private EffectiveMultiValueConfigFieldDescriptor? _multiDesc => Descriptor as EffectiveMultiValueConfigFieldDescriptor;
+}
@@ -0,0 +1,84 @@
+@namespace DnsmasqWebUI.Components.EffectiveConfig
+@using DnsmasqWebUI.Infrastructure.Helpers.Config
+@using DnsmasqWebUI.Models.Dnsmasq
+@using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig
+
+<OptionHelpLabel AnchorId="@(OptionHelpAnchorId ?? "")" HelpKey="@OptionHelpKey" OptionLabel="@Label" Title="@(LabelTooltip ?? Source?.GetReadOnlyTooltip())"><strong>@Label:</strong></OptionHelpLabel>
+@if (DisplayMode == EffectiveConfigDisplayMode.Edit && IsActive && Source?.IsReadOnly != true && !IsCapabilityDisabled)
+{
+    <span class="ec-field-value" @onclick:stopPropagation="true">
+        <input type="text"
+               class="form-control form-control-sm"
+               placeholder="@(DnsmasqOptionPlaceholders.Get(Label) ?? "Value")"
+               value="@(_editValue ?? EditValue)"
+               @oninput="OnValueInput"
+               @onfocusout="OnInputBlur" />
+        <OptionStateBadge AnchorId="@(ReadonlyBadgeAnchorId ?? "")" Source="@Source" OptionName="@Label" Value="@(RawValue ?? DisplayValue)" IsInteractive="@(DisplayMode == EffectiveConfigDisplayMode.Edit && !string.IsNullOrEmpty(ReadonlyBadgeAnchorId))" ShowEditableBadge="@ShowEditableBadge" HasPendingChange="@HasPendingChange" EditableAsButton="true" FieldKey="@FieldKey" IsActiveEditor="true" IsCapabilityDisabled="@IsCapabilityDisabled" CapabilityDisabledReason="@CapabilityDisabledReason" OnConfirmRequested="@OnConfirmRequested" OnCancelRequested="@OnCancelRequested" OnRevertRequested="@OnRevertRequested" />
+    </span>
+}
+else
+{
+    <span class="ec-field-value">
+        @DisplayValue
+        <OptionStateBadge AnchorId="@(ReadonlyBadgeAnchorId ?? "")" Source="@Source" OptionName="@Label" Value="@(RawValue ?? DisplayValue)" IsInteractive="@(DisplayMode == EffectiveConfigDisplayMode.Edit && !string.IsNullOrEmpty(ReadonlyBadgeAnchorId))" ShowEditableBadge="@ShowEditableBadge" HasPendingChange="@HasPendingChange" EditableAsButton="true" FieldKey="@FieldKey" IsActiveEditor="false" IsCapabilityDisabled="@IsCapabilityDisabled" CapabilityDisabledReason="@CapabilityDisabledReason" OnConfirmRequested="@OnConfirmRequested" OnCancelRequested="@OnCancelRequested" OnRevertRequested="@OnRevertRequested" />
+    </span>
+}
+
+@code {
+    [Parameter] public string Label { get; set; } = "";
+    [Parameter] public string DisplayValue { get; set; } = "";
+    [Parameter] public string EditValue { get; set; } = "";
+    [Parameter] public ConfigValueSource? Source { get; set; }
+    /// <summary>Optional explainer shown on hover over the label (e.g. from DnsmasqOptionTooltips).</summary>
+    [Parameter] public string? LabelTooltip { get; set; }
+    [Parameter] public string? OptionHelpKey { get; set; }
+    [Parameter] public string? OptionHelpAnchorId { get; set; }
+    /// <summary>When set in edit mode, the readonly badge is rendered as a button with this id so the popover can anchor to it.</summary>
+    [Parameter] public string? ReadonlyBadgeAnchorId { get; set; }
+    /// <summary>Raw value for the readonly popover override line (e.g. from descriptor); falls back to DisplayValue.</summary>
+    [Parameter] public object? RawValue { get; set; }
+    /// <summary>When true, show an 'editable' badge next to non-readonly fields; clicking it activates edit for this field.</summary>
+    [Parameter] public bool ShowEditableBadge { get; set; }
+    /// <summary>When true, badge shows "pending" and warning style to indicate this field has an unsaved change.</summary>
+    [Parameter] public bool HasPendingChange { get; set; }
+    /// <summary>Field key for activation via context when editable badge is clicked.</summary>
+    [Parameter] public string FieldKey { get; set; } = "";
+    /// <summary>When true, add ec-field-editing class and show input when DisplayMode is Edit.</summary>
+    [Parameter] public bool IsActive { get; set; }
+    /// <summary>When true, option is disabled because dnsmasq build does not support it; show disabled badge and no editor.</summary>
+    [Parameter] public bool IsCapabilityDisabled { get; set; }
+    /// <summary>Tooltip when <see cref="IsCapabilityDisabled"/> is true.</summary>
+    [Parameter] public string? CapabilityDisabledReason { get; set; }
+    /// <summary>When Edit and not readonly: raised when the user changes the value. Not yet wired to save.</summary>
+    [Parameter] public EventCallback<string> DisplayValueChanged { get; set; }
+    /// <summary>When Edit and not readonly: raised when the input loses focus; argument is the current value.</summary>
+    [Parameter] public EventCallback<string?> OnBlur { get; set; }
+    /// <summary>When user clicks OK; parent should commit and deactivate.</summary>
+    [Parameter] public EventCallback OnConfirmRequested { get; set; }
+    /// <summary>When user clicks Cancel; parent should clear draft and deactivate.</summary>
+    [Parameter] public EventCallback OnCancelRequested { get; set; }
+    /// <summary>When user clicks Revert; parent should revert pending, clear draft, and deactivate.</summary>
+    [Parameter] public EventCallback OnRevertRequested { get; set; }
+    [CascadingParameter] public EffectiveConfigDisplayMode DisplayMode { get; set; } = EffectiveConfigDisplayMode.View;
+
+    private string? _editValue;
+
+    protected override void OnParametersSet()
+    {
+        if (DisplayMode != EffectiveConfigDisplayMode.Edit)
+            _editValue = null;
+    }
+
+    private async Task OnValueInput(ChangeEventArgs e)
+    {
+        var value = e.Value?.ToString() ?? "";
+        _editValue = value;
+        await DisplayValueChanged.InvokeAsync(value);
+    }
+
+    private async Task OnInputBlur(FocusEventArgs _)
+    {
+        if (OnBlur.HasDelegate)
+            await OnBlur.InvokeAsync(_editValue ?? EditValue);
+    }
+}
@@ -1,5 +1,5 @@
-@namespace DnsmasqWebUI.Components.Dnsmasq.EffectiveConfig
-@using DnsmasqWebUI.Extensions
+@namespace DnsmasqWebUI.Components.EffectiveConfig
+@using DnsmasqWebUI.Extensions.DependencyInjection
@using Microsoft.AspNetCore.Components
@using Microsoft.JSInterop
@using System.Text.Json.Serialization
@@ -50,19 +50,33 @@
    private DotNetObjectReference<ConfigOptionHelpModal>? _dotNetRef;
    private bool _scrollListenerAdded;
    private bool _mouseOverModal;
+    private IJSObjectReference? _jsModule;
+    private bool _moduleLoaded;

    protected override async Task OnAfterRenderAsync(bool firstRender)
    {
-        if (Visible && !_scrollListenerAdded)
+        if (firstRender)
+        {
+            try
+            {
+                _jsModule = await JSRuntime.InvokeAsync<IJSObjectReference>("import", "./js/config-option-help.js");
+                _moduleLoaded = true;
+            }
+            catch (InvalidOperationException) { /* prerender */ }
+            catch (JSDisconnectedException) { /* circuit disconnected */ }
+            catch (JSException) { /* import failed */ }
+        }
+
+        if (Visible && !_scrollListenerAdded && _moduleLoaded && _jsModule != null)
        {
            _scrollListenerAdded = true;
            _dotNetRef = DotNetObjectReference.Create(this);
-            await JSRuntime.InvokeVoidAsync("addConfigOptionHelpScrollCloseListener", _dotNetRef);
+            await _jsModule.InvokeVoidAsyncSafe("addScrollCloseListener", _dotNetRef);
        }
-        else if (!Visible && _scrollListenerAdded)
+        else if (!Visible && _scrollListenerAdded && _jsModule != null)
        {
            _scrollListenerAdded = false;
-            await JSRuntime.InvokeVoidAsync("removeConfigOptionHelpScrollCloseListener");
+            await _jsModule.InvokeVoidAsyncSafe("removeScrollCloseListener");
            _dotNetRef?.Dispose();
            _dotNetRef = null;
        }
@@ -79,13 +93,15 @@

    public async ValueTask DisposeAsync()
    {
-        if (_scrollListenerAdded)
+        if (_scrollListenerAdded && _jsModule != null)
        {
            _scrollListenerAdded = false;
-            try { await JSRuntime.InvokeVoidAsync("removeConfigOptionHelpScrollCloseListener"); } catch { /* best effort */ }
+            await _jsModule.InvokeVoidAsyncSafe("removeScrollCloseListener");
            _dotNetRef?.Dispose();
            _dotNetRef = null;
        }
+        await _jsModule.DisposeAsyncSafe();
+        _jsModule = null;
    }

    protected override async Task OnParametersSetAsync()
@@ -134,19 +150,16 @@

    private async Task PositionUnderAnchorAsync()
    {
-        if (string.IsNullOrEmpty(AnchorId)) return;
-        try
+        if (string.IsNullOrEmpty(AnchorId) || _jsModule == null) return;
+        var rect = await _jsModule.InvokeAsyncSafe<BoundingRect?>("getAnchorRect", AnchorId);
+        if (rect is { } r)
        {
-            var rect = await JSRuntime.InvokeAsync<BoundingRect?>("getConfigOptionHelpAnchorRect", AnchorId);
-            if (rect is { } r)
-            {
-                var gap = 4;
-                var topPx = r.Bottom + gap;
-                var leftPx = r.Left;
-                _positionStyle = $"position: fixed; top: {topPx}px; left: {leftPx}px; visibility: visible;";
-            }
+            var gap = 4;
+            var topPx = r.Bottom + gap;
+            var leftPx = r.Left;
+            _positionStyle = $"position: fixed; top: {topPx}px; left: {leftPx}px; visibility: visible;";
        }
-        catch
+        else
        {
            _positionStyle = "visibility: visible;";
        }
@@ -0,0 +1,155 @@
+@namespace DnsmasqWebUI.Components.EffectiveConfig
+@using DnsmasqWebUI.Models.Dnsmasq
+@using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig
+@using DnsmasqWebUI.Infrastructure.Services.EffectiveConfig.Abstractions
+@using DnsmasqWebUI.Infrastructure.Services.UI.Notifications.Abstractions
+@inject IEffectiveConfigSaveService SaveService
+@inject INotificationService NotificationService
+
+@if (ShowModal)
+{
+    <EffectiveConfigSaveModal
+        PendingChanges="@PendingChanges"
+        Status="@Status"
+        Session="@Session"
+        SaveState="@_saveState"
+        SaveResult="@_saveResult"
+        RestoreResult="@_restoreResult"
+        OnClose="@OnClose"
+        OnContinueEditing="@(EventCallback.Factory.Create(this, HandleContinueEditing))"
+        OnSave="@HandleSave"
+        OnRestore="@HandleRestore"
+        OnReverted="@HandleReverted"
+        OnCloseAndEndEdit="@HandleCloseAndEndEdit" />
+}
+
+@code {
+    public enum SaveUiState
+    {
+        Review,
+        Saving,
+        WriteFailed,
+        ValidateFailed,
+        ReloadFailed,
+        RestoreInProgress,
+        RestoreFailed
+    }
+
+    [Parameter] public bool ShowModal { get; set; }
+    [Parameter] public IReadOnlyList<PendingEffectiveConfigChange> PendingChanges { get; set; } = null!;
+    [Parameter] public DnsmasqServiceStatus? Status { get; set; }
+    [Parameter] public EventCallback OnClose { get; set; }
+    /// <summary>Invoked when the modal reverts a change so the parent can re-run validation (e.g. cross-option evaluator).</summary>
+    [Parameter] public EventCallback OnRevertedNotify { get; set; }
+    [Parameter] public EventCallback OnSaveCompleted { get; set; }
+    [Parameter] public EventCallback OnContinueEditingAfterSavedFailure { get; set; }
+    [Parameter] public EventCallback OnCloseAndEndEdit { get; set; }
+    [Parameter] public IEffectiveConfigEditSession Session { get; set; } = null!;
+
+    private SaveUiState _saveState = SaveUiState.Review;
+    private EffectiveConfigSaveResult? _saveResult;
+    private EffectiveConfigRestoreResult? _restoreResult;
+
+    protected override void OnParametersSet()
+    {
+        if (!ShowModal)
+        {
+            _saveState = SaveUiState.Review;
+            _saveResult = null;
+            _restoreResult = null;
+        }
+    }
+
+    private async Task HandleReverted()
+    {
+        if (OnRevertedNotify.HasDelegate)
+            await OnRevertedNotify.InvokeAsync();
+        await InvokeAsync(StateHasChanged);
+    }
+
+    private async Task HandleSave()
+    {
+        if (Session.PendingChanges.Count == 0) return;
+        if (Session.HasBlockingValidationErrors())
+        {
+            NotificationService.ShowError("Fix validation errors before saving.");
+            return;
+        }
+
+        _saveState = SaveUiState.Saving;
+        _saveResult = null;
+        _restoreResult = null;
+        await InvokeAsync(StateHasChanged);
+
+        var result = await Session.ApplyAsync();
+
+        _saveResult = result;
+        if (result.Saved && result.Restarted)
+        {
+            var message = result.UserMessage ?? "Config saved and dnsmasq restarted.";
+            NotificationService.ShowSuccess(message);
+            _saveState = SaveUiState.Review;
+            _saveResult = null;
+            await OnClose.InvokeAsync();
+            await OnSaveCompleted.InvokeAsync();
+            return;
+        }
+
+        if (result.Saved && result.IsValidateFailed)
+            _saveState = SaveUiState.ValidateFailed;
+        else if (result.Saved && !result.Restarted)
+            _saveState = SaveUiState.ReloadFailed;
+        else if (!result.Saved)
+            _saveState = SaveUiState.WriteFailed;
+        else
+            _saveState = SaveUiState.Review;
+
+        await InvokeAsync(StateHasChanged);
+    }
+
+    private async Task HandleRestore(string backupPath)
+    {
+        if (string.IsNullOrEmpty(backupPath)) return;
+
+        _saveState = SaveUiState.RestoreInProgress;
+        _restoreResult = null;
+        await InvokeAsync(StateHasChanged);
+
+        var result = await SaveService.RestoreAsync(backupPath);
+
+        _restoreResult = result;
+        if (result.Restored && result.Restarted)
+        {
+            var message = result.UserMessage ?? "Backup restored and dnsmasq restarted.";
+            NotificationService.ShowSuccess(message);
+            _saveState = SaveUiState.Review;
+            _saveResult = null;
+            _restoreResult = null;
+            await OnCloseAndEndEdit.InvokeAsync();
+            await OnSaveCompleted.InvokeAsync();
+            return;
+        }
+
+        _saveState = SaveUiState.RestoreFailed;
+        await InvokeAsync(StateHasChanged);
+    }
+
+    private async Task HandleContinueEditing()
+    {
+        if (_saveState == SaveUiState.ValidateFailed || _saveState == SaveUiState.ReloadFailed)
+        {
+            await OnContinueEditingAfterSavedFailure.InvokeAsync();
+            return;
+        }
+
+        await OnClose.InvokeAsync();
+    }
+
+    private async Task HandleCloseAndEndEdit()
+    {
+        await OnCloseAndEndEdit.InvokeAsync();
+
+        if (_saveState == SaveUiState.ValidateFailed || _saveState == SaveUiState.ReloadFailed)
+            await OnSaveCompleted.InvokeAsync();
+    }
+}
@@ -0,0 +1,343 @@
+@namespace DnsmasqWebUI.Components.EffectiveConfig
+@using DnsmasqWebUI.Models.Dnsmasq
+@using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig
+@using DnsmasqWebUI.Infrastructure.Services.EffectiveConfig.Abstractions
+@using DnsmasqWebUI.Infrastructure.Helpers.Config
+
+<div class="modal fade show" style="display: block;" tabindex="-1" role="dialog" aria-labelledby="ec-save-modal-title" aria-modal="true">
+    <div class="modal-dialog modal-dialog-scrollable" role="document">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h5 class="modal-title" id="ec-save-modal-title">Save effective config changes</h5>
+                <button type="button" class="btn-close" @onclick="Close" aria-label="Close" disabled="@(SaveState == EffectiveConfigSaveFlow.SaveUiState.Saving || SaveState == EffectiveConfigSaveFlow.SaveUiState.RestoreInProgress)"></button>
+            </div>
+            <div class="modal-body ec-save-modal-body">
+                @if (SaveState == EffectiveConfigSaveFlow.SaveUiState.Saving || SaveState == EffectiveConfigSaveFlow.SaveUiState.RestoreInProgress)
+                {
+                    <div class="ec-save-modal-loading text-center py-4">
+                        <div class="spinner-border text-primary" role="status" aria-hidden="true"></div>
+                        <p class="text-muted mt-2 mb-0">@(SaveState == EffectiveConfigSaveFlow.SaveUiState.Saving ? "Saving, validating and restarting…" : "Restoring backup and restarting…")</p>
+                    </div>
+                }
+                else if (SaveState == EffectiveConfigSaveFlow.SaveUiState.ValidateFailed && SaveResult != null)
+                {
+                    <div class="ec-save-modal-reload-failed">
+                        <div class="alert alert-danger mb-3 d-flex align-items-center gap-2 ec-save-modal-alert">
+                            <i class="bi bi-exclamation-triangle-fill ec-save-modal-alert-icon" aria-hidden="true"></i>
+                            <div class="ec-save-modal-alert-text">
+                                <strong>Config was saved, but validation failed.</strong> Restart was not attempted. You can restore the backup or keep editing.
+                            </div>
+                        </div>
+                        @if (SaveResult.BackupPath != null)
+                        {
+                            <p class="ec-save-modal-backup-path mb-2">
+                                <span class="text-muted">Backup:</span> <code class="small ec-save-modal-backup-code">@SaveResult.BackupPath</code>
+                            </p>
+                        }
+                        <div class="ec-save-modal-stderr mb-3">
+                            <p class="text-muted small mb-1"><strong>Validation output</strong></p>
+                            <pre class="ec-save-modal-pre border rounded p-2 bg-light small mb-0 text-body">@GetValidationFailedOutput(SaveResult)</pre>
+                        </div>
+                    </div>
+                }
+                else if (SaveState == EffectiveConfigSaveFlow.SaveUiState.WriteFailed && SaveResult != null)
+                {
+                    <div class="alert alert-danger mb-0">
+                        <strong>Save failed.</strong> @SaveResult.UserMessage
+                        @if (!string.IsNullOrEmpty(SaveResult.RestartStdErr))
+                        {
+                            <pre class="ec-save-modal-pre border rounded p-2 bg-light small mt-2 mb-0">@SaveResult.RestartStdErr</pre>
+                        }
+                    </div>
+                }
+                else if (SaveState == EffectiveConfigSaveFlow.SaveUiState.ReloadFailed && SaveResult != null)
+                {
+                    <div class="ec-save-modal-reload-failed">
+                        <div class="alert alert-danger mb-3 d-flex align-items-center gap-2 ec-save-modal-alert">
+                            <i class="bi bi-exclamation-triangle-fill ec-save-modal-alert-icon" aria-hidden="true"></i>
+                            <div class="ec-save-modal-alert-text">
+                                <strong>Config was saved, but the restart command failed.</strong> You can restore the backup or keep editing.
+                            </div>
+                        </div>
+                        @if (SaveResult.BackupPath != null)
+                        {
+                            <p class="ec-save-modal-backup-path mb-2">
+                                <span class="text-muted">Backup:</span> <code class="small ec-save-modal-backup-code">@SaveResult.BackupPath</code>
+                            </p>
+                        }
+                        <div class="ec-save-modal-stderr mb-3">
+                            <p class="text-muted small mb-1"><strong>Command output</strong></p>
+                            <pre class="ec-save-modal-pre border rounded p-2 bg-light small mb-0 text-body">@GetRestartFailedOutput(SaveResult)</pre>
+                        </div>
+                    </div>
+                }
+                else if (SaveState == EffectiveConfigSaveFlow.SaveUiState.RestoreFailed && RestoreResult != null)
+                {
+                    <div class="ec-save-modal-restore-failed">
+                        <div class="alert alert-danger mb-3 d-flex align-items-center gap-2 ec-save-modal-alert">
+                            <i class="bi bi-exclamation-triangle-fill ec-save-modal-alert-icon" aria-hidden="true"></i>
+                            <div class="ec-save-modal-alert-text">@RestoreResult.UserMessage</div>
+                        </div>
+                        <div class="ec-save-modal-stderr mb-3">
+                            <p class="text-muted small mb-1"><strong>Command output</strong></p>
+                            <pre class="ec-save-modal-pre border rounded p-2 bg-light small mb-0 text-body">@GetRestoreFailedOutput(RestoreResult)</pre>
+                        </div>
+                    </div>
+                }
+                else
+                {
+                    @if (ValidationErrors.Count > 0 || ValidationWarnings.Count > 0)
+                    {
+                        <div class="ec-save-modal-validation mb-3">
+                            @if (ValidationErrors.Count > 0)
+                            {
+                                <div class="alert alert-danger py-2 mb-2">
+                                    <strong>Validation errors</strong>
+                                    <ul class="mb-0 mt-1 ps-3">
+                                        @foreach (var issue in ValidationErrors)
+                                        {
+                                            <li>@issue.Message</li>
+                                        }
+                                    </ul>
+                                </div>
+                            }
+                            @if (ValidationWarnings.Count > 0)
+                            {
+                                <div class="alert alert-warning py-2 mb-2">
+                                    <strong>Validation warnings</strong>
+                                    <ul class="mb-0 mt-1 ps-3">
+                                        @foreach (var issue in ValidationWarnings)
+                                        {
+                                            <li>@issue.Message</li>
+                                        }
+                                    </ul>
+                                </div>
+                            }
+                        </div>
+                    }
+                    <p class="text-muted mb-3">These changes will be written to your config. Remove any you don't want to keep.</p>
+                    @if (ManagedFilePath != null)
+                    {
+                        <p class="ec-save-modal-target mb-3">
+                            <span class="text-muted">Target file:</span> <code class="small">@ManagedFilePath</code>
+                        </p>
+                    }
+                    @if (PendingChanges.Count == 0)
+                    {
+                        <div class="ec-save-modal-empty alert alert-light border text-center text-muted py-4 mb-0">
+                            No pending changes. Close to continue editing.
+                        </div>
+                    }
+                    else
+                    {
+                        <div class="ec-save-modal-changes list-group list-group-flush">
+                            @foreach (var c in PendingChanges)
+                            {
+                                var change = c;
+                                var oldList = AsStringList(change.OldValue);
+                                var newList = AsStringList(change.NewValue);
+                                var isMultiValue = oldList != null || newList != null;
+                                <div class="list-group-item ec-save-modal-item d-flex align-items-start gap-3 py-3 px-0 border-0 border-bottom">
+                                    <div class="ec-save-modal-item-body flex-grow-1 min-width-0">
+                                        <div class="d-flex align-items-center gap-2">
+                                            <StatusBadge Kind="StatusBadgeKind.NeutralPill" Text="@change.OptionName" Class="ec-save-modal-option me-2" />
+                                            @if (!isMultiValue)
+                                            {
+                                                <span class="ec-save-modal-diff text-body">
+                                                    <span class="text-muted text-decoration-line-through">@FormatValue(change.OldValue, change.OptionName)</span>
+                                                    <span class="text-muted mx-1" aria-hidden="true">→</span>
+                                                    <span>@FormatValue(change.NewValue, change.OptionName)</span>
+                                                </span>
+                                            }
+                                        </div>
+                                        @if (isMultiValue)
+                                        {
+                                            var oldSeq = oldList ?? Array.Empty<string>();
+                                            var newSeq = newList ?? Array.Empty<string>();
+                                            var added = newSeq.Except(oldSeq).ToList();
+                                            var removed = oldSeq.Except(newSeq).ToList();
+                                            var orderOrDuplicatesChanged = added.Count == 0 && removed.Count == 0 && !oldSeq.SequenceEqual(newSeq, StringComparer.Ordinal);
+                                            <div class="ec-save-modal-multidiff ps-3 mt-1 small">
+                                                @if (orderOrDuplicatesChanged)
+                                                {
+                                                    <div class="text-muted">Order or duplicates changed:</div>
+                                                    <div class="text-muted text-decoration-line-through">Before: @string.Join(", ", oldSeq)</div>
+                                                    <div class="text-success">After: @string.Join(", ", newSeq)</div>
+                                                }
+                                                else
+                                                {
+                                                    @foreach (var val in removed)
+                                                    {
+                                                        <div class="text-muted text-decoration-line-through">− @val</div>
+                                                    }
+                                                    @foreach (var val in added)
+                                                    {
+                                                        <div class="text-success">+ @val</div>
+                                                    }
+                                                }
+                                            </div>
+                                        }
+                                        @if (change.CurrentSourceFilePath != null)
+                                        {
+                                            <div class="ec-save-modal-override small text-muted mt-1">Overrides @System.IO.Path.GetFileName(change.CurrentSourceFilePath)</div>
+                                        }
+                                    </div>
+                                    <button type="button" class="btn btn-sm btn-outline-danger flex-shrink-0" @onclick="() => Revert(change)" title="Revert this change" aria-label="Revert @change.OptionName">
+                                        <i class="bi bi-arrow-counterclockwise me-1" aria-hidden="true"></i>Revert
+                                    </button>
+                                </div>
+                            }
+                        </div>
+                    }
+                }
+            </div>
+            <div class="modal-footer ec-save-modal-footer">
+                @if ((SaveState == EffectiveConfigSaveFlow.SaveUiState.ReloadFailed || SaveState == EffectiveConfigSaveFlow.SaveUiState.ValidateFailed) && SaveResult?.BackupPath != null)
+                {
+                    <button type="button" class="btn btn-primary" @onclick="() => Restore(SaveResult.BackupPath)"><i class="bi bi-arrow-counterclockwise me-1" aria-hidden="true"></i>Restore backup</button>
+                    <button type="button" class="btn btn-outline-warning" @onclick="ContinueEditing"><i class="bi bi-pencil me-1" aria-hidden="true"></i>Continue editing</button>
+                    <button type="button" class="btn btn-danger" @onclick="CloseAndEndEdit"><i class="bi bi-x-circle me-1" aria-hidden="true"></i>Stop editing</button>
+                }
+                else if (SaveState == EffectiveConfigSaveFlow.SaveUiState.RestoreFailed)
+                {
+                    <button type="button" class="btn btn-outline-warning" @onclick="Close"><i class="bi bi-pencil me-1" aria-hidden="true"></i>Continue editing</button>
+                    <button type="button" class="btn btn-danger" @onclick="CloseAndEndEdit"><i class="bi bi-x-circle me-1" aria-hidden="true"></i>Stop editing</button>
+                }
+                else if (SaveState == EffectiveConfigSaveFlow.SaveUiState.WriteFailed)
+                {
+                    <button type="button" class="btn btn-outline-warning" @onclick="Close"><i class="bi bi-pencil me-1" aria-hidden="true"></i>Continue editing</button>
+                }
+                else if (SaveState != EffectiveConfigSaveFlow.SaveUiState.Saving && SaveState != EffectiveConfigSaveFlow.SaveUiState.RestoreInProgress)
+                {
+                    <button type="button" class="btn btn-secondary" @onclick="Close"><i class="bi bi-x me-1" aria-hidden="true"></i>Cancel</button>
+                    <button type="button" class="btn btn-primary" @onclick="Save" disabled="@(PendingChanges.Count == 0 || HasBlockingValidationErrors)"><i class="bi bi-floppy-fill me-1" aria-hidden="true"></i>Save</button>
+                }
+            </div>
+        </div>
+    </div>
+    <div class="modal-backdrop fade show" style="display: block;" @onclick="OnBackdropClick"></div>
+</div>
+
+@code {
+    [Parameter] public IReadOnlyList<PendingEffectiveConfigChange> PendingChanges { get; set; } = null!;
+    [Parameter] public DnsmasqServiceStatus? Status { get; set; }
+    [Parameter] public IEffectiveConfigEditSession Session { get; set; } = null!;
+    [Parameter] public EffectiveConfigSaveFlow.SaveUiState SaveState { get; set; }
+    [Parameter] public EffectiveConfigSaveResult? SaveResult { get; set; }
+    [Parameter] public EffectiveConfigRestoreResult? RestoreResult { get; set; }
+    [Parameter] public EventCallback OnClose { get; set; }
+    [Parameter] public EventCallback OnContinueEditing { get; set; }
+    [Parameter] public EventCallback OnSave { get; set; }
+    [Parameter] public EventCallback<string> OnRestore { get; set; }
+    [Parameter] public EventCallback OnReverted { get; set; }
+    [Parameter] public EventCallback OnCloseAndEndEdit { get; set; }
+
+    private bool AllowClose => SaveState != EffectiveConfigSaveFlow.SaveUiState.Saving && SaveState != EffectiveConfigSaveFlow.SaveUiState.RestoreInProgress;
+
+    private string? ManagedFilePath => Status?.ManagedFilePath;
+
+    private IReadOnlyList<FieldIssue> ValidationErrors => Session.GetValidationSummary().Where(i => i.Severity == FieldIssueSeverity.Error).ToList();
+    private IReadOnlyList<FieldIssue> ValidationWarnings => Session.GetValidationSummary().Where(i => i.Severity == FieldIssueSeverity.Warning).ToList();
+    private bool HasBlockingValidationErrors => Session.HasBlockingValidationErrors();
+
+    private static string GetValidationFailedOutput(EffectiveConfigSaveResult result)
+    {
+        var err = (result.ValidationStdErr ?? "").Trim();
+        var outp = (result.ValidationStdOut ?? "").Trim();
+        if (err.Length > 0 && outp.Length > 0)
+            return err + "\n\n" + outp;
+        if (err.Length > 0) return err;
+        if (outp.Length > 0) return outp;
+        var exitInfo = result.ValidationExitCode >= 0 ? $"Exit code: {result.ValidationExitCode}." : "";
+        return string.IsNullOrEmpty(exitInfo) ? "(No output captured)" : exitInfo + " (No output captured)";
+    }
+
+    private static string GetRestartFailedOutput(EffectiveConfigSaveResult result)
+    {
+        var err = (result.RestartStdErr ?? "").Trim();
+        var outp = (result.RestartStdOut ?? "").Trim();
+        if (err.Length > 0 && outp.Length > 0)
+            return err + "\n\n" + outp;
+        if (err.Length > 0) return err;
+        if (outp.Length > 0) return outp;
+        var exitInfo = result.RestartExitCode >= 0 ? $"Exit code: {result.RestartExitCode}." : "";
+        return string.IsNullOrEmpty(exitInfo) ? "(No output captured)" : exitInfo + " (No output captured)";
+    }
+
+    private static string GetRestoreFailedOutput(EffectiveConfigRestoreResult result)
+    {
+        var err = (result.RestartStdErr ?? "").Trim();
+        if (err.Length > 0) return err;
+        var exitInfo = result.RestartExitCode >= 0 ? $"Exit code: {result.RestartExitCode}." : "";
+        return string.IsNullOrEmpty(exitInfo) ? "(No output captured)" : exitInfo + " (No output captured)";
+    }
+
+    /// <summary>If the value is a list of strings (multi-value option), return it; otherwise null.</summary>
+    private static IReadOnlyList<string>? AsStringList(object? v)
+    {
+        if (v == null) return null;
+        if (v is IReadOnlyList<string> ro) return ro;
+        if (v is List<string> list) return list;
+        if (v is string[] arr) return arr;
+        return null;
+    }
+
+    private static string FormatValue(object? v, string? optionName = null)
+    {
+        if (optionName != null && EffectiveConfigWriteSemantics.GetBehavior(optionName) == EffectiveConfigWriteBehavior.KeyOnlyOrValue)
+            return FormatKeyOnlyOrValue(v);
+        if (v == null) return "(not set)";
+        if (v is bool b) return b ? "on" : "off";
+        var list = AsStringList(v);
+        if (list != null) return list.Count == 0 ? "(none)" : string.Join(", ", list);
+        return v.ToString() ?? "(not set)";
+    }
+
+    private static string FormatKeyOnlyOrValue(object? v)
+    {
+        if (v == null) return "(not set)";
+        var s = v.ToString();
+        if (string.IsNullOrEmpty(s)) return "(set)";
+        return s;
+    }
+
+    private async Task Revert(PendingEffectiveConfigChange change)
+    {
+        Session.RevertChange(change.SectionId, change.OptionName);
+        await OnReverted.InvokeAsync();
+    }
+
+    private async Task OnBackdropClick()
+    {
+        if (!AllowClose) return;
+        await Close();
+    }
+
+    private async Task Close()
+    {
+        if (!AllowClose) return;
+        await OnClose.InvokeAsync();
+    }
+
+    private async Task ContinueEditing()
+    {
+        if (!AllowClose) return;
+        await OnContinueEditing.InvokeAsync();
+    }
+
+    private async Task Save()
+    {
+        await OnSave.InvokeAsync();
+    }
+
+    private async Task Restore(string backupPath)
+    {
+        await OnRestore.InvokeAsync(backupPath);
+    }
+
+    private async Task CloseAndEndEdit()
+    {
+        if (!AllowClose) return;
+        await OnCloseAndEndEdit.InvokeAsync();
+    }
+}
@@ -0,0 +1,87 @@
+/* Keep footer buttons on one line */
+.ec-save-modal-footer {
+    flex-wrap: nowrap;
+}
+
+/* Ensure the dialog stacks above the backdrop when both are siblings inside .modal */
+.modal-dialog {
+    position: relative;
+    z-index: 1056;
+}
+
+.modal-backdrop {
+    z-index: 1050;
+}
+
+.ec-save-modal-body {
+    padding-top: 0.25rem;
+}
+
+.ec-save-modal-target {
+    font-size: 0.9rem;
+}
+
+.ec-save-modal-changes {
+    margin: 0 -1rem;
+    padding: 0 1rem;
+}
+
+.ec-save-modal-item:last-child {
+    border-bottom: 0 !important;
+}
+
+.ec-save-modal-option {
+    font-weight: 500;
+    font-size: 0.75rem;
+}
+
+.ec-save-modal-diff {
+    font-size: 0.9375rem;
+}
+
+.ec-save-modal-override {
+    font-size: 0.8125rem;
+}
+
+.ec-save-modal-empty {
+    font-size: 0.9rem;
+}
+
+.ec-save-modal-loading {
+    min-height: 6rem;
+}
+
+.ec-save-modal-backup-path {
+    font-size: 0.9rem;
+}
+
+.ec-save-modal-backup-code {
+    word-break: break-all;
+}
+
+/* Command output: ensure text is always visible (avoid inherited color/visibility issues) */
+.ec-save-modal-pre {
+    font-size: 0.8125rem;
+    max-height: 12rem;
+    overflow: auto;
+    color: var(--bs-body-color, #212529);
+    white-space: pre-wrap;
+    word-break: break-word;
+    min-height: 2.5rem;
+}
+
+/* Alert icon in reload/restore failed states: larger, spacing, aligned with text */
+.ec-save-modal-alert {
+    --ec-save-modal-alert-icon-gap: 0.5rem;
+}
+
+.ec-save-modal-alert-icon {
+    flex-shrink: 0;
+    font-size: 1.25rem;
+    margin-right: var(--ec-save-modal-alert-icon-gap);
+    line-height: 1;
+}
+
+.ec-save-modal-alert-text {
+    min-width: 0;
+}
@@ -0,0 +1,57 @@
+@namespace DnsmasqWebUI.Components.EffectiveConfig
+@using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig
+
+<ConfigOptionHelpModal HelpKey="@HelpKey" AnchorId="@AnchorId" Visible="@Visible" Title="@Title"
+    OnClose="RequestClose" OnMouseEnterModal="CancelCloseTimer" OnMouseLeaveModal="ScheduleClose" />
+
+@code {
+    [Parameter] public bool Visible { get; set; }
+    [Parameter] public string? HelpKey { get; set; }
+    [Parameter] public string? AnchorId { get; set; }
+    [Parameter] public string Title { get; set; } = "Option help";
+    [Parameter] public EventCallback OnCloseRequested { get; set; }
+
+    private CancellationTokenSource? _closeCts;
+
+    private void CancelCloseTimer()
+    {
+        _closeCts?.Cancel();
+        _closeCts = null;
+    }
+
+    private void ScheduleClose()
+    {
+        _closeCts?.Cancel();
+        _closeCts = new CancellationTokenSource();
+        var token = _closeCts.Token;
+        _ = Task.Run(async () =>
+        {
+            try { await Task.Delay(300, token); }
+            catch (OperationCanceledException) { return; }
+            await InvokeAsync(async () =>
+            {
+                if (token.IsCancellationRequested) return;
+                _closeCts = null;
+                await OnCloseRequested.InvokeAsync();
+            });
+        }, token);
+    }
+
+    private async Task RequestClose()
+    {
+        CancelCloseTimer();
+        await OnCloseRequested.InvokeAsync();
+    }
+
+    /// <summary>Called by the section when the label loses mouse (so we schedule close; if user moves to modal, OnMouseEnterModal cancels).</summary>
+    public void ScheduleCloseFromLabelLeave()
+    {
+        ScheduleClose();
+    }
+
+    /// <summary>Called when opening or switching help (e.g. user clicked another label); cancels any pending 300ms close so the timer from a previous label leave does not dismiss the new help.</summary>
+    public void CancelCloseFromLabelEnter()
+    {
+        CancelCloseTimer();
+    }
+}
@@ -0,0 +1,40 @@
+@namespace DnsmasqWebUI.Components.EffectiveConfig
+@using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig
+
+<span id="@AnchorId" class="@EffectiveCssClass" title="@Title" @onclick="OnClick" @onmouseleave="OnMouseLeave">
+    @ChildContent
+</span>
+
+@code {
+    [Parameter] public string AnchorId { get; set; } = "";
+    [Parameter] public string? HelpKey { get; set; }
+    [Parameter] public string OptionLabel { get; set; } = "";
+    [Parameter] public string? CssClass { get; set; }
+
+    private string EffectiveCssClass =>
+        CssClass ?? (!string.IsNullOrEmpty(HelpKey) ? "ec-field-label ec-field-label-help" : "ec-field-label");
+    [Parameter] public string? Title { get; set; }
+    [CascadingParameter] public EffectiveConfigUiContext? Ui { get; set; }
+    [Parameter] public RenderFragment? ChildContent { get; set; }
+
+    private Task OnClick()
+    {
+        if (Ui == null || string.IsNullOrEmpty(HelpKey)) return Task.CompletedTask;
+        return Ui.RequestOptionHelpAsync(new ConfigOptionHelpRequestEventArgs
+        {
+            HelpKey = HelpKey,
+            OptionLabel = OptionLabel,
+            AnchorId = AnchorId
+        });
+    }
+
+    private Task OnMouseLeave()
+    {
+        if (Ui == null) return Task.CompletedTask;
+        return Ui.RequestOptionHelpAsync(new ConfigOptionHelpRequestEventArgs
+        {
+            AnchorId = AnchorId,
+            IsLabelMouseLeave = true
+        });
+    }
+}
@@ -0,0 +1,143 @@
+@namespace DnsmasqWebUI.Components.EffectiveConfig
+@using DnsmasqWebUI.Models.Dnsmasq
+@using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig
+
+@if (IsCapabilityDisabled)
+{
+    <StatusBadge Kind="StatusBadgeKind.ReadOnly"
+                 Text="disabled"
+                 Title="@CapabilityDisabledReason"
+                 Class="status-badge-inline" />
+}
+else if (Source?.IsReadOnly == true)
+{
+    var readonlyTitle = !string.IsNullOrEmpty(ReadonlyTitleOverride) ? ReadonlyTitleOverride : Source?.GetReadOnlyTooltip();
+    if (ReadonlyClickActivatesField && Ui != null && !string.IsNullOrEmpty(FieldKey))
+    {
+        <StatusBadge Kind="StatusBadgeKind.ReadOnly" Text="readonly" Clickable="true"
+                     Id="@AnchorId" Title="@readonlyTitle"
+                     OnClick="OnEditableClick"
+                     Class="status-badge-inline" />
+    }
+    else if (IsInteractive && Ui != null)
+    {
+        <StatusBadge Kind="StatusBadgeKind.ReadOnly" Text="readonly" Clickable="true"
+                     Id="@AnchorId" Title="@readonlyTitle"
+                     OnClick="OnReadonlyClick" OnMouseLeave="OnReadonlyMouseLeave"
+                     Class="status-badge-inline" />
+    }
+    else
+    {
+        <StatusBadge Kind="StatusBadgeKind.ReadOnly" Text="readonly"
+                     Title="@readonlyTitle"
+                     Class="status-badge-inline" />
+    }
+}
+else if (ShowEditableBadge)
+{
+    @if (EditableAsButton)
+    {
+        @if (IsActiveEditor)
+        {
+            <span class="status-badge-inline">
+                <StatusBadge Kind="StatusBadgeKind.ActionOk" Text="ok" Clickable="true"
+                             Title="Apply this field change" AriaLabel="Apply change"
+                             PreventBlurOnMouseDown="true" OnClick="OnConfirmClick" />
+                <StatusBadge Kind="StatusBadgeKind.ActionCancel" Text="cancel" Clickable="true"
+                             Title="Discard in-progress edits for this field" AriaLabel="Cancel edit"
+                             PreventBlurOnMouseDown="true" OnClick="OnCancelClick" />
+                @if (HasPendingChange)
+                {
+                    <StatusBadge Kind="StatusBadgeKind.ActionRevert" Text="revert" Clickable="true"
+                                 Title="Remove this field from pending changes" AriaLabel="Revert pending change"
+                                 PreventBlurOnMouseDown="true" OnClick="OnRevertClick" />
+                }
+            </span>
+        }
+        else
+        {
+            <StatusBadge Kind="@(HasPendingChange ? StatusBadgeKind.Pending : StatusBadgeKind.Editable)"
+                         Text="@(HasPendingChange ? "pending" : "editable")"
+                         Clickable="true"
+                         Title="@(HasPendingChange ? "Pending change" : "Edit this field")"
+                         AriaLabel="Edit"
+                         OnClick="OnEditableClick"
+                         Class="status-badge-inline" />
+        }
+    }
+    else
+    {
+        <StatusBadge Kind="StatusBadgeKind.Editable" Text="editable"
+                     Class="status-badge-inline" />
+    }
+}
+
+@code {
+    [Parameter] public string AnchorId { get; set; } = "";
+    [Parameter] public ConfigValueSource? Source { get; set; }
+    [Parameter] public string OptionName { get; set; } = "";
+    [Parameter] public object? Value { get; set; }
+    [Parameter] public bool IsInteractive { get; set; }
+    [Parameter] public bool ShowEditableBadge { get; set; }
+    [Parameter] public bool HasPendingChange { get; set; }
+    [Parameter] public bool EditableAsButton { get; set; } = true;
+    [Parameter] public bool IsActiveEditor { get; set; }
+    [Parameter] public EventCallback OnConfirmRequested { get; set; }
+    [Parameter] public EventCallback OnCancelRequested { get; set; }
+    [Parameter] public EventCallback OnRevertRequested { get; set; }
+    [Parameter] public string? FieldKey { get; set; }
+    /// <summary>Optional: when set, editable-badge click invokes this instead of activating the field by key (e.g. list editor per-item edit).</summary>
+    [Parameter] public EventCallback OnEditableClickRequested { get; set; }
+    /// <summary>When true, readonly badge click activates the field for editing instead of showing the readonly popover (e.g. for multi-value where new items can still be added).</summary>
+    [Parameter] public bool ReadonlyClickActivatesField { get; set; }
+    /// <summary>Optional tooltip for readonly badge when <see cref="ReadonlyClickActivatesField"/> is true (e.g. "New values can still be added. Click to edit.").</summary>
+    [Parameter] public string? ReadonlyTitleOverride { get; set; }
+    /// <summary>When true, option is disabled because dnsmasq build does not support it (e.g. no DNSSEC).</summary>
+    [Parameter] public bool IsCapabilityDisabled { get; set; }
+    /// <summary>Tooltip shown when <see cref="IsCapabilityDisabled"/> is true (e.g. "This dnsmasq build does not support DNSSEC; option not written.").</summary>
+    [Parameter] public string? CapabilityDisabledReason { get; set; }
+    [CascadingParameter] public EffectiveConfigUiContext? Ui { get; set; }
+
+    private async Task OnConfirmClick()
+    {
+        if (OnConfirmRequested.HasDelegate)
+            await OnConfirmRequested.InvokeAsync();
+    }
+
+    private async Task OnCancelClick()
+    {
+        if (OnCancelRequested.HasDelegate)
+            await OnCancelRequested.InvokeAsync();
+        else if (Ui != null)
+            await Ui.DeactivateFieldAsync();
+    }
+
+    private async Task OnRevertClick()
+    {
+        if (OnRevertRequested.HasDelegate)
+            await OnRevertRequested.InvokeAsync();
+    }
+
+    private async Task OnEditableClick()
+    {
+        if (OnEditableClickRequested.HasDelegate)
+        {
+            await OnEditableClickRequested.InvokeAsync();
+            return;
+        }
+        if (Ui != null && !string.IsNullOrEmpty(FieldKey))
+            await Ui.ActivateFieldAsync(FieldKey);
+    }
+
+    private Task OnReadonlyClick()
+    {
+        if (Ui == null || Source == null) return Task.CompletedTask;
+        return Ui.RequestReadonlyPopoverAsync(new ReadonlyBadgeClickedEventArgs(AnchorId, Source, OptionName, Value));
+    }
+
+    private Task OnReadonlyMouseLeave()
+    {
+        if (Ui == null) return Task.CompletedTask;
+        return Ui.ScheduleReadonlyPopoverCloseAsync();
+    }
+}
@@ -0,0 +1,47 @@
+@namespace DnsmasqWebUI.Components.EffectiveConfig
+@using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig
+@using DnsmasqWebUI.Infrastructure.Helpers.Config
+
+@if (Source is { IsReadOnly: true })
+{
+    <div class="ec-readonly-hint small text-muted mt-1">
+        <span class="d-block">@ReadonlyConfigCommandGenerator.GetEditFileHint(Source)</span>
+        @if (!string.IsNullOrEmpty(_removeCommand))
+        {
+            <div class="mt-1">
+                <CopyableCodeLine Text="@_removeCommand" CssClass="small" CodeCssClass="small text-break" CopyTitle="Copy command" />
+            </div>
+        }
+        @if (!string.IsNullOrEmpty(_overrideLine))
+        {
+            <span class="d-block mt-1">@ReadonlyConfigCommandGenerator.GetOverrideHint(OptionName, Value, ManagedFilePath)</span>
+            <div class="mt-1">
+                <CopyableCodeLine Text="@_overrideLine" CodeCssClass="small" CopyTitle="Copy line" />
+            </div>
+        }
+    </div>
+}
+
+@code {
+    [Parameter] public ConfigValueSource? Source { get; set; }
+    [Parameter] public string OptionName { get; set; } = "";
+    [Parameter] public object? Value { get; set; }
+    [Parameter] public string? ManagedFilePath { get; set; }
+
+    private string _removeCommand = "";
+    private string _overrideLine = "";
+
+    protected override void OnParametersSet()
+    {
+        if (Source is { IsReadOnly: true })
+        {
+            _removeCommand = ReadonlyConfigCommandGenerator.GetRemoveLineCommand(Source, OptionName);
+            _overrideLine = ReadonlyConfigCommandGenerator.GetOverrideLine(OptionName, Value, ManagedFilePath);
+        }
+        else
+        {
+            _removeCommand = "";
+            _overrideLine = "";
+        }
+    }
+}
@@ -0,0 +1,171 @@
+@namespace DnsmasqWebUI.Components.EffectiveConfig
+@using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig
+@using DnsmasqWebUI.Infrastructure.Helpers.Config
+@using DnsmasqWebUI.Extensions
+@using Microsoft.AspNetCore.Components
+@using Microsoft.JSInterop
+@using System.Text.Json.Serialization
+@inject IJSRuntime JSRuntime
+@implements IAsyncDisposable
+
+@if (Visible && Source != null)
+{
+    <div class="ec-readonly-popover" id="@_popoverId" style="@_positionStyle" @onmouseenter="OnPopoverMouseEnter" @onmouseleave="OnPopoverMouseLeave">
+        <div class="ec-readonly-popover-content">
+            <div class="ec-readonly-popover-header">
+                <span class="ec-readonly-popover-title">Read-only: @OptionName</span>
+            </div>
+            <div class="ec-readonly-popover-body small">
+                <p class="text-muted mb-2">@ReadonlyConfigCommandGenerator.GetEditFileHint(Source)</p>
+                @if (!string.IsNullOrEmpty(_removeCommand))
+                {
+                    <div class="mb-2">
+                        <CopyableCodeLine Text="@_removeCommand" CodeCssClass="small" CopyTitle="Copy command" />
+                    </div>
+                }
+                @if (!string.IsNullOrEmpty(_overrideLine))
+                {
+                    <p class="text-muted mb-1">@ReadonlyConfigCommandGenerator.GetOverrideHint(OptionName, Value, ManagedFilePath)</p>
+                    <CopyableCodeLine Text="@_overrideLine" CodeCssClass="small" CopyTitle="Copy line" />
+                }
+            </div>
+        </div>
+    </div>
+}
+
+@code {
+    [Parameter] public bool Visible { get; set; }
+    [Parameter] public string? AnchorId { get; set; }
+    [Parameter] public ConfigValueSource? Source { get; set; }
+    [Parameter] public string OptionName { get; set; } = "";
+    [Parameter] public object? Value { get; set; }
+    [Parameter] public string? ManagedFilePath { get; set; }
+    [Parameter] public EventCallback OnClose { get; set; }
+    [Parameter] public EventCallback OnMouseEnterPopover { get; set; }
+    [Parameter] public EventCallback OnMouseLeavePopover { get; set; }
+
+    private const string HiddenPositionStyle = "position: fixed; z-index: 1060; left: 0; top: 0; visibility: hidden;";
+    private const string VisiblePositionStyleFormat = "position: fixed; top: {0}px; left: {1}px; visibility: visible;";
+
+    private string _positionStyle = "";
+    private readonly string _popoverId = "ec-readonly-popover-" + Guid.NewGuid().ToString("N")[..8];
+    private DotNetObjectReference<ReadonlyEditPopover>? _dotNetRef;
+    private bool _scrollListenerAdded;
+    private bool _mouseOverPopover;
+    private IJSObjectReference? _jsModule;
+    private bool _moduleLoaded;
+    private string _removeCommand = "";
+    private string _overrideLine = "";
+
+    protected override void OnParametersSet()
+    {
+        if (Source is { IsReadOnly: true })
+        {
+            _removeCommand = ReadonlyConfigCommandGenerator.GetRemoveLineCommand(Source, OptionName);
+            _overrideLine = ReadonlyConfigCommandGenerator.GetOverrideLine(OptionName, Value, ManagedFilePath);
+        }
+        else
+        {
+            _removeCommand = "";
+            _overrideLine = "";
+        }
+        if (Visible && string.IsNullOrEmpty(_positionStyle))
+            _positionStyle = HiddenPositionStyle;
+    }
+
+    protected override async Task OnAfterRenderAsync(bool firstRender)
+    {
+        if (firstRender)
+        {
+            try
+            {
+                _jsModule = await JSRuntime.InvokeAsync<IJSObjectReference>("import", "./js/config-option-help.js");
+                _moduleLoaded = true;
+            }
+            catch (InvalidOperationException) { }
+            catch (JSDisconnectedException) { }
+            catch (JSException) { }
+        }
+
+        if (Visible && !_scrollListenerAdded && _moduleLoaded && _jsModule != null)
+        {
+            _scrollListenerAdded = true;
+            _dotNetRef = DotNetObjectReference.Create(this);
+            await _jsModule.InvokeVoidAsyncSafe("addScrollCloseListener", _dotNetRef);
+        }
+        else if (!Visible && _scrollListenerAdded && _jsModule != null)
+        {
+            _scrollListenerAdded = false;
+            await _jsModule.InvokeVoidAsyncSafe("removeScrollCloseListener");
+            _dotNetRef?.Dispose();
+            _dotNetRef = null;
+        }
+
+        if (!Visible)
+            _positionStyle = "";
+
+        if (Visible && _moduleLoaded && _jsModule != null)
+        {
+            await PositionUnderAnchorAsync();
+            StateHasChanged();
+        }
+    }
+
+    [JSInvokable]
+    public async Task OnScrollClose()
+    {
+        await PositionUnderAnchorAsync();
+        StateHasChanged();
+        if (!_mouseOverPopover)
+            await OnClose.InvokeAsync();
+    }
+
+    public async ValueTask DisposeAsync()
+    {
+        if (_scrollListenerAdded && _jsModule != null)
+        {
+            _scrollListenerAdded = false;
+            await _jsModule.InvokeVoidAsyncSafe("removeScrollCloseListener");
+            _dotNetRef?.Dispose();
+            _dotNetRef = null;
+        }
+        await _jsModule.DisposeAsyncSafe();
+        _jsModule = null;
+    }
+
+    private async Task PositionUnderAnchorAsync()
+    {
+        if (string.IsNullOrEmpty(AnchorId) || _jsModule == null) return;
+        var rect = await _jsModule.InvokeAsyncSafe<BoundingRect?>("getAnchorRect", AnchorId);
+        if (rect is { } r)
+        {
+            var gap = 4;
+            var topPx = r.Bottom + gap;
+            var leftPx = r.Left;
+            _positionStyle = string.Format(VisiblePositionStyleFormat, topPx, leftPx);
+        }
+        else
+        {
+            _positionStyle = HiddenPositionStyle;
+        }
+    }
+
+    private async Task OnPopoverMouseEnter()
+    {
+        _mouseOverPopover = true;
+        await OnMouseEnterPopover.InvokeAsync();
+    }
+
+    private async Task OnPopoverMouseLeave()
+    {
+        _mouseOverPopover = false;
+        await OnMouseLeavePopover.InvokeAsync();
+    }
+
+    private sealed record BoundingRect(
+        [property: JsonPropertyName("top")] double Top,
+        [property: JsonPropertyName("left")] double Left,
+        [property: JsonPropertyName("bottom")] double Bottom,
+        [property: JsonPropertyName("width")] double Width,
+        [property: JsonPropertyName("height")] double Height);
+}
@@ -0,0 +1,36 @@
+/* Readonly edit popover: anchored under the badge; same look as option help popover */
+.ec-readonly-popover {
+    position: fixed;
+    z-index: 1060;
+    max-width: min(420px, calc(100vw - 1rem));
+    max-height: min(70vh, 400px);
+    overflow: auto;
+    border: 1px solid var(--bs-border-color, #dee2e6);
+    border-radius: 0.375rem;
+    box-shadow: 0 0.5rem 1rem rgba(0, 0, 0, 0.15);
+    background: var(--bs-body-bg, #fff);
+}
+
+.ec-readonly-popover-content {
+    display: flex;
+    flex-direction: column;
+    min-height: 0;
+}
+
+.ec-readonly-popover-header {
+    padding: 0.5rem 0.75rem;
+    border-bottom: 1px solid var(--bs-border-color-translucent, rgba(0, 0, 0, 0.075));
+    flex-shrink: 0;
+}
+
+.ec-readonly-popover-title {
+    font-weight: 600;
+    font-size: 0.9rem;
+}
+
+.ec-readonly-popover-body {
+    padding: 0.75rem;
+    overflow: auto;
+    flex: 1;
+    min-height: 0;
+}
@@ -0,0 +1,64 @@
+@namespace DnsmasqWebUI.Components.EffectiveConfig
+@using DnsmasqWebUI.Models.Dnsmasq
+@using DnsmasqWebUI.Models.Dnsmasq.EffectiveConfig
+
+<ReadonlyEditPopover Visible="@Visible" AnchorId="@AnchorId" Source="@Source" OptionName="@OptionName" Value="@Value" ManagedFilePath="@ManagedFilePath"
+    OnClose="RequestClose" OnMouseEnterPopover="CancelCloseTimer" OnMouseLeavePopover="ScheduleClose" />
+
+@code {
+    [Parameter] public bool Visible { get; set; }
+    [Parameter] public string? AnchorId { get; set; }
+    [Parameter] public ConfigValueSource? Source { get; set; }
+    [Parameter] public string OptionName { get; set; } = "";
+    [Parameter] public object? Value { get; set; }
+    [Parameter] public string? ManagedFilePath { get; set; }
+    [Parameter] public EventCallback OnCloseRequested { get; set; }
+
+    private CancellationTokenSource? _closeCts;
+
+    private void CancelCloseTimer()
+    {
+        _closeCts?.Cancel();
+        _closeCts = null;
+    }
+
+    private void ScheduleClose()
+    {
+        _closeCts?.Cancel();
+        _closeCts = new CancellationTokenSource();
+        var token = _closeCts.Token;
+        _ = Task.Run(async () =>
+        {
+            try { await Task.Delay(300, token); }
+            catch (OperationCanceledException) { return; }
+            await InvokeAsync(async () =>
+            {
+                if (token.IsCancellationRequested) return;
+                _closeCts = null;
+                await OnCloseRequested.InvokeAsync();
+            });
+        }, token);
+    }
+
+    private async Task RequestClose()
+    {
+        CancelCloseTimer();
+        await OnCloseRequested.InvokeAsync();
+    }
+
+    /// <summary>
+    /// Called when mouse leaves readonly badge; close unless pointer enters popover quickly.
+    /// </summary>
+    public void ScheduleCloseFromBadgeLeave()
+    {
+        ScheduleClose();
+    }
+
+    /// <summary>
+    /// Called when readonly badge is interacted with to keep popover open.
+    /// </summary>
+    public void CancelCloseFromBadgeEnter()
+    {
+        CancelCloseTimer();
+    }
+}
@@ -4,11 +4,11 @@
        @Path
        @if (IsEditable)
        {
-            <span class="badge bg-primary ms-1">editable</span>
+            <StatusBadge Kind="StatusBadgeKind.Editable" Text="editable" Class="ms-1" />
        }
        else
        {
-            <span class="badge bg-secondary ms-1"> read-only</span>
+            <StatusBadge Kind="StatusBadgeKind.ReadOnly" Text="read-only" Class="ms-1" />
        }
    </h3>
    <div class="table-responsive-cards">
@@ -1,5 +1,6 @@
@inherits LayoutComponentBase
@namespace DnsmasqWebUI.Components.Layout
+@using DnsmasqWebUI.Components.Shared
@inject ISettingsModalService SettingsModalService
@implements IDisposable

@@ -17,6 +18,7 @@
 </div>

 <SettingsModal IsVisible="_settingsModalOpen" Title="@_settingsModalTitle" SettingsContext="_settingsModalContext" OnClose="CloseSettingsModal" />
+<NotificationHost />

 <div id="blazor-error-ui" data-nosnippet>
    An unhandled error has occurred.
@@ -1,8 +1,10 @@
@namespace DnsmasqWebUI.Components.Layout
@using System.Reflection
+@using DnsmasqWebUI.Infrastructure.Services.UI.Notifications.Abstractions
@inject IOptions<ApplicationOptions> AppOptions
@inject ISettingsModalService SettingsModalService
@inject IUpdateCheckService UpdateCheckService
+@inject INotificationService NotificationService
@implements IDisposable

 <div class="top-row ps-3 navbar navbar-dark">
@@ -37,6 +39,16 @@
                <i class="bi bi-hdd-network nav-icon" aria-hidden="true"></i> DHCP
            </NavLink>
        </div>
+        <div class="nav-item px-3">
+            <NavLink class="nav-link" href="dns-records">
+                <i class="bi bi-diagram-3-fill nav-icon" aria-hidden="true"></i> DNS records
+            </NavLink>
+        </div>
+        <div class="nav-item px-3">
+            <NavLink class="nav-link" href="filters">
+                <i class="bi bi-funnel-fill nav-icon" aria-hidden="true"></i> Filters
+            </NavLink>
+        </div>
    </nav>
    <div class="nav-footer px-3 py-2" aria-label="Links and version">
        <a class="nav-footer-link" href="https://github.com/alexhopeoconnor/dnsmasq-webui" target="_blank" rel="noopener noreferrer" title="dnsmasq-webui project on GitHub">Project</a>
@@ -54,14 +66,7 @@
        else
        {
            <button type="button" class="nav-footer-link nav-footer-check-btn" @onclick="ForceCheckAsync" disabled="@UpdateCheckService.CheckInProgress" title="@GetCheckButtonTooltip()" aria-label="@GetCheckButtonTooltip()">
-                @if (UpdateCheckService.CheckInProgress)
-                {
-                    <i class="bi bi-arrow-repeat nav-footer-spin" aria-hidden="true"></i>
-                }
-                else
-                {
-                    <i class="bi bi-arrow-repeat" aria-hidden="true"></i>
-                }
+                <i class="bi bi-arrow-repeat nav-footer-check-icon @(UpdateCheckService.CheckInProgress ? "nav-footer-spin" : null)" aria-hidden="true"></i>
            </button>
        }
        ]</span>
@@ -106,13 +111,23 @@
            return "Checking…";
        var last = UpdateCheckService.LastCheckTime;
        if (last.HasValue)
-            return $"No new update available. Checked at {last.Value.ToLocalTime():t}. Check again.";
+        {
+            var local = last.Value.ToLocalTime();
+            var format = local.Date == DateTime.Now.Date ? "t" : "g"; // time only today, short date+time otherwise
+            return $"No new update available. Checked at {local.ToString(format)}. Check again.";
+        }
        return "Check for updates";
    }

    private async Task ForceCheckAsync()
    {
        await UpdateCheckService.CheckNowAsync();
+        if (UpdateCheckService.LastCheckFailed)
+            NotificationService.ShowError("Update check failed: " + (UpdateCheckService.LastCheckErrorMessage ?? "Unknown error."));
+        else if (UpdateCheckService.NewerVersionAvailable)
+            NotificationService.ShowSuccess($"New version {UpdateCheckService.NewerVersionTag} is available.");
+        else
+            NotificationService.ShowInfo("You're up to date.");
    }

    private void OpenAllSettings() => SettingsModalService.Open(SettingsModalContext.All, "Settings");
@@ -190,6 +190,10 @@
    color: rgba(255, 255, 255, 0.9) !important;
 }

+.nav-footer-check-icon {
+    display: inline-block; /* required for transform animation */
+}
+
 .nav-footer-spin {
    animation: nav-footer-spin 0.8s linear infinite;
 }
@@ -28,7 +28,17 @@
                @if (SettingsContext == SettingsModalContext.All)
                {
                    <div class="mb-3">
-                        <label class="form-label">Search settings</label>
+                        <div class="d-flex align-items-center gap-2 mb-1">
+                            <label class="form-label mb-0">Search settings</label>
+                            <div class="d-flex gap-1 ms-auto" role="group" aria-label="Expand or collapse all sections">
+                                <button type="button" class="btn btn-sm btn-outline-secondary settings-expand-collapse-btn" title="Expand all sections" aria-label="Expand all sections" @onclick="ExpandAllGroups">
+                                    <i class="bi bi-arrows-expand" aria-hidden="true"></i>
+                                </button>
+                                <button type="button" class="btn btn-sm btn-outline-secondary settings-expand-collapse-btn" title="Collapse all sections" aria-label="Collapse all sections" @onclick="CollapseAllGroups">
+                                    <i class="bi bi-arrows-collapse" aria-hidden="true"></i>
+                                </button>
+                            </div>
+                        </div>
                        <input type="search" class="form-control" placeholder="Search..." autocomplete="off"
                               @bind="_searchTerm" @bind:event="oninput" @bind:after="FilterSettings" />
                    </div>
@@ -136,8 +146,8 @@
                }
            </div>
            <div class="modal-footer">
-                <button type="button" class="btn btn-secondary" @onclick="Close">Cancel</button>
-                <button type="button" class="btn btn-primary" @onclick="Save">Save</button>
+                <button type="button" class="btn btn-secondary" @onclick="Close"><i class="bi bi-x me-1" aria-hidden="true"></i>Cancel</button>
+                <button type="button" class="btn btn-primary" @onclick="Save"><i class="bi bi-floppy-fill me-1" aria-hidden="true"></i>Save</button>
            </div>
        </div>
    </dialog>
@@ -1,5 +1,6 @@
 using DnsmasqWebUI.Models.Client;
-using DnsmasqWebUI.Infrastructure.Services.Abstractions;
+using DnsmasqWebUI.Extensions.Interop;
+using DnsmasqWebUI.Infrastructure.Services.UI.Settings.Abstractions;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Web;
 using Microsoft.JSInterop;
@@ -55,7 +56,7 @@ public partial class SettingsModal : IAsyncDisposable
        {
            try
            {
-                _jsModule = await JSRuntime.InvokeAsync<IJSObjectReference>("import", "./js/settings-modal.js");
+                _jsModule = await JSRuntime.InvokeAsync<IJSObjectReference>("import", "./js/dialog.js");
                _dotNetRef = DotNetObjectReference.Create(this);
                _moduleLoaded = true;
            }
@@ -68,10 +69,10 @@ public partial class SettingsModal : IAsyncDisposable
        {
            if (!_dialogInitialized)
            {
-                await _jsModule.InvokeVoidAsync("initDialog", _dialogRef, _dotNetRef);
+                await _jsModule.InvokeVoidAsyncSafe("initDialog", _dialogRef, _dotNetRef);
                _dialogInitialized = true;
            }
-            await _jsModule.InvokeVoidAsync("showModal", _dialogRef);
+            await _jsModule.InvokeVoidAsyncSafe("showModal", _dialogRef);
        }
    }

@@ -97,6 +98,19 @@ public partial class SettingsModal : IAsyncDisposable
        StateHasChanged();
    }

+    private void ExpandAllGroups()
+    {
+        foreach (var g in GetVisibleGroups())
+            _expandedGroupIds.Add(g.Id);
+        StateHasChanged();
+    }
+
+    private void CollapseAllGroups()
+    {
+        _expandedGroupIds.Clear();
+        StateHasChanged();
+    }
+
    private bool ShouldShowSection(string key)
    {
        var keys = SettingsModalSections.GetSectionKeysForContext(SettingsContext);
@@ -125,13 +139,15 @@ public partial class SettingsModal : IAsyncDisposable
        }

        await ClientSettingsService.SaveSettingsAsync(ClientSettingsFields.ToDto());
-        await (_jsModule?.InvokeVoidAsync("closeModal", _dialogRef) ?? ValueTask.CompletedTask);
+        if (_jsModule != null)
+            await _jsModule.InvokeVoidAsyncSafe("closeModal", _dialogRef);
        await OnClose.InvokeAsync();
    }

    private async Task Close()
    {
-        await (_jsModule?.InvokeVoidAsync("closeModal", _dialogRef) ?? ValueTask.CompletedTask);
+        if (_jsModule != null)
+            await _jsModule.InvokeVoidAsyncSafe("closeModal", _dialogRef);
        await OnClose.InvokeAsync();
    }

@@ -147,14 +163,8 @@ public partial class SettingsModal : IAsyncDisposable
    /// </summary>
    public async ValueTask DisposeAsync()
    {
-        if (_jsModule != null)
-        {
-            try { await _jsModule.DisposeAsync(); }
-            catch (InvalidOperationException ex) { Logger.LogDebug(ex, "SettingsModal: DisposeAsync skipped (prerender)"); }
-            catch (JSDisconnectedException ex) { Logger.LogDebug(ex, "SettingsModal: DisposeAsync skipped (circuit disconnected)"); }
-            catch (JSException ex) { Logger.LogDebug(ex, "SettingsModal: DisposeAsync failed"); }
-            _jsModule = null;
-        }
+        await _jsModule.DisposeAsyncSafe();
+        _jsModule = null;
        _dotNetRef?.Dispose();
        _dotNetRef = null;
    }
@@ -28,6 +28,15 @@
    padding: 1.25rem;
 }

+.settings-expand-collapse-btn {
+    padding: 0.25rem 0.4rem;
+    line-height: 1;
+}
+
+.settings-expand-collapse-btn .bi {
+    font-size: 1rem;
+}
+
 .settings-modal-dialog .modal-footer {
    padding: 1rem 1.25rem;
    border-top: 1px solid rgba(0, 0, 0, 0.125);
@@ -13,7 +13,7 @@

 <PageTitle>DHCP | @AppTitle</PageTitle>

-<h1 class="page-title">DHCP</h1>
+<h1 class="page-title">DHCP Configuration</h1>

@if (_status == null)
 {
@@ -24,6 +24,10 @@
 }
 else
 {
+    <section class="page-section">
+        <EffectiveConfigSection Status="_status" Context="EffectiveConfigContext.Dhcp" ShowSearchBox="true" OnSaveCompleted="RefreshStatusAsync" />
+    </section>
+
    @* ---- Static hosts (dhcp-host= in managed file) ---- *@
    <section class="page-section">
        <h2 class="page-section-title">Static hosts</h2>
@@ -97,7 +101,7 @@ else
                                <td><input type="checkbox" checked="@e.Ignore" @onchange="() => ToggleIgnore(e)" title="Add ignore flag so dnsmasq will not assign this client a lease" /></td>
                                <td><input class="form-control form-control-sm" @bind="e.Comment" /></td>
                                <td class="text-muted small">—</td>
-                                <td><button class="btn btn-sm btn-danger" @onclick="() => Delete(e)">Delete</button></td>
+                                <td><button class="btn btn-sm btn-danger" @onclick="() => Delete(e)"><i class="bi bi-trash me-1" aria-hidden="true"></i>Delete</button></td>
                            }
                            else
                            {
@@ -203,7 +207,7 @@ else
                        @if (editable)
                        {
                            <div class="table-card-row mt-2">
-                                <button class="btn btn-sm btn-danger" @onclick="() => Delete(e)">Delete</button>
+                                <button class="btn btn-sm btn-danger" @onclick="() => Delete(e)"><i class="bi bi-trash me-1" aria-hidden="true"></i>Delete</button>
                            </div>
                        }
                    </div>
@@ -212,11 +216,11 @@ else
        </div>
    </div>
    <div class="d-flex flex-wrap align-items-center gap-2 mt-2">
-        <button class="btn btn-primary" @onclick="Add">Add host</button>
-        <button class="btn btn-primary" @onclick="Save" disabled="@_saving">Save</button>
+        <button class="btn btn-primary" @onclick="Add"><i class="bi bi-plus-lg me-1" aria-hidden="true"></i>Add host</button>
+        <button class="btn btn-primary" @onclick="Save" disabled="@_saving"><i class="bi bi-floppy-fill me-1" aria-hidden="true"></i>Save</button>
        @if (_status.ReloadCommandConfigured)
        {
-            <button class="btn btn-primary" @onclick="Reload" disabled="@_saving">Reload config</button>
+            <button class="btn btn-primary" @onclick="Reload" disabled="@_saving"><i class="bi bi-arrow-repeat me-1" aria-hidden="true"></i>Reload config</button>
        }
    </div>
        }
@@ -253,7 +257,7 @@ else
        {
            <p class="text-muted">No leases yet. Leases appear here when DHCP clients obtain an address; use Refresh to update.</p>
            <div class="d-flex flex-wrap align-items-center gap-2 mt-2">
-                <button class="btn btn-primary" @onclick="() => LoadLeases(showLoading: true, forceRefresh: true)" disabled="@_leasesLoading">Refresh</button>
+                <button class="btn btn-primary" @onclick="() => LoadLeases(showLoading: true, forceRefresh: true)" disabled="@_leasesLoading"><i class="bi bi-arrow-repeat me-1" aria-hidden="true"></i>Refresh</button>
            </div>
        }
        else
@@ -286,8 +290,8 @@ else
                                    <td>@e.ClientId</td>
                                    <td>
                                        <div class="d-flex flex-wrap gap-1">
-                                            <button type="button" class="btn btn-primary btn-sm" title="Add a new static host entry using this lease's MAC, name, and address" @onclick="() => AddStaticFromLease(e)">Add static</button>
-                                            <button type="button" class="btn btn-outline-danger btn-sm" title="Add a static host with ignore flag (dnsmasq will not assign this client a lease)" @onclick="() => AddStaticFromLeaseWithIgnore(e)">Ignore</button>
+                                            <button type="button" class="btn btn-primary btn-sm" title="Add a new static host entry using this lease's MAC, name, and address" @onclick="() => AddStaticFromLease(e)"><i class="bi bi-plus me-1" aria-hidden="true"></i>Add static</button>
+                                            <button type="button" class="btn btn-outline-danger btn-sm" title="Add a static host with ignore flag (dnsmasq will not assign this client a lease)" @onclick="() => AddStaticFromLeaseWithIgnore(e)"><i class="bi bi-slash-circle me-1" aria-hidden="true"></i>Ignore</button>
                                        </div>
                                    </td>
                                </tr>
@@ -309,8 +313,8 @@ else
                                <div class="table-card-row"><span class="table-card-label">Name</span> @e.Name</div>
                                <div class="table-card-row"><span class="table-card-label">Client ID</span> @e.ClientId</div>
                                <div class="table-card-row mt-2 d-flex flex-wrap gap-1">
-                                    <button type="button" class="btn btn-primary btn-sm" title="Add a new static host entry using this lease's MAC, name, and address" @onclick="() => AddStaticFromLease(e)">Add static</button>
-                                    <button type="button" class="btn btn-outline-danger btn-sm" title="Add a static host with ignore flag (dnsmasq will not assign this client a lease)" @onclick="() => AddStaticFromLeaseWithIgnore(e)">Ignore</button>
+                                    <button type="button" class="btn btn-primary btn-sm" title="Add a new static host entry using this lease's MAC, name, and address" @onclick="() => AddStaticFromLease(e)"><i class="bi bi-plus me-1" aria-hidden="true"></i>Add static</button>
+                                    <button type="button" class="btn btn-outline-danger btn-sm" title="Add a static host with ignore flag (dnsmasq will not assign this client a lease)" @onclick="() => AddStaticFromLeaseWithIgnore(e)"><i class="bi bi-slash-circle me-1" aria-hidden="true"></i>Ignore</button>
                                </div>
                            </div>
                        </div>
@@ -318,15 +322,11 @@ else
                </div>
            </div>
            <div class="d-flex flex-wrap align-items-center gap-2 mt-2">
-                <button class="btn btn-primary" @onclick="() => LoadLeases(showLoading: true, forceRefresh: true)" disabled="@_leasesLoading">Refresh</button>
+                <button class="btn btn-primary" @onclick="() => LoadLeases(showLoading: true, forceRefresh: true)" disabled="@_leasesLoading"><i class="bi bi-arrow-repeat me-1" aria-hidden="true"></i>Refresh</button>
            </div>
        }
    </section>

-    <section class="page-section">
-        <h2 class="page-section-title">Config affecting DHCP</h2>
-        <EffectiveConfigSection Status="_status" Context="EffectiveConfigContext.Dhcp" ShowSearchBox="true" />
-    </section>
 }

@code {
@@ -416,6 +416,16 @@ else
        StateHasChanged();
    }

+    private async Task RefreshStatusAsync()
+    {
+        try
+        {
+            _status = await StatusClient.GetStatusAsync();
+            await InvokeAsync(StateHasChanged);
+        }
+        catch { /* ignore */ }
+    }
+
    private async Task Load()
    {
        _error = null;
@@ -0,0 +1,64 @@
+@page "/dns-records"
+@rendermode InteractiveServer
+@namespace DnsmasqWebUI.Components.Pages
+@inject IStatusClient StatusClient
+@inject IOptions<ApplicationOptions> AppOptions
+
+<PageTitle>DNS records | @AppTitle</PageTitle>
+
+<h1 class="page-title">DNS Records Configuration</h1>
+
+@if (_status == null)
+{
+    <p class="d-flex align-items-center gap-2">
+        <span class="spinner-border spinner-border-sm" role="status" aria-hidden="true"></span>
+        Loading...
+    </p>
+}
+else
+{
+    <section class="page-section">
+        <EffectiveConfigSection Status="_status" Context="EffectiveConfigContext.DnsRecords" ShowSearchBox="true" OnSaveCompleted="RefreshStatusAsync" />
+    </section>
+    <div class="page-chips" role="group" aria-label="Record type">
+        <span class="page-chip active">All</span>
+        <span class="page-chip">CNAME</span>
+        <span class="page-chip">MX / SRV</span>
+        <span class="page-chip">PTR</span>
+        <span class="page-chip">TXT</span>
+        <span class="page-chip">A / AAAA</span>
+        <span class="page-chip">Other</span>
+    </div>
+}
+
+@code {
+    private string AppTitle => AppOptions!.Value!.EffectiveTitle;
+    private DnsmasqServiceStatus? _status;
+
+    protected override async Task OnInitializedAsync()
+    {
+        await Load();
+    }
+
+    private async Task RefreshStatusAsync()
+    {
+        try
+        {
+            _status = await StatusClient.GetStatusAsync();
+            await InvokeAsync(StateHasChanged);
+        }
+        catch { /* ignore */ }
+    }
+
+    private async Task Load()
+    {
+        try
+        {
+            _status = await StatusClient.GetStatusAsync();
+        }
+        catch
+        {
+            // Status will stay null; UI shows loading or empty
+        }
+    }
+}
@@ -6,8 +6,10 @@
@inject IReloadClient ReloadClient
@inject IClientSettingsService ClientSettingsService
@inject ISettingsModalService SettingsModalService
+@inject INotificationService NotificationService
@inject IOptions<ApplicationOptions> AppOptions
@implements IDisposable
+@using DnsmasqWebUI.Infrastructure.Services.UI.Notifications.Abstractions

 <PageTitle>Dnsmasq | @AppTitle</PageTitle>

@@ -22,41 +24,25 @@ else if (_error != null)
 else if (_status != null)
 {
    <section class="page-section">
-        <h2 class="page-section-title">Service configuration</h2>
-        <p class="mb-1"><strong>Config files (load order):</strong></p>
-        <ul class="list-unstyled small ms-2 mb-0">
-            @{
-                var configFileList = _status.ConfigFiles?.Count > 0 ? _status.ConfigFiles : _configSet?.Files;
-            }
-            @if (configFileList != null && configFileList.Count > 0)
-            {
-                @foreach (var f in configFileList)
+        @if (!string.IsNullOrWhiteSpace(_status.DnsmasqVersion) || !string.IsNullOrWhiteSpace(_status.DnsmasqVersionError))
+        {
+            <p class="text-muted small mb-1 text-end">
+                @if (!string.IsNullOrWhiteSpace(_status.DnsmasqVersion))
                {
-                    var isMain = string.Equals(f.Path, _status.MainConfigPath, StringComparison.Ordinal);
-                    var isManaged = f.IsManaged;
-                    var exists = isMain ? _status.MainConfigPathExists : (isManaged ? _status.ManagedFilePathExists : (bool?)null);
-                    <li>
-                        @if (f.IsManaged)
-                        {
-                            <span class="badge bg-primary me-1">managed</span>
-                        }
-                        else
-                        {
-                            <span class="badge bg-secondary me-1">@(f.Source.ToString().ToLowerInvariant())</span>
-                        }
-                        @f.Path
-                        @if (exists == true) { <text> ✓</text> }
-                        @if (exists == false) { <text> @(isManaged ? "(not created yet)" : "(missing)")</text> }
-                    </li>
+                    var versionTooltip = "Minimum required by this UI: " + _status.MinimumSupportedDnsmasqVersion + ". " + (_status.DnsmasqVersionSupported ? "Supported." : "Unsupported.");
+                    <a href="https://thekelleys.org.uk/dnsmasq/CHANGELOG" target="_blank" rel="noopener noreferrer" class="text-muted text-decoration-none" title="@versionTooltip">
+                        dnsmasq <code>@_status.DnsmasqVersion</code>
+                    </a>
                }
-            }
-            else
-            {
-                <li><strong>Main config:</strong> @(_status.MainConfigPath ?? "—") @(_status.MainConfigPathExists ? "✓" : "(missing)")</li>
-                <li><strong>Managed file:</strong> @(_status.ManagedFilePath ?? "—") @(_status.ManagedFilePathExists ? "✓" : "(not created yet)")</li>
-            }
-        </ul>
-        <EffectiveConfigSection Status="_status" Context="EffectiveConfigContext.All" ShowSearchBox="true" />
+                @if (!string.IsNullOrWhiteSpace(_status.DnsmasqVersionError))
+                {
+                    <span class="text-warning ms-1" title="@_status.DnsmasqVersionError">@_status.DnsmasqVersionError</span>
+                }
+            </p>
+        }
+        <h2 class="page-section-title">Service configuration</h2>
+        <ConfigFileList Status="_status" ConfigSet="_configSet" />
+        <EffectiveConfigSection Status="_status" Context="EffectiveConfigContext.All" ShowSearchBox="true" OnSaveCompleted="RefreshStatusAsync" />
        @if (_status.ReloadCommandConfigured)
        {
            <div class="d-flex align-items-center gap-2 flex-wrap mt-3">
@@ -65,20 +51,16 @@ else if (_status != null)
                    {
                        <span class="spinner-border spinner-border-sm me-1" role="status" aria-hidden="true"></span>
                    }
+                    else
+                    {
+                        <i class="bi bi-arrow-repeat me-1" aria-hidden="true"></i>
+                    }
                    @(_reloading ? "Reloading…" : "Reload config")
                </button>
-                @if (!string.IsNullOrEmpty(_reloadMessage))
-                {
-                    <span class="@(_reloadSuccess ? "text-success" : "text-danger") small">@_reloadMessage</span>
-                }
-                @if (!_reloadSuccess && _reloadDetail != null)
-                {
-                    <pre class="pre-block mt-2 mb-0" style="max-height: 10rem;">@_reloadDetail</pre>
-                }
            </div>
        }

-        <StatusSection RefreshIntervalSeconds="@ClientSettingsFields.ServiceStatusPollingInterval.Value" IsReloading="_reloading" OnOpenSettings="OpenServiceStatusSettings" />
+        <StatusSection RefreshIntervalSeconds="@ClientSettingsFields.ServiceStatusPollingInterval.Value" IsReloading="_reloading" OnReloadRequested="ReloadDnsmasq" ReloadCommandConfigured="_status.ReloadCommandConfigured" OnOpenSettings="OpenServiceStatusSettings" />
        <LogsSection Status="_status" RefreshIntervalSeconds="@ClientSettingsFields.RecentLogsPollingInterval.Value" LogsMaxLines="@ClientSettingsFields.RecentLogsMaxLines.Value" LogsAutoScroll="@ClientSettingsFields.RecentLogsAutoScroll.Value" OnOpenSettings="OpenRecentLogsSettings" />
        <AppLogsSection RefreshIntervalSeconds="@ClientSettingsFields.AppLogsPollingInterval.Value" LogsMaxLines="@ClientSettingsFields.AppLogsMaxLines.Value" LogsAutoScroll="@ClientSettingsFields.AppLogsAutoScroll.Value" OnOpenSettings="OpenAppLogsSettings" />
    </section>
@@ -92,9 +74,6 @@ else if (_status != null)
    private string? _error;
    private bool _loading = true;
    private bool _reloading;
-    private string? _reloadMessage;
-    private string? _reloadDetail;
-    private bool _reloadSuccess;
    private readonly CancellationTokenSource _cts = new();

    protected override void OnInitialized()
@@ -150,26 +129,38 @@ else if (_status != null)
        await InvokeAsync(StateHasChanged);
    }

+    private async Task RefreshStatusAsync()
+    {
+        try
+        {
+            _status = await StatusClient.GetStatusAsync(_cts.Token);
+            await InvokeAsync(StateHasChanged);
+        }
+        catch (OperationCanceledException) { }
+        catch (ObjectDisposedException)
+        {
+            // Component disposed (e.g. navigated away) while callback was pending; ignore
+        }
+    }
+
    private async Task ReloadDnsmasq()
    {
        if (_status == null || !_status.ReloadCommandConfigured || _reloading) return;
        _reloading = true;
-        _reloadMessage = null;
-        _reloadDetail = null;
        try
        {
            var token = _cts.Token;
            var result = await ReloadClient.ReloadAsync(token);
            if (result.Success)
            {
-                _reloadMessage = "Reloaded.";
-                _reloadSuccess = true;
+                NotificationService.ShowSuccess("Reloaded.");
            }
            else
            {
-                _reloadMessage = "Reload failed" + (result.ExitCode != 0 ? " (exit " + result.ExitCode + ")" : "") + ".";
-                _reloadDetail = BuildReloadDetail(result);
-                _reloadSuccess = false;
+                var msg = "Reload failed" + (result.ExitCode != 0 ? " (exit " + result.ExitCode + ")" : "") + ".";
+                if (!string.IsNullOrEmpty(result.StdErr))
+                    msg += " " + result.StdErr;
+                NotificationService.ShowError(msg);
            }
            try
            {
@@ -183,7 +174,7 @@ else if (_status != null)
        catch (OperationCanceledException) { }
        catch (Exception ex)
        {
-            if (_reloadMessage == null) { _reloadMessage = ex.Message; _reloadSuccess = false; }
+            NotificationService.ShowError("Reload failed: " + ex.Message);
        }
        finally
        {
@@ -191,14 +182,6 @@ else if (_status != null)
        }
    }

-    private static string? BuildReloadDetail(ReloadResult r)
-    {
-        var parts = new List<string>();
-        if (!string.IsNullOrEmpty(r.StdOut)) parts.Add("stdout:\n" + r.StdOut);
-        if (!string.IsNullOrEmpty(r.StdErr)) parts.Add("stderr:\n" + r.StdErr);
-        return parts.Count > 0 ? string.Join("\n\n", parts) : null;
-    }
-
    public void Dispose()
    {
        SettingsModalService.SettingsChanged -= OnSettingsChanged;
@@ -0,0 +1,63 @@
+@page "/filters"
+@rendermode InteractiveServer
+@namespace DnsmasqWebUI.Components.Pages
+@inject IStatusClient StatusClient
+@inject IOptions<ApplicationOptions> AppOptions
+
+<PageTitle>Filters | @AppTitle</PageTitle>
+
+<h1 class="page-title">Filters Configuration</h1>
+
+@if (_status == null)
+{
+    <p class="d-flex align-items-center gap-2">
+        <span class="spinner-border spinner-border-sm" role="status" aria-hidden="true"></span>
+        Loading...
+    </p>
+}
+else
+{
+    <section class="page-section">
+        <EffectiveConfigSection Status="_status" Context="EffectiveConfigContext.Filters" ShowSearchBox="true" OnSaveCompleted="RefreshStatusAsync" />
+    </section>
+    <div class="page-chips" role="group" aria-label="Filter policy category">
+        <span class="page-chip active">All</span>
+        <span class="page-chip">Blocking / sinkhole</span>
+        <span class="page-chip">Split DNS</span>
+        <span class="page-chip">Safety</span>
+        <span class="page-chip">Response shaping</span>
+        <span class="page-chip">Firewall</span>
+    </div>
+}
+
+@code {
+    private string AppTitle => AppOptions!.Value!.EffectiveTitle;
+    private DnsmasqServiceStatus? _status;
+
+    protected override async Task OnInitializedAsync()
+    {
+        await Load();
+    }
+
+    private async Task RefreshStatusAsync()
+    {
+        try
+        {
+            _status = await StatusClient.GetStatusAsync();
+            await InvokeAsync(StateHasChanged);
+        }
+        catch { /* ignore */ }
+    }
+
+    private async Task Load()
+    {
+        try
+        {
+            _status = await StatusClient.GetStatusAsync();
+        }
+        catch
+        {
+            // Status will stay null; UI shows loading or empty
+        }
+    }
+}
@@ -6,7 +6,7 @@
@inject IOptions<ApplicationOptions> AppOptions
 <PageTitle>Hosts | @AppTitle</PageTitle>

-<h1 class="page-title">Hosts file</h1>
+<h1 class="page-title">Hosts Configuration</h1>

@if (_status == null)
 {
@@ -18,8 +18,7 @@
 else
 {
    <section class="page-section mb-4">
-        <h2 class="page-section-title">Config affecting hosts</h2>
-        <EffectiveConfigSection Status="_status" Context="EffectiveConfigContext.Hosts" ShowSearchBox="true" />
+        <EffectiveConfigSection Status="_status" Context="EffectiveConfigContext.Hosts" ShowSearchBox="true" OnSaveCompleted="RefreshStatusAsync" />
    </section>
    @if (string.IsNullOrEmpty(_status.ManagedHostsFilePath))
    {
@@ -45,7 +44,7 @@ else
        }

        <HostsFileSection Path="@(_status.ManagedHostsFilePath ?? "")" Entries="_entries" IsEditable="true" IsFirst="true" />
-        <button class="btn btn-primary mt-2" @onclick="Save" disabled="@_saving">Save</button>
+        <button class="btn btn-primary mt-2" @onclick="Save" disabled="@_saving"><i class="bi bi-floppy-fill me-1" aria-hidden="true"></i>Save</button>

        @if (_readOnlyHosts?.Count > 0)
        {
@@ -90,6 +89,16 @@ else
        await Load();
    }

+    private async Task RefreshStatusAsync()
+    {
+        try
+        {
+            _status = await StatusClient.GetStatusAsync();
+            await InvokeAsync(StateHasChanged);
+        }
+        catch { /* ignore */ }
+    }
+
    private async Task Load()
    {
        _error = null;
@@ -0,0 +1,46 @@
+@namespace DnsmasqWebUI.Components.Shared
+@using DnsmasqWebUI.Infrastructure.Services.UI.Notifications.Abstractions
+@inject INotificationService NotificationService
+@implements IDisposable
+
+@if (_toasts.Count > 0)
+{
+    <div class="notification-host" aria-live="polite">
+        @foreach (var item in _toasts)
+        {
+            <NotificationToast @key="item.Id"
+                Id="@item.Id"
+                Kind="@item.Kind"
+                Message="@item.Message"
+                AutoDismissMs="4500"
+                OnDismissRequested="Dismiss" />
+        }
+    </div>
+}
+
+@code {
+    private List<NotificationItem> _toasts = new();
+
+    protected override void OnInitialized()
+    {
+        NotificationService.NotificationsChanged += OnNotificationsChanged;
+        _toasts = NotificationService.GetSnapshot().ToList();
+    }
+
+    private void OnNotificationsChanged(object? sender, EventArgs e)
+    {
+        _toasts = NotificationService.GetSnapshot().ToList();
+        InvokeAsync(StateHasChanged);
+    }
+
+    private async Task Dismiss(int id)
+    {
+        NotificationService.Dismiss(id);
+        await InvokeAsync(StateHasChanged);
+    }
+
+    public void Dispose()
+    {
+        NotificationService.NotificationsChanged -= OnNotificationsChanged;
+    }
+}
@@ -0,0 +1,14 @@
+.notification-host {
+    position: fixed;
+    top: var(--app-spacing-md, 1rem);
+    right: var(--app-spacing-md, 1rem);
+    z-index: 1100;
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+    pointer-events: none;
+}
+
+.notification-host > * {
+    pointer-events: auto;
+}
@@ -0,0 +1,44 @@
+@namespace DnsmasqWebUI.Components.Shared
+@using DnsmasqWebUI.Infrastructure.Services.UI.Notifications.Abstractions
+
+<div class="notification-toast notification-toast-@Kind.ToString().ToLowerInvariant()" role="alert">
+    <span class="notification-toast-accent" aria-hidden="true"></span>
+    <span class="notification-toast-icon" aria-hidden="true">@Icon</span>
+    <span class="notification-toast-message">@Message</span>
+    <button type="button" class="notification-toast-dismiss" aria-label="Dismiss" @onclick="Dismiss">×</button>
+</div>
+
+@code {
+    [Parameter] public NotificationKind Kind { get; set; }
+    [Parameter] public string Message { get; set; } = "";
+    [Parameter] public int Id { get; set; }
+    [Parameter] public int AutoDismissMs { get; set; } = 4500;
+    [Parameter] public EventCallback<int> OnDismissRequested { get; set; }
+
+    private string Icon => Kind switch
+    {
+        NotificationKind.Success => "✓",
+        NotificationKind.Error => "✕",
+        NotificationKind.Warning => "⚠",
+        NotificationKind.Info => "ℹ",
+        _ => "•"
+    };
+
+    protected override void OnAfterRender(bool firstRender)
+    {
+        if (firstRender && AutoDismissMs > 0)
+            _ = ScheduleAutoDismiss();
+    }
+
+    private async Task ScheduleAutoDismiss()
+    {
+        try
+        {
+            await Task.Delay(AutoDismissMs);
+            await InvokeAsync(() => OnDismissRequested.InvokeAsync(Id));
+        }
+        catch (TaskCanceledException) { }
+    }
+
+    private async Task Dismiss() => await OnDismissRequested.InvokeAsync(Id);
+}
@@ -0,0 +1,88 @@
+/* Toast: compact popover with left accent, icon, message, dismiss. Modern, distinct. */
+.notification-toast {
+    display: flex;
+    align-items: center;
+    gap: 0.625rem;
+    min-width: 16rem;
+    max-width: 28rem;
+    padding: 0.75rem 1rem;
+    padding-left: 0.5rem;
+    background: var(--notification-bg);
+    color: var(--notification-fg);
+    border-radius: var(--app-radius-lg, 0.5rem);
+    box-shadow: 0 4px 14px rgba(0, 0, 0, 0.15);
+    font-size: 0.9375rem;
+    line-height: 1.4;
+}
+
+.notification-toast-accent {
+    width: 4px;
+    align-self: stretch;
+    border-radius: 2px;
+    background: var(--notification-accent);
+    flex-shrink: 0;
+}
+
+.notification-toast-icon {
+    flex-shrink: 0;
+    width: 1.25rem;
+    height: 1.25rem;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    font-weight: 700;
+    font-size: 0.875rem;
+}
+
+.notification-toast-message {
+    flex: 1;
+    min-width: 0;
+}
+
+.notification-toast-dismiss {
+    flex-shrink: 0;
+    width: 1.5rem;
+    height: 1.5rem;
+    padding: 0;
+    border: none;
+    background: transparent;
+    color: inherit;
+    opacity: 0.75;
+    font-size: 1.25rem;
+    line-height: 1;
+    cursor: pointer;
+    border-radius: var(--app-radius, 0.375rem);
+}
+
+.notification-toast-dismiss:hover {
+    opacity: 1;
+    background: rgba(0, 0, 0, 0.08);
+}
+
+/* Success */
+.notification-toast-success {
+    --notification-bg: #f0fdf4;
+    --notification-fg: #166534;
+    --notification-accent: #22c55e;
+}
+
+/* Error */
+.notification-toast-error {
+    --notification-bg: #fef2f2;
+    --notification-fg: #b91c1c;
+    --notification-accent: #ef4444;
+}
+
+/* Warning */
+.notification-toast-warning {
+    --notification-bg: #fffbeb;
+    --notification-fg: #b45309;
+    --notification-accent: #f59e0b;
+}
+
+/* Info */
+.notification-toast-info {
+    --notification-bg: #eff6ff;
+    --notification-fg: #1d4ed8;
+    --notification-accent: #3b82f6;
+}
@@ -0,0 +1,80 @@
+@namespace DnsmasqWebUI.Components.Shared
+
+@if (Clickable)
+{
+    <button type="button"
+            class="@CssClass"
+            title="@Title"
+            aria-label="@(AriaLabel ?? Text)"
+            disabled="@Disabled"
+            id="@(string.IsNullOrEmpty(Id) ? null : Id)"
+            @onclick="OnClick"
+            @onclick:stopPropagation="@StopPropagation"
+            @onmousedown:preventDefault="@PreventBlurOnMouseDown"
+            @onmouseleave="OnMouseLeave">
+        @ChildContent
+        @if (ChildContent == null && !string.IsNullOrWhiteSpace(IconClass))
+        {
+            <i class="@IconClass" aria-hidden="true"></i>
+            <span class="visually-hidden">@Text</span>
+        }
+        else if (ChildContent == null)
+        {
+            @Text
+        }
+    </button>
+}
+else
+{
+    <span class="@CssClass" title="@Title" id="@(string.IsNullOrEmpty(Id) ? null : Id)">
+        @ChildContent
+        @if (ChildContent == null && !string.IsNullOrWhiteSpace(IconClass))
+        {
+            <i class="@IconClass" aria-hidden="true"></i>
+            <span class="visually-hidden">@Text</span>
+        }
+        else if (ChildContent == null)
+        {
+            @Text
+        }
+    </span>
+}
+
+@code {
+    [Parameter] public StatusBadgeKind Kind { get; set; }
+    [Parameter] public string Text { get; set; } = "";
+    [Parameter] public bool Clickable { get; set; }
+    [Parameter] public bool Disabled { get; set; }
+    [Parameter] public string? Title { get; set; }
+    [Parameter] public string? AriaLabel { get; set; }
+    [Parameter] public string? Id { get; set; }
+    [Parameter] public string? IconClass { get; set; }
+    [Parameter] public bool StopPropagation { get; set; } = true;
+    [Parameter] public bool PreventBlurOnMouseDown { get; set; }
+    [Parameter] public EventCallback OnClick { get; set; }
+    [Parameter] public EventCallback OnMouseLeave { get; set; }
+    [Parameter] public string? Class { get; set; }
+    [Parameter] public RenderFragment? ChildContent { get; set; }
+
+    private string CssClass
+    {
+        get
+        {
+            var kindClass = Kind switch
+            {
+                StatusBadgeKind.Managed => "bg-primary",
+                StatusBadgeKind.SourceMain => "bg-secondary",
+                StatusBadgeKind.SourceInclude => "bg-secondary",
+                StatusBadgeKind.Editable => "bg-primary",
+                StatusBadgeKind.ReadOnly => "bg-secondary",
+                StatusBadgeKind.Pending => "bg-warning text-dark",
+                StatusBadgeKind.ActionOk => "bg-success",
+                StatusBadgeKind.ActionCancel => "bg-secondary",
+                StatusBadgeKind.ActionRevert => "bg-danger",
+                StatusBadgeKind.NeutralPill => "bg-light text-dark border rounded-pill",
+                _ => "bg-secondary"
+            };
+            return $"badge status-badge {kindClass} {Class}".Trim();
+        }
+    }
+}
@@ -0,0 +1,49 @@
+/* Shared badge: compact label size, alignment, no button border when clickable */
+.status-badge {
+    display: inline-flex;
+    align-items: center;
+    line-height: 1.2;
+    white-space: nowrap;
+    border: 0;
+    font-size: 0.75rem;
+    font-weight: 500;
+    padding: 0.2em 0.5em;
+    border-radius: 0.25rem;
+}
+
+.status-badge + .status-badge {
+    margin-left: 0.35rem;
+}
+
+.status-badge-inline {
+    margin-left: 0.35rem;
+}
+
+/* Clickable badges: pointer, hover lift + glow, active press, focus for a11y */
+button.status-badge {
+    cursor: pointer;
+    transition: transform 0.2s ease-out, filter 0.2s ease-out, box-shadow 0.2s ease-out;
+}
+
+button.status-badge:hover:not(:disabled) {
+    transform: scale(1.06) translateY(-2px);
+    filter: brightness(0.94);
+    box-shadow: 0 2px 6px rgba(0, 0, 0, 0.15);
+}
+
+button.status-badge:active:not(:disabled) {
+    transform: scale(0.94) translateY(0);
+    filter: brightness(0.88);
+    box-shadow: 0 0 0 rgba(0, 0, 0, 0);
+    transition-duration: 0.1s;
+}
+
+button.status-badge:focus-visible {
+    outline: 2px solid currentColor;
+    outline-offset: 2px;
+}
+
+button.status-badge:disabled {
+    opacity: 0.7;
+    cursor: not-allowed;
+}
@@ -0,0 +1,16 @@
+namespace DnsmasqWebUI.Components.Shared;
+
+/// <summary>Semantic badge intent for <see cref="StatusBadge"/>; maps to consistent CSS and behavior.</summary>
+public enum StatusBadgeKind
+{
+    Managed,
+    SourceMain,
+    SourceInclude,
+    Editable,
+    ReadOnly,
+    Pending,
+    ActionOk,
+    ActionCancel,
+    ActionRevert,
+    NeutralPill
+}
--- a/Show More
+++ b/Show More