diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 06aabaa..e614808 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -79,9 +79,9 @@ jobs:
           python-version: "3.x"
           check-latest: true
           architecture: ${{ runner.arch == 'ARM64' && 'arm64' || 'x64' }}
-      - uses: astral-sh/setup-uv@v10.2.0
+      - uses: astral-sh/setup-uv@v10.3.3
         with:
-          version: "0.12"
+          version: "0.13.6"
       - name: Linux native dependencies
         if: matrix.platform == 'linux'
         run: |
@@ -90,9 +90,9 @@ jobs:
       - name: Cache native Rust dependencies
         uses: Swatinem/rust-cache@v2
         with:
-          key: release-${{ matrix.name }}-${{ hashFiles('scripts/src/vole_scripts/*.py', 'scripts/cmake/**') }}
+          key: release-${{ matrix.name }}-${{ hashFiles('scripts/src/vole_scripts/*.py', 'scripts/cmake/**', 'scripts/native/**') }}
           workspaces: ". -> target"
-          env-vars: ImageOS ImageVersion SDKROOT DEVELOPER_DIR BORING AWS_LC LIBCLANG BINDGEN
+          env-vars: ImageOS ImageVersion SDKROOT DEVELOPER_DIR VOLE BORING AWS_LC LIBCLANG BINDGEN
           cache-bin: "false"
       - name: Build and package production CLI
         shell: bash
@@ -193,9 +193,9 @@ jobs:
           python-version: "3.x"
           check-latest: true
           architecture: ${{ runner.arch == 'ARM64' && 'arm64' || 'x64' }}
-      - uses: astral-sh/setup-uv@v10.2.0
+      - uses: astral-sh/setup-uv@v10.3.3
         with:
-          version: "0.12"
+          version: "0.13.6"
       - name: Locked source
         run: cargo fetch --locked
       - name: Linux native dependencies
@@ -222,7 +222,7 @@ jobs:
       - name: Cache native Rust dependencies
         uses: Swatinem/rust-cache@v2
         with:
-          key: release-${{ matrix.name }}-${{ hashFiles('scripts/src/vole_scripts/*.py', 'scripts/cmake/**') }}
+          key: release-${{ matrix.name }}-${{ hashFiles('scripts/src/vole_scripts/*.py', 'scripts/cmake/**', 'scripts/native/**') }}
           workspaces: ". -> target"
           env-vars: ImageOS ImageVersion SDKROOT DEVELOPER_DIR ANDROID_NDK_HOME VOLE BORING AWS_LC LIBCLANG BINDGEN
           cache-bin: "false"
@@ -295,13 +295,13 @@ jobs:
         with:
           python-version: "3.x"
           check-latest: true
-      - uses: astral-sh/setup-uv@v10.2.0
+      - uses: astral-sh/setup-uv@v10.3.3
         with:
-          version: "0.12"
+          version: "0.13.6"
       - name: Cache native Rust dependencies
         uses: Swatinem/rust-cache@v2
         with:
-          key: release-ffi-apple-${{ matrix.target }}-${{ hashFiles('scripts/src/vole_scripts/*.py', 'scripts/cmake/**') }}
+          key: release-ffi-apple-${{ matrix.target }}-${{ hashFiles('scripts/src/vole_scripts/*.py', 'scripts/cmake/**', 'scripts/native/**') }}
           workspaces: ". -> target"
           env-vars: ImageOS ImageVersion SDKROOT DEVELOPER_DIR VOLE BORING AWS_LC LIBCLANG BINDGEN
           cache-bin: "false"
@@ -335,9 +335,9 @@ jobs:
         with:
           python-version: "3.x"
           check-latest: true
-      - uses: astral-sh/setup-uv@v10.2.0
+      - uses: astral-sh/setup-uv@v10.3.3
         with:
-          version: "0.12"
+          version: "0.13.6"
       - uses: actions/download-artifact@v8
         with:
           pattern: vole-apple-*-${{ github.sha }}
@@ -368,9 +368,9 @@ jobs:
         with:
           python-version: "3.x"
           check-latest: true
-      - uses: astral-sh/setup-uv@v10.2.0
+      - uses: astral-sh/setup-uv@v10.3.3
         with:
-          version: "0.12"
+          version: "0.13.6"
       - uses: actions/download-artifact@v8
         with:
           pattern: vole-release-build-*-${{ github.sha }}
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index ddec080..6365e61 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -19,7 +19,7 @@ env:
 jobs:
   client-contracts:
     name: ${{ matrix.name }}
-    runs-on: macos-26
+    runs-on: ubuntu-26.04
     timeout-minutes: 90
     strategy:
       fail-fast: false
@@ -41,16 +41,23 @@ jobs:
         with:
           python-version: "3.x"
           check-latest: true
-      - uses: astral-sh/setup-uv@v10.2.0
+      - uses: astral-sh/setup-uv@v10.3.3
         with:
-          version: "0.12"
+          version: "0.13.6"
+      - name: Linux native dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y clang libclang-dev cmake ninja-build perl pkg-config
+      - name: Prepare official BLAKE3 static dependency
+        shell: bash
+        run: uv run --project scripts --locked vole-scripts deps --github-env "$GITHUB_ENV"
       - name: Cache Rust dependencies
         uses: Swatinem/rust-cache@v2
         with:
-          key: tests-${{ matrix.profile }}
+          key: tests-${{ matrix.profile }}-${{ hashFiles('scripts/native/**', 'scripts/src/vole_scripts/*.py') }}
           workspaces: ". -> target"
           # Native TLS artifacts must not cross runner SDK/image changes.
-          env-vars: ImageOS ImageVersion SDKROOT DEVELOPER_DIR BORING AWS_LC LIBCLANG BINDGEN
+          env-vars: ImageOS ImageVersion SDKROOT DEVELOPER_DIR BORING AWS_LC LIBCLANG BINDGEN VOLE_BLAKE3
           cache-bin: "false"
       - name: Format and scripts
         if: matrix.profile == 'features'
@@ -86,14 +93,16 @@ jobs:
           cargo metadata --locked --all-features --format-version 1 > "$RUNNER_TEMP/vole-metadata.json"
           uv run --project scripts --locked python - "$RUNNER_TEMP/vole-metadata.json" <<'PY'
           import json
+          import re
           import sys
+          import tomllib
           from pathlib import Path
 
           metadata = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
           packages = metadata["packages"]
           nodes = {node["id"]: node for node in metadata["resolve"]["nodes"]}
           registry = {"registry+https://github.com/rust-lang/crates.io-index", "registry+https://index.crates.io/"}
-          boring_source = "git+https://github.com/YuanDevTeam/boring?branch=release#43c1c1d5b9464b3f2d5204be8664778fada7dbaf"
+          smoltcp_source = "git+https://github.com/smoltcp-rs/smoltcp?rev=24bda3b4f982625d8453d4360172557d24921c76#24bda3b4f982625d8453d4360172557d24921c76"
 
           def require(condition, message):
               if not condition:
@@ -112,21 +121,89 @@ jobs:
               return set(nodes[item["id"]]["features"])
 
           require(not any("watfaq" in (item.get("source") or "").lower() for item in packages), "retired dependency source is forbidden")
-          rustls = package("rustls", "0.23.45")
-          package("tokio-rustls", "0.26.5")
-          package("ring")
+          workspace_root = Path(metadata["workspace_root"])
+          manifest = tomllib.loads((workspace_root / "Cargo.toml").read_text(encoding="utf-8"))
+          boring_repository = "https://github.com/YuanDevTeam/boring"
+          boring_revision = manifest["dependencies"]["boring"].get("rev")
+          require(isinstance(boring_revision, str) and re.fullmatch(r"[0-9a-f]{40}", boring_revision), "Boring PR dependencies must pin a complete commit SHA")
+          boring_specs = [manifest["dependencies"][name] for name in ("boring", "tokio-boring")]
+          boring_specs.append(manifest["dev-dependencies"]["boring-sys"])
+          boring_specs.extend(manifest["patch"]["crates-io"][name] for name in ("boring", "boring-sys"))
+          for spec in boring_specs:
+              require(spec.get("git") == boring_repository and spec.get("rev") == boring_revision and not {"path", "branch", "tag"} & spec.keys(), "Boring dependencies and patches must share one Git commit source")
+          boring_source = f"git+{boring_repository}?rev={boring_revision}#{boring_revision}"
+          require(not (workspace_root / "vendor").exists(), "Core vendor sources are forbidden")
+          require(not (workspace_root / "crates" / "vole-blake3-raw" / "vendor").exists(), "BLAKE3 must use the installed official C library")
+          native_manifest = json.loads((workspace_root / "scripts" / "native" / "blake3" / "vcpkg.json").read_text(encoding="utf-8"))
+          require(native_manifest.get("builtin-baseline") == "9eec002df1cd109f8f104cd966a763daf9751489", "unapproved official BLAKE3 C registry baseline")
+          require(native_manifest.get("dependencies") == [{"name": "blake3", "default-features": False}], "BLAKE3 C must use the reviewed static-only package")
+          require(native_manifest.get("overrides") == [{"name": "blake3", "version": "1.8.7", "port-version": 0}], "unapproved official BLAKE3 C version")
+          for name, version in (("idna", "1.1.0"), ("url", "2.5.8")):
+              require(package(name, version).get("license") == "MIT OR Apache-2.0", f"unapproved {name} license")
+          for item in packages:
+              if item["name"].startswith(("icu_", "unicode-")):
+                  require(item.get("source") in registry, f"{item['name']} must use official registry Unicode data")
+          rust_blake3 = package("blake3", "1.8.7")
+          require(rust_blake3.get("license") == "CC0-1.0 OR Apache-2.0 OR Apache-2.0 WITH LLVM-exception", "unapproved Rust BLAKE3 license")
+          rustls = package("rustls", "0.23.46")
+          package("tokio-rustls", "0.26.6")
+          package("rustls-native-certs", "0.8.5")
+          ring = package("ring")
+          quinn = package("quinn", "0.11.12")
+          proto = package("quinn-proto", "0.11.19")
+          require(proto.get("license") == "MIT OR Apache-2.0", "unapproved QUIC protocol license")
+          require({"rustls-ring", "ring"} <= features(proto), "QUIC protocol must use rustls/ring")
+          require("rustls-ring" in features(quinn), "Quinn wrapper must use rustls/ring")
+          require(not (features(proto) | features(quinn)) & {"aws-lc-rs", "aws-lc-rs-fips", "rustls-aws-lc-rs", "rustls-aws-lc-rs-fips"}, "Quinn must keep the approved ring TLS provider")
+          require(proto["id"] in {dependency["pkg"] for dependency in nodes[quinn["id"]]["deps"]}, "Quinn wrapper must resolve the official protocol source")
+          h3 = package("h3", "0.0.8")
+          require(h3.get("license") == "MIT", "unapproved Quinn HTTP/3 license")
+          h3_quinn = package("h3-quinn", "0.0.10")
+          require(h3["id"] in {dependency["pkg"] for dependency in nodes[h3_quinn["id"]]["deps"]}, "Quinn HTTP/3 adapter must resolve the official source")
+          quiche = package("quiche", "0.30.0")
+          require(features(quiche) == {"boring", "boring-sys", "boringssl-boring-crate", "foreign-types-shared"}, "quiche must use the shared Boring provider without FFI or qlog")
+          require(quiche.get("license") == "BSD-2-Clause", "unapproved quiche license")
+          stack = package("smoltcp", "0.14.0", {smoltcp_source})
+          require(stack.get("license") == "0BSD", "unapproved raw IP stack license")
+          rsa = package("rsa", "0.9.10")
+          rcgen = package("rcgen", "0.14.10")
+          require(features(rsa) == {"std"}, "RSA is restricted to controller key generation")
+          require(features(rcgen) == {"crypto", "ring", "x509-parser"}, "certificate generation must use ring and the reviewed CA parser")
+          x509 = package("x509-parser", "0.18.1")
+          require(x509.get("license") == "MIT OR Apache-2.0", "unapproved X.509 parser license")
+          require(features(x509) == {"default", "ring", "verify"}, "X.509 verification must use ring")
+          x509_parents = {node["id"] for node in nodes.values() if any(dependency["pkg"] == x509["id"] for dependency in node.get("deps", []))}
+          require(x509_parents == {metadata["resolve"]["root"], rcgen["id"]}, "X.509 parsing is restricted to Vole and rcgen")
+          for item in (rsa, rcgen):
+              require(item.get("license") == "MIT OR Apache-2.0", f"unapproved {item['name']} license")
+              parents = {node["id"] for node in nodes.values() if any(dependency["pkg"] == item["id"] for dependency in node.get("deps", []))}
+              require(parents == {metadata["resolve"]["root"]}, f"{item['name']} must be consumed only by Vole")
+          require(ring["id"] in {dependency["pkg"] for dependency in nodes[rcgen["id"]]["deps"]}, "rcgen must use the approved ring package")
+          wireguard = package("boringtun", "0.7.1")
+          require(wireguard.get("license") == "BSD-3-Clause", "unapproved WireGuard license")
+          require(not features(wireguard) & {"device", "ffi-bindings", "jni-bindings"}, "WireGuard must use only the userspace protocol")
           require("ring" in features(rustls) and not features(rustls) & {"reality", "aws_lc_rs", "fips"}, "rustls must use only the ring TLS provider")
-          hpke = package("hpke", "0.14.1")
-          require(features(hpke) == {"alloc", "aes", "chacha", "x25519", "hkdfsha2"}, "unapproved ECH algorithms")
+          mieru_aead = next(item for item in packages if item["name"] == "chacha20poly1305" and item["version"] == "0.11.0")
+          require(mieru_aead.get("source") in registry and "zeroize" in features(mieru_aead), "Mieru must use official zeroizing XChaCha20-Poly1305")
+          mieru_proto = package("prost", "0.14.4")
+          require(mieru_proto.get("license") == "Apache-2.0" and mieru_proto.get("source") in registry, "Mieru protobuf must use official Apache-2.0 prost")
+          hpke = package("hpke", "0.15.1")
+          require(features(hpke) == {"alloc", "aes", "chacha", "x25519", "hkdfsha2", "nistp", "mlkem", "shake"}, "unapproved HPKE algorithms")
+          age = package("age", "0.11.5")
+          require(features(age) == {"armor"}, "AGE must use only native armored-file decoding")
+          package("age-core", "0.11.0")
+          package("x-wing", "0.1.1")
+          package("ml-kem", "0.3.4")
           native = {}
           for name, required in (("boring", {"reality", "client-fingerprint", "shadow-tls-v3", "jls"}), ("boring-sys", {"reality", "shadow-tls-v3", "jls"}), ("tokio-boring", set())):
-              item = package(name, "5.2.0", {boring_source})
+              item = package(name, "5.4.0", {boring_source})
               native[name] = item
               require(required <= features(item), f"{name} is missing required TLS features")
               require(not features(item) & {"fips", "fips-precompiled", "rpk", "pq-experimental", "restls"}, f"{name} enables an unapproved TLS mode")
           for parent, children in (("boring", {"boring-sys"}), ("tokio-boring", {"boring", "boring-sys"})):
               dependencies = {dependency["pkg"] for dependency in nodes[native[parent]["id"]]["deps"]}
               require(all(native[child]["id"] in dependencies for child in children), f"{parent} must use the approved native TLS packages")
+          require(native["boring"]["id"] in {dependency["pkg"] for dependency in nodes[quiche["id"]]["deps"]}, "quiche must share Vole's approved Boring package")
           aws = [item for item in packages if item["name"].lower().startswith("aws-lc")]
           if aws:
               require({item["name"] for item in aws} == {"aws-lc-rs", "aws-lc-sys"}, "unapproved AWS-LC package")
@@ -140,8 +217,17 @@ jobs:
               for name, required in (("shadowsocks", {"aead-cipher-2022"}), ("shadowsocks-crypto", {"v2", "aws-lc"})):
                   require(required <= features(chain[name]), f"{name} must enable SS 2022")
               require(not any(features(item) & {"fips", "aead-cipher-2022-extra", "v2-extra"} for item in chain.values()), "unapproved SS 2022 or AWS-LC mode")
-          print("Locked TLS sources, providers, ECH algorithms and SS 2022 dependency chain passed")
+          print("Locked TLS/Unicode/BLAKE3 sources, controller generation, HPKE/AGE algorithms and SS 2022 dependency chain passed")
           PY
+      - name: Official BLAKE3 raw memory vectors
+        if: matrix.profile == 'features'
+        run: |
+          cargo test --locked -p vole-blake3-raw
+      - name: H3 memory fixtures
+        if: matrix.profile == 'features'
+        run: |
+          cargo test --locked --features cli --lib transport::quiche_h3::tests::
+          cargo test --locked --features cli --lib transport::quinn_h3::tests::
       - name: Production and netstack clippy
         if: matrix.profile == 'features'
         run: |
@@ -177,6 +263,8 @@ jobs:
             xhttp_h3_shutdown hysteria2_paths hysteria2_config shadowsocks_backpressure
             shadowtls_config shadowtls_stream uot_config shadowsocks_uot hysteria2_packet_ids
             tuic_config tuic_memory httpupgrade_config httpupgrade_memory vmess_lifecycle
+            grpc_config grpc_pool grpc_protocol_pool
+            sing_mux_config sing_mux
           )
           target_flags=()
           for target in "${targets[@]}"; do target_flags+=(--test "$target"); done
@@ -184,14 +272,29 @@ jobs:
           # Keep this explicit allowlist: unfiltered legacy tests may open host listeners.
           filters=(
             geodata:: routing:: security:: outbound::vless::encryption config::
-            inbound::mixed::tests:: inbound::socks5::association::tests::
+            connections::tests:: routing::diagnostics::tests:: dialer::connections::tests::
+            polled_datagram_
+            resource::http::tests:: fake_ip_ sniffing::tests:: tcp_sniffer::tests::
+            resource::age_provider::tests:: resource::bundle::tests:: resource::bundle_limits::tests::
+            resource::cache::tests:: resource::subscription::tests::
+            dns::fallback::tests:: dns::runtime::tests::dns_fallback_
+            dns::runtime::tests::resolve_ipv6_
+            dns::source::tests:: dns::runtime::tests::dns_source_
+            dns::runtime::encrypted_tests::
+            dns::options::tests:: dns::runtime::quic_tests:: dns::runtime::ech_tests::
+            controller_secure_
+            outbound::http::tests:: outbound::wireguard::tests:: inbound::mixed::tests:: inbound::socks5::association::tests::
             inbound::http::parser::tests:: inbound::http::framing::tests::
             outbound::hysteria2:: outbound::shadowsocks::tests::official_tcp_
             outbound::anytls:: outbound::uot:: outbound::tuic:: transport::h2_write::tests::
-            transport::sing_mux::smux_driver::tests:: transport::sing_mux::tests::
-            platform::tun_rs_io::tests:: platform::windows_tun_io::tests::
+            outbound::trusttunnel:: outbound::mieru:: outbound::masque:: security::masque:: config::masque::
+            transport::quic:: transport::quinn_h3:: transport::quiche_h3:: transport::masque_codec:: transport::h3_connect::
+            transport::smux::tests:: transport::sing_mux::tests::
+            grpc_duplex_pool_keeps_response
+            outbound::sing_mux::tests::
+            platform::linux_network::tests:: platform::tun_rs_io::tests:: platform::windows_tun_io::tests::
             platform::windows_wintun_io::tests:: tun_runtime::tests::
-            invoke::foreground::tests:: runtime::shutdown_tests::
+            invoke::foreground::tests:: runtime::shutdown_tests:: runtime::providers::tests:: resource::probe::tests:: invoke::measure_delay::tests::
           )
           for filter in "${filters[@]}"; do run_test 1 --lib "$filter"; done
           run_test 1 --bin vole cli::tests::
@@ -200,14 +303,28 @@ jobs:
             dialer::tests::socket_initialization_cancellation_joins_started_and_queued_work
             dialer::tests::socket_initialization_shared_pool_contention_reclaims_cancelled_work
             outbound::connector::tests::authenticated_continuation_keeps_group_choice_but_has_a_new_io_deadline
+            outbound::connector::tests::ingress_connector_dispatcher_preserves_user_for_dialer_proxy_and_continuations
             runtime::tests::integration_feature_admission_is_explicit_without_opening_sockets
             invoke::tests::version_and_state_use_the_fixed_response_envelope
             invoke::tests::initialize_is_idempotent_only_for_the_same_data_directory
             invoke::tests::envelope_and_payload_are_strict
             invoke::tests::runtime_thread_cannot_reenter_invoke
             invoke::tests::engine_workers_preserve_invoke_admission_and_shutdown
+            invoke::tests::update_dns_network_raw_admission_is_bounded_before_value_or_registry_work
+            invoke::tests::update_dns_network_is_runtime_local_strict_and_monotonic
             invoke::tests::engine_completion_notifies_after_panic_and_join_reports_failure
+            dns::runtime::tests::subrule_dns_rules_keep_round_robin_for_new_physical_connections
+            dns::runtime::tests::runtime_dns_separates_bootstrap_proxy_direct_and_hosts
+            dns::runtime::tests::udp_truncation_retries_the_same_upstream_over_tcp
             dns::runtime::tests::concurrent_redir_host_hint_reads_and_dns_updates_complete
+            dns::runtime::tests::domain_policies_use_specificity_and_preserve_geosite_order
+            dns::runtime::tests::dns_policy_selection_is_consistent_across_snapshot_swaps
+            dns::runtime::tests::classical_logical_selectors_drive_dns_policy_and_sniffing_without_egress
+            dns::runtime::tests::rule_budget_propagates_through_fake_ip_policy_and_sniffer_without_egress
+            runtime::tests::prepares_builtin_routes_without_static_nodes_or_bootstrap
+            runtime::tests::prepares_udp_capabilities_through_runtime_wrappers
+            runtime::tests::prepares_shared_mux_capabilities_and_registers_only_final_graph_nodes
+            runtime::tests::controller_diagnostics_are_opt_in_for_business_routes
             invoke::tests::null_invalid_utf8_and_oversized_input_return_json_failures
             invoke::tests::same_instance_command_is_fail_fast
             invoke::tests::android_protector_is_required_only_for_tun
@@ -231,15 +348,22 @@ jobs:
             test "$(grep -Ec '^test result: ok\. [1-9][0-9]* passed; 0 failed;' "$test_log")" -eq "$expected_summaries"
             rm -f "$test_log"
           }
-          protocols=(socks5 anytls shadowsocks trojan vmess vless hysteria2 tuic)
+          protocols=(socks5 anytls shadowsocks trojan trusttunnel mieru masque vmess vless hysteria2 tuic wireguard)
           cargo check --locked --no-default-features --lib
           for protocol in "${protocols[@]}"; do
             cargo check --locked --no-default-features --features "outbound-$protocol" --lib
             run_test 1 --features "outbound-$protocol" --lib runtime::tests::integration_feature_admission_is_explicit_without_opening_sockets -- --exact
           done
-          for feature in inbound-http inbound-socks5 stream-transport quic-transport shadow-tls-v3 tun invoke ffi cli windows-wintun windows-uwp; do
+          for feature in outbound-http inbound-http inbound-socks5 stream-transport quic-transport quinn-h3-transport quiche-h3-transport dns-quic sing-mux shadow-tls-v3 tun invoke ffi cli windows-wintun windows-uwp; do
             cargo check --locked --no-default-features --features "$feature" --lib
           done
+          dns_graph="$(mktemp "$RUNNER_TEMP/vole-dns-graph.XXXXXX")"
+          cargo tree --locked --no-default-features --features dns-quic --target all --edges normal,build --prefix none | tee "$dns_graph"
+          if grep -Eq '^(quiche|boring|boring-sys|tokio-boring) v' "$dns_graph"; then
+            echo "The production DNS feature must use Quinn/rustls without quiche or Boring"
+            exit 1
+          fi
+          rm -f "$dns_graph"
           cargo check --locked --no-default-features --features cli --bin vole
           run_test 2 --test feature_foundations --test hysteria2_config
           cargo check --locked --lib
diff --git a/AGENTS.md b/AGENTS.md
index a5f8a66..2b51361 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -2,29 +2,33 @@
 
 Vole is a standalone Rust proxy core with native libraries and an optional foreground CLI. The native library contract is the JSON Invoke API, with no API or configuration revision fields. The `invoke` feature owns the shared request handler; `cli` and `ffi` are its command-line and native transports. The CLI parses flags, calls Invoke, renders responses, and sets exit status without requiring C ABI or Windows package entry points. Runtime configuration uses the strict schema documented in `docs/config.yaml`; native callers pass it inline as `configYaml` / `configYamls`; the explicit Invoke `foreground` operation owns bounded file/stdin reads, environment/path defaults, signals, and cleanup for CLI use. YAML does not contain `default-proxy`. Business proxy listeners use only `mixed-port`: shared HTTP/SOCKS5 TCP and SOCKS5 UDP require both inbound features. Top-level `port`, `socks-port`, `udp`, and `listeners` are rejected; proxy-node `port` and `udp` retain their outbound semantics. `allow-lan` and `authentication` are independent; omitted or empty authentication leaves both loopback and wildcard bindings unauthenticated. Public lifecycle state is runtime-local and single-instance.
 
-iOS, tvOS 17+ (ARM64 device/simulator), macOS, Android and Linux use config-owned `tun.file-descriptor` through the Unix `tun-rs` adapter; positive descriptors remain host-owned and Vole closes only its duplicate. With descriptor 0, Linux and macOS can create/open native TUN devices from `tun.device`. Linux validates a real single-queue raw-IP TUN and its configured MTU; the host owns addresses, DNS, namespace/routing isolation, and physical egress. Apple packetFlow does not publicly guarantee raw-fd access; Linux or simulator results do not sign off a physical Network Extension. Windows has mutually exclusive `windows-uwp` (`windows-rs` / `Windows.Networking.Vpn`) and `windows-wintun` builds sharing the same core. Validate Wintun devices and packaged UWP integration separately.
+iOS, tvOS 17+ (ARM64 device/simulator), macOS, Android and Linux use config-owned `tun.file-descriptor` through the Unix `tun-rs` adapter; positive descriptors remain host-owned and Vole closes only its duplicate. With descriptor 0, Linux and macOS can create/open native TUN devices from `tun.device`. Linux validates a real single-queue raw-IP TUN and its configured MTU; the host owns borrowed-fd addresses, DNS, namespace/routing isolation, and physical egress. Core-owned Linux TUN supports auto-detect-interface, auto-route and per-link systemd-resolved setup with rollback; package installation supplies capabilities and noninteractive DNS authorization. Apple packetFlow does not publicly guarantee raw-fd access; Linux or simulator results do not sign off a physical Network Extension. Windows has mutually exclusive `windows-uwp` (`windows-rs` / `Windows.Networking.Vpn`) and `windows-wintun` builds sharing the same core. Validate Wintun devices and packaged UWP integration separately.
 
 # Sources of Truth
 
 Current source, tests, and the public contract documents under `docs/` define implemented behavior. Keep documentation focused on current usage and contracts; record validation results in the relevant CI run or PR rather than accumulating development logs. When touching a documented boundary, reconcile its document with the Invoke API and current tests in the same change.
 
+Keep all development plans in the workspace's `references/plan/` directory outside Git repositories (`../references/plan/` from this checkout). Repository documentation contains finalized conclusions, accepted decisions, and current contracts; implementation plans and task lists stay in that external directory.
+
 Read the relevant document completely before changing that area:
 
+- Mihomo compatibility, protocol interoperability, or compatibility/performance tradeoffs: `docs/mihomo-compatibility.md`. Apply its compatibility principles to implementation, tests, and reviews. For performance or defect fixes, first compare local Mihomo, clash-rs and official client source, then profile the matched workload to locate the bottleneck, and only then change Vole. Distinguish Core, peer and benchmark causes; retain confirmed peer failures instead of changing Core for them. Shared-layer changes require explicit regressions of affected previously passing windows; historical PASS does not sign off changed code.
 - Invoke, FFI, lifecycle, Android protect, or config delivery: `docs/invoke-api.md`, `src/invoke/`, and `src/ffi/`.
 - YAML, proxy graph, proxy groups, DNS, rules, or sniffer: `docs/config.yaml`, `docs/tun-icmp-dns.md`, and `src/config/`.
 - HTTP/SOCKS5 inbound, authentication, or listeners: `docs/inbounds.md` and `src/inbound/`.
+- Business HTTP rewrite, selective TLS, or its separate configuration: `docs/http-processing.md` and `src/http_processing/`.
 - SOCKS5, AnyTLS, Trojan, VMess, Hysteria2, TUIC v5 or SS 2022: `docs/outbounds.md`.
 - VLESS, Vision, Encryption, JLS or static ECH: `docs/vless.md`.
 - XHTTP request fields, download legs, H1/H2/H3 or sing-mux: `docs/xhttp.md`.
 - Runtime Controller, proxy-group selection, or TUN traffic metrics: `docs/controller-api.md` and `src/controller.rs`.
 - GeoData: `docs/geodata.md`.
-- TLS profiles, certificate policy or TLS dependencies: `docs/tls-client-fingerprint.md` and `docs/tls-dependencies.md`; REALITY also requires `docs/reality-wire-protocol.md`. Before local boring development or opening/updating a PR, follow the dependency-source workflow in `docs/tls-dependencies.md`. Keep dependency auditing in CI rather than duplicating it in platform build scripts.
+- TLS profiles, certificate policy or TLS dependencies: `docs/tls-client-fingerprint.md` and `docs/tls-dependencies.md`; REALITY also requires `docs/reality-wire-protocol.md`. Before local Boring development or opening/updating a Vole PR, follow the path-to-commit workflow and Boring PR prerequisite in `docs/tls-dependencies.md`. Keep dependency auditing in CI rather than duplicating it in platform build scripts.
 - TUN fields, resource acquisition, fd ownership, packet I/O, MTU, or UDP idle policy: `docs/config.yaml`, `docs/tun-platform.md`, and `docs/tun-icmp-dns.md`.
 - Windows VPN/TUN, outbound binding, AppContainer packet buffers, or package lifecycle: `docs/windows-vpn.md` and `docs/tun-platform.md`.
 - CLI, foreground file/environment/path/signal behavior, or tag releases: `docs/cli.md`, `docs/invoke-api.md`, `scripts/README.md`, `src/cli.rs`, `src/invoke/foreground.rs`, and `.github/workflows/release.yml`; distinguish configured workflows from executed release validation.
 - Builds: `scripts/README.md`; `vole-scripts build` compiles platform outputs, and `vole_scripts.release` packages them for CI.
 - Offline regressions: `tests/README.md`. Rust memory/configuration tests remain in Vole; run explicit pure-memory filters, with all-target coverage limited to `--no-run`.
-- Protocol interoperability or pressure: the public [container-benchmark](https://github.com/YuanDevTeam/container-benchmark) owns all container orchestration and fixtures. Supply the checkout explicitly with `--source vole=PATH`; Vole builds do not import it or infer workspace paths.
+- Protocol interoperability or pressure: isolated benchmark tooling owns container orchestration and fixtures. Supply the checkout explicitly with `--source vole=PATH`; Vole builds do not import it or infer workspace paths. Keep benchmark results, comparisons and conclusions in the benchmark project; Vole documents implementation contracts and acceptance criteria. Keep tooling repository addresses and raw runs outside Vole.
 - Server-side tests: `docs/testing-isolation.md`. Use isolated benchmark containers for every server peer and network origin; container failure is not permission for a host fallback.
 - Claims that something passed: `docs/acceptance.md`. Record only commands and environments actually executed; host tests and cross-builds do not prove physical-device data paths.
 
@@ -32,12 +36,12 @@ Read the relevant document completely before changing that area:
 
 - `src/invoke/` owns shared JSON dispatch, registry, lifecycle admission, panic containment, and engine completion. `start(configYaml)` performs internal preparation and platform acquisition; no public `prepare` or fd/framing payload exists. `validateConfig` needs no initialization.
 - `src/ffi/` adapts C ABI and Android JNI to Invoke and preserves native buffer/callback boundaries.
-- `src/cli.rs` owns five flags, Invoke request conversion, rendering, and exit status. `src/invoke/foreground.rs` owns file/stdin reads, native path metadata, environment defaults, process signals, bounded stderr, and foreground cleanup. Foreground validation reads its input but does not initialize data, resolve remote endpoints, or inspect platform devices.
+- `src/cli.rs` owns argument parsing, Invoke request conversion, rendering, and exit status. `src/invoke/foreground.rs` owns file/stdin reads, native path metadata, environment defaults, process signals, stderr logging, and foreground cleanup. Foreground validation reads its input but does not initialize data, resolve remote endpoints, or inspect platform devices.
 - `src/runtime.rs` prepares and owns DNS, routing, outbound graphs, listeners, GeoData, and long-lived tasks.
 - `src/tun_runtime.rs` connects platform raw-IP I/O to `vole-netstack` and dispatches TCP, UDP, DNS, ICMP, and sniffing.
 - `src/platform/` contains platform adapters. Keep framing internal, propagate configured MTU, and preserve original borrowed-fd flags and ownership. Windows backend selection occurs at compilation; keep Windows callback semantics here instead of simulating a Unix fd.
 - `src/dialer.rs` is the shared physical TCP/UDP socket seam. Fix socket protection or Windows `(source IP, interface index)` binding once here rather than in each outbound.
-- Static `select` groups share Running Session selection between routing and `dialer-proxy`. Keep protocol configuration immutable, validate the complete node/member DAG, and retain only declared dependencies to avoid Arc cycles. Resolve upstreams at the `OutboundConnector` seam using one setup deadline and per-group selection snapshot; prepare every potential DIRECT server endpoint. `measureDelay` remains node-only.
+- Static and provider-backed select, url-test and fallback groups share Running Session selection between routing and `dialer-proxy`. Provider candidates validate the complete graph before publication; existing sessions retain their old resource generation until release. Keep protocol configuration immutable, validate the complete node/member DAG, and retain only declared dependencies to avoid Arc cycles. Resolve upstreams at the `OutboundConnector` seam using one setup deadline and per-group selection snapshot; resolve DIRECT server endpoints on demand through the proxy DNS role. `measureDelay` remains node-only.
 - `crates/vole-netstack` is platform-independent raw-IP state and must not depend on WinRT, JNI, Swift, or host UI frameworks.
 - Core runtime lifecycle does not infer App, extension, service, or daemon roles and does not implement cross-process state or IPC. The Windows-only host Invoke is the explicit package integration seam for profile/status/Session Snapshot/StartupTask operations and an optional bounded `sessionBackend`; its Session Host owns backend process liveness without interpreting arguments, files, ports, or protocols. Provider runtime state remains process-local.
 
@@ -45,7 +49,7 @@ Read the relevant document completely before changing that area:
 
 1. Keep the latest-only schema strict. Reject unknown and obsolete fields instead of adding compatibility branches or silent migration.
 2. Preserve bounded queues, packet/buffer/parser limits, cancellation, and synchronous stop barriers. Do not turn UDP callback paths into blocking waits.
-3. Keep secrets, UUIDs, DNS questions, full config/request bodies, and runtime traffic destinations out of logs and errors. Configuration-service endpoints may appear only as a bounded, sanitized origin or source index when operational diagnosis requires it; never log userinfo, query, fragment, private addresses, or redirect targets.
+3. CLI and Controller logs preserve each emitted event's complete target, message and fields, including strings, errors and Debug values. Apply configured log levels and bounded subscription queues, without content redaction, field allowlists, truncation or additional rate limits. Do not add logging of configuration/request bodies or credentials merely to populate logs; API error and snapshot contracts remain separate.
 4. Platform trust boundaries fail closed. Android protect failure, WinRT VPN physical-interface loss, invalid packet-buffer ownership, or unsupported target startup must not fall back to an unprotected socket. Desktop Wintun leaves interface addresses, DNS, routes and physical-egress isolation to the host; it does not inherit the WinRT Provider's binding or network-change monitor.
 5. Packaged Windows VPN uses official `Windows.Networking.Vpn` through `windows-rs`. `VpnPacketBuffer` bytes are copied within callbacks. After acquiring a framework buffer, return it to Windows before propagating any later local error; a return-API failure propagates the platform error and fails closed. Every framework buffer is returned exactly once. Network changes stop this path; they do not silently rebind or reconnect.
 6. Reuse the existing raw-IP netstack, runtime and outbound graph. Windows WinRT VPN and desktop Wintun use separate platform adapters with the shared Dialer and synchronous stop barrier; Wintun's DLL and first-release network configuration are host-owned. Add no second Windows proxy core, per-protocol socket factory or fake fd layer.
diff --git a/CONTEXT.md b/CONTEXT.md
index f3b6689..9040004 100644
--- a/CONTEXT.md
+++ b/CONTEXT.md
@@ -72,14 +72,21 @@ _Avoid_: Managed core, child core, URI configuration
 A named, concrete outbound protocol path that can be selected as a route target or referenced by another proxy node through `dialer-proxy`.
 _Avoid_: Proxy when a proxy group or route target is intended, server profile
 
+**Routing control**:
+A named rule-flow effect that updates the current decision and resumes rule evaluation without establishing a protocol connection. It is not a measurable proxy node.
+_Avoid_: Physical outbound, transport, fake connection
+
 **Proxy group**:
-A named route or upstream target whose current-session selection identifies one direct member. Routing and `dialer-proxy` share the same selection; an upstream group's DIRECT member connects the current node's prepared server.
+A named route or upstream target whose current-session selection identifies one direct member. Routing and `dialer-proxy` share the same selection; an upstream group's DIRECT member connects the current node's server resolved on demand.
 _Avoid_: Folder, provider, subscription
 
 **Route target**:
-A proxy node, proxy group, or reserved built-in target that routing rules, the final `MATCH`, and DNS routes can select.
+A proxy node, routing control, proxy group, or reserved built-in target. Rule-flow controls run only during rule evaluation; selecting one as a physical upstream does not establish a connection.
 _Avoid_: Proxy when the distinction between a node and group matters, dialer
 
 **Group selection**:
 The running-session state identifying the direct member route target currently chosen by a proxy group.
 _Avoid_: Variant, configuration switch, active profile
+
+**Resource generation**:
+A validated combination of provider content, proxy nodes, groups, rules and DNS policies. New sessions use the published generation; existing sessions retain their dependencies until completion. Failed candidates preserve the usable generation and its HTTP cache.
diff --git a/Cargo.lock b/Cargo.lock
index 8d144cd..7222452 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -8,25 +8,35 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
+[[package]]
+name = "aead"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0"
+dependencies = [
+ "crypto-common 0.1.7",
+ "generic-array",
+]
+
 [[package]]
 name = "aead"
 version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1973cfbc1a2daf9cf550e74e1f088c28e7f7d8c1e1418fb6c9dc5184b7e84c99"
 dependencies = [
- "crypto-common",
- "inout",
+ "crypto-common 0.2.2",
+ "inout 0.2.5",
 ]
 
 [[package]]
 name = "aes"
-version = "0.9.3"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "35f0f96ce78e38c3dc6d8948aa8163d06385be74000f3c7a95bf1eef35d3ea32"
+checksum = "fc0fc36d7440d015b45468ba08a21e80e056ebbd014c611c6298bb7503e04bd1"
 dependencies = [
- "cipher",
+ "cipher 0.5.2",
  "cpubits",
- "cpufeatures",
+ "cpufeatures 0.3.1",
  "zeroize",
 ]
 
@@ -36,14 +46,70 @@ version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f2b8006a0c83f52b62ba44a97b58bf76fe2f70a329e588f67f89691d93d498f"
 dependencies = [
- "aead",
+ "aead 0.6.1",
  "aes",
- "cipher",
+ "cipher 0.5.2",
  "ctr",
  "ctutils",
  "ghash",
 ]
 
+[[package]]
+name = "age"
+version = "0.11.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "047a482d1843edf1ce76ada63183698144030fe1191bd5ddba6e41e164e0bc43"
+dependencies = [
+ "age-core",
+ "base64 0.21.7",
+ "bech32 0.9.1",
+ "chacha20poly1305 0.10.1",
+ "cookie-factory",
+ "hmac 0.12.1",
+ "i18n-embed",
+ "i18n-embed-fl",
+ "lazy_static",
+ "nom",
+ "pin-project",
+ "rand 0.8.8",
+ "rust-embed",
+ "scrypt",
+ "sha2 0.10.9",
+ "subtle",
+ "x25519-dalek 2.0.1",
+ "zeroize",
+]
+
+[[package]]
+name = "age-core"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2bf6a89c984ca9d850913ece2da39e1d200563b0a94b002b253beee4c5acf99"
+dependencies = [
+ "base64 0.21.7",
+ "chacha20poly1305 0.10.1",
+ "cookie-factory",
+ "hkdf 0.12.4",
+ "io_tee",
+ "nom",
+ "rand 0.8.8",
+ "secrecy",
+ "sha2 0.10.9",
+]
+
+[[package]]
+name = "ahash"
+version = "0.8.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
+dependencies = [
+ "cfg-if",
+ "getrandom 0.3.4",
+ "once_cell",
+ "version_check",
+ "zerocopy",
+]
+
 [[package]]
 name = "aho-corasick"
 version = "1.1.5"
@@ -68,15 +134,27 @@ dependencies = [
  "alloc-no-stdlib",
 ]
 
+[[package]]
+name = "anyhow"
+version = "1.0.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
+
 [[package]]
 name = "arc-swap"
-version = "1.9.2"
+version = "1.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c049c0be4daef0b145cb3555416b3b8ef5b7888a38aea1a3a155801fe7b0810b"
+checksum = "380962b3d93b99642e50b9febf72c071e97e8b32d86eae9cf4ef582bb960ae6e"
 dependencies = [
  "rustversion",
 ]
 
+[[package]]
+name = "arraydeque"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d902e3d592a523def97af8f317b08ce16b7ab854c1985a0c671e6f15cebc236"
+
 [[package]]
 name = "arrayvec"
 version = "0.7.8"
@@ -95,7 +173,7 @@ dependencies = [
  "nom",
  "num-traits",
  "rusticata-macros",
- "thiserror",
+ "thiserror 2.0.21",
  "time",
 ]
 
@@ -130,7 +208,7 @@ checksum = "82f6aeea286b8eb4dd3431a1be1b59d290ace00f5bfd8e2a159bc2a05e2c1667"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
 ]
 
 [[package]]
@@ -147,9 +225,9 @@ checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
 
 [[package]]
 name = "aws-lc-rs"
-version = "1.18.1"
+version = "1.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b281d307588d634de920874890732659e2e7672f72b5e10e81badc1a8a83621e"
+checksum = "048006790404103c488e6c5616b3e7e702a71292aadda08e8f7698a9e0d2eb53"
 dependencies = [
  "aws-lc-sys",
  "untrusted 0.7.1",
@@ -158,9 +236,9 @@ dependencies = [
 
 [[package]]
 name = "aws-lc-sys"
-version = "0.45.0"
+version = "0.47.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9bff6c3b54fad79a2e60b8102caf565819711497c1f5f092f49508e2f5c31b27"
+checksum = "8bfbe32ac36b3c428696ce315464181bc4029d689fd58e3f2a4e58c252242f52"
 dependencies = [
  "cc",
  "cmake",
@@ -169,12 +247,57 @@ dependencies = [
  "pkg-config",
 ]
 
+[[package]]
+name = "base16ct"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd307490d624467aa6f74b0eabb77633d1f758a7b25f12bceb0b22e08d9726f6"
+
+[[package]]
+name = "base64"
+version = "0.21.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
+
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
 [[package]]
 name = "base64"
 version = "0.23.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5"
 
+[[package]]
+name = "base64ct"
+version = "1.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"
+
+[[package]]
+name = "basic-toml"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba62675e8242a4c4e806d12f11d136e626e6c8361d6b829310732241652a178a"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "bech32"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d86b93f97252c47b41663388e6d155714a9d0c398b99f1005cbc5f978b29f445"
+
+[[package]]
+name = "bech32"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "efbd3e1070bbdf4cd88a75264e18e8a26f7cb5c6949eadf0ceb85fb159cf08f8"
+
 [[package]]
 name = "bindgen"
 version = "0.72.1"
@@ -184,15 +307,30 @@ dependencies = [
  "bitflags 2.13.2",
  "cexpr",
  "clang-sys",
- "itertools",
+ "itertools 0.13.0",
  "proc-macro2",
  "quote",
  "regex",
- "rustc-hash",
+ "rustc-hash 2.1.3",
  "shlex 1.3.0",
  "syn 2.0.119",
 ]
 
+[[package]]
+name = "bit-set"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
+dependencies = [
+ "bit-vec 0.8.0",
+]
+
+[[package]]
+name = "bit-vec"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
+
 [[package]]
 name = "bit-vec"
 version = "0.9.1"
@@ -214,13 +352,22 @@ version = "2.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06"
 
+[[package]]
+name = "blake2"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46502ad458c9a52b69d4d4d32775c788b7a1b85e8bc9d482d92250fc0e3f8efe"
+dependencies = [
+ "digest 0.10.7",
+]
+
 [[package]]
 name = "blake2"
 version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5b5d4d889834ee8ecfc0f8426ad30faf7cdcb10f741a8e6d7224d95325479f6f"
 dependencies = [
- "digest",
+ "digest 0.11.3",
 ]
 
 [[package]]
@@ -233,7 +380,16 @@ dependencies = [
  "cc",
  "cfg-if",
  "constant_time_eq",
- "cpufeatures",
+ "cpufeatures 0.3.1",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
 ]
 
 [[package]]
@@ -243,12 +399,13 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d2f6c7dbe95a6ed67ad9f18e57daf93a2f034c524b99fd2b76d18fdfeb6660aa"
 dependencies = [
  "hybrid-array",
+ "zeroize",
 ]
 
 [[package]]
 name = "boring"
-version = "5.2.0"
-source = "git+https://github.com/YuanDevTeam/boring?branch=release#43c1c1d5b9464b3f2d5204be8664778fada7dbaf"
+version = "5.4.0"
+source = "git+https://github.com/YuanDevTeam/boring?rev=c717137e6c794a0b069f64686a375858ffc80818#c717137e6c794a0b069f64686a375858ffc80818"
 dependencies = [
  "bitflags 2.13.2",
  "boring-sys",
@@ -261,8 +418,8 @@ dependencies = [
 
 [[package]]
 name = "boring-sys"
-version = "5.2.0"
-source = "git+https://github.com/YuanDevTeam/boring?branch=release#43c1c1d5b9464b3f2d5204be8664778fada7dbaf"
+version = "5.4.0"
+source = "git+https://github.com/YuanDevTeam/boring?rev=c717137e6c794a0b069f64686a375858ffc80818#c717137e6c794a0b069f64686a375858ffc80818"
 dependencies = [
  "bindgen",
  "cmake",
@@ -270,11 +427,36 @@ dependencies = [
  "fslock",
 ]
 
+[[package]]
+name = "boringtun"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15dd6a8a89cbe8997f37ca0cf035e6ea4d64cd2ecea4aed83ffb9f99f7126939"
+dependencies = [
+ "aead 0.5.2",
+ "base64 0.22.1",
+ "blake2 0.10.6",
+ "chacha20poly1305 0.10.1",
+ "hex",
+ "hmac 0.12.1",
+ "ip_network",
+ "ip_network_table",
+ "libc",
+ "nix 0.31.3",
+ "parking_lot",
+ "portable-atomic",
+ "rand_core 0.6.4",
+ "ring",
+ "tracing",
+ "untrusted 0.9.0",
+ "x25519-dalek 2.0.1",
+]
+
 [[package]]
 name = "brotli"
-version = "9.0.0"
+version = "9.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8b851b75c23ca7873623d612fe49bd1989aeb03d08fb9432187eb253d3d4c6b"
+checksum = "627b7cfb0578f0eafce087a90fcd40add1231900b69e4d4de2d456260a4f5d81"
 dependencies = [
  "alloc-no-stdlib",
  "alloc-stdlib",
@@ -283,9 +465,9 @@ dependencies = [
 
 [[package]]
 name = "brotli-decompressor"
-version = "6.0.1"
+version = "6.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "941cd9bd4ddab83cb46fa5a2d428f1c857b24ac78cb876cf7beb710840934bd7"
+checksum = "34c6783f42c21c952ad7112b354f0ba2f10760e9decea5b1b60523d6e270faaf"
 dependencies = [
  "alloc-no-stdlib",
  "alloc-stdlib",
@@ -317,9 +499,9 @@ checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04"
 
 [[package]]
 name = "cc"
-version = "1.5.1"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f360145194ee8e21db5ee7f3fcd4fe52210864c75c985dae33218202c8bbe040"
+checksum = "375989decec1a0fa424442bed520fa12ede43a48475ce8c7417d2c69b32b5f6b"
 dependencies = [
  "find-msvc-tools",
  "jobserver",
@@ -348,6 +530,17 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f079e83a288787bcd14a6aea84cee5c87a67c5a3e660c30f557a3d24761b3527"
 
+[[package]]
+name = "chacha20"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818"
+dependencies = [
+ "cfg-if",
+ "cipher 0.4.4",
+ "cpufeatures 0.2.17",
+]
+
 [[package]]
 name = "chacha20"
 version = "0.10.2"
@@ -355,9 +548,23 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06"
 dependencies = [
  "cfg-if",
- "cipher",
- "cpufeatures",
- "rand_core",
+ "cipher 0.5.2",
+ "cpufeatures 0.3.1",
+ "rand_core 0.10.1",
+ "zeroize",
+]
+
+[[package]]
+name = "chacha20poly1305"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10cd79432192d1c0f4e1a0fef9527696cc039165d729fb41b3f4f4f354c2dc35"
+dependencies = [
+ "aead 0.5.2",
+ "chacha20 0.9.1",
+ "cipher 0.4.4",
+ "poly1305 0.8.0",
+ "zeroize",
 ]
 
 [[package]]
@@ -366,10 +573,22 @@ version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b89e1c441e926b9c82a8d023f6e1b7ae0adcfaa7d621814e4d60789bac751cb"
 dependencies = [
- "aead",
- "chacha20",
- "cipher",
- "poly1305",
+ "aead 0.6.1",
+ "chacha20 0.10.2",
+ "cipher 0.5.2",
+ "poly1305 0.9.1",
+ "zeroize",
+]
+
+[[package]]
+name = "cipher"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
+dependencies = [
+ "crypto-common 0.1.7",
+ "inout 0.1.4",
+ "zeroize",
 ]
 
 [[package]]
@@ -378,9 +597,9 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e8cf2a2c93cd704877c0858356ed03480ff301ee950b43f1cbe4573b088bfa6c"
 dependencies = [
- "block-buffer",
- "crypto-common",
- "inout",
+ "block-buffer 0.12.1",
+ "crypto-common 0.2.2",
+ "inout 0.2.5",
 ]
 
 [[package]]
@@ -409,6 +628,12 @@ version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0c9ea0ac24bc397ab3c98583a3c9ba74fa56b09a4449bbe172b9b1ddb016027a"
 
+[[package]]
+name = "const-oid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
+
 [[package]]
 name = "const-oid"
 version = "0.10.2"
@@ -421,6 +646,15 @@ version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3d52eff69cd5e647efe296129160853a42795992097e8af39800e1060caeea9b"
 
+[[package]]
+name = "cookie-factory"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9885fa71e26b8ab7855e2ec7cae6e9b380edff76cd052e07c683a0319d51b3a2"
+dependencies = [
+ "futures",
+]
+
 [[package]]
 name = "core-foundation"
 version = "0.10.1"
@@ -449,6 +683,15 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "15b85f9c39137c3a891689859392b1bd49812121d0d61c9caf00d46ed5ce06ae"
 
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "cpufeatures"
 version = "0.3.1"
@@ -460,13 +703,39 @@ dependencies = [
 
 [[package]]
 name = "crc32fast"
-version = "1.5.2"
+version = "1.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01a7799fd6b852db0e61728dde9a204c423b44d689dbd432522543614b490e78"
+checksum = "5f97d3416d5337d15c4b0d78c8c91df922ca143f57ec20e2d1c188333047ef04"
 dependencies = [
  "cfg-if",
 ]
 
+[[package]]
+name = "crypto-bigint"
+version = "0.7.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c035cb64cba03dad2fb921f3e218785e8cf9a41790da5eb3a1400f62fa2be11"
+dependencies = [
+ "cpubits",
+ "ctutils",
+ "hybrid-array",
+ "num-traits",
+ "rand_core 0.10.1",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "rand_core 0.6.4",
+ "typenum",
+]
+
 [[package]]
 name = "crypto-common"
 version = "0.2.2"
@@ -475,7 +744,7 @@ checksum = "ce6e4c961d6cd6c9a86db418387425e8bdeaf05b3c8bc1411e6dca4c252f1453"
 dependencies = [
  "getrandom 0.4.3",
  "hybrid-array",
- "rand_core",
+ "rand_core 0.10.1",
 ]
 
 [[package]]
@@ -484,16 +753,32 @@ version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baaca1c4b237092596f64d571e9db6ce4109c4ef9742e27590f1709594461f21"
 dependencies = [
- "cipher",
+ "cipher 0.5.2",
 ]
 
 [[package]]
 name = "ctutils"
-version = "0.4.2"
+version = "0.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d5515a3834141de9eafb9717ad39eea8247b5674e6066c404e8c4b365d2a29e"
+checksum = "a2376ffd6f96d8a9db59875b4b6b0237d6900b5baf64279714e05493ce64828a"
 dependencies = [
  "cmov",
+ "subtle",
+]
+
+[[package]]
+name = "curve25519-dalek"
+version = "4.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.2.17",
+ "curve25519-dalek-derive",
+ "fiat-crypto 0.2.9",
+ "rustc_version",
+ "subtle",
+ "zeroize",
 ]
 
 [[package]]
@@ -503,9 +788,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b5eed333089e2e1c1ac8c6c0398e5e2497b4c9926ca6d0365ed1e099afa5bc23"
 dependencies = [
  "cfg-if",
- "cpufeatures",
+ "cpufeatures 0.3.1",
  "curve25519-dalek-derive",
- "fiat-crypto",
+ "fiat-crypto 0.3.0",
  "rustc_version",
  "subtle",
  "zeroize",
@@ -528,11 +813,17 @@ version = "2.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4583a4551df46e2792f82ceeac45e850d2e2d5debba0b91f102385cda5b11f06"
 
+[[package]]
+name = "debug_panic"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9377eb110cece2e9431deb8d7d2ec8c116510b896741f9f2bf02b352147aa2a6"
+
 [[package]]
 name = "defmt"
-version = "1.1.1"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2953bfe4f93bbd20cc71198842756f77d161884c99ebbabc41d80231ded88d1"
+checksum = "e4a0795ac740cb54d7b3775c9c17345f6aaecf884c01733b39d6017738e0e3e1"
 dependencies = [
  "bitflags 1.3.2",
  "defmt-macros",
@@ -540,23 +831,43 @@ dependencies = [
 
 [[package]]
 name = "defmt-macros"
-version = "1.1.1"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bad9c72e7ca2137e0dc3813245a0d282fd6daad32fd800af018306a9169b5fe8"
+checksum = "840bb056bd99c495c9188198a258ab787c79f306d864db3e6e8451442d6d8366"
 dependencies = [
  "defmt-parser",
  "proc-macro2",
  "quote",
- "syn 2.0.119",
+ "syn 3.0.9",
 ]
 
 [[package]]
 name = "defmt-parser"
-version = "1.0.0"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71958f69fb2de856c5dd51ac9377e986ca1aa5919f931bf5395a807277f889a0"
+dependencies = [
+ "thiserror 2.0.21",
+]
+
+[[package]]
+name = "der"
+version = "0.7.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb"
+dependencies = [
+ "const-oid 0.9.6",
+ "zeroize",
+]
+
+[[package]]
+name = "der"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10d60334b3b2e7c9d91ef8150abfb6fa4c1c39ebbcf4a81c2e346aad939fee3e"
+checksum = "6a996a108feb8b427a6e12fcf6af4aa83409b79d72c15337d7741368131ee004"
 dependencies = [
- "thiserror",
+ "const-oid 0.10.2",
+ "zeroize",
 ]
 
 [[package]]
@@ -575,9 +886,21 @@ dependencies = [
 
 [[package]]
 name = "deranged"
-version = "0.5.8"
+version = "0.5.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e9de72ce2ad1f90dc62fa25f0f430ef85eb4b0d8fa0be4f30373bc40a21d28e"
+
+[[package]]
+name = "digest"
+version = "0.10.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer 0.10.4",
+ "const-oid 0.9.6",
+ "crypto-common 0.1.7",
+ "subtle",
+]
 
 [[package]]
 name = "digest"
@@ -585,10 +908,11 @@ version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2"
 dependencies = [
- "block-buffer",
- "const-oid",
- "crypto-common",
+ "block-buffer 0.12.1",
+ "const-oid 0.10.2",
+ "crypto-common 0.2.2",
  "ctutils",
+ "zeroize",
 ]
 
 [[package]]
@@ -599,7 +923,33 @@ checksum = "c6232dd377dcc64799954cbd3a9bb882e9cdc1308ccd87b1c098f1fb2eaf82a8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
+]
+
+[[package]]
+name = "domain"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b68712c02bff2348323c1441ab2e8528e32af4f8f9edf29356356290328c8e6"
+dependencies = [
+ "bumpalo",
+ "bytes",
+ "domain-macros",
+ "hashbrown",
+ "jiff",
+ "octseq",
+ "serde",
+]
+
+[[package]]
+name = "domain-macros"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fba8fbc4580c745dfeab102232dcb729f030ac3e2c9ff5374a9dfd6dc9ddf8e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
 ]
 
 [[package]]
@@ -630,15 +980,35 @@ dependencies = [
 
 [[package]]
 name = "either"
-version = "1.18.0"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e9c71c2167ca323c882b99918929403426e2373ea17242ff5653e0d5e1058be"
+
+[[package]]
+name = "elliptic-curve"
+version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "252afb9ae5eaa683babdc6a068b3f5726eb19e05070c731f9b2a23a7c3e8ed34"
+checksum = "900f37e7e18d74a2347389af6cd69e3a30d5cc9e697f40004865679aa75e9c7c"
+dependencies = [
+ "base16ct",
+ "crypto-bigint",
+ "crypto-common 0.2.2",
+ "digest 0.11.3",
+ "ff",
+ "group",
+ "hkdf 0.13.0",
+ "hybrid-array",
+ "rand_core 0.10.1",
+ "sec1",
+ "subtle",
+ "zeroize",
+]
 
 [[package]]
 name = "encoding_rs"
-version = "0.8.42"
+version = "0.8.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e985e0451871ad22fb8d2b6b076e2028a502a0d3950998c2c5c0a4f9b5d9679"
+checksum = "89253175e704ab869b04f9db224d38630e0211a53841a79181deae0889e169f5"
 dependencies = [
  "cfg-if",
  "core_detect",
@@ -648,11 +1018,23 @@ dependencies = [
  "simdutf8",
 ]
 
+[[package]]
+name = "enum_dispatch"
+version = "0.3.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa18ce2bc66555b3218614519ac839ddb759a7d6720732f979ef8d13be147ecd"
+dependencies = [
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
 [[package]]
 name = "equivalent"
-version = "1.0.2"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+checksum = "00d174d5400e5e8fd687ad1049e2f578285fa914201b1af7e8b112a4546bd826"
 
 [[package]]
 name = "errno"
@@ -664,6 +1046,17 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "fancy-regex"
+version = "0.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20ed7f62ce0ae0da1a8b93c3c7104ab7e0760a74491e097c701fff966e945390"
+dependencies = [
+ "bit-set",
+ "regex-automata",
+ "regex-syntax",
+]
+
 [[package]]
 name = "fastrand"
 version = "2.5.0"
@@ -674,16 +1067,41 @@ dependencies = [
 ]
 
 [[package]]
-name = "fiat-crypto"
-version = "0.3.0"
+name = "ff"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1f686ab92a9fb0eaf188f6c6c87b89490baa6fdb0db4544ba4dc47f7942489f"
+dependencies = [
+ "rand_core 0.10.1",
+ "subtle",
+]
+
+[[package]]
+name = "fiat-crypto"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28dea519a9695b9977216879a3ebfddf92f1c08c05d984f8996aecd6ecdc811d"
+
+[[package]]
+name = "fiat-crypto"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "64cd1e32ddd350061ae6edb1b082d7c54915b5c672c389143b9a63403a109f24"
 
+[[package]]
+name = "find-crate"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59a98bbaacea1c0eb6a0876280051b892eb73594fd90cf3b20e9c817029c57d2"
+dependencies = [
+ "toml",
+]
+
 [[package]]
 name = "find-msvc-tools"
-version = "0.1.14"
+version = "0.1.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aedcfb3409746eddb02b9e19ebda1c3394f759a152e48ee875a0844d1b955484"
+checksum = "1c66915cc5391097de7a2b0b972e8505aa33c0df401fd3a6811dbdb32881ba48"
 
 [[package]]
 name = "flate2"
@@ -695,6 +1113,50 @@ dependencies = [
  "miniz_oxide",
 ]
 
+[[package]]
+name = "fluent"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb74634707bebd0ce645a981148e8fb8c7bccd4c33c652aeffd28bf2f96d555a"
+dependencies = [
+ "fluent-bundle",
+ "unic-langid",
+]
+
+[[package]]
+name = "fluent-bundle"
+version = "0.15.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fe0a21ee80050c678013f82edf4b705fe2f26f1f9877593d13198612503f493"
+dependencies = [
+ "fluent-langneg",
+ "fluent-syntax",
+ "intl-memoizer",
+ "intl_pluralrules",
+ "rustc-hash 1.1.0",
+ "self_cell 0.10.3",
+ "smallvec",
+ "unic-langid",
+]
+
+[[package]]
+name = "fluent-langneg"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7eebbe59450baee8282d71676f3bfed5689aeab00b27545e83e5f14b1195e8b0"
+dependencies = [
+ "unic-langid",
+]
+
+[[package]]
+name = "fluent-syntax"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a530c4694a6a8d528794ee9bbd8ba0122e779629ac908d15ad5a7ae7763a33d"
+dependencies = [
+ "thiserror 1.0.69",
+]
+
 [[package]]
 name = "flume"
 version = "0.12.0"
@@ -713,6 +1175,12 @@ version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
+[[package]]
+name = "foldhash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+
 [[package]]
 name = "foreign-types"
 version = "0.5.0"
@@ -731,7 +1199,7 @@ checksum = "ea5190182e6915eb873ddbc16e23b711b6eb1f9c00a0d0a3a91b5f6228475225"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
 ]
 
 [[package]]
@@ -821,7 +1289,7 @@ checksum = "9fb9654ba8355388abeb8dcb4fc62f511300867002afc858860463bdd9fe0c44"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
 ]
 
 [[package]]
@@ -853,6 +1321,16 @@ dependencies = [
  "slab",
 ]
 
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
 [[package]]
 name = "getifaddrs"
 version = "0.6.2"
@@ -877,6 +1355,18 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 5.3.0",
+ "wasip2",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.4.3"
@@ -886,8 +1376,8 @@ dependencies = [
  "cfg-if",
  "js-sys",
  "libc",
- "r-efi",
- "rand_core",
+ "r-efi 6.0.0",
+ "rand_core 0.10.1",
  "wasm-bindgen",
 ]
 
@@ -906,11 +1396,22 @@ version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e4eba85ea1d0a966a983acd07deee566e67395d2d96b6fb39e62b5a833f1eb0b"
 
+[[package]]
+name = "group"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fd1a1c7a5206c5b7a3f5a0d7ccd3ff85d0c8f5133d62a02680255b0004af5f4"
+dependencies = [
+ "ff",
+ "rand_core 0.10.1",
+ "subtle",
+]
+
 [[package]]
 name = "h2"
-version = "0.4.19"
+version = "0.4.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef8e5e5a340588f4452631496976cf8636d4a7ecf600239fdc27615d2530bc16"
+checksum = "7d29020232d6aa3fb1daca64c1127cf662cf97f254ae16c18c05b8ab635fc118"
 dependencies = [
  "atomic-waker",
  "bytes",
@@ -967,6 +1468,18 @@ name = "hashbrown"
 version = "0.17.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
+dependencies = [
+ "foldhash",
+]
+
+[[package]]
+name = "hashlink"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a596f1b20ed2cc5ecac41a164aaebc7258057060f06c0cf7a2ba3991ee7990fb"
+dependencies = [
+ "hashbrown",
+]
 
 [[package]]
 name = "heapless"
@@ -978,13 +1491,37 @@ dependencies = [
  "stable_deref_trait",
 ]
 
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
+name = "hkdf"
+version = "0.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7"
+dependencies = [
+ "hmac 0.12.1",
+]
+
 [[package]]
 name = "hkdf"
 version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4aaa26c720c68b866f2c96ef5c1264b3e6f473fe5d4ce61cd44bbe913e553018"
 dependencies = [
- "hmac",
+ "hmac 0.13.0",
+]
+
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest 0.10.7",
 ]
 
 [[package]]
@@ -993,27 +1530,62 @@ version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6303bc9732ae41b04cb554b844a762b4115a61bfaa81e3e83050991eeb56863f"
 dependencies = [
- "digest",
+ "digest 0.11.3",
+]
+
+[[package]]
+name = "hostname"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "617aaa3557aef3810a6369d0a99fac8a080891b68bd9f9812a1eeda0c0730cbd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "windows-link 0.2.1",
 ]
 
 [[package]]
 name = "hpke"
-version = "0.14.1"
+version = "0.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5324110b02044183df000f0bd7d2d7e61f1000631508627e77f63983b6fdffb"
+checksum = "8f512e325a1a71bf3273fb9b7fc9e5d96dac136fb4a95d0e6637001b12ea3e09"
 dependencies = [
- "aead",
+ "aead 0.6.1",
  "aes-gcm",
- "chacha20poly1305",
- "hkdf",
+ "chacha20poly1305 0.11.0",
+ "curve25519-dalek 5.0.0",
+ "hkdf 0.13.0",
  "hybrid-array",
- "rand_core",
- "sha2",
+ "ml-kem",
+ "p256",
+ "p384",
+ "p521",
+ "rand_core 0.10.1",
+ "sha2 0.11.1",
+ "sha3",
+ "shake",
  "subtle",
- "x25519-dalek",
+ "turboshake",
+ "x-wing",
+ "x25519-dalek 3.0.0",
  "zeroize",
 ]
 
+[[package]]
+name = "httlib-hpack"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40cf60e5e8567c6ff914a590f1452821de9377a560338a562e570a6ff052aae3"
+dependencies = [
+ "httlib-huffman",
+]
+
+[[package]]
+name = "httlib-huffman"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a9fcbcc408c5526c3ab80d534e5c86e7967c1fb7aa0a8c76abd1edc27deb877"
+
 [[package]]
 name = "http"
 version = "1.5.0"
@@ -1046,18 +1618,20 @@ version = "0.4.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "27f864f10dfb56725ce5ce5472bc52252c8f93a4ab86327122cebf62c5f59a17"
 dependencies = [
+ "ctutils",
+ "subtle",
  "typenum",
+ "zeroize",
 ]
 
 [[package]]
 name = "hyper"
-version = "1.11.1"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "27b501faa50e7a26c3d3560ca625132f4078a17771f4810baf70475ae48cbe43"
+checksum = "2c3e324da4c95177d6291d4c8730197c0d1822f8a9766814a4a44fa5ab797c9c"
 dependencies = [
  "atomic-waker",
  "bytes",
- "futures-channel",
  "futures-core",
  "http",
  "http-body",
@@ -1071,9 +1645,9 @@ dependencies = [
 
 [[package]]
 name = "hyper-util"
-version = "0.1.20"
+version = "0.1.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0"
+checksum = "ddc03d96684f9226b8a787cdb71488417b53ab5ea8fdb1dac946cb9431cc8bff"
 dependencies = [
  "bytes",
  "http",
@@ -1083,11 +1657,77 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "i18n-config"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e06b90c8a0d252e203c94344b21e35a30f3a3a85dc7db5af8f8df9f3e0c63ef"
+dependencies = [
+ "basic-toml",
+ "log",
+ "serde",
+ "serde_derive",
+ "thiserror 1.0.69",
+ "unic-langid",
+]
+
+[[package]]
+name = "i18n-embed"
+version = "0.15.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "669ffc2c93f97e6ddf06ddbe999fcd6782e3342978bb85f7d3c087c7978404c4"
+dependencies = [
+ "arc-swap",
+ "fluent",
+ "fluent-langneg",
+ "fluent-syntax",
+ "i18n-embed-impl",
+ "intl-memoizer",
+ "log",
+ "parking_lot",
+ "rust-embed",
+ "thiserror 1.0.69",
+ "unic-langid",
+ "walkdir",
+]
+
+[[package]]
+name = "i18n-embed-fl"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04b2969d0b3fc6143776c535184c19722032b43e6a642d710fa3f88faec53c2d"
+dependencies = [
+ "find-crate",
+ "fluent",
+ "fluent-syntax",
+ "i18n-config",
+ "i18n-embed",
+ "proc-macro-error2",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn 2.0.119",
+ "unic-langid",
+]
+
+[[package]]
+name = "i18n-embed-impl"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f2cc0e0523d1fe6fc2c6f66e5038624ea8091b3e7748b5e8e0c84b1698db6c2"
+dependencies = [
+ "find-crate",
+ "i18n-config",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
 [[package]]
 name = "icu_collections"
-version = "2.3.0"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa68d21081c4a05d5a901a1c62add574c77048b6a1c67be3b50ce0b60d4ca513"
+checksum = "fe090a42a0d3140fed8c63263ed1fecc02422cb2f4bfe55cd8de2de1b8e105dd"
 dependencies = [
  "displaydoc",
  "potential_utf",
@@ -1099,9 +1739,9 @@ dependencies = [
 
 [[package]]
 name = "icu_locale_core"
-version = "2.3.0"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d56e28588da92eee5c3201a6eff33fabdd49b62269c8938d4ff050ce4d900deb"
+checksum = "25d29b57c17c6528d0dc4c2141cfa2d08200465acb537a3909c8b9b8a4a984c0"
 dependencies = [
  "displaydoc",
  "litemap",
@@ -1112,9 +1752,9 @@ dependencies = [
 
 [[package]]
 name = "icu_normalizer"
-version = "2.3.0"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12f9cf5f235641ed274641dd81c3f28d870e276763d0797aeeab72317b1c646f"
+checksum = "404a3b8c486f205c87fe7f23ab6894d84a4ad76d6e4671ae1981ba7def87c599"
 dependencies = [
  "icu_collections",
  "icu_normalizer_data",
@@ -1126,15 +1766,15 @@ dependencies = [
 
 [[package]]
 name = "icu_normalizer_data"
-version = "2.3.0"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1563da1ed3e0b3bf3d74c9b85917ac9c56464d2f57242270c09c9e752f8021a0"
+checksum = "20f0088bfb7441f7a37fa0c9e20cb1e9cba1cac6b9ce8cd2a6dc44294f8e8cbc"
 
 [[package]]
 name = "icu_properties"
-version = "2.3.0"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e7ca276ad3145661a65914e6daf131ca5120cd3dcee8f8f3214b8875184a148"
+checksum = "2ea83d991c56158f7cf898bf86436c1dfe7c07ee82fe88951f2695c9f37a379f"
 dependencies = [
  "displaydoc",
  "icu_collections",
@@ -1147,15 +1787,15 @@ dependencies = [
 
 [[package]]
 name = "icu_properties_data"
-version = "2.3.0"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e590f038c1464a96894fd6d10127e90a8be4509f56ff7ecef851b15cee0b7caa"
+checksum = "b98f29af82d02b163fe50161388350e743bb3107cc8e8c2f7314cb505faddfcf"
 
 [[package]]
 name = "icu_provider"
-version = "2.3.1"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d27bbb9d3abbefac45d55f647c9de1d44aafcd1186eb91879afef17c396c3e73"
+checksum = "413099315636c588ee8f011190b329b971a09a8fae9d157e01dcae8379468514"
 dependencies = [
  "displaydoc",
  "icu_locale_core",
@@ -1199,19 +1839,87 @@ dependencies = [
 
 [[package]]
 name = "inout"
-version = "0.2.2"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "inout"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4250ce6452e92010fdf7268ccc5d14faa80bb12fc741938534c58f16804e03c7"
+checksum = "3b5cf4372d022092674a83b8febf5865f7a573cc0c5baec5e49c879b6a20978f"
 dependencies = [
  "hybrid-array",
 ]
 
+[[package]]
+name = "intl-memoizer"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "310da2e345f5eb861e7a07ee182262e94975051db9e4223e909ba90f392f163f"
+dependencies = [
+ "type-map",
+ "unic-langid",
+]
+
+[[package]]
+name = "intl_pluralrules"
+version = "7.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "078ea7b7c29a2b4df841a7f6ac8775ff6074020c6776d48491ce2268e068f972"
+dependencies = [
+ "unic-langid",
+]
+
+[[package]]
+name = "intrusive-collections"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4275b20e6057cd7733fd8df8a5a31701e4fe44497dad0f3fa0e1c4fb971506be"
+
+[[package]]
+name = "io_tee"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b3f7cef34251886990511df1c61443aa928499d598a9473929ab5a90a527304"
+
+[[package]]
+name = "ip_network"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa2f047c0a98b2f299aa5d6d7088443570faae494e9ae1305e48be000c9e0eb1"
+
+[[package]]
+name = "ip_network_table"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4099b7cfc5c5e2fe8c5edf3f6f7adf7a714c9cc697534f63a5a5da30397cb2c0"
+dependencies = [
+ "ip_network",
+ "ip_network_table-deps-treebitmap",
+]
+
+[[package]]
+name = "ip_network_table-deps-treebitmap"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e537132deb99c0eb4b752f0346b6a836200eaaa3516dd7e5514b63930a09e5d"
+
 [[package]]
 name = "ipnet"
 version = "2.12.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "791930b43c0d5973160d90a8f3894509f2b273430f5c5c73b668636d0287c5c0"
 
+[[package]]
+name = "ipnetwork"
+version = "0.21.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf370abdafd54d13e54a620e8c3e1145f28e46cc9d704bc6d94414559df41763"
+
 [[package]]
 name = "itertools"
 version = "0.13.0"
@@ -1221,12 +1929,58 @@ dependencies = [
  "either",
 ]
 
+[[package]]
+name = "itertools"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
 
+[[package]]
+name = "jiff"
+version = "0.2.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2b005715dcbeb0089a3c0dab99f2ff1cc3b2525323552703d648585d342a383"
+dependencies = [
+ "defmt",
+ "jiff-core",
+ "jiff-static",
+ "log",
+ "portable-atomic",
+ "portable-atomic-util",
+ "serde_core",
+]
+
+[[package]]
+name = "jiff-core"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e52fe76043ccecc9005d2305ebaadf7d7fc0cc89ca6baa10a94d6bc68c7128c"
+dependencies = [
+ "defmt",
+ "log",
+]
+
+[[package]]
+name = "jiff-static"
+version = "0.2.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2cc9817253cf7c7ee4684451bd327e88d6f3658014e54a29198625590650695c"
+dependencies = [
+ "jiff-core",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
 [[package]]
 name = "jobserver"
 version = "0.1.35"
@@ -1239,9 +1993,9 @@ dependencies = [
 
 [[package]]
 name = "js-sys"
-version = "0.3.105"
+version = "0.3.107"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce57d20d1ea864ce2ac172ab472d409214f4fd359f0b2a2775abdf522e2af99e"
+checksum = "8dc09d2154098bbf4ef54eab6b117a3c24cbbffe94046b16ee6d6d4510584d3a"
 dependencies = [
  "cfg-if",
  "futures-util",
@@ -1255,20 +2009,33 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d8f198d1db720e4940b5a493201d199d9f24f568f8f746bd13706243a2f71598"
 dependencies = [
  "cfg-if",
- "cpufeatures",
+ "cpufeatures 0.3.1",
+]
+
+[[package]]
+name = "kem"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01737161ba802849cfd486b5bd209d38ba4943494c249a8126005170c7621edd"
+dependencies = [
+ "crypto-common 0.2.2",
+ "rand_core 0.10.1",
 ]
 
 [[package]]
 name = "lazy_static"
-version = "1.5.0"
+version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+checksum = "20870f649af7073d53e38067b2a84312175d56ea15217e1b15bc83506ec50afb"
+dependencies = [
+ "spin 0.9.9",
+]
 
 [[package]]
 name = "libc"
-version = "0.2.189"
+version = "0.2.191"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
+checksum = "65cd87c9a6d60536580b316ad985726104730a5151c99845f2490428ef91240a"
 
 [[package]]
 name = "libloading"
@@ -1290,6 +2057,12 @@ dependencies = [
  "windows-link 0.2.1",
 ]
 
+[[package]]
+name = "libm"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
+
 [[package]]
 name = "linux-raw-sys"
 version = "0.12.1"
@@ -1313,9 +2086,9 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.34"
+version = "0.4.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6"
+checksum = "5d15f86d12da44cd8d4ec3c73984537eb7f4cadcb9776a575a0a8a05ca11005c"
 
 [[package]]
 name = "lru-slab"
@@ -1329,12 +2102,30 @@ version = "0.11.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9106e1d747ffd48e6be5bb2d97fa706ed25b144fbee4d5c02eae110cd8d6badd"
 
+[[package]]
+name = "lzma-rust2"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1c46f3fcd2e888afdb01a07efc071cb21300e07c68d32c3e8b01b5c8cb1fcaa"
+
 [[package]]
 name = "managed"
 version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ca88d725a0a943b096803bd34e73a4437208b6077654cc4ecb2947a5f91618d"
 
+[[package]]
+name = "maxminddb"
+version = "0.32.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b43d2458d977b610b04a3858e6504f06133663d303a1a0606601b530bfc9bc6"
+dependencies = [
+ "ipnetwork",
+ "memchr",
+ "serde",
+ "thiserror 2.0.21",
+]
+
 [[package]]
 name = "md-5"
 version = "0.11.0"
@@ -1342,7 +2133,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "69b6441f590336821bb897fb28fc622898ccceb1d6cea3fde5ea86b090c4de98"
 dependencies = [
  "cfg-if",
- "digest",
+ "digest 0.11.3",
 ]
 
 [[package]]
@@ -1360,6 +2151,22 @@ dependencies = [
  "autocfg",
 ]
 
+[[package]]
+name = "mime"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
+
+[[package]]
+name = "mime_guess"
+version = "2.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7c44f8e672c00fe5308fa235f821cb4198414e1c77935c1ab6948d3fd78550e"
+dependencies = [
+ "mime",
+ "unicase",
+]
+
 [[package]]
 name = "minimal-lexical"
 version = "0.2.1"
@@ -1378,15 +2185,42 @@ dependencies = [
 
 [[package]]
 name = "mio"
-version = "1.2.3"
+version = "1.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b18443e9c262bfe8fa82f51666e2642c53393f7e5c27b3e1aeab922cff5b9d8"
+checksum = "1788edb87fdc09c7e26304471e2f5be8cdefb1b6930d6e3985fc02ff53bf86ee"
 dependencies = [
  "libc",
  "wasi",
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "ml-kem"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84ca78b66f46050d49fa21693ae8adab2081d8101b65d8067316b6b70b64a0d1"
+dependencies = [
+ "hybrid-array",
+ "kem",
+ "module-lattice",
+ "rand_core 0.10.1",
+ "sha3",
+ "shake",
+ "zeroize",
+]
+
+[[package]]
+name = "module-lattice"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4a1e412c8ee83a1c678f427806219c49c96b2511b9f07497514f0e43fb26155"
+dependencies = [
+ "ctutils",
+ "hybrid-array",
+ "num-traits",
+ "zeroize",
+]
+
 [[package]]
 name = "multiversion_no_op"
 version = "1.0.0"
@@ -1403,13 +2237,13 @@ dependencies = [
  "core-foundation",
  "ipnet",
  "libc",
- "netlink-packet-core",
+ "netlink-packet-core 0.8.2",
  "netlink-packet-route 0.25.1",
- "netlink-sys",
+ "netlink-sys 0.8.8",
  "nix 0.30.1",
  "scopeguard",
  "system-configuration-sys",
- "thiserror",
+ "thiserror 2.0.21",
  "widestring",
  "windows 0.61.3",
 ]
@@ -1423,6 +2257,12 @@ dependencies = [
  "paste",
 ]
 
+[[package]]
+name = "netlink-packet-core"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d6e2daf9a8c2e21302714706860a0e6be02e03d17294ecc66b354ea7d4059dd"
+
 [[package]]
 name = "netlink-packet-route"
 version = "0.25.1"
@@ -1432,19 +2272,20 @@ dependencies = [
  "bitflags 2.13.2",
  "libc",
  "log",
- "netlink-packet-core",
+ "netlink-packet-core 0.8.2",
 ]
 
 [[package]]
 name = "netlink-packet-route"
-version = "0.31.0"
+version = "0.33.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2288fcb784eb3defd5fb16f4c4160d5f477de192eac730f43e1d11c24d9a007"
+checksum = "59d48ffc8b73a506e1ff0878528c72668f2bfbc3d875b6be890a96be5d0d5576"
 dependencies = [
  "bitflags 2.13.2",
  "libc",
  "log",
- "netlink-packet-core",
+ "netlink-packet-core 0.9.0",
+ "zerocopy",
 ]
 
 [[package]]
@@ -1458,6 +2299,17 @@ dependencies = [
  "log",
 ]
 
+[[package]]
+name = "netlink-sys"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c99d38e00b420df49e940fe0826e667c3dad82ac68eb4c2bbf754c1c14a83a10"
+dependencies = [
+ "bytes",
+ "libc",
+ "log",
+]
+
 [[package]]
 name = "nix"
 version = "0.30.1"
@@ -1510,6 +2362,22 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "num-bigint-dig"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e661dda6640fad38e827a6d4a310ff4763082116fe217f279885c97f511bb0b7"
+dependencies = [
+ "lazy_static",
+ "libm",
+ "num-integer",
+ "num-iter",
+ "num-traits",
+ "rand 0.8.8",
+ "smallvec",
+ "zeroize",
+]
+
 [[package]]
 name = "num-conv"
 version = "0.2.2"
@@ -1525,6 +2393,16 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "num-iter"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c92800bd69a1eac91786bcfe9da64a897eb72911b8dc3095decbd07429e8048b"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
 [[package]]
 name = "num-traits"
 version = "0.2.19"
@@ -1532,6 +2410,23 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
 dependencies = [
  "autocfg",
+ "libm",
+]
+
+[[package]]
+name = "octets"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d59d30d3ad7f7e1c9a66e51c9cb71ae1c794b28ffe7053fd785defb0d180069"
+
+[[package]]
+name = "octseq"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "182eab3e1cd9cdc0ecf1ce3342d9844f3dc7d098f0694569bfdf327b612d69fd"
+dependencies = [
+ "bytes",
+ "serde",
 ]
 
 [[package]]
@@ -1549,6 +2444,12 @@ version = "1.21.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
+[[package]]
+name = "opaque-debug"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
+
 [[package]]
 name = "openssl-macros"
 version = "0.1.1"
@@ -1560,6 +2461,12 @@ dependencies = [
  "syn 2.0.119",
 ]
 
+[[package]]
+name = "openssl-probe"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e036b411754132fd6b74e94b74e9a13c5cf606fa93d1885c35860d3060820b1"
+
 [[package]]
 name = "oslog"
 version = "0.2.0"
@@ -1569,6 +2476,41 @@ dependencies = [
  "cc",
 ]
 
+[[package]]
+name = "p256"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2c9239b2dbc807adbbe147e8cf72ea7450c3a0aabe62cb8e75ff4ec22e1f72a"
+dependencies = [
+ "elliptic-curve",
+ "primefield",
+ "primeorder",
+]
+
+[[package]]
+name = "p384"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d17b851e6b3e378ab4ecb07fa2ed23f4d15f075735f8fec9fa1e7bdce5f8301f"
+dependencies = [
+ "elliptic-curve",
+ "fiat-crypto 0.3.0",
+ "primefield",
+ "primeorder",
+]
+
+[[package]]
+name = "p521"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ad64cc32c2dc466317c12ee5853e61f159f9eab1fe7efade0395dc2e7b43449"
+dependencies = [
+ "base16ct",
+ "elliptic-curve",
+ "primefield",
+ "primeorder",
+]
+
 [[package]]
 name = "parking_lot"
 version = "0.12.5"
@@ -1598,6 +2540,16 @@ version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 
+[[package]]
+name = "pbkdf2"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2"
+dependencies = [
+ "digest 0.10.7",
+ "hmac 0.12.1",
+]
+
 [[package]]
 name = "percent-encoding"
 version = "2.3.2"
@@ -1630,20 +2582,52 @@ version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
 
+[[package]]
+name = "pkcs1"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8ffb9f10fa047879315e6625af03c164b16962a5368d724ed16323b68ace47f"
+dependencies = [
+ "der 0.7.10",
+ "pkcs8",
+ "spki",
+]
+
+[[package]]
+name = "pkcs8"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
+dependencies = [
+ "der 0.7.10",
+ "spki",
+]
+
 [[package]]
 name = "pkg-config"
 version = "0.3.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548"
 
+[[package]]
+name = "poly1305"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8159bd90725d2df49889a078b54f4f79e87f1f8a8444194cdca81d38f5393abf"
+dependencies = [
+ "cpufeatures 0.2.17",
+ "opaque-debug",
+ "universal-hash 0.5.1",
+]
+
 [[package]]
 name = "poly1305"
 version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6e2d0073b297041425c7c3df6eb4792d598a15323fe63346852b092eca02904c"
 dependencies = [
- "cpufeatures",
- "universal-hash",
+ "cpufeatures 0.3.1",
+ "universal-hash 0.6.1",
 ]
 
 [[package]]
@@ -1653,8 +2637,23 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f0fa31d631f2b2cb2a544d0aa321ce847a94764d701ca2becc411138b93d49cd"
 dependencies = [
  "cpubits",
- "cpufeatures",
- "universal-hash",
+ "cpufeatures 0.3.1",
+ "universal-hash 0.6.1",
+]
+
+[[package]]
+name = "portable-atomic"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85"
+
+[[package]]
+name = "portable-atomic-util"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10ab3eb7f3becc3a1cbc4f2c6f20267996cfc1a6467a873763411b136a122715"
+dependencies = [
+ "portable-atomic",
 ]
 
 [[package]]
@@ -1668,9 +2667,65 @@ dependencies = [
 
 [[package]]
 name = "powerfmt"
-version = "0.2.0"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+checksum = "4a6394b9e965e73d0a289ee54f589087e2c676aedf60885baf52c76b771e4958"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "primefield"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c555a6e4eb7d4e158fcb028c835c3b8642206ddc279b5c6b202ef9a8bdb592f4"
+dependencies = [
+ "crypto-bigint",
+ "crypto-common 0.2.2",
+ "ff",
+ "rand_core 0.10.1",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "primeorder"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c9f42978c78a00e3d68f69fc03e57a234debae69da4020a4fb588fcdcd07b06"
+dependencies = [
+ "elliptic-curve",
+ "primefield",
+ "wnaf",
+]
+
+[[package]]
+name = "proc-macro-error-attr2"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96de42df36bb9bba5542fe9f1a054b8cc87e172759a1868aa05c1f3acc89dfc5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+]
+
+[[package]]
+name = "proc-macro-error2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11ec05c52be0a07b08061f7dd003e7d7092e0472bc731b4af7bb1ef876109802"
+dependencies = [
+ "proc-macro-error-attr2",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
 
 [[package]]
 name = "proc-macro2"
@@ -1681,6 +2736,67 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "prost"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "528ac67416ff8646872a3c02cad9cc4ee5dc9f9540c9b10771855c95cb2e5ae1"
+dependencies = [
+ "bytes",
+ "prost-derive",
+]
+
+[[package]]
+name = "prost-derive"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b570b25f7617e43d59005d0990ccb79e950a423952cea19671b7a876da390adf"
+dependencies = [
+ "anyhow",
+ "itertools 0.14.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "psl"
+version = "2.1.246"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27d58bd13c235442118460335daf360f0fefaa9035ec4ad957f851d738e7b7d6"
+dependencies = [
+ "psl-types",
+]
+
+[[package]]
+name = "psl-types"
+version = "2.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33cb294fe86a74cbcf50d4445b37da762029549ebeea341421c7c70370f86cac"
+
+[[package]]
+name = "quiche"
+version = "0.30.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52b35a721a2a56797347929745fa783fc99e680d9484b80324ce40106b75493a"
+dependencies = [
+ "boring",
+ "boring-sys",
+ "bytes",
+ "debug_panic",
+ "either",
+ "enum_dispatch",
+ "foreign-types-shared",
+ "intrusive-collections",
+ "libc",
+ "libm",
+ "log",
+ "octets",
+ "slab",
+ "smallvec",
+ "windows-sys 0.59.0",
+]
+
 [[package]]
 name = "quinn"
 version = "0.11.12"
@@ -1693,10 +2809,10 @@ dependencies = [
  "pin-project-lite",
  "quinn-proto",
  "quinn-udp",
- "rustc-hash",
+ "rustc-hash 2.1.3",
  "rustls",
  "socket2",
- "thiserror",
+ "thiserror 2.0.21",
  "tokio",
  "tracing",
  "web-time",
@@ -1704,21 +2820,21 @@ dependencies = [
 
 [[package]]
 name = "quinn-proto"
-version = "0.11.18"
+version = "0.11.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9746dbde176634f4f2f1faf2404e30a31b2bc1e9cafb5329c95d8177a18c9fc"
+checksum = "0e750cca55fe4f0439a15d0bb529da9651e79993e8e72c61a899a36d462befbe"
 dependencies = [
  "bytes",
  "getrandom 0.4.3",
  "lru-slab",
- "rand",
+ "rand 0.10.3",
  "rand_pcg",
  "ring",
- "rustc-hash",
+ "rustc-hash 2.1.3",
  "rustls",
  "rustls-pki-types",
  "slab",
- "thiserror",
+ "thiserror 2.0.21",
  "tinyvec",
  "tracing",
  "web-time",
@@ -1726,9 +2842,9 @@ dependencies = [
 
 [[package]]
 name = "quinn-udp"
-version = "0.5.15"
+version = "0.5.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "35a133f956daabe89a61a685c2649f13d82d5aa4bd5d12d1277e1072a21c0694"
+checksum = "af66907df18639dcf4db56ca65490cabc4b27a97dbadd96f2926cca73298f016"
 dependencies = [
  "cfg_aliases",
  "libc",
@@ -1747,21 +2863,57 @@ dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
 [[package]]
 name = "r-efi"
 version = "6.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
 
+[[package]]
+name = "rand"
+version = "0.8.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e058c7de0b26af77780c769414d6257830bb240f3c38477dbc2c16e5f54d6d4c"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core 0.6.4",
+]
+
 [[package]]
 name = "rand"
 version = "0.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "65c9fb96cbc91e3478eaae79a69fcd3f1ae4ad052e471fe6732fff548984b4af"
 dependencies = [
- "chacha20",
+ "chacha20 0.10.2",
  "getrandom 0.4.3",
- "rand_core",
+ "rand_core 0.10.1",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom 0.2.17",
 ]
 
 [[package]]
@@ -1776,7 +2928,7 @@ version = "0.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "caa0f4137e1c0a72f4c651489402276c8e8e1cf081f3b0ba156d2cbeef09e86a"
 dependencies = [
- "rand_core",
+ "rand_core 0.10.1",
 ]
 
 [[package]]
@@ -1792,6 +2944,15 @@ dependencies = [
  "yasna",
 ]
 
+[[package]]
+name = "redb"
+version = "4.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39178e0a867f9e3eaa6292a4ab1dd3613f2519c5b564341e1e7b29b270736cc4"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "redox_syscall"
 version = "0.5.18"
@@ -1846,18 +3007,79 @@ dependencies = [
 
 [[package]]
 name = "route_manager"
-version = "0.2.13"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e06d678f16f191d7232488ef782418aafb953bccfc6c38d28255ed6610c18dce"
+checksum = "694798681cd69a10928204225a680ad9416b081d9e9f8718d7a61e2d134da323"
 dependencies = [
  "flume",
  "libc",
- "netlink-packet-core",
- "netlink-packet-route 0.31.0",
- "netlink-sys",
+ "netlink-packet-core 0.9.0",
+ "netlink-packet-route 0.33.0",
+ "netlink-sys 0.9.0",
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "rsa"
+version = "0.9.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8573f03f5883dcaebdfcf4725caa1ecb9c15b2ef50c43a07b816e06799bb12d"
+dependencies = [
+ "const-oid 0.9.6",
+ "digest 0.10.7",
+ "num-bigint-dig",
+ "num-integer",
+ "num-traits",
+ "pkcs1",
+ "pkcs8",
+ "rand_core 0.6.4",
+ "signature",
+ "spki",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "rust-embed"
+version = "8.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19afa5b4b6a611de00bd1bdae6ae6f39084c9399f0679c3f52d8469cf335cc23"
+dependencies = [
+ "rust-embed-impl",
+ "rust-embed-utils",
+ "walkdir",
+]
+
+[[package]]
+name = "rust-embed-impl"
+version = "8.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e0d8afda6374eac59e066abee06d265247ebbaf3006cf878e2879e8356e34053"
+dependencies = [
+ "mime_guess",
+ "proc-macro2",
+ "quote",
+ "rust-embed-utils",
+ "syn 2.0.119",
+ "walkdir",
+]
+
+[[package]]
+name = "rust-embed-utils"
+version = "8.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d84e8ba78bd384263e5922f084cbe1b081c3b7e69add59c8fb097b879ba968a"
+dependencies = [
+ "sha2 0.11.1",
+ "walkdir",
+]
+
+[[package]]
+name = "rustc-hash"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+
 [[package]]
 name = "rustc-hash"
 version = "2.1.3"
@@ -1884,9 +3106,9 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "1.1.5"
+version = "1.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "891efababe418670775f199f0d233d84843c227a0949a883ce15b37c78d6629d"
+checksum = "e5e76742e5294153d4dde1207dbec5bdd81eef6fabdc0d2118babadabfd858aa"
 dependencies = [
  "bitflags 2.13.2",
  "errno",
@@ -1897,9 +3119,9 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.23.45"
+version = "0.23.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d41d731c7d2f962d1ccc364cec258de3c0e93b38c2fb3ba97ac74513048d634"
+checksum = "48e13bd8c0e9365c43cfa5c9e8f9ad49d3c8444926c9aac819e0e4dc503c8fdf"
 dependencies = [
  "once_cell",
  "ring",
@@ -1909,6 +3131,18 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "rustls-native-certs"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a073f5dc7469f984c52ad2752b63b0807745133b6de880b7b64c1ac4c48aec4"
+dependencies = [
+ "openssl-probe",
+ "rustls-pki-types",
+ "schannel",
+ "security-framework",
+]
+
 [[package]]
 name = "rustls-pki-types"
 version = "1.15.1"
@@ -1921,9 +3155,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-webpki"
-version = "0.103.15"
+version = "0.103.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2"
+checksum = "4443b1b6d39d7c663139942cc4558262562d2c84123bb6282ef177009ca8b281"
 dependencies = [
  "ring",
  "rustls-pki-types",
@@ -1937,28 +3171,127 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
 
 [[package]]
-name = "ryu"
-version = "1.0.23"
+name = "ryu"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
+
+[[package]]
+name = "salsa20"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97a22f5af31f73a954c10289c93e8a50cc23d971e80ee446f1f6f7137a088213"
+dependencies = [
+ "cipher 0.4.4",
+]
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "schannel"
+version = "0.1.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9cb23c424d8ee841bb4d813677ca237e2a610067d594fec130f87d6093495ab5"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "scrypt"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0516a385866c09368f0b5bcd1caff3366aace790fcd46e2bb032697bb172fd1f"
+dependencies = [
+ "pbkdf2",
+ "salsa20",
+ "sha2 0.10.9",
+]
+
+[[package]]
+name = "sealed"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b68e2ea526d9fb32f23ca8894fb5da9e743f34c2f41701f0501dc8a25c4b343"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.9",
+]
+
+[[package]]
+name = "sec1"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d56d437c2f19203ce5f7122e507831de96f3d2d4d3be5af44a0b0a09d8a80e4d"
+dependencies = [
+ "base16ct",
+ "ctutils",
+ "der 0.8.3",
+ "hybrid-array",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "secrecy"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e891af845473308773346dc847b2c23ee78fe442e0472ac50e22a18a93d3ae5a"
+dependencies = [
+ "zeroize",
+]
+
+[[package]]
+name = "security-framework"
+version = "3.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
+checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"
+dependencies = [
+ "bitflags 2.13.2",
+ "core-foundation",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
 
 [[package]]
-name = "scopeguard"
-version = "1.2.0"
+name = "security-framework-sys"
+version = "2.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
 
 [[package]]
-name = "sealed"
-version = "0.7.0"
+name = "self_cell"
+version = "0.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b68e2ea526d9fb32f23ca8894fb5da9e743f34c2f41701f0501dc8a25c4b343"
+checksum = "e14e4d63b804dc0c7ec4a1e52bcb63f02c7ac94476755aa579edac21e01f915d"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 3.0.6",
+ "self_cell 1.3.0",
 ]
 
+[[package]]
+name = "self_cell"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ab42ca02749e120097e328d91d415325bdf43b1c72c4c8badf37375fe40a813"
+
 [[package]]
 name = "semver"
 version = "1.0.28"
@@ -1967,9 +3300,9 @@ checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
 
 [[package]]
 name = "sendfd"
-version = "0.4.4"
+version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b183bfd5b1bc64ab0c1ef3ee06b008a9ef1b68a7d3a99ba566fbfe7a7c6d745b"
+checksum = "c8fa82bbd0ce6c16273ec6c310d3973f8b8f8665ecfe0ca02a49b3ea61b2418c"
 dependencies = [
  "libc",
  "tokio",
@@ -2002,14 +3335,14 @@ checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.151"
+version = "1.0.154"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14"
+checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6"
 dependencies = [
  "itoa",
  "memchr",
@@ -2043,6 +3376,18 @@ dependencies = [
  "unsafe-libyaml",
 ]
 
+[[package]]
+name = "sevenz-rust2"
+version = "0.24.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30146010a60b5773ef63f7b0033576c7a0487ecc87a30d97b787ca8e27c85140"
+dependencies = [
+ "crc32fast",
+ "js-sys",
+ "lzma-rust2",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "sha1"
 version = "0.11.0"
@@ -2050,19 +3395,47 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aacc4cc499359472b4abe1bf11d0b12e688af9a805fa5e3016f9a386dc2d0214"
 dependencies = [
  "cfg-if",
- "cpufeatures",
- "digest",
+ "cpufeatures 0.3.1",
+ "digest 0.11.3",
 ]
 
+[[package]]
+name = "sha1_smol"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbfa15b3dddfee50a0fff136974b3e1bde555604ba463834a7eb7deb6417705d"
+
 [[package]]
 name = "sha2"
-version = "0.11.0"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.2.17",
+ "digest 0.10.7",
+]
+
+[[package]]
+name = "sha2"
+version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4"
+checksum = "47d7069beb7d6ac7b9acd1039986e73443f24234f41074da099d6f994ac9ad19"
 dependencies = [
  "cfg-if",
- "cpufeatures",
- "digest",
+ "cpufeatures 0.3.1",
+ "digest 0.11.3",
+]
+
+[[package]]
+name = "sha3"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc9bad02c26382724b2d2692c6f179285e4b54eeecd7968f52a50059c3c11759"
+dependencies = [
+ "digest 0.11.3",
+ "keccak",
+ "sponge-cursor",
 ]
 
 [[package]]
@@ -2072,7 +3445,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e2065b026dbe4f47048eca384adf07f693bf901050d80abd3adb7b2422709b2d"
 dependencies = [
  "aes",
- "base64",
+ "base64 0.23.1",
  "blake3",
  "byte_string",
  "bytes",
@@ -2084,7 +3457,7 @@ dependencies = [
  "lru_time_cache",
  "percent-encoding",
  "pin-project",
- "rand",
+ "rand 0.10.3",
  "sealed",
  "sendfd",
  "serde",
@@ -2093,7 +3466,7 @@ dependencies = [
  "shadowsocks-crypto",
  "socket2",
  "spin 0.12.3",
- "thiserror",
+ "thiserror 2.0.21",
  "tokio",
  "tokio-tfo",
  "trait-variant",
@@ -2113,8 +3486,8 @@ dependencies = [
  "blake3",
  "bytes",
  "cfg-if",
- "chacha20poly1305",
- "rand",
+ "chacha20poly1305 0.11.0",
+ "rand 0.10.3",
 ]
 
 [[package]]
@@ -2123,7 +3496,7 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09057cb2149ad4cbd2da1e26b351f9a4c354219421229c69c3063e6f61947c4a"
 dependencies = [
- "digest",
+ "digest 0.11.3",
  "keccak",
  "sponge-cursor",
 ]
@@ -2150,6 +3523,16 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "signature"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
+dependencies = [
+ "digest 0.10.7",
+ "rand_core 0.6.4",
+]
+
 [[package]]
 name = "simd-adler32"
 version = "0.3.10"
@@ -2170,15 +3553,14 @@ checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
 
 [[package]]
 name = "smallvec"
-version = "1.16.1"
+version = "1.16.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba467056f1b547ed52077911161fc86985becbc60e8e1857c8a144dab0def891"
+checksum = "d0d5d4b1981b8bbbb7aed204cae5726d683d5d6ac7e74ec54122ea28f315e7c8"
 
 [[package]]
 name = "smoltcp"
 version = "0.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6f8b28ad56c6e35524a37dd492af5d1a47e31e1a4d175cd12f89c075f01980f"
+source = "git+https://github.com/smoltcp-rs/smoltcp?rev=24bda3b4f982625d8453d4360172557d24921c76#24bda3b4f982625d8453d4360172557d24921c76"
 dependencies = [
  "bitflags 1.3.2",
  "byteorder",
@@ -2216,11 +3598,24 @@ dependencies = [
  "lock_api",
 ]
 
+[[package]]
+name = "spki"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
+dependencies = [
+ "base64ct",
+ "der 0.7.10",
+]
+
 [[package]]
 name = "sponge-cursor"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3a0219bd7d979d58245a4f41f695e1ac9f8befdffadd7f61f1bae9e39abc6620"
+dependencies = [
+ "zeroize",
+]
 
 [[package]]
 name = "stable_deref_trait"
@@ -2234,6 +3629,12 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
 [[package]]
 name = "subtle"
 version = "2.6.1"
@@ -2253,9 +3654,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "3.0.6"
+version = "3.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee"
+checksum = "d78c8dee4c7bf0e14673097256fed6142ce9d3b85a408189d07482442145823b"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2281,7 +3682,7 @@ checksum = "901704edd0dfe137f1987838ee4f259e4e063c31371bdb423f7ae38ec6f77f02"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
 ]
 
 [[package]]
@@ -2309,22 +3710,42 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "2.0.20"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e"
+dependencies = [
+ "thiserror-impl 2.0.21",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec86235f5fcc2a73650310756d2ac5b138a5780bbbdfae3eeccec992c435ba4f"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
 dependencies = [
- "thiserror-impl",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "2.0.20"
+version = "2.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc04cd3e1236dd4a98afca4569f2deb3f120e5422a4023be2cb683f8486292af"
+checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
 ]
 
 [[package]]
@@ -2359,11 +3780,12 @@ dependencies = [
 
 [[package]]
 name = "tinystr"
-version = "0.8.4"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1e27c91459209c2986af3dcf603a5a74a4368754ce37414f59acc971167f643"
+checksum = "abc840c238154d58f9e86b2792261edfde565a17696e1cda1a449de27979801a"
 dependencies = [
  "displaydoc",
+ "serde_core",
  "zerovec",
 ]
 
@@ -2375,9 +3797,9 @@ checksum = "fd3ca314f692efd6c868f8408f53fe444634a845f96c028b97d35f6a1f79f0ee"
 
 [[package]]
 name = "tokio"
-version = "1.53.1"
+version = "1.54.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "202caea871b69668250d242070849eb495be178ed697a3e98aebce5bc81a0bed"
+checksum = "b52fd3255258d26fac7264ab5a76b53c13367136dc011d3d6ad4f8ed070396a3"
 dependencies = [
  "bytes",
  "libc",
@@ -2392,8 +3814,8 @@ dependencies = [
 
 [[package]]
 name = "tokio-boring"
-version = "5.2.0"
-source = "git+https://github.com/YuanDevTeam/boring?branch=release#43c1c1d5b9464b3f2d5204be8664778fada7dbaf"
+version = "5.4.0"
+source = "git+https://github.com/YuanDevTeam/boring?rev=c717137e6c794a0b069f64686a375858ffc80818#c717137e6c794a0b069f64686a375858ffc80818"
 dependencies = [
  "boring",
  "boring-sys",
@@ -2408,14 +3830,14 @@ checksum = "78773a2a397f451582ce068015985c33193cf6dea8b74d2a639fe457b2f07b0e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
 ]
 
 [[package]]
 name = "tokio-rustls"
-version = "0.26.5"
+version = "0.26.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0c85f2c3ef0b1cd58b36682f4b17aaa995f0e5db534d85692b4903abce21f67"
+checksum = "c9cc2678c2cdd569ef8215e2afd7954ada2ae20b4fdd2c5fe6139a3b02d105db"
 dependencies = [
  "rustls",
  "tokio",
@@ -2452,9 +3874,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-util"
-version = "0.7.19"
+version = "0.7.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "494815d09bf52b5548659851081238f0ca39ff638363907596da739561c62c52"
+checksum = "e464cf451ba96ebfc6f9b6542f17ee8b8956e33f1e40d9690624e59d7a7f8a4b"
 dependencies = [
  "bytes",
  "futures-core",
@@ -2466,6 +3888,15 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "toml"
+version = "0.5.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "tracing"
 version = "0.1.44"
@@ -2495,6 +3926,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
 dependencies = [
  "once_cell",
+ "valuable",
 ]
 
 [[package]]
@@ -2516,11 +3948,11 @@ checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
 
 [[package]]
 name = "tun-rs"
-version = "2.8.11"
+version = "2.8.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19e3459c60bb1cd4a5969fced4299be335b3e3169d8cb3466ffe23da56eeeeb4"
+checksum = "280a6cc03289f9254d9268eadd5712c476dbd7a47ef51aae86e8b9d0b45dcd43"
 dependencies = [
- "byteorder",
+ "ahash",
  "bytes",
  "encoding_rs",
  "getifaddrs",
@@ -2548,9 +3980,29 @@ dependencies = [
  "http",
  "httparse",
  "log",
- "rand",
+ "rand 0.10.3",
  "sha1",
- "thiserror",
+ "thiserror 2.0.21",
+]
+
+[[package]]
+name = "turboshake"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f892c6904b0bd5a9241eac848347abcbbbd2b9f3892bad23ac3e6efab8d6f06a"
+dependencies = [
+ "digest 0.11.3",
+ "keccak",
+ "sponge-cursor",
+]
+
+[[package]]
+name = "type-map"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb30dbbd9036155e74adad6812e9898d03ec374946234fbcebd5dfc7b9187b90"
+dependencies = [
+ "rustc-hash 2.1.3",
 ]
 
 [[package]]
@@ -2559,11 +4011,46 @@ version = "1.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
 
+[[package]]
+name = "unic-langid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a28ba52c9b05311f4f6e62d5d9d46f094bd6e84cb8df7b3ef952748d752a7d05"
+dependencies = [
+ "unic-langid-impl",
+]
+
+[[package]]
+name = "unic-langid-impl"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dce1bf08044d4b7a94028c93786f8566047edc11110595914de93362559bc658"
+dependencies = [
+ "serde",
+ "tinystr",
+]
+
+[[package]]
+name = "unicase"
+version = "2.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "357cc3acc6a036009fd6c973ed009037c732d60d0b4f6c673e9041497482a28f"
+
 [[package]]
 name = "unicode-ident"
-version = "1.0.26"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563"
+
+[[package]]
+name = "universal-hash"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954"
+checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea"
+dependencies = [
+ "crypto-common 0.1.7",
+ "subtle",
+]
 
 [[package]]
 name = "universal-hash"
@@ -2571,7 +4058,7 @@ version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f4987bdc12753382e0bec4a65c50738ffaabc998b9cdd1f952fb5f39b0048a96"
 dependencies = [
- "crypto-common",
+ "crypto-common 0.2.2",
  "ctutils",
 ]
 
@@ -2607,73 +4094,117 @@ dependencies = [
 
 [[package]]
 name = "utf8_iter"
-version = "1.0.4"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af3bd9d3e571c26fcce9d033b87ea5ab061b8d2ffe9b7a5675d810d68f03edf0"
+dependencies = [
+ "utf_types",
+]
+
+[[package]]
+name = "utf_types"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+checksum = "3a3b425286980a367278453f3b6d28cdcb134b574e5a35824a6ff5eebad50bb6"
 
 [[package]]
 name = "uuid"
-version = "1.26.1"
+version = "1.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ef6dac1e96601b4fb3acccccff2139741fcb757cb9a36089bf5be91cfb285ce"
+checksum = "4a0e2d11620c50695fe12bbbfde96b3477fe606e7284c22d505c12ce51214514"
 dependencies = [
  "js-sys",
  "serde_core",
+ "sha1_smol",
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "valuable"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
 [[package]]
 name = "vole"
 version = "0.1.0"
 dependencies = [
  "aes",
+ "age",
+ "age-core",
  "arc-swap",
  "async-trait",
- "base64",
- "blake2",
+ "base64 0.23.1",
+ "bech32 0.12.0",
+ "blake2 0.11.0",
  "blake3",
  "boring",
  "boring-sys",
+ "boringtun",
+ "brotli",
  "bytes",
+ "chacha20poly1305 0.11.0",
  "crc32fast",
+ "domain",
+ "fancy-regex",
+ "flate2",
  "foreign-types",
  "futures-util",
+ "getifaddrs",
  "h2",
  "h3",
  "h3-quinn",
+ "hostname",
  "hpke",
+ "httlib-hpack",
  "http",
  "httparse",
  "hyper",
  "hyper-util",
  "idna",
  "libc",
- "log",
+ "maxminddb",
  "md-5",
  "oslog",
+ "prost",
+ "psl",
+ "quiche",
  "quinn",
  "quinn-proto",
- "rand",
+ "rand 0.10.3",
  "rcgen",
+ "redb",
  "regex",
  "regex-syntax",
  "ring",
+ "rsa",
  "rustls",
+ "rustls-native-certs",
  "serde",
  "serde_json",
  "serde_yaml_ng",
- "sha2",
+ "sevenz-rust2",
+ "sha2 0.11.1",
  "shadowsocks",
  "shake",
  "socket2",
  "tempfile",
- "thiserror",
+ "thiserror 2.0.21",
+ "time",
  "tokio",
  "tokio-boring",
  "tokio-rustls",
+ "tokio-tfo",
  "tokio-tungstenite",
  "tokio-util",
  "tracing",
+ "tracing-core",
  "tun-rs",
  "url",
  "uuid",
@@ -2683,8 +4214,11 @@ dependencies = [
  "windows 0.62.2",
  "windows-collections 0.3.2",
  "windows-core 0.62.2",
+ "x509-parser",
+ "yaml-rust2",
  "yamux",
  "zeroize",
+ "zstd",
 ]
 
 [[package]]
@@ -2703,16 +4237,26 @@ dependencies = [
  "bytes",
  "futures-util",
  "smoltcp",
- "thiserror",
+ "thiserror 2.0.21",
  "tokio",
  "tokio-util",
 ]
 
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
 [[package]]
 name = "want"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e"
+checksum = "ec4cdd0dd910afe868b7ef477227d8d538b46b3075031afee8a9f2acb0a2ed0b"
 dependencies = [
  "try-lock",
 ]
@@ -2723,14 +4267,22 @@ version = "0.11.1+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
 
+[[package]]
+name = "wasip2"
+version = "1.0.4+wasi-0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b67efb37e106e55ce722a510d6b5f9c17f083e5fc79afc2badeb12cc313d9487"
+dependencies = [
+ "wit-bindgen",
+]
+
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.128"
+version = "0.2.130"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aecb87a33d3b0c5e3b7aa46336eaf486cffafbd281b195e4c8b80d50df2351bf"
+checksum = "a0181c14ddd6c7b8b0b0132a5f1ea2f32be0d893cd3ea97b6e3b28886b8a3d1c"
 dependencies = [
  "cfg-if",
- "once_cell",
  "rustversion",
  "wasm-bindgen-macro",
  "wasm-bindgen-shared",
@@ -2738,9 +4290,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.128"
+version = "0.2.130"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a690d511e3c1a8b3a55e33511e3c2c00c78415cd23650f32b808627f5696b9ed"
+checksum = "6e931a02a39abdbf66966fc35902b5ed58344750a70885bed4ebb3d8eaf28ed9"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -2748,22 +4300,22 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.128"
+version = "0.2.130"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "411e4887f0071ef2d2164a9d5fdf2d20efbef78fccd3a78b0c10a1dc5295e48a"
+checksum = "2ca4b54280e455bd831e33a6b8e734baf432fe63fbc35c42ac14ce67a043a53a"
 dependencies = [
  "bumpalo",
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.128"
+version = "0.2.130"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81941cd78d0c92026c33e5e01312845a4cb1e9af3407f9134b100dd03144103e"
+checksum = "3b1f9c3798725016c6ee5f2f57869ec0831e8bbc0ab0310a86e787e97f41389e"
 dependencies = [
  "unicode-ident",
 ]
@@ -2780,9 +4332,9 @@ dependencies = [
 
 [[package]]
 name = "webpki-roots"
-version = "1.0.9"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7dcd9d09a39985f5344844e66b0c530a33843579125f23e21e9f0f220850f22a"
+checksum = "f5f280bbb2b287bc8e7de7e3852945a0ff50d1bbcb5ed42b6c7a568c546df171"
 dependencies = [
  "rustls-pki-types",
 ]
@@ -2809,6 +4361,15 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
+[[package]]
+name = "winapi-util"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "winapi-x86_64-pc-windows-gnu"
 version = "0.4.0"
@@ -3005,6 +4566,15 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.60.2"
@@ -3180,20 +4750,64 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "wit-bindgen"
+version = "0.57.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
+
+[[package]]
+name = "wnaf"
+version = "0.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "795ca18b3fdb5e62bf982199278341ddcf7ebf7d32e25e212ad05d496e95f6fa"
+dependencies = [
+ "ff",
+ "group",
+ "hybrid-array",
+ "primefield",
+]
+
 [[package]]
 name = "writeable"
 version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc"
 
+[[package]]
+name = "x-wing"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01576e56599d01d75c5efcd5b30fa5de29e776f5a225e43fbf8c92c7302d4c8b"
+dependencies = [
+ "kem",
+ "ml-kem",
+ "sha3",
+ "shake",
+ "x25519-dalek 3.0.0",
+ "zeroize",
+]
+
+[[package]]
+name = "x25519-dalek"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7e468321c81fb07fa7f4c636c3972b9100f0346e5b6a9f2bd0603a52f7ed277"
+dependencies = [
+ "curve25519-dalek 4.1.3",
+ "rand_core 0.6.4",
+ "serde",
+ "zeroize",
+]
+
 [[package]]
 name = "x25519-dalek"
 version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e7e8131a03190127fb2263afc72b322ecadae46b6ff8c6f399ff5d02f5559af6"
 dependencies = [
- "curve25519-dalek",
- "rand_core",
+ "curve25519-dalek 5.0.0",
+ "rand_core 0.10.1",
  "zeroize",
 ]
 
@@ -3211,10 +4825,20 @@ dependencies = [
  "oid-registry",
  "ring",
  "rusticata-macros",
- "thiserror",
+ "thiserror 2.0.21",
  "time",
 ]
 
+[[package]]
+name = "yaml-rust2"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57e5b818a27a4cd30884ea380857a5e56f7ec3ba24a3990a3cc0b95af3238e18"
+dependencies = [
+ "arraydeque",
+ "hashlink",
+]
+
 [[package]]
 name = "yamux"
 version = "0.14.1"
@@ -3236,15 +4860,15 @@ version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b5f6765e852b9b4dc8e2a76843e4d64d1cea8e79bcde0b6901aea8e7c7f08282"
 dependencies = [
- "bit-vec",
+ "bit-vec 0.9.1",
  "time",
 ]
 
 [[package]]
 name = "yoke"
-version = "0.8.3"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "709fe23a0424b6a435d82152b1bd3fdfb0833487d5fa90d05d42762a9891fef5"
+checksum = "417ef3fcf6c300b7dbd25c85531a746931c02ad536f3cf4786ed1e88223340b3"
 dependencies = [
  "stable_deref_trait",
  "yoke-derive",
@@ -3253,16 +4877,36 @@ dependencies = [
 
 [[package]]
 name = "yoke-derive"
-version = "0.8.3"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33811428bee40dbceb6d545e95754741d17a6aef9a4849f0fd62e2ba4f412a78"
+checksum = "ec8ebde2db3681e8c9980cc27822030e68752690ddfa9473e739aeb4dbde6d71"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
  "synstructure 0.14.0",
 ]
 
+[[package]]
+name = "zerocopy"
+version = "0.8.63"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5fe1f8f1b06191a00962174c61aa5005e0bb391a6d80d07e24d115c01a92ed8"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.63"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "863ad3ac83293fb4d740aedbfdc9240dd8d1a50c1099acd76ce80ce7c7230c7f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
 [[package]]
 name = "zerofrom"
 version = "0.1.8"
@@ -3280,15 +4924,15 @@ checksum = "f75b4683f6c7f45248d4d64056a24298c6281e0993356d7d1b4a1a962ef10d4a"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
  "synstructure 0.14.0",
 ]
 
 [[package]]
 name = "zeroize"
-version = "1.9.0"
+version = "1.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e13c156562582aa81c60cb29407084cdb54c4164760106ab78e6c5b0858cf64e"
+checksum = "e13084392c5e4bc371903e2935a5eaeed24905a7511356b883835e18a78f6879"
 dependencies = [
  "zeroize_derive",
 ]
@@ -3317,10 +4961,11 @@ dependencies = [
 
 [[package]]
 name = "zerovec"
-version = "0.11.8"
+version = "0.11.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb0464e17806c1d976d5cba29399c7f08e516e279e2ba493f63123b5fca67dd8"
+checksum = "f58a2799cfe9a1670c7ea8edbd52ef8edb93cb37a7f83bf31ba9e35d9dae6a40"
 dependencies = [
+ "serde",
  "yoke",
  "zerofrom",
  "zerovec-derive",
@@ -3328,13 +4973,13 @@ dependencies = [
 
 [[package]]
 name = "zerovec-derive"
-version = "0.11.6"
+version = "0.11.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34df6fc39dbd26ddc9c10e6a2984476e13acce22e64e4487636ef494369225da"
+checksum = "c3743ddbf47738d929cd1ae2e199d40d0162979dfe31aef8ae646d2bf00bf97a"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
 ]
 
 [[package]]
@@ -3342,3 +4987,31 @@ name = "zmij"
 version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"
+
+[[package]]
+name = "zstd"
+version = "0.14.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db3ae9bf90af6e40197bef767eeefc46ad6397420fe873830bd85e5fbbfb3c70"
+dependencies = [
+ "zstd-safe",
+]
+
+[[package]]
+name = "zstd-safe"
+version = "8.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ded520f16b29e1a9b771c722221b2b0a0398c2316d9bb3c42b458a5414d7434b"
+dependencies = [
+ "zstd-sys",
+]
+
+[[package]]
+name = "zstd-sys"
+version = "2.1.2+zstd.1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "481ada9c543b2323cbb7bbdbb5249177fbf0188ed959ed2c15e4b22421c84ed3"
+dependencies = [
+ "cc",
+ "pkg-config",
+]
diff --git a/Cargo.toml b/Cargo.toml
index 0fa6d8d..3d32002 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -30,121 +30,173 @@ required-features = ["ffi", "windows-uwp"]
 
 [features]
 default = [
+    "dns-quic",
     "inbound-http",
     "inbound-socks5",
+    "outbound-http",
     "outbound-anytls",
     "outbound-socks5",
     "outbound-shadowsocks",
     "outbound-trojan",
+    "outbound-trusttunnel",
+    "outbound-mieru",
+    "outbound-masque",
     "outbound-vmess",
     "outbound-vless",
     "outbound-hysteria2",
     "outbound-tuic",
+    "outbound-wireguard",
     "shadow-tls-v3",
+    "sing-mux",
 ]
-inbound-http = []
-inbound-socks5 = []
-outbound-anytls = ["dep:md-5", "tls-fingerprint"]
+inbound-http = ["dep:rcgen", "rcgen/x509-parser", "dep:rsa", "dep:tokio-tungstenite", "dep:hyper", "dep:hyper-util", "dep:x509-parser"]
+inbound-socks5 = ["dep:rcgen", "dep:rsa", "dep:ring", "dep:tokio-tungstenite"]
+outbound-anytls = ["dep:md-5", "stream-security", "ech"]
 outbound-socks5 = []
-outbound-shadowsocks = ["dep:shadowsocks", "dep:log"]
-outbound-vless = ["tls-fingerprint", "boring/reality", "boring/jls", "boring/mlkem", "dep:blake3", "dep:hpke", "dep:zeroize", "dep:vole-blake3-raw", "stream-transport", "quic-transport", "dep:hyper", "dep:hyper-util", "dep:h3", "dep:h3-quinn", "dep:yamux", "tokio-util/compat"]
-outbound-trojan = ["stream-transport", "tls-fingerprint"]
-outbound-vmess = ["stream-transport", "tls-fingerprint", "dep:aes", "dep:crc32fast", "dep:md-5", "dep:ring", "dep:shake"]
+outbound-http = []
+outbound-shadowsocks = ["dep:shadowsocks", "dep:blake3", "stream-security", "stream-transport", "ech", "dep:aes", "dep:ring"]
+outbound-vless = ["ech", "stream-security", "boring/mlkem", "dep:blake3", "dep:vole-blake3-raw", "stream-transport", "quinn-h3-transport", "dep:hyper", "dep:hyper-util"]
+outbound-trojan = ["stream-transport", "stream-security", "ech"]
+outbound-trusttunnel = ["stream-transport", "tls-fingerprint", "ech", "quiche-h3-transport"]
+outbound-mieru = ["dep:boring", "dep:chacha20poly1305", "dep:hostname", "dep:prost", "dep:ring"]
+outbound-masque = ["stream-transport", "quiche-h3-transport", "dep:vole-netstack"]
+outbound-vmess = ["stream-transport", "stream-security", "ech", "dep:aes", "dep:md-5", "dep:ring", "dep:shake"]
+stream-security = ["tls-fingerprint", "boring/reality", "boring/jls"]
 tls-fingerprint = ["dep:boring", "dep:tokio-boring"]
-shadow-tls-v3 = ["tls-fingerprint", "boring/shadow-tls-v3", "dep:ring", "dep:zeroize"]
-outbound-hysteria2 = ["quic-transport", "dep:quinn-proto", "dep:h3", "dep:h3-quinn", "dep:blake2"]
+ech = []
+shadow-tls-v3 = ["tls-fingerprint", "boring/shadow-tls-v3", "dep:ring"]
+outbound-hysteria2 = ["ech", "quic-transport", "dep:h3", "dep:h3-quinn", "dep:blake2", "dep:hyper", "dep:hyper-util"]
 outbound-tuic = ["quic-transport"]
-stream-transport = ["dep:tokio-tungstenite", "dep:httparse", "dep:log"]
-quic-transport = ["dep:quinn"]
+sing-mux = ["stream-transport", "dep:yamux", "tokio-util/compat"]
+outbound-wireguard = ["dep:boringtun", "dep:vole-netstack"]
+stream-transport = ["dep:tokio-tungstenite", "dep:httparse"]
+quic-transport = ["dep:quinn", "dep:quinn-proto"]
+# Exposes h3::ConnectionState for connection error/closing checks before reuse.
+# h3-quinn does not enable this feature on Vole's behalf.
+quinn-h3-transport = ["quic-transport", "dep:h3", "dep:h3-quinn", "h3/i-implement-a-third-party-backend-and-opt-into-breaking-changes"]
+quiche-h3-transport = ["quic-transport", "dep:quiche", "dep:boring"]
+dns-quic = ["quinn-h3-transport"]
 # Enables local interoperability-only trust-root injection. Release build
 # scripts must not enable this feature.
 interop-test = ["outbound-anytls", "outbound-vless"]
-# Allows plaintext GeoData fixtures for isolated benchmarks, never production.
-benchmark-geodata-http = []
-invoke = ["tun", "tokio/rt-multi-thread", "tokio/signal"]
+invoke = ["tun", "dns-quic", "tokio/rt-multi-thread", "tokio/signal"]
 ffi = ["invoke"]
 cli = ["invoke"]
-windows-wintun = ["tun", "dep:tun-rs"]
+windows-wintun = ["tun", "dep:tun-rs", "dep:windows"]
 windows-uwp = ["invoke", "dep:windows", "dep:windows-collections", "dep:windows-core"]
 tun = [
-    "dep:vole-netstack",
     "inbound-http",
     "inbound-socks5",
     "outbound-anytls",
+    "outbound-http",
     "outbound-socks5",
     "outbound-shadowsocks",
     "outbound-trojan",
+    "outbound-trusttunnel",
+    "outbound-mieru",
+    "outbound-masque",
     "outbound-vmess",
     "outbound-vless",
     "outbound-hysteria2",
     "outbound-tuic",
+    "outbound-wireguard",
     "shadow-tls-v3",
+    "sing-mux",
 ]
 
 [dependencies]
-aes = { version = "0.9.3", optional = true, features = ["zeroize"] }
+age = { version = "=0.11.5", default-features = false, features = ["armor"] }
+age-core = "=0.11.0"
+aes = { version = "0.9.4", optional = true, features = ["zeroize"] }
 arc-swap = "1"
 async-trait = "0.1"
 base64 = "0.23"
+bech32 = "=0.12.0"
 blake2 = { version = "=0.11.0", optional = true }
 blake3 = { version = "=1.8.7", optional = true }
-boring = { git = "https://github.com/YuanDevTeam/boring", branch = "release", version = "=5.2.0", features = ["client-fingerprint"], optional = true }
+boringtun = { version = "=0.7.1", default-features = false, optional = true }
+boring = { git = "https://github.com/YuanDevTeam/boring", rev = "c717137e6c794a0b069f64686a375858ffc80818", version = "=5.4.0", features = ["client-fingerprint"], optional = true }
 bytes = "1"
-crc32fast = { version = "1.5.2", optional = true }
+chacha20poly1305 = { version = "=0.11.0", default-features = false, features = ["zeroize"], optional = true }
+crc32fast = "=1.5.4"
+domain = { version = "=0.12.3", default-features = false, features = ["std"] }
+fancy-regex = { version = "=0.20.0", default-features = false, features = ["std", "unicode"] }
+flate2 = { version = "=1.1.10", default-features = false, features = ["rust_backend"] }
+brotli = { version = "=9.1.1", default-features = false, features = ["std"] }
 futures-util = { version = "0.3", features = ["sink"] }
-h2 = "0.4.19"
+getifaddrs = "=0.6.2"
+h2 = "0.4.20"
 h3 = { version = "=0.0.8", default-features = false, optional = true }
 h3-quinn = { version = "=0.0.10", default-features = false, optional = true }
-hpke = { version = "=0.14.1", default-features = false, features = ["alloc", "aes", "chacha", "x25519"], optional = true }
+hpke = { version = "=0.15.1", default-features = false, features = ["alloc", "aes", "chacha", "x25519", "nistp", "mlkem", "shake"] }
+hostname = { version = "=0.4.2", default-features = false, optional = true }
 http = "1"
-hyper = { version = "=1.11.1", default-features = false, features = ["client", "http1"], optional = true }
-hyper-util = { version = "=0.1.20", default-features = false, features = ["tokio"], optional = true }
+hyper = { version = "=1.12.0", default-features = false, features = ["client", "http1"], optional = true }
+hyper-util = { version = "=0.1.21", default-features = false, features = ["tokio"], optional = true }
 httparse = { version = "1.10", optional = true }
+httlib-hpack = "=0.1.3"
 idna = "1.1"
 libc = "0.2"
-# Upstream SS trace/debug logs include key material and traffic destinations.
-# Keep the log facade compiled out when SS is linked; Vole uses tracing.
-log = { version = "0.4", optional = true, features = ["max_level_off", "release_max_level_off"] }
 md-5 = { version = "0.11", optional = true }
+maxminddb = { version = "=0.32.0", default-features = false }
 quinn = { version = "=0.11.12", default-features = false, features = ["runtime-tokio", "rustls-ring"], optional = true }
-quinn-proto = { version = "=0.11.18", default-features = false, features = ["rustls-ring"], optional = true }
+quinn-proto = { version = "=0.11.19", default-features = false, features = ["rustls-ring"], optional = true }
+quiche = { version = "=0.30.0", default-features = false, features = ["boringssl-boring-crate"], optional = true }
 rand = "0.10"
+rcgen = { version = "=0.14.10", default-features = false, features = ["crypto", "ring"], optional = true }
+rsa = { version = "=0.9.10", default-features = false, features = ["std"], optional = true }
 ring = { version = "0.17.14", optional = true }
+redb = "=4.4.0"
+psl = "=2.1.246"
+prost = { version = "=0.14.4", default-features = false, features = ["derive", "std"], optional = true }
 regex = "1.13"
 regex-syntax = { version = "0.8", default-features = false, features = ["std", "unicode-case"] }
-rustls = { version = "=0.23.45", default-features = false, features = ["ring", "std", "tls12"] }
-serde = { version = "1", features = ["derive"] }
-serde_json = "1"
+rustls = { version = "=0.23.46", default-features = false, features = ["ring", "std", "tls12"] }
+rustls-native-certs = "=0.8.5"
+serde = { version = "1", features = ["derive", "rc"] }
+serde_json = { version = "1", features = ["raw_value"] }
 serde_yaml_ng = "0.10"
+yaml-rust2 = { version = "=0.13.0", default-features = false }
+sevenz-rust2 = { version = "=0.24.2", default-features = false }
 sha2 = "0.11"
 shake = { version = "0.1.0", optional = true }
 shadowsocks = { version = "=1.25.0", optional = true, default-features = false, features = ["aead-cipher-2022"] }
 socket2 = { version = "0.6", features = ["all"] }
 thiserror = "2"
+time = { version = "=0.3.55", features = ["formatting"] }
 tokio = { version = "1", features = ["io-util", "macros", "net", "rt", "sync", "time"] }
-tokio-boring = { git = "https://github.com/YuanDevTeam/boring", branch = "release", version = "=5.2.0", optional = true }
-tokio-rustls = { version = "=0.26.5", default-features = false, features = ["ring", "tls12"] }
+tokio-boring = { git = "https://github.com/YuanDevTeam/boring", rev = "c717137e6c794a0b069f64686a375858ffc80818", version = "=5.4.0", optional = true }
+tokio-rustls = { version = "=0.26.6", default-features = false, features = ["ring", "tls12"] }
 tokio-tungstenite = { version = "=0.30.0", default-features = false, features = ["handshake"], optional = true }
 tokio-util = { version = "0.7", features = ["rt"] }
 tracing = "0.1"
+tracing-core = "0.1.36"
 url = "2"
-uuid = { version = "1", features = ["serde"] }
+uuid = { version = "=1.29.0", features = ["serde", "v5"] }
 vole-netstack = { path = "crates/vole-netstack", optional = true }
 vole-blake3-raw = { path = "crates/vole-blake3-raw", optional = true }
 webpki-roots = "1"
+x509-parser = { version = "=0.18.1", default-features = false, optional = true }
 yamux = { version = "=0.14.1", optional = true }
-zeroize = { version = "=1.9.0", optional = true }
+zeroize = { version = "=1.9.1" }
+zstd = { version = "0.14.3", default-features = false }
 
 [target.'cfg(any(target_os = "ios", target_os = "tvos", target_os = "macos"))'.dependencies]
 oslog = { version = "0.2", default-features = false }
 
+[target.'cfg(target_os = "linux")'.dependencies]
+# Public socket adapter; shared Dialer retains protection, deadlines and Stop.
+tokio-tfo = "=0.4.3"
+# Core-owned Linux TUN setup uses tun-rs's opt-in address management API.
+tun-rs = { version = "=2.8.16", default-features = false, features = ["address-management"] }
+
 [target.'cfg(unix)'.dependencies]
 # Keep one Cargo dependency name across target tables. Unix compiles this small
 # adapter dependency; platform I/O remains gated by the tun feature.
-tun-rs = { version = "=2.8.11", default-features = false }
+tun-rs = { version = "=2.8.16", default-features = false }
 
 [target.'cfg(windows)'.dependencies]
-tun-rs = { version = "=2.8.11", default-features = false, optional = true, features = ["interruptible"] }
+tun-rs = { version = "=2.8.16", default-features = false, optional = true, features = ["interruptible"] }
 windows = { version = "=0.62.2", optional = true, features = [
     "ApplicationModel_Background",
     "ApplicationModel_Core",
@@ -163,6 +215,7 @@ windows = { version = "=0.62.2", optional = true, features = [
     "Win32_NetworkManagement_Ndis",
     "Win32_Networking_WinSock",
     "Win32_Security",
+    "Win32_Security_Cryptography",
     "Win32_Security_Isolation",
     "Win32_System_Com",
     "Win32_System_JobObjects",
@@ -177,8 +230,11 @@ windows-collections = { version = "=0.3.2", optional = true }
 windows-core = { version = "=0.62.2", optional = true }
 
 [dev-dependencies]
+h3 = { version = "=0.0.8", default-features = false }
+h3-quinn = { version = "=0.0.10", default-features = false }
+sevenz-rust2 = { version = "=0.24.2", default-features = false, features = ["compress"] }
 # Native peer controls for bounded in-memory ALPS tests; same source as boring.
-boring-sys = { git = "https://github.com/YuanDevTeam/boring", branch = "release", version = "=5.2.0" }
+boring-sys = { git = "https://github.com/YuanDevTeam/boring", rev = "c717137e6c794a0b069f64686a375858ffc80818", version = "=5.4.0" }
 foreign-types = "=0.5.0"
 tokio = { version = "1", features = ["test-util"] }
 # Independent EIH relay fixture only; production crypto remains the official SS crate.
@@ -208,3 +264,8 @@ unsafe_op_in_unsafe_fn = "deny"
 [lints.clippy]
 all = "warn"
 pedantic = "allow"
+
+[patch.crates-io]
+# quiche and Vole share the same approved Boring commit.
+boring = { git = "https://github.com/YuanDevTeam/boring", rev = "c717137e6c794a0b069f64686a375858ffc80818" }
+boring-sys = { git = "https://github.com/YuanDevTeam/boring", rev = "c717137e6c794a0b069f64686a375858ffc80818" }
diff --git a/README.md b/README.md
index d47c58e..67538be 100644
--- a/README.md
+++ b/README.md
@@ -6,36 +6,46 @@
 
 Vole is a Rust proxy core for VPN clients and local proxies, available as native libraries and a foreground CLI. It routes TCP/UDP traffic through direct connections, proxy nodes, groups, and chains, with integrated DNS, GeoData, and a cross-platform TUN data plane.
 
-Configuration uses **Mihomo-compatible YAML for the supported feature set**. Vole focuses on client-side capabilities rather than implementing every Mihomo field or its complete Dashboard API.
+Configuration uses **Mihomo-style YAML for the supported feature set**. Vole prioritizes memory efficiency and throughput. Compatibility targets interoperability with Mihomo listeners and official protocol servers, without requiring identical behavior for every field; see the [compatibility principles](docs/mihomo-compatibility.md#兼容原则).
 
 ## What Vole can do
 
 - **Accept application and VPN traffic:** HTTP forwarding, CONNECT and Upgrade; SOCKS5 CONNECT and UDP ASSOCIATE; host-provided IPv4/IPv6 TUN packets.
-- **Route by destination:** domain, domain suffix/keyword, IP CIDR, destination port, TCP/UDP, GeoSite and GeoIP rules, with explicit DIRECT and REJECT actions.
-- **Choose and chain proxies:** nested `select` groups, live group selection, and `dialer-proxy` chains that can reference nodes or groups. Selection changes apply to new physical transports without moving existing connections.
-- **Handle DNS:** controlled UDP/TCP nameservers, GeoSite-based nameserver policies, sequential failover, caching and duplicate-query coalescing; intercept configured TCP/UDP TUN DNS targets (port 53 by default).
-- **Identify traffic for routing:** HTTP, TLS and QUIC domain sniffing, plus TUN DNS hints, without rewriting the actual destination. ICMPv4/ICMPv6 Echo is answered locally.
-- **Manage routing assets:** load referenced categories from `geosite.dat` / `geoip.dat` on demand and update them through the configured route. GeoSite supports Domain, Full, Plain and Regex records, attribute intersections and inverted selectors; GeoIP supports inverted selectors. All platforms retain selected records without a count cap or truncation; GeoData has no total memory quota. See [GeoData boundaries](docs/geodata.md#内存与安全边界).
-- **Expose client controls:** a loopback Controller for group selection and TUN traffic rates/totals, plus isolated node/chain delay measurement through Invoke API.
+- **Route traffic:** rule/global/direct modes; domain, source/destination IP and port, TCP/UDP, GeoSite/GeoIP, rule providers and logical rules; process/UID rules on supported platforms; named direct/dns/reject outbounds and built-in routing actions.
+- **Choose and chain proxies:** nested select/url-test/fallback/load-balance groups, health checks and persistent selection; `dialer-proxy` chains can reference nodes or groups. Existing connections retain their selected path.
+- **Handle DNS:** hosts, separate bootstrap/node/direct resolvers, UDP/TCP/DoH/DoT/DoQ, domain/GeoSite/rule-set policies, fallback, bounded caching, redir-host and persistent fake-IP mappings; intercept configured TUN DNS targets.
+- **Identify traffic for routing:** HTTP/1, HTTP/2 and TLS sniffing for TUN and mixed TCP; QUIC v1/v2 sniffing for TUN and SOCKS5 UDP associations, with force/skip conditions and configurable destination override. ICMPv4/ICMPv6 Echo is answered locally.
+- **Manage routing assets:** HTTP/file/inline proxy and rule providers, URI/Base64/AGE subscriptions, dynamic groups, filters and overrides; YAML/Text and domain/ipcidr MRS. GeoData loads complete referenced categories and supports routed downloads and periodic updates. Failed updates retain usable state. See [GeoData boundaries](docs/geodata.md#内存与安全边界).
+- **Expose client controls:** group/resource state, connection snapshots and cancellation, rule counters, effective configuration, bounded WebSocket streams and DNS diagnostics; supported configuration updates, TUN traffic metrics and isolated node/chain delay measurement. See the [Controller contract](docs/controller-api.md) for update boundaries.
+- **Process selected business HTTP:** URL rewrites and redirects, with optional host-supplied CA interception for explicitly allowed HTTPS domains and bounded H1/H2 streaming. This uses a [separate HTTP configuration](docs/http-processing.md).
 
 ## Proxy protocols
 
-All eight protocols below are enabled in the default build. UDP support is configured per node.
+The default build enables the protocols below. UDP support depends on the protocol mode and node configuration.
 
 | Protocol | Capabilities |
 | --- | --- |
-| [VLESS](docs/vless.md) | TCP, WebSocket / HTTPUpgrade, gRPC, HTTP first-packet camouflage, legacy H2, [XHTTP H1/H2/H3](docs/xhttp.md); Vision, Encryption, REALITY, JLS, static ECH and sing-mux in supported combinations |
-| [VMess AEAD](docs/outbounds.md#vmess-aead) | TCP, WebSocket / HTTPUpgrade, gRPC, HTTP first-packet camouflage and legacy H2; TCP/UDP, plaintext or standard TLS |
+| [VLESS](docs/vless.md) | TCP, WebSocket / HTTPUpgrade, gRPC, HTTP first-packet camouflage, legacy H2, [XHTTP H1/H2/H3](docs/xhttp.md); Vision, Encryption, REALITY, JLS and ECH in supported combinations |
+| [VMess AEAD](docs/outbounds.md#vmess-aead) | TCP, WebSocket / HTTPUpgrade, gRPC, HTTP first-packet camouflage and legacy H2; TCP/UDP, plaintext or supported TLS modes |
 | [Trojan](docs/outbounds.md#trojan) | TCP/UDP over TLS TCP, WebSocket / HTTPUpgrade or gRPC |
-| [Shadowsocks 2022](docs/outbounds.md#shadowsocks-2022) | TCP/UDP; AES-128-GCM, AES-256-GCM and ChaCha20-Poly1305; AES identity chains; optional strict ShadowTLS v3 TCP wrapping and UoT v2 |
+| [Shadowsocks 2022](docs/outbounds.md#shadowsocks-2022) | TCP/UDP; three 2022 ciphers and AES identity chains; optional obfs, WebSocket, JLS or strict ShadowTLS v3 plugins; UoT v2 |
 | [AnyTLS](docs/outbounds.md#anytls) | TLS sessions and UDP over TCP v2 |
+| [HTTP / HTTPS CONNECT](docs/outbounds.md#http--https-connect) | TCP CONNECT, optional proxy authentication and TLS |
 | [SOCKS5](docs/outbounds.md#socks5) | CONNECT and UDP ASSOCIATE, with optional username/password authentication |
-| [Hysteria2](docs/outbounds.md#hysteria2) | QUIC TCP/UDP, bandwidth control, Salamander, port hopping and mTLS |
-| [TUIC v5](docs/outbounds.md#tuic-v5) | QUIC TCP/UDP, native/quic UDP relay modes and selectable congestion control |
+| [Hysteria2](docs/outbounds.md#hysteria2) | QUIC TCP/UDP, bandwidth control, Salamander/Gecko, port hopping or Realm/STUN, and mTLS |
+| [TUIC v5](docs/outbounds.md#tuic-v5) | QUIC TCP/UDP, native/quic UDP relay modes, UoT v2, selectable congestion control and `disable-sni` with certificate verification retained |
+| [WireGuard](docs/outbounds.md#wireguard) | TCP/UDP over standard WireGuard, multiple peers and node DNS, with a user-space IP stack |
+| [TrustTunnel](docs/outbounds.md#trusttunnel) | TCP/UDP over H2 or H3 CONNECT; authentication, health checks, mTLS and ECH |
+| [Mieru](docs/outbounds.md#mieru) | TCP/UDP over TCP or UDP carriers; multiplexing, STANDARD/NO-WAIT handshakes and traffic patterns |
+| [MASQUE](docs/outbounds.md#masque) | TCP/UDP over H2/H3 CONNECT-IP; TCP-only H3 L4 proxy mode |
 
-Standard TLS connections support certificate verification and SHA-256 certificate pins. Applicable TCP TLS paths can use Chrome, Firefox or Safari ClientHello templates; `client-fingerprint` is independent of the certificate `fingerprint`. See [TLS profiles and certificate policy](docs/tls-client-fingerprint.md) for the exact names and combinations. These features do not promise indistinguishability from a browser or unrestricted protocol combinations.
+The shared [sing-mux wrapper](docs/xhttp.md#通用-sing-mux) supports all enabled node protocols. It provides TCP and, with `only-tcp: false`, UDP over the node's ordinary TCP path. The peer must provide sing-mux decoding; a normal HTTP/SOCKS5 listener does not automatically decode it.
 
-SS2022 uses the unmodified official Rust library; its known empty-first-write/server-first and padding risks remain documented in the [Shadowsocks contract](docs/outbounds.md#shadowsocks-2022).
+VMess, VLESS, Trojan and AnyTLS support ShadowTLS v3 or JLS on their supported TCP carriers; VMess and Trojan also support REALITY. These modes follow the [shared stream security constraints](docs/outbounds.md#流式安全身份), including transport exclusions and mutually exclusive identities.
+
+Standard TLS connections support certificate verification and SHA-256 certificate pins. Applicable TCP TLS paths can use Chrome, Firefox, Safari or iOS ClientHello templates; `client-fingerprint` is independent of the certificate `fingerprint`. See [TLS profiles and certificate policy](docs/tls-client-fingerprint.md) for the exact names and combinations. These features do not promise indistinguishability from a browser or unrestricted protocol combinations.
+
+SS2022 uses the unmodified official Rust crypto and codecs with Vole-owned initialized padding and server-first handling. See the [Shadowsocks contract](docs/outbounds.md#shadowsocks-2022).
 
 ## Mihomo-style configuration
 
@@ -70,13 +80,13 @@ rules:
   - MATCH,Proxy
 ```
 
-Replace the example endpoint and credentials. GeoSite/GeoIP rules require the corresponding assets under `<dataDir>/geodata`; missing assets leave those rule types unavailable. See the [complete configuration reference](docs/config.yaml) and [GeoData behavior](docs/geodata.md).
+Replace the example endpoint and credentials. GeoSite/DAT/ASN assets use `<dataDir>/geodata`; the default GeoIP mode uses a country MMDB in `<dataDir>` (`geodata-mode: true` selects DAT); missing required assets are downloaded through the configured route, and affected rules remain unavailable until loading succeeds. See the [complete configuration reference](docs/config.yaml) and [GeoData behavior](docs/geodata.md).
 
 `mixed-port` shares one TCP port between HTTP and SOCKS5 and enables SOCKS5 UDP on the same port. `allow-lan` controls binding independently of `authentication`: omitting `authentication` or using `[]` allows unauthenticated access on either loopback or wildcard addresses; configured credentials are checked by both HTTP and SOCKS5. Top-level `port`, `socks-port`, `udp` and `listeners` are rejected; proxy-node `port` and `udp` keep their outbound meanings.
 
-Compatibility is scoped to documented fields and behavior, not arbitrary Mihomo configurations. Groups currently support static `select`; DNS nameservers use literal IPs over UDP/TCP. Providers, automatic group selection, encrypted DNS and fake-IP are outside the current feature set. Unknown fields and invalid combinations are rejected rather than silently ignored; Vole-specific semantics are called out in the relevant contracts.
+Compatibility covers the documented subset of Mihomo fields. Unknown fields and unsupported combinations are rejected. See [current compatibility scope](docs/mihomo-compatibility.md) and the individual contracts for platform and protocol limits.
 
-Library hosts start an instance with inline `configYaml`; TUN device, file descriptor, MTU, DNS interception and UDP timeout belong to the `tun` configuration. Platform callbacks remain runtime-local. The CLI sends options through the same Invoke API, whose foreground operation reads the file selected by `-f`. Vole leaves interface addresses, DNS and system routes to the host.
+Library hosts start an instance with inline `configYaml`; TUN device, file descriptor, MTU, DNS interception and UDP timeout belong to the `tun` configuration. Platform callbacks remain runtime-local. The CLI sends options through the same Invoke API, whose foreground operation reads the file selected by `-f`. Linux core-owned TUN can configure automatic routing and systemd-resolved DNS; borrowed descriptors and App platform networks remain host-owned.
 
 ## CLI
 
@@ -97,12 +107,12 @@ vole -t -f ./config.yaml
 | iOS / macOS | Host-provided utun file descriptor; macOS can also open/create a native utun |
 | tvOS 17+ | Host-provided utun file descriptor; ARM64 device and simulator targets |
 | Android | `VpnService` file descriptor with outbound socket protection |
-| Linux | Real single-queue raw-IP TUN from a borrowed fd or a core-opened device; the host owns system network configuration |
+| Linux | Real single-queue raw-IP TUN from a borrowed fd or a core-opened device; core-owned Linux TUN supports automatic routes and system DNS |
 | Windows | Mutually exclusive `windows-wintun` desktop and `windows-uwp` packaged Provider/Session Host builds sharing the core |
 
-Vole provides native libraries and a foreground CLI; platform hosts still own system network configuration. Unix hosts own the original TUN descriptor; Vole uses and closes its own duplicate. Apple's public packetFlow API does not guarantee raw-fd access, so actual Network Extension integration and device validation remain host responsibilities. See [TUN integration](docs/tun-platform.md) and [platform acceptance boundaries](docs/acceptance.md).
+Vole provides native libraries and a foreground CLI. Apple, Android and Windows hosts own system network configuration and application lifecycle; Linux core-owned TUN additionally supports automatic routes and system DNS. Unix hosts own the original TUN descriptor; Vole uses and closes its own duplicate. Apple's public packetFlow API does not guarantee raw-fd access, so actual Network Extension integration and device validation remain host responsibilities. See [TUN integration](docs/tun-platform.md) and [platform acceptance boundaries](docs/acceptance.md).
 
-Desktop Wintun loads a host-provided `wintun.dll` from the process executable's directory. The host configures interface addresses, DNS, routes and physical egress; Windows Wintun device validation is separate from the existing packaged VPN results. See [CLI usage and tag releases](docs/cli.md) for command-line delivery.
+Desktop Wintun loads a host-provided `wintun.dll` from the process executable's directory. The host configures interface addresses, DNS, routes and physical egress; Windows Wintun and packaged UWP require separate device validation. See [CLI usage and tag releases](docs/cli.md) for command-line delivery.
 
 The cross-platform C ABI accepts JSON requests through Invoke API:
 
@@ -113,19 +123,11 @@ void VoleFree(char *response);
 
 One public instance follows `initialize → createInstance → start(configYaml) → stop → destroyInstance`; preparation is internal to `start`. `validateConfig` requires no initialization. The CLI uses the explicit foreground Invoke operation for files, environment defaults, signals and cleanup. The API also provides state queries, GeoData status and delay measurement. See [Invoke API](docs/invoke-api.md), [Controller API](docs/controller-api.md) and the [Windows integration example](example/windows-uwp/README.md).
 
-## Benchmark
-
-[**Vole / Mihomo TUN benchmark**](https://github.com/YuanDevTeam/container-benchmark) contains the reproducible setup, measured results and comparison charts for both cores under the same native Linux TUN environment.
-
-The benchmark project also owns protocol interoperability (`interop`) and memory-pressure runs (`stress`), with an explicit `--source vole=PATH` checkout. Vole's own scripts only compile core and platform artifacts.
-
-Workloads, input assets and measured results are maintained in the benchmark project.
-See [acceptance boundaries](docs/acceptance.md) for the scope of build, network and device validation.
-
 ## Documentation
 
 - [Documentation index](docs/README.md)
 - [Configuration reference](docs/config.yaml)
+- [Mihomo compatibility scope](docs/mihomo-compatibility.md)
 - [Core and platform builds](scripts/README.md)
 - [CLI usage and tag releases](docs/cli.md)
 - [Core regression tests](tests/README.md)
@@ -137,7 +139,11 @@ See [acceptance boundaries](docs/acceptance.md) for the scope of build, network
 Vole builds on and learns from public dependencies, protocol implementations and platform references:
 
 - TUN dependencies: the local [`vole-netstack`](crates/vole-netstack/README.md) uses [smoltcp](https://github.com/smoltcp-rs/smoltcp); Unix and Windows Wintun packet I/O use [tun-rs](https://github.com/tun-rs/tun-rs) (Apache-2.0).
+- Provider case mapping uses Rust's standard Unicode case conversion through a bounded adapter.
+- WireGuard: [boringtun](https://github.com/cloudflare/boringtun) (BSD-3-Clause), without host-device, FFI or JNI features.
 - [Wintun](https://www.wintun.net/): the runtime DLL is supplied by the host, not bundled. The upstream [API header](https://github.com/tun-rs/tun-rs/blob/2.8.11/src/platform/windows/tun/wintun.h) included by tun-rs is copyright 2018–2021 WireGuard LLC, licensed `GPL-2.0 OR MIT`; distribution of the linked API bindings must retain its copyright and MIT alternative license notice.
+- Offline archives: [sevenz-rust2](https://github.com/hasenbanck/sevenz-rust2) and [lzma-rust2](https://github.com/hasenbanck/lzma-rust2) (Apache-2.0), used through a bounded member reader.
+- Name expressions: [fancy-regex](https://github.com/fancy-regex/fancy-regex) (MIT), used only for bounded provider/group lookaround and backreferences.
 - Networking and routing references: [clash-rs](https://github.com/Watfaq/clash-rs), [netstack-smoltcp](https://github.com/cavivie/netstack-smoltcp), [Mihomo](https://github.com/MetaCubeX/mihomo), [Xray-core](https://github.com/XTLS/Xray-core) and [Leaf](https://github.com/eycorsican/leaf). These reference projects are not netstack dependencies.
 - TLS and Shadowsocks: [rustls](https://github.com/rustls/rustls), [boring](https://github.com/cloudflare/boring), [BoringSSL](https://boringssl.googlesource.com/boringssl/) and [shadowsocks-rust](https://github.com/shadowsocks/shadowsocks-rust). Derived replay-window code retains its [MIT notices](src/outbound/shadowsocks/packet_window.rs).
 - Windows integration: [windows-rs](https://github.com/microsoft/windows-rs), [UWP VPN Plugin Sample](https://github.com/microsoft/UwpVpnPluginSample), [wireguard-uwp-rs](https://github.com/luqmana/wireguard-uwp-rs), [Maple](https://github.com/YtFlow/Maple) and [YtFlowCore](https://github.com/YtFlow/YtFlowCore).
diff --git a/crates/vole-blake3-raw/Cargo.toml b/crates/vole-blake3-raw/Cargo.toml
index 9ae31fc..3680e59 100644
--- a/crates/vole-blake3-raw/Cargo.toml
+++ b/crates/vole-blake3-raw/Cargo.toml
@@ -4,9 +4,10 @@ version = "0.1.0"
 edition = "2024"
 license = "MIT"
 publish = false
+links = "blake3"
 
 [build-dependencies]
-cc = "=1.5.1"
+cc = "=1.11.0"
 
 [dev-dependencies]
 blake3 = "=1.8.7"
diff --git a/crates/vole-blake3-raw/README.md b/crates/vole-blake3-raw/README.md
index c66357b..cac3c36 100644
--- a/crates/vole-blake3-raw/README.md
+++ b/crates/vole-blake3-raw/README.md
@@ -4,57 +4,70 @@ Private workspace crate for the byte-string DeriveKey used on the VLESS
 Encryption wire. One public function accepts two byte slices and returns a
 32-byte key. It performs no allocation, IO, runtime loading, or TLS operation.
 Callers own input/output secrets and their erasure policy. The C adapter clears
-its hasher; it cannot guarantee erasure of upstream internal temporaries.
-
-The official Rust API takes `&str`; arbitrary binary protocol contexts cannot be
-converted to UTF-8, hex, or base64 without changing the derivation. The official
-C `blake3_hasher_init_derive_key_raw` is used directly. Rust does not mirror the
-C hasher layout or implement a compression/KDF algorithm.
-
-This reproduces an existing protocol, not a new cryptographic recommendation:
-BLAKE3's authors recommend a fixed, globally unique application-specific context,
-and caution against dynamic contexts. Compatibility does not establish the
-security of VLESS Encryption's protocol design.
-
-## Source and build
-
-The five `vendor/blake3*` files are byte-for-byte copies from official
-[BLAKE3 1.8.7](https://github.com/BLAKE3-team/BLAKE3/tree/1.8.7/c), commit
-`f3149ec5bb5449af877ba20377a11008ff499fa2` (latest stable checked 2026-09-26).
-Archive SHA-256: `c6782a28842b1c0478524ac06a4f2ede784038ee298d6e2162c0b089c4306a3c`.
-Upstream offers CC0-1.0, Apache-2.0, or Apache-2.0 WITH LLVM-exception; all three
-license texts are preserved in `vendor/`. Vendored source is used under
-Apache-2.0 WITH LLVM-exception. Vole-owned adapter/build/Rust code is MIT.
-
-| File | SHA-256 |
-| --- | --- |
-| blake3.c | b118ddf7cf9e6e5ef3fded72dcb1acf9dfdc4ea923cbe4605900ad6ee9afe1af |
-| blake3.h | 81bbb11ad1909341565dce4914cc0e5c29718eca27e6950b28f9226a91aaf8c5 |
-| blake3_impl.h | d388dca3574602c8849805ea3c8c0a12d082ac0e428756f305e111942f099af4 |
-| blake3_dispatch.c | 134f21550138c0af6312925c988aeee35df287e4119e8ad1d206fccdb2238fe3 |
-| blake3_portable.c | 2bc25b0dad67b4329d0b49cfa075ab2b0d04e424addbddc4e9c389c52a192524 |
-
-`build.rs` compiles these local files with official portable-only switches and
-compile-time symbol prefixes. It never accesses research checkouts, Cargo source
-caches, or the network. No bindgen, SIMD implementation, or fork is introduced.
-Latest stable `cc` 1.5.1 is selected explicitly. Upgrades require rechecking the
-official release, replacing unchanged files, updating provenance and hashes,
-and rerunning vectors and target builds.
+its hasher with volatile stores; it cannot guarantee erasure of upstream
+internal temporaries.
 
-## Check
+The official Rust 1.8.7 derive API takes `&str`. Arbitrary binary protocol
+contexts may contain invalid UTF-8, so conversion to UTF-8, hex or base64 would
+change the derivation. NUL itself is valid UTF-8 and can occur in a Rust string.
+The official C `blake3_hasher_init_derive_key_raw` accepts a pointer and length.
+Rust does not mirror the C hasher layout or implement a compression/KDF algorithm.
+
+This reproduces an existing protocol. BLAKE3's authors recommend a fixed,
+globally unique application-specific context; wire compatibility alone does
+not establish the security of VLESS Encryption's protocol design.
+
+## Dependency and build
+
+The implementation is official [BLAKE3 1.8.7](https://github.com/BLAKE3-team/BLAKE3/tree/1.8.7/c),
+installed as a static library through the official
+[vcpkg port](https://github.com/microsoft/vcpkg/tree/e456309491fd875487bf02b8a0dca76c1b1b00cc/ports/blake3).
+[The manifest](../../scripts/native/blake3/vcpkg.json) locks the registry commit
+and exact port version. vcpkg manages release acquisition, checksum verification,
+its official Windows ARM patch and upstream license texts in the dependency cache.
+Vole-owned adapter/build/Rust code and package configuration are MIT.
+
+There is no bundled BLAKE3 source. `build.rs` compiles only `src/derive.c` and
+links the supplied static archive. It never downloads dependencies or searches
+Cargo source caches. Platform build scripts prepare the dependency automatically;
+see [build instructions](../../scripts/README.md).
+
+The Vole-owned package triplet sets compile-time `vole_c_blake3_*` names for all
+C symbols, keeping the official source and port unchanged. This prevents
+collisions with the official Rust crate's native SIMD callbacks in the same
+Core or test executable. ARM retains official NEON; x86 uses the official C
+intrinsics mode so compiler macros also rename SIMD exports. Package upgrades
+require reviewing the upstream symbol set and rerunning vectors and target builds.
+
+For direct Cargo use, provide absolute public include and static library directories:
 
 ```sh
+export VOLE_BLAKE3_INCLUDE_DIR=/absolute/native-package/include
+export VOLE_BLAKE3_LIB_DIR=/absolute/native-package/lib
 cargo test --locked -p vole-blake3-raw
 ```
 
-This checks a primitive, not the Encryption handshake, ticket authentication,
-runtime ownership, platform integration, or end-to-end Encryption acceptance.
+Native builds accept those two variables. Cross builds require target-specific
+pairs such as `VOLE_BLAKE3_INCLUDE_DIR_AARCH64_APPLE_IOS` and
+`VOLE_BLAKE3_LIB_DIR_AARCH64_APPLE_IOS`; target-specific paths take precedence.
+The archive must be the matching namespaced static package, built for the same
+architecture, SDK/API and CRT; Unix shared-library consumers require PIC.
+The public header must declare version 1.8.7. Missing paths, a wrong header
+version or a missing archive fail closed. Cargo declares this native identity
+with `links = "blake3"`.
+
+## Check
+
+The four memory-only tests verify the linked C library version, arbitrary binary
+contexts, independent vectors and coexistence with the official Rust crate.
+They check a primitive; Encryption handshake, ticket authentication, runtime
+ownership and platform behavior need their own tests.
 
-The binary-context fixture has 52 values generated with the independent
+The fixture has 52 values generated with the independent
 `github.com/metacubex/blake3 v0.1.0` implementation used by Mihomo, using Go 1.27.1.
 Its SHA-256 is `16fa3198a0a6adad7de4df74010f1625b72a445991e8554842c0b12bd070b08d`.
-The generator and Go module lock are in `tests/generator/`; run `go run .` there
-to reproduce the JSON on stdout (not part of the Rust build). Inputs contain
-invalid UTF-8 and NUL and cover 64/1024-byte boundaries and protocol contexts up
-to 17005 bytes. UTF-8 cases also link and compare the official Rust crate in the
-same test executable.
+The generator and Go module lock are in `tests/generator/`; `go run .` reproduces
+the JSON on stdout and is not part of the Rust build. Inputs contain invalid
+UTF-8 and NUL and cover 64/1024-byte boundaries and wire contexts up to 17005
+bytes. UTF-8 cases also compare the official Rust derive interface in the same
+test executable.
diff --git a/crates/vole-blake3-raw/build.rs b/crates/vole-blake3-raw/build.rs
index 7d36ec4..36a8ad0 100644
--- a/crates/vole-blake3-raw/build.rs
+++ b/crates/vole-blake3-raw/build.rs
@@ -1,46 +1,76 @@
+use std::{env, fs, path::PathBuf};
+
+const VERSION: &str = "1.8.7";
+
+fn dependency_dir(name: &str, target: &str, host: &str) -> PathBuf {
+    let scoped = format!("{name}_{}", target.to_uppercase().replace('-', "_"));
+    println!("cargo:rerun-if-env-changed={scoped}");
+    println!("cargo:rerun-if-env-changed={name}");
+    let value = env::var_os(&scoped)
+        .or_else(|| (target == host).then(|| env::var_os(name)).flatten())
+        .unwrap_or_else(|| {
+            panic!(
+                "set {scoped} to the absolute directory of the target's installed official BLAKE3 {VERSION} static package; native builds also accept {name}"
+            )
+        });
+    let path = PathBuf::from(value);
+    assert!(path.is_absolute(), "{scoped} must be an absolute path");
+    assert!(path.is_dir(), "{scoped} must name an existing directory");
+    // Preserve the native path spelling for MSVC's include and linker flags.
+    // Windows canonicalization adds a verbatim prefix that cl.exe rejects.
+    path
+}
+
 fn main() {
-    let mut build = cc::Build::new();
-    build
-        .include("vendor")
+    let target = env::var("TARGET").expect("Cargo TARGET");
+    let host = env::var("HOST").expect("Cargo HOST");
+    let include = dependency_dir("VOLE_BLAKE3_INCLUDE_DIR", &target, &host);
+    let lib = dependency_dir("VOLE_BLAKE3_LIB_DIR", &target, &host);
+    let header = include.join("blake3.h");
+    let header_text = fs::read_to_string(&header).expect("read installed public blake3.h");
+    let expected_version = format!("\"{VERSION}\"");
+    assert!(
+        header_text.lines().any(|line| {
+            let mut fields = line.split_whitespace();
+            fields.next() == Some("#define")
+                && fields.next() == Some("BLAKE3_VERSION_STRING")
+                && fields.next() == Some(expected_version.as_str())
+        }),
+        "installed blake3.h must declare BLAKE3_VERSION_STRING {VERSION}"
+    );
+    let archive_name = if target.ends_with("-msvc") {
+        "blake3.lib"
+    } else {
+        "libblake3.a"
+    };
+    let archive = lib.join(archive_name);
+    assert!(
+        archive.is_file(),
+        "missing static BLAKE3 archive {archive_name}"
+    );
+
+    // Only this Vole-owned adapter is compiled here. Package management owns
+    // the public header and archive; this build never discovers or downloads C.
+    let mut adapter = cc::Build::new();
+    adapter
+        .include(&include)
         .file("src/derive.c")
-        .file("vendor/blake3.c")
-        .file("vendor/blake3_dispatch.c")
-        .file("vendor/blake3_portable.c")
         .std("c11")
-        .define("BLAKE3_NO_SSE2", None)
-        .define("BLAKE3_NO_SSE41", None)
-        .define("BLAKE3_NO_AVX2", None)
-        .define("BLAKE3_NO_AVX512", None)
-        .define("BLAKE3_USE_NEON", "0")
-        .define("BLAKE3_API", "")
-        .define("BLAKE3_PRIVATE", "")
         .flag_if_supported("-fvisibility=hidden");
-
-    // Prefix at compilation, never by modifying the vendored official source.
-    // The regular Rust blake3 crate can link into the same final executable.
+    // Match the external package's compile-time namespace without changing
+    // upstream's public header or implementation. This is required when the
+    // official Rust crate also contributes its native SIMD callbacks.
     for symbol in [
-        "blake3_version",
-        "blake3_hasher_init",
-        "blake3_hasher_init_keyed",
-        "blake3_hasher_init_derive_key",
         "blake3_hasher_init_derive_key_raw",
         "blake3_hasher_update",
         "blake3_hasher_finalize",
-        "blake3_hasher_finalize_seek",
-        "blake3_hasher_reset",
-        "blake3_compress_subtree_wide",
-        "blake3_compress_in_place",
-        "blake3_compress_xof",
-        "blake3_xof_many",
-        "blake3_hash_many",
-        "blake3_simd_degree",
-        "blake3_compress_in_place_portable",
-        "blake3_compress_xof_portable",
-        "blake3_hash_many_portable",
     ] {
-        build.define(symbol, format!("vole_raw_{symbol}").as_str());
+        adapter.define(symbol, format!("vole_c_{symbol}").as_str());
     }
-    build.compile("vole_blake3_raw");
+    adapter.compile("vole_blake3_raw");
+    println!("cargo:rustc-link-search=native={}", lib.display());
+    println!("cargo:rustc-link-lib=static=blake3");
     println!("cargo:rerun-if-changed=src/derive.c");
-    println!("cargo:rerun-if-changed=vendor");
+    println!("cargo:rerun-if-changed={}", header.display());
+    println!("cargo:rerun-if-changed={}", archive.display());
 }
diff --git a/crates/vole-blake3-raw/src/derive.c b/crates/vole-blake3-raw/src/derive.c
index c335590..a220057 100644
--- a/crates/vole-blake3-raw/src/derive.c
+++ b/crates/vole-blake3-raw/src/derive.c
@@ -1,4 +1,4 @@
-/* Vole-owned one-shot adapter. The BLAKE3 implementation is unmodified. */
+/* Vole-owned one-shot adapter to the installed official BLAKE3 C API. */
 #include "blake3.h"
 
 void vole_blake3_raw_derive(const unsigned char *context, size_t context_len,
diff --git a/crates/vole-blake3-raw/tests/derive.rs b/crates/vole-blake3-raw/tests/derive.rs
index ecbfef0..de55ec6 100644
--- a/crates/vole-blake3-raw/tests/derive.rs
+++ b/crates/vole-blake3-raw/tests/derive.rs
@@ -1,5 +1,16 @@
 use vole_blake3_raw::derive_key;
 
+#[test]
+fn links_the_required_official_c_library_version() {
+    unsafe extern "C" {
+        #[link_name = "vole_c_blake3_version"]
+        fn blake3_version() -> *const std::ffi::c_char;
+    }
+    // SAFETY: the public API returns a static NUL-terminated version string.
+    let version = unsafe { std::ffi::CStr::from_ptr(blake3_version()) };
+    assert_eq!(version.to_bytes(), b"1.8.7");
+}
+
 #[test]
 fn derives_binary_context_without_utf8_conversion() {
     // Independent github.com/metacubex/blake3 v0.1.0 DeriveKey result.
diff --git a/crates/vole-blake3-raw/vendor/.gitattributes b/crates/vole-blake3-raw/vendor/.gitattributes
deleted file mode 100644
index 9852d38..0000000
--- a/crates/vole-blake3-raw/vendor/.gitattributes
+++ /dev/null
@@ -1,3 +0,0 @@
-# Preserve the official release bytes, including upstream whitespace.
-blake3_impl.h whitespace=-blank-at-eol
-LICENSE_A2LLVM whitespace=-blank-at-eof
diff --git a/crates/vole-blake3-raw/vendor/LICENSE_A2 b/crates/vole-blake3-raw/vendor/LICENSE_A2
deleted file mode 100644
index d512ca9..0000000
--- a/crates/vole-blake3-raw/vendor/LICENSE_A2
+++ /dev/null
@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2019 Jack O'Connor and Samuel Neves
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/crates/vole-blake3-raw/vendor/LICENSE_A2LLVM b/crates/vole-blake3-raw/vendor/LICENSE_A2LLVM
deleted file mode 100644
index 8d11bec..0000000
--- a/crates/vole-blake3-raw/vendor/LICENSE_A2LLVM
+++ /dev/null
@@ -1,219 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-    1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-    2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-    3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-    4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-    5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-    6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-    7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-    8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-    9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-    END OF TERMS AND CONDITIONS
-
-    APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-    Copyright 2019 Jack O'Connor and Samuel Neves
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-
-
----- LLVM Exceptions to the Apache 2.0 License ----
-
-As an exception, if, as a result of your compiling your source code, portions
-of this Software are embedded into an Object form of such source code, you
-may redistribute such embedded portions in such Object form without complying
-with the conditions of Sections 4(a), 4(b) and 4(d) of the License.
-
-In addition, if you combine or link compiled forms of this Software with
-software that is licensed under the GPLv2 ("Combined Software") and if a
-court of competent jurisdiction determines that the patent provision (Section
-3), the indemnity provision (Section 9) or other Section of the License
-conflicts with the conditions of the GPLv2, you may retroactively and
-prospectively choose to deem waived or otherwise exclude such Section(s) of
-the License, but only in their entirety and only with respect to the Combined
-Software.
-
diff --git a/crates/vole-blake3-raw/vendor/LICENSE_CC0 b/crates/vole-blake3-raw/vendor/LICENSE_CC0
deleted file mode 100644
index 0e259d4..0000000
--- a/crates/vole-blake3-raw/vendor/LICENSE_CC0
+++ /dev/null
@@ -1,121 +0,0 @@
-Creative Commons Legal Code
-
-CC0 1.0 Universal
-
-    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
-    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
-    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
-    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
-    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
-    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
-    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
-    HEREUNDER.
-
-Statement of Purpose
-
-The laws of most jurisdictions throughout the world automatically confer
-exclusive Copyright and Related Rights (defined below) upon the creator
-and subsequent owner(s) (each and all, an "owner") of an original work of
-authorship and/or a database (each, a "Work").
-
-Certain owners wish to permanently relinquish those rights to a Work for
-the purpose of contributing to a commons of creative, cultural and
-scientific works ("Commons") that the public can reliably and without fear
-of later claims of infringement build upon, modify, incorporate in other
-works, reuse and redistribute as freely as possible in any form whatsoever
-and for any purposes, including without limitation commercial purposes.
-These owners may contribute to the Commons to promote the ideal of a free
-culture and the further production of creative, cultural and scientific
-works, or to gain reputation or greater distribution for their Work in
-part through the use and efforts of others.
-
-For these and/or other purposes and motivations, and without any
-expectation of additional consideration or compensation, the person
-associating CC0 with a Work (the "Affirmer"), to the extent that he or she
-is an owner of Copyright and Related Rights in the Work, voluntarily
-elects to apply CC0 to the Work and publicly distribute the Work under its
-terms, with knowledge of his or her Copyright and Related Rights in the
-Work and the meaning and intended legal effect of CC0 on those rights.
-
-1. Copyright and Related Rights. A Work made available under CC0 may be
-protected by copyright and related or neighboring rights ("Copyright and
-Related Rights"). Copyright and Related Rights include, but are not
-limited to, the following:
-
-  i. the right to reproduce, adapt, distribute, perform, display,
-     communicate, and translate a Work;
- ii. moral rights retained by the original author(s) and/or performer(s);
-iii. publicity and privacy rights pertaining to a person's image or
-     likeness depicted in a Work;
- iv. rights protecting against unfair competition in regards to a Work,
-     subject to the limitations in paragraph 4(a), below;
-  v. rights protecting the extraction, dissemination, use and reuse of data
-     in a Work;
- vi. database rights (such as those arising under Directive 96/9/EC of the
-     European Parliament and of the Council of 11 March 1996 on the legal
-     protection of databases, and under any national implementation
-     thereof, including any amended or successor version of such
-     directive); and
-vii. other similar, equivalent or corresponding rights throughout the
-     world based on applicable law or treaty, and any national
-     implementations thereof.
-
-2. Waiver. To the greatest extent permitted by, but not in contravention
-of, applicable law, Affirmer hereby overtly, fully, permanently,
-irrevocably and unconditionally waives, abandons, and surrenders all of
-Affirmer's Copyright and Related Rights and associated claims and causes
-of action, whether now known or unknown (including existing as well as
-future claims and causes of action), in the Work (i) in all territories
-worldwide, (ii) for the maximum duration provided by applicable law or
-treaty (including future time extensions), (iii) in any current or future
-medium and for any number of copies, and (iv) for any purpose whatsoever,
-including without limitation commercial, advertising or promotional
-purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
-member of the public at large and to the detriment of Affirmer's heirs and
-successors, fully intending that such Waiver shall not be subject to
-revocation, rescission, cancellation, termination, or any other legal or
-equitable action to disrupt the quiet enjoyment of the Work by the public
-as contemplated by Affirmer's express Statement of Purpose.
-
-3. Public License Fallback. Should any part of the Waiver for any reason
-be judged legally invalid or ineffective under applicable law, then the
-Waiver shall be preserved to the maximum extent permitted taking into
-account Affirmer's express Statement of Purpose. In addition, to the
-extent the Waiver is so judged Affirmer hereby grants to each affected
-person a royalty-free, non transferable, non sublicensable, non exclusive,
-irrevocable and unconditional license to exercise Affirmer's Copyright and
-Related Rights in the Work (i) in all territories worldwide, (ii) for the
-maximum duration provided by applicable law or treaty (including future
-time extensions), (iii) in any current or future medium and for any number
-of copies, and (iv) for any purpose whatsoever, including without
-limitation commercial, advertising or promotional purposes (the
-"License"). The License shall be deemed effective as of the date CC0 was
-applied by Affirmer to the Work. Should any part of the License for any
-reason be judged legally invalid or ineffective under applicable law, such
-partial invalidity or ineffectiveness shall not invalidate the remainder
-of the License, and in such case Affirmer hereby affirms that he or she
-will not (i) exercise any of his or her remaining Copyright and Related
-Rights in the Work or (ii) assert any associated claims and causes of
-action with respect to the Work, in either case contrary to Affirmer's
-express Statement of Purpose.
-
-4. Limitations and Disclaimers.
-
- a. No trademark or patent rights held by Affirmer are waived, abandoned,
-    surrendered, licensed or otherwise affected by this document.
- b. Affirmer offers the Work as-is and makes no representations or
-    warranties of any kind concerning the Work, express, implied,
-    statutory or otherwise, including without limitation warranties of
-    title, merchantability, fitness for a particular purpose, non
-    infringement, or the absence of latent or other defects, accuracy, or
-    the present or absence of errors, whether or not discoverable, all to
-    the greatest extent permissible under applicable law.
- c. Affirmer disclaims responsibility for clearing rights of other persons
-    that may apply to the Work or any use thereof, including without
-    limitation any person's Copyright and Related Rights in the Work.
-    Further, Affirmer disclaims responsibility for obtaining any necessary
-    consents, permissions or other rights required for any use of the
-    Work.
- d. Affirmer understands and acknowledges that Creative Commons is not a
-    party to this document and has no duty or obligation with respect to
-    this CC0 or use of the Work.
diff --git a/crates/vole-blake3-raw/vendor/blake3.c b/crates/vole-blake3-raw/vendor/blake3.c
deleted file mode 100644
index 00f91f4..0000000
--- a/crates/vole-blake3-raw/vendor/blake3.c
+++ /dev/null
@@ -1,651 +0,0 @@
-#include <assert.h>
-#include <stdbool.h>
-#include <string.h>
-#include <stdint.h>
-
-#include "blake3.h"
-#include "blake3_impl.h"
-
-const char *blake3_version(void) { return BLAKE3_VERSION_STRING; }
-
-INLINE void chunk_state_init(blake3_chunk_state *self, const uint32_t key[8],
-                             uint8_t flags) {
-  memcpy(self->cv, key, BLAKE3_KEY_LEN);
-  self->chunk_counter = 0;
-  memset(self->buf, 0, BLAKE3_BLOCK_LEN);
-  self->buf_len = 0;
-  self->blocks_compressed = 0;
-  self->flags = flags;
-}
-
-INLINE void chunk_state_reset(blake3_chunk_state *self, const uint32_t key[8],
-                              uint64_t chunk_counter) {
-  memcpy(self->cv, key, BLAKE3_KEY_LEN);
-  self->chunk_counter = chunk_counter;
-  self->blocks_compressed = 0;
-  memset(self->buf, 0, BLAKE3_BLOCK_LEN);
-  self->buf_len = 0;
-}
-
-INLINE size_t chunk_state_len(const blake3_chunk_state *self) {
-  return (BLAKE3_BLOCK_LEN * (size_t)self->blocks_compressed) +
-         ((size_t)self->buf_len);
-}
-
-INLINE size_t chunk_state_fill_buf(blake3_chunk_state *self,
-                                   const uint8_t *input, size_t input_len) {
-  size_t take = BLAKE3_BLOCK_LEN - ((size_t)self->buf_len);
-  if (take > input_len) {
-    take = input_len;
-  }
-  uint8_t *dest = self->buf + ((size_t)self->buf_len);
-  memcpy(dest, input, take);
-  self->buf_len += (uint8_t)take;
-  return take;
-}
-
-INLINE uint8_t chunk_state_maybe_start_flag(const blake3_chunk_state *self) {
-  if (self->blocks_compressed == 0) {
-    return CHUNK_START;
-  } else {
-    return 0;
-  }
-}
-
-typedef struct {
-  uint32_t input_cv[8];
-  uint64_t counter;
-  uint8_t block[BLAKE3_BLOCK_LEN];
-  uint8_t block_len;
-  uint8_t flags;
-} output_t;
-
-INLINE output_t make_output(const uint32_t input_cv[8],
-                            const uint8_t block[BLAKE3_BLOCK_LEN],
-                            uint8_t block_len, uint64_t counter,
-                            uint8_t flags) {
-  output_t ret;
-  memcpy(ret.input_cv, input_cv, 32);
-  memcpy(ret.block, block, BLAKE3_BLOCK_LEN);
-  ret.block_len = block_len;
-  ret.counter = counter;
-  ret.flags = flags;
-  return ret;
-}
-
-// Chaining values within a given chunk (specifically the compress_in_place
-// interface) are represented as words. This avoids unnecessary bytes<->words
-// conversion overhead in the portable implementation. However, the hash_many
-// interface handles both user input and parent node blocks, so it accepts
-// bytes. For that reason, chaining values in the CV stack are represented as
-// bytes.
-INLINE void output_chaining_value(const output_t *self, uint8_t cv[32]) {
-  uint32_t cv_words[8];
-  memcpy(cv_words, self->input_cv, 32);
-  blake3_compress_in_place(cv_words, self->block, self->block_len,
-                           self->counter, self->flags);
-  store_cv_words(cv, cv_words);
-}
-
-INLINE void output_root_bytes(const output_t *self, uint64_t seek, uint8_t *out,
-                              size_t out_len) {
-  if (out_len == 0) {
-      return;
-  }
-  uint64_t output_block_counter = seek / 64;
-  size_t offset_within_block = seek % 64;
-  uint8_t wide_buf[64];
-  if(offset_within_block) {
-    blake3_compress_xof(self->input_cv, self->block, self->block_len, output_block_counter, self->flags | ROOT, wide_buf);
-    const size_t available_bytes = 64 - offset_within_block;
-    const size_t bytes = out_len > available_bytes ? available_bytes : out_len;
-    memcpy(out, wide_buf + offset_within_block, bytes);
-    out += bytes;
-    out_len -= bytes;
-    output_block_counter += 1;
-  }
-  if(out_len / 64) {
-    blake3_xof_many(self->input_cv, self->block, self->block_len, output_block_counter, self->flags | ROOT, out, out_len / 64);
-  }
-  output_block_counter += out_len / 64;
-  out += out_len & -64;
-  out_len -= out_len & -64;
-  if(out_len) {
-    blake3_compress_xof(self->input_cv, self->block, self->block_len, output_block_counter, self->flags | ROOT, wide_buf);
-    memcpy(out, wide_buf, out_len);
-  }
-}
-
-INLINE void chunk_state_update(blake3_chunk_state *self, const uint8_t *input,
-                               size_t input_len) {
-  if (self->buf_len > 0) {
-    size_t take = chunk_state_fill_buf(self, input, input_len);
-    input += take;
-    input_len -= take;
-    if (input_len > 0) {
-      blake3_compress_in_place(
-          self->cv, self->buf, BLAKE3_BLOCK_LEN, self->chunk_counter,
-          self->flags | chunk_state_maybe_start_flag(self));
-      self->blocks_compressed += 1;
-      self->buf_len = 0;
-      memset(self->buf, 0, BLAKE3_BLOCK_LEN);
-    }
-  }
-
-  while (input_len > BLAKE3_BLOCK_LEN) {
-    blake3_compress_in_place(self->cv, input, BLAKE3_BLOCK_LEN,
-                             self->chunk_counter,
-                             self->flags | chunk_state_maybe_start_flag(self));
-    self->blocks_compressed += 1;
-    input += BLAKE3_BLOCK_LEN;
-    input_len -= BLAKE3_BLOCK_LEN;
-  }
-
-  chunk_state_fill_buf(self, input, input_len);
-}
-
-INLINE output_t chunk_state_output(const blake3_chunk_state *self) {
-  uint8_t block_flags =
-      self->flags | chunk_state_maybe_start_flag(self) | CHUNK_END;
-  return make_output(self->cv, self->buf, self->buf_len, self->chunk_counter,
-                     block_flags);
-}
-
-INLINE output_t parent_output(const uint8_t block[BLAKE3_BLOCK_LEN],
-                              const uint32_t key[8], uint8_t flags) {
-  return make_output(key, block, BLAKE3_BLOCK_LEN, 0, flags | PARENT);
-}
-
-// Given some input larger than one chunk, return the number of bytes that
-// should go in the left subtree. This is the largest power-of-2 number of
-// chunks that leaves at least 1 byte for the right subtree.
-INLINE size_t left_subtree_len(size_t input_len) {
-  // Subtract 1 to reserve at least one byte for the right side. input_len
-  // should always be greater than BLAKE3_CHUNK_LEN.
-  size_t full_chunks = (input_len - 1) / BLAKE3_CHUNK_LEN;
-  return round_down_to_power_of_2(full_chunks) * BLAKE3_CHUNK_LEN;
-}
-
-// Use SIMD parallelism to hash up to MAX_SIMD_DEGREE chunks at the same time
-// on a single thread. Write out the chunk chaining values and return the
-// number of chunks hashed. These chunks are never the root and never empty;
-// those cases use a different codepath.
-INLINE size_t compress_chunks_parallel(const uint8_t *input, size_t input_len,
-                                       const uint32_t key[8],
-                                       uint64_t chunk_counter, uint8_t flags,
-                                       uint8_t *out) {
-#if defined(BLAKE3_TESTING)
-  assert(0 < input_len);
-  assert(input_len <= MAX_SIMD_DEGREE * BLAKE3_CHUNK_LEN);
-#endif
-
-  const uint8_t *chunks_array[MAX_SIMD_DEGREE];
-  size_t input_position = 0;
-  size_t chunks_array_len = 0;
-  while (input_len - input_position >= BLAKE3_CHUNK_LEN) {
-    chunks_array[chunks_array_len] = &input[input_position];
-    input_position += BLAKE3_CHUNK_LEN;
-    chunks_array_len += 1;
-  }
-
-  blake3_hash_many(chunks_array, chunks_array_len,
-                   BLAKE3_CHUNK_LEN / BLAKE3_BLOCK_LEN, key, chunk_counter,
-                   true, flags, CHUNK_START, CHUNK_END, out);
-
-  // Hash the remaining partial chunk, if there is one. Note that the empty
-  // chunk (meaning the empty message) is a different codepath.
-  if (input_len > input_position) {
-    uint64_t counter = chunk_counter + (uint64_t)chunks_array_len;
-    blake3_chunk_state chunk_state;
-    chunk_state_init(&chunk_state, key, flags);
-    chunk_state.chunk_counter = counter;
-    chunk_state_update(&chunk_state, &input[input_position],
-                       input_len - input_position);
-    output_t output = chunk_state_output(&chunk_state);
-    output_chaining_value(&output, &out[chunks_array_len * BLAKE3_OUT_LEN]);
-    return chunks_array_len + 1;
-  } else {
-    return chunks_array_len;
-  }
-}
-
-// Use SIMD parallelism to hash up to MAX_SIMD_DEGREE parents at the same time
-// on a single thread. Write out the parent chaining values and return the
-// number of parents hashed. (If there's an odd input chaining value left over,
-// return it as an additional output.) These parents are never the root and
-// never empty; those cases use a different codepath.
-INLINE size_t compress_parents_parallel(const uint8_t *child_chaining_values,
-                                        size_t num_chaining_values,
-                                        const uint32_t key[8], uint8_t flags,
-                                        uint8_t *out) {
-#if defined(BLAKE3_TESTING)
-  assert(2 <= num_chaining_values);
-  assert(num_chaining_values <= 2 * MAX_SIMD_DEGREE_OR_2);
-#endif
-
-  const uint8_t *parents_array[MAX_SIMD_DEGREE_OR_2];
-  size_t parents_array_len = 0;
-  while (num_chaining_values - (2 * parents_array_len) >= 2) {
-    parents_array[parents_array_len] =
-        &child_chaining_values[2 * parents_array_len * BLAKE3_OUT_LEN];
-    parents_array_len += 1;
-  }
-
-  blake3_hash_many(parents_array, parents_array_len, 1, key,
-                   0, // Parents always use counter 0.
-                   false, flags | PARENT,
-                   0, // Parents have no start flags.
-                   0, // Parents have no end flags.
-                   out);
-
-  // If there's an odd child left over, it becomes an output.
-  if (num_chaining_values > 2 * parents_array_len) {
-    memcpy(&out[parents_array_len * BLAKE3_OUT_LEN],
-           &child_chaining_values[2 * parents_array_len * BLAKE3_OUT_LEN],
-           BLAKE3_OUT_LEN);
-    return parents_array_len + 1;
-  } else {
-    return parents_array_len;
-  }
-}
-
-// The wide helper function returns (writes out) an array of chaining values
-// and returns the length of that array. The number of chaining values returned
-// is the dynamically detected SIMD degree, at most MAX_SIMD_DEGREE. Or fewer,
-// if the input is shorter than that many chunks. The reason for maintaining a
-// wide array of chaining values going back up the tree, is to allow the
-// implementation to hash as many parents in parallel as possible.
-//
-// As a special case when the SIMD degree is 1, this function will still return
-// at least 2 outputs. This guarantees that this function doesn't perform the
-// root compression. (If it did, it would use the wrong flags, and also we
-// wouldn't be able to implement extendable output.) Note that this function is
-// not used when the whole input is only 1 chunk long; that's a different
-// codepath.
-//
-// Why not just have the caller split the input on the first update(), instead
-// of implementing this special rule? Because we don't want to limit SIMD or
-// multi-threading parallelism for that update().
-size_t blake3_compress_subtree_wide(const uint8_t *input, size_t input_len,
-                                    const uint32_t key[8],
-                                    uint64_t chunk_counter, uint8_t flags,
-                                    uint8_t *out, bool use_tbb) {
-  // Note that the single chunk case does *not* bump the SIMD degree up to 2
-  // when it is 1. If this implementation adds multi-threading in the future,
-  // this gives us the option of multi-threading even the 2-chunk case, which
-  // can help performance on smaller platforms.
-  if (input_len <= blake3_simd_degree() * BLAKE3_CHUNK_LEN) {
-    return compress_chunks_parallel(input, input_len, key, chunk_counter, flags,
-                                    out);
-  }
-
-  // With more than simd_degree chunks, we need to recurse. Start by dividing
-  // the input into left and right subtrees. (Note that this is only optimal
-  // as long as the SIMD degree is a power of 2. If we ever get a SIMD degree
-  // of 3 or something, we'll need a more complicated strategy.)
-  size_t left_input_len = left_subtree_len(input_len);
-  size_t right_input_len = input_len - left_input_len;
-  const uint8_t *right_input = &input[left_input_len];
-  uint64_t right_chunk_counter =
-      chunk_counter + (uint64_t)(left_input_len / BLAKE3_CHUNK_LEN);
-
-  // Make space for the child outputs. Here we use MAX_SIMD_DEGREE_OR_2 to
-  // account for the special case of returning 2 outputs when the SIMD degree
-  // is 1.
-  uint8_t cv_array[2 * MAX_SIMD_DEGREE_OR_2 * BLAKE3_OUT_LEN];
-  size_t degree = blake3_simd_degree();
-  if (left_input_len > BLAKE3_CHUNK_LEN && degree == 1) {
-    // The special case: We always use a degree of at least two, to make
-    // sure there are two outputs. Except, as noted above, at the chunk
-    // level, where we allow degree=1. (Note that the 1-chunk-input case is
-    // a different codepath.)
-    degree = 2;
-  }
-  uint8_t *right_cvs = &cv_array[degree * BLAKE3_OUT_LEN];
-
-  // Recurse!
-  size_t left_n = SIZE_MAX;
-  size_t right_n = SIZE_MAX;
-
-#if defined(BLAKE3_USE_TBB)
-  blake3_compress_subtree_wide_join_tbb(
-      key, flags, use_tbb,
-      // left-hand side
-      input, left_input_len, chunk_counter, cv_array, &left_n,
-      // right-hand side
-      right_input, right_input_len, right_chunk_counter, right_cvs, &right_n);
-#else
-  left_n = blake3_compress_subtree_wide(
-      input, left_input_len, key, chunk_counter, flags, cv_array, use_tbb);
-  right_n = blake3_compress_subtree_wide(right_input, right_input_len, key,
-                                         right_chunk_counter, flags, right_cvs,
-                                         use_tbb);
-#endif // BLAKE3_USE_TBB
-
-  // The special case again. If simd_degree=1, then we'll have left_n=1 and
-  // right_n=1. Rather than compressing them into a single output, return
-  // them directly, to make sure we always have at least two outputs.
-  if (left_n == 1) {
-    memcpy(out, cv_array, 2 * BLAKE3_OUT_LEN);
-    return 2;
-  }
-
-  // Otherwise, do one layer of parent node compression.
-  size_t num_chaining_values = left_n + right_n;
-  return compress_parents_parallel(cv_array, num_chaining_values, key, flags,
-                                   out);
-}
-
-// Hash a subtree with compress_subtree_wide(), and then condense the resulting
-// list of chaining values down to a single parent node. Don't compress that
-// last parent node, however. Instead, return its message bytes (the
-// concatenated chaining values of its children). This is necessary when the
-// first call to update() supplies a complete subtree, because the topmost
-// parent node of that subtree could end up being the root. It's also necessary
-// for extended output in the general case.
-//
-// As with compress_subtree_wide(), this function is not used on inputs of 1
-// chunk or less. That's a different codepath.
-INLINE void
-compress_subtree_to_parent_node(const uint8_t *input, size_t input_len,
-                                const uint32_t key[8], uint64_t chunk_counter,
-                                uint8_t flags, uint8_t out[2 * BLAKE3_OUT_LEN],
-                                bool use_tbb) {
-#if defined(BLAKE3_TESTING)
-  assert(input_len > BLAKE3_CHUNK_LEN);
-#endif
-
-  uint8_t cv_array[MAX_SIMD_DEGREE_OR_2 * BLAKE3_OUT_LEN];
-  size_t num_cvs = blake3_compress_subtree_wide(input, input_len, key,
-                                                chunk_counter, flags, cv_array, use_tbb);
-  assert(num_cvs <= MAX_SIMD_DEGREE_OR_2);
-  // The following loop never executes when MAX_SIMD_DEGREE_OR_2 is 2, because
-  // as we just asserted, num_cvs will always be <=2 in that case. But GCC
-  // (particularly GCC 8.5) can't tell that it never executes, and if NDEBUG is
-  // set then it emits incorrect warnings here. We tried a few different
-  // hacks to silence these, but in the end our hacks just produced different
-  // warnings (see https://github.com/BLAKE3-team/BLAKE3/pull/380). Out of
-  // desperation, we ifdef out this entire loop when we know it's not needed.
-#if MAX_SIMD_DEGREE_OR_2 > 2
-  // If MAX_SIMD_DEGREE_OR_2 is greater than 2 and there's enough input,
-  // compress_subtree_wide() returns more than 2 chaining values. Condense
-  // them into 2 by forming parent nodes repeatedly.
-  uint8_t out_array[MAX_SIMD_DEGREE_OR_2 * BLAKE3_OUT_LEN / 2];
-  while (num_cvs > 2) {
-    num_cvs =
-        compress_parents_parallel(cv_array, num_cvs, key, flags, out_array);
-    memcpy(cv_array, out_array, num_cvs * BLAKE3_OUT_LEN);
-  }
-#endif
-  memcpy(out, cv_array, 2 * BLAKE3_OUT_LEN);
-}
-
-INLINE void hasher_init_base(blake3_hasher *self, const uint32_t key[8],
-                             uint8_t flags) {
-  memcpy(self->key, key, BLAKE3_KEY_LEN);
-  chunk_state_init(&self->chunk, key, flags);
-  self->cv_stack_len = 0;
-}
-
-void blake3_hasher_init(blake3_hasher *self) { hasher_init_base(self, IV, 0); }
-
-void blake3_hasher_init_keyed(blake3_hasher *self,
-                              const uint8_t key[BLAKE3_KEY_LEN]) {
-  uint32_t key_words[8];
-  load_key_words(key, key_words);
-  hasher_init_base(self, key_words, KEYED_HASH);
-}
-
-void blake3_hasher_init_derive_key_raw(blake3_hasher *self, const void *context,
-                                       size_t context_len) {
-  blake3_hasher context_hasher;
-  hasher_init_base(&context_hasher, IV, DERIVE_KEY_CONTEXT);
-  blake3_hasher_update(&context_hasher, context, context_len);
-  uint8_t context_key[BLAKE3_KEY_LEN];
-  blake3_hasher_finalize(&context_hasher, context_key, BLAKE3_KEY_LEN);
-  uint32_t context_key_words[8];
-  load_key_words(context_key, context_key_words);
-  hasher_init_base(self, context_key_words, DERIVE_KEY_MATERIAL);
-}
-
-void blake3_hasher_init_derive_key(blake3_hasher *self, const char *context) {
-  blake3_hasher_init_derive_key_raw(self, context, strlen(context));
-}
-
-// As described in hasher_push_cv() below, we do "lazy merging", delaying
-// merges until right before the next CV is about to be added. This is
-// different from the reference implementation. Another difference is that we
-// aren't always merging 1 chunk at a time. Instead, each CV might represent
-// any power-of-two number of chunks, as long as the smaller-above-larger stack
-// order is maintained. Instead of the "count the trailing 0-bits" algorithm
-// described in the spec, we use a "count the total number of 1-bits" variant
-// that doesn't require us to retain the subtree size of the CV on top of the
-// stack. The principle is the same: each CV that should remain in the stack is
-// represented by a 1-bit in the total number of chunks (or bytes) so far.
-INLINE void hasher_merge_cv_stack(blake3_hasher *self, uint64_t total_len) {
-  size_t post_merge_stack_len = (size_t)popcnt(total_len);
-  while (self->cv_stack_len > post_merge_stack_len) {
-    uint8_t *parent_node =
-        &self->cv_stack[(self->cv_stack_len - 2) * BLAKE3_OUT_LEN];
-    output_t output = parent_output(parent_node, self->key, self->chunk.flags);
-    output_chaining_value(&output, parent_node);
-    self->cv_stack_len -= 1;
-  }
-}
-
-// In reference_impl.rs, we merge the new CV with existing CVs from the stack
-// before pushing it. We can do that because we know more input is coming, so
-// we know none of the merges are root.
-//
-// This setting is different. We want to feed as much input as possible to
-// compress_subtree_wide(), without setting aside anything for the chunk_state.
-// If the user gives us 64 KiB, we want to parallelize over all 64 KiB at once
-// as a single subtree, if at all possible.
-//
-// This leads to two problems:
-// 1) This 64 KiB input might be the only call that ever gets made to update.
-//    In this case, the root node of the 64 KiB subtree would be the root node
-//    of the whole tree, and it would need to be ROOT finalized. We can't
-//    compress it until we know.
-// 2) This 64 KiB input might complete a larger tree, whose root node is
-//    similarly going to be the root of the whole tree. For example, maybe
-//    we have 196 KiB (that is, 128 + 64) hashed so far. We can't compress the
-//    node at the root of the 256 KiB subtree until we know how to finalize it.
-//
-// The second problem is solved with "lazy merging". That is, when we're about
-// to add a CV to the stack, we don't merge it with anything first, as the
-// reference impl does. Instead we do merges using the *previous* CV that was
-// added, which is sitting on top of the stack, and we put the new CV
-// (unmerged) on top of the stack afterwards. This guarantees that we never
-// merge the root node until finalize().
-//
-// Solving the first problem requires an additional tool,
-// compress_subtree_to_parent_node(). That function always returns the top
-// *two* chaining values of the subtree it's compressing. We then do lazy
-// merging with each of them separately, so that the second CV will always
-// remain unmerged. (That also helps us support extendable output when we're
-// hashing an input all-at-once.)
-INLINE void hasher_push_cv(blake3_hasher *self, uint8_t new_cv[BLAKE3_OUT_LEN],
-                           uint64_t chunk_counter) {
-  hasher_merge_cv_stack(self, chunk_counter);
-  memcpy(&self->cv_stack[self->cv_stack_len * BLAKE3_OUT_LEN], new_cv,
-         BLAKE3_OUT_LEN);
-  self->cv_stack_len += 1;
-}
-
-INLINE void blake3_hasher_update_base(blake3_hasher *self, const void *input,
-                                      size_t input_len, bool use_tbb) {
-  // Explicitly checking for zero avoids causing UB by passing a null pointer
-  // to memcpy. This comes up in practice with things like:
-  //   std::vector<uint8_t> v;
-  //   blake3_hasher_update(&hasher, v.data(), v.size());
-  if (input_len == 0) {
-    return;
-  }
-
-  const uint8_t *input_bytes = (const uint8_t *)input;
-
-  // If we have some partial chunk bytes in the internal chunk_state, we need
-  // to finish that chunk first.
-  if (chunk_state_len(&self->chunk) > 0) {
-    size_t take = BLAKE3_CHUNK_LEN - chunk_state_len(&self->chunk);
-    if (take > input_len) {
-      take = input_len;
-    }
-    chunk_state_update(&self->chunk, input_bytes, take);
-    input_bytes += take;
-    input_len -= take;
-    // If we've filled the current chunk and there's more coming, finalize this
-    // chunk and proceed. In this case we know it's not the root.
-    if (input_len > 0) {
-      output_t output = chunk_state_output(&self->chunk);
-      uint8_t chunk_cv[32];
-      output_chaining_value(&output, chunk_cv);
-      hasher_push_cv(self, chunk_cv, self->chunk.chunk_counter);
-      chunk_state_reset(&self->chunk, self->key, self->chunk.chunk_counter + 1);
-    } else {
-      return;
-    }
-  }
-
-  // Now the chunk_state is clear, and we have more input. If there's more than
-  // a single chunk (so, definitely not the root chunk), hash the largest whole
-  // subtree we can, with the full benefits of SIMD (and maybe in the future,
-  // multi-threading) parallelism. Two restrictions:
-  // - The subtree has to be a power-of-2 number of chunks. Only subtrees along
-  //   the right edge can be incomplete, and we don't know where the right edge
-  //   is going to be until we get to finalize().
-  // - The subtree must evenly divide the total number of chunks up until this
-  //   point (if total is not 0). If the current incomplete subtree is only
-  //   waiting for 1 more chunk, we can't hash a subtree of 4 chunks. We have
-  //   to complete the current subtree first.
-  // Because we might need to break up the input to form powers of 2, or to
-  // evenly divide what we already have, this part runs in a loop.
-  while (input_len > BLAKE3_CHUNK_LEN) {
-    size_t subtree_len = round_down_to_power_of_2(input_len);
-    uint64_t count_so_far = self->chunk.chunk_counter * BLAKE3_CHUNK_LEN;
-    // Shrink the subtree_len until it evenly divides the count so far. We know
-    // that subtree_len itself is a power of 2, so we can use a bitmasking
-    // trick instead of an actual remainder operation. (Note that if the caller
-    // consistently passes power-of-2 inputs of the same size, as is hopefully
-    // typical, this loop condition will always fail, and subtree_len will
-    // always be the full length of the input.)
-    //
-    // An aside: We don't have to shrink subtree_len quite this much. For
-    // example, if count_so_far is 1, we could pass 2 chunks to
-    // compress_subtree_to_parent_node. Since we'll get 2 CVs back, we'll still
-    // get the right answer in the end, and we might get to use 2-way SIMD
-    // parallelism. The problem with this optimization, is that it gets us
-    // stuck always hashing 2 chunks. The total number of chunks will remain
-    // odd, and we'll never graduate to higher degrees of parallelism. See
-    // https://github.com/BLAKE3-team/BLAKE3/issues/69.
-    while ((((uint64_t)(subtree_len - 1)) & count_so_far) != 0) {
-      subtree_len /= 2;
-    }
-    // The shrunken subtree_len might now be 1 chunk long. If so, hash that one
-    // chunk by itself. Otherwise, compress the subtree into a pair of CVs.
-    uint64_t subtree_chunks = subtree_len / BLAKE3_CHUNK_LEN;
-    if (subtree_len <= BLAKE3_CHUNK_LEN) {
-      blake3_chunk_state chunk_state;
-      chunk_state_init(&chunk_state, self->key, self->chunk.flags);
-      chunk_state.chunk_counter = self->chunk.chunk_counter;
-      chunk_state_update(&chunk_state, input_bytes, subtree_len);
-      output_t output = chunk_state_output(&chunk_state);
-      uint8_t cv[BLAKE3_OUT_LEN];
-      output_chaining_value(&output, cv);
-      hasher_push_cv(self, cv, chunk_state.chunk_counter);
-    } else {
-      // This is the high-performance happy path, though getting here depends
-      // on the caller giving us a long enough input.
-      uint8_t cv_pair[2 * BLAKE3_OUT_LEN];
-      compress_subtree_to_parent_node(input_bytes, subtree_len, self->key,
-                                      self->chunk.chunk_counter,
-                                      self->chunk.flags, cv_pair, use_tbb);
-      hasher_push_cv(self, cv_pair, self->chunk.chunk_counter);
-      hasher_push_cv(self, &cv_pair[BLAKE3_OUT_LEN],
-                     self->chunk.chunk_counter + (subtree_chunks / 2));
-    }
-    self->chunk.chunk_counter += subtree_chunks;
-    input_bytes += subtree_len;
-    input_len -= subtree_len;
-  }
-
-  // If there's any remaining input less than a full chunk, add it to the chunk
-  // state. In that case, also do a final merge loop to make sure the subtree
-  // stack doesn't contain any unmerged pairs. The remaining input means we
-  // know these merges are non-root. This merge loop isn't strictly necessary
-  // here, because hasher_push_chunk_cv already does its own merge loop, but it
-  // simplifies blake3_hasher_finalize below.
-  if (input_len > 0) {
-    chunk_state_update(&self->chunk, input_bytes, input_len);
-    hasher_merge_cv_stack(self, self->chunk.chunk_counter);
-  }
-}
-
-void blake3_hasher_update(blake3_hasher *self, const void *input,
-                          size_t input_len) {
-  bool use_tbb = false;
-  blake3_hasher_update_base(self, input, input_len, use_tbb);
-}
-
-#if defined(BLAKE3_USE_TBB)
-void blake3_hasher_update_tbb(blake3_hasher *self, const void *input,
-                              size_t input_len) {
-  bool use_tbb = true;
-  blake3_hasher_update_base(self, input, input_len, use_tbb);
-}
-#endif // BLAKE3_USE_TBB
-
-void blake3_hasher_finalize(const blake3_hasher *self, uint8_t *out,
-                            size_t out_len) {
-  blake3_hasher_finalize_seek(self, 0, out, out_len);
-}
-
-void blake3_hasher_finalize_seek(const blake3_hasher *self, uint64_t seek,
-                                 uint8_t *out, size_t out_len) {
-  // Explicitly checking for zero avoids causing UB by passing a null pointer
-  // to memcpy. This comes up in practice with things like:
-  //   std::vector<uint8_t> v;
-  //   blake3_hasher_finalize(&hasher, v.data(), v.size());
-  if (out_len == 0) {
-    return;
-  }
-
-  // If the subtree stack is empty, then the current chunk is the root.
-  if (self->cv_stack_len == 0) {
-    output_t output = chunk_state_output(&self->chunk);
-    output_root_bytes(&output, seek, out, out_len);
-    return;
-  }
-  // If there are any bytes in the chunk state, finalize that chunk and do a
-  // roll-up merge between that chunk hash and every subtree in the stack. In
-  // this case, the extra merge loop at the end of blake3_hasher_update
-  // guarantees that none of the subtrees in the stack need to be merged with
-  // each other first. Otherwise, if there are no bytes in the chunk state,
-  // then the top of the stack is a chunk hash, and we start the merge from
-  // that.
-  output_t output;
-  size_t cvs_remaining;
-  if (chunk_state_len(&self->chunk) > 0) {
-    cvs_remaining = self->cv_stack_len;
-    output = chunk_state_output(&self->chunk);
-  } else {
-    // There are always at least 2 CVs in the stack in this case.
-    cvs_remaining = self->cv_stack_len - 2;
-    output = parent_output(&self->cv_stack[cvs_remaining * 32], self->key,
-                           self->chunk.flags);
-  }
-  while (cvs_remaining > 0) {
-    cvs_remaining -= 1;
-    uint8_t parent_block[BLAKE3_BLOCK_LEN];
-    memcpy(parent_block, &self->cv_stack[cvs_remaining * 32], 32);
-    output_chaining_value(&output, &parent_block[32]);
-    output = parent_output(parent_block, self->key, self->chunk.flags);
-  }
-  output_root_bytes(&output, seek, out, out_len);
-}
-
-void blake3_hasher_reset(blake3_hasher *self) {
-  chunk_state_reset(&self->chunk, self->key, 0);
-  self->cv_stack_len = 0;
-}
diff --git a/crates/vole-blake3-raw/vendor/blake3.h b/crates/vole-blake3-raw/vendor/blake3.h
deleted file mode 100644
index c5b7998..0000000
--- a/crates/vole-blake3-raw/vendor/blake3.h
+++ /dev/null
@@ -1,86 +0,0 @@
-#ifndef BLAKE3_H
-#define BLAKE3_H
-
-#include <stddef.h>
-#include <stdint.h>
-
-#if !defined(BLAKE3_API)
-# if defined(_WIN32) || defined(__CYGWIN__)
-#   if defined(BLAKE3_DLL)
-#     if defined(BLAKE3_DLL_EXPORTS)
-#       define BLAKE3_API __declspec(dllexport)
-#     else
-#       define BLAKE3_API __declspec(dllimport)
-#     endif
-#     define BLAKE3_PRIVATE
-#   else
-#     define BLAKE3_API
-#     define BLAKE3_PRIVATE
-#   endif
-# elif __GNUC__ >= 4
-#   define BLAKE3_API __attribute__((visibility("default")))
-#   define BLAKE3_PRIVATE __attribute__((visibility("hidden")))
-# else
-#   define BLAKE3_API
-#   define BLAKE3_PRIVATE
-# endif
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define BLAKE3_VERSION_STRING "1.8.7"
-#define BLAKE3_KEY_LEN 32
-#define BLAKE3_OUT_LEN 32
-#define BLAKE3_BLOCK_LEN 64
-#define BLAKE3_CHUNK_LEN 1024
-#define BLAKE3_MAX_DEPTH 54
-
-// This struct is a private implementation detail. It has to be here because
-// it's part of the blake3_hasher structure defined below.
-typedef struct {
-  uint32_t cv[8];
-  uint64_t chunk_counter;
-  uint8_t buf[BLAKE3_BLOCK_LEN];
-  uint8_t buf_len;
-  uint8_t blocks_compressed;
-  uint8_t flags;
-} blake3_chunk_state;
-
-typedef struct {
-  uint32_t key[8];
-  blake3_chunk_state chunk;
-  uint8_t cv_stack_len;
-  // The stack size is MAX_DEPTH + 1 because we do lazy merging. For example,
-  // with 7 chunks, we have 3 entries in the stack. Adding an 8th chunk
-  // requires a 4th entry, rather than merging everything down to 1, because we
-  // don't know whether more input is coming. This is different from how the
-  // reference implementation does things.
-  uint8_t cv_stack[(BLAKE3_MAX_DEPTH + 1) * BLAKE3_OUT_LEN];
-} blake3_hasher;
-
-BLAKE3_API const char *blake3_version(void);
-BLAKE3_API void blake3_hasher_init(blake3_hasher *self);
-BLAKE3_API void blake3_hasher_init_keyed(blake3_hasher *self,
-                                         const uint8_t key[BLAKE3_KEY_LEN]);
-BLAKE3_API void blake3_hasher_init_derive_key(blake3_hasher *self, const char *context);
-BLAKE3_API void blake3_hasher_init_derive_key_raw(blake3_hasher *self, const void *context,
-                                                  size_t context_len);
-BLAKE3_API void blake3_hasher_update(blake3_hasher *self, const void *input,
-                                     size_t input_len);
-#if defined(BLAKE3_USE_TBB)
-BLAKE3_API void blake3_hasher_update_tbb(blake3_hasher *self, const void *input,
-                                         size_t input_len);
-#endif // BLAKE3_USE_TBB
-BLAKE3_API void blake3_hasher_finalize(const blake3_hasher *self, uint8_t *out,
-                                       size_t out_len);
-BLAKE3_API void blake3_hasher_finalize_seek(const blake3_hasher *self, uint64_t seek,
-                                            uint8_t *out, size_t out_len);
-BLAKE3_API void blake3_hasher_reset(blake3_hasher *self);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* BLAKE3_H */
diff --git a/crates/vole-blake3-raw/vendor/blake3_dispatch.c b/crates/vole-blake3-raw/vendor/blake3_dispatch.c
deleted file mode 100644
index 14dfbbe..0000000
--- a/crates/vole-blake3-raw/vendor/blake3_dispatch.c
+++ /dev/null
@@ -1,332 +0,0 @@
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include "blake3_impl.h"
-
-#if defined(_MSC_VER)
-#include <Windows.h>
-#endif
-
-#if defined(IS_X86)
-#if defined(_MSC_VER)
-#include <intrin.h>
-#elif defined(__GNUC__)
-#include <immintrin.h>
-#else
-#undef IS_X86 /* Unimplemented! */
-#endif
-#endif
-
-#if !defined(BLAKE3_ATOMICS)
-#if defined(__has_include)
-#if __has_include(<stdatomic.h>) && !defined(_MSC_VER)
-#define BLAKE3_ATOMICS 1
-#else
-#define BLAKE3_ATOMICS 0
-#endif /* __has_include(<stdatomic.h>) && !defined(_MSC_VER) */
-#else
-#define BLAKE3_ATOMICS 0
-#endif /* defined(__has_include) */
-#endif /* BLAKE3_ATOMICS */
-
-#if BLAKE3_ATOMICS
-#define ATOMIC_INT _Atomic int
-#define ATOMIC_LOAD(x) x
-#define ATOMIC_STORE(x, y) x = y
-#elif defined(_MSC_VER)
-#define ATOMIC_INT LONG
-#define ATOMIC_LOAD(x) InterlockedOr(&x, 0)
-#define ATOMIC_STORE(x, y) InterlockedExchange(&x, y)
-#else
-#define ATOMIC_INT int
-#define ATOMIC_LOAD(x) x
-#define ATOMIC_STORE(x, y) x = y
-#endif
-
-#define MAYBE_UNUSED(x) (void)((x))
-
-#if defined(IS_X86)
-static uint64_t xgetbv(void) {
-#if defined(_MSC_VER)
-  return _xgetbv(0);
-#else
-  uint32_t eax = 0, edx = 0;
-  __asm__ __volatile__("xgetbv\n" : "=a"(eax), "=d"(edx) : "c"(0));
-  return ((uint64_t)edx << 32) | eax;
-#endif
-}
-
-static void cpuid(uint32_t out[4], uint32_t id) {
-#if defined(_MSC_VER)
-  __cpuid((int *)out, id);
-#elif defined(__i386__) || defined(_M_IX86)
-  __asm__ __volatile__("movl %%ebx, %1\n"
-                       "cpuid\n"
-                       "xchgl %1, %%ebx\n"
-                       : "=a"(out[0]), "=r"(out[1]), "=c"(out[2]), "=d"(out[3])
-                       : "a"(id));
-#else
-  __asm__ __volatile__("cpuid\n"
-                       : "=a"(out[0]), "=b"(out[1]), "=c"(out[2]), "=d"(out[3])
-                       : "a"(id));
-#endif
-}
-
-static void cpuidex(uint32_t out[4], uint32_t id, uint32_t sid) {
-#if defined(_MSC_VER)
-  __cpuidex((int *)out, id, sid);
-#elif defined(__i386__) || defined(_M_IX86)
-  __asm__ __volatile__("movl %%ebx, %1\n"
-                       "cpuid\n"
-                       "xchgl %1, %%ebx\n"
-                       : "=a"(out[0]), "=r"(out[1]), "=c"(out[2]), "=d"(out[3])
-                       : "a"(id), "c"(sid));
-#else
-  __asm__ __volatile__("cpuid\n"
-                       : "=a"(out[0]), "=b"(out[1]), "=c"(out[2]), "=d"(out[3])
-                       : "a"(id), "c"(sid));
-#endif
-}
-
-
-enum cpu_feature {
-  SSE2 = 1 << 0,
-  SSSE3 = 1 << 1,
-  SSE41 = 1 << 2,
-  AVX = 1 << 3,
-  AVX2 = 1 << 4,
-  AVX512F = 1 << 5,
-  AVX512VL = 1 << 6,
-  /* ... */
-  UNDEFINED = 1 << 30
-};
-
-#if !defined(BLAKE3_TESTING)
-static /* Allow the variable to be controlled manually for testing */
-#endif
-    ATOMIC_INT g_cpu_features = UNDEFINED;
-
-#if !defined(BLAKE3_TESTING)
-static
-#endif
-    enum cpu_feature
-    get_cpu_features(void) {
-
-  /* If TSAN detects a data race here, try compiling with -DBLAKE3_ATOMICS=1 */
-  enum cpu_feature features = ATOMIC_LOAD(g_cpu_features);
-  if (features != UNDEFINED) {
-    return features;
-  } else {
-#if defined(IS_X86)
-    uint32_t regs[4] = {0};
-    uint32_t *eax = &regs[0], *ebx = &regs[1], *ecx = &regs[2], *edx = &regs[3];
-    (void)edx;
-    features = 0;
-    cpuid(regs, 0);
-    const int max_id = *eax;
-    cpuid(regs, 1);
-#if defined(__amd64__) || defined(_M_X64)
-    features |= SSE2;
-#else
-    if (*edx & (1UL << 26))
-      features |= SSE2;
-#endif
-    if (*ecx & (1UL << 9))
-      features |= SSSE3;
-    if (*ecx & (1UL << 19))
-      features |= SSE41;
-
-    if (*ecx & (1UL << 27)) { // OSXSAVE
-      const uint64_t mask = xgetbv();
-      if ((mask & 6) == 6) { // SSE and AVX states
-        if (*ecx & (1UL << 28))
-          features |= AVX;
-        if (max_id >= 7) {
-          cpuidex(regs, 7, 0);
-          if (*ebx & (1UL << 5))
-            features |= AVX2;
-          if ((mask & 224) == 224) { // Opmask, ZMM_Hi256, Hi16_Zmm
-            if (*ebx & (1UL << 31))
-              features |= AVX512VL;
-            if (*ebx & (1UL << 16))
-              features |= AVX512F;
-          }
-        }
-      }
-    }
-    ATOMIC_STORE(g_cpu_features, features);
-    return features;
-#else
-    /* How to detect NEON? */
-    return 0;
-#endif
-  }
-}
-#endif
-
-void blake3_compress_in_place(uint32_t cv[8],
-                              const uint8_t block[BLAKE3_BLOCK_LEN],
-                              uint8_t block_len, uint64_t counter,
-                              uint8_t flags) {
-#if defined(IS_X86)
-  const enum cpu_feature features = get_cpu_features();
-  MAYBE_UNUSED(features);
-#if !defined(BLAKE3_NO_AVX512)
-  if (features & AVX512VL) {
-    blake3_compress_in_place_avx512(cv, block, block_len, counter, flags);
-    return;
-  }
-#endif
-#if !defined(BLAKE3_NO_SSE41)
-  if (features & SSE41) {
-    blake3_compress_in_place_sse41(cv, block, block_len, counter, flags);
-    return;
-  }
-#endif
-#if !defined(BLAKE3_NO_SSE2)
-  if (features & SSE2) {
-    blake3_compress_in_place_sse2(cv, block, block_len, counter, flags);
-    return;
-  }
-#endif
-#endif
-  blake3_compress_in_place_portable(cv, block, block_len, counter, flags);
-}
-
-void blake3_compress_xof(const uint32_t cv[8],
-                         const uint8_t block[BLAKE3_BLOCK_LEN],
-                         uint8_t block_len, uint64_t counter, uint8_t flags,
-                         uint8_t out[64]) {
-#if defined(IS_X86)
-  const enum cpu_feature features = get_cpu_features();
-  MAYBE_UNUSED(features);
-#if !defined(BLAKE3_NO_AVX512)
-  if (features & AVX512VL) {
-    blake3_compress_xof_avx512(cv, block, block_len, counter, flags, out);
-    return;
-  }
-#endif
-#if !defined(BLAKE3_NO_SSE41)
-  if (features & SSE41) {
-    blake3_compress_xof_sse41(cv, block, block_len, counter, flags, out);
-    return;
-  }
-#endif
-#if !defined(BLAKE3_NO_SSE2)
-  if (features & SSE2) {
-    blake3_compress_xof_sse2(cv, block, block_len, counter, flags, out);
-    return;
-  }
-#endif
-#endif
-  blake3_compress_xof_portable(cv, block, block_len, counter, flags, out);
-}
-
-
-void blake3_xof_many(const uint32_t cv[8],
-                     const uint8_t block[BLAKE3_BLOCK_LEN],
-                     uint8_t block_len, uint64_t counter, uint8_t flags,
-                     uint8_t out[64], size_t outblocks) {
-  if (outblocks == 0) {
-    // The current assembly implementation always outputs at least 1 block.
-    return;
-  }
-#if defined(IS_X86)
-  const enum cpu_feature features = get_cpu_features();
-  MAYBE_UNUSED(features);
-#if !defined(_WIN32) && !defined(__CYGWIN__) && !defined(BLAKE3_NO_AVX512)
-  if (features & AVX512VL) {
-    blake3_xof_many_avx512(cv, block, block_len, counter, flags, out, outblocks);
-    return;
-  }
-#endif
-#endif
-  for(size_t i = 0; i < outblocks; ++i) {
-    blake3_compress_xof(cv, block, block_len, counter + i, flags, out + 64*i);
-  }
-}
-
-void blake3_hash_many(const uint8_t *const *inputs, size_t num_inputs,
-                      size_t blocks, const uint32_t key[8], uint64_t counter,
-                      bool increment_counter, uint8_t flags,
-                      uint8_t flags_start, uint8_t flags_end, uint8_t *out) {
-#if defined(IS_X86)
-  const enum cpu_feature features = get_cpu_features();
-  MAYBE_UNUSED(features);
-#if !defined(BLAKE3_NO_AVX512)
-  if ((features & (AVX512F|AVX512VL)) == (AVX512F|AVX512VL)) {
-    blake3_hash_many_avx512(inputs, num_inputs, blocks, key, counter,
-                            increment_counter, flags, flags_start, flags_end,
-                            out);
-    return;
-  }
-#endif
-#if !defined(BLAKE3_NO_AVX2)
-  if (features & AVX2) {
-    blake3_hash_many_avx2(inputs, num_inputs, blocks, key, counter,
-                          increment_counter, flags, flags_start, flags_end,
-                          out);
-    return;
-  }
-#endif
-#if !defined(BLAKE3_NO_SSE41)
-  if (features & SSE41) {
-    blake3_hash_many_sse41(inputs, num_inputs, blocks, key, counter,
-                           increment_counter, flags, flags_start, flags_end,
-                           out);
-    return;
-  }
-#endif
-#if !defined(BLAKE3_NO_SSE2)
-  if (features & SSE2) {
-    blake3_hash_many_sse2(inputs, num_inputs, blocks, key, counter,
-                          increment_counter, flags, flags_start, flags_end,
-                          out);
-    return;
-  }
-#endif
-#endif
-
-#if BLAKE3_USE_NEON == 1
-  blake3_hash_many_neon(inputs, num_inputs, blocks, key, counter,
-                        increment_counter, flags, flags_start, flags_end, out);
-  return;
-#endif
-
-  blake3_hash_many_portable(inputs, num_inputs, blocks, key, counter,
-                            increment_counter, flags, flags_start, flags_end,
-                            out);
-}
-
-// The dynamically detected SIMD degree of the current platform.
-size_t blake3_simd_degree(void) {
-#if defined(IS_X86)
-  const enum cpu_feature features = get_cpu_features();
-  MAYBE_UNUSED(features);
-#if !defined(BLAKE3_NO_AVX512)
-  if ((features & (AVX512F|AVX512VL)) == (AVX512F|AVX512VL)) {
-    return 16;
-  }
-#endif
-#if !defined(BLAKE3_NO_AVX2)
-  if (features & AVX2) {
-    return 8;
-  }
-#endif
-#if !defined(BLAKE3_NO_SSE41)
-  if (features & SSE41) {
-    return 4;
-  }
-#endif
-#if !defined(BLAKE3_NO_SSE2)
-  if (features & SSE2) {
-    return 4;
-  }
-#endif
-#endif
-#if BLAKE3_USE_NEON == 1
-  return 4;
-#endif
-  return 1;
-}
diff --git a/crates/vole-blake3-raw/vendor/blake3_impl.h b/crates/vole-blake3-raw/vendor/blake3_impl.h
deleted file mode 100644
index 88e71e4..0000000
--- a/crates/vole-blake3-raw/vendor/blake3_impl.h
+++ /dev/null
@@ -1,333 +0,0 @@
-#ifndef BLAKE3_IMPL_H
-#define BLAKE3_IMPL_H
-
-#include <assert.h>
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <string.h>
-
-#include "blake3.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// internal flags
-enum blake3_flags {
-  CHUNK_START         = 1 << 0,
-  CHUNK_END           = 1 << 1,
-  PARENT              = 1 << 2,
-  ROOT                = 1 << 3,
-  KEYED_HASH          = 1 << 4,
-  DERIVE_KEY_CONTEXT  = 1 << 5,
-  DERIVE_KEY_MATERIAL = 1 << 6,
-};
-
-// This C implementation tries to support recent versions of GCC, Clang, and
-// MSVC.
-#if defined(_MSC_VER)
-#define INLINE static __forceinline
-#else
-#define INLINE static inline __attribute__((always_inline))
-#endif
-
-#ifdef __cplusplus
-#define NOEXCEPT noexcept
-#else
-#define NOEXCEPT
-#endif
-
-#if (defined(__x86_64__) || defined(_M_X64)) && !defined(_M_ARM64EC)
-#define IS_X86
-#define IS_X86_64
-#endif
-
-#if defined(__i386__) || defined(_M_IX86)
-#define IS_X86
-#define IS_X86_32
-#endif
-
-#if defined(__aarch64__) || defined(_M_ARM64) || defined(_M_ARM64EC)
-#define IS_AARCH64
-#endif
-
-#if defined(IS_X86)
-#if defined(_MSC_VER)
-#include <intrin.h>
-#endif
-#endif
-
-#if !defined(BLAKE3_USE_NEON) 
-  // If BLAKE3_USE_NEON not manually set, autodetect based on AArch64ness
-  #if defined(IS_AARCH64)
-    #if defined(__ARM_BIG_ENDIAN)
-      #define BLAKE3_USE_NEON 0
-    #else
-      #define BLAKE3_USE_NEON 1
-    #endif
-  #else
-    #define BLAKE3_USE_NEON 0
-  #endif
-#endif
-
-#if defined(IS_X86)
-#define MAX_SIMD_DEGREE 16
-#elif BLAKE3_USE_NEON == 1
-#define MAX_SIMD_DEGREE 4
-#else
-#define MAX_SIMD_DEGREE 1
-#endif
-
-// There are some places where we want a static size that's equal to the
-// MAX_SIMD_DEGREE, but also at least 2.
-#define MAX_SIMD_DEGREE_OR_2 (MAX_SIMD_DEGREE > 2 ? MAX_SIMD_DEGREE : 2)
-
-static const uint32_t IV[8] = {0x6A09E667UL, 0xBB67AE85UL, 0x3C6EF372UL,
-                               0xA54FF53AUL, 0x510E527FUL, 0x9B05688CUL,
-                               0x1F83D9ABUL, 0x5BE0CD19UL};
-
-static const uint8_t MSG_SCHEDULE[7][16] = {
-    {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
-    {2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8},
-    {3, 4, 10, 12, 13, 2, 7, 14, 6, 5, 9, 0, 11, 15, 8, 1},
-    {10, 7, 12, 9, 14, 3, 13, 15, 4, 0, 11, 2, 5, 8, 1, 6},
-    {12, 13, 9, 11, 15, 10, 14, 8, 7, 2, 5, 3, 0, 1, 6, 4},
-    {9, 14, 11, 5, 8, 12, 15, 1, 13, 3, 0, 10, 2, 6, 4, 7},
-    {11, 15, 5, 0, 1, 9, 8, 6, 14, 10, 2, 12, 3, 4, 7, 13},
-};
-
-/* Find index of the highest set bit */
-/* x is assumed to be nonzero.       */
-static unsigned int highest_one(uint64_t x) {
-#if defined(__GNUC__) || defined(__clang__)
-  return 63 ^ (unsigned int)__builtin_clzll(x);
-#elif defined(_MSC_VER) && defined(IS_X86_64)
-  unsigned long index;
-  _BitScanReverse64(&index, x);
-  return index;
-#elif defined(_MSC_VER) && defined(IS_X86_32)
-  if(x >> 32) {
-    unsigned long index;
-    _BitScanReverse(&index, (unsigned long)(x >> 32));
-    return 32 + index;
-  } else {
-    unsigned long index;
-    _BitScanReverse(&index, (unsigned long)x);
-    return index;
-  }
-#else
-  unsigned int c = 0;
-  if(x & 0xffffffff00000000ULL) { x >>= 32; c += 32; }
-  if(x & 0x00000000ffff0000ULL) { x >>= 16; c += 16; }
-  if(x & 0x000000000000ff00ULL) { x >>=  8; c +=  8; }
-  if(x & 0x00000000000000f0ULL) { x >>=  4; c +=  4; }
-  if(x & 0x000000000000000cULL) { x >>=  2; c +=  2; }
-  if(x & 0x0000000000000002ULL) {           c +=  1; }
-  return c;
-#endif
-}
-
-// Count the number of 1 bits.
-INLINE unsigned int popcnt(uint64_t x) {
-#if defined(__GNUC__) || defined(__clang__)
-  return (unsigned int)__builtin_popcountll(x);
-#else
-  unsigned int count = 0;
-  while (x != 0) {
-    count += 1;
-    x &= x - 1;
-  }
-  return count;
-#endif
-}
-
-// Largest power of two less than or equal to x. As a special case, returns 1
-// when x is 0. 
-INLINE uint64_t round_down_to_power_of_2(uint64_t x) {
-  return 1ULL << highest_one(x | 1);
-}
-
-INLINE uint32_t counter_low(uint64_t counter) { return (uint32_t)counter; }
-
-INLINE uint32_t counter_high(uint64_t counter) {
-  return (uint32_t)(counter >> 32);
-}
-
-INLINE uint32_t load32(const void *src) {
-  const uint8_t *p = (const uint8_t *)src;
-  return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) |
-         ((uint32_t)(p[2]) << 16) | ((uint32_t)(p[3]) << 24);
-}
-
-INLINE void load_key_words(const uint8_t key[BLAKE3_KEY_LEN],
-                           uint32_t key_words[8]) {
-  key_words[0] = load32(&key[0 * 4]);
-  key_words[1] = load32(&key[1 * 4]);
-  key_words[2] = load32(&key[2 * 4]);
-  key_words[3] = load32(&key[3 * 4]);
-  key_words[4] = load32(&key[4 * 4]);
-  key_words[5] = load32(&key[5 * 4]);
-  key_words[6] = load32(&key[6 * 4]);
-  key_words[7] = load32(&key[7 * 4]);
-}
-
-INLINE void load_block_words(const uint8_t block[BLAKE3_BLOCK_LEN],
-                             uint32_t block_words[16]) {
-  for (size_t i = 0; i < 16; i++) {
-      block_words[i] = load32(&block[i * 4]);
-  }
-}
-
-INLINE void store32(void *dst, uint32_t w) {
-  uint8_t *p = (uint8_t *)dst;
-  p[0] = (uint8_t)(w >> 0);
-  p[1] = (uint8_t)(w >> 8);
-  p[2] = (uint8_t)(w >> 16);
-  p[3] = (uint8_t)(w >> 24);
-}
-
-INLINE void store_cv_words(uint8_t bytes_out[32], uint32_t cv_words[8]) {
-  store32(&bytes_out[0 * 4], cv_words[0]);
-  store32(&bytes_out[1 * 4], cv_words[1]);
-  store32(&bytes_out[2 * 4], cv_words[2]);
-  store32(&bytes_out[3 * 4], cv_words[3]);
-  store32(&bytes_out[4 * 4], cv_words[4]);
-  store32(&bytes_out[5 * 4], cv_words[5]);
-  store32(&bytes_out[6 * 4], cv_words[6]);
-  store32(&bytes_out[7 * 4], cv_words[7]);
-}
-
-void blake3_compress_in_place(uint32_t cv[8],
-                              const uint8_t block[BLAKE3_BLOCK_LEN],
-                              uint8_t block_len, uint64_t counter,
-                              uint8_t flags);
-
-void blake3_compress_xof(const uint32_t cv[8],
-                         const uint8_t block[BLAKE3_BLOCK_LEN],
-                         uint8_t block_len, uint64_t counter, uint8_t flags,
-                         uint8_t out[64]);
-
-void blake3_xof_many(const uint32_t cv[8],
-                     const uint8_t block[BLAKE3_BLOCK_LEN],
-                     uint8_t block_len, uint64_t counter, uint8_t flags,
-                     uint8_t out[64], size_t outblocks);
-
-void blake3_hash_many(const uint8_t *const *inputs, size_t num_inputs,
-                      size_t blocks, const uint32_t key[8], uint64_t counter,
-                      bool increment_counter, uint8_t flags,
-                      uint8_t flags_start, uint8_t flags_end, uint8_t *out);
-
-size_t blake3_simd_degree(void);
-
-BLAKE3_PRIVATE size_t blake3_compress_subtree_wide(const uint8_t *input, size_t input_len,
-                                                   const uint32_t key[8],
-                                                   uint64_t chunk_counter, uint8_t flags,
-                                                   uint8_t *out, bool use_tbb);
-
-#if defined(BLAKE3_USE_TBB)
-BLAKE3_PRIVATE void blake3_compress_subtree_wide_join_tbb(
-    // shared params
-    const uint32_t key[8], uint8_t flags, bool use_tbb,
-    // left-hand side params
-    const uint8_t *l_input, size_t l_input_len, uint64_t l_chunk_counter,
-    uint8_t *l_cvs, size_t *l_n,
-    // right-hand side params
-    const uint8_t *r_input, size_t r_input_len, uint64_t r_chunk_counter,
-    uint8_t *r_cvs, size_t *r_n) NOEXCEPT;
-#endif
-
-// Declarations for implementation-specific functions.
-void blake3_compress_in_place_portable(uint32_t cv[8],
-                                       const uint8_t block[BLAKE3_BLOCK_LEN],
-                                       uint8_t block_len, uint64_t counter,
-                                       uint8_t flags);
-
-void blake3_compress_xof_portable(const uint32_t cv[8],
-                                  const uint8_t block[BLAKE3_BLOCK_LEN],
-                                  uint8_t block_len, uint64_t counter,
-                                  uint8_t flags, uint8_t out[64]);
-
-void blake3_hash_many_portable(const uint8_t *const *inputs, size_t num_inputs,
-                               size_t blocks, const uint32_t key[8],
-                               uint64_t counter, bool increment_counter,
-                               uint8_t flags, uint8_t flags_start,
-                               uint8_t flags_end, uint8_t *out);
-
-#if defined(IS_X86)
-#if !defined(BLAKE3_NO_SSE2)
-void blake3_compress_in_place_sse2(uint32_t cv[8],
-                                   const uint8_t block[BLAKE3_BLOCK_LEN],
-                                   uint8_t block_len, uint64_t counter,
-                                   uint8_t flags);
-void blake3_compress_xof_sse2(const uint32_t cv[8],
-                              const uint8_t block[BLAKE3_BLOCK_LEN],
-                              uint8_t block_len, uint64_t counter,
-                              uint8_t flags, uint8_t out[64]);
-void blake3_hash_many_sse2(const uint8_t *const *inputs, size_t num_inputs,
-                           size_t blocks, const uint32_t key[8],
-                           uint64_t counter, bool increment_counter,
-                           uint8_t flags, uint8_t flags_start,
-                           uint8_t flags_end, uint8_t *out);
-#endif
-#if !defined(BLAKE3_NO_SSE41)
-void blake3_compress_in_place_sse41(uint32_t cv[8],
-                                    const uint8_t block[BLAKE3_BLOCK_LEN],
-                                    uint8_t block_len, uint64_t counter,
-                                    uint8_t flags);
-void blake3_compress_xof_sse41(const uint32_t cv[8],
-                               const uint8_t block[BLAKE3_BLOCK_LEN],
-                               uint8_t block_len, uint64_t counter,
-                               uint8_t flags, uint8_t out[64]);
-void blake3_hash_many_sse41(const uint8_t *const *inputs, size_t num_inputs,
-                            size_t blocks, const uint32_t key[8],
-                            uint64_t counter, bool increment_counter,
-                            uint8_t flags, uint8_t flags_start,
-                            uint8_t flags_end, uint8_t *out);
-#endif
-#if !defined(BLAKE3_NO_AVX2)
-void blake3_hash_many_avx2(const uint8_t *const *inputs, size_t num_inputs,
-                           size_t blocks, const uint32_t key[8],
-                           uint64_t counter, bool increment_counter,
-                           uint8_t flags, uint8_t flags_start,
-                           uint8_t flags_end, uint8_t *out);
-#endif
-#if !defined(BLAKE3_NO_AVX512)
-void blake3_compress_in_place_avx512(uint32_t cv[8],
-                                     const uint8_t block[BLAKE3_BLOCK_LEN],
-                                     uint8_t block_len, uint64_t counter,
-                                     uint8_t flags);
-
-void blake3_compress_xof_avx512(const uint32_t cv[8],
-                                const uint8_t block[BLAKE3_BLOCK_LEN],
-                                uint8_t block_len, uint64_t counter,
-                                uint8_t flags, uint8_t out[64]);
-
-void blake3_hash_many_avx512(const uint8_t *const *inputs, size_t num_inputs,
-                             size_t blocks, const uint32_t key[8],
-                             uint64_t counter, bool increment_counter,
-                             uint8_t flags, uint8_t flags_start,
-                             uint8_t flags_end, uint8_t *out);
-
-#if !defined(_WIN32) && !defined(__CYGWIN__)
-void blake3_xof_many_avx512(const uint32_t cv[8],
-                            const uint8_t block[BLAKE3_BLOCK_LEN],
-                            uint8_t block_len, uint64_t counter, uint8_t flags,
-                            uint8_t* out, size_t outblocks);
-#endif
-#endif
-#endif
-
-#if BLAKE3_USE_NEON == 1
-void blake3_hash_many_neon(const uint8_t *const *inputs, size_t num_inputs,
-                           size_t blocks, const uint32_t key[8],
-                           uint64_t counter, bool increment_counter,
-                           uint8_t flags, uint8_t flags_start,
-                           uint8_t flags_end, uint8_t *out);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* BLAKE3_IMPL_H */
diff --git a/crates/vole-blake3-raw/vendor/blake3_portable.c b/crates/vole-blake3-raw/vendor/blake3_portable.c
deleted file mode 100644
index 062dd1b..0000000
--- a/crates/vole-blake3-raw/vendor/blake3_portable.c
+++ /dev/null
@@ -1,160 +0,0 @@
-#include "blake3_impl.h"
-#include <string.h>
-
-INLINE uint32_t rotr32(uint32_t w, uint32_t c) {
-  return (w >> c) | (w << (32 - c));
-}
-
-INLINE void g(uint32_t *state, size_t a, size_t b, size_t c, size_t d,
-              uint32_t x, uint32_t y) {
-  state[a] = state[a] + state[b] + x;
-  state[d] = rotr32(state[d] ^ state[a], 16);
-  state[c] = state[c] + state[d];
-  state[b] = rotr32(state[b] ^ state[c], 12);
-  state[a] = state[a] + state[b] + y;
-  state[d] = rotr32(state[d] ^ state[a], 8);
-  state[c] = state[c] + state[d];
-  state[b] = rotr32(state[b] ^ state[c], 7);
-}
-
-INLINE void round_fn(uint32_t state[16], const uint32_t *msg, size_t round) {
-  // Select the message schedule based on the round.
-  const uint8_t *schedule = MSG_SCHEDULE[round];
-
-  // Mix the columns.
-  g(state, 0, 4, 8, 12, msg[schedule[0]], msg[schedule[1]]);
-  g(state, 1, 5, 9, 13, msg[schedule[2]], msg[schedule[3]]);
-  g(state, 2, 6, 10, 14, msg[schedule[4]], msg[schedule[5]]);
-  g(state, 3, 7, 11, 15, msg[schedule[6]], msg[schedule[7]]);
-
-  // Mix the rows.
-  g(state, 0, 5, 10, 15, msg[schedule[8]], msg[schedule[9]]);
-  g(state, 1, 6, 11, 12, msg[schedule[10]], msg[schedule[11]]);
-  g(state, 2, 7, 8, 13, msg[schedule[12]], msg[schedule[13]]);
-  g(state, 3, 4, 9, 14, msg[schedule[14]], msg[schedule[15]]);
-}
-
-INLINE void compress_pre(uint32_t state[16], const uint32_t cv[8],
-                         const uint8_t block[BLAKE3_BLOCK_LEN],
-                         uint8_t block_len, uint64_t counter, uint8_t flags) {
-  uint32_t block_words[16];
-  block_words[0] = load32(block + 4 * 0);
-  block_words[1] = load32(block + 4 * 1);
-  block_words[2] = load32(block + 4 * 2);
-  block_words[3] = load32(block + 4 * 3);
-  block_words[4] = load32(block + 4 * 4);
-  block_words[5] = load32(block + 4 * 5);
-  block_words[6] = load32(block + 4 * 6);
-  block_words[7] = load32(block + 4 * 7);
-  block_words[8] = load32(block + 4 * 8);
-  block_words[9] = load32(block + 4 * 9);
-  block_words[10] = load32(block + 4 * 10);
-  block_words[11] = load32(block + 4 * 11);
-  block_words[12] = load32(block + 4 * 12);
-  block_words[13] = load32(block + 4 * 13);
-  block_words[14] = load32(block + 4 * 14);
-  block_words[15] = load32(block + 4 * 15);
-
-  state[0] = cv[0];
-  state[1] = cv[1];
-  state[2] = cv[2];
-  state[3] = cv[3];
-  state[4] = cv[4];
-  state[5] = cv[5];
-  state[6] = cv[6];
-  state[7] = cv[7];
-  state[8] = IV[0];
-  state[9] = IV[1];
-  state[10] = IV[2];
-  state[11] = IV[3];
-  state[12] = counter_low(counter);
-  state[13] = counter_high(counter);
-  state[14] = (uint32_t)block_len;
-  state[15] = (uint32_t)flags;
-
-  round_fn(state, &block_words[0], 0);
-  round_fn(state, &block_words[0], 1);
-  round_fn(state, &block_words[0], 2);
-  round_fn(state, &block_words[0], 3);
-  round_fn(state, &block_words[0], 4);
-  round_fn(state, &block_words[0], 5);
-  round_fn(state, &block_words[0], 6);
-}
-
-void blake3_compress_in_place_portable(uint32_t cv[8],
-                                       const uint8_t block[BLAKE3_BLOCK_LEN],
-                                       uint8_t block_len, uint64_t counter,
-                                       uint8_t flags) {
-  uint32_t state[16];
-  compress_pre(state, cv, block, block_len, counter, flags);
-  cv[0] = state[0] ^ state[8];
-  cv[1] = state[1] ^ state[9];
-  cv[2] = state[2] ^ state[10];
-  cv[3] = state[3] ^ state[11];
-  cv[4] = state[4] ^ state[12];
-  cv[5] = state[5] ^ state[13];
-  cv[6] = state[6] ^ state[14];
-  cv[7] = state[7] ^ state[15];
-}
-
-void blake3_compress_xof_portable(const uint32_t cv[8],
-                                  const uint8_t block[BLAKE3_BLOCK_LEN],
-                                  uint8_t block_len, uint64_t counter,
-                                  uint8_t flags, uint8_t out[64]) {
-  uint32_t state[16];
-  compress_pre(state, cv, block, block_len, counter, flags);
-
-  store32(&out[0 * 4], state[0] ^ state[8]);
-  store32(&out[1 * 4], state[1] ^ state[9]);
-  store32(&out[2 * 4], state[2] ^ state[10]);
-  store32(&out[3 * 4], state[3] ^ state[11]);
-  store32(&out[4 * 4], state[4] ^ state[12]);
-  store32(&out[5 * 4], state[5] ^ state[13]);
-  store32(&out[6 * 4], state[6] ^ state[14]);
-  store32(&out[7 * 4], state[7] ^ state[15]);
-  store32(&out[8 * 4], state[8] ^ cv[0]);
-  store32(&out[9 * 4], state[9] ^ cv[1]);
-  store32(&out[10 * 4], state[10] ^ cv[2]);
-  store32(&out[11 * 4], state[11] ^ cv[3]);
-  store32(&out[12 * 4], state[12] ^ cv[4]);
-  store32(&out[13 * 4], state[13] ^ cv[5]);
-  store32(&out[14 * 4], state[14] ^ cv[6]);
-  store32(&out[15 * 4], state[15] ^ cv[7]);
-}
-
-INLINE void hash_one_portable(const uint8_t *input, size_t blocks,
-                              const uint32_t key[8], uint64_t counter,
-                              uint8_t flags, uint8_t flags_start,
-                              uint8_t flags_end, uint8_t out[BLAKE3_OUT_LEN]) {
-  uint32_t cv[8];
-  memcpy(cv, key, BLAKE3_KEY_LEN);
-  uint8_t block_flags = flags | flags_start;
-  while (blocks > 0) {
-    if (blocks == 1) {
-      block_flags |= flags_end;
-    }
-    blake3_compress_in_place_portable(cv, input, BLAKE3_BLOCK_LEN, counter,
-                                      block_flags);
-    input = &input[BLAKE3_BLOCK_LEN];
-    blocks -= 1;
-    block_flags = flags;
-  }
-  store_cv_words(out, cv);
-}
-
-void blake3_hash_many_portable(const uint8_t *const *inputs, size_t num_inputs,
-                               size_t blocks, const uint32_t key[8],
-                               uint64_t counter, bool increment_counter,
-                               uint8_t flags, uint8_t flags_start,
-                               uint8_t flags_end, uint8_t *out) {
-  while (num_inputs > 0) {
-    hash_one_portable(inputs[0], blocks, key, counter, flags, flags_start,
-                      flags_end, out);
-    if (increment_counter) {
-      counter += 1;
-    }
-    inputs += 1;
-    num_inputs -= 1;
-    out = &out[BLAKE3_OUT_LEN];
-  }
-}
diff --git a/crates/vole-netstack/Cargo.toml b/crates/vole-netstack/Cargo.toml
index 95e5fa7..961eecb 100644
--- a/crates/vole-netstack/Cargo.toml
+++ b/crates/vole-netstack/Cargo.toml
@@ -9,7 +9,8 @@ description = "Bounded userspace IPv4/IPv6 TCP and UDP netstack for Vole"
 [dependencies]
 bytes = "1"
 futures-util = "0.3"
-smoltcp = { version = "0.14", default-features = false, features = [
+# Upstream recovery fixes preserve retries when bounded packet output is full.
+smoltcp = { git = "https://github.com/smoltcp-rs/smoltcp", rev = "24bda3b4f982625d8453d4360172557d24921c76", default-features = false, features = [
     "std",
     "medium-ip",
     "auto-icmp-echo-reply",
diff --git a/crates/vole-netstack/README.md b/crates/vole-netstack/README.md
index ab58cff..0da7b71 100644
--- a/crates/vole-netstack/README.md
+++ b/crates/vole-netstack/README.md
@@ -81,20 +81,104 @@ control.stop().await;
 smoltcp sockets and woken pending TCP operations. Dropping the sole
 `PacketStream` also stops the driver and releases all endpoints.
 
+## Active TCP client
+
+`NetStack::start_client(config, addresses)` returns `ClientNetStackParts` with
+the same raw packet endpoints, control and statistics, plus a cloneable
+`TcpConnector`. `ClientAddresses` supplies optional IPv4/IPv6 source addresses;
+at least one must be unicast. An omitted family fails with `AddrNotAvailable`.
+The client mode does not create a passive accept or UDP datagram queue, and
+discards incoming TCP packets that do not belong to a requested connection.
+
+An optional `ClientConfig` retains up to two real `ClientPrefix` candidates,
+including two addresses in one family, and selects the source for each peer.
+It separates the bounded receive packet size from the TX MTU and can opt into
+per-flow ICMP PMTU feedback in the packet adapter. Mapped IPv4 and duplicate candidates normalize
+before startup. IPv4-only clients permit MTU 68..65535; a real IPv6 candidate
+requires at least 1280. Passive TUN validation still requires 1280.
+`ClientAddresses` converts with the former receive bound and PMTU disabled.
+
+```rust,ignore
+let parts = vole_netstack::NetStack::start_client(config, addresses)?;
+// The owner must concurrently pump packet_sink and packet_stream.
+let stream = parts.tcp_connector.connect(peer, deadline).await?;
+assert_eq!(stream.destination_addr(), peer);
+parts.control.stop().await;
+```
+
+`connect` takes an IP `SocketAddr` and an absolute Tokio `Instant`; bounded
+command admission and the handshake use that one deadline. It returns only
+after the socket reaches Established, with `source_addr` representing the
+configured local IP and allocated ephemeral port. `destination_addr` is the
+remote peer. The driver alone owns socket state and allocates source ports;
+there is no host socket, DNS resolver, system interface, route or NAT setup.
+
+The command queue holds at most 32 requests, independently of active socket
+count. Waiting for queue space remains cancellable and deadline-bound. Future
+Drop, deadline or handshake failure aborts the pending socket and reclaims its
+flow after any reset reaches the existing output queue; a full output never
+blocks Stop. Successful streams retain the existing direction buffers and TCP
+half-close behavior. Stop closes admission, wakes queued/in-flight connects
+and releases every socket before returning. Passive `start`/`start_tcp` TUN
+uses the same configured data buffers and admits validated TCP PMTU feedback
+without changing connection admission or adding packet queues.
+
+An active owner may call `tcp_connector.set_initial_mtu(mtu, deadline)` after
+its transport handshake and before any TCP connection. The same bounded
+command queue confirms a valid reduction before the first SYN is exposed.
+The driver rebuilds smoltcp's device-capability snapshot with unchanged source
+prefixes and routes; the independent receive packet limit is retained. Invalid
+budgets, increases, expired deadlines or an already started TCP flow fail.
+
 ## Driver buffering and scheduling
 
+TCP uses the official unmodified smoltcp engine. Active clients initialize its
+device with the known transport MTU; callers should use their actual packet
+budget when available. ICMP feedback cannot change smoltcp's socket MSS.
+Instead, validated feedback reduces that flow's output budget, and the packet
+adapter splits later TCP output, including ordinary retransmissions. Recovery
+uses smoltcp's own retransmission/congestion timers; no immediate retransmission
+or Mihomo timer equality is promised.
+
+Active clients retain the engine's one-second initial retransmission timeout
+and use a 200 ms minimum after RTT sampling. Passive TUN sockets keep the
+engine defaults; RTT estimates and timeout backoff remain engine-owned.
+
+Passive TUN TCP enables this bounded fallback as well; an incoming error must
+identify an active intercepted flow. Active clients additionally require a
+configured local source address and explicitly enable PMTU discovery.
+The adapter validates the local/remote tuple, outer destination and quoted
+sequence against output actually placed in the raw queue and not acknowledged.
+Sent ranges, ACK watermarks and path budgets each hold at most 64 metadata
+entries, with no payload history. Exhaustion forgets old optimization metadata;
+it cannot authorize a quote for unsent bytes. Partial ACKs trim references,
+sequence arithmetic handles wrap, and flow reclamation removes its metadata.
+
+Software segmentation supports non-fragmented IPv4 and plain IPv6 TCP. IP/TCP
+options, sequence, checksums and flags are preserved; FIN/PSH appear only on
+the last segment and CWR only on the first. Oversized SYN/RST/URG or packets
+requiring unsupported IP fragmentation/IPv6 extension handling are dropped;
+UDP message boundaries are never split. IPv6 budgets below 1280 are ignored.
+Continual software segmentation creates more packets and allocations than a
+correct initial device MTU, so it is a fallback for later path reductions.
+
 Device ingress holds at most one pending packet, not another packet queue.
 smoltcp TX tokens reserve capacity in the existing bounded raw output queue
 before consuming ingress or allocating an output packet. Consuming a token
 sends directly into that queue; dropping an unused token returns its permit.
-There is no intermediate device TX backlog. TCP protocol state retains pending
-output, including resets, until a token is available. Low-priority ICMP echo
+During segmentation, at most one original output packet and its offset remain
+in the device; each generated segment reserves its raw queue slot before
+allocation. No additional packet queue exists. A pending original prevents
+further smoltcp TX tokens until its segments drain. TCP protocol state retains
+pending output, including resets, until a token is available. Low-priority ICMP echo
 replies are dropped when output is full, without waiting or retaining a reply.
 
 `PacketStream::recv`, `recv_batch` and `try_recv` wake the driver when they
 restore output capacity. An immediate protocol timer is deferred while output
 is full, avoiding a zero-delay retry loop; the wakeup resumes it promptly.
 Bounded periodic polling still performs lifecycle maintenance.
+Stop releases the pending original and all PMTU metadata before reporting
+completion; it never waits for a blocked output consumer.
 
 The driver consumes at most eight already-ready ingress packets before full
 socket maintenance. TCP ingress still advances packet by packet; cancellation
diff --git a/crates/vole-netstack/src/client.rs b/crates/vole-netstack/src/client.rs
new file mode 100644
index 0000000..6046bdc
--- /dev/null
+++ b/crates/vole-netstack/src/client.rs
@@ -0,0 +1,439 @@
+use std::{
+    io,
+    net::{IpAddr, Ipv4Addr},
+};
+
+use crate::{ClientAddresses, ConfigError};
+
+/// Largest ordinary IPv6 packet, including its fixed header. Jumbograms are
+/// outside the raw client codec; this limit is independent of the TX MTU.
+pub const MAX_RECEIVE_PACKET_SIZE: usize = 40 + 65_535;
+
+/// A local address and its actual prefix length, retaining the address's host
+/// bits. Field names in a proxy configuration do not determine its family.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ClientPrefix {
+    pub address: IpAddr,
+    pub prefix_len: u8,
+}
+
+/// One internal client profile. It adds no system address or route settings.
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub struct ClientConfig {
+    pub prefixes: [Option<ClientPrefix>; 2],
+    /// Zero preserves the legacy behavior of using the configured TX MTU.
+    pub receive_packet_limit: usize,
+    /// Enables correlated packet-layer ICMP PMTU feedback in active mode only.
+    pub path_mtu_discovery: bool,
+}
+
+impl From<ClientAddresses> for ClientConfig {
+    fn from(addresses: ClientAddresses) -> Self {
+        Self {
+            prefixes: [
+                addresses.ipv4.map(|address| ClientPrefix {
+                    address: address.into(),
+                    prefix_len: 32,
+                }),
+                addresses.ipv6.map(|address| ClientPrefix {
+                    address: address.into(),
+                    prefix_len: 128,
+                }),
+            ],
+            receive_packet_limit: 0,
+            path_mtu_discovery: false,
+        }
+    }
+}
+
+impl ClientConfig {
+    /// Normalizes mapped addresses and duplicate source candidates, then
+    /// checks the active family's MTU and the separate receive allocation bound.
+    ///
+    /// # Errors
+    ///
+    /// Returns a configuration error for invalid or non-unicast prefixes,
+    /// subnet broadcasts, missing local addresses, or invalid packet bounds.
+    pub fn validate(mut self, mtu: usize) -> Result<Self, ConfigError> {
+        let mut normalized = [None; 2];
+        for (slot, prefix) in self.prefixes.into_iter().enumerate() {
+            let Some(mut prefix) = prefix else { continue };
+            if let IpAddr::V6(address) = prefix.address
+                && let Some(address) = address.to_ipv4_mapped()
+            {
+                prefix.address = address.into();
+                prefix.prefix_len = prefix
+                    .prefix_len
+                    .checked_sub(96)
+                    .ok_or(ConfigError::ClientPrefix)?;
+            }
+            let maximum = if prefix.address.is_ipv4() { 32 } else { 128 };
+            if prefix.prefix_len > maximum {
+                return Err(ConfigError::ClientPrefix);
+            }
+            match prefix.address {
+                IpAddr::V4(address) => {
+                    if address.is_unspecified() || address.is_multicast() {
+                        return Err(ConfigError::ClientAddress("IPv4"));
+                    }
+                    if address.is_broadcast() || subnet_broadcast(prefix, false) == Some(address) {
+                        return Err(ConfigError::ClientBroadcast);
+                    }
+                }
+                IpAddr::V6(address) => {
+                    if address.is_unspecified() || address.is_multicast() {
+                        return Err(ConfigError::ClientAddress("IPv6"));
+                    }
+                }
+            }
+            normalized[slot] = Some(prefix);
+        }
+        if normalized.iter().all(Option::is_none) {
+            return Err(ConfigError::NoClientAddress);
+        }
+
+        // An address supplied under one prefix can be another supplied
+        // prefix's subnet broadcast. Check before merging duplicate sources.
+        for prefix in normalized.into_iter().flatten() {
+            if let Some(broadcast) = subnet_broadcast(prefix, true)
+                && normalized
+                    .iter()
+                    .flatten()
+                    .any(|source| source.address == IpAddr::V4(broadcast))
+            {
+                return Err(ConfigError::ClientBroadcast);
+            }
+        }
+
+        self.prefixes = [None; 2];
+        let mut count = 0;
+        for prefix in normalized.into_iter().flatten() {
+            if let Some(existing) = self.prefixes[..count]
+                .iter_mut()
+                .flatten()
+                .find(|existing| existing.address == prefix.address)
+            {
+                existing.prefix_len = existing.prefix_len.max(prefix.prefix_len);
+            } else {
+                self.prefixes[count] = Some(prefix);
+                count += 1;
+            }
+        }
+        let minimum = if self.has_ipv6() { 1_280 } else { 68 };
+        if !(minimum..=65_535).contains(&mtu) {
+            return Err(ConfigError::ClientMtu {
+                value: mtu,
+                minimum,
+            });
+        }
+        if self.receive_packet_limit == 0 {
+            self.receive_packet_limit = mtu;
+        }
+        if !(1..=MAX_RECEIVE_PACKET_SIZE).contains(&self.receive_packet_limit) {
+            return Err(ConfigError::ReceivePacketLimit(self.receive_packet_limit));
+        }
+        Ok(self)
+    }
+
+    /// Iterates the at most two canonical source candidates in stable order.
+    pub fn prefixes(&self) -> impl Iterator<Item = ClientPrefix> + '_ {
+        self.prefixes.iter().copied().flatten()
+    }
+
+    #[must_use]
+    pub fn has_ipv6(&self) -> bool {
+        self.prefixes().any(|prefix| prefix.address.is_ipv6())
+    }
+
+    #[must_use]
+    pub fn contains_address(&self, address: IpAddr) -> bool {
+        let address = unmap(address);
+        self.prefixes().any(|prefix| prefix.address == address)
+    }
+
+    /// Selects an actual local source with the applicable RFC 6724 rules.
+    /// Configured addresses are stable and non-deprecated on a single output
+    /// interface, so those rules are ties. Complete ties retain input order.
+    ///
+    /// # Errors
+    ///
+    /// Returns an I/O error for an invalid destination or unavailable family.
+    pub fn source_for(&self, destination: IpAddr) -> io::Result<IpAddr> {
+        let destination = unmap(destination);
+        if destination.is_unspecified()
+            || destination.is_multicast()
+            || matches!(destination, IpAddr::V4(ip) if ip.is_broadcast())
+        {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "invalid client peer",
+            ));
+        }
+        if destination.is_loopback() && !self.contains_address(destination) {
+            return Err(io::Error::new(
+                io::ErrorKind::NetworkUnreachable,
+                "client loopback peer is not a local address",
+            ));
+        }
+        let mut selected = None;
+        for candidate in self
+            .prefixes()
+            .filter(|prefix| prefix.address.is_ipv4() == destination.is_ipv4())
+        {
+            if selected.is_none_or(|current| prefer_source(candidate, current, destination)) {
+                selected = Some(candidate);
+            }
+        }
+        selected.map(|prefix| prefix.address).ok_or_else(|| {
+            io::Error::new(
+                io::ErrorKind::AddrNotAvailable,
+                "active client source family is unavailable",
+            )
+        })
+    }
+}
+
+fn unmap(address: IpAddr) -> IpAddr {
+    match address {
+        IpAddr::V6(ip) => ip.to_ipv4_mapped().map_or(address, IpAddr::V4),
+        IpAddr::V4(_) => address,
+    }
+}
+
+fn subnet_broadcast(prefix: ClientPrefix, skip_loopback: bool) -> Option<Ipv4Addr> {
+    let IpAddr::V4(address) = prefix.address else {
+        return None;
+    };
+    if prefix.prefix_len >= 31 || (skip_loopback && address.is_loopback()) {
+        return None;
+    }
+    let host_mask = u32::try_from((1_u64 << (32 - prefix.prefix_len)) - 1).ok()?;
+    Some(Ipv4Addr::from(u32::from(address) | host_mask))
+}
+
+fn prefer_source(candidate: ClientPrefix, current: ClientPrefix, destination: IpAddr) -> bool {
+    if candidate.address == destination || current.address == destination {
+        return candidate.address == destination;
+    }
+    let candidate_scope = scope(candidate.address);
+    let current_scope = scope(current.address);
+    let destination_scope = scope(destination);
+    if candidate_scope != current_scope {
+        let candidate_appropriate = candidate_scope >= destination_scope;
+        let current_appropriate = current_scope >= destination_scope;
+        if candidate_appropriate != current_appropriate {
+            return candidate_appropriate;
+        }
+        return if candidate_appropriate {
+            candidate_scope < current_scope
+        } else {
+            candidate_scope > current_scope
+        };
+    }
+    let matching_label = |source| label(source) == label(destination);
+    if matching_label(candidate.address) != matching_label(current.address) {
+        return matching_label(candidate.address);
+    }
+    common_prefix(candidate, destination) > common_prefix(current, destination)
+}
+
+fn scope(address: IpAddr) -> u8 {
+    if address.is_loopback() {
+        return 2;
+    }
+    match address {
+        IpAddr::V4(ip) if ip.is_link_local() => 2,
+        IpAddr::V6(ip) => {
+            let bytes = ip.octets();
+            if bytes[0] == 0xfe && bytes[1] & 0xc0 == 0x80 {
+                2
+            } else if bytes[0] == 0xfe && bytes[1] & 0xc0 == 0xc0 {
+                5
+            } else {
+                14
+            }
+        }
+        IpAddr::V4(_) => 14,
+    }
+}
+
+fn label(address: IpAddr) -> u8 {
+    let IpAddr::V6(ip) = address else { return 4 };
+    if ip.is_loopback() {
+        return 0;
+    }
+    let bytes = ip.octets();
+    if bytes[..2] == [0x20, 0x02] {
+        2
+    } else if bytes[..4] == [0x20, 0x01, 0, 0] {
+        5
+    } else if bytes[0] & 0xfe == 0xfc {
+        13
+    } else if bytes[0] == 0xfe && bytes[1] & 0xc0 == 0xc0 {
+        11
+    } else if bytes[..2] == [0x3f, 0xfe] {
+        12
+    } else if bytes[..12] == [0; 12] {
+        3
+    } else {
+        1
+    }
+}
+
+fn common_prefix(source: ClientPrefix, destination: IpAddr) -> u8 {
+    let differing = match (source.address, destination) {
+        (IpAddr::V4(a), IpAddr::V4(b)) => (u32::from(a) ^ u32::from(b)).leading_zeros(),
+        (IpAddr::V6(a), IpAddr::V6(b)) => (u128::from(a) ^ u128::from(b)).leading_zeros(),
+        _ => return 0,
+    };
+    u8::try_from(differing)
+        .unwrap_or(128)
+        .min(source.prefix_len)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn prefix(address: &str, prefix_len: u8) -> ClientPrefix {
+        ClientPrefix {
+            address: address.parse().unwrap(),
+            prefix_len,
+        }
+    }
+
+    #[test]
+    fn source_selection_keeps_two_same_family_candidates_and_prefix_bounds() {
+        let config = ClientConfig {
+            prefixes: [
+                Some(prefix("2001:db8:1::2", 48)),
+                Some(prefix("2001:db8:2::2", 48)),
+            ],
+            ..Default::default()
+        }
+        .validate(1280)
+        .unwrap();
+        assert_eq!(
+            config.source_for("2001:db8:1::9".parse().unwrap()).unwrap(),
+            "2001:db8:1::2".parse::<IpAddr>().unwrap()
+        );
+        assert_eq!(
+            config.source_for("2001:db8:2::9".parse().unwrap()).unwrap(),
+            "2001:db8:2::2".parse::<IpAddr>().unwrap()
+        );
+        // Equal configured /32 matches tie even though the second address is
+        // closer beyond those bits; the first candidate must stay selected.
+        let config = ClientConfig {
+            prefixes: [
+                Some(prefix("2001:db8:1::2", 32)),
+                Some(prefix("2001:db8:2::2", 32)),
+            ],
+            ..config
+        }
+        .validate(1280)
+        .unwrap();
+        assert_eq!(
+            config.source_for("2001:db8:2::9".parse().unwrap()).unwrap(),
+            "2001:db8:1::2".parse::<IpAddr>().unwrap()
+        );
+        let config = ClientConfig {
+            prefixes: [Some(prefix("fe80::2", 64)), Some(prefix("2001:db8::2", 64))],
+            ..config
+        }
+        .validate(1280)
+        .unwrap();
+        assert_eq!(
+            config.source_for("fe80::9".parse().unwrap()).unwrap(),
+            "fe80::2".parse::<IpAddr>().unwrap()
+        );
+        assert_eq!(
+            config.source_for("2001:db8::9".parse().unwrap()).unwrap(),
+            "2001:db8::2".parse::<IpAddr>().unwrap()
+        );
+    }
+
+    #[test]
+    fn mapped_duplicates_and_broadcasts_follow_actual_prefixes() {
+        for prefixes in [
+            [
+                Some(prefix("::ffff:10.23.0.2", 120)),
+                Some(prefix("10.23.0.2", 32)),
+            ],
+            [
+                Some(prefix("10.23.0.2", 32)),
+                Some(prefix("::ffff:10.23.0.2", 120)),
+            ],
+        ] {
+            let config = ClientConfig {
+                prefixes,
+                ..Default::default()
+            }
+            .validate(68)
+            .unwrap();
+            assert_eq!(
+                config.prefixes().collect::<Vec<_>>(),
+                vec![ClientPrefix {
+                    address: "10.23.0.2".parse().unwrap(),
+                    prefix_len: 32
+                }]
+            );
+            assert!(!config.has_ipv6());
+        }
+        for prefixes in [
+            [Some(prefix("10.23.0.255", 24)), None],
+            [
+                Some(prefix("10.23.0.2", 24)),
+                Some(prefix("10.23.0.255", 32)),
+            ],
+        ] {
+            assert_eq!(
+                ClientConfig {
+                    prefixes,
+                    ..Default::default()
+                }
+                .validate(68),
+                Err(ConfigError::ClientBroadcast)
+            );
+        }
+        ClientConfig {
+            prefixes: [Some(prefix("10.23.0.255", 31)), None],
+            ..Default::default()
+        }
+        .validate(68)
+        .unwrap();
+    }
+
+    #[test]
+    fn active_family_mtu_and_receive_budget_leave_passive_bounds_intact() {
+        let ipv4 = ClientConfig {
+            prefixes: [Some(prefix("10.23.0.2", 24)), None],
+            receive_packet_limit: MAX_RECEIVE_PACKET_SIZE,
+            path_mtu_discovery: true,
+        };
+        let ipv4 = ipv4.validate(68).unwrap();
+        assert_eq!(ipv4.receive_packet_limit, MAX_RECEIVE_PACKET_SIZE);
+        let config = crate::NetStackConfig {
+            mtu: 68,
+            ..Default::default()
+        };
+        config.validate_client(&ipv4).unwrap();
+        assert_eq!(config.validate(), Err(ConfigError::Mtu(68)));
+        let ipv6 = ClientConfig {
+            prefixes: [Some(prefix("fd23::2", 64)), None],
+            ..ipv4
+        };
+        assert!(matches!(
+            ipv6.validate(1279),
+            Err(ConfigError::ClientMtu { minimum: 1280, .. })
+        ));
+        ipv6.validate(1280).unwrap();
+        let legacy = ClientConfig::from(ClientAddresses {
+            ipv4: Some(Ipv4Addr::new(10, 23, 0, 2)),
+            ipv6: None,
+        })
+        .validate(1500)
+        .unwrap();
+        assert_eq!(legacy.receive_packet_limit, 1500);
+        assert!(!legacy.path_mtu_discovery);
+    }
+}
diff --git a/crates/vole-netstack/src/config.rs b/crates/vole-netstack/src/config.rs
index 86d6c5d..cca0402 100644
--- a/crates/vole-netstack/src/config.rs
+++ b/crates/vole-netstack/src/config.rs
@@ -1,12 +1,24 @@
-use std::time::Duration;
+use std::{
+    net::{Ipv4Addr, Ipv6Addr},
+    time::Duration,
+};
 
 use thiserror::Error;
 
+/// Configured source addresses for an active raw-IP client stack.
+///
+/// An omitted family is unavailable; the driver never invents a source address.
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub struct ClientAddresses {
+    pub ipv4: Option<Ipv4Addr>,
+    pub ipv6: Option<Ipv6Addr>,
+}
+
 /// Finite buffering and timing configuration for one netstack instance.
 ///
 /// Queue counts are hard limits. Each TCP buffer includes both the smoltcp
 /// socket buffer and the application-facing queue for one flow in that
-/// direction. Each layer reserves half of the configured total.
+/// direction. Each layer is bounded to half of the configured total.
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct NetStackConfig {
     /// Maximum raw IP packet size and the IP-medium MTU advertised to smoltcp.
@@ -59,6 +71,24 @@ impl NetStackConfig {
         if !(1_280..=65_535).contains(&self.mtu) {
             return Err(ConfigError::Mtu(self.mtu));
         }
+        self.validate_resources()
+    }
+
+    pub(crate) fn validate_client(
+        &self,
+        client: &crate::client::ClientConfig,
+    ) -> Result<(), ConfigError> {
+        let minimum = if client.has_ipv6() { 1_280 } else { 68 };
+        if !(minimum..=65_535).contains(&self.mtu) {
+            return Err(ConfigError::ClientMtu {
+                value: self.mtu,
+                minimum,
+            });
+        }
+        self.validate_resources()
+    }
+
+    fn validate_resources(&self) -> Result<(), ConfigError> {
         for (name, value) in [
             ("packet_queue", self.packet_queue),
             ("tcp_accept_queue", self.tcp_accept_queue),
@@ -96,6 +126,18 @@ impl NetStackConfig {
 
 #[derive(Debug, Error, Eq, PartialEq)]
 pub enum ConfigError {
+    #[error("active netstack requires at least one configured source address")]
+    NoClientAddress,
+    #[error("active netstack {0} source address must be unicast")]
+    ClientAddress(&'static str),
+    #[error("active netstack source prefix is invalid")]
+    ClientPrefix,
+    #[error("active netstack source address is a subnet broadcast")]
+    ClientBroadcast,
+    #[error("active netstack MTU must be between {minimum} and 65535 bytes, got {value}")]
+    ClientMtu { value: usize, minimum: usize },
+    #[error("active netstack receive packet limit must be between 1 and 65575 bytes, got {0}")]
+    ReceivePacketLimit(usize),
     #[error("MTU must be between 1280 and 65535 bytes, got {0}")]
     Mtu(usize),
     #[error("resource limit `{0}` must be greater than zero")]
diff --git a/crates/vole-netstack/src/device.rs b/crates/vole-netstack/src/device.rs
index dbfc78d..e17ea08 100644
--- a/crates/vole-netstack/src/device.rs
+++ b/crates/vole-netstack/src/device.rs
@@ -4,14 +4,34 @@ use smoltcp::{
 };
 use tokio::sync::mpsc;
 
-use crate::Packet;
+use crate::{
+    Packet,
+    pmtu::PathMtuHint,
+    segmentation::{PathMtu, PendingSegments, is_pure_tcp_ack, reverse},
+    tcp::FlowKey,
+};
+
+enum PendingTransmit {
+    Segments(PendingSegments),
+    Reply(Packet),
+}
+impl PendingTransmit {
+    fn flow(&self) -> Option<FlowKey> {
+        match self {
+            Self::Segments(segments) => Some(segments.flow()),
+            Self::Reply(packet) => PendingSegments::new(packet.clone()).map(|part| part.flow()),
+        }
+    }
+}
 
-/// A raw-IP device with one pending ingress and reserved bounded output slots.
+/// A raw-IP device with one pending ingress and one bounded pending output.
 pub(crate) struct RawIpDevice {
     rx: Option<Packet>,
     output: mpsc::Sender<Packet>,
     emitted: u64,
     capabilities: DeviceCapabilities,
+    pending_tx: Option<PendingTransmit>,
+    path_mtu: Option<PathMtu>,
 }
 
 impl RawIpDevice {
@@ -24,6 +44,8 @@ impl RawIpDevice {
             output,
             emitted: 0,
             capabilities,
+            pending_tx: None,
+            path_mtu: None,
         }
     }
 
@@ -53,7 +75,94 @@ impl RawIpDevice {
     }
 
     pub(crate) fn tx_is_full(&self) -> bool {
-        self.output.capacity() == 0
+        self.pending_tx.is_some() || self.output.capacity() == 0
+    }
+
+    pub(crate) fn enable_path_mtu(&mut self) {
+        self.path_mtu = Some(PathMtu::default());
+    }
+
+    pub(crate) fn disable_path_mtu(&mut self) {
+        self.path_mtu = None;
+    }
+
+    pub(crate) fn set_initial_mtu(&mut self, mtu: usize) {
+        self.capabilities.max_transmission_unit = mtu;
+    }
+
+    pub(crate) fn apply_path_mtu(&mut self, hint: PathMtuHint) -> bool {
+        self.path_mtu
+            .as_mut()
+            .is_some_and(|paths| paths.apply(hint, self.capabilities.max_transmission_unit))
+    }
+
+    pub(crate) fn acknowledge(&mut self, packet: &Packet) {
+        if let Some(paths) = &mut self.path_mtu {
+            paths.acknowledge(packet);
+        }
+    }
+
+    pub(crate) fn forget_flow(&mut self, incoming: FlowKey) {
+        let outgoing = reverse(incoming);
+        if let Some(paths) = &mut self.path_mtu {
+            paths.forget(outgoing);
+        }
+        if self
+            .pending_tx
+            .as_ref()
+            .is_some_and(|pending| pending.flow() == Some(outgoing))
+        {
+            self.pending_tx = None;
+        }
+    }
+
+    pub(crate) fn clear(&mut self) {
+        self.rx = None;
+        self.pending_tx = None;
+        self.path_mtu = None;
+    }
+
+    /// Drain only into the existing raw output queue, without waiting. Every
+    /// segment reserves its slot before allocating a packet. A partial drain
+    /// retains one original packet and resumes on `PacketStream` notification.
+    pub(crate) fn flush_pending(&mut self) {
+        while let Some(pending) = &mut self.pending_tx {
+            let Ok(permit) = self.output.try_reserve() else {
+                break;
+            };
+            if matches!(pending, PendingTransmit::Reply(_)) {
+                let Some(PendingTransmit::Reply(packet)) = self.pending_tx.take() else {
+                    unreachable!();
+                };
+                if let Some(paths) = &mut self.path_mtu {
+                    paths.emitted(&packet);
+                }
+                permit.send(packet);
+                self.emitted = self.emitted.wrapping_add(1);
+                continue;
+            }
+            let PendingTransmit::Segments(pending) = pending else {
+                unreachable!();
+            };
+            let budget = self
+                .path_mtu
+                .as_ref()
+                .map_or(self.capabilities.max_transmission_unit, |paths| {
+                    paths.budget(pending.flow(), self.capabilities.max_transmission_unit)
+                });
+            let Some(packet) = pending.next(budget) else {
+                self.pending_tx = None;
+                break;
+            };
+            if let Some(paths) = &mut self.path_mtu {
+                paths.emitted(&packet);
+            }
+            permit.send(packet);
+            self.emitted = self.emitted.wrapping_add(1);
+            if pending.is_finished() {
+                self.pending_tx = None;
+            }
+        }
     }
 }
 
@@ -64,21 +173,41 @@ impl Device for RawIpDevice {
     fn receive(&mut self, _timestamp: Instant) -> Option<(Self::RxToken<'_>, Self::TxToken<'_>)> {
         // Reserve before consuming ingress: smoltcp can need an immediate
         // response, and concurrent generic UDP senders share this capacity.
-        let permit = self.output.try_reserve().ok()?;
+        if self.pending_tx.is_some() {
+            return None;
+        }
+        let permit = match self.output.try_reserve() {
+            Ok(permit) => Some(permit),
+            Err(mpsc::error::TrySendError::Full(()))
+                if self.rx.as_ref().is_some_and(is_pure_tcp_ack) =>
+            {
+                None
+            }
+            Err(_) => return None,
+        };
         let packet = self.rx.take()?;
         Some((
             RawRxToken(packet),
             RawTxToken {
                 permit,
                 emitted: &mut self.emitted,
+                pending: &mut self.pending_tx,
+                path_mtu: &mut self.path_mtu,
+                mtu: self.capabilities.max_transmission_unit,
             },
         ))
     }
 
     fn transmit(&mut self, _timestamp: Instant) -> Option<Self::TxToken<'_>> {
+        if self.pending_tx.is_some() {
+            return None;
+        }
         Some(RawTxToken {
-            permit: self.output.try_reserve().ok()?,
+            permit: Some(self.output.try_reserve().ok()?),
             emitted: &mut self.emitted,
+            pending: &mut self.pending_tx,
+            path_mtu: &mut self.path_mtu,
+            mtu: self.capabilities.max_transmission_unit,
         })
     }
 
@@ -99,8 +228,11 @@ impl RxToken for RawRxToken {
 }
 
 pub(crate) struct RawTxToken<'a> {
-    permit: mpsc::Permit<'a, Packet>,
+    permit: Option<mpsc::Permit<'a, Packet>>,
     emitted: &'a mut u64,
+    pending: &'a mut Option<PendingTransmit>,
+    path_mtu: &'a mut Option<PathMtu>,
+    mtu: usize,
 }
 
 impl TxToken for RawTxToken<'_> {
@@ -110,7 +242,35 @@ impl TxToken for RawTxToken<'_> {
     {
         let mut bytes = vec![0_u8; len];
         let result = f(&mut bytes);
-        self.permit.send(Packet::new(bytes));
+        let mut packet = Packet::new(bytes);
+        let Some(permit) = self.permit else {
+            // A pure incoming ACK can still require a challenge ACK or RST.
+            // Preserve that response in the existing single pending slot;
+            // never acknowledge a generated reply by silently dropping it.
+            *self.pending = Some(PendingTransmit::Reply(packet));
+            return result;
+        };
+        if let Some(paths) = self.path_mtu.as_mut() {
+            // Metadata parsing is limited to trusted smoltcp output. Packets
+            // within the path budget keep their allocation and byte contents.
+            if let Some(mut pending) = PendingSegments::new(packet.clone()) {
+                let budget = paths.budget(pending.flow(), self.mtu);
+                if packet.len() > budget {
+                    let Some(first) = pending.next(budget) else {
+                        return result;
+                    };
+                    packet = first;
+                    if !pending.is_finished() {
+                        *self.pending = Some(PendingTransmit::Segments(pending));
+                    }
+                }
+            } else if packet.len() > self.mtu {
+                // No UDP boundary splitting or implicit IP fragmentation.
+                return result;
+            }
+            paths.emitted(&packet);
+        }
+        permit.send(packet);
         *self.emitted = self.emitted.wrapping_add(1);
         result
     }
@@ -120,6 +280,129 @@ impl TxToken for RawTxToken<'_> {
 mod tests {
     use super::*;
 
+    #[test]
+    fn full_tx_consumes_pure_ack_without_allocating_an_output_or_queue() {
+        use crate::segmentation::tests::tcp_packet;
+        let flow = FlowKey {
+            source: "10.23.0.2:4000".parse().unwrap(),
+            destination: "198.51.100.2:443".parse().unwrap(),
+        };
+        let (output, mut receiver) = mpsc::channel(1);
+        let mut device = RawIpDevice::new(1500, output.clone());
+        let occupied = Packet::new(vec![0x45; 40]);
+        output.try_send(occupied.clone()).unwrap();
+        for acknowledgment in 10..13 {
+            let ack = tcp_packet(flow, 1, acknowledgment, 16, 0);
+            device.push_rx(ack.clone()).unwrap();
+            let (rx, tx) = device
+                .receive(Instant::now())
+                .expect("full TX blocked pure TCP ACK");
+            rx.consume(|bytes| assert_eq!(bytes, ack.data()));
+            drop(tx); // Valid ordinary ACKs do not require an immediate reply.
+            assert!(device.rx_is_empty());
+            assert!(device.pending_tx.is_none());
+            assert_eq!(device.emitted(), 0);
+            assert_eq!(output.capacity(), 0);
+        }
+        assert_eq!(receiver.try_recv().unwrap(), occupied);
+        assert!(receiver.try_recv().is_err());
+    }
+
+    #[test]
+    fn full_tx_preserves_ack_or_reset_reply_in_the_existing_pending_slot() {
+        use crate::segmentation::tests::tcp_packet;
+        let flow = FlowKey {
+            source: "10.23.0.2:4000".parse().unwrap(),
+            destination: "198.51.100.2:443".parse().unwrap(),
+        };
+        for flags in [16, 20] {
+            let (output, mut receiver) = mpsc::channel(1);
+            let mut device = RawIpDevice::new(1500, output.clone());
+            device.enable_path_mtu();
+            let occupied = Packet::new(vec![0x45; 40]);
+            output.try_send(occupied.clone()).unwrap();
+            device.push_rx(tcp_packet(flow, 1, 10, 16, 0)).unwrap();
+            let (rx, tx) = device
+                .receive(Instant::now())
+                .expect("pure ACK did not enter");
+            rx.consume(|_| {});
+            let response = tcp_packet(reverse(flow), 10, 1, flags, 0);
+            tx.consume(response.len(), |bytes| {
+                bytes.copy_from_slice(response.data());
+            });
+            assert!(device.pending_tx.is_some());
+            assert_eq!(device.emitted(), 0);
+            assert!(device.transmit(Instant::now()).is_none());
+            device.flush_pending();
+            assert_eq!(device.emitted(), 0); // Never overwrite or bypass full output.
+            assert_eq!(receiver.try_recv().unwrap(), occupied);
+            device.flush_pending();
+            assert_eq!(receiver.try_recv().unwrap(), response);
+            assert_eq!(device.emitted(), 1);
+            assert!(device.pending_tx.is_none());
+            assert!(receiver.try_recv().is_err());
+        }
+    }
+
+    #[test]
+    fn full_tx_keeps_syn_data_fin_urgent_and_invalid_ack_pending() {
+        use crate::segmentation::tests::tcp_packet;
+        let flow = FlowKey {
+            source: "10.23.0.2:4000".parse().unwrap(),
+            destination: "198.51.100.2:443".parse().unwrap(),
+        };
+        let mut inputs = vec![
+            tcp_packet(flow, 1, 0, 2, 0),
+            tcp_packet(flow, 1, 10, 16, 1),
+            tcp_packet(flow, 1, 10, 17, 0),
+            tcp_packet(flow, 1, 10, 20, 0),
+            tcp_packet(flow, 1, 10, 48, 0),
+        ];
+        let mut invalid = tcp_packet(flow, 1, 10, 16, 0).data().to_vec();
+        *invalid.last_mut().unwrap() ^= 1;
+        inputs.push(Packet::new(invalid));
+        for input in inputs {
+            let (output, _receiver) = mpsc::channel(1);
+            let mut device = RawIpDevice::new(1500, output.clone());
+            output.try_send(Packet::new(vec![0x45; 40])).unwrap();
+            device.push_rx(input).unwrap();
+            assert!(device.receive(Instant::now()).is_none());
+            assert!(!device.rx_is_empty());
+            assert!(device.pending_tx.is_none());
+        }
+    }
+
+    #[test]
+    fn full_tx_pending_reply_blocks_a_second_ack_and_clear_releases_both() {
+        use crate::segmentation::tests::tcp_packet;
+        let flow = FlowKey {
+            source: "10.23.0.2:4000".parse().unwrap(),
+            destination: "198.51.100.2:443".parse().unwrap(),
+        };
+        let (output, mut receiver) = mpsc::channel(1);
+        let mut device = RawIpDevice::new(1500, output.clone());
+        output.try_send(Packet::new(vec![0x45; 40])).unwrap();
+        device.push_rx(tcp_packet(flow, 1, 10, 16, 0)).unwrap();
+        let (rx, tx) = device
+            .receive(Instant::now())
+            .expect("pure ACK did not enter");
+        rx.consume(|_| {});
+        let response = tcp_packet(reverse(flow), 10, 1, 16, 0);
+        tx.consume(response.len(), |bytes| {
+            bytes.copy_from_slice(response.data());
+        });
+        device.push_rx(tcp_packet(flow, 1, 11, 16, 0)).unwrap();
+        assert!(device.receive(Instant::now()).is_none());
+        assert!(device.transmit(Instant::now()).is_none());
+        assert!(device.pending_tx.is_some() && !device.rx_is_empty());
+        device.clear();
+        assert!(device.pending_tx.is_none() && device.rx_is_empty());
+        receiver.try_recv().unwrap();
+        device.flush_pending();
+        assert!(receiver.try_recv().is_err());
+        assert_eq!(device.emitted(), 0);
+    }
+
     #[test]
     fn full_tx_queue_does_not_consume_rx() {
         let (output, mut receiver) = mpsc::channel(1);
@@ -187,4 +470,90 @@ mod tests {
         assert!(device.transmit(Instant::now()).is_none());
         assert!(!device.rx_is_empty());
     }
+
+    #[test]
+    fn split_output_resumes_with_one_reserved_slot_and_adopts_a_smaller_budget() {
+        use crate::segmentation::tests::{hint, tcp_packet};
+        let flow = FlowKey {
+            source: "10.23.0.2:4000".parse().unwrap(),
+            destination: "198.51.100.2:443".parse().unwrap(),
+        };
+        let (output, mut receiver) = mpsc::channel(1);
+        let mut device = RawIpDevice::new(9000, output);
+        device.enable_path_mtu();
+        let first = tcp_packet(flow, 1000, 91, 16, 7000);
+        device
+            .transmit(Instant::now())
+            .unwrap()
+            .consume(first.len(), |bytes| bytes.copy_from_slice(first.data()));
+        let emitted = receiver.try_recv().unwrap();
+        assert!(device.apply_path_mtu(hint(&emitted, 1280)));
+
+        let next = tcp_packet(flow, 10000, 91, 16, 7000);
+        device
+            .transmit(Instant::now())
+            .unwrap()
+            .consume(next.len(), |bytes| bytes.copy_from_slice(next.data()));
+        assert_eq!(device.emitted(), 2);
+        assert!(device.pending_tx.is_some() && device.transmit(Instant::now()).is_none());
+        device.flush_pending();
+        assert_eq!(device.emitted(), 2); // full queue, no segment allocation
+        let segment = receiver.try_recv().unwrap();
+        assert_eq!(segment.len(), 1280);
+        let mut unsent = hint(&segment, 576);
+        unsent.sequence = 12000; // original exists, this tail has not left it
+        assert!(!device.apply_path_mtu(unsent));
+        assert!(device.apply_path_mtu(hint(&segment, 576)));
+        let mut payload_size = segment.len() - 56;
+        while device.pending_tx.is_some() {
+            device.flush_pending();
+            let packet = receiver.try_recv().unwrap();
+            assert!(packet.len() <= 576);
+            payload_size += packet.len() - 56;
+        }
+        assert_eq!(payload_size, 7000);
+        assert!(device.transmit(Instant::now()).is_some());
+        // New oversized output can be discarded synchronously without having
+        // to drain the consumer, including its retained original allocation.
+        device
+            .transmit(Instant::now())
+            .unwrap()
+            .consume(next.len(), |bytes| bytes.copy_from_slice(next.data()));
+        assert!(device.pending_tx.is_some());
+        device.clear();
+        assert!(device.pending_tx.is_none() && device.path_mtu.is_none());
+    }
+
+    #[test]
+    fn reclaimed_tuple_discards_pending_bytes_and_old_quote_authorization() {
+        use crate::segmentation::tests::{hint, tcp_packet};
+        let flow = FlowKey {
+            source: "10.23.0.2:4000".parse().unwrap(),
+            destination: "198.51.100.2:443".parse().unwrap(),
+        };
+        let (output, mut receiver) = mpsc::channel(1);
+        let mut device = RawIpDevice::new(1500, output);
+        device.enable_path_mtu();
+        let packet = tcp_packet(flow, 1000, 91, 16, 1400);
+        device
+            .transmit(Instant::now())
+            .unwrap()
+            .consume(packet.len(), |bytes| bytes.copy_from_slice(packet.data()));
+        let emitted = receiver.try_recv().unwrap();
+        assert!(device.apply_path_mtu(hint(&emitted, 576)));
+        device
+            .transmit(Instant::now())
+            .unwrap()
+            .consume(packet.len(), |bytes| bytes.copy_from_slice(packet.data()));
+        assert!(device.pending_tx.is_some());
+        device.forget_flow(reverse(flow));
+        assert!(device.pending_tx.is_none());
+        assert!(!device.apply_path_mtu(hint(&emitted, 296)));
+        receiver.try_recv().unwrap();
+        device
+            .transmit(Instant::now())
+            .unwrap()
+            .consume(packet.len(), |bytes| bytes.copy_from_slice(packet.data()));
+        assert_eq!(receiver.try_recv().unwrap().len(), packet.len());
+    }
 }
diff --git a/crates/vole-netstack/src/echo.rs b/crates/vole-netstack/src/echo.rs
new file mode 100644
index 0000000..ca27f3b
--- /dev/null
+++ b/crates/vole-netstack/src/echo.rs
@@ -0,0 +1,426 @@
+//! Checked Echo wire helpers. No socket, task, DNS or routing ownership.
+use std::net::{IpAddr, Ipv4Addr};
+
+use smoltcp::{
+    phy::ChecksumCapabilities,
+    wire::{
+        Icmpv4Packet, Icmpv4Repr, Icmpv6Packet, Icmpv6Repr, IpProtocol, IpRepr, Ipv4Packet,
+        Ipv4Repr, Ipv6Packet, Ipv6Repr,
+    },
+};
+
+/// The addresses here are the actual endpoints of this packet direction.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct EchoPacketView<'a> {
+    pub source: IpAddr,
+    pub destination: IpAddr,
+    pub identifier: u16,
+    pub sequence: u16,
+    pub payload: &'a [u8],
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq, thiserror::Error)]
+pub enum EchoPacketError {
+    #[error("Echo packet endpoints use different address families")]
+    AddressFamily,
+    #[error("Echo packet exceeds the current raw-IP MTU")]
+    Mtu,
+}
+
+/// Recognized Echo failures and unsupported raw-IP shapes cannot fall through
+/// to the existing synthetic responder. Other ICMP/error/PMTU remains `NotEcho`.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum EchoPacketClass<'a> {
+    NotEcho,
+    Rejected,
+    Request(EchoPacketView<'a>),
+}
+#[must_use]
+pub fn classify_echo_request(bytes: &[u8]) -> EchoPacketClass<'_> {
+    let recognized = match bytes.first().map(|b| b >> 4) {
+        Some(4) if bytes.get(9) == Some(&1) => {
+            // Includes non-initial fragments: no reassembly or local success.
+            if bytes.len() < 20 || u16::from_be_bytes([bytes[6], bytes[7]]) & 0x3fff != 0 {
+                return EchoPacketClass::Rejected;
+            }
+            let offset = usize::from(bytes[0] & 15) * 4;
+            if offset < 20 {
+                return EchoPacketClass::Rejected;
+            }
+            match bytes.get(offset) {
+                Some(8) => true,
+                None => return EchoPacketClass::Rejected,
+                _ => false,
+            }
+        }
+        Some(6) => match bytes.get(6) {
+            Some(58) => match bytes.get(40) {
+                Some(128) => true,
+                None => return EchoPacketClass::Rejected,
+                _ => false,
+            },
+            // The existing netstack dispatches the base next_header only and
+            // does not implement these extension chains, including PMTU in
+            // one. Make that unsupported-shape drop explicit before autoEcho.
+            Some(0 | 43 | 44 | 50 | 51 | 60) => return EchoPacketClass::Rejected,
+            _ => false,
+        },
+        _ => false,
+    };
+    if !recognized {
+        return EchoPacketClass::NotEcho;
+    }
+    parse_echo_request_view(bytes).map_or(EchoPacketClass::Rejected, EchoPacketClass::Request)
+}
+
+/// Classify only a complete, checksum-valid, unfragmented unicast Echo Request.
+/// None leaves ownership and dispatch of the original packet with the caller.
+#[must_use]
+pub fn parse_echo_request_view(bytes: &[u8]) -> Option<EchoPacketView<'_>> {
+    parse_echo_view(bytes, false)
+}
+
+fn unicast(address: IpAddr) -> bool {
+    match address {
+        IpAddr::V4(ip) => !ip.is_unspecified() && !ip.is_multicast() && ip != Ipv4Addr::BROADCAST,
+        IpAddr::V6(ip) => !ip.is_unspecified() && !ip.is_multicast(),
+    }
+}
+
+fn parse_echo_view(bytes: &[u8], reply: bool) -> Option<EchoPacketView<'_>> {
+    let caps = ChecksumCapabilities::default();
+    let (source, destination, identifier, sequence, payload) = match bytes.first()? >> 4 {
+        4 => {
+            let ip = Ipv4Packet::new_checked(bytes).ok()?;
+            if ip.next_header() != IpProtocol::Icmp
+                || usize::from(ip.total_len()) != bytes.len()
+                || ip.more_frags()
+                || ip.frag_offset() != 0
+            {
+                return None;
+            }
+            let repr = Ipv4Repr::parse(&ip, &caps).ok()?;
+            if repr.next_header != IpProtocol::Icmp {
+                return None;
+            }
+            let icmp = Icmpv4Packet::new_checked(ip.payload()).ok()?;
+            let (identifier, sequence, payload) = match Icmpv4Repr::parse(&icmp, &caps).ok()? {
+                Icmpv4Repr::EchoRequest {
+                    ident,
+                    seq_no,
+                    data,
+                } if !reply => (ident, seq_no, data),
+                Icmpv4Repr::EchoReply {
+                    ident,
+                    seq_no,
+                    data,
+                } if reply => (ident, seq_no, data),
+                _ => return None,
+            };
+            (
+                repr.src_addr.into(),
+                repr.dst_addr.into(),
+                identifier,
+                sequence,
+                payload,
+            )
+        }
+        6 => {
+            let ip = Ipv6Packet::new_checked(bytes).ok()?;
+            if ip.total_len() != bytes.len() || ip.next_header() != IpProtocol::Icmpv6 {
+                return None;
+            }
+            let repr = Ipv6Repr::parse(&ip).ok()?;
+            let icmp = Icmpv6Packet::new_checked(ip.payload()).ok()?;
+            let (identifier, sequence, payload) =
+                match Icmpv6Repr::parse(&repr.src_addr, &repr.dst_addr, &icmp, &caps).ok()? {
+                    Icmpv6Repr::EchoRequest {
+                        ident,
+                        seq_no,
+                        data,
+                    } if !reply => (ident, seq_no, data),
+                    Icmpv6Repr::EchoReply {
+                        ident,
+                        seq_no,
+                        data,
+                    } if reply => (ident, seq_no, data),
+                    _ => return None,
+                };
+            (
+                repr.src_addr.into(),
+                repr.dst_addr.into(),
+                identifier,
+                sequence,
+                payload,
+            )
+        }
+        _ => return None,
+    };
+    if !unicast(source) || !unicast(destination) {
+        return None;
+    }
+    Some(EchoPacketView {
+        source,
+        destination,
+        identifier,
+        sequence,
+        payload,
+    })
+}
+
+/// Validate a body returned by a Linux DGRAM ICMP socket. `source` comes from
+/// recvmsg's peer sockaddr, `destination` from `IP_PKTINFO/IPV6_PKTINFO`. The IPv6
+/// checksum therefore uses physical addresses, never the original TUN tuple.
+#[must_use]
+pub fn parse_echo_reply_body(
+    source: IpAddr,
+    destination: IpAddr,
+    bytes: &[u8],
+) -> Option<EchoPacketView<'_>> {
+    if !unicast(source) || !unicast(destination) {
+        return None;
+    }
+    let caps = ChecksumCapabilities::default();
+    let (identifier, sequence, payload) = match (source, destination) {
+        (IpAddr::V4(_), IpAddr::V4(_)) => {
+            let packet = Icmpv4Packet::new_checked(bytes).ok()?;
+            match Icmpv4Repr::parse(&packet, &caps).ok()? {
+                Icmpv4Repr::EchoReply {
+                    ident,
+                    seq_no,
+                    data,
+                } => (ident, seq_no, data),
+                _ => return None,
+            }
+        }
+        (IpAddr::V6(src), IpAddr::V6(dst)) => {
+            let packet = Icmpv6Packet::new_checked(bytes).ok()?;
+            match Icmpv6Repr::parse(&src, &dst, &packet, &caps).ok()? {
+                Icmpv6Repr::EchoReply {
+                    ident,
+                    seq_no,
+                    data,
+                } => (ident, seq_no, data),
+                _ => return None,
+            }
+        }
+        _ => return None,
+    };
+    Some(EchoPacketView {
+        source,
+        destination,
+        identifier,
+        sequence,
+        payload,
+    })
+}
+
+/// Build a reply from the peer-validated Echo body and the retained TUN tuple.
+/// The caller supplies reply-direction endpoints, not the original request.
+/// Allocation happens only after address-family and complete length checks.
+///
+/// # Errors
+/// Returns an error if the address families differ or the complete packet
+/// exceeds the raw-IP MTU or IP length limit.
+pub fn encode_echo_reply_into(
+    packet: &EchoPacketView<'_>,
+    mtu: usize,
+    frame: &mut Vec<u8>,
+) -> Result<(), EchoPacketError> {
+    emit_echo(packet, true, mtu, frame)
+}
+
+fn emit_echo(
+    packet: &EchoPacketView<'_>,
+    reply: bool,
+    mtu: usize,
+    frame: &mut Vec<u8>,
+) -> Result<(), EchoPacketError> {
+    if packet.source.is_ipv4() != packet.destination.is_ipv4() {
+        return Err(EchoPacketError::AddressFamily);
+    }
+    let body_len = 8usize
+        .checked_add(packet.payload.len())
+        .ok_or(EchoPacketError::Mtu)?;
+    let header_len = if packet.source.is_ipv4() {
+        20usize
+    } else {
+        40usize
+    };
+    let packet_len = header_len
+        .checked_add(body_len)
+        .ok_or(EchoPacketError::Mtu)?;
+    if packet_len > mtu || packet_len > usize::from(u16::MAX) {
+        return Err(EchoPacketError::Mtu);
+    }
+    let protocol = if packet.source.is_ipv4() {
+        IpProtocol::Icmp
+    } else {
+        IpProtocol::Icmpv6
+    };
+    let ip = IpRepr::new(
+        packet.source.into(),
+        packet.destination.into(),
+        protocol,
+        body_len,
+        64,
+    );
+    let caps = ChecksumCapabilities::default();
+    frame.clear();
+    frame.resize(packet_len, 0);
+    ip.emit(&mut frame[..], &caps);
+    match (packet.source, packet.destination) {
+        (IpAddr::V4(_), IpAddr::V4(_)) => {
+            let repr = if reply {
+                Icmpv4Repr::EchoReply {
+                    ident: packet.identifier,
+                    seq_no: packet.sequence,
+                    data: packet.payload,
+                }
+            } else {
+                Icmpv4Repr::EchoRequest {
+                    ident: packet.identifier,
+                    seq_no: packet.sequence,
+                    data: packet.payload,
+                }
+            };
+            repr.emit(
+                &mut Icmpv4Packet::new_unchecked(&mut frame[header_len..]),
+                &caps,
+            );
+        }
+        (IpAddr::V6(source), IpAddr::V6(destination)) => {
+            let repr = if reply {
+                Icmpv6Repr::EchoReply {
+                    ident: packet.identifier,
+                    seq_no: packet.sequence,
+                    data: packet.payload,
+                }
+            } else {
+                Icmpv6Repr::EchoRequest {
+                    ident: packet.identifier,
+                    seq_no: packet.sequence,
+                    data: packet.payload,
+                }
+            };
+            repr.emit(
+                &source,
+                &destination,
+                &mut Icmpv6Packet::new_unchecked(&mut frame[header_len..]),
+                &caps,
+            );
+        }
+        _ => return Err(EchoPacketError::AddressFamily),
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn request(ipv6: bool, payload: &[u8]) -> EchoPacketView<'_> {
+        EchoPacketView {
+            source: if ipv6 { "2001:db8::1" } else { "192.0.2.1" }
+                .parse()
+                .unwrap(),
+            destination: if ipv6 { "2001:db8::2" } else { "192.0.2.2" }
+                .parse()
+                .unwrap(),
+            identifier: 0xfedc,
+            sequence: 0xabcd,
+            payload,
+        }
+    }
+
+    #[test]
+    fn checked_echo_preserves_tuple_identity_odd_payload_and_both_checksums() {
+        for ipv6 in [false, true] {
+            for payload in [&b""[..], &b"a"[..], &b"odd-payload"[..]] {
+                let view = request(ipv6, payload);
+                let mut input = Vec::new();
+                emit_echo(&view, false, 1500, &mut input).unwrap();
+                let parsed = parse_echo_request_view(&input).unwrap();
+                assert_eq!(parsed, view);
+                assert_eq!(
+                    classify_echo_request(&input),
+                    EchoPacketClass::Request(view)
+                );
+                let reply = EchoPacketView {
+                    source: parsed.destination,
+                    destination: parsed.source,
+                    ..parsed
+                };
+                let mut frame = Vec::new();
+                encode_echo_reply_into(&reply, 1500, &mut frame).unwrap();
+                assert_eq!(parse_echo_view(&frame, true), Some(reply));
+                let header = if ipv6 { 40 } else { 20 };
+                assert_eq!(
+                    parse_echo_reply_body(reply.source, reply.destination, &frame[header..]),
+                    Some(reply)
+                );
+                assert!(parse_echo_request_view(&frame).is_none());
+            }
+        }
+    }
+
+    #[test]
+    fn malformed_echo_never_becomes_a_valid_forwarding_request() {
+        for ipv6 in [false, true] {
+            let mut valid = Vec::new();
+            emit_echo(&request(ipv6, b"odd"), false, 1500, &mut valid).unwrap();
+            let mut bad_checksum = valid.clone();
+            *bad_checksum.last_mut().unwrap() ^= 1;
+            assert!(parse_echo_request_view(&bad_checksum).is_none());
+            assert_eq!(
+                classify_echo_request(&bad_checksum),
+                EchoPacketClass::Rejected
+            );
+            let mut trailing = valid.clone();
+            trailing.push(0);
+            assert!(parse_echo_request_view(&trailing).is_none());
+            assert!(parse_echo_request_view(&valid[..valid.len() - 1]).is_none());
+        }
+        let mut fragmented = Vec::new();
+        emit_echo(&request(false, b"x"), false, 1500, &mut fragmented).unwrap();
+        fragmented[6] |= 0x20;
+        Ipv4Packet::new_unchecked(&mut fragmented[..]).fill_checksum();
+        assert!(parse_echo_request_view(&fragmented).is_none());
+        assert_eq!(
+            classify_echo_request(&fragmented),
+            EchoPacketClass::Rejected
+        );
+        let mut extension = vec![0u8; 56];
+        extension[0] = 0x60;
+        extension[6] = 44;
+        extension[40] = 58;
+        extension[48] = 128;
+        assert_eq!(classify_echo_request(&extension), EchoPacketClass::Rejected);
+    }
+
+    #[test]
+    fn reply_allocation_is_rejected_before_touching_the_existing_frame() {
+        let packet = request(true, b"payload");
+        let mut frame = vec![1, 2, 3];
+        let before_capacity = frame.capacity();
+        assert_eq!(
+            encode_echo_reply_into(&packet, 1, &mut frame),
+            Err(EchoPacketError::Mtu)
+        );
+        assert_eq!(frame, [1, 2, 3]);
+        assert_eq!(frame.capacity(), before_capacity);
+    }
+
+    #[test]
+    fn invalid_echo_code_is_dropped_but_non_echo_errors_keep_the_original_path() {
+        let mut packet = Vec::new();
+        emit_echo(&request(false, b"odd"), false, 1500, &mut packet).unwrap();
+        packet[21] = 1;
+        Icmpv4Packet::new_unchecked(&mut packet[20..]).fill_checksum();
+        assert_eq!(classify_echo_request(&packet), EchoPacketClass::Rejected);
+        packet[20] = 3;
+        packet[21] = 4;
+        Icmpv4Packet::new_unchecked(&mut packet[20..]).fill_checksum();
+        assert_eq!(classify_echo_request(&packet), EchoPacketClass::NotEcho);
+    }
+}
diff --git a/crates/vole-netstack/src/lib.rs b/crates/vole-netstack/src/lib.rs
index 8a3e591..08e74ae 100644
--- a/crates/vole-netstack/src/lib.rs
+++ b/crates/vole-netstack/src/lib.rs
@@ -5,21 +5,31 @@
 //! packets from [`PacketStream`]. TCP and UDP are exposed separately to the
 //! outbound dispatcher.
 
+mod client;
 mod config;
 mod device;
+mod echo;
 mod icmp;
 mod packet;
+mod pmtu;
+mod segmentation;
 mod stack;
 mod tcp;
 mod udp;
 
-pub use config::{ConfigError, NetStackConfig};
+pub use client::{ClientConfig, ClientPrefix, MAX_RECEIVE_PACKET_SIZE};
+pub use config::{ClientAddresses, ConfigError, NetStackConfig};
+pub use echo::{
+    EchoPacketClass, EchoPacketError, EchoPacketView, classify_echo_request,
+    encode_echo_reply_into, parse_echo_reply_body, parse_echo_request_view,
+};
 pub use packet::Packet;
+pub use pmtu::{PathMtuHint, build_packet_too_big, parse_path_mtu_hint};
 pub use stack::{
-    NetStack, NetStackControl, NetStackError, NetStackParts, NetStackStats, PacketSink,
-    PacketStream, ResourceSnapshot, TcpNetStackParts,
+    ClientNetStackParts, NetStack, NetStackControl, NetStackError, NetStackParts, NetStackStats,
+    PacketSink, PacketStream, ResourceSnapshot, TcpNetStackParts,
 };
-pub use tcp::{TcpListener, TcpStream};
+pub use tcp::{TcpConnector, TcpListener, TcpStream};
 pub use udp::{
     UdpDatagram, UdpError, UdpPacketView, UdpSender, UdpSocket, encode_udp_packet_into,
     parse_udp_packet_view,
diff --git a/crates/vole-netstack/src/pmtu.rs b/crates/vole-netstack/src/pmtu.rs
new file mode 100644
index 0000000..ee0e2a0
--- /dev/null
+++ b/crates/vole-netstack/src/pmtu.rs
@@ -0,0 +1,431 @@
+//! Client-only ICMP path feedback. Parsing borrows the packet and allocates no
+//! state; bounded egress metadata owns tuple/sequence correlation and path MTU.
+
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
+
+use crate::Packet;
+
+const TCP: u8 = 6;
+const UDP: u8 = 17;
+const ICMPV4: u8 = 1;
+const ICMPV6: u8 = 58;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct PathMtuHint {
+    pub outer_destination: IpAddr,
+    pub local: SocketAddr,
+    pub remote: SocketAddr,
+    pub sequence: u32,
+    pub mtu: usize,
+}
+
+/// Parses a complete ICMP Fragmentation Needed / Packet Too Big message and
+/// its possibly truncated TCP quotation. An embedded original IP total length
+/// can exceed the quotation length; eight TCP bytes suffice for correlation.
+///
+/// The caller must match the outer destination and local/remote tuple against
+/// an active client socket. Its packet adapter must validate the quoted sequence
+/// against actually emitted output before accepting any MTU reduction.
+#[must_use]
+pub fn parse_path_mtu_hint(packet: &[u8]) -> Option<PathMtuHint> {
+    let outer = complete_ip(packet)?;
+    let icmp = outer.payload;
+    if icmp.len() < 8 || !unicast(outer.source) || !unicast(outer.destination) {
+        return None;
+    }
+    let (mtu, quote) = match (outer.source, outer.protocol, icmp[0], icmp[1]) {
+        (IpAddr::V4(_), ICMPV4, 3, 4) => {
+            if checksum(icmp) != 0 {
+                return None;
+            }
+            let quote = &icmp[8..];
+            let mut mtu = usize::from(u16::from_be_bytes([icmp[6], icmp[7]]));
+            if mtu == 0 {
+                mtu = legacy_ipv4_mtu(quote)?;
+            }
+            (mtu.max(68), quote)
+        }
+        (IpAddr::V6(_), ICMPV6, 2, 0) => {
+            if transport_checksum(outer.source, outer.destination, ICMPV6, icmp) != 0 {
+                return None;
+            }
+            let mtu = usize::try_from(u32::from_be_bytes(icmp[4..8].try_into().ok()?)).ok()?;
+            // The frozen client reference discards this hint instead of
+            // replacing it with the IPv6 minimum link MTU.
+            if mtu < 1_280 {
+                return None;
+            }
+            (mtu, &icmp[8..])
+        }
+        _ => return None,
+    };
+    let quoted = quoted_ip(quote)?;
+    if quoted.protocol != TCP
+        || quoted.payload.len() < 8
+        || quoted.source.is_ipv4() != outer.source.is_ipv4()
+        || !unicast(quoted.source)
+        || !unicast(quoted.destination)
+    {
+        return None;
+    }
+    let tcp = quoted.payload;
+    Some(PathMtuHint {
+        outer_destination: outer.destination,
+        local: SocketAddr::new(quoted.source, u16::from_be_bytes([tcp[0], tcp[1]])),
+        remote: SocketAddr::new(quoted.destination, u16::from_be_bytes([tcp[2], tcp[3]])),
+        sequence: u32::from_be_bytes(tcp[4..8].try_into().ok()?),
+        mtu,
+    })
+}
+
+/// Creates local too-big feedback for a complete emitted TCP/UDP packet that
+/// the controlled packet transport cannot carry. The quotation is bounded by
+/// the IPv4 576-byte / IPv6 1280-byte ICMP packet size and preserves the bytes
+/// used for active-flow correlation. No host packet or network I/O is performed.
+#[must_use]
+pub fn build_packet_too_big(quoted: &[u8], mtu: usize) -> Option<Packet> {
+    let original = complete_ip(quoted)?;
+    if !matches!(original.protocol, TCP | UDP)
+        || original.payload.len() < 8
+        || !unicast(original.source)
+        || !unicast(original.destination)
+        || quoted.len() <= mtu
+    {
+        return None;
+    }
+    match (original.source, original.destination) {
+        (IpAddr::V4(local), IpAddr::V4(remote)) => {
+            let mtu = u16::try_from(mtu.max(68)).ok()?;
+            let quote_len = quoted.len().min(576 - 20 - 8);
+            let total_len = 20 + 8 + quote_len;
+            let mut bytes = vec![0; total_len];
+            bytes[0] = 0x45;
+            bytes[2..4].copy_from_slice(&u16::try_from(total_len).ok()?.to_be_bytes());
+            bytes[8] = 64;
+            bytes[9] = ICMPV4;
+            bytes[12..16].copy_from_slice(&remote.octets());
+            bytes[16..20].copy_from_slice(&local.octets());
+            bytes[20] = 3;
+            bytes[21] = 4;
+            bytes[26..28].copy_from_slice(&mtu.to_be_bytes());
+            bytes[28..].copy_from_slice(&quoted[..quote_len]);
+            let icmp_checksum = checksum(&bytes[20..]);
+            bytes[22..24].copy_from_slice(&icmp_checksum.to_be_bytes());
+            let ip_checksum = checksum(&bytes[..20]);
+            bytes[10..12].copy_from_slice(&ip_checksum.to_be_bytes());
+            Some(Packet::new(bytes))
+        }
+        (IpAddr::V6(local), IpAddr::V6(remote)) => {
+            if mtu < 1_280 {
+                return None;
+            }
+            let mtu = u32::try_from(mtu).ok()?;
+            let quote_len = quoted.len().min(1_280 - 40 - 8);
+            // A very long quoted extension chain cannot supply the required
+            // transport prefix within the permitted ICMP packet size.
+            if quoted_ip(&quoted[..quote_len])?.payload.len() < 8 {
+                return None;
+            }
+            let payload_len = 8 + quote_len;
+            let mut bytes = vec![0; 40 + payload_len];
+            bytes[0] = 0x60;
+            bytes[4..6].copy_from_slice(&u16::try_from(payload_len).ok()?.to_be_bytes());
+            bytes[6] = ICMPV6;
+            bytes[7] = 64;
+            bytes[8..24].copy_from_slice(&remote.octets());
+            bytes[24..40].copy_from_slice(&local.octets());
+            bytes[40] = 2;
+            bytes[44..48].copy_from_slice(&mtu.to_be_bytes());
+            bytes[48..].copy_from_slice(&quoted[..quote_len]);
+            let value = transport_checksum(remote.into(), local.into(), ICMPV6, &bytes[40..]);
+            bytes[42..44].copy_from_slice(&value.to_be_bytes());
+            Some(Packet::new(bytes))
+        }
+        _ => None,
+    }
+}
+
+struct IpView<'a> {
+    source: IpAddr,
+    destination: IpAddr,
+    protocol: u8,
+    payload: &'a [u8],
+}
+
+fn complete_ip(bytes: &[u8]) -> Option<IpView<'_>> {
+    match bytes.first()? >> 4 {
+        4 => {
+            if bytes.len() < 20 {
+                return None;
+            }
+            let header_len = usize::from(bytes[0] & 0x0f) * 4;
+            let total_len = usize::from(u16::from_be_bytes([bytes[2], bytes[3]]));
+            if header_len < 20
+                || header_len > bytes.len()
+                || total_len != bytes.len()
+                || checksum(&bytes[..header_len]) != 0
+                || u16::from_be_bytes([bytes[6], bytes[7]]) & 0x3fff != 0
+            {
+                return None;
+            }
+            ipv4_view(bytes, header_len)
+        }
+        6 => {
+            if bytes.len() < 40
+                || 40 + usize::from(u16::from_be_bytes([bytes[4], bytes[5]])) != bytes.len()
+            {
+                return None;
+            }
+            ipv6_view(bytes, false)
+        }
+        _ => None,
+    }
+}
+
+fn quoted_ip(bytes: &[u8]) -> Option<IpView<'_>> {
+    match bytes.first()? >> 4 {
+        4 => {
+            if bytes.len() < 20 {
+                return None;
+            }
+            let header_len = usize::from(bytes[0] & 0x0f) * 4;
+            if header_len < 20
+                || header_len > bytes.len()
+                || u16::from_be_bytes([bytes[6], bytes[7]]) & 0x1fff != 0
+            {
+                return None;
+            }
+            // RFC ICMP quotations commonly omit the original TCP body; no
+            // full-packet length or transport checksum is available here.
+            ipv4_view(bytes, header_len)
+        }
+        6 if bytes.len() >= 40 => ipv6_view(bytes, true),
+        _ => None,
+    }
+}
+
+fn ipv4_view(bytes: &[u8], header_len: usize) -> Option<IpView<'_>> {
+    Some(IpView {
+        source: Ipv4Addr::from(<[u8; 4]>::try_from(&bytes[12..16]).ok()?).into(),
+        destination: Ipv4Addr::from(<[u8; 4]>::try_from(&bytes[16..20]).ok()?).into(),
+        protocol: bytes[9],
+        payload: &bytes[header_len..],
+    })
+}
+
+fn ipv6_view(bytes: &[u8], quoted: bool) -> Option<IpView<'_>> {
+    let source = Ipv6Addr::from(<[u8; 16]>::try_from(&bytes[8..24]).ok()?);
+    let destination = Ipv6Addr::from(<[u8; 16]>::try_from(&bytes[24..40]).ok()?);
+    if source.to_ipv4_mapped().is_some() || destination.to_ipv4_mapped().is_some() {
+        return None;
+    }
+    let mut next = bytes[6];
+    let mut offset: usize = 40;
+    loop {
+        match next {
+            0 | 43 | 60 | 135 | 51 => {
+                let header = bytes.get(offset..offset.checked_add(2)?)?;
+                let length = if next == 51 {
+                    (usize::from(header[1]) + 2) * 4
+                } else {
+                    (usize::from(header[1]) + 1) * 8
+                };
+                offset = offset.checked_add(length)?;
+                if offset > bytes.len() {
+                    return None;
+                }
+                next = header[0];
+            }
+            44 => {
+                let header = bytes.get(offset..offset.checked_add(8)?)?;
+                let fragment = u16::from_be_bytes([header[2], header[3]]);
+                if fragment & 0xfff8 != 0 || (!quoted && fragment & 1 != 0) {
+                    return None;
+                }
+                next = header[0];
+                offset += 8;
+            }
+            _ => {
+                return Some(IpView {
+                    source: source.into(),
+                    destination: destination.into(),
+                    protocol: next,
+                    payload: &bytes[offset..],
+                });
+            }
+        }
+    }
+}
+
+fn unicast(address: IpAddr) -> bool {
+    !address.is_unspecified()
+        && !address.is_multicast()
+        && !matches!(address, IpAddr::V4(ip) if ip.is_broadcast())
+}
+
+fn legacy_ipv4_mtu(quote: &[u8]) -> Option<usize> {
+    if quote.len() < 20 || quote[0] >> 4 != 4 {
+        return None;
+    }
+    let header_len = usize::from(quote[0] & 0x0f) * 4;
+    let total_len = usize::from(u16::from_be_bytes([quote[2], quote[3]]));
+    if header_len < 20 || total_len < header_len {
+        return None;
+    }
+    Some(
+        [
+            65_535, 32_000, 17_914, 8_166, 4_352, 2_002, 1_492, 1_006, 508, 296, 68,
+        ]
+        .into_iter()
+        .find(|plateau| *plateau < total_len)
+        .unwrap_or(68),
+    )
+}
+
+fn sum_words(bytes: &[u8]) -> u32 {
+    let (words, remainder) = bytes.as_chunks::<2>();
+    let mut sum = words
+        .iter()
+        .map(|word| u32::from(u16::from_be_bytes([word[0], word[1]])))
+        .sum::<u32>();
+    if let Some(last) = remainder.first() {
+        sum += u32::from(*last) << 8;
+    }
+    sum
+}
+
+fn fold_checksum(mut sum: u32) -> u16 {
+    while sum >> 16 != 0 {
+        sum = (sum & 0xffff) + (sum >> 16);
+    }
+    !u16::try_from(sum).expect("folded checksum fits u16")
+}
+
+fn checksum(bytes: &[u8]) -> u16 {
+    fold_checksum(sum_words(bytes))
+}
+
+fn transport_checksum(source: IpAddr, destination: IpAddr, protocol: u8, payload: &[u8]) -> u16 {
+    let mut sum = sum_words(payload) + u32::from(protocol);
+    if let (IpAddr::V6(source), IpAddr::V6(destination)) = (source, destination) {
+        sum += sum_words(&source.octets()) + sum_words(&destination.octets());
+        // The caller's complete ordinary IPv6 packet bounds this conversion.
+        let length = u32::try_from(payload.len()).unwrap_or(u32::MAX);
+        sum += (length >> 16) + (length & 0xffff);
+    }
+    fold_checksum(sum)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn emitted_packet(ipv6: bool, size: usize) -> Vec<u8> {
+        let header_len = if ipv6 { 40 } else { 20 };
+        let mut bytes = vec![0; size];
+        if ipv6 {
+            bytes[0] = 0x60;
+            bytes[4..6].copy_from_slice(&u16::try_from(size - 40).unwrap().to_be_bytes());
+            bytes[6] = TCP;
+            bytes[7] = 64;
+            bytes[8..24].copy_from_slice(&"2001:db8:1::2".parse::<Ipv6Addr>().unwrap().octets());
+            bytes[24..40].copy_from_slice(&"2001:db8:2::9".parse::<Ipv6Addr>().unwrap().octets());
+        } else {
+            bytes[0] = 0x45;
+            bytes[2..4].copy_from_slice(&u16::try_from(size).unwrap().to_be_bytes());
+            bytes[6] = 0x40;
+            bytes[8] = 64;
+            bytes[9] = TCP;
+            bytes[12..16].copy_from_slice(&[10, 23, 0, 2]);
+            bytes[16..20].copy_from_slice(&[198, 51, 100, 9]);
+            let value = checksum(&bytes[..20]);
+            bytes[10..12].copy_from_slice(&value.to_be_bytes());
+        }
+        bytes[header_len..header_len + 2].copy_from_slice(&49_152_u16.to_be_bytes());
+        bytes[header_len + 2..header_len + 4].copy_from_slice(&443_u16.to_be_bytes());
+        bytes[header_len + 4..header_len + 8].copy_from_slice(&0xffff_fffe_u32.to_be_bytes());
+        bytes[header_len + 12] = 0x50;
+        bytes
+    }
+
+    fn repair_ipv4(bytes: &mut [u8]) {
+        let length = u16::try_from(bytes.len()).unwrap();
+        bytes[2..4].copy_from_slice(&length.to_be_bytes());
+        bytes[10..12].fill(0);
+        bytes[22..24].fill(0);
+        let value = checksum(&bytes[20..]);
+        bytes[22..24].copy_from_slice(&value.to_be_bytes());
+        let value = checksum(&bytes[..20]);
+        bytes[10..12].copy_from_slice(&value.to_be_bytes());
+    }
+
+    #[test]
+    fn real_truncated_icmp_quote_preserves_tuple_sequence_and_checksum_policy() {
+        for (ipv6, mtu, maximum) in [(false, 296, 576), (true, 1280, 1280)] {
+            let original = emitted_packet(ipv6, 1500);
+            let reply = build_packet_too_big(&original, mtu).unwrap();
+            assert_eq!(reply.len(), maximum);
+            // Independently check generated checksums using smoltcp's wire
+            // decoder, rather than relying only on this module's parser.
+            if ipv6 {
+                let ip = smoltcp::wire::Ipv6Packet::new_checked(reply.data()).unwrap();
+                let icmp = smoltcp::wire::Icmpv6Packet::new_checked(ip.payload()).unwrap();
+                assert!(icmp.verify_checksum(&ip.src_addr(), &ip.dst_addr()));
+            } else {
+                let ip = smoltcp::wire::Ipv4Packet::new_checked(reply.data()).unwrap();
+                assert!(ip.verify_checksum());
+                let icmp = smoltcp::wire::Icmpv4Packet::new_checked(ip.payload()).unwrap();
+                assert!(icmp.verify_checksum());
+            }
+            let hint = parse_path_mtu_hint(reply.data()).unwrap();
+            assert_eq!(hint.mtu, mtu);
+            assert_eq!(hint.sequence, 0xffff_fffe);
+            assert_eq!(hint.local.port(), 49_152);
+            assert_eq!(hint.remote.port(), 443);
+            assert_eq!(hint.outer_destination, hint.local.ip());
+            let mut corrupt = reply.data().to_vec();
+            *corrupt.last_mut().unwrap() ^= 1;
+            assert!(parse_path_mtu_hint(&corrupt).is_none());
+            assert!(parse_path_mtu_hint(&reply.data()[..reply.len() - 1]).is_none());
+        }
+        // RFC 792 permits an original IPv4 header plus eight TCP bytes only,
+        // even though the embedded total length continues to say 1500.
+        let original = emitted_packet(false, 1500);
+        let mut minimal = build_packet_too_big(&original, 68).unwrap().data()[..56].to_vec();
+        repair_ipv4(&mut minimal);
+        assert_eq!(parse_path_mtu_hint(&minimal).unwrap().mtu, 68);
+        minimal[26..28].fill(0);
+        repair_ipv4(&mut minimal);
+        assert_eq!(parse_path_mtu_hint(&minimal).unwrap().mtu, 1492);
+        minimal[28 + 6..28 + 8].copy_from_slice(&1_u16.to_be_bytes());
+        repair_ipv4(&mut minimal);
+        assert!(parse_path_mtu_hint(&minimal).is_none());
+    }
+
+    #[test]
+    fn ipv6_under_minimum_and_truncated_extension_quotes_have_real_semantics() {
+        let original = emitted_packet(true, 1500);
+        assert!(build_packet_too_big(&original, 1279).is_none());
+        let mut bytes = build_packet_too_big(&original, 1280)
+            .unwrap()
+            .data()
+            .to_vec();
+        bytes[44..48].copy_from_slice(&1279_u32.to_be_bytes());
+        bytes[42..44].fill(0);
+        let outer = complete_ip(&bytes).unwrap();
+        let value = transport_checksum(outer.source, outer.destination, ICMPV6, outer.payload);
+        bytes[42..44].copy_from_slice(&value.to_be_bytes());
+        assert!(parse_path_mtu_hint(&bytes).is_none());
+
+        // A quoted first IPv6 fragment can expose TCP's tuple and sequence;
+        // a non-first fragment cannot. Only the eight-byte TCP prefix remains.
+        let mut quote = original[..40].to_vec();
+        quote[6] = 44;
+        quote.extend_from_slice(&[TCP, 0, 0, 1, 0, 0, 0, 9]);
+        quote.extend_from_slice(&original[40..48]);
+        assert_eq!(quoted_ip(&quote).unwrap().payload.len(), 8);
+        quote[43] = 9;
+        assert!(quoted_ip(&quote).is_none());
+        assert!(quoted_ip(&quote[..47]).is_none());
+    }
+}
diff --git a/crates/vole-netstack/src/segmentation.rs b/crates/vole-netstack/src/segmentation.rs
new file mode 100644
index 0000000..8104d08
--- /dev/null
+++ b/crates/vole-netstack/src/segmentation.rs
@@ -0,0 +1,536 @@
+//! Bounded packet-layer TCP adaptation around the unmodified smoltcp engine.
+//! The TCP socket continues to own ACK, retransmission and congestion state.
+
+use std::collections::VecDeque;
+
+use smoltcp::wire::{IpProtocol, Ipv4Packet, Ipv6Packet, TcpPacket};
+
+use crate::{Packet, pmtu::PathMtuHint, tcp::FlowKey};
+
+/// Exhaustion forgets older optimizations; it never authorizes unseen bytes.
+const CACHE_ENTRIES: usize = 64;
+
+#[derive(Clone, Copy)]
+struct TcpView {
+    flow: FlowKey,
+    ip_len: usize,
+    tcp_len: usize,
+    sequence: u32,
+    acknowledgment: u32,
+    flags: u8,
+    payload_len: usize,
+}
+
+impl TcpView {
+    fn parse(bytes: &[u8], verify_checksum: bool) -> Option<Self> {
+        let (source, destination, ip_len) = match bytes.first()? >> 4 {
+            4 => {
+                let ip = Ipv4Packet::new_checked(bytes).ok()?;
+                if usize::from(ip.total_len()) != bytes.len()
+                    || ip.next_header() != IpProtocol::Tcp
+                    || u16::from_be_bytes([bytes[6], bytes[7]]) & 0x3fff != 0
+                    || (verify_checksum && !ip.verify_checksum())
+                {
+                    return None;
+                }
+                (
+                    ip.src_addr().into(),
+                    ip.dst_addr().into(),
+                    usize::from(ip.header_len()),
+                )
+            }
+            6 => {
+                let ip = Ipv6Packet::new_checked(bytes).ok()?;
+                if ip.total_len() != bytes.len() || ip.next_header() != IpProtocol::Tcp {
+                    return None;
+                }
+                (ip.src_addr().into(), ip.dst_addr().into(), 40)
+            }
+            _ => return None,
+        };
+        let tcp = TcpPacket::new_checked(&bytes[ip_len..]).ok()?;
+        if verify_checksum && !tcp.verify_checksum(&source, &destination) {
+            return None;
+        }
+        let tcp_len = usize::from(tcp.header_len());
+        Some(Self {
+            flow: FlowKey {
+                source: std::net::SocketAddr::new(source.into(), tcp.src_port()),
+                destination: std::net::SocketAddr::new(destination.into(), tcp.dst_port()),
+            },
+            ip_len,
+            tcp_len,
+            sequence: u32::from_be_bytes(bytes[ip_len + 4..ip_len + 8].try_into().ok()?),
+            acknowledgment: u32::from_be_bytes(bytes[ip_len + 8..ip_len + 12].try_into().ok()?),
+            flags: bytes[ip_len + 13],
+            payload_len: bytes.len().checked_sub(ip_len + tcp_len)?,
+        })
+    }
+}
+
+/// Only the queue-pressure fast path uses this classifier. The normal path
+/// still lets smoltcp validate every accepted packet. A rejected candidate is
+/// retained, not discarded, until ordinary output reservation can succeed.
+pub(crate) fn is_pure_tcp_ack(packet: &Packet) -> bool {
+    TcpView::parse(packet.data(), true).is_some_and(|view| {
+        view.payload_len == 0 && view.flags & 16 != 0 && view.flags & !(16 | 64 | 128) == 0
+    })
+}
+
+/// At most one original packet is retained while the bounded output drains.
+/// Options are copied unchanged; FIN/PSH belong to the last segment and CWR
+/// belongs to the first. IPv6 extensions and IP fragmentation are not split.
+pub(crate) struct PendingSegments {
+    original: Packet,
+    view: TcpView,
+    offset: usize,
+}
+
+impl PendingSegments {
+    pub(crate) fn new(original: Packet) -> Option<Self> {
+        let view = TcpView::parse(original.data(), false)?;
+        Some(Self {
+            original,
+            view,
+            offset: 0,
+        })
+    }
+
+    pub(crate) fn flow(&self) -> FlowKey {
+        self.view.flow
+    }
+
+    pub(crate) fn next(&mut self, budget: usize) -> Option<Packet> {
+        if self.offset >= self.view.payload_len
+            || (self.view.flow.source.is_ipv6() && budget < 1280)
+            // SYN/RST/URG need special sequence or urgent-pointer semantics;
+            // fail closed rather than fragmenting such an oversized packet.
+            || self.view.flags & (2 | 4 | 32) != 0
+        {
+            return None;
+        }
+        let header_len = self.view.ip_len + self.view.tcp_len;
+        let capacity = budget
+            .checked_sub(header_len)
+            .filter(|length| *length != 0)?;
+        let length = capacity.min(self.view.payload_len - self.offset);
+        let mut bytes = Vec::with_capacity(header_len + length);
+        bytes.extend_from_slice(&self.original.data()[..header_len]);
+        bytes.extend_from_slice(
+            &self.original.data()[header_len + self.offset..header_len + self.offset + length],
+        );
+        let sequence = self
+            .view
+            .sequence
+            .wrapping_add(u32::try_from(self.offset).ok()?);
+        bytes[self.view.ip_len + 4..self.view.ip_len + 8].copy_from_slice(&sequence.to_be_bytes());
+        if self.offset != 0 {
+            bytes[self.view.ip_len + 13] &= !0x80;
+        }
+        self.offset += length;
+        if self.offset != self.view.payload_len {
+            bytes[self.view.ip_len + 13] &= !(1 | 8);
+        }
+        let packet_len = bytes.len();
+        if self.view.flow.source.is_ipv4() {
+            let mut ip = Ipv4Packet::new_unchecked(&mut bytes);
+            ip.set_total_len(u16::try_from(packet_len).ok()?);
+            ip.fill_checksum();
+        } else {
+            Ipv6Packet::new_unchecked(&mut bytes)
+                .set_payload_len(u16::try_from(packet_len - 40).ok()?);
+        }
+        TcpPacket::new_unchecked(&mut bytes[self.view.ip_len..]).fill_checksum(
+            &self.view.flow.source.ip().into(),
+            &self.view.flow.destination.ip().into(),
+        );
+        Some(Packet::new(bytes))
+    }
+
+    pub(crate) fn is_finished(&self) -> bool {
+        self.offset >= self.view.payload_len
+    }
+}
+
+#[derive(Clone, Copy)]
+struct SentRange {
+    flow: FlowKey,
+    first: u32,
+    end: u32,
+}
+
+#[derive(Clone, Copy)]
+struct Path {
+    flow: FlowKey,
+    mtu: usize,
+}
+
+#[derive(Clone, Copy)]
+struct Acknowledgment {
+    flow: FlowKey,
+    sequence: u32,
+}
+
+/// Quotes must identify an actually emitted and still unacknowledged range.
+/// Passive TUN and opted-in client mode allocate this bounded metadata; it
+/// stores no body and never grows with the number of live connections.
+#[derive(Default)]
+pub(crate) struct PathMtu {
+    sent: VecDeque<SentRange>,
+    paths: VecDeque<Path>,
+    acknowledgments: VecDeque<Acknowledgment>,
+}
+
+impl PathMtu {
+    pub(crate) fn emitted(&mut self, packet: &Packet) {
+        let Some(view) = TcpView::parse(packet.data(), false) else {
+            return;
+        };
+        let length =
+            view.payload_len + usize::from(view.flags & 1 != 0) + usize::from(view.flags & 2 != 0);
+        if length == 0 {
+            return;
+        }
+        let Ok(length) = u32::try_from(length) else {
+            return;
+        };
+        let mut first = view.sequence;
+        let end = first.wrapping_add(length);
+        if let Some(ack) = self
+            .acknowledgments
+            .iter()
+            .find(|ack| ack.flow == view.flow)
+        {
+            // A retransmitted original can still be waiting for output when
+            // its previous copy is ACKed. Do not re-authorize those bytes.
+            if at_or_after(ack.sequence, end) {
+                return;
+            }
+            if in_range(ack.sequence, first, end) {
+                first = ack.sequence;
+            }
+        }
+        if self.sent.len() == CACHE_ENTRIES {
+            self.sent.pop_front();
+        }
+        self.sent.push_back(SentRange {
+            flow: view.flow,
+            first,
+            end,
+        });
+    }
+
+    pub(crate) fn acknowledge(&mut self, packet: &Packet) {
+        // Egress is trusted smoltcp output. Ingress must pass both checksums
+        // before it can revoke or trim the quote authorization metadata.
+        let Some(view) = TcpView::parse(packet.data(), true) else {
+            return;
+        };
+        if view.flags & 16 == 0 {
+            return;
+        }
+        let flow = reverse(view.flow);
+        // Only a range previously exposed to the peer can seed its ACK
+        // watermark. ACKs outside it may revoke optimization metadata below,
+        // but cannot create a lasting reference for queued, unsent bytes.
+        if self.sent.iter().any(|sent| {
+            sent.flow == flow
+                && (in_range(view.acknowledgment, sent.first, sent.end)
+                    || view.acknowledgment == sent.end)
+        }) {
+            if let Some(ack) = self.acknowledgments.iter_mut().find(|ack| ack.flow == flow) {
+                if at_or_after(view.acknowledgment, ack.sequence) {
+                    ack.sequence = view.acknowledgment;
+                }
+            } else {
+                if self.acknowledgments.len() == CACHE_ENTRIES {
+                    self.acknowledgments.pop_front();
+                }
+                self.acknowledgments.push_back(Acknowledgment {
+                    flow,
+                    sequence: view.acknowledgment,
+                });
+            }
+        }
+        for sent in &mut self.sent {
+            if sent.flow == flow && in_range(view.acknowledgment, sent.first, sent.end) {
+                sent.first = view.acknowledgment;
+            }
+        }
+        self.sent
+            .retain(|sent| sent.flow != flow || !at_or_after(view.acknowledgment, sent.end));
+    }
+
+    pub(crate) fn budget(&self, flow: FlowKey, initial_mtu: usize) -> usize {
+        self.paths
+            .iter()
+            .find(|path| path.flow == flow)
+            .map_or(initial_mtu, |path| path.mtu.min(initial_mtu))
+    }
+
+    pub(crate) fn apply(&mut self, hint: PathMtuHint, initial_mtu: usize) -> bool {
+        let flow = FlowKey {
+            source: hint.local,
+            destination: hint.remote,
+        };
+        if hint.outer_destination != hint.local.ip()
+            || hint.mtu < if hint.local.is_ipv6() { 1280 } else { 68 }
+            || hint.mtu >= self.budget(flow, initial_mtu)
+            || !self
+                .sent
+                .iter()
+                .any(|sent| sent.flow == flow && in_range(hint.sequence, sent.first, sent.end))
+        {
+            return false;
+        }
+        self.paths.retain(|path| path.flow != flow);
+        if self.paths.len() == CACHE_ENTRIES {
+            self.paths.pop_front();
+        }
+        self.paths.push_back(Path {
+            flow,
+            mtu: hint.mtu,
+        });
+        true
+    }
+
+    pub(crate) fn forget(&mut self, flow: FlowKey) {
+        self.sent.retain(|sent| sent.flow != flow);
+        self.paths.retain(|path| path.flow != flow);
+        self.acknowledgments.retain(|ack| ack.flow != flow);
+    }
+}
+
+pub(crate) fn reverse(flow: FlowKey) -> FlowKey {
+    FlowKey {
+        source: flow.destination,
+        destination: flow.source,
+    }
+}
+
+fn in_range(value: u32, first: u32, end: u32) -> bool {
+    value.wrapping_sub(first) < end.wrapping_sub(first)
+}
+
+fn at_or_after(value: u32, reference: u32) -> bool {
+    value.wrapping_sub(reference).cast_signed() >= 0
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+    use super::*;
+
+    fn flow(ipv6: bool, port: u16) -> FlowKey {
+        if ipv6 {
+            FlowKey {
+                source: format!("[2001:db8::2]:{port}").parse().unwrap(),
+                destination: "[2001:db8:1::2]:443".parse().unwrap(),
+            }
+        } else {
+            FlowKey {
+                source: format!("10.23.0.2:{port}").parse().unwrap(),
+                destination: "198.51.100.2:443".parse().unwrap(),
+            }
+        }
+    }
+
+    pub(crate) fn tcp_packet(
+        flow: FlowKey,
+        sequence: u32,
+        ack: u32,
+        flags: u8,
+        size: usize,
+    ) -> Packet {
+        let ip_len = if flow.source.is_ipv6() { 40 } else { 24 };
+        let tcp_len = 32;
+        let mut bytes = vec![0; ip_len + tcp_len + size];
+        let packet_len = bytes.len();
+        if let (std::net::IpAddr::V4(source), std::net::IpAddr::V4(destination)) =
+            (flow.source.ip(), flow.destination.ip())
+        {
+            bytes[0] = 0x46;
+            bytes[2..4].copy_from_slice(&u16::try_from(packet_len).unwrap().to_be_bytes());
+            bytes[6] = 0x40;
+            bytes[8] = 64;
+            bytes[9] = 6;
+            bytes[12..16].copy_from_slice(&source.octets());
+            bytes[16..20].copy_from_slice(&destination.octets());
+            bytes[20..24].copy_from_slice(&[1, 1, 0, 0]);
+            Ipv4Packet::new_unchecked(&mut bytes).fill_checksum();
+        } else if let (std::net::IpAddr::V6(source), std::net::IpAddr::V6(destination)) =
+            (flow.source.ip(), flow.destination.ip())
+        {
+            bytes[0] = 0x60;
+            bytes[4..6].copy_from_slice(&u16::try_from(packet_len - 40).unwrap().to_be_bytes());
+            bytes[6] = 6;
+            bytes[7] = 64;
+            bytes[8..24].copy_from_slice(&source.octets());
+            bytes[24..40].copy_from_slice(&destination.octets());
+        }
+        bytes[ip_len..ip_len + 2].copy_from_slice(&flow.source.port().to_be_bytes());
+        bytes[ip_len + 2..ip_len + 4].copy_from_slice(&flow.destination.port().to_be_bytes());
+        bytes[ip_len + 4..ip_len + 8].copy_from_slice(&sequence.to_be_bytes());
+        bytes[ip_len + 8..ip_len + 12].copy_from_slice(&ack.to_be_bytes());
+        bytes[ip_len + 12] = 0x80;
+        bytes[ip_len + 13] = flags;
+        bytes[ip_len + 14..ip_len + 16].copy_from_slice(&32768_u16.to_be_bytes());
+        bytes[ip_len + 20..ip_len + 32].copy_from_slice(&[1, 1, 8, 10, 0, 0, 0, 9, 0, 0, 0, 8]);
+        for (index, byte) in bytes[ip_len + tcp_len..].iter_mut().enumerate() {
+            *byte = u8::try_from(index % 251).unwrap();
+        }
+        TcpPacket::new_unchecked(&mut bytes[ip_len..])
+            .fill_checksum(&flow.source.ip().into(), &flow.destination.ip().into());
+        Packet::new(bytes)
+    }
+
+    pub(crate) fn hint(packet: &Packet, mtu: usize) -> PathMtuHint {
+        let view = TcpView::parse(packet.data(), true).unwrap();
+        PathMtuHint {
+            outer_destination: view.flow.source.ip(),
+            local: view.flow.source,
+            remote: view.flow.destination,
+            sequence: view.sequence,
+            mtu,
+        }
+    }
+
+    #[test]
+    fn segments_preserve_content_options_checksum_flags_and_wrap() {
+        for (ipv6, budget) in [(false, 576), (true, 1280)] {
+            let original = tcp_packet(flow(ipv6, 4000), u32::MAX - 300, 91, 0xd9, 7000);
+            let original_view = TcpView::parse(original.data(), true).unwrap();
+            let mut pending = PendingSegments::new(original.clone()).unwrap();
+            let mut received = Vec::new();
+            let mut first = true;
+            while let Some(segment) = pending.next(budget) {
+                assert!(segment.len() <= budget);
+                let view = TcpView::parse(segment.data(), true).unwrap();
+                assert_eq!(view.flow, original_view.flow);
+                assert_eq!(
+                    view.sequence,
+                    original_view
+                        .sequence
+                        .wrapping_add(u32::try_from(received.len()).unwrap())
+                );
+                assert_eq!(view.acknowledgment, 91);
+                assert_eq!(view.flags & 0x80 != 0, first);
+                assert_eq!(
+                    view.flags & (1 | 8),
+                    if pending.is_finished() { 1 | 8 } else { 0 }
+                );
+                assert_ne!(view.flags & (16 | 64), 0);
+                let header_end = view.ip_len + view.tcp_len;
+                assert_eq!(
+                    &segment.data()[view.ip_len + 20..header_end],
+                    &original.data()[view.ip_len + 20..header_end]
+                );
+                if !ipv6 {
+                    assert_eq!(&segment.data()[20..24], &original.data()[20..24]);
+                }
+                received.extend_from_slice(&segment.data()[header_end..]);
+                first = false;
+            }
+            assert_eq!(
+                received,
+                original.data()[original_view.ip_len + original_view.tcp_len..]
+            );
+            assert!(pending.is_finished());
+        }
+    }
+
+    #[test]
+    fn changing_budget_and_unsupported_ip_modes_fail_closed() {
+        let original = tcp_packet(flow(false, 4000), 100, 91, 0x10, 7000);
+        let mut pending = PendingSegments::new(original).unwrap();
+        assert_eq!(pending.next(1280).unwrap().len(), 1280);
+        let second = pending.next(576).unwrap();
+        assert_eq!(second.len(), 576);
+        assert_eq!(
+            TcpView::parse(second.data(), true).unwrap().sequence,
+            100 + 1280 - 56
+        );
+        for flags in [2, 4, 32] {
+            let mut pending =
+                PendingSegments::new(tcp_packet(flow(false, 4000), 100, 91, flags, 7000)).unwrap();
+            assert!(pending.next(576).is_none());
+        }
+        let ipv6 = tcp_packet(flow(true, 4000), 100, 91, 16, 7000);
+        assert!(
+            PendingSegments::new(ipv6.clone())
+                .unwrap()
+                .next(1279)
+                .is_none()
+        );
+        let mut extension = ipv6.data().to_vec();
+        extension[6] = 60;
+        assert!(PendingSegments::new(Packet::new(extension)).is_none());
+        let mut fragmented = tcp_packet(flow(false, 4000), 100, 91, 16, 7000)
+            .data()
+            .to_vec();
+        fragmented[6] |= 0x20;
+        assert!(PendingSegments::new(Packet::new(fragmented)).is_none());
+    }
+
+    #[test]
+    fn quotes_require_emitted_unacked_ranges_and_isolate_flows() {
+        for ipv6 in [false, true] {
+            let mut paths = PathMtu::default();
+            let original = tcp_packet(flow(ipv6, 4000), u32::MAX - 300, 91, 0x10, 1400);
+            let original_hint = hint(&original, if ipv6 { 1280 } else { 576 });
+            assert!(!paths.apply(original_hint, 1500));
+            paths.emitted(&original);
+            let mut wrong = original_hint;
+            wrong.remote.set_port(444);
+            assert!(!paths.apply(wrong, 1500));
+            wrong = original_hint;
+            wrong.sequence = original_hint.sequence.wrapping_add(1400);
+            assert!(!paths.apply(wrong, 1500));
+            let partial_ack = original_hint.sequence.wrapping_add(500);
+            paths.acknowledge(&tcp_packet(
+                reverse(flow(ipv6, 4000)),
+                91,
+                partial_ack,
+                16,
+                0,
+            ));
+            assert!(!paths.apply(original_hint, 1500));
+            let mut tail_hint = original_hint;
+            tail_hint.sequence = partial_ack;
+            assert!(paths.apply(tail_hint, 1500));
+            assert_eq!(paths.budget(flow(ipv6, 4001), 1500), 1500);
+            let final_ack = original_hint.sequence.wrapping_add(1400);
+            paths.acknowledge(&tcp_packet(reverse(flow(ipv6, 4000)), 91, final_ack, 16, 0));
+            paths.emitted(&original); // previously queued retransmit copy
+            tail_hint.mtu -= if ipv6 { 0 } else { 100 };
+            assert!(!paths.apply(tail_hint, 1500));
+            paths.forget(flow(ipv6, 4000));
+            assert_eq!(paths.budget(flow(ipv6, 4000), 1500), 1500);
+            assert!(
+                paths.sent.is_empty() && paths.paths.is_empty() && paths.acknowledgments.is_empty()
+            );
+            // Tuple reuse starts without the predecessor's ACK watermark.
+            paths.emitted(&original);
+            assert!(paths.apply(original_hint, 1500));
+        }
+    }
+
+    #[test]
+    fn caches_remain_bounded_and_eviction_cannot_authorize_old_quotes() {
+        let mut paths = PathMtu::default();
+        for port in 4000..4200 {
+            let packet = tcp_packet(flow(false, port), 100, 91, 16, 1400);
+            paths.emitted(&packet);
+            assert!(paths.apply(hint(&packet, 1280), 1500));
+            paths.acknowledge(&tcp_packet(reverse(flow(false, port)), 91, 101, 16, 0));
+            assert!(paths.sent.len() <= CACHE_ENTRIES);
+            assert!(paths.paths.len() <= CACHE_ENTRIES);
+            assert!(paths.acknowledgments.len() <= CACHE_ENTRIES);
+        }
+        assert_eq!(paths.sent.len(), CACHE_ENTRIES);
+        assert_eq!(paths.paths.len(), CACHE_ENTRIES);
+        assert_eq!(paths.acknowledgments.len(), CACHE_ENTRIES);
+        let old = tcp_packet(flow(false, 4000), 100, 91, 16, 1400);
+        assert!(!paths.apply(hint(&old, 1000), 1500));
+        assert_eq!(paths.budget(flow(false, 4000), 1500), 1500);
+    }
+}
diff --git a/crates/vole-netstack/src/stack.rs b/crates/vole-netstack/src/stack.rs
index cf3b59a..027233a 100644
--- a/crates/vole-netstack/src/stack.rs
+++ b/crates/vole-netstack/src/stack.rs
@@ -22,15 +22,21 @@ use tokio::sync::{Notify, mpsc, watch};
 use tokio_util::sync::CancellationToken;
 
 use crate::{
-    NetStackConfig, Packet,
+    ClientConfig, NetStackConfig, Packet,
     config::ConfigError,
     device::RawIpDevice,
     icmp::{IcmpIngress, classify as classify_icmp},
-    tcp::{FlowKey, TcpListener, TcpStream, TcpStreamHandle},
+    pmtu::parse_path_mtu_hint,
+    tcp::{
+        ClientRequest, ConnectRequest, FlowKey, InitialMtuRequest, TcpConnector, TcpListener,
+        TcpStream, TcpStreamHandle, connect_stopped, connect_timeout,
+    },
     udp::{UdpDatagram, UdpSocket, parse_udp_packet},
 };
 
 const RAW_INGRESS_BATCH: usize = 8;
+const TCP_CONNECT_QUEUE: usize = 32;
+const EPHEMERAL_PORT_START: u16 = 49_152;
 
 /// Running stack and all of its application-facing endpoints.
 pub struct NetStack {
@@ -56,6 +62,60 @@ pub struct TcpNetStackParts {
     pub stats: NetStackStats,
 }
 
+/// Active TCP endpoints with configured sources and no passive accept/UDP queue.
+pub struct ClientNetStackParts {
+    pub packet_sink: PacketSink,
+    pub packet_stream: PacketStream,
+    pub tcp_connector: TcpConnector,
+    pub control: NetStackControl,
+    pub stats: NetStackStats,
+}
+
+struct DriverParts {
+    packet_sink: PacketSink,
+    packet_stream: PacketStream,
+    tcp_listener: Option<TcpListener>,
+    tcp_connector: Option<TcpConnector>,
+    udp_socket: Option<UdpSocket>,
+    control: NetStackControl,
+    stats: NetStackStats,
+}
+
+impl DriverParts {
+    fn into_stack(self) -> NetStack {
+        NetStack {
+            parts: NetStackParts {
+                packet_sink: self.packet_sink,
+                packet_stream: self.packet_stream,
+                tcp_listener: self.tcp_listener.expect("passive endpoints requested"),
+                udp_socket: self.udp_socket.expect("UDP endpoints requested"),
+                control: self.control,
+                stats: self.stats,
+            },
+        }
+    }
+
+    fn into_tcp(self) -> TcpNetStackParts {
+        TcpNetStackParts {
+            packet_sink: self.packet_sink,
+            packet_stream: self.packet_stream,
+            tcp_listener: self.tcp_listener.expect("passive endpoints requested"),
+            control: self.control,
+            stats: self.stats,
+        }
+    }
+
+    fn into_client(self) -> ClientNetStackParts {
+        ClientNetStackParts {
+            packet_sink: self.packet_sink,
+            packet_stream: self.packet_stream,
+            tcp_connector: self.tcp_connector.expect("active endpoints requested"),
+            control: self.control,
+            stats: self.stats,
+        }
+    }
+}
+
 impl NetStack {
     /// Starts one netstack driver on the current Tokio runtime.
     ///
@@ -64,20 +124,7 @@ impl NetStack {
     /// Returns [`NetStackError::Config`] for inconsistent bounds and
     /// [`NetStackError::NoRuntime`] when called outside a Tokio runtime.
     pub fn start(config: NetStackConfig) -> Result<Self, NetStackError> {
-        Self::start_parts(config, true).map(|(parts, udp_socket)| Self::with_udp(parts, udp_socket))
-    }
-
-    fn with_udp(parts: TcpNetStackParts, udp_socket: Option<UdpSocket>) -> Self {
-        Self {
-            parts: NetStackParts {
-                packet_sink: parts.packet_sink,
-                packet_stream: parts.packet_stream,
-                tcp_listener: parts.tcp_listener,
-                udp_socket: udp_socket.expect("UDP endpoints requested"),
-                control: parts.control,
-                stats: parts.stats,
-            },
-        }
+        Self::start_parts(config, true, None).map(DriverParts::into_stack)
     }
 
     /// Starts only the TCP/ICMP driver; callers handle UDP with the pure codec.
@@ -86,14 +133,36 @@ impl NetStack {
     ///
     /// Returns the same configuration and runtime errors as [`Self::start`].
     pub fn start_tcp(config: NetStackConfig) -> Result<TcpNetStackParts, NetStackError> {
-        Self::start_parts(config, false).map(|(parts, _)| parts)
+        Self::start_parts(config, false, None).map(DriverParts::into_tcp)
+    }
+
+    /// Starts active TCP using only the supplied local IP addresses.
+    ///
+    /// UDP remains caller-owned through the pure packet codec. Unsolicited
+    /// incoming TCP flows are discarded; passive TUN behavior is unchanged.
+    ///
+    /// # Errors
+    ///
+    /// Returns the errors of [`Self::start`] and a configuration error when
+    /// no local address is supplied or a supplied address is not unicast.
+    pub fn start_client(
+        config: NetStackConfig,
+        addresses: impl Into<ClientConfig>,
+    ) -> Result<ClientNetStackParts, NetStackError> {
+        let addresses = addresses.into().validate(config.mtu)?;
+        Self::start_parts(config, false, Some(addresses)).map(DriverParts::into_client)
     }
 
     fn start_parts(
         config: NetStackConfig,
         with_udp: bool,
-    ) -> Result<(TcpNetStackParts, Option<UdpSocket>), NetStackError> {
-        config.validate()?;
+        addresses: Option<ClientConfig>,
+    ) -> Result<DriverParts, NetStackError> {
+        if let Some(client) = &addresses {
+            config.validate_client(client)?;
+        } else {
+            config.validate()?;
+        }
         tokio::runtime::Handle::try_current().map_err(|_| NetStackError::NoRuntime)?;
 
         let cancellation = CancellationToken::new();
@@ -101,7 +170,36 @@ impl NetStack {
         let stats = NetStackStats::default();
         let (raw_inbound_tx, raw_inbound_rx) = mpsc::channel(config.packet_queue);
         let (raw_outbound_tx, raw_outbound_rx) = mpsc::channel(config.packet_queue);
-        let (tcp_accept_tx, tcp_accept_rx) = mpsc::channel(config.tcp_accept_queue);
+        let (tcp_accept_tx, tcp_listener, client, tcp_connector) =
+            if let Some(addresses) = addresses {
+                let (sender, receiver) = mpsc::channel(TCP_CONNECT_QUEUE);
+                (
+                    None,
+                    None,
+                    Some(ClientDriver {
+                        addresses,
+                        requests: receiver,
+                        next_port: EPHEMERAL_PORT_START,
+                    }),
+                    Some(TcpConnector {
+                        sender,
+                        addresses,
+                        cancellation: cancellation.clone(),
+                        notify: notify.clone(),
+                    }),
+                )
+            } else {
+                let (sender, receiver) = mpsc::channel(config.tcp_accept_queue);
+                (
+                    Some(sender),
+                    Some(TcpListener {
+                        receiver,
+                        cancellation: cancellation.clone(),
+                    }),
+                    None,
+                    None,
+                )
+            };
         let (udp_tx, udp_socket) = if with_udp {
             let (sender, receiver) = mpsc::channel(config.udp_queue);
             (
@@ -118,8 +216,9 @@ impl NetStack {
         };
         let (stopped_tx, stopped_rx) = watch::channel(false);
 
-        let mtu = config.mtu;
-        let driver = Driver::new(
+        let receive_packet_limit =
+            addresses.map_or(config.mtu, |client| client.receive_packet_limit);
+        let mut driver = Driver::new(
             config,
             raw_inbound_rx,
             raw_outbound_tx.clone(),
@@ -130,32 +229,32 @@ impl NetStack {
             stats.clone(),
             stopped_tx,
         );
+        if let Some(client) = client {
+            driver.configure_client(&client.addresses);
+            driver.client = Some(client);
+        }
         tokio::spawn(driver.run());
 
-        Ok((
-            TcpNetStackParts {
-                packet_sink: PacketSink {
-                    sender: raw_inbound_tx,
-                    cancellation: cancellation.clone(),
-                    mtu,
-                },
-                packet_stream: PacketStream {
-                    receiver: raw_outbound_rx,
-                    cancellation: cancellation.clone(),
-                    notify,
-                },
-                tcp_listener: TcpListener {
-                    receiver: tcp_accept_rx,
-                    cancellation: cancellation.clone(),
-                },
-                control: NetStackControl {
-                    cancellation,
-                    stopped: stopped_rx,
-                },
-                stats,
+        Ok(DriverParts {
+            packet_sink: PacketSink {
+                sender: raw_inbound_tx,
+                cancellation: cancellation.clone(),
+                mtu: receive_packet_limit,
+            },
+            packet_stream: PacketStream {
+                receiver: raw_outbound_rx,
+                cancellation: cancellation.clone(),
+                notify,
             },
+            tcp_listener,
+            tcp_connector,
             udp_socket,
-        ))
+            control: NetStackControl {
+                cancellation,
+                stopped: stopped_rx,
+            },
+            stats,
+        })
     }
 
     #[must_use]
@@ -400,13 +499,22 @@ fn validate_raw_packet(packet: &Packet, mtu: usize) -> Result<(), NetStackError>
 struct TcpEntry {
     socket: SocketHandle,
     handle: Arc<TcpStreamHandle>,
+    connecting: Option<ConnectRequest>,
+    connect_cancellation: Option<CancellationToken>,
+}
+
+struct ClientDriver {
+    addresses: ClientConfig,
+    requests: mpsc::Receiver<ClientRequest>,
+    next_port: u16,
 }
 
 struct Driver {
     config: NetStackConfig,
     raw_inbound: mpsc::Receiver<Packet>,
     raw_outbound: mpsc::Sender<Packet>,
-    tcp_accept: mpsc::Sender<TcpStream>,
+    tcp_accept: Option<mpsc::Sender<TcpStream>>,
+    client: Option<ClientDriver>,
     udp_outbound: Option<mpsc::Sender<UdpDatagram>>,
     cancellation: CancellationToken,
     notify: Arc<Notify>,
@@ -425,7 +533,7 @@ impl Driver {
         config: NetStackConfig,
         raw_inbound: mpsc::Receiver<Packet>,
         raw_outbound: mpsc::Sender<Packet>,
-        tcp_accept: mpsc::Sender<TcpStream>,
+        tcp_accept: Option<mpsc::Sender<TcpStream>>,
         udp_outbound: Option<mpsc::Sender<UdpDatagram>>,
         cancellation: CancellationToken,
         notify: Arc<Notify>,
@@ -435,6 +543,10 @@ impl Driver {
         let mut interface_config = InterfaceConfig::new(HardwareAddress::Ip);
         interface_config.random_seed = 0x4f_6e_65_56_43_6f_72_65;
         let mut device = RawIpDevice::new(config.mtu, raw_outbound.clone());
+        // Passive TUN TCP uses the same bounded, body-free PMTU metadata as
+        // IP-carrier clients. A quote still needs the exact live socket and
+        // an emitted, unacknowledged sequence before it can lower its budget.
+        device.enable_path_mtu();
         let mut interface = Interface::new(interface_config, &mut device, Instant::now());
         interface.set_any_ip(true);
         interface.update_ip_addrs(|addresses| {
@@ -462,6 +574,7 @@ impl Driver {
             raw_inbound,
             raw_outbound,
             tcp_accept,
+            client: None,
             udp_outbound,
             cancellation,
             notify,
@@ -475,33 +588,100 @@ impl Driver {
         }
     }
 
+    fn configure_client(&mut self, addresses: &ClientConfig) {
+        if !addresses.path_mtu_discovery {
+            self.device.disable_path_mtu();
+        }
+        self.interface.set_any_ip(false);
+        self.interface.update_ip_addrs(|configured| {
+            configured.clear();
+            for prefix in addresses.prefixes() {
+                configured
+                    .push(IpCidr::new(prefix.address.into(), prefix.prefix_len))
+                    .expect("client IP address capacity");
+            }
+        });
+        self.interface.routes_mut().remove_default_ipv4_route();
+        self.interface.routes_mut().remove_default_ipv6_route();
+        // The IP-medium device emits every destination into the caller's
+        // packet path; these routes never configure a system interface.
+        if let Some(ip) = addresses
+            .prefixes()
+            .find_map(|prefix| match prefix.address {
+                IpAddr::V4(ip) => Some(ip),
+                IpAddr::V6(_) => None,
+            })
+        {
+            self.interface
+                .routes_mut()
+                .add_default_ipv4_route(ip)
+                .expect("IPv4 route capacity");
+        }
+        if let Some(ip) = addresses
+            .prefixes()
+            .find_map(|prefix| match prefix.address {
+                IpAddr::V6(ip) => Some(ip),
+                IpAddr::V4(_) => None,
+            })
+        {
+            self.interface
+                .routes_mut()
+                .add_default_ipv6_route(ip)
+                .expect("IPv6 route capacity");
+        }
+    }
+
+    async fn next_request(client: &mut Option<ClientDriver>) -> Option<ClientRequest> {
+        match client {
+            Some(client) => client.requests.recv().await,
+            None => std::future::pending().await,
+        }
+    }
+
     async fn run(mut self) {
         loop {
             self.drive();
-            if self.cancellation.is_cancelled() {
+            if self.cancellation.is_cancelled() || !self.wait_for_work().await {
                 break;
             }
+        }
+    }
 
-            let delay = self.next_delay();
-            tokio::select! {
-                biased;
-                () = self.cancellation.cancelled() => break,
-                () = self.notify.notified() => {}
-                // A full output still allows one ingress classification:
-                // low-priority ICMP drops immediately, while TCP retains its
-                // one pending packet until output capacity returns.
-                packet = self.raw_inbound.recv(), if self.device.rx_is_empty() => {
-                    let Some(packet) = packet else { break; };
-                    let batch_count = self.handle_packet_batch(packet);
-                    // recv() already charges the first packet. try_recv()
-                    // does not, so retain the old per-packet cooperative
-                    // accounting without repeating socket maintenance.
-                    for _ in 1..batch_count {
-                        tokio::task::consume_budget().await;
-                    }
+    async fn wait_for_work(&mut self) -> bool {
+        let delay = self.next_delay();
+        let has_connect_requests = self
+            .client
+            .as_ref()
+            .is_some_and(|client| !client.requests.is_closed());
+        tokio::select! {
+            biased;
+            () = self.cancellation.cancelled() => false,
+            // A full output still allows one ingress classification:
+            // low-priority ICMP drops immediately, while TCP retains its
+            // one pending packet until output capacity returns.
+            packet = self.raw_inbound.recv(), if self.device.rx_is_empty() => {
+                let Some(packet) = packet else { return false; };
+                let batch_count = self.handle_packet_batch(packet);
+                // recv() already charges the first packet. try_recv()
+                // does not, so retain the old per-packet cooperative
+                // accounting without repeating socket maintenance.
+                for _ in 1..batch_count {
+                    tokio::task::consume_budget().await;
+                }
+                true
+            }
+            // Socket maintenance runs before this wait on every iteration.
+            // Its own notifications must not outrank an already-ready packet,
+            // especially TCP ACKs which release the relay's bounded buffers.
+            () = self.notify.notified() => true,
+            request = Self::next_request(&mut self.client), if has_connect_requests => {
+                if let Some(request) = request {
+                    self.handle_client_request(request);
+                    tokio::task::consume_budget().await;
                 }
-                () = tokio::time::sleep(delay) => {}
+                true
             }
+            () = tokio::time::sleep(delay) => true,
         }
     }
 
@@ -544,6 +724,27 @@ impl Driver {
     }
 
     fn handle_packet(&mut self, packet: Packet) {
+        if self
+            .client
+            .as_ref()
+            .is_none_or(|client| client.addresses.path_mtu_discovery)
+            && let Some(hint) = parse_path_mtu_hint(packet.data())
+        {
+            let local_address = self
+                .client
+                .as_ref()
+                .is_none_or(|client| client.addresses.contains_address(hint.local.ip()));
+            if hint.outer_destination == hint.local.ip()
+                && local_address
+                && self.tcp_entries.contains_key(&FlowKey {
+                    source: hint.remote,
+                    destination: hint.local,
+                })
+            {
+                self.device.apply_path_mtu(hint);
+            }
+            return;
+        }
         if self.config.fake_icmp_echo {
             match classify_icmp(&packet) {
                 IcmpIngress::NotIcmp => {}
@@ -579,7 +780,8 @@ impl Driver {
     }
 
     fn handle_icmp_packet(&mut self, packet: Packet) {
-        if !self.device.rx_is_empty() || self.device.tx_is_full() {
+        if packet.len() > self.config.mtu || !self.device.rx_is_empty() || self.device.tx_is_full()
+        {
             self.stats.0.icmp_dropped.fetch_add(1, Ordering::AcqRel);
             return;
         }
@@ -609,9 +811,18 @@ impl Driver {
             return;
         };
 
-        if !self.tcp_entries.contains_key(&flow) && (!syn || ack || !self.admit_tcp(flow)) {
-            return;
+        if !self.tcp_entries.contains_key(&flow) {
+            if self.client.is_some() {
+                if syn && !ack {
+                    self.stats.0.rejected_tcp.fetch_add(1, Ordering::AcqRel);
+                }
+                return;
+            }
+            if !syn || ack || !self.admit_tcp(flow) {
+                return;
+            }
         }
+        self.device.acknowledge(&packet);
         if self.device.push_rx(packet).is_err() {
             // A pending ingress packet must never be overwritten.
             self.stats.0.rejected_tcp.fetch_add(1, Ordering::AcqRel);
@@ -619,35 +830,28 @@ impl Driver {
     }
 
     fn admit_tcp(&mut self, flow: FlowKey) -> bool {
-        if self.tcp_accept.capacity() == 0 {
+        let Some(accept) = self.tcp_accept.as_ref() else {
+            return false;
+        };
+        if accept.capacity() == 0 {
             self.stats.0.rejected_tcp.fetch_add(1, Ordering::AcqRel);
             return false;
         }
 
-        let recv_layer_buffer = self.config.recv_layer_buffer_size();
-        let send_layer_buffer = self.config.send_layer_buffer_size();
-        let mut socket = tcp::Socket::new(
-            tcp::SocketBuffer::new(vec![0_u8; recv_layer_buffer]),
-            tcp::SocketBuffer::new(vec![0_u8; send_layer_buffer]),
-        );
-        socket.set_keep_alive(Some(smoltcp::time::Duration::from_secs(28)));
-        socket.set_timeout(Some(self.config.tcp_idle_timeout.into()));
-        socket.set_ack_delay(Some(smoltcp::time::Duration::from_millis(10)));
-        socket.set_nagle_enabled(false);
-        socket.set_congestion_control(tcp::CongestionControl::Cubic);
+        let mut socket = self.new_tcp_socket();
         if socket.listen(flow.destination).is_err() {
             self.stats.0.rejected_tcp.fetch_add(1, Ordering::AcqRel);
             return false;
         }
 
         let handle = Arc::new(TcpStreamHandle::new(
-            recv_layer_buffer,
-            send_layer_buffer,
+            self.config.recv_layer_buffer_size(),
+            self.config.send_layer_buffer_size(),
             self.notify.clone(),
         ));
         let socket_handle = self.sockets.add(socket);
         let stream = TcpStream::new(flow, handle.clone());
-        if self.tcp_accept.try_send(stream).is_err() {
+        if accept.try_send(stream).is_err() {
             self.sockets.remove(socket_handle);
             self.stats.0.rejected_tcp.fetch_add(1, Ordering::AcqRel);
             return false;
@@ -657,6 +861,8 @@ impl Driver {
             TcpEntry {
                 socket: socket_handle,
                 handle,
+                connecting: None,
+                connect_cancellation: None,
             },
         );
         self.half_open.insert(flow);
@@ -664,20 +870,180 @@ impl Driver {
         true
     }
 
+    fn new_tcp_socket(&self) -> tcp::Socket<'static> {
+        let mut socket = tcp::Socket::new(
+            tcp::SocketBuffer::new(vec![0; self.config.recv_layer_buffer_size()]),
+            tcp::SocketBuffer::new(vec![0; self.config.send_layer_buffer_size()]),
+        );
+        socket.set_keep_alive(Some(smoltcp::time::Duration::from_secs(28)));
+        socket.set_timeout(Some(self.config.tcp_idle_timeout.into()));
+        socket.set_ack_delay(Some(smoltcp::time::Duration::from_millis(10)));
+        socket.set_nagle_enabled(false);
+        socket.set_congestion_control(tcp::CongestionControl::Cubic);
+        if self.client.is_some() {
+            // The initial SYN timeout stays unchanged; RTT samples set the lower floor.
+            socket.set_min_rto(smoltcp::time::Duration::from_millis(200));
+        }
+        socket
+    }
+
+    fn connect_tcp(&mut self, request: ConnectRequest) {
+        if request.cancellation.is_cancelled() || request.response.is_closed() {
+            return;
+        }
+        if self.cancellation.is_cancelled() {
+            let _ = request.response.send(Err(connect_stopped()));
+            return;
+        }
+        if tokio::time::Instant::now() >= request.deadline {
+            let _ = request.response.send(Err(connect_timeout()));
+            return;
+        }
+        let client = self.client.as_mut().expect("active request has a driver");
+        let source = match client.addresses.source_for(request.destination.ip()) {
+            Ok(source) => source,
+            Err(error) => {
+                let _ = request.response.send(Err(error));
+                return;
+            }
+        };
+        let mut selected = None;
+        for _ in EPHEMERAL_PORT_START..=u16::MAX {
+            let port = client.next_port;
+            client.next_port = if port == u16::MAX {
+                EPHEMERAL_PORT_START
+            } else {
+                port + 1
+            };
+            let incoming = FlowKey {
+                source: request.destination,
+                destination: SocketAddr::new(source, port),
+            };
+            if !self.tcp_entries.contains_key(&incoming) {
+                selected = Some(incoming);
+                break;
+            }
+        }
+        let Some(flow) = selected else {
+            let _ = request.response.send(Err(std::io::Error::new(
+                std::io::ErrorKind::AddrInUse,
+                "active TCP source ports exhausted for peer",
+            )));
+            return;
+        };
+        let mut socket = self.new_tcp_socket();
+        if socket
+            .connect(self.interface.context(), flow.source, flow.destination)
+            .is_err()
+        {
+            let _ = request.response.send(Err(std::io::Error::new(
+                std::io::ErrorKind::AddrNotAvailable,
+                "active TCP endpoint is unavailable",
+            )));
+            return;
+        }
+        let handle = Arc::new(TcpStreamHandle::new(
+            self.config.recv_layer_buffer_size(),
+            self.config.send_layer_buffer_size(),
+            self.notify.clone(),
+        ));
+        let socket = self.sockets.add(socket);
+        let connect_cancellation = Some(request.cancellation.clone());
+        self.tcp_entries.insert(
+            flow,
+            TcpEntry {
+                socket,
+                handle,
+                connecting: Some(request),
+                connect_cancellation,
+            },
+        );
+        self.half_open.insert(flow);
+        self.update_flow_stats();
+    }
+
+    fn handle_client_request(&mut self, request: ClientRequest) {
+        match request {
+            ClientRequest::Connect(request) => self.connect_tcp(request),
+            ClientRequest::InitialMtu(request) => self.set_initial_mtu(request),
+        }
+    }
+
+    fn set_initial_mtu(&mut self, request: InitialMtuRequest) {
+        if request.response.is_closed() {
+            return;
+        }
+        let result = if self.cancellation.is_cancelled() {
+            Err(connect_stopped())
+        } else if tokio::time::Instant::now() >= request.deadline {
+            Err(connect_timeout())
+        } else if !self.tcp_entries.is_empty() || self.device.emitted() != 0 {
+            Err(std::io::Error::new(
+                std::io::ErrorKind::AlreadyExists,
+                "initial TCP MTU is already in use",
+            ))
+        } else {
+            let addresses = self
+                .client
+                .as_ref()
+                .expect("active command has a client")
+                .addresses;
+            if request.mtu > self.config.mtu || addresses.validate(request.mtu).is_err() {
+                Err(std::io::Error::new(
+                    std::io::ErrorKind::InvalidInput,
+                    "invalid initial TCP packet budget",
+                ))
+            } else {
+                self.config.mtu = request.mtu;
+                self.device.set_initial_mtu(request.mtu);
+                // smoltcp snapshots DeviceCapabilities when Interface is
+                // created. Before the first flow, rebuild that snapshot and
+                // restore the same sources/routes without replacing sockets.
+                let mut config = InterfaceConfig::new(HardwareAddress::Ip);
+                config.random_seed = 0x4f_6e_65_56_43_6f_72_65;
+                self.interface = Interface::new(config, &mut self.device, Instant::now());
+                self.configure_client(&addresses);
+                Ok(())
+            }
+        };
+        let _ = request.response.send(result);
+    }
+
     fn drive(&mut self) {
         if self.raw_outbound.is_closed() {
             self.cancellation.cancel();
             return;
         }
+        self.device.flush_pending();
+        // Busy packet traffic must not starve command admission. The same
+        // bounded prefix as raw ingress avoids draining an unbounded burst.
+        for _ in 0..RAW_INGRESS_BATCH {
+            let request = self
+                .client
+                .as_mut()
+                .and_then(|client| client.requests.try_recv().ok());
+            let Some(request) = request else {
+                break;
+            };
+            self.handle_client_request(request);
+        }
         if !self.device.tx_is_full() {
             self.interface
                 .poll(Instant::now(), &mut self.device, &mut self.sockets);
+        } else if !self.device.rx_is_empty() {
+            // ACK/window progress must not wait for outbound DATA capacity.
+            // Device::receive allows only a pure ACK on this path and keeps
+            // any immediate response in the same existing pending slot.
+            self.interface
+                .poll_ingress_single(Instant::now(), &mut self.device, &mut self.sockets);
         }
         self.drive_tcp_sockets();
+        self.device.flush_pending();
         if !self.device.tx_is_full() {
             self.interface
                 .poll(Instant::now(), &mut self.device, &mut self.sockets);
         }
+        self.device.flush_pending();
     }
 
     fn drive_tcp_sockets(&mut self) {
@@ -687,12 +1053,13 @@ impl Driver {
             .and_then(parse_tcp_flow)
             .map(|(flow, _, _)| flow);
         let mut inactive = Vec::new();
-        for (flow, entry) in &self.tcp_entries {
+        for (flow, entry) in &mut self.tcp_entries {
             let socket = self.sockets.get_mut::<tcp::Socket>(entry.socket);
+            Self::finish_connect(*flow, entry, socket);
             let handle = &entry.handle;
 
             let mut received = false;
-            while socket.can_recv() && !handle.app_recv.is_full() {
+            while socket.can_recv() {
                 match socket.recv(|bytes| {
                     let count = handle.app_recv.write(bytes);
                     (count, count)
@@ -706,7 +1073,7 @@ impl Driver {
             }
 
             let mut sent = false;
-            while socket.can_send() && !handle.app_send.is_empty() {
+            while socket.can_send() {
                 match socket.send(|bytes| {
                     let count = handle.app_send.read(bytes);
                     (count, count)
@@ -723,7 +1090,7 @@ impl Driver {
                 socket.state(),
                 tcp::State::Listen | tcp::State::SynSent | tcp::State::SynReceived
             );
-            if past_handshake {
+            if past_handshake && !self.half_open.is_empty() {
                 self.half_open.remove(flow);
             }
             if past_handshake && !socket.may_recv() && !socket.can_recv() {
@@ -766,6 +1133,7 @@ impl Driver {
 
         for flow in inactive {
             if let Some(entry) = self.tcp_entries.remove(&flow) {
+                self.device.forget_flow(flow);
                 self.sockets.remove(entry.socket);
                 self.half_open.remove(&flow);
                 entry.handle.socket_closed.store(true, Ordering::Release);
@@ -776,6 +1144,55 @@ impl Driver {
         self.update_flow_stats();
     }
 
+    fn finish_connect(incoming: FlowKey, entry: &mut TcpEntry, socket: &mut tcp::Socket<'_>) {
+        let handle = &entry.handle;
+        if entry
+            .connect_cancellation
+            .as_ref()
+            .is_some_and(CancellationToken::is_cancelled)
+        {
+            // Covers cancellation after the response was queued but before
+            // the caller accepted its stream, including an established race.
+            socket.abort();
+            handle.dropped.store(true, Ordering::Release);
+        }
+        let request = entry.connecting.take_if(|request| {
+            request.response.is_closed()
+                || request.cancellation.is_cancelled()
+                || tokio::time::Instant::now() >= request.deadline
+                || matches!(
+                    socket.state(),
+                    tcp::State::Established | tcp::State::CloseWait | tcp::State::Closed
+                )
+        });
+        let Some(request) = request else {
+            return;
+        };
+        let result = if request.response.is_closed() || request.cancellation.is_cancelled() {
+            Err(connect_stopped())
+        } else if tokio::time::Instant::now() >= request.deadline {
+            Err(connect_timeout())
+        } else if socket.state() == tcp::State::Closed {
+            Err(std::io::Error::new(
+                std::io::ErrorKind::ConnectionRefused,
+                "active TCP handshake was closed",
+            ))
+        } else {
+            Ok(TcpStream::new(
+                FlowKey {
+                    source: incoming.destination,
+                    destination: incoming.source,
+                },
+                handle.clone(),
+            ))
+        };
+        if result.is_err() {
+            socket.abort();
+            handle.dropped.store(true, Ordering::Release);
+        }
+        let _ = request.response.send(result);
+    }
+
     fn next_delay(&mut self) -> Duration {
         let smoltcp_delay = self
             .interface
@@ -784,11 +1201,21 @@ impl Driver {
         // A ready egress timer cannot make progress while output is full.
         // PacketStream notifies on capacity recovery; retain a bounded timer
         // for lifecycle maintenance instead of repeatedly sleeping for zero.
-        if smoltcp_delay.is_zero() && self.device.tx_is_full() {
+        let delay = if smoltcp_delay.is_zero() && self.device.tx_is_full() {
             self.config.max_poll_interval
         } else {
             smoltcp_delay.min(self.config.max_poll_interval)
-        }
+        };
+        self.tcp_entries
+            .values()
+            .filter_map(|entry| entry.connecting.as_ref())
+            .fold(delay, |delay, request| {
+                delay.min(
+                    request
+                        .deadline
+                        .saturating_duration_since(tokio::time::Instant::now()),
+                )
+            })
     }
 
     fn update_flow_stats(&self) {
@@ -811,9 +1238,25 @@ impl Driver {
 
     fn shutdown(&mut self) {
         self.cancellation.cancel();
-        self.device.discard_rx();
-        for entry in self.tcp_entries.values() {
+        self.device.clear();
+        if let Some(client) = &mut self.client {
+            client.requests.close();
+            while let Ok(request) = client.requests.try_recv() {
+                match request {
+                    ClientRequest::Connect(request) => {
+                        let _ = request.response.send(Err(connect_stopped()));
+                    }
+                    ClientRequest::InitialMtu(request) => {
+                        let _ = request.response.send(Err(connect_stopped()));
+                    }
+                }
+            }
+        }
+        for entry in self.tcp_entries.values_mut() {
             entry.handle.mark_stopped();
+            if let Some(request) = entry.connecting.take() {
+                let _ = request.response.send(Err(connect_stopped()));
+            }
         }
         self.tcp_entries.clear();
         self.half_open.clear();
@@ -916,6 +1359,312 @@ mod tests {
         Packet::new(ip.into_inner())
     }
 
+    // Keep both real handshakes and the failed-emit timeline in one regression.
+    #[allow(clippy::too_many_lines)]
+    #[tokio::test]
+    async fn failed_fast_retransmit_survives_another_socket_filling_tx() {
+        use crate::segmentation::tests::tcp_packet;
+        use tokio::io::AsyncWriteExt;
+        let config = NetStackConfig {
+            packet_queue: 1,
+            ..NetStackConfig::default()
+        };
+        let (_inbound, receiver) = mpsc::channel(config.packet_queue);
+        let (outbound, mut packets) = mpsc::channel(config.packet_queue);
+        let (accept, mut streams) = mpsc::channel(config.tcp_accept_queue);
+        let (stopped, _) = watch::channel(false);
+        let mut driver = Driver::new(
+            config,
+            receiver,
+            outbound,
+            Some(accept),
+            None,
+            CancellationToken::new(),
+            Arc::new(Notify::new()),
+            NetStackStats::default(),
+            stopped,
+        );
+        let flows = [
+            FlowKey {
+                source: "10.0.0.2:12000".parse().unwrap(),
+                destination: "192.0.2.1:12001".parse().unwrap(),
+            },
+            FlowKey {
+                source: "10.0.0.3:12002".parse().unwrap(),
+                destination: "192.0.2.1:12001".parse().unwrap(),
+            },
+        ];
+        let mut sequences = [0; 2];
+        for (index, flow) in flows.into_iter().enumerate() {
+            let remote_sequence = 100 + u32::try_from(index).unwrap() * 100;
+            driver.handle_packet_batch(tcp_packet(flow, remote_sequence, 0, 2, 0));
+            driver.drive();
+            let syn_ack = packets.try_recv().expect("actual SYN-ACK missing");
+            let ip = Ipv4Packet::new_checked(syn_ack.data()).unwrap();
+            let tcp = TcpPacket::new_checked(ip.payload()).unwrap();
+            assert!(tcp.syn() && tcp.ack());
+            sequences[index] =
+                u32::from_be_bytes(ip.payload()[4..8].try_into().unwrap()).wrapping_add(1);
+            driver.handle_packet_batch(tcp_packet(
+                flow,
+                remote_sequence + 1,
+                sequences[index],
+                16,
+                0,
+            ));
+            driver.drive();
+            assert!(packets.try_recv().is_err());
+        }
+        let mut first_stream = streams.try_recv().unwrap();
+        let mut retry_stream = streams.try_recv().unwrap();
+        let first_handle = driver.tcp_entries[&flows[0]].socket;
+        let retry_handle = driver.tcp_entries[&flows[1]].socket;
+        let handles: Vec<_> = driver.sockets.iter().map(|(handle, _)| handle).collect();
+        assert!(
+            handles
+                .iter()
+                .position(|handle| *handle == first_handle)
+                .unwrap()
+                < handles
+                    .iter()
+                    .position(|handle| *handle == retry_handle)
+                    .unwrap(),
+            "fixture requires the output-filling socket before the retry socket"
+        );
+
+        let lost = b"actual-unacknowledged-DATA";
+        retry_stream.write_all(lost).await.unwrap();
+        driver.drive_tcp_sockets();
+        let now = Instant::now();
+        driver
+            .interface
+            .poll_egress(now, &mut driver.device, &mut driver.sockets);
+        let original = packets.try_recv().expect("actual original DATA missing");
+        let ip = Ipv4Packet::new_checked(original.data()).unwrap();
+        let tcp = TcpPacket::new_checked(ip.payload()).unwrap();
+        assert_eq!(tcp.dst_port(), flows[1].source.port());
+        assert_eq!(tcp.payload(), lost);
+        let original_sequence = tcp.seq_number();
+        assert_eq!(
+            driver.sockets.get::<tcp::Socket>(retry_handle).send_queue(),
+            lost.len()
+        );
+
+        // The actual TCP ACK parser schedules fast retransmit. Do not poll
+        // egress until the earlier socket has an ordinary DATA packet ready.
+        let ack_at = now + smoltcp::time::Duration::from_millis(1);
+        for _ in 0..3 {
+            driver.handle_packet(tcp_packet(flows[1], 201, sequences[1], 16, 0));
+            driver
+                .interface
+                .poll_ingress_single(ack_at, &mut driver.device, &mut driver.sockets);
+            assert!(driver.device.rx_is_empty());
+        }
+        let filling = b"earlier-socket-occupies-the-only-output-slot";
+        first_stream.write_all(filling).await.unwrap();
+        driver.drive_tcp_sockets();
+        driver.interface.poll_egress(
+            now + smoltcp::time::Duration::from_millis(2),
+            &mut driver.device,
+            &mut driver.sockets,
+        );
+        let occupied = packets
+            .try_recv()
+            .expect("earlier socket did not emit DATA");
+        let ip = Ipv4Packet::new_checked(occupied.data()).unwrap();
+        let tcp = TcpPacket::new_checked(ip.payload()).unwrap();
+        assert_eq!(tcp.dst_port(), flows[0].source.port());
+        assert_eq!(tcp.payload(), filling);
+        assert!(!driver.device.tx_is_full());
+
+        // Capacity is now free. No new peer ACK, application write or real-time
+        // wait follows the failed emit; only one public egress poll at +1ms.
+        driver.interface.poll_egress(
+            now + smoltcp::time::Duration::from_millis(3),
+            &mut driver.device,
+            &mut driver.sockets,
+        );
+        let retried = packets.try_recv().is_ok_and(|packet| {
+            let ip = Ipv4Packet::new_checked(packet.data()).unwrap();
+            let tcp = TcpPacket::new_checked(ip.payload()).unwrap();
+            tcp.dst_port() == flows[1].source.port()
+                && tcp.seq_number() == original_sequence
+                && tcp.payload() == lost
+                && !tcp.syn()
+                && !tcp.fin()
+                && !tcp.rst()
+        });
+        driver.shutdown();
+        drop((first_stream, retry_stream));
+        assert!(driver.cancellation.is_cancelled());
+        assert!(driver.tcp_entries.is_empty());
+        assert_eq!(driver.sockets.iter().count(), 0);
+        assert!(
+            retried,
+            "failed fast retransmit must remain immediately retryable after TX capacity returns"
+        );
+    }
+
+    #[tokio::test]
+    async fn full_tx_pure_ack_releases_actual_smoltcp_send_queue() {
+        use tokio::io::AsyncWriteExt;
+        let config = NetStackConfig {
+            packet_queue: 1,
+            ..NetStackConfig::default()
+        };
+        let (_sender, inbound) = mpsc::channel(config.packet_queue);
+        let (outbound, mut packets) = mpsc::channel(config.packet_queue);
+        let (accept, mut streams) = mpsc::channel(config.tcp_accept_queue);
+        let (stopped, _) = watch::channel(false);
+        let mut driver = Driver::new(
+            config,
+            inbound,
+            outbound,
+            Some(accept),
+            None,
+            CancellationToken::new(),
+            Arc::new(Notify::new()),
+            NetStackStats::default(),
+            stopped,
+        );
+        driver.handle_packet_batch(tcp_handshake_packet(100, None));
+        driver.drive();
+        let syn_ack = packets.try_recv().unwrap();
+        let ip = Ipv4Packet::new_checked(syn_ack.data()).unwrap();
+        let tcp = TcpPacket::new_checked(ip.payload()).unwrap();
+        let acknowledged = tcp.seq_number().0.wrapping_add(1);
+        driver.handle_packet_batch(tcp_handshake_packet(101, Some(acknowledged)));
+        driver.drive();
+        let mut stream = streams.try_recv().unwrap();
+        let payload = b"unacknowledged-before-full-output";
+        stream.write_all(payload).await.unwrap();
+        driver.drive();
+        let data = packets.try_recv().unwrap();
+        let ip = Ipv4Packet::new_checked(data.data()).unwrap();
+        let tcp = TcpPacket::new_checked(ip.payload()).unwrap();
+        assert_eq!(tcp.payload(), payload);
+        let ack = tcp
+            .seq_number()
+            .0
+            .wrapping_add(i32::try_from(payload.len()).unwrap());
+        assert_eq!(
+            driver
+                .sockets
+                .get::<tcp::Socket>(driver.tcp_entries.values().next().unwrap().socket)
+                .send_queue(),
+            payload.len()
+        );
+        driver.raw_outbound.try_send(packet(99)).unwrap();
+        assert!(driver.device.tx_is_full());
+        // A real ACK must reach the live smoltcp socket while the downstream
+        // packet consumer is blocked; no fabricated socket-state observation.
+        driver.handle_packet_batch(tcp_handshake_packet(101, Some(ack)));
+        assert!(
+            driver.device.rx_is_empty(),
+            "ACK remained blocked behind full TX"
+        );
+        assert_eq!(
+            driver
+                .sockets
+                .get::<tcp::Socket>(driver.tcp_entries.values().next().unwrap().socket)
+                .send_queue(),
+            0
+        );
+        assert_eq!(packets.try_recv().unwrap(), packet(99));
+        driver.shutdown();
+        assert!(driver.cancellation.is_cancelled());
+    }
+
+    #[tokio::test]
+    async fn full_tx_smoltcp_immediate_reset_is_retained_until_capacity_returns() {
+        let config = NetStackConfig {
+            packet_queue: 1,
+            ..NetStackConfig::default()
+        };
+        let (_sender, inbound) = mpsc::channel(config.packet_queue);
+        let (outbound, mut packets) = mpsc::channel(config.packet_queue);
+        let (accept, _streams) = mpsc::channel(config.tcp_accept_queue);
+        let (stopped, _) = watch::channel(false);
+        let mut driver = Driver::new(
+            config,
+            inbound,
+            outbound,
+            Some(accept),
+            None,
+            CancellationToken::new(),
+            Arc::new(Notify::new()),
+            NetStackStats::default(),
+            stopped,
+        );
+        driver.handle_packet_batch(tcp_handshake_packet(100, None));
+        driver.drive();
+        let syn_ack = packets.try_recv().unwrap();
+        let ip = Ipv4Packet::new_checked(syn_ack.data()).unwrap();
+        let tcp = TcpPacket::new_checked(ip.payload()).unwrap();
+        let wrong_ack = tcp.seq_number().0.wrapping_add(2);
+        driver.raw_outbound.try_send(packet(99)).unwrap();
+        driver.handle_packet_batch(tcp_handshake_packet(101, Some(wrong_ack)));
+        assert!(
+            driver.device.rx_is_empty(),
+            "full TX blocked the invalid-ACK response path"
+        );
+        assert_eq!(packets.try_recv().unwrap(), packet(99));
+        driver.drive();
+        let reset = packets.try_recv().unwrap();
+        let ip = Ipv4Packet::new_checked(reset.data()).unwrap();
+        assert!(TcpPacket::new_checked(ip.payload()).unwrap().rst());
+        assert!(packets.try_recv().is_err());
+        driver.shutdown();
+        assert!(driver.device.rx_is_empty());
+        assert!(driver.cancellation.is_cancelled());
+    }
+
+    #[tokio::test]
+    async fn ready_ingress_progresses_before_repeated_app_notifications() {
+        for cancelled in [false, true] {
+            let config = NetStackConfig::default();
+            let (sender, inbound) = mpsc::channel(config.packet_queue);
+            let (outbound, _packets) = mpsc::channel(config.packet_queue);
+            let (accept, _streams) = mpsc::channel(config.tcp_accept_queue);
+            let (stopped, _) = watch::channel(false);
+            let cancellation = CancellationToken::new();
+            let notify = Arc::new(Notify::new());
+            let mut driver = Driver::new(
+                config,
+                inbound,
+                outbound,
+                Some(accept),
+                None,
+                cancellation.clone(),
+                notify.clone(),
+                NetStackStats::default(),
+                stopped,
+            );
+            sender.try_send(tcp_handshake_packet(100, None)).unwrap();
+            // Application writes and output capacity recovery can make this
+            // notification ready on every iteration of a busy duplex relay.
+            for _ in 0..3 {
+                notify.notify_one();
+                if cancelled {
+                    cancellation.cancel();
+                }
+                let running = driver.wait_for_work().await;
+                assert_eq!(running, !cancelled);
+                if cancelled {
+                    assert_eq!(driver.raw_inbound.len(), 1);
+                    assert!(driver.tcp_entries.is_empty());
+                    break;
+                }
+                assert!(
+                    driver.raw_inbound.is_empty(),
+                    "ready IP input lost to app notification"
+                );
+                assert_eq!(driver.tcp_entries.len(), 1);
+                sender.try_send(tcp_handshake_packet(100, None)).unwrap();
+            }
+        }
+    }
+
     #[tokio::test]
     async fn driver_batch_preserves_queued_suffix_when_tcp_ingress_fills_tx() {
         let config = NetStackConfig {
@@ -931,7 +1680,7 @@ mod tests {
             config,
             inbound,
             outbound,
-            accept,
+            Some(accept),
             Some(udp),
             CancellationToken::new(),
             Arc::new(Notify::new()),
@@ -1001,7 +1750,7 @@ mod tests {
             config,
             inbound,
             outbound,
-            accept,
+            Some(accept),
             Some(udp),
             CancellationToken::new(),
             Arc::new(Notify::new()),
@@ -1073,7 +1822,7 @@ mod tests {
             config,
             inbound,
             outbound,
-            accept,
+            Some(accept),
             None,
             CancellationToken::new(),
             Arc::new(Notify::new()),
diff --git a/crates/vole-netstack/src/tcp.rs b/crates/vole-netstack/src/tcp.rs
index 756e44c..30cb38b 100644
--- a/crates/vole-netstack/src/tcp.rs
+++ b/crates/vole-netstack/src/tcp.rs
@@ -13,17 +13,178 @@ use std::{
 use futures_util::task::AtomicWaker;
 use tokio::{
     io::{AsyncRead, AsyncWrite, ReadBuf},
-    sync::{Notify, mpsc},
+    sync::{Notify, mpsc, oneshot},
+    time::Instant,
 };
 use tokio_util::sync::CancellationToken;
 
+use crate::ClientConfig;
+
+pub(crate) struct ConnectRequest {
+    pub(crate) destination: SocketAddr,
+    pub(crate) deadline: Instant,
+    pub(crate) cancellation: CancellationToken,
+    pub(crate) response: oneshot::Sender<std::io::Result<TcpStream>>,
+}
+
+pub(crate) struct InitialMtuRequest {
+    pub(crate) mtu: usize,
+    pub(crate) deadline: Instant,
+    pub(crate) response: oneshot::Sender<std::io::Result<()>>,
+}
+
+pub(crate) enum ClientRequest {
+    Connect(ConnectRequest),
+    InitialMtu(InitialMtuRequest),
+}
+
+struct ConnectGuard {
+    cancellation: CancellationToken,
+    notify: Arc<Notify>,
+    armed: bool,
+}
+
+impl Drop for ConnectGuard {
+    fn drop(&mut self) {
+        if self.armed {
+            self.cancellation.cancel();
+            self.notify.notify_one();
+        }
+    }
+}
+
+/// Active TCP connections driven entirely by the stack's raw-IP endpoints.
+#[derive(Clone)]
+pub struct TcpConnector {
+    pub(crate) sender: mpsc::Sender<ClientRequest>,
+    pub(crate) cancellation: CancellationToken,
+    pub(crate) notify: Arc<Notify>,
+    pub(crate) addresses: ClientConfig,
+}
+
+impl TcpConnector {
+    /// Reduces the initial transmit MTU to a known packet-transport budget.
+    ///
+    /// This must complete before the first TCP connection. Receive packet
+    /// limits and source prefixes remain unchanged. Admission and completion
+    /// share the supplied deadline, and Stop never waits on this command.
+    ///
+    /// # Errors
+    ///
+    /// Returns `InvalidInput` for an increase or invalid family MTU,
+    /// `AlreadyExists` once TCP output or a flow exists, `TimedOut` at the
+    /// deadline, and `ConnectionAborted` when the stack stops.
+    pub async fn set_initial_mtu(&self, mtu: usize, deadline: Instant) -> std::io::Result<()> {
+        if Instant::now() >= deadline {
+            return Err(connect_timeout());
+        }
+        let (response, received) = oneshot::channel();
+        let request = ClientRequest::InitialMtu(InitialMtuRequest {
+            mtu,
+            deadline,
+            response,
+        });
+        tokio::select! {
+            biased;
+            () = self.cancellation.cancelled() => return Err(connect_stopped()),
+            () = tokio::time::sleep_until(deadline) => return Err(connect_timeout()),
+            result = self.sender.send(request) => result.map_err(|_| connect_stopped())?,
+        }
+        tokio::select! {
+            biased;
+            () = self.cancellation.cancelled() => Err(connect_stopped()),
+            () = tokio::time::sleep_until(deadline) => Err(connect_timeout()),
+            result = received => result.unwrap_or_else(|_| Err(connect_stopped())),
+        }
+    }
+
+    /// Connects to an IP endpoint and returns only after TCP is established.
+    ///
+    /// Queue admission and handshake share the supplied absolute deadline.
+    /// Dropping this future cancels its pending request and socket; no background
+    /// connect task survives the caller. The stack performs no DNS or host I/O.
+    ///
+    /// # Errors
+    ///
+    /// Returns `AddrNotAvailable` for an unconfigured address family,
+    /// `InvalidInput` for a non-unicast/zero-port peer, `TimedOut` at the
+    /// deadline, or an I/O error when TCP fails or the stack stops.
+    pub async fn connect(
+        &self,
+        mut destination: SocketAddr,
+        deadline: Instant,
+    ) -> std::io::Result<TcpStream> {
+        if let std::net::IpAddr::V6(ip) = destination.ip()
+            && let Some(ip) = ip.to_ipv4_mapped()
+        {
+            destination = SocketAddr::new(ip.into(), destination.port());
+        }
+        let invalid_ip = match destination.ip() {
+            std::net::IpAddr::V4(ip) => {
+                ip.is_unspecified() || ip.is_multicast() || ip.is_broadcast()
+            }
+            std::net::IpAddr::V6(ip) => ip.is_unspecified() || ip.is_multicast(),
+        };
+        if invalid_ip || destination.port() == 0 {
+            return Err(Error::new(
+                ErrorKind::InvalidInput,
+                "invalid active TCP peer",
+            ));
+        }
+        self.addresses.source_for(destination.ip())?;
+        if Instant::now() >= deadline {
+            return Err(connect_timeout());
+        }
+        let cancellation = CancellationToken::new();
+        let mut guard = ConnectGuard {
+            cancellation: cancellation.clone(),
+            notify: self.notify.clone(),
+            armed: true,
+        };
+        let (response, received) = oneshot::channel();
+        let request = ConnectRequest {
+            destination,
+            deadline,
+            cancellation,
+            response,
+        };
+        tokio::select! {
+            biased;
+            () = self.cancellation.cancelled() => return Err(connect_stopped()),
+            () = tokio::time::sleep_until(deadline) => return Err(connect_timeout()),
+            result = self.sender.send(ClientRequest::Connect(request)) => result.map_err(|_| connect_stopped())?,
+        }
+        let result = tokio::select! {
+            biased;
+            () = self.cancellation.cancelled() => Err(connect_stopped()),
+            () = tokio::time::sleep_until(deadline) => Err(connect_timeout()),
+            result = received => result.unwrap_or_else(|_| Err(connect_stopped())),
+        };
+        if result.is_ok() {
+            guard.armed = false;
+        }
+        result
+    }
+}
+
+pub(crate) fn connect_stopped() -> Error {
+    Error::new(
+        ErrorKind::ConnectionAborted,
+        "netstack is stopping or stopped",
+    )
+}
+
+pub(crate) fn connect_timeout() -> Error {
+    Error::new(ErrorKind::TimedOut, "netstack TCP connect deadline elapsed")
+}
+
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub(crate) struct FlowKey {
     pub(crate) source: SocketAddr,
     pub(crate) destination: SocketAddr,
 }
 
-/// A bounded queue whose allocation is made once when a flow is accepted.
+/// A bounded queue whose storage grows with use and is retained until drop.
 pub(crate) struct ByteQueue {
     bytes: Mutex<VecDeque<u8>>,
     capacity: usize,
@@ -32,7 +193,7 @@ pub(crate) struct ByteQueue {
 impl ByteQueue {
     fn new(capacity: usize) -> Self {
         Self {
-            bytes: Mutex::new(VecDeque::with_capacity(capacity)),
+            bytes: Mutex::new(VecDeque::new()),
             capacity,
         }
     }
@@ -46,6 +207,16 @@ impl ByteQueue {
     pub(crate) fn write(&self, source: &[u8]) -> usize {
         let mut bytes = self.lock();
         let count = source.len().min(self.capacity - bytes.len());
+        let needed = bytes.len() + count;
+        if needed > bytes.capacity() {
+            // Amortized VecDeque growth can overshoot even a power-of-two
+            // limit when the first write is an arbitrary-sized TCP segment.
+            let target = needed
+                .max(bytes.capacity().saturating_mul(2))
+                .min(self.capacity);
+            let additional = target - bytes.len();
+            bytes.reserve_exact(additional);
+        }
         bytes.extend(&source[..count]);
         count
     }
@@ -60,10 +231,6 @@ impl ByteQueue {
         self.lock().is_empty()
     }
 
-    pub(crate) fn is_full(&self) -> bool {
-        self.lock().len() == self.capacity
-    }
-
     #[cfg(test)]
     pub(crate) fn len(&self) -> usize {
         self.lock().len()
@@ -119,7 +286,7 @@ impl TcpStreamHandle {
     }
 }
 
-/// One TCP flow intercepted from the raw-IP side.
+/// One intercepted or actively established userspace TCP flow.
 pub struct TcpStream {
     flow: FlowKey,
     pub(crate) handle: Arc<TcpStreamHandle>,
@@ -130,13 +297,13 @@ impl TcpStream {
         Self { flow, handle }
     }
 
-    /// Address of the application that wrote the original TUN packet.
+    /// Intercepted application address, or local source of an active connection.
     #[must_use]
     pub const fn source_addr(&self) -> SocketAddr {
         self.flow.source
     }
 
-    /// Original destination that the outbound dispatcher must dial.
+    /// Original intercepted destination, or remote peer of an active connection.
     #[must_use]
     pub const fn destination_addr(&self) -> SocketAddr {
         self.flow.destination
@@ -323,6 +490,68 @@ mod tests {
         assert_eq!(&bytes[..4], b"abcd");
     }
 
+    #[test]
+    fn byte_queue_grows_with_use_without_exceeding_its_storage_limit() {
+        for limit in [16 * 1024, 16 * 1024 - 3] {
+            let queue = ByteQueue::new(limit);
+            assert_eq!(queue.lock().capacity(), 0);
+            assert_eq!(queue.write(&[]), 0);
+            assert_eq!(queue.lock().capacity(), 0);
+
+            assert_eq!(queue.write(&[42]), 1);
+            assert!(queue.lock().capacity() < limit);
+            let mut hello = [0];
+            assert_eq!(queue.read(&mut hello), 1);
+            assert_eq!(hello, [42]);
+
+            let payload: Vec<_> = (0_u8..=250).cycle().take(limit).collect();
+            for chunk in payload.chunks(1460) {
+                assert_eq!(queue.write(chunk), chunk.len());
+                assert!(queue.lock().capacity() <= limit);
+            }
+            let full_capacity = queue.lock().capacity();
+            assert_eq!(queue.len(), limit);
+            assert_eq!(queue.write(b"full"), 0);
+            assert_eq!(queue.lock().capacity(), full_capacity);
+
+            let mut prefix = vec![0; 6 * 1024];
+            assert_eq!(queue.read(&mut prefix), prefix.len());
+            assert_eq!(prefix, payload[..prefix.len()]);
+            let suffix = vec![7; prefix.len()];
+            assert_eq!(queue.write(&suffix), suffix.len());
+            let mut remaining = vec![0; limit];
+            let mut received = 0;
+            while received < limit {
+                let count = queue.read(&mut remaining[received..]);
+                assert!(count > 0);
+                received += count;
+            }
+            assert_eq!(&remaining[..limit - suffix.len()], &payload[prefix.len()..]);
+            assert_eq!(&remaining[limit - suffix.len()..], &suffix);
+            assert!(queue.is_empty());
+            assert_eq!(queue.lock().capacity(), full_capacity);
+        }
+
+        let queue = ByteQueue::new(13);
+        assert_eq!(queue.write(b"abcdef"), 6);
+        let mut prefix = [0; 4];
+        assert_eq!(queue.read(&mut prefix), 4);
+        assert_eq!(&prefix, b"abcd");
+        assert_eq!(queue.write(b"ghijkl"), 6);
+        assert!(queue.lock().capacity() <= 13);
+        assert_eq!(queue.write(b"mnopq"), 5);
+        assert_eq!(queue.write(b"full"), 0);
+        assert!(queue.lock().capacity() <= 13);
+        let mut remaining = [0; 13];
+        let mut received = 0;
+        while received < remaining.len() {
+            let count = queue.read(&mut remaining[received..]);
+            assert!(count > 0);
+            received += count;
+        }
+        assert_eq!(&remaining, b"efghijklmnopq");
+    }
+
     #[tokio::test]
     async fn closed_socket_unblocks_buffered_flush_and_rejects_writes() {
         let handle = Arc::new(TcpStreamHandle::new(16, 16, Arc::new(Notify::new())));
diff --git a/crates/vole-netstack/tests/netstack.rs b/crates/vole-netstack/tests/netstack.rs
index d078cb6..fc1546a 100644
--- a/crates/vole-netstack/tests/netstack.rs
+++ b/crates/vole-netstack/tests/netstack.rs
@@ -1,14 +1,1031 @@
 use std::{
-    net::{Ipv4Addr, Ipv6Addr, SocketAddr},
+    net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr},
     time::Duration,
 };
 
 use bytes::Bytes;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
-use vole_netstack::{NetStack, NetStackConfig, NetStackError, Packet, UdpDatagram};
+use vole_netstack::{
+    ClientAddresses, ClientConfig, ClientPrefix, NetStack, NetStackConfig, NetStackError, Packet,
+    UdpDatagram,
+};
 
 const WAIT: Duration = Duration::from_secs(2);
 
+fn client_addresses() -> ClientAddresses {
+    ClientAddresses {
+        ipv4: Some("10.23.0.2".parse().unwrap()),
+        ipv6: Some("fd23::2".parse().unwrap()),
+    }
+}
+
+fn tcp_flow(packet: &Packet) -> Flow {
+    let bytes = packet.data();
+    let offset = ip_header_len(bytes);
+    let (source, destination) = match bytes[0] >> 4 {
+        4 => (
+            Ipv4Addr::from(<[u8; 4]>::try_from(&bytes[12..16]).unwrap()).into(),
+            Ipv4Addr::from(<[u8; 4]>::try_from(&bytes[16..20]).unwrap()).into(),
+        ),
+        6 => (
+            Ipv6Addr::from(<[u8; 16]>::try_from(&bytes[8..24]).unwrap()).into(),
+            Ipv6Addr::from(<[u8; 16]>::try_from(&bytes[24..40]).unwrap()).into(),
+        ),
+        _ => unreachable!(),
+    };
+    Flow {
+        source: SocketAddr::new(
+            source,
+            u16::from_be_bytes(bytes[offset..offset + 2].try_into().unwrap()),
+        ),
+        destination: SocketAddr::new(
+            destination,
+            u16::from_be_bytes(bytes[offset + 2..offset + 4].try_into().unwrap()),
+        ),
+    }
+}
+
+fn client_prefix(address: &str, prefix_len: u8) -> ClientPrefix {
+    ClientPrefix {
+        address: address.parse().unwrap(),
+        prefix_len,
+    }
+}
+
+fn tcp_mss(packet: &Packet) -> Option<u16> {
+    let offset = ip_header_len(packet.data());
+    let header_len = usize::from(packet.data()[offset + 12] >> 4) * 4;
+    let mut options = &packet.data()[offset + 20..offset + header_len];
+    while let Some(kind) = options.first().copied() {
+        match kind {
+            0 => break,
+            1 => options = &options[1..],
+            _ => {
+                let length = usize::from(options[1]);
+                assert!(length >= 2 && length <= options.len());
+                if kind == 2 {
+                    assert_eq!(length, 4);
+                    return Some(u16::from_be_bytes([options[2], options[3]]));
+                }
+                options = &options[length..];
+            }
+        }
+    }
+    None
+}
+
+fn tcp_payload(packet: &Packet) -> &[u8] {
+    let offset = ip_header_len(packet.data());
+    let start = offset + usize::from(packet.data()[offset + 12] >> 4) * 4;
+    &packet.data()[start..]
+}
+
+async fn timeout_tcp_data(stream: &mut vole_netstack::PacketStream) -> Packet {
+    loop {
+        let packet = timeout_packet(stream).await;
+        if !tcp_payload(&packet).is_empty() {
+            return packet;
+        }
+    }
+}
+
+async fn active_connect(
+    parts: &mut vole_netstack::ClientNetStackParts,
+    destination: SocketAddr,
+) -> (vole_netstack::TcpStream, Flow, u32) {
+    active_connect_with_mss(parts, destination, 1460).await
+}
+
+async fn active_connect_with_mss(
+    parts: &mut vole_netstack::ClientNetStackParts,
+    destination: SocketAddr,
+    peer_mss: u16,
+) -> (vole_netstack::TcpStream, Flow, u32) {
+    let mut connect = Box::pin(
+        parts
+            .tcp_connector
+            .connect(destination, tokio::time::Instant::now() + WAIT),
+    );
+    assert!(futures_util::poll!(connect.as_mut()).is_pending());
+    let syn = timeout_tcp_flag(&mut parts.packet_stream, TcpFlags::SYN).await;
+    let local = tcp_flow(&syn);
+    let peer = Flow {
+        source: local.destination,
+        destination: local.source,
+    };
+    let sequence = tcp_sequence(&syn).wrapping_add(1);
+    parts
+        .packet_sink
+        .send(build_tcp_mss(
+            &peer,
+            700,
+            sequence,
+            TcpFlags::SYN | TcpFlags::ACK,
+            &[],
+            peer_mss,
+        ))
+        .await
+        .unwrap();
+    let stream = tokio::time::timeout(WAIT, connect).await.unwrap().unwrap();
+    (stream, peer, sequence)
+}
+
+#[tokio::test]
+async fn client_pmtu_partial_ack_recovers_and_stop_releases_a_blocked_split() {
+    let mut parts = NetStack::start_client(
+        NetStackConfig {
+            mtu: 9000,
+            packet_queue: 1,
+            max_poll_interval: Duration::from_millis(2),
+            ..NetStackConfig::default()
+        },
+        ClientConfig {
+            prefixes: [Some(client_prefix("10.23.0.2", 24)), None],
+            receive_packet_limit: 9000,
+            path_mtu_discovery: true,
+        },
+    )
+    .unwrap();
+    let (mut stream, peer, sequence) =
+        active_connect_with_mss(&mut parts, "198.51.100.20:443".parse().unwrap(), 8960).await;
+    let payload: Vec<_> = (0..2048)
+        .map(|index| u8::try_from(index % 251).unwrap())
+        .collect();
+    stream.write_all(&payload).await.unwrap();
+    let original = timeout_tcp_data(&mut parts.packet_stream).await;
+    assert!(
+        tcp_payload(&original).len() >= 2000,
+        "jumbo fixture emitted only {} bytes",
+        tcp_payload(&original).len()
+    );
+    let payload = &payload[..tcp_payload(&original).len()];
+    assert_eq!(tcp_payload(&original), payload);
+    let acknowledged = 900;
+    parts
+        .packet_sink
+        .send(build_tcp(
+            &peer,
+            701,
+            sequence.wrapping_add(acknowledged),
+            TcpFlags::ACK,
+            b"!",
+        ))
+        .await
+        .unwrap();
+    let mut barrier = [0];
+    tokio::time::timeout(WAIT, stream.read_exact(&mut barrier))
+        .await
+        .unwrap()
+        .unwrap();
+    assert_eq!(barrier, *b"!");
+    // A checksum-valid quote inside the acknowledged prefix is stale.
+    parts
+        .packet_sink
+        .send(build_path_mtu_hint(&original, 576))
+        .await
+        .unwrap();
+    // Quote the first unacknowledged sequence using a complete genuine TCP
+    // packet. The ICMP message still retains only its eight-byte TCP prefix.
+    let tail = build_tcp(
+        &Flow {
+            source: peer.destination,
+            destination: peer.source,
+        },
+        sequence.wrapping_add(acknowledged),
+        702,
+        TcpFlags::ACK,
+        &payload[usize::try_from(acknowledged).unwrap()..],
+    );
+    parts
+        .packet_sink
+        .send(build_path_mtu_hint(&tail, 576))
+        .await
+        .unwrap();
+    let recovered = timeout_tcp_data(&mut parts.packet_stream).await;
+    assert_eq!(
+        tcp_sequence(&recovered),
+        sequence.wrapping_add(acknowledged)
+    );
+    assert!(recovered.len() <= 576);
+    assert_eq!(
+        tcp_payload(&recovered),
+        &payload[900..900 + tcp_payload(&recovered).len()]
+    );
+    // A one-slot output leaves thousands of bytes in the packet adapter's
+    // original. Waiting neither drains the output nor makes Stop depend on it.
+    tokio::time::sleep(Duration::from_millis(5)).await;
+    tokio::time::timeout(WAIT, parts.control.stop())
+        .await
+        .unwrap();
+    assert!(stream.is_stopped());
+    assert_eq!(parts.stats.snapshot().active_tcp, 0);
+    assert!(parts.packet_stream.recv().await.is_none());
+}
+
+#[tokio::test]
+async fn masque_client_mtu_sources_and_independent_receive_budget_use_actual_packets() {
+    for (mtu, prefix, destination, expected_mss) in [
+        (68, client_prefix("10.23.0.2", 24), "10.23.0.20:443", 28),
+        (1280, client_prefix("fd23::2", 64), "[fd23::20]:443", 1220),
+    ] {
+        let mut parts = NetStack::start_client(
+            NetStackConfig {
+                mtu: 1500,
+                ..NetStackConfig::default()
+            },
+            ClientConfig {
+                prefixes: [Some(prefix), None],
+                receive_packet_limit: 1500,
+                path_mtu_discovery: true,
+            },
+        )
+        .unwrap();
+        parts
+            .tcp_connector
+            .set_initial_mtu(mtu, tokio::time::Instant::now() + WAIT)
+            .await
+            .unwrap();
+        let mut connect = Box::pin(parts.tcp_connector.connect(
+            destination.parse().unwrap(),
+            tokio::time::Instant::now() + WAIT,
+        ));
+        assert!(futures_util::poll!(connect.as_mut()).is_pending());
+        let syn = timeout_tcp_flag(&mut parts.packet_stream, TcpFlags::SYN).await;
+        assert!(syn.len() <= mtu);
+        assert_eq!(tcp_mss(&syn), Some(expected_mss));
+        let flow = tcp_flow(&syn);
+        assert_eq!(flow.source.ip(), prefix.address);
+        let peer = Flow {
+            source: flow.destination,
+            destination: flow.source,
+        };
+        let local_sequence = tcp_sequence(&syn).wrapping_add(1);
+        parts
+            .packet_sink
+            .send(build_tcp_mss(
+                &peer,
+                700,
+                local_sequence,
+                TcpFlags::SYN | TcpFlags::ACK,
+                &[],
+                if mtu == 68 { 28 } else { 1220 },
+            ))
+            .await
+            .unwrap();
+        let mut stream = tokio::time::timeout(WAIT, connect).await.unwrap().unwrap();
+        let incoming = vec![0x61; 1400];
+        let packet = build_tcp(&peer, 701, local_sequence, TcpFlags::ACK, &incoming);
+        assert!(packet.len() > mtu);
+        parts.packet_sink.send(packet).await.unwrap();
+        let mut received = vec![0; incoming.len()];
+        tokio::time::timeout(WAIT, stream.read_exact(&mut received))
+            .await
+            .unwrap()
+            .unwrap();
+        assert_eq!(received, incoming);
+        let outgoing = vec![0x62; 100];
+        stream.write_all(&outgoing).await.unwrap();
+        let mut emitted = Vec::new();
+        while emitted.len() < outgoing.len() {
+            let packet = timeout_tcp_data(&mut parts.packet_stream).await;
+            assert!(packet.len() <= mtu);
+            if mtu == 68 {
+                assert!(
+                    tcp_payload(&packet).len() <= 28,
+                    "small path MSS was ignored"
+                );
+            }
+            emitted.extend_from_slice(tcp_payload(&packet));
+            parts
+                .packet_sink
+                .send(build_tcp(
+                    &peer,
+                    2101,
+                    local_sequence.wrapping_add(u32::try_from(emitted.len()).unwrap()),
+                    TcpFlags::ACK,
+                    &[],
+                ))
+                .await
+                .unwrap();
+        }
+        assert_eq!(emitted, outgoing);
+        parts.control.stop().await;
+        assert!(stream.is_stopped());
+        assert_eq!(parts.stats.snapshot().active_tcp, 0);
+    }
+    assert_two_configured_sources().await;
+}
+
+#[tokio::test]
+async fn initial_mtu_rejects_invalid_late_and_stopped_commands() {
+    let mut parts = NetStack::start_client(
+        NetStackConfig::default(),
+        ClientConfig {
+            prefixes: [Some(client_prefix("10.23.0.2", 24)), None],
+            receive_packet_limit: 1500,
+            path_mtu_discovery: true,
+        },
+    )
+    .unwrap();
+    let connector = &parts.tcp_connector;
+    for mtu in [67, 1501] {
+        assert_eq!(
+            connector
+                .set_initial_mtu(mtu, tokio::time::Instant::now() + WAIT)
+                .await
+                .unwrap_err()
+                .kind(),
+            std::io::ErrorKind::InvalidInput
+        );
+    }
+    assert_eq!(
+        connector
+            .set_initial_mtu(1280, tokio::time::Instant::now())
+            .await
+            .unwrap_err()
+            .kind(),
+        std::io::ErrorKind::TimedOut
+    );
+    connector
+        .set_initial_mtu(1280, tokio::time::Instant::now() + WAIT)
+        .await
+        .unwrap();
+    let mut connect = Box::pin(connector.connect(
+        "198.51.100.2:443".parse().unwrap(),
+        tokio::time::Instant::now() + WAIT,
+    ));
+    assert!(futures_util::poll!(connect.as_mut()).is_pending());
+    let syn = timeout_tcp_flag(&mut parts.packet_stream, TcpFlags::SYN).await;
+    assert_eq!(tcp_mss(&syn), Some(1240));
+    assert_eq!(
+        connector
+            .set_initial_mtu(1000, tokio::time::Instant::now() + WAIT)
+            .await
+            .unwrap_err()
+            .kind(),
+        std::io::ErrorKind::AlreadyExists
+    );
+    parts.control.stop().await;
+    assert_eq!(
+        connector
+            .set_initial_mtu(1280, tokio::time::Instant::now() + WAIT)
+            .await
+            .unwrap_err()
+            .kind(),
+        std::io::ErrorKind::ConnectionAborted
+    );
+    assert!(connect.await.is_err());
+}
+
+async fn assert_two_configured_sources() {
+    let mut parts = NetStack::start_client(
+        NetStackConfig::default(),
+        ClientConfig {
+            prefixes: [
+                Some(client_prefix("10.23.0.2", 24)),
+                Some(client_prefix("10.24.0.2", 24)),
+            ],
+            receive_packet_limit: 1500,
+            path_mtu_discovery: true,
+        },
+    )
+    .unwrap();
+    for (destination, expected_source) in [
+        ("[::ffff:10.23.0.20]:443", "10.23.0.2"),
+        ("10.24.0.20:443", "10.24.0.2"),
+    ] {
+        let (stream, _, _) = active_connect(&mut parts, destination.parse().unwrap()).await;
+        assert_eq!(
+            stream.source_addr().ip(),
+            expected_source.parse::<IpAddr>().unwrap()
+        );
+        drop(stream);
+    }
+    parts.control.stop().await;
+    assert_eq!(parts.stats.snapshot().active_tcp, 0);
+}
+
+#[tokio::test]
+async fn masque_client_pmtu_resegments_only_the_active_quoted_flow() {
+    for (first_peer, second_peer, payload_len, mtu) in [
+        ("198.51.100.20:443", "198.51.100.21:443", 800, 576),
+        ("[2001:db8:2::20]:443", "[2001:db8:2::21]:443", 1400, 1280),
+    ] {
+        let mut parts = NetStack::start_client(
+            NetStackConfig::default(),
+            ClientConfig {
+                prefixes: [
+                    Some(client_prefix("10.23.0.2", 24)),
+                    Some(client_prefix("fd23::2", 64)),
+                ],
+                receive_packet_limit: 1500,
+                path_mtu_discovery: true,
+            },
+        )
+        .unwrap();
+        let (mut first, peer, sequence) =
+            active_connect(&mut parts, first_peer.parse().unwrap()).await;
+        let (mut second, _, _) = active_connect(&mut parts, second_peer.parse().unwrap()).await;
+        first.write_all(&vec![0x41; payload_len]).await.unwrap();
+        let acknowledged = timeout_tcp_data(&mut parts.packet_stream).await;
+        assert_eq!(
+            tcp_payload(&acknowledged).len(),
+            payload_len,
+            "baseline first write was segmented for {first_peer}"
+        );
+        assert_eq!(tcp_sequence(&acknowledged), sequence);
+        parts
+            .packet_sink
+            .send(build_tcp(
+                &peer,
+                701,
+                sequence.wrapping_add(u32::try_from(payload_len).unwrap()),
+                TcpFlags::ACK,
+                b"!",
+            ))
+            .await
+            .unwrap();
+        // Queue admission is not TCP ACK processing. Consume actual peer data
+        // from the same ACK so the second write starts with released flight
+        // credit, rather than racing the driver's pre-ingress egress pass.
+        let mut barrier = [0];
+        tokio::time::timeout(WAIT, first.read_exact(&mut barrier))
+            .await
+            .unwrap()
+            .unwrap();
+        assert_eq!(&barrier, b"!");
+        // A real, checksummed error for already acknowledged bytes cannot alter
+        // this socket or seed a destination-wide cache for either connection.
+        parts
+            .packet_sink
+            .send(build_path_mtu_hint(&acknowledged, mtu))
+            .await
+            .unwrap();
+        first.write_all(&vec![0x42; payload_len]).await.unwrap();
+        let outstanding = timeout_tcp_data(&mut parts.packet_stream).await;
+        assert!(
+            outstanding.len() > usize::from(mtu),
+            "new frame for {first_peer}: length={}, sequence={}, expected_sequence={}",
+            outstanding.len(),
+            tcp_sequence(&outstanding),
+            sequence.wrapping_add(u32::try_from(payload_len).unwrap())
+        );
+        assert_eq!(
+            tcp_sequence(&outstanding),
+            sequence.wrapping_add(u32::try_from(payload_len).unwrap())
+        );
+        parts
+            .packet_sink
+            .send(build_path_mtu_hint(&outstanding, mtu))
+            .await
+            .unwrap();
+        let retransmitted = timeout_tcp_data(&mut parts.packet_stream).await;
+        assert_eq!(tcp_flow(&retransmitted).source, first.source_addr());
+        assert_eq!(tcp_sequence(&retransmitted), tcp_sequence(&outstanding));
+        assert!(retransmitted.len() <= usize::from(mtu));
+        let fragment_size = usize::from(mtu) - ip_header_len(outstanding.data()) - 20;
+        assert_eq!(
+            tcp_payload(&retransmitted),
+            &tcp_payload(&outstanding)[..fragment_size]
+        );
+        second.write_all(&vec![0x43; payload_len]).await.unwrap();
+        loop {
+            let packet = timeout_tcp_data(&mut parts.packet_stream).await;
+            if tcp_flow(&packet).source == second.source_addr() {
+                assert!(
+                    packet.len() > usize::from(mtu),
+                    "PMTU leaked into a sibling flow"
+                );
+                assert_eq!(tcp_payload(&packet), &vec![0x43; payload_len]);
+                break;
+            }
+        }
+        parts.control.stop().await;
+        assert!(first.is_stopped() && second.is_stopped());
+        assert_eq!(parts.stats.snapshot().active_tcp, 0);
+    }
+}
+
+#[tokio::test]
+async fn passive_tun_pmtu_resegments_only_live_sent_tcp_and_preserves_siblings() {
+    for (first_flow, second_flow, length, mtu) in [
+        (Flow::v4(21001), Flow::v4(21002), 800, 576u16),
+        (Flow::v6(21001), Flow::v6(21002), 1400, 1280u16),
+    ] {
+        let mut parts = NetStack::start(NetStackConfig::default())
+            .unwrap()
+            .into_parts();
+        let mut streams = Vec::new();
+        for flow in [&first_flow, &second_flow] {
+            parts
+                .packet_sink
+                .send(build_tcp_mss(flow, 100, 0, TcpFlags::SYN, &[], 1460))
+                .await
+                .unwrap();
+            let reply = timeout_tcp_flag(&mut parts.packet_stream, TcpFlags::SYN).await;
+            assert!(is_syn_ack(&reply, flow));
+            parts
+                .packet_sink
+                .send(build_tcp(
+                    flow,
+                    101,
+                    tcp_sequence(&reply).wrapping_add(1),
+                    TcpFlags::ACK,
+                    &[],
+                ))
+                .await
+                .unwrap();
+            streams.push(
+                tokio::time::timeout(WAIT, parts.tcp_listener.accept())
+                    .await
+                    .unwrap()
+                    .unwrap(),
+            );
+        }
+        streams[0].write_all(&vec![0x51; length]).await.unwrap();
+        let outstanding = timeout_tcp_data(&mut parts.packet_stream).await;
+        assert!(outstanding.len() > usize::from(mtu));
+        parts
+            .packet_sink
+            .send(build_path_mtu_hint(&outstanding, mtu))
+            .await
+            .unwrap();
+        let retransmitted = timeout_tcp_data(&mut parts.packet_stream).await;
+        assert_eq!(tcp_sequence(&retransmitted), tcp_sequence(&outstanding));
+        assert_eq!(tcp_flow(&retransmitted).destination, first_flow.source);
+        assert!(retransmitted.len() <= usize::from(mtu));
+        streams[1].write_all(&vec![0x52; length]).await.unwrap();
+        loop {
+            let packet = timeout_tcp_data(&mut parts.packet_stream).await;
+            if tcp_flow(&packet).destination == second_flow.source {
+                assert!(packet.len() > usize::from(mtu));
+                assert_eq!(tcp_payload(&packet), vec![0x52; length]);
+                break;
+            }
+        }
+        parts.control.stop().await;
+        assert_eq!(parts.stats.snapshot().active_tcp, 0);
+    }
+}
+
+fn build_path_mtu_hint(quoted: &Packet, mtu: u16) -> Packet {
+    let flow = tcp_flow(quoted);
+    // Quote only the IP header and the first eight transport bytes. The original
+    // IP total length intentionally exceeds the quotation's allocation.
+    let quoted_len = ip_header_len(quoted.data()) + 8;
+    let mut message = vec![0; 8 + quoted_len];
+    message[8..].copy_from_slice(&quoted.data()[..quoted_len]);
+    match flow.source.ip() {
+        IpAddr::V4(local) => {
+            message[0] = 3;
+            message[1] = 4;
+            message[6..8].copy_from_slice(&mtu.to_be_bytes());
+            let checksum = internet_checksum(&message);
+            message[2..4].copy_from_slice(&checksum.to_be_bytes());
+            build_ipv4("192.0.2.1".parse().unwrap(), local, 1, &message)
+        }
+        IpAddr::V6(local) => {
+            let router = "2001:db8::1".parse().unwrap();
+            message[0] = 2;
+            message[4..8].copy_from_slice(&u32::from(mtu).to_be_bytes());
+            let checksum = transport_checksum_v6(router, local, 58, &message);
+            message[2..4].copy_from_slice(&checksum.to_be_bytes());
+            build_ipv6(router, local, 58, &message)
+        }
+    }
+}
+
+async fn wait_no_tcp(stats: &vole_netstack::NetStackStats) {
+    tokio::time::timeout(WAIT, async {
+        while stats.snapshot().active_tcp != 0 {
+            tokio::task::yield_now().await;
+        }
+    })
+    .await
+    .expect("TCP state was not reclaimed");
+    assert_eq!(stats.snapshot().half_open_tcp, 0);
+}
+
+async fn timeout_tcp_flag(stream: &mut vole_netstack::PacketStream, flag: u8) -> Packet {
+    loop {
+        let packet = timeout_packet(stream).await;
+        let offset = ip_header_len(packet.data());
+        if packet.data()[offset + 13] & flag != 0 {
+            return packet;
+        }
+    }
+}
+
+#[tokio::test]
+async fn active_tcp_uses_configured_sources_and_delivers_established_duplex_streams() {
+    let mut parts = NetStack::start_client(NetStackConfig::default(), client_addresses()).unwrap();
+    for destination in ["198.51.100.20:443", "[2001:db8:2::20]:443"] {
+        let destination: SocketAddr = destination.parse().unwrap();
+        let mut connect = Box::pin(
+            parts
+                .tcp_connector
+                .connect(destination, tokio::time::Instant::now() + WAIT),
+        );
+        assert!(futures_util::poll!(connect.as_mut()).is_pending());
+        let syn = timeout_packet(&mut parts.packet_stream).await;
+        let flow = tcp_flow(&syn);
+        assert_eq!(flow.destination, destination);
+        assert_eq!(
+            flow.source.ip(),
+            if destination.is_ipv4() {
+                IpAddr::V4(client_addresses().ipv4.unwrap())
+            } else {
+                IpAddr::V6(client_addresses().ipv6.unwrap())
+            }
+        );
+        let offset = ip_header_len(syn.data());
+        assert_eq!(
+            syn.data()[offset + 13] & (TcpFlags::SYN | TcpFlags::ACK),
+            TcpFlags::SYN
+        );
+        assert!(
+            futures_util::poll!(connect.as_mut()).is_pending(),
+            "connect returned before the handshake"
+        );
+        let peer = Flow {
+            source: flow.destination,
+            destination: flow.source,
+        };
+        let local_sequence = tcp_sequence(&syn).wrapping_add(1);
+        parts
+            .packet_sink
+            .send(build_tcp(
+                &peer,
+                800,
+                local_sequence,
+                TcpFlags::SYN | TcpFlags::ACK,
+                &[],
+            ))
+            .await
+            .unwrap();
+        let mut stream = tokio::time::timeout(WAIT, connect).await.unwrap().unwrap();
+        assert_eq!(stream.source_addr(), flow.source);
+        assert_eq!(stream.destination_addr(), destination);
+        assert_eq!(parts.stats.snapshot().half_open_tcp, 0);
+        stream.write_all(b"hello").await.unwrap();
+        loop {
+            let packet = timeout_packet(&mut parts.packet_stream).await;
+            let offset = ip_header_len(packet.data());
+            let start = offset + usize::from(packet.data()[offset + 12] >> 4) * 4;
+            if start != packet.len() {
+                assert_eq!(&packet.data()[start..], b"hello");
+                assert_eq!(tcp_flow(&packet).source, flow.source);
+                break;
+            }
+        }
+        parts
+            .packet_sink
+            .send(build_tcp(
+                &peer,
+                801,
+                local_sequence.wrapping_add(5),
+                TcpFlags::ACK,
+                b"world",
+            ))
+            .await
+            .unwrap();
+        let mut payload = [0; 5];
+        tokio::time::timeout(WAIT, stream.read_exact(&mut payload))
+            .await
+            .unwrap()
+            .unwrap();
+        assert_eq!(&payload, b"world");
+        stream.shutdown().await.unwrap();
+        timeout_tcp_flag(&mut parts.packet_stream, 1).await;
+        parts
+            .packet_sink
+            .send(build_tcp(
+                &peer,
+                806,
+                local_sequence.wrapping_add(6),
+                TcpFlags::ACK | 1,
+                b"tail",
+            ))
+            .await
+            .unwrap();
+        let mut tail = Vec::new();
+        tokio::time::timeout(WAIT, stream.read_to_end(&mut tail))
+            .await
+            .unwrap()
+            .unwrap();
+        assert_eq!(tail, b"tail");
+    }
+    parts.control.stop().await;
+    assert_eq!(parts.stats.snapshot().active_tcp, 0);
+}
+
+#[tokio::test]
+async fn active_tcp_shutdown_drains_accepted_tail_before_fin_without_prior_acks() {
+    assert_active_accepted_tail(false).await;
+}
+
+#[tokio::test]
+async fn active_tcp_drop_drains_accepted_tail_before_fin_without_prior_acks() {
+    assert_active_accepted_tail(true).await;
+}
+
+async fn assert_active_accepted_tail(drop_after_write: bool) {
+    let config = NetStackConfig::default();
+    let payload: Vec<u8> = (0..24 * 1024)
+        .map(|index| u8::try_from(index % 251).unwrap())
+        .collect();
+    assert!(payload.len() > config.tcp_send_buffer / 2);
+    assert!(payload.len() < config.tcp_send_buffer);
+    let mut parts = NetStack::start_client(config, client_addresses()).unwrap();
+    let (mut stream, peer, sequence) =
+        active_connect(&mut parts, "198.51.100.20:443".parse().unwrap()).await;
+    tokio::time::timeout(WAIT, stream.write_all(&payload))
+        .await
+        .expect("accepted prefix did not fit the existing total send budget")
+        .unwrap();
+
+    // No DATA ACK was supplied. A real pending shutdown verifies that there
+    // is still an application tail, without observing private queue counters.
+    let mut stream = Some(stream);
+    let mut shutdown = Box::pin(stream.as_mut().unwrap().shutdown());
+    assert!(futures_util::poll!(shutdown.as_mut()).is_pending());
+    if drop_after_write {
+        drop(shutdown);
+        drop(stream.take());
+        receive_active_accepted_tail(&mut parts, &peer, sequence, &payload).await;
+    } else {
+        tokio::join!(
+            async {
+                tokio::time::timeout(WAIT, shutdown)
+                    .await
+                    .expect("ACK recovery did not complete shutdown")
+                    .unwrap();
+            },
+            receive_active_accepted_tail(&mut parts, &peer, sequence, &payload),
+        );
+        let mut byte = [0];
+        let mut read = Box::pin(stream.as_mut().unwrap().read(&mut byte));
+        assert!(
+            futures_util::poll!(read.as_mut()).is_pending(),
+            "local write shutdown closed the receive half before peer FIN"
+        );
+    }
+    assert_eq!(parts.stats.snapshot().active_tcp, 1);
+
+    // FIN has not been acknowledged yet. Close the peer with a real packet
+    // that cumulatively acknowledges the accepted DATA and the local FIN.
+    let fin_end = sequence
+        .wrapping_add(u32::try_from(payload.len()).unwrap())
+        .wrapping_add(1);
+    parts
+        .packet_sink
+        .send(build_tcp(&peer, 701, fin_end, TcpFlags::ACK | 1, &[]))
+        .await
+        .unwrap();
+    tokio::time::timeout(WAIT, async {
+        loop {
+            let packet = timeout_packet(&mut parts.packet_stream).await;
+            let offset = ip_header_len(packet.data());
+            assert_eq!(packet.data()[offset + 13] & 4, 0, "unexpected RST");
+            if tcp_acknowledgement(&packet) == 702 {
+                assert_eq!(tcp_sequence(&packet), fin_end);
+                assert_eq!(tcp_payload(&packet), []);
+                break;
+            }
+        }
+    })
+    .await
+    .expect("peer FIN was not acknowledged");
+    if let Some(stream) = stream.as_mut() {
+        let mut byte = [0];
+        assert_eq!(
+            tokio::time::timeout(WAIT, stream.read(&mut byte))
+                .await
+                .expect("peer FIN did not reach the application")
+                .unwrap(),
+            0
+        );
+    }
+    wait_no_tcp(&parts.stats).await;
+    parts.control.stop().await;
+    assert_eq!(parts.stats.snapshot().half_open_tcp, 0);
+    assert!(parts.packet_stream.recv().await.is_none());
+}
+
+async fn receive_active_accepted_tail(
+    parts: &mut vole_netstack::ClientNetStackParts,
+    peer: &Flow,
+    sequence: u32,
+    expected: &[u8],
+) {
+    tokio::time::timeout(WAIT, async {
+        let mut received = 0;
+        loop {
+            let packet = timeout_packet(&mut parts.packet_stream).await;
+            let flow = tcp_flow(&packet);
+            assert_eq!(flow.source, peer.destination);
+            assert_eq!(flow.destination, peer.source);
+            let offset = ip_header_len(packet.data());
+            let flags = packet.data()[offset + 13];
+            assert_eq!(flags & 4, 0, "accepted tail was reset");
+            let payload = tcp_payload(&packet);
+            let start = usize::try_from(tcp_sequence(&packet).wrapping_sub(sequence)).unwrap();
+            if !payload.is_empty() {
+                assert!(start <= received, "wire prefix contains a sequence hole");
+                let end = start + payload.len();
+                assert!(
+                    end <= expected.len(),
+                    "unexpected bytes beyond accepted tail"
+                );
+                assert_eq!(payload, &expected[start..end]);
+                received = received.max(end);
+            }
+            if flags & 1 != 0 {
+                assert_eq!(received, expected.len());
+                assert_eq!(start + payload.len(), expected.len(), "early FIN sequence");
+                assert_eq!(parts.stats.snapshot().active_tcp, 1);
+                return;
+            }
+            if !payload.is_empty() {
+                parts
+                    .packet_sink
+                    .send(build_tcp(
+                        peer,
+                        701,
+                        sequence.wrapping_add(u32::try_from(received).unwrap()),
+                        TcpFlags::ACK,
+                        &[],
+                    ))
+                    .await
+                    .unwrap();
+            }
+        }
+    })
+    .await
+    .expect("accepted tail/FIN did not drain after real ACK recovery");
+}
+
+#[tokio::test]
+async fn active_tcp_refused_handshake_reclaims_its_socket() {
+    let mut parts = NetStack::start_client(NetStackConfig::default(), client_addresses()).unwrap();
+    let mut connect = Box::pin(parts.tcp_connector.connect(
+        "198.51.100.20:443".parse().unwrap(),
+        tokio::time::Instant::now() + WAIT,
+    ));
+    assert!(futures_util::poll!(connect.as_mut()).is_pending());
+    let syn = timeout_packet(&mut parts.packet_stream).await;
+    let flow = tcp_flow(&syn);
+    let peer = Flow {
+        source: flow.destination,
+        destination: flow.source,
+    };
+    parts
+        .packet_sink
+        .send(build_tcp(
+            &peer,
+            0,
+            tcp_sequence(&syn).wrapping_add(1),
+            TcpFlags::ACK | 4,
+            &[],
+        ))
+        .await
+        .unwrap();
+    assert_eq!(
+        tokio::time::timeout(WAIT, connect)
+            .await
+            .unwrap()
+            .unwrap_err()
+            .kind(),
+        std::io::ErrorKind::ConnectionRefused
+    );
+    wait_no_tcp(&parts.stats).await;
+    parts.control.stop().await;
+}
+
+#[tokio::test]
+async fn active_tcp_cancel_and_deadline_emit_reset_and_reclaim_state() {
+    for (drop_future, establish) in [(true, false), (false, false), (true, true)] {
+        let mut parts = NetStack::start_client(
+            NetStackConfig {
+                max_poll_interval: Duration::from_secs(5),
+                ..NetStackConfig::default()
+            },
+            client_addresses(),
+        )
+        .unwrap();
+        let mut connect = Box::pin(parts.tcp_connector.connect(
+            "198.51.100.20:443".parse().unwrap(),
+            tokio::time::Instant::now() + Duration::from_millis(150),
+        ));
+        assert!(futures_util::poll!(connect.as_mut()).is_pending());
+        let syn = timeout_packet(&mut parts.packet_stream).await;
+        if establish {
+            let flow = tcp_flow(&syn);
+            let peer = Flow {
+                source: flow.destination,
+                destination: flow.source,
+            };
+            parts
+                .packet_sink
+                .send(build_tcp(
+                    &peer,
+                    800,
+                    tcp_sequence(&syn).wrapping_add(1),
+                    TcpFlags::SYN | TcpFlags::ACK,
+                    &[],
+                ))
+                .await
+                .unwrap();
+            timeout_tcp_flag(&mut parts.packet_stream, TcpFlags::ACK).await;
+            tokio::time::timeout(WAIT, async {
+                while parts.stats.snapshot().half_open_tcp != 0 {
+                    tokio::task::yield_now().await;
+                }
+            })
+            .await
+            .unwrap();
+            // The caller has not polled the queued Established result. Drop
+            // must still abort, rather than leaving an unclaimed live socket.
+        }
+        if drop_future {
+            drop(connect);
+        } else {
+            assert_eq!(
+                connect.await.unwrap_err().kind(),
+                std::io::ErrorKind::TimedOut
+            );
+        }
+        let reset = timeout_packet(&mut parts.packet_stream).await;
+        let offset = ip_header_len(reset.data());
+        assert_ne!(reset.data()[offset + 13] & 4, 0);
+        assert_eq!(tcp_flow(&reset).source, tcp_flow(&syn).source);
+        wait_no_tcp(&parts.stats).await;
+        parts.control.stop().await;
+    }
+}
+
+#[tokio::test]
+async fn active_tcp_stop_releases_full_output_pending_connects_and_rejects_unsolicited_syn() {
+    let mut parts = NetStack::start_client(
+        NetStackConfig {
+            packet_queue: 1,
+            max_poll_interval: Duration::from_secs(5),
+            ..NetStackConfig::default()
+        },
+        client_addresses(),
+    )
+    .unwrap();
+    let destination = "198.51.100.20:443".parse().unwrap();
+    let mut first = Box::pin(
+        parts
+            .tcp_connector
+            .connect(destination, tokio::time::Instant::now() + WAIT),
+    );
+    let mut second = Box::pin(
+        parts
+            .tcp_connector
+            .connect(destination, tokio::time::Instant::now() + WAIT),
+    );
+    assert!(futures_util::poll!(first.as_mut()).is_pending());
+    assert!(futures_util::poll!(second.as_mut()).is_pending());
+    let stranger = Flow {
+        source: destination,
+        destination: "10.23.0.2:8000".parse().unwrap(),
+    };
+    parts
+        .packet_sink
+        .send(build_tcp(&stranger, 100, 0, TcpFlags::SYN, &[]))
+        .await
+        .unwrap();
+    tokio::time::timeout(WAIT, async {
+        while parts.stats.snapshot().active_tcp != 2 || parts.stats.snapshot().rejected_tcp != 1 {
+            tokio::task::yield_now().await;
+        }
+    })
+    .await
+    .unwrap();
+    // The sole output slot still contains a SYN; stop must not await draining.
+    tokio::time::timeout(Duration::from_millis(500), parts.control.stop())
+        .await
+        .unwrap();
+    assert_eq!(
+        first.await.unwrap_err().kind(),
+        std::io::ErrorKind::ConnectionAborted
+    );
+    assert_eq!(
+        second.await.unwrap_err().kind(),
+        std::io::ErrorKind::ConnectionAborted
+    );
+    wait_no_tcp(&parts.stats).await;
+    assert!(parts.packet_stream.recv().await.is_none());
+    assert!(matches!(
+        parts
+            .packet_sink
+            .try_send(build_tcp(&stranger, 100, 0, TcpFlags::SYN, &[])),
+        Err(NetStackError::Stopped)
+    ));
+}
+
 #[tokio::test]
 async fn ready_tcp_burst_preserves_flow_binding_and_neighboring_icmp() {
     let mut parts = NetStack::start(NetStackConfig {
@@ -98,26 +1115,10 @@ async fn configured_jumbo_mtu_reaches_tcp_mss_for_both_ip_families() {
             .unwrap();
         let reply = timeout_packet(&mut parts.packet_stream).await;
         assert!(is_syn_ack(&reply, &flow));
-        let offset = ip_header_len(reply.data());
-        let header_len = usize::from(reply.data()[offset + 12] >> 4) * 4;
-        let mut options = &reply.data()[offset + 20..offset + header_len];
-        let mut mss = None;
-        while let Some(kind) = options.first().copied() {
-            match kind {
-                0 => break,
-                1 => options = &options[1..],
-                _ => {
-                    let length = usize::from(options[1]);
-                    assert!(length >= 2 && length <= options.len());
-                    if kind == 2 {
-                        assert_eq!(length, 4);
-                        mss = Some(u16::from_be_bytes([options[2], options[3]]));
-                    }
-                    options = &options[length..];
-                }
-            }
-        }
-        assert_eq!(mss, Some(u16::try_from(9000 - offset - 20).unwrap()));
+        assert_eq!(
+            tcp_mss(&reply),
+            Some(u16::try_from(9000 - ip_header_len(reply.data()) - 20).unwrap())
+        );
     }
     parts.control.stop().await;
 }
@@ -352,7 +1353,11 @@ async fn dropping_the_only_output_consumer_stops_active_tcp_and_other_endpoints(
 
 #[tokio::test]
 async fn asymmetric_tcp_buffers_bound_each_direction_and_stop_unblocks_writes() {
-    for (recv_buffer, send_buffer) in [(4 * 1024, 16 * 1024), (16 * 1024, 4 * 1024)] {
+    for (recv_buffer, send_buffer) in [
+        (4 * 1024, 16 * 1024),
+        (16 * 1024, 4 * 1024),
+        (32 * 1024, 64 * 1024),
+    ] {
         for flow in [Flow::v4(13_500), Flow::v6(13_501)] {
             let mut parts = NetStack::start_tcp(NetStackConfig {
                 tcp_recv_buffer: recv_buffer,
@@ -929,15 +1934,47 @@ async fn timeout_packet(stream: &mut vole_netstack::PacketStream) -> Packet {
 }
 
 fn build_tcp(flow: &Flow, sequence: u32, ack: u32, flags: u8, payload: &[u8]) -> Packet {
-    let mut transport = vec![0_u8; 20 + payload.len()];
+    build_tcp_options(flow, sequence, ack, flags, payload, &[])
+}
+
+fn build_tcp_mss(
+    flow: &Flow,
+    sequence: u32,
+    ack: u32,
+    flags: u8,
+    payload: &[u8],
+    mss: u16,
+) -> Packet {
+    let bytes = mss.to_be_bytes();
+    build_tcp_options(
+        flow,
+        sequence,
+        ack,
+        flags,
+        payload,
+        &[2, 4, bytes[0], bytes[1]],
+    )
+}
+
+fn build_tcp_options(
+    flow: &Flow,
+    sequence: u32,
+    ack: u32,
+    flags: u8,
+    payload: &[u8],
+    options: &[u8],
+) -> Packet {
+    let header_len = 20 + options.len();
+    let mut transport = vec![0_u8; header_len + payload.len()];
     transport[..2].copy_from_slice(&flow.source.port().to_be_bytes());
     transport[2..4].copy_from_slice(&flow.destination.port().to_be_bytes());
     transport[4..8].copy_from_slice(&sequence.to_be_bytes());
     transport[8..12].copy_from_slice(&ack.to_be_bytes());
-    transport[12] = 5 << 4;
+    transport[12] = u8::try_from(header_len / 4).unwrap() << 4;
     transport[13] = flags;
     transport[14..16].copy_from_slice(&u16::MAX.to_be_bytes());
-    transport[20..].copy_from_slice(payload);
+    transport[20..header_len].copy_from_slice(options);
+    transport[header_len..].copy_from_slice(payload);
 
     match (flow.source, flow.destination) {
         (SocketAddr::V4(source), SocketAddr::V4(destination)) => {
diff --git a/docs/README.md b/docs/README.md
index 3de2a63..c04f44f 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -4,12 +4,13 @@
 
 ## 配置与接口
 
-- [配置协议](config.yaml)：严格 YAML、节点、静态 select 组、DNS 与规则。
+- [配置协议](config.yaml)：严格 YAML、节点、providers、动态与自动策略组、DNS 与规则。
+- [Mihomo 兼容原则与范围](mihomo-compatibility.md)：互通要求、性能取舍、已实现能力及协议与平台边界。
 - [Invoke API](invoke-api.md)：严格请求格式、核心软件版本与构建身份、生命周期、平台回调及内联配置。
-- [Controller](controller-api.md)：认证、运行中组选择和 TUN 流量。
+- [Controller](controller-api.md)：认证、组与资源、连接管理、规则/配置/DNS 诊断和 TUN 流量。
 - [混合入站](inbounds.md)：同端口 HTTP 转发/隧道、SOCKS5 TCP/授权 UDP、监听及认证。
-- [出站](outbounds.md)：SOCKS5、AnyTLS、Trojan、VMess AEAD、Hysteria2、SS 2022。
-- [VLESS](vless.md)：传输、Vision、Encryption、REALITY、JLS、静态 ECH。
+- [出站](outbounds.md)：HTTP(S) CONNECT、SOCKS5、AnyTLS、Trojan、VMess AEAD、Hysteria2、TUIC v5、SS 2022、WireGuard、TrustTunnel、Mieru、MASQUE。
+- [VLESS](vless.md)：传输、Vision、Encryption、REALITY、JLS、ECH。
 - [XHTTP 与 sing-mux](xhttp.md)：双腿、H1/H2/H3、连接池及复用。
 - [TLS 证书与指纹](tls-client-fingerprint.md)：证书 pin、ClientHello 模板、身份与缓存。
 - [REALITY 线协议](reality-wire-protocol.md)：认证、密钥与失败边界。
diff --git a/docs/acceptance.md b/docs/acceptance.md
index 2269628..1138150 100644
--- a/docs/acceptance.md
+++ b/docs/acceptance.md
@@ -2,20 +2,69 @@
 
 只报告实际执行的检查。结果记录在对应 CI、PR 或 benchmark 运行中，本文维护验证范围。
 
+兼容验收遵循 [Mihomo 兼容原则](mihomo-compatibility.md#兼容原则)：验证与 Mihomo listener 和官方协议 server 的互通，性能优化综合评估吞吐、CPU、内存和丢包率的收益与代价。字段对照用于记录支持范围与差异，不要求逐字段行为相等。性能达标须依据当次明确的内存预算、目标负载及实测结果判断，不能仅凭连接成功或配置解析通过。
+
 | 层次 | 验证内容 |
 | --- | --- |
 | 离线 / 纯内存 | 配置、协议编解码、取消、生命周期、内存与 FFI 所有权 |
 | 平台编译 | 各目标构建、CLI 基本运行、库文件和发布归档 |
 | 原生消费者 | C/Swift/JNI 等真实宿主的加载、调用与资源释放 |
-| 容器互通 | 官方协议对端、真实双向流量、认证、UDP 与关闭行为 |
+| 容器互通 | Mihomo listener 与官方协议 server、真实双向流量、认证、支持模式的 UDP 与关闭行为 |
 | 压力 | 实际吞吐、CPU、内存峰值、丢包、DNS 完成数及退出清理 |
 | 设备 / 发布 | 真机 TUN、物理出口、权限、生命周期、签名安装及商店要求 |
 
+协议互通先验证握手、认证、双向数据、关闭与资源清理。吞吐、CPU、内存和丢包率独立记录，
+不以压力阈值判定互通失败；全部互通完成后，再单独进行压力验收与性能优化。
+
 编译不替代原生消费者或设备验证；模拟器、Wintun 与 UWP 分别验收。
 Linux RSS 不等于 Apple Network Extension physical footprint。
 性能结果须同时给出输入、目标负载和实际负载，保留失败与丢包情况。
 
+## 性能采纳标准
+
+所有平台与构建使用统一的内存策略和 benchmark 预算，内存统一使用 MiB：
+
+- **1 Gbps：≤43 MiB（45,088,768 bytes）**。
+- **2 Gbps：≤45 MiB（47,185,920 bytes）**。
+
+每档使用单一内存门槛，不再区分硬上限与优化目标。
+
+内存策略不按平台或编译模式切换，CLI 与 FFI 共用同一实现。
+
+真实 iOS/tvOS VPN 扩展仍以整个 Network Extension 进程的 physical footprint 验收，
+包含 Core、宿主桥接与扩展运行时。
+上述数值是项目按负载划分的验收预算，不声明为各设备的系统限额，也不能只计算 Rust heap。
+Linux 压力使用 RSS；Linux 结果只作优化筛选，不替代真机扩展验收。
+其他平台记录承载 Core 的整个后台进程及实际指标口径，排除独立负载客户端和原站。
+不同平台和测量指标的数值不直接混合排名。
+
+定速压力使用既有 Linux 原生 TUN 环境。冷启动、配置和 GeoData 更新、负载、收尾及
+Stop 都应覆盖；未执行的生命周期场景单独标明，不从一次压力结果推导。
+测试执行完成不代表达到验收门槛。
+
+性能对照使用相同输入、负载和重复次数的普通 Release 构建，分别比较吞吐/QPS 中位数
+与同平台进程内存峰值。Linux 保留原压力负载和 RSS 观察逻辑，覆盖 exec 至退出/reap，
+包括启动、负载、drain 和 Stop；heaptrack 等仪器开销、tracked heap 和 wait4 读数
+不能替代这一验收口径。
+
+- 整体验收必须满足对应负载的内存门槛，协议数据正确性、取消与资源清理必须保持；不能用吞吐或丢包改善抵消内存超限。
+- 吞吐、CPU、内存和丢包率都允许渐进式改进，不要求一次修改达到全部目标、各项同步改善或单项绝对不退步，不设单次改善幅度下限。不固定指标优化顺序，按实测瓶颈和综合收益选择下一步。
+- 允许指标之间的合理取舍，结合改善幅度、代价、实际完成量和运行间波动评估；综合收益为正的阶段性改进可以采纳。减少实际负载或业务未完成导致的 CPU、内存下降不能算作优化收益。
+- 当前组合和所有受影响组合均需完成相同输入、负载下的回归，不能只凭目标组合的结果采纳。涉及内存增长时仍须满足对应内存门槛；降低内存但尚未达标的阶段性改进也可采纳，超限 FAIL 保留。采纳改进与整体验收分别判断，未达标项不改签为通过。
+- Linux 压力与横向对比均覆盖纯 TCP、纯 UDP、混合 TCP/UDP 三种业务；每种业务独立记录与验收。不支持 UDP 的协议只验收纯 TCP，其他口径明确标记不适用。
+- Linux 定速压力在 **1 Gbps** 下内存须 **≤43 MiB**。性能不设独立的绝对容量轴，以实际吞吐 **≥950 Mbps**、适用的 UDP 交付丢包率 **≤1%** 作为默认参考，满足即性能通过，不再专项优化。完整性和测量独立验收：纯 TCP 要求已发送业务字节与接收字节、校验和一致，无超时、断流或未完成流；TCP 重传独立记录。期限内交付缺口不能单独归因为永久丢失或 Core 缺陷，须先区分 Core、对端与测试工具。
+- 性能对照客户端固定为 Vole 和 Mihomo。1 Gbps 未达到默认性能参考时，补测同协议组合、服务端、流量类型、输入和负载的 Mihomo；逐指标采用较容易达到的标准，达到后也认为性能通过，不再专项优化。Mihomo 与 Mihomo listener 或官方服务端存在兼容问题时，照常统计并比较吞吐、CPU、内存和丢包率，兼容问题及内容错误独立记录。官方客户端仅作源码技术参考，不作为测试对照客户端。
+- 吞吐按实际写入和读到的字节统计，包含错误内容及错误返回前的部分 I/O；内容校验失败只记录首错和累计错误，继续压力收发。数据正确性与吞吐计数分开，错误数据不计为完整、正确交付。对照须保留匹配输入、真实 TUN、实际负载窗口、进程观测、正常 Stop/join 及清理证据；缺测明确记录，不伪造数值。初期逐指标参考为吞吐下限 **min(950 Mbps, Mihomo 实测吞吐)**、UDP 丢包率上限 **max(1%, Mihomo 实测丢包率)**；CPU 继续记录。Vole 内存仍须 **≤43 MiB**，自身数据正确性、TCP 完整交付、实际窗口、DNS 与正常退出清理要求保持；不能用性能通过豁免这些门禁。旧复合负载标记包含此前吞吐目标时，不将其 false 当作实际窗口无效；使用实际活动窗和收发计数判断。历史 FAIL/ERROR、兼容问题与实际身份保留，不追溯改签。
+- 每个精确协议组合、流量类型和负载窗口优先争取达到或优于匹配 Mihomo，独立生产候选的优化尝试**最多20轮**。达到适用参考即停止该项性能优化；同一候选的重复、原版对照、纯观测及仅编译／内存测试不重复计轮。经多轮仍不能达到目标时，可记录结论提前结束；20轮是上限，不要求为凑数做满。
+- 结束上述优化阶段后，允许与匹配 Mihomo **最高相对10%差距**：吞吐下限为 **min(950 Mbps, 0.9 × Mihomo 实测吞吐)**，UDP丢包率上限为 **max(1%, min(100%, 1.1 × Mihomo 实测丢包率))**。这是相对比例，不是增加10个百分点；Mihomo丢包率为0时仍沿用1%较容易参考。必须保留独立候选及真实TUN结果的轮次证据、结束原因、严格结果与降级阶段；没有适用证据不自动放宽。内存、数据／来源、TCP完整交付、实际窗口、DNS、测量与Stop／清理门槛不放宽，历史FAIL／ERROR不重写。
+- **2 Gbps** 用于内存过载验收，内存须 **≤45 MiB**；吞吐、CPU 和丢包率只记录，不设吞吐及丢包门槛。允许通过掐连接、丢包、断连和限制队列大小等方式保护内存。仍须完成真实 TUN 的完整压力窗口，并验证已接收内容、源地址、观测有效性和退出清理；提前结束或没有实际流量不能代替压力验收。
+- UDP 交付丢包率以实际发送与唯一有效接收的数据报数计算，按上下行发送包数加权汇总，同时保留两个方向的独立计数和含错误、重复数据的原始收包数。丢包在固定收尾后统计；吞吐仅统计活动窗口，不把漏发算作丢包。iOS/tvOS 吞吐负载根据真机与链路能力校准，内存预算保持一致。
+
+当前默认压力档位仅 **1 Gbps**，2 Gbps 后续单独验证。完整性、性能参考、内存、实际完成量、负载窗口、CPU、UDP loss、DNS 完成数、测量有效性及退出/join/资源清理分别记录。2 Gbps 下的超时、丢包、断连和未完成量保留原始状态，不因允许过载保护而改签为完整交付；Vole 自身的错误内容或源地址仍使验收失败。测量成功不等于业务成功，编译、配置解析或连接成功不代替压力验收。显式安排的 3 Gbps 专项沿用 **≤45 MiB** 的内存过载标准；历史结果保留当时语义，不追溯改签。
+
+过载保护应遵循[运行时资源策略](runtime-resource-policy.md)的资源所有权、局部容量、取消和同步 Stop 边界。
+
 核心测试入口见 [tests](../tests/README.md)，平台与发布入口见 [scripts](../scripts/README.md)。
-网络互通和压力由 [container-benchmark](https://github.com/YuanDevTeam/container-benchmark)
-执行，遵守 [测试隔离](testing-isolation.md)。设备要求见 [TUN 平台层](tun-platform.md)
+网络互通和压力由独立容器测试工具执行，结果与结论统一保存在 benchmark 工程，
+遵守 [测试隔离](testing-isolation.md)。设备要求见 [TUN 平台层](tun-platform.md)
 与 [Windows VPN](windows-vpn.md)。
diff --git a/docs/adr/0005-model-select-proxy-groups-as-session-route-targets.md b/docs/adr/0005-model-select-proxy-groups-as-session-route-targets.md
index 52a29e2..7af4674 100644
--- a/docs/adr/0005-model-select-proxy-groups-as-session-route-targets.md
+++ b/docs/adr/0005-model-select-proxy-groups-as-session-route-targets.md
@@ -4,10 +4,18 @@ status: accepted
 
 # ADR 0005：将 select 代理组建模为会话路由与上游目标
 
-`select` 是普通规则、最终 `MATCH`、DNS 与 `dialer-proxy` 共享的命名目标。组拥有一个有序、非空的直接成员列表，成员可以是代理节点、嵌套 `select` 组、`DIRECT` 或 `REJECT`；省略 `default-selected` 时选择第一项，显式值必须精确命中一个直接成员。节点上游和全部组成员边统一为无环图，包括未选成员；独立 `measureDelay` 仍只接受具体节点链。
+`select` 是普通规则、`MATCH`、DNS 与 `dialer-proxy` 共享的命名目标。组拥有一个有序、非空的直接成员列表，成员可以是代理节点、嵌套 `select` 组、`DIRECT` 或 `REJECT`；`default-selected` 精确匹配直接成员，省略、null、空串或未命中时选择第一项。节点上游和全部组成员边统一为无环图，包括未选成员；独立 `measureDelay` 仍只接受具体节点链。
 
-组选择只属于当前 Vole 运行会话，由调用方在下一次配置中重新提供。新建底层 transport 时读取当前选择；同一次建链对每个上游组只读一次，SOCKS5 UDP 的控制连接和 relay 路径共享快照与绝对期限。不同组没有原子快照保证。在途握手、既有 TCP / UDP、DNS cache / singleflight / TCP pool 和旧 AnyTLS 会话不迁移；复用旧会话的新业务流仍保持原路径。被选成员失败时原样返回，不隐式 failover。
+`mode` 支持 rule、global、direct；rule 模式允许空规则和任意位置的 MATCH，未命中直连。global 使用 GLOBAL 组；未显式声明时自动生成，成员顺序为 DIRECT、REJECT、全部节点、全部声明组，默认 DIRECT。该组与普通 select 共用运行时选择和 Controller 接口。
+
+组当前选择属于运行会话；profile.store-selected 开启时由 Core 保存 Controller 的显式选择，下次启动恢复有效缓存成员。新建底层 transport 时读取当前选择；同一次建链对每个上游组只读一次，SOCKS5 UDP 的控制连接和 relay 路径共享快照与绝对期限。不同组没有原子快照保证。在途握手、既有 TCP / UDP、DNS cache / singleflight / TCP pool 和旧 AnyTLS 会话不迁移；复用旧会话的新业务流仍保持原路径。被选成员失败时原样返回，不隐式 failover。
 
 路由组保留 `Dispatcher` seam；组上游在 `OutboundConnector` seam 解析，共享同一个原子选择索引，但不重新执行业务规则，不丢弃 effective peer、UDP 预算或建链期限。协议配置保持不可变，组连接器只持有声明的依赖；依赖优先构造、逆序停止与释放，避免全局节点注册表形成 Arc 环或深图递归析构。
 
-上游组的 DIRECT 连接当前节点服务器，不是业务目标；REJECT 直接使建链失败。节点无上游，或上游组经纯组链能到达 DIRECT 时，prepare 预解析其主端点及独立下载端点，包括未选路径；仅经代理访问的节点保持逻辑域名。潜在首跳解析失败时 prepare 失败，不在切组后临时借系统 DNS。
+上游组的 DIRECT 连接当前节点服务器，不是业务目标；REJECT 直接使建链失败。节点的主端点与独立下载端点在实际建链时通过运行时节点 resolver 解析；准备阶段不预解析潜在首跳。未选成员的 DNS 故障不阻塞启动。仅经代理访问的节点保持逻辑域名。DNS 关闭时使用系统解析，开启时使用配置的节点 nameserver/policy，不因失败切换系统解析；所有路径共享建链期限、递归依赖检查和停止取消。独立 measureDelay 的节点准备仍使用受控引导 resolver。
+
+Provider 成员通过完整资源候选生成。候选重新校验名称及节点/组依赖图后发布，新连接使用当前资源，既有 TCP/UDP 与在途 DNS 保留仍使用的旧资源；不再使用的资源按原停止屏障释放。失败候选不替换可用配置或 HTTP 缓存。动态组移除当前成员时回到有效默认项或首成员，空组按 empty-fallback 处理。下载使用已发布资源，不依赖候选发布完成。
+
+url-test 与 fallback 复用同一组选择和依赖图。共享 HTTP(S) 健康探测分别执行延迟容差和按序恢复，检查遵循 lazy、超时、并发上限和停止取消。探测结果不声明 UDP 能力，也不迁移既有连接。
+
+load-balance 与路由、dialer-proxy 共用健康状态与策略实例。一致性哈希、轮询和粘滞选择在新连接建链时执行；UDP 对含负载均衡组的目标分别保留 transport，过期或明确的新 QUIC 流才重新选择。动态资源代际仍固定在旧会话上。上游组以当前节点服务器为目标，单次建链的所有协议步骤共用同一选择。
diff --git a/docs/adr/0006-control-live-proxy-group-selection-through-controller.md b/docs/adr/0006-control-live-proxy-group-selection-through-controller.md
index 92b384f..607d6be 100644
--- a/docs/adr/0006-control-live-proxy-group-selection-through-controller.md
+++ b/docs/adr/0006-control-live-proxy-group-selection-through-controller.md
@@ -6,6 +6,8 @@ status: accepted
 
 Vole 首版只通过 Controller 暴露代理组的实时选择，不新增 Invoke 方法，也不扩展 Windows 控制管道。Controller 采用 mihomo `select` 的核心调用形状：`GET /group`、`GET /group/{name}`、`GET /proxies/{name}` 和 `PUT /proxies/{name}`；PUT body 为 `{"name":"member"}`，成功返回空的 `204`。组状态只承诺 `name`、`type`、`all`、`now`，不宣称兼容完整 mihomo Dashboard API。
 
-Windows WinRT VPN 的实际运行时位于独立 Session Host，桌面 Wintun、Apple 与 Android 的运行时位于 Invoke owner 背后；Controller 是现有平台中唯一能统一到达实际运行会话的 Adapter。组路由可以在无 TUN 的本地代理运行时中使用，`/traffic` 仍只在存在 TUN 统计时提供。
+Windows WinRT VPN 的实际运行时位于独立 Session Host，桌面 Wintun、Apple 与 Android 的运行时位于 Invoke owner 背后；Controller 是现有平台中唯一能统一到达实际运行会话的 Adapter。Controller 也可用于合法 mixed-only 静态节点或纯 DIRECT 配置，无需额外开启 TUN 或显式代理组；组路由可以在无 TUN 的本地代理运行时中使用，`/traffic` 仍只在存在 TUN 统计时提供。
 
-配置同时包含代理组和 Controller 时，必须为整个 Controller 配置 Bearer secret。请求使用精确名称和严格、有界的 JSON，任何失败都不得改变选择。没有 Controller 的代理组配置仍然有效，但本次会话中没有公开的实时切换入口；调用方在成功切换后自行持久化下一次启动所需的 `default-selected`，持久化失败不回滚已经成功的运行时选择。
+Controller 的监听地址和可选 `secret` 遵循 Mihomo 的配置语义：支持 IP、`localhost` 或空 host 与数值端口，端口 0 由系统选择；省略或空串 `secret` 表示不要求认证，非空值统一启用 Bearer 鉴权，代理组不增加认证要求。请求使用精确名称和严格、有界的 JSON，任何失败都不得改变选择。没有 Controller 的代理组配置仍然有效，但本次会话中没有公开的实时切换入口；Core 按 `profile.store-selected`（默认 true）保存 Controller 的显式选择；下次启动优先恢复仍存在的缓存成员，否则使用配置默认或首成员。持久化失败不回滚已经成功的运行时选择。
+
+Controller 同时展示动态 provider、自动组和节点健康状态；组选择与探测任务均位于实际运行会话。Controller 的节点/组 delay 与 Provider healthcheck 在当前资源代际中共用自动健康探测器、DNS、Dialer 和停止屏障；每节点手动历史有界，实际内存仅在请求时采集。独立 measureDelay 保持 node-only Invoke 接口，复用内部 HTTP/TLS 探测能力。
diff --git a/docs/adr/0009-share-invoke-between-cli-and-native-hosts.md b/docs/adr/0009-share-invoke-between-cli-and-native-hosts.md
index 93704e9..46b1ea4 100644
--- a/docs/adr/0009-share-invoke-between-cli-and-native-hosts.md
+++ b/docs/adr/0009-share-invoke-between-cli-and-native-hosts.md
@@ -6,6 +6,8 @@ status: accepted
 
 CLI 和原生传输都调用同一 Invoke 请求处理器，让配置准入、实例表、平台资源获取与停止屏障具有一份实现。公开业务启动合并为 `start(configYaml)`，配置准备保留在命令内部；TUN 的设备和借用描述符来自 YAML，包格式由平台内部选择。
 
-前台进程需要文件与标准输入、环境和路径默认值、退出信号及完整清理，因此这些行为归属显式的 `foreground` 操作；CLI 只处理五个参数、请求转换、输出和退出码。普通业务生命周期不接管宿主信号或角色，使 VPN、服务和嵌入式宿主继续管理自己的进程生命周期。原生路径作为字符串或平台编码元数据无损传递，不通过有损文本转换。
+前台进程需要文件与标准输入、环境和路径默认值、退出信号及完整清理，因此这些行为归属显式的 `foreground` 操作；CLI 只处理参数、请求转换、输出和退出码。普通业务生命周期不接管宿主信号或角色，使 VPN、服务和嵌入式宿主继续管理自己的进程生命周期。原生路径作为字符串或平台编码元数据无损传递，不通过有损文本转换。
 
 前台与业务调用共用单实例约束。前台等待信号或引擎完成时释放命令锁，结束时 join 启动/引擎工作并停止、销毁实例；观察到完成不代替真实清理屏障。当前请求及文件行为见 [Invoke API](../invoke-api.md)与 [CLI](../cli.md)。
+
+独立 HTTP 处理配置使用可选 `httpConfigYaml`；CLI 对应 `-http-config` 仅传显式路径给 foreground，读取与验证仍归 Invoke。此参数只服务于独立 HTTP 附加配置，不扩展 Mihomo YAML，也不改变单实例与停止所有权。
diff --git a/docs/adr/0010-freeze-http-resources-and-private-material-per-session.md b/docs/adr/0010-freeze-http-resources-and-private-material-per-session.md
new file mode 100644
index 0000000..8bcb8a4
--- /dev/null
+++ b/docs/adr/0010-freeze-http-resources-and-private-material-per-session.md
@@ -0,0 +1,11 @@
+---
+status: accepted
+---
+
+# ADR 0010：会话固定 HTTP 资源和私密材料
+
+独立 HTTP 配置的资源更新只产生完整的待应用候选；运行会话固定主设置、实际 payload、编译规则和 CA 身份。显式重连先准备候选，再经过停止屏障切换；失败恢复保留的旧实际内容，不重新读取已变化的来源。普通 Stop 释放私密材料。节点选择和分流资源更新不应用待修改的 HTTP 配置。
+
+CA 由 Invoke 的独立私密上下文提供，CLI 只传明确的私密文件路径；共享 YAML、普通缓存和可序列化启动快照不承载私钥。Windows 跨进程交付使用绑定启动身份的当前用户 DPAPI sidecar。静态校验和离线演算不获取 CA、不读取外部资源，也不初始化 VPN。
+
+URL、头和正文阶段始终按原始 URL 选规则。匹配正文在有界事务内累积，完整成功后才提交输出；格式或工作区不足时回放原文。共享工作区在分配前预留，许可随实际缓冲持有至发送结束；传输错误、取消和 Stop 仍作为真实失败处理。
diff --git a/docs/cli.md b/docs/cli.md
index 682c0f4..9ca2eeb 100644
--- a/docs/cli.md
+++ b/docs/cli.md
@@ -3,17 +3,33 @@
 `vole` 是前台入口。CLI 解析参数并调用 Invoke；配置读取、初始化、信号与清理由
 Invoke 的 `foreground` 操作处理，运行时复用同一个内核。
 
+GNU/Linux 的 TUN 会话在 Core 工作线程启动前，将 glibc 的 arena 默认设为 1，
+mmap 阈值设为 32 KiB，降低包处理时的堆保留。显式 `MALLOC_ARENA_MAX`、
+`MALLOC_MMAP_THRESHOLD_` 或 `GLIBC_TUNABLES` 环境设置优先。
+前台入口和普通业务 `start` 共用该策略，会影响同一进程内的宿主分配器；无 TUN 会话保留宿主策略。
+帮助和配置校验保持纯查询行为。
+
 ```sh
 vole -f /path/to/config.yaml
 vole -d /path/to/data -f ./config.yaml
 vole -t -f ./config.yaml
 cat config.yaml | vole -f -
+vole -t -config "$(base64 < config.yaml)"
 ```
 
 | 参数 | 作用 |
 | --- | --- |
 | `-d <dir>` | 配置及数据目录，默认用户目录下的 `.config/vole` |
 | `-f <file>` | 配置路径；默认 `<data-dir>/config.yaml`，`-f -` 从标准输入读取 |
+| `-config <base64>` | 标准 Base64 编码的主配置，非空时优先于 `-f` |
+| `-age-secret-key <key>` | 解密 AGE armor 主配置的身份，可含多行身份 |
+| `-ext-ctl <address>` | 非空时覆盖 HTTP Controller 地址 |
+| `-ext-ctl-tls <address>` | 非空时覆盖 TLS Controller 地址 |
+| `-ext-ctl-unix <path>` | 非空时覆盖 Linux 本地 Controller 路径 |
+| `-ext-ctl-routing-mark <mark>` | 非零时覆盖 Linux 管理 TCP socket mark |
+| `-secret <token>` | 非空时覆盖 Controller 认证密钥 |
+| `-http-config <file>` | 显式的独立 HTTP 附加配置，交给 Invoke 读取与验证 |
+| `-http-ca <file>` | 独立私密 CA JSON 路径，交给 Invoke 读取；`-t` 不读取它 |
 | `-t` | 校验配置后退出，不初始化数据、联网或启动 TUN |
 | `-v` | 输出内核版本及构建身份 |
 | `-h` | 输出帮助 |
@@ -24,14 +40,50 @@ cat config.yaml | vole -f -
 
 `-d` 与 `-f` 独立。与 Mihomo 一致，相对路径从启动工作目录解析并折叠 `.`/`..`；
 绝对路径原样交给文件系统，保留符号链接后的 `..` 语义。路径支持空格及平台原生字符。
-`VOLE_HOME_DIR`、`VOLE_CONFIG_FILE` 提供环境默认值，显式参数优先。
+`VOLE_HOME_DIR`、`VOLE_CONFIG_FILE`、`VOLE_CONFIG_STRING` 和 `VOLE_AGE_SECRET_KEY`
+提供环境默认值，分别对应 `-d/-f/-config/-age-secret-key`；显式参数优先，显式空值清除相应环境默认。
+非空 Base64 主配置优先，其次是配置路径 `-` 明确选择的标准输入，最后为配置文件；不会探测标准输入。
+`VOLE_CONFIG_FILE=-` 同样明确选择标准输入。Base64 使用带 padding 的标准字母表，允许 CR/LF，
+不接受 URL-safe 字母表；编码文本最多 11,184,812 字节，解码后最多 8 MiB。
+解码后的输入和文件／标准输入均可为标准 AGE armor，复用 provider 的 X25519／hybrid 身份与认证解密；
+身份文本最多 16 KiB，解密后的 YAML 最多 8 MiB。编码、密文、明文按阶段释放，不在运行会话中保留编码副本；
+临时身份与请求缓冲清零，错误不包含正文或密钥。帮助和版本不读取这些环境值或配置来源。
 Unix 用户目录取 `HOME`，Windows 取 `USERPROFILE`，缺失时使用工作目录。
 默认 `.config/vole` 不存在或不可访问时，若设置 `XDG_CONFIG_HOME`，使用其中的 `vole` 目录。
-配置文件必须是普通文件，文件和标准输入上限均为 256 KiB，CLI 不写回配置。
+配置文件必须是普通文件，文件和标准输入上限均为 8 MiB，CLI 不写回配置。
+正常运行时，`VOLE_OVERRIDE_EXTERNAL_CONTROLLER`、`VOLE_OVERRIDE_EXTERNAL_CONTROLLER_TLS`、
+`VOLE_OVERRIDE_EXTERNAL_CONTROLLER_UNIX`、`VOLE_OVERRIDE_SECRET` 提供 Controller 覆盖的环境默认。显式参数优先，显式空值清除该环境默认，
+且不覆盖 YAML 原值；只更改具体的 Controller 配置，不提供通用字段覆盖。
+地址沿用 YAML 的 IP／localhost／空 host 与数字端口规则，不查询域名；密钥不会输出到日志或错误。
+`-ext-ctl-routing-mark` 在 CLI 按 Go flag 的平台 int/base-0 语法解析，支持符号、进制前缀和合法下划线；
+非法显式数字参数返回 2，`-t` 也执行参数语法检查。Invoke 接收数值元数据；32 位 socket mark 范围由运行期统一校验。
+`VOLE_OVERRIDE_EXTERNAL_CONTROLLER_ROUTING_MARK` 是十进制环境默认，沿用 Mihomo 的 Atoi 返回值；缺失或语法错误使用 0，溢出返回平台饱和值后仍受 socket 范围校验；
+显式 0 屏蔽环境默认但保留 YAML mark。此项只用于管理 TCP，不改变业务 routing-mark 或 Unix socket。
+`-t` 与 Mihomo 一致，只校验输入配置，不读取环境／应用运行期覆盖；`-h/-v` 不读取其环境值。
+
+独立 HTTP 配置上限 1 MiB，使用 `-http-config <file>` 或 `--http-config=<file>`。省略不探测文件；空路径与 `-` 失败，空文件关闭处理。相对 provider 文件从 HTTP 文件目录解析，缓存从数据目录解析。`-t` 只校验主文档／inline 内容，不读取外部 provider、下载或私密 CA；`-v/-h` 不读取附加文件。详细输入见 [HTTP 处理](http-processing.md)。
+
+开启选择性 HTTPS 时，额外传 `-http-ca /private/ca.json`，格式为 `{"certificate":"...PEM...","privateKey":"...PEM..."}`。Unix 文件必须属于当前用户、关闭 group／other 权限（如 0600），且不能是符号链接。私钥不进入共享规则、命令行正文、普通快照或日志；宿主管理证书生成与客户端信任。
+客户端 certificate/private-key 可引用 PEM 文件，相对路径从 -d 的数据目录解析；-t 同样读取并校验身份，仍不初始化目录。
+
+`VOLE_SAFE_PATHS` 可为主配置的 file provider 读取和 HTTP provider 缓存增加授权目录。
+使用系统路径列表分隔符（Unix 为 `:`、Windows 为 `;`），保留原生路径编码；相对目录从启动工作目录解析，
+空项不授权当前目录。授权目录必须已经存在，初始化后固定，并由 provider 候选与恢复快照继承。
+文件读取不创建目录；只有 HTTP provider 缓存可在授权根内新建目录及写入正文／sidecar。
+路径中的 `..`、祖先或目标符号链接逃逸被拒绝。默认仍限 dataDir；file provider 在额外目录内不会回写 bundle 回退。
+本次主配置／独立 HTTP 文件保留为不可被缓存覆盖的输入，显式私密 CA 路径不授予 provider 读写。
+该环境只进入 provider 资源上下文，不改变主配置、客户端身份／私密 CA、独立 HTTP 设置或 Controller socket 的文件合同；
+不修改全进程环境，也不提供任意目录写入授权。`-t/-h/-v` 不读取此环境值。
 
 正常运行执行 `initialize → createInstance → start(configYaml)`，等待退出后
 `stop → destroyInstance`。Unix 支持 SIGINT/SIGTERM，Windows 支持 Ctrl+C/Ctrl+Break；
-退出等待内核清理完成。诊断写入有界 stderr，不包含配置正文或凭据。
+退出等待内核清理完成。日志写入 stderr，遵循配置的 `log-level`，完整保留已生成事件的 target、message 和所有字段；不按敏感字段脱敏、不截断内容，也不另设每秒条数限制。
+Unix 的 SIGHUP 通过同一候选工作器重载主配置：文件源重读该文件，Base64／标准输入源复用首次
+解密后的有效 YAML，不重读标准输入、环境默认、独立 HTTP 文件或私密 CA。文件 AGE 保留已解析身份，
+不保留原始密钥文本。Controller 覆盖继续应用于候选；规则、节点与普通 provider 候选沿原热更新流程。
+坏候选、繁忙或超时保留当前会话；启动资源变化报告 reconnect required，SIGHUP 不自动停止或重连，
+需宿主协调或重启前台进程。活动 HTTP payload／CA 继续固定，HTTP provider 待应用内容不会由 SIGHUP 应用。
+退出或引擎停止会取消并等待已开始的重载工作；宿主原 TUN fd 不被替换或关闭。
 具体请求格式见 [Invoke API](invoke-api.md)。
 
 ## TUN 与发布
@@ -39,7 +91,8 @@ Unix 用户目录取 `HOME`，Windows 取 `USERPROFILE`，缺失时使用工作
 TUN 完全由 YAML 配置。Unix 的 `tun.file-descriptor > 0` 借用宿主 fd，内核只关闭自己的副本；
 省略或为 0 时 Linux/macOS 可根据 `tun.device` 创建或打开原生 TUN。
 Windows CLI 固定使用 Wintun，DLL 由宿主提供；Windows FFI 编译时可选择 Wintun 或 UWP。
-接口地址、DNS、系统路由及物理出口隔离由宿主管理，CLI 直接把配置交给内核。
+Linux 自建 TUN 的自动路由与 DNS 接管由 Core 执行，CLI 直接把配置交给内核。
+其他平台和借用 fd 的接口地址、DNS、系统路由及物理出口隔离仍由宿主管理。
 平台接入见 [TUN](tun-platform.md) 和 [Windows VPN](windows-vpn.md)。
 
 构建命令、tag 发布矩阵和归档内容统一见 [编译与发布](../scripts/README.md)。
diff --git a/docs/config.yaml b/docs/config.yaml
index 51247e2..0feb89c 100644
--- a/docs/config.yaml
+++ b/docs/config.yaml
@@ -1,11 +1,14 @@
 # Vole 配置的完整示例。
 #
-# 配置只接受本文列出的结构；未知或已移除的字段、anchor、alias 和自定义 tag 都会失败。
+# 配置只接受本文列出的结构；未知或已移除的字段和自定义 tag 都会失败。支持 anchor、alias 和 YAML merge。
+# 原始配置上限 8 MiB，展开预算 32 MiB，嵌套最多 64 层；递归 alias 失败。
 # 顶层 port、socks-port、udp 和 listeners 都不接受；代理节点的 port / udp 仍有效。
 #
 # 库宿主先通过 Invoke API 调用 initialize({dataDir})，再通过 configYaml 内联
 # 传入配置；CLI 使用 -f 指定文件，-d 指定数据目录，省略时读取数据目录下的 config.yaml。
-# GeoData 固定由 Vole 管理在 dataDir/geodata 中；CLI 的 -t 只校验，不创建目录或联网。
+# GeoSite/DAT/ASN 由 Vole 管理在 dataDir/geodata 中；国家 MMDB 位于 dataDir 根目录。
+# CLI 的 -t 只校验，不创建目录或联网。
+# certificate/private-key 可为成对 PEM 或文件路径；相对路径从 dataDir 解析，校验时读取并验证。
 # 所有平台均不设 GeoData 条数上限，不按数量截断，也不设总内存预算；
 # 仅加载当前业务规则和 DNS policy 引用的分类/属性交集，详见 docs/geodata.md。
 
@@ -14,45 +17,133 @@
 # IPv6 包。dns.ipv6 只有与本项同时为 true 时才生效。
 ipv6: true
 
-# GeoData 下载配置可省略；出现时三项必须齐全。URL 必须是以域名为主机、无
-# userinfo/fragment 的绝对 HTTPS URL，更新周期固定为 24 小时。validateConfig 和
-# measureDelay 不下载。公共实例启动后，只有实际规则需要资产且自动更新已启用时
-# 才后台检查。下载使用最终 MATCH route target 在创建新物理 transport 时解析到的
-# 当前节点、DIRECT 或 REJECT；代理组不自动故障转移，也不回退 DIRECT。
+# mode 缺省 rule：顺序规则首条命中，未命中 DIRECT；global 使用 GLOBAL 组，direct 直连。
+# log-level 缺省 info，还支持 debug、warning、error、silent；两字段值不区分大小写。
+mode: rule
+log-level: info
+
+# unified-delay 默认 false；true 时复用探测连接再次发送 HEAD，成功时记录第二次耗时。
+# profile.store-selected 默认 true，将 Controller 的显式选择保存到 dataDir/selected.json。
+# 启动时缓存中的有效选择优先于 default-selected；成员已删除时使用配置默认/首成员。
+# 文件损坏时使用配置；写入失败保留已生效选择，并在 Controller 状态中报告。
+unified-delay: false
+find-process-mode: strict # strict 按实际身份谓词惰性查询；always 每业务决策一次；off 不查询
+# 物理 TCP 与 mixed 接入连接的探活。单位秒；0 使用 15 秒，负数保留对应 OS 值。
+# Android 始终禁用 TCP keep-alive；Windows 保留系统探测次数，其余平台为 9 次。
+# tcp-concurrent=true 同时尝试解析结果，首次成功取消其余尝试；ip-version 的偏好
+# 给首选地址族最多 300ms 优先窗口。已建立的复用连接保留创建时的设置。
+# IP4P 仅用于受控物理端点：2001:0000::/32 的 octets[10..12] 为网络序端口，
+# octets[12..16] 为IPv4；普通地址保持。逻辑server/SNI与认证身份不改变。
+experimental:
+  dialer-ip4p-convert: false
+  # Quinn 的 Linux DIRECT 物理首跳：TUIC/XHTTP H3/DoQ/DoH H3。
+  # GSO 开启时依 OS 能力每次最多8段；ECN 缺省关闭，不改变进程环境。
+  quic-go-disable-gso: false
+  quic-go-disable-ecn: true
+# 开启时转换物理TCP和SS2022/SOCKS5/WireGuard UDP节点端点；不转换DIRECT无连接UDP或DNS答复。
+
+tcp-concurrent: false
+keep-alive-idle: 0
+keep-alive-interval: 0
+disable-keep-alive: false
+# 物理 TCP/UDP 的默认出口；空接口/零 mark 使用平台默认或 TUN 自动识别。
+# 节点的非空 interface-name / 非零 routing-mark 分别覆盖全局值，空/0 继续继承。
+# 接口支持 Linux、Apple 和 Windows，名称在建 socket 时校验；失败不回退其他出口。
+# 回环物理目标保留本机路径，不应用公开接口/mark；UWP 回环目标的现有安全门禁不变。
+# Android 显式接口绑定尚不可用，保留原 protect；非零 mark 仅 Linux 可用。
+# Linux 自建 TUN auto-route 仅捕获未标记流量；物理首跳保留有效的非零公开 mark，
+# 未配置 mark 时注入私有防环值。全局/节点与动态 Provider 使用同一继承与 socket 策略。
+# UWP 仅允许选择 Provider 当前物理适配器，不改变其源地址/接口索引；Wintun 不继承该绑定。
+interface-name: ""
+routing-mark: 0
+profile:
+  store-selected: true
+  store-fake-ip: false # true：dataDir/fake-ip.redb 持久化双向映射与分配位置
+
+# 资源下载使用 global-ua（缺省 Vole/ 加 Core 版本）；etag-support 缺省 true。
+# geodata-mode 默认 false，使用国家 MMDB；true 使用 GeoIP DAT。此示例显式选择 DAT。
+# URL 缺省 MetaCubeX meta-rules-dat latest DAT / 国家 MMDB / ASN MMDB。
+# URL 以域名为主机、无 fragment，生产构建使用 HTTPS；userinfo 用于 HTTP Basic。
+# HTTP 资源自动流式解压 gzip，状态只保存来源摘要与脱敏 origin。
+# 自动更新默认 false；启动后仍获取缺失的必需资产。周期单位小时，默认 24，0 关闭周期检查。
+global-ua: "Vole/0.1.0"
+etag-support: true
+geodata-mode: true
 geox-url:
   geoip: https://assets.example.com/geoip.dat
+  mmdb: https://assets.example.com/geoip.metadb
   geosite: https://assets.example.com/geosite.dat
+  asn: https://assets.example.com/ASN.mmdb
 geo-auto-update: true
 geo-update-interval: 24
 
+# 客户端共享信任根：内置 WebPKI + 启动时可读系统根 + 此处证书内容。
+# 字段沿用 Mihomo 的真实拼写 custom-certifactes；内容为 PEM（或可表示的 DER），不是路径。
+# 不设置本项仍使用基础信任；pure validate 不读取系统根。平台读取限制见 tls-client-fingerprint.md。
+# tls:
+#   custom-certifactes:
+#     - |-
+#       -----BEGIN CERTIFICATE-----
+#       <CA certificate content>
+#       -----END CERTIFICATE-----
+# 同一 tls 对象的 certificate/private-key 仅用于 HTTPS Controller，可用配对 PEM 或 dataDir 文件；
+# 均空时生成随机 RSA 2048 自签证书。内联固定，文件证书对热更新失败保留旧值。
+# client-auth-type: request/require-any/verify-if-given/require-and-verify，其它字符串为默认不请求证书；
+# 非空 client-auth-cert 在默认模式时提升为 require-and-verify，CA 内容/文件仅启动加载。
+# 上述服务端字段不改变 custom-certifactes 的客户端根库，也不用于独立 measureDelay 配置。
+
 # 可选的 HTTP/SOCKS5 混合入口；mixed-port 省略或 0 时关闭，1–65535 时启用。
 # TCP 在同端口接入 HTTP 转发 / CONNECT / Upgrade 和 SOCKS5 CONNECT / UDP ASSOCIATE。
 # SOCKS5 UDP 随入口启用并绑定同端口，不提供独立入站 UDP 开关或 listeners 配置。
 # 构建必须同时包含 inbound-http 和 inbound-socks5；缺少任一 feature 则拒绝启用入口。
 # allow-lan 默认 false，绑定回环；true 时绑定通配地址，与 authentication 独立。
 # ipv6: true 时同时绑定同端口 IPv6（v6-only）；false 时只监听 IPv4。
-# authentication 省略或 [] 表示任何绑定地址均免认证；非空时必须恰好包含一项 user:password，
-# 按首个冒号分隔，用户名 / 密码各 1–255 UTF-8 字节，HTTP/SOCKS5 共用。
-# 共享或非空认证要求 mixed-port 启用。
+# authentication 省略、null 或 [] 表示任何绑定地址均免认证；非空支持多个 user:password，
+# 按首个冒号分隔，不 trim，允许空用户名或密码。HTTP 受 32 KiB 总头预算约束；SOCKS5 各字段最多 255 字节。
+# mixed-port 关闭时可以保留合法的 allow-lan 和 authentication，供之后启用入口使用。
 # HTTP 逐请求认证、选路，支持流式正文 / 分块、Keep-Alive、CONNECT 与 Upgrade。
 # 共享只适合可信网络，Basic 不加密链路；详细边界见 docs/inbounds.md#http。
 # UDP 必须属于有效的 TCP 控制连接，源 IP/端口校验和资源上限见 inbounds.md#socks5。
 mixed-port: 1080
 allow-lan: false
+bind-address: "*" # allow-lan=true 时可指定单个 IP；localhost 始终绑定回环
+lan-allowed-ips: [0.0.0.0/0, "::/0"]
+lan-disallowed-ips: [] # 拒绝优先
+skip-auth-prefixes: [] # 仅跳过认证，仍执行来源访问控制
 authentication:
   - "probe-user:probe-password"
 
-# 可选的运行时 Controller，地址必须是回环 IP 和显式非零端口。它可服务于启用
-# TUN 的配置或含 proxy-groups 的配置；运行配置仍需开启 mixed-port 或 TUN。
-# 只要 Controller 管理 proxy-groups，secret 就必填；仅有 TUN 流量接口时可省略。
-# secret 出现时必须为 1–255 UTF-8 字节，并作为全部 Controller 路由的 Bearer token。
+# 可选的运行时 Controller，接受 IP:port、localhost:port 或 :port；端口 0 由系统分配。
+# 静态节点、纯 DIRECT 及未启用代理入口的配置也可使用。
+# secret 省略或空串时免认证；非空时保护 Controller 业务路由，CORS 预检先于认证。
+# external-controller-tls 可单独启用，或与 HTTP 同时启用；HTTPS 实际提供 H2/H1，明文仅 H1。
+# CORS origins 缺省/[]/含 * 时允许所有来源；精确/单 * 匹配忽略大小写，无匹配不返回允许头。
+# 允许 GET/POST/PUT/PATCH/DELETE 与 OPTIONS；Content-Type/Authorization/Origin，max-age 300，
+# 不允许 credentials；allow-private-network 缺省 true，只在成功预检且请求 true 时返回允许头。
 # Controller 提供 GET /traffic、GET /group、GET /group/{name}、
-# GET /proxies/{name} 和 PUT /proxies/{name}，不属于 Invoke API。
+# GET /proxies/{name} 和 PUT /proxies/{name}；另含连接查询/关闭、有效配置、规则
+# 与有界原始 DNS 记录查询、节点/组 delay、Provider healthcheck、实际进程内存；
+# 完整接口见 controller-api.md；不属于 Invoke API。
 external-controller: 127.0.0.1:9090
+# external-controller-tls: 127.0.0.1:9443
+# Linux 本地 HTTP/1 / WebSocket 管理入口；空串关闭，相对路径从 dataDir 解析。
+# 父目录须已存在；0600 在 listen 前设置，已有文件/目录/链接/socket 均不接管。
+# 本地入口依赖文件权限，不要求 secret；并行网络 HTTP/HTTPS 仍使用原 Bearer。
+external-controller-unix: ""
+# 仅 Linux 管理 HTTP/HTTPS TCP listener 及已接受 socket 使用 SO_MARK；0 不设置。
+# 与业务 routing-mark 独立，不用于 Unix socket；非零值在其它系统启动网络入口时不支持。
+external-controller-routing-mark: 0
+external-controller-cors:
+  allow-origins: ["*"]
+  allow-private-network: true
 secret: "vole-runtime-secret"
 
-# TUN 使用 Mihomo 同名字段；未实现的 auto-route、auto-redirect、
-# auto-detect-interface、地址/路由、stack、offload 等字段仍严格拒绝。
+# TUN 使用 Mihomo 同名字段；auto-route/auto-detect-interface 仅供 Linux 自建 TUN。
+# Linux 缺省均为 true，其他平台缺省 false；借用 fd 的网络配置始终由宿主负责。
+# Linux 自建 auto-route 消费 inet6-address、route-address/route-exclude-address、
+# iproute2-table-index/iproute2-rule-index、strict-route、输入接口和 UID/端口排除。
+# 借用 fd、Apple/Android/Windows 仍由宿主应用这些网络设置；改动需要宿主重配/重连。
+# auto-redirect、stack、offload 等字段仍严格拒绝。
 # file-descriptor 缺省或 0 时由 core 打开本机平台 TUN；正数为当前进程已有 fd。
 # Unix 借用 fd 必须已 nonblocking，核心仅复制并关闭副本；帧格式由平台固定处理。
 # Linux / macOS 支持原生打开；Android / iOS / tvOS 仍要求宿主提供 fd。
@@ -67,8 +158,34 @@ secret: "vole-runtime-secret"
 # dns-hijack 缺省 [0.0.0.0:53]；[] 关闭。只在 dns.enable:true 的 TUN TCP/UDP 上生效。
 # 精确 IP:port 匹配指定目标；any/未指定地址匹配任何地址族的 53 端口。
 # udp-timeout 单位秒，缺省或 0 为 300；控制源关联及各目的流的空闲失效。
-# 配置必须启用 mixed-port 或 TUN。
+# Linux 专属 ICMP：真实 Echo 走共享 Dialer 的 DIRECT；真实 TUN 前缀、启用的 fake-IP 池或
+# disable-icmp-forwarding:true 使用本地合成，不代表真实 RTT。其他平台拒绝这两个字段。
+# icmp-timeout 为非负 int64 秒，缺省/0 为 10；超出本机单调时钟范围明确拒绝。
+# 运行组须由安装器/宿主在出口 namespace 预先授权 ping_group_range；Core 不改 sysctl、不提权、无 IP raw fallback。
+# 最多两个物理 ping socket、64 个许可、入/出各 8 项，真实包限 min(mtu,2048)；Stop 清理全部所有者。
+# 这些值变化须显式重连；详细合同见 tun-icmp-dns.md 与 tun-platform.md。
+# mixed-port 与 TUN 均关闭时仍可运行 Controller 和资源任务。
 tun:
+  # icmp-timeout: 10 # 仅 Linux；0 同缺省，其他平台不要填写
+  # disable-icmp-forwarding: false # 仅 Linux；true 保留本地合成回应
+  # auto-route: true # Linux：自动路由；DNS 启用且劫持网关时接管 systemd-resolved
+  # auto-detect-interface: true # Linux：出站自动绑定物理接口
+  # inet6-address: ["fdfe:dcba:9876::1/126"] # 顶层 ipv6 关闭时不添加；[] 关闭 IPv6 捕获
+  # route-address: [] # 各地址族省略时捕获其默认网段
+  # route-exclude-address: ["192.168.0.0/16", "fc00::/7"]
+  # iproute2-table-index: 2022 # 0 使用缺省值；不得占用系统表
+  # iproute2-rule-index: 9000 # 0 使用缺省值；本会话使用该值到 +8
+  # strict-route: false # 自动路由时，阻止所选输入绕过未捕获的 IPv6 地址族
+  # include-interface: [lo, veth-client] # Linux ingress接口；本机output为lo；非空时忽略exclude-interface
+  # exclude-interface: [veth-bypass] # 仅include为空时使用；两者均空保持仅本机捕获
+  # include-uid: [1001] # Linux 本机应用捕获范围；不解析 Android 包名
+  # include-uid-range: ["1001:1010"]
+  # exclude-uid: [1005] # exclude 优先于 include
+  # exclude-uid-range: ["2000:2010"]
+  # exclude-src-port: [5353]
+  # exclude-src-port-range: ["30000:30010"]
+  # exclude-dst-port: [22]
+  # exclude-dst-port-range: ["6000:6010"]
   enable: true
   device: ""
   file-descriptor: 0
@@ -77,49 +194,58 @@ tun:
     - any:53
   udp-timeout: 300
 
-# 可选的 TUN TCP/UDP 嗅探器。省略或 enable: false 表示关闭。启用时至少配置
-# HTTP、TLS、QUIC 之一；协议值为空或省略 ports 时分别使用 80/443/443。每种协议
-# 最多 64 个单端口或升序闭区间；HTTP 与 TLS 的 TCP 端口不能重叠，QUIC 使用
-# UDP，可与二者使用相同端口。嗅探结果只参与选路，不改写实际目标。
+# TCP 嗅探用于 TUN 和 mixed；QUIC 多包嗅探用于 TUN UDP。
+# 省略或 enable: false 关闭；未列出协议时不嗅探。协议 ports 省略/为空表示全部端口。
+# HTTP/TLS 重叠端口共享有界预读，按 TLS、HTTP 顺序识别；每协议最多 64 个端口/区间。
 sniffer:
   enable: true
+  force-dns-mapping: true
+  parse-pure-ip: true
+  force-domain: [] # Clash 通配、geosite:、rule-set:；可强制嗅探已知域名/fake-IP
+  skip-domain: [] # 对识别出的域名生效
+  skip-src-address: [] # CIDR、geoip:、rule-set:
+  skip-dst-address: []
+  override-destination: true # false 只提供选路域名；true 同时替换实际目标
   sniff:
     HTTP:
       ports: [80, 8080-8380]
+      override-destination: false # 协议项覆盖全局值
     TLS:
       ports: [443, 8443]
     QUIC:
       ports: [443, 8443]
 
-# 至少配置一个具体代理节点。节点和代理组定义名共享同一大小写敏感的命名空间，
-# 引用精确匹配且不做 Unicode normalization 或大小写折叠。名称必须为 1–64 UTF-8
-# 字节，首尾不能是任何 Unicode 空白字符，不能含控制字符，也不能包含逗号、井号、
-# 斜杠、问号、`&`、`=`、`%`、反斜杠，或使用 `.`、`..`、`DIRECT`、`REJECT`、
-# `RULES`；内部普通空格、CJK 和 emoji 可用。dialer-proxy 可引用具体节点或 select
-# 组。所有节点上游和全部组成员（包括未选成员）组成同一张无环图；未知引用、自引用
-# 和混合环均失败。代理数量和链深没有独立上限，仍受 YAML 256 KiB 和名称唯一约束。
-# 节点没有上游，或上游组经纯组成员链能到达 DIRECT 时，prepare 预解析该节点及其
-# 独立下载端点，即使 DIRECT 尚未选中；纯代理路径保留逻辑域名。候选首跳 DNS 失败
-# 则 prepare 失败，切换 DIRECT 不临时调用系统 DNS。物理首跳连接本机服务时，server 必须使用 127.0.0.0/8
-# 范围内的 IPv4 字面量或 ::1；域名解析到回环地址会失败关闭。
+# proxies 可省略或设为 []，允许仅使用 DIRECT、REJECT 或只包含内置动作的代理组。
+# VLESS/VMess uuid 支持标准、紧凑、花括号和 URN；其他字符串按 UUIDv5(nil, 原始UTF-8)映射。
+# 引用的节点和代理组必须存在。节点和代理组定义名共享同一大小写敏感的命名空间，
+# 引用精确匹配且不做 Unicode normalization 或大小写折叠。名称必须为非空字符串；
+# DIRECT、REJECT、REJECT-DROP、COMPATIBLE、PASS、PASS-RULE 为保留定义名。
+# 路径与 URL 中的保留字符由调用方按相应协议编码，不限制节点本身的名称。
+# dialer-proxy 可指定 DIRECT、COMPATIBLE 或引用具体节点、策略组。全部上游和组成员（包括未选成员）须无环。
+# 代理数量和链深没有独立上限，仍受 YAML 大小与名称唯一约束。
+# 实际建立物理首跳时才通过节点 resolver 解析主端点和独立下载端点。
+# 未选节点的 DNS 失败不阻塞准备；DNS 关闭时才使用系统 resolver。
+# DNS 开启时可通过 hosts 配置本机端点；关闭 DNS 或独立测速的系统 resolver
+# 仍拒绝解析到回环的服务器域名，本机服务器可使用 IP 字面量。
 #
 # VLESS 子集：
 # - type 固定 vless，network 默认 tcp，支持 tcp/ws/grpc/http/h2/xhttp，tls 默认 false；
 #   TCP 支持明文或 TLS 1.2/1.3；XHTTP H1/H2 支持明文、TLS1.3 或 REALITY。
 # - encryption 省略/空/none，或 mlkem768x25519plus.{native,xorpub,random}.{1rtt,0rtt}.<key>…；
 #   key/padding 链、上限和恢复规则见 vless.md；该层独立于外层 TLS/传输。
-#   flow 省略/空/xtls-rprx-vision；Vision 仅 TCP + TLS1.3/REALITY 或 Encryption，
-#   packet-encoding 必须 xudp（即使 udp=false）；
+#   flow 省略/null/空串/xtls-rprx-vision；Vision 仅 TCP + TLS1.3/REALITY 或 Encryption，
+#   packet-encoding 省略、xudp 或 none 均使用 XUDP；packetaddr 不可与 Vision 组合（即使 udp=false）；
 # - servername 可省略（WS Host 去端口后优先于 server）；TCP alpn 默认空，
 #   WS 默认 [http/1.1]，gRPC/H2 默认 [h2]；XHTTP [http/1.1] 选择 H1，
 #   空或 H1/H2 列表选择 H2，仅 [h3] 选择 H3。H3 必须标准 TLS1.3 与受控 UDP，
 #   不回退 H2。明文 XHTTP 的 alpn 仅选择版本，其余 TLS 专属字段仍拒绝。
 #   详细语义见 docs/vless.md 和 docs/xhttp.md。
-# - packet-encoding 默认 xudp；none 是显式 raw，packetaddr/packet 为 IP-only
-#   地址帧。raw 固定首包目标；packetaddr 域名通过受控 DNS 解析。
+# - packet-encoding 省略、xudp 或 none 均使用 XUDP；packetaddr/packet 为 IP-only
+#   地址帧；packetaddr 域名通过受控 DNS 解析。
+# - REALITY 不用于 WS/HTTPUpgrade；该组合在配置期拒绝。
 # - TLS 省略 reality-opts；REALITY 必须提供 reality-opts.public-key，可选 short-id；
-#   support-x25519mlkem768 默认 false；true 强制真实混合协商、不回退经典组。
-#   true 只允许 client-fingerprint chrome 或未命名（省略/none/空串）；不改写模板。
+#   support-x25519mlkem768 默认 false；true 允许同次握手协商真实混合或经典组。
+#   chrome 和未命名模板提供混合/X25519 双 share；其余 TLS1.3 模板保留真实经典 share。
 # - xhttp-opts 请求字段与值域详见 docs/xhttp.md；mode 只接受
 #   auto/packet-up/stream-up/stream-one；stream-one 不能与 download-settings 同用；
 # - download-settings 一旦出现（包括 {}），就为下行 GET 创建独立的
@@ -127,7 +253,7 @@ sniffer:
 #   XHTTP session ID，不进行第二次 VLESS 握手。两条请求最终必须由 CDN 或
 #   反向代理汇聚到同一个服务端 XHTTP 处理器和会话存储。
 # - download-settings 缺省叶字段继承；headers/reuse-settings/reality-opts/jls-opts/ech-opts 整对象
-#   替换，{} 分别清空请求头、重置复用默认、清除 REALITY/JLS/ECH。false/空串不等同缺省；
+#   替换，{} 分别清空请求头、重置复用默认、清除 REALITY/JLS/ShadowTLS/ECH。false/空串不等同缺省；
 #   certificate/private-key 成对替换或同时空串清除。改变安全类型须显式清除冲突
 #   策略。两个独立 listener 不能组成共享会话。
 #   auto 为 TLS -> packet-up、REALITY +
@@ -136,26 +262,158 @@ sniffer:
 #   同时关闭下载腿，不提供 TCP 半关闭后继续读取尾包的保证；packet-up 的待完成
 #   上传最多等待 1 秒。需要完整响应的应用须在关闭前读完响应。
 # - 标准 TLS 支持 skip-cert-verify/fingerprint/name-cert-verify，以及配对的
-#   内联 PEM certificate/private-key；不能混用 REALITY。完整策略见 vless.md。
+#   内联 PEM 或文件路径 certificate/private-key；不能混用 REALITY。完整策略见 vless.md。
 # - WS/gRPC/HTTP/H2 复用共享传输。WS 可 v2ray-http-upgrade 及其 fast-open；
-#   gRPC 可 UA、空闲 PING、max-connections/min-streams/max-streams 池阈值。
-# - smux 支持 h2mux/smux/yamux、padding/only-tcp 与池阈值；与 Vision 互斥。
-# - client-fingerprint 接受 none/chrome/chrome120/firefox/firefox120/safari/safari16；
-#   chrome=Chrome133，firefox=Firefox120，safari=Safari16.0；节点缺省关闭。
+#   gRPC 与 Trojan/VMess 共用 UA、空闲 PING、max-connections/min-streams/max-streams 池阈值。
+# - 公共节点 smux 支持 h2mux/smux/yamux、padding/only-tcp 与池阈值；与 Vision 互斥。
+# - random 在进程首次按 Chrome/Safari/iOS/Firefox = 6:3:2:1 选定后稳定复用。
+# - client-fingerprint 接受 none/chrome/firefox/safari/ios/android/edge/"360"/qq/random；
+#   chrome=Chrome133，firefox=Firefox120，safari=Safari16.0；android/360只有TLS1.2能力；节点缺省关闭。
 #   适用于标准 TCP TLS/REALITY，不改变证书 fingerprint；下载腿缺省继承、
 #   显式名称覆盖、none/空串清除，转 H3/明文必须清除指纹。
-#   非空 ALPS 服务端设置暂拒绝；边界见 docs/tls-client-fingerprint.md。
+#   不声明TLS ALPS，H2沿标准SETTINGS/ACK；意外协商的非空设置仍拒绝，见docs/tls-client-fingerprint.md。
 # - jls-opts.username/password 必须成对非空，各 1–65535 UTF-8 字节，要求 tls: true；
 #   与同腿 REALITY/证书策略/mTLS、Vision/H3 互斥。下载对象缺省继承、整体替换、
 #   {} 清除，主腿空对象拒绝。保持完整 TLS1.3 认证，无恢复；详见 vless.md#jls。
-# - 静态 ech-opts 只用于标准 TLS，详见下方示意与 docs/vless.md#静态-ech。
-#   不接受动态 query-server-name、shadow-tls-opts 或已移除的 restls-opts。
+# - ech-opts 的静态/动态来源只用于标准 TLS，详见下方示意与 docs/vless.md#ech。
+#   query-server-name 只覆盖动态 HTTPS 记录查询名，不改变拨号、SNI 或证书验证名。
+#   shadow-tls-opts 必须 {version: 3, password: 非空密码}，与 REALITY/JLS/ECH、Vision 互斥；
+#   使用既有 servername/SNI 与证书策略，只用于 TCP 承载和 XHTTP H1/H2。
 #
 # 下方 vless-edge 通过 upstream-select 当前选择的 socks-hop 建链：
 # 客户端 -> socks-hop -> vless-edge -> 目标。
+# 普通协议节点和具名 direct 可声明 tfo: false（默认）。Linux 单个可用物理 TCP 地址启用
+# TCP Fast Open；多地址沿普通 eager TCP 选择，其他系统沿普通受控 TCP。原生 UDP 不受影响。
+# 仅真实物理首跳消费；经代理使用上游节点自己的 tfo，组落到 DIRECT 时使用当前节点 tfo。
+# 普通协议节点和具名 direct 可声明 mptcp: false（默认，非 null 布尔值）。仅 Linux
+# 无 socket protector、显式/自动接口、专用 DNS binding 或源 IP 约束的物理 TCP 路径尝试 MPTCP。
+# 系统路径管理器与额外路径由宿主管理，Core 不配置接口/子流；routing-mark 仍沿现有防环策略。
+# 受约束路径、其他系统或本机/对端不支持时使用普通受控 TCP，不绕过保护或绑定失败。
+# 代理链只消费实际首跳自己的值，组落到 DIRECT 时使用当前节点值；原生 UDP/QUIC 不受影响。
+# 普通协议节点和具名 direct 支持 ip-version: dual/ipv4/ipv6/ipv4-prefer/ipv6-prefer；默认 dual。
+# 普通协议节点和具名 direct 可声明 interface-name / routing-mark，仅物理首跳消费；经 dialer-proxy 时
+# 使用真正上游节点的出口策略，组落到 DIRECT 时保留当前节点策略。XHTTP 两腿使用相同策略。
+# 普通协议节点支持 smux 包装，要求对端提供 sing-mux 解码；普通 HTTP/SOCKS listener 不自动解码。
+# only-tcp: false 提供 mux UDP，即使底层 udp 为 false；true 保留底层 UDP 能力与编码。
+# smux.brutal-opts 启用后，每条新会话先与支持 TCP Brutal 的对端协商；远端下行协商不限定客户端平台。
+# Linux 本地上行只在可确认独占的直连物理 TCP 上尝试；代理 hop、共享/多腿传输与 mptcp:true 不设置本地算法。
+# Core 不安装/加载模块；本地不可用保留有效远端协商。池保持单会话，退役等待旧流释放；详见 xhttp.md。
+# HTTP(S) CONNECT 示例：type: http，必填 name/server/port，tls 默认 false。
+# username/password 均非空才认证；headers 为字符串映射；仅 TCP，不支持 udp: true。
+# tls: true 时支持 sni/skip-cert-verify/name-cert-verify/fingerprint，
+# 以及成对的 certificate/private-key（PEM 或文件路径）。支持 dialer-proxy；详见 outbounds.md。
+# TrustTunnel 支持 H2/H3 CONNECT TCP/UDP，type: trusttunnel；username/password 默认空串，
+# 始终发送 Basic 认证，不要求非空。quic 默认 false（TLS+H2），true 使用 QUIC/TLS1.3+H3。
+# sni 缺省/空串使用 server；alpn 缺省/[] 随模式使用 [h2]/[h3]，自定义列表须包含该值，
+# H3 实际协商必须为 h3；H2 接受 h2，或在认证后无 ALPN 时使用 H2 prior knowledge；明确协商其他协议拒绝。
+# 两模式共享证书策略、mTLS、ech-opts；client-fingerprint 仅 H2 消费，
+# H3 将该字符串视为 no-op，不校验模板名。H3 外层始终需要双向至少1200字节UDP路径。
+# 逻辑客户端池 max-connections/min-streams/max-streams 全为 0 时采用 8/5/0；
+# 优先复用流数最少的客户端，max-connections > 0 时，达到客户端数上限或
+# 当前流数 < min-streams 即复用；max-connections <= 0 时，按
+# max-streams > 0 且当前流数 < max-streams 复用；未满足条件则增加客户端。
+# 零活跃流始终复用，混合填写不报互斥，阈值不限制业务总连接数。物理连接空闲30秒关闭。
+# udp: true 启用 _udp2 多目标数据报；health-check: true 启用 _check 协议探测，
+# 成功CONNECT响应重置7秒计时，单次探测期限7秒；二者缺省false。UDP业务在两模式均走可靠流。
+# congestion-controller 仅H3消费：cubic/new_reno 使用 quiche 原生 CUBIC/Reno；
+# bbr/bbr_meta_v1/bbr_meta_v2 均映射到 quiche 原生 Bbr2Gcongestion，省略/未知使用 cubic。
+# H2 不消费 congestion-controller。
 proxies:
-  # TUIC v5：固定 QUIC/TLS1.3；必填 UUID 和原样 password（可空，最多 65535 UTF-8 字节）。
-  # 不接受 v4、token、0-RTT、client-fingerprint、mTLS、ECH 或其他 TLS 后端选项。
+  # 功能出站没有 server/port；不接受 udp、smux 或 dialer-proxy。
+  # direct 另接受 interface-name/routing-mark/ip-version/tfo/mptcp，域名使用 direct-nameserver。
+  - {name: direct-local, type: direct}
+  # dns 仅接受 name/type，复用当前会话解析器，可由普通规则接管任意端口的 TCP/UDP DNS。
+  - {name: dns-local, type: dns}
+  # reject 仅接受 name/type；立即结束，不增加 action 字段。
+  - {name: reject-local, type: reject}
+  # rematch 是规则控制，不建立连接。两个 target 至少出现一个，省略保留原值；
+  # target-rematch-name: '' 清标记；target-sub-rule: '' 或未知名称回主规则。
+  # 已存在的空子列表耗尽后 DIRECT；省略 target-sub-rule 保留当前根列表。
+  # 仅业务 rule 模式和 DNS #RULES 消费，不能用于 node-only 测速或物理上游。
+  - {name: mark-blue, type: rematch, target-rematch-name: blue}
+  - name: trusttunnel-edge
+    type: trusttunnel
+    server: trusttunnel.example.com
+    port: 443
+    quic: false # true 改为H3，其余业务配置不变
+    username: synthetic-user
+    password: synthetic-password
+    udp: true
+    health-check: true
+
+  # Mieru：transport 必填 TCP 或 UDP；二者均承载 TCP 和 udp: true 的 UDP Associate。
+  # username/password 各为 1–64 UTF-8 字节，保留原值。port 与非空 port-range 互斥，
+  # 范围如 "24810-24812"，每次新物理连接随机选择包含两端的端口。
+  # multiplexing 为 MULTIPLEXING_DEFAULT/OFF/LOW/MIDDLE/HIGH，默认 LOW；
+  # handshake-mode 为 HANDSHAKE_DEFAULT/STANDARD/NO_WAIT，默认 STANDARD。
+  # 枚举须携带上述完整前缀。UDP 底层提供 ACK/重传/排序/窗口，不是裸 UDP 转发。
+  # traffic-pattern：可选的标准 Base64 Mieru protobuf；省略/空值使用协议默认策略。
+  - name: mieru-edge
+    type: mieru
+    server: mieru.example.com
+    port: 24810
+    transport: TCP
+    username: synthetic-user
+    password: synthetic-password
+    udp: true
+    multiplexing: MULTIPLEXING_LOW
+    handshake-mode: HANDSHAKE_STANDARD
+
+  # MASQUE L4：标准Base64 SEC1 ECDSA私钥与SPKI服务端公钥；独立客户端证书。
+  # 仅TCP，udp: true仍关闭基础UDP；SNI缺省为consumer-masque-proxy.cloudflareclient.com。
+  # ip/ipv6/uri/mtu及正handshake-timeout在L4不消费；负超时拒绝。
+  # name-cert-verify占位不消费；skip-cert-verify关闭公钥固定但仍验证握手签名。
+  # - name: masque-l4
+  #   type: masque
+  #   server: masque.example.com
+  #   port: 443
+  #   network: h3-l4proxy
+  #   # IP tunnel: network: quic 或 h2, ip: 192.0.2.2, ipv6: 2001:db8::2, udp: true
+  #   # IP mode MTU defaults to 1280; IPv4-only permits 68..65535.
+  #   # uri: https://cloudflareaccess.com # IP tunnel CONNECT authority
+  #   # handshake-timeout: 5 # 整数秒；0 沿创建调用期限；正值由节点持有
+  #   remote-dns-resolve: false # true 且 dns 非空时经本节点解析业务域名
+  #   dns: [] # IP 模式支持 UDP/TCP 等；L4 需要 tcp:// 或其它 TCP DNS 传输
+  #   private-key: "<Base64 SEC1 DER>"
+  #   public-key: "<Base64 ECDSA SPKI DER>"
+  #   congestion-controller: bbr # 同 TrustTunnel H3 的算法映射
+  #   ip-stack: {mode: auto, congestion-controller: cubic}
+
+  # 标准 WireGuard：用户态内层 TCP/UDP，不创建系统接口/路由/NAT。
+  # 密钥为公开测试值，不可用于真实连接。外层始终需要双向 UDP；业务 udp 默认 false。
+  # ip/ipv6 接受 IP 或 CIDR，按实际地址族选择，每族最多一个；至少配置一个。
+  # MTU 缺省/0 为 1408，范围 1280–65503；实际上游双向预算须至少 MTU+32。
+  # 与 Mihomo 一致，单 peer 顶层 allowed-ips 接受但忽略。完整行为见 outbounds.md#wireguard。
+  - name: wireguard-edge
+    type: wireguard
+    server: wireguard.example.com
+    port: 51820
+    ip: 10.84.0.2/24
+    # ipv6: fd84::2/64
+    private-key: "AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE="
+    public-key: "AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI="
+    # pre-shared-key: "AwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwM="
+    mtu: 1408
+    persistent-keepalive: 0 # uint16 秒；0 不定期保活
+    allowed-ips: [] # 无 peers 时忽略；各本地地址族使用全地址路由
+    reserved: [] # 空、三字节数组或标准 Base64 字符串（如 "U4An"）；peer 缺省继承顶层值
+    remote-dns-resolve: false # true 且 dns 非空时，业务域名通过本节点查询
+    # 支持 Core DNS 上游；fragment 出口 token 忽略，键值参数保留且只解码一次。
+    # 不继承全局 prefer-h3，HTTPS h3=true 仍生效；上游域名仍由 Core 代理 DNS bootstrap。
+    dns: []
+    refresh-server-ip-interval: 0 # 秒；0 不更新，新业务触发到期检查
+    # peers 非空时忽略顶层 server/port/public-key；每项 allowed-ips 必须非空。
+    # peers:
+    #   - server: wireguard.example.com
+    #     port: 51820
+    #     public-key: "AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI="
+    #     allowed-ips: ["0.0.0.0/0"]
+    #     reserved: [0, 0, 0]
+    udp: true
+    # dialer-proxy: upstream-select # 上游必须提供足够的双向 UDP 预算
+
+  # TUIC v5：固定 QUIC/TLS1.3；UUID 必填，password 缺省为空，原样使用（最多 65535 UTF-8 字节）。
+  # 支持成对 PEM/文件 certificate/private-key 客户端身份；不接受 v4、token、0-RTT、client-fingerprint、ECH。
   - name: tuic-edge
     type: tuic
     server: tuic.example.com
@@ -167,12 +425,28 @@ proxies:
     skip-cert-verify: false
     # fingerprint: "<SHA-256 certificate pin, 64 hex digits>"
     # name-cert-verify: verified.example.com
+    # certificate/private-key: 成对内联 PEM 或文件路径；不改变服务端信任根
+    # 文件对由既有资源工作器检查并用于新物理连接；失败保旧，边界见 docs/tls-client-fingerprint.md
     congestion-controller: cubic # cubic（默认）/new_reno/bbr
-    udp: true # 缺省 false；只控制业务 UDP，QUIC 首跳始终需要数据报
+    disable-sni: false # true只关闭SNI，证书名称/pin验证保持
+    udp: true # 可省略或设 false，均保留业务 UDP；组 disable-udp 仍生效
     udp-relay-mode: native # native（默认）/quic
+    # ip: 192.0.2.1 # 仅覆盖物理入口，server/SNI 保留
+    # heartbeat-interval: 10000 # 毫秒；<=0 回落 10000，同时控制 keepalive/HEARTBEAT
+    # recv-window-conn: 0 # 实际为 stream 窗口：缺省/0 初始1.5MiB/上限15MiB；正数固定
+    # recv-window: 0 # 实际为 connection 窗口：缺省/0 初始2MiB/上限64MiB；正数固定
+    # 固定 Middle 策略下，缺省实际 stream4MiB/connection2MiB，不预分配全部信用。
+    # max-open-streams: 100 # 0 同默认；参考阈值100=>90，实际同时所有者默认89，正N!=100为N-1
+    # max-udp-relay-packet-size: 1252 # 仅在缺省 frame 上限时用于计算 frame=该值+29
+    # max-datagram-frame-size: 1281 # 完整 QUIC DATAGRAM frame，参考限制到1400；与累计256KiB缓冲独立
+    # disable-mtu-discovery: false # 发现受实际上游双向预算限制
+    # udp-over-stream: false # QUIC可靠流承载业务UDP；QUIC物理入口仍须数据报
+    # udp-over-stream-version: 2 # 省略同2；仅接受整数2
+
     # dialer-proxy: upstream-select # 所选上游必须实际支持双向至少 1200 字节数据报
 
-  # Hysteria2：固定 QUIC/TLS1.3，外层总是需要 UDP；业务 UDP 默认关闭。
+  # Hysteria2：固定 QUIC/TLS1.3，外层总是需要 UDP；业务 UDP 始终可用。
+  # udp 可省略或填 true/false，均不禁用业务 UDP；组 disable-udp 仍生效。
   # 完整字段/预算及开发验收边界见 outbounds.md#hysteria2。标准 TLS 证书策略与其他协议共用。
   - name: hysteria2-edge
     type: hysteria2
@@ -182,16 +456,38 @@ proxies:
     sni: hysteria2.example.com
     alpn: [h3] # 缺省或 [] 都归一为 h3
     skip-cert-verify: false
+    # name-cert-verify: verified.example.com # 独立证书验证名，不改变 SNI
     # fingerprint: "<SHA-256 certificate pin, 64 hex digits>"
-    # certificate/private-key: 成对内联 PEM 客户端身份
+    # certificate/private-key: 成对内联 PEM 或文件路径 客户端身份
     udp: true
     up: 0 # 裸数单位 Mbps；0 自动，也可 "125 KBps"，b=bit/B=byte
     down: 0
-    udp-mtu: 1197 # 单个协议分片预算；0 同默认，范围 64–65535
-    # obfs: salamander
+    udp-mtu: 1400 # 单个协议分片预算；0 同默认，范围 64–65535
+    # initial-stream-receive-window: 65536 # byte，0/省略为64KiB
+    # max-stream-receive-window: 65536 # 固定信用=max(initial,min(maximum,4MiB))，不预分配缓冲
+    # initial-connection-receive-window: 4194304 # 固定连接信用；0/省略为4MiB，可显式增大
+    # max-connection-receive-window: 4194304 # 接受独立上限；Middle策略仍使用连接initial，不自适应增长
+    # handshake-timeout: 0 # 秒；正值由节点独立持有共享握手，各调用保留自己的期限
+
+    # obfs: gecko # 或 salamander
+    # obfs-min-packet-size: 512 # 仅 Gecko，正值且 min≤max≤2048
+    # obfs-max-packet-size: 1200 # 填充目标，仍受真实物理UDP预算限制
     # obfs-password: "independent-synthetic-password"
-    # ports: "443,8443-8445" # 非空集合控制初始及后续入口；出现时 port 可省略
-    # hop-interval: "5-7" # 仅与 ports 配套，默认 30 秒，最小 5 秒
+    # realm-opts: # enable true 时不能启用 ports/hop-interval
+    #   enable: true
+    #   server-url: https://realm.example.com # HTTP(S) base，无userinfo/query/fragment
+    #   token: synthetic-token
+    #   realm-id: synthetic-zone
+    #   stun-servers: [stun.example.com:3478]
+    #   sni: realm.example.com # 以下仅HTTPS控制面，独立于业务QUIC身份
+    #   alpn: [h2, http/1.1]
+    #   skip-cert-verify: false
+    #   name-cert-verify: realm.example.com
+    #   fingerprint: ""
+    #   certificate: ./client.crt # 与private-key成对，或内联PEM
+    #   private-key: ./client.key
+    # ports: "443/8443-8445" # 逗号或斜线；有效集合控制初始/后续入口，port可省略或0
+    # hop-interval: "5-7" # 随 ports；0使用30秒，正数小于5归一为5，范围归一
     # dialer-proxy: upstream-select
 
   # VMess AEAD：alterId 仅 0；cipher 默认 auto（实际 AES 硬件检测），还支持
@@ -200,7 +496,12 @@ proxies:
   # network 默认 tcp，支持 tcp/ws/grpc/http/h2。tls 默认 false；关闭时
   # 禁止 servername/alpn/fingerprint/skip-cert-verify 等 TLS 专属字段。
   # servername 优先显式值，其次 WS Host 去端口，否则 server。
+  # TLS 支持 name-cert-verify 和成对的内联 PEM 或文件路径 certificate/private-key；
+  # 验证名不改变 servername，客户端身份不增加服务端信任根。
   # ws-opts/grpc-opts 与下面 Trojan 的结构相同；HTTP/H2 选项见示例注释。
+  # tls: true 时可选 shadow-tls-opts: {version: 3, password: cover-password} 或
+  # jls-opts: {username: user, password: password}；身份单选。REALITY 仅 TCP/HTTP/H2/gRPC，
+  # 必须有效 client-fingerprint，不用于 WS/HTTPUpgrade。
   # UDP 默认 false；packet-encoding 默认为空（raw），或 xudp/packetaddr。
   # raw transport 固定首包目标；packetaddr 域名由受控 Vole DNS 解析为 IP。
   # TCP/WS 保留下载侧；gRPC/HTTP/H2 上传 EOF 关闭逻辑流，详见 outbounds.md#vmess-aead。
@@ -225,11 +526,12 @@ proxies:
     #   headers: {Host: [cover.example:443], X-Custom: [one, two]}
     # 每次握手各选一个路径与每个头的一个值；禁止 Content-Length/Transfer-Encoding。
     # network: h2
-    # h2-opts:
-    #   host: [cover.example:443] # 必填、非空；每流选一个，不改变 TLS 认证名
+    # h2-opts: # 省略/host: [] 使用 www.example.com；path 省略/空为 /
+    #   host: [cover.example:443] # 每流选一个；缺省/空列表用 www.example.com，不改变 TLS 认证名
     #   path: /cover              # 默认 /；普通 PUT body，不使用 gRPC framing
 
   # Trojan（outbound-trojan feature）：固定 TLS，不接受 tls 开关。
+  # 可选通用 ShadowTLS v3/JLS；TCP/gRPC 另支持 REALITY，须有效 client-fingerprint。
   # password 必须非空，按原始 UTF-8 字节认证，不 trim。
   # network 接受 tcp（默认）、ws、grpc。sni 默认 server，不回退 WS Host；
   # alpn 默认 tcp=[]、ws=[http/1.1]、grpc=[h2]。显式列表保留顺序，WS/gRPC
@@ -237,6 +539,7 @@ proxies:
   # Stop / 取消仍关闭全部会话及自有 driver，不更改 XHTTP 的全关闭约定。
   # skip-cert-verify 默认 false；fingerprint 沿用 AnyTLS 的证书 SHA-256
   # pin 语义，pin 与 skip 同时存在仍必须匹配 pin。udp 默认 false。
+  # name-cert-verify 只改变证书验证名；certificate/private-key 为成对内联 PEM 或文件路径 客户端身份。
   # UDP 在 TLS 流内传输；单包负载最多 8192 字节并与入口预算取较小值，
   # 不拆包或截断。域名地址保持域名交由服务端处理；Mihomo v1.19.31 的
   # Trojan listener 不接收域名 UDP 帧，使用该对端时需要 IP 业务目标。
@@ -252,7 +555,7 @@ proxies:
     # ws-opts:
     #   path: /edge?query=1       # 默认 /，必须绝对路径
     #   headers: {Host: cover.example:443, X-Custom: value}
-    #   max-early-data: 2048    # 0–2048，默认 0
+    #   max-early-data: 4096    # 默认0；发送按实际HTTP头预算钳位，不预分配此上限
     #   early-data-header-name: Sec-WebSocket-Protocol
     #   v2ray-http-upgrade: true # 默认 false；原始流，不发送 WebSocket 帧
     #   v2ray-http-upgrade-fast-open: false # 仅 upgrade=true 可开启
@@ -262,8 +565,14 @@ proxies:
     # 不接受保留握手头、重复大小写头、CR/LF、userinfo 或超限 HTTP 头。
     # network: grpc
     # grpc-opts:
-    #   grpc-service-name: edge # 必填；普通名映射 /edge/Tun；/ 开头使用完整路径
-    # ws-opts / grpc-opts 仅可用于对应 network；不提供 gRPC 连接池。
+    #   grpc-service-name: edge # 省略/空默认 GunService；普通名映射 /edge/Tun；/ 开头使用完整路径
+    #   grpc-user-agent: grpc-go/1.36.0 # 省略/空使用此默认值
+    #   ping-interval: 0       # 秒数；0 不主动 PING；负值明确拒绝
+    #   max-connections: 4     # 正值时优先按连接上限/min-streams 扩容；显式1/2保留各自策略
+    #   min-streams: 0
+    #   max-streams: 0         # max-connections 非正时按此复用阈值扩容
+    # 三阈值省略或字面全零时为4/0/0（Mihomo为1/0/0）；负阈值禁用分支。
+    # ws-opts / grpc-opts 仅可用于对应 network；grpc-opts 可省略。
 
   - name: vless-edge
     type: vless
@@ -281,11 +590,11 @@ proxies:
       path: /onev
       mode: auto
       headers: {X-Transport: edge}
-      # 以下范围均为字符串 N 或 N-M。所有请求字段与合法配套见 docs/xhttp.md。
+      # 范围用字符串 N 或 N-M；uplink-chunk-size/sc-max-each-post-bytes/sc-min-posts-interval-ms 也接受整数。
       x-padding-bytes: "100-1000"
       sc-max-each-post-bytes: "1000000" # packet-up，最多16MiB，非预分配大小
-      sc-min-posts-interval-ms: "30"    # packet-up，0–60000且最大值为正
-      reuse-settings: # 省略无额外池；{} 启用默认池，阈值不是全节点数量上限
+      sc-min-posts-interval-ms: "10"    # packet-up，0–60000且最大值为正
+      reuse-settings: # 省略时仅 H3 共享活动连接（每条 4 个租约、无空闲缓存）；{} 启用显式池
         max-concurrency: "0"
         max-connections: "0"
         c-max-reuse-times: "0"
@@ -307,18 +616,24 @@ proxies:
         fingerprint: ""     # 清除继承的 pin
         client-fingerprint: "" # 清除继承的 ClientHello profile
         name-cert-verify: "" # 恢复下载认证名
-        # certificate: <inline PEM> # 与 private-key 成对；禁止文件路径
-        # private-key: <inline PEM>
+        # certificate: ./client.crt # 与 private-key 成对，或两者都使用内联 PEM
+        # private-key: ./client.key
         # reality-opts: {} # 清除继承的 REALITY；非空对象必须提供 public-key
         # jls-opts: {} # 清除继承的 JLS；非空对象必须提供 username/password
+        # shadow-tls-opts: {} # 清除继承的 ShadowTLS；非空须 version: 3 和 password
     smux:
       enabled: false
-      protocol: h2mux # h2mux/smux/yamux
-      max-connections: 1 # 0–i32::MAX；正值与正 max-streams 互斥
+      protocol: h2mux # 缺省/空为 h2mux，另支持 smux/yamux
+      max-connections: 1 # 带符号平台整数；负阈值禁用；正值优先于 max-streams
       min-streams: 0
       max-streams: 0
       padding: false
-      only-tcp: false # true 保留 packet-encoding；false 使用 sing-mux UDP
+      only-tcp: false # true 委托底层 UDP；false 提供 sing-mux UDP
+      statistic: false # true 记录真实 Inner 连接，可由 Controller 关闭，不重复计入业务总字节
+      brutal-opts:
+        enabled: false # true 要求服务端支持并启用 TCP Brutal；失败不回退普通 mux
+        up: 100 Mbps # 客户端发送能力；裸整数/纯数字字符串单位为 Mbps，b=bit、B=byte
+        down: 100 Mbps # 客户端接收能力；接受十进制 K/M/G/T bps/Bps，缺省为 0
     dialer-proxy: upstream-select
 
   # REALITY 写法示意：在 VLESS 节点中保留 tls: true，并增加以下 mapping；不要与
@@ -328,35 +643,47 @@ proxies:
   #   short-id: "0123"
   #   support-x25519mlkem768: false # 主腿/下载腿均可配置，必须为非 null 布尔值
 
-  # 标准 TLS 的可选静态 ECH；主腿与 download-settings 使用相同字段。
-  # 启用时 config 必填标准 Base64 ECHConfigList，不能只填写 enable。
-  # 实际只协商 TLS1.3，servername 必须是 DNS 名；不查询 DNS 或自动明文回落。
-  # {} 清除；不能与同腿 REALITY/JLS、Vision 混用，详细契约见 docs/vless.md#静态-ech。
+  # 标准 TLS 的可选静态/动态 ECH；主腿与 download-settings 使用相同字段。
+  # 非空 config 是标准 Base64 ECHConfigList；省略/空串时通过节点 DNS 查询 HTTPS key 5。
+  # 实际只协商 TLS1.3，servername 必须是 DNS 名；静态 config 不查询 DNS，失败不自动明文回落。
+  # {} 清除；不能与同腿 REALITY/JLS、Vision 混用，详细契约见 docs/vless.md#ech。
   # ech-opts:
   #   enable: true
+  #   query-server-name: query.example # 省略则查询 servername，静态 config 优先
   #   config: "<server-provided Base64 ECHConfigList>"
 
   # SOCKS5 出站支持 CONNECT 和 UDP ASSOCIATE。username/password 必须同时省略
-  # 或同时出现；tls 只能省略或为 false。udp 控制 UDP ASSOCIATE。
+  # 或同时出现；tls 默认 false，true 使用 server 作为 TLS 名称，不接受 sni/alpn/client-fingerprint。
+  # TLS 支持 skip-cert-verify/name-cert-verify/fingerprint 和成对内联 PEM 或文件路径 certificate/private-key。
+  # TLS 只保护 TCP 控制连接，UDP relay 数据不经 TLS；udp 控制 UDP ASSOCIATE。
   - name: socks-hop
     type: socks5
     server: socks.example.com
     port: 1080
+    mptcp: false # true 仅在上述 Linux 宿主管理的无接口/源地址约束路径尝试
     username: user
     password: password
     udp: true
 
-  # AnyTLS 只提供客户端出站，配置只接受以下字段和可选 dialer-proxy。
+  # AnyTLS 只提供客户端出站，接受以下协议字段和节点通用字段。
   # sni 省略时使用 server。TLS 1.3/1.2 默认 WebPKI，alpn 省略/[] 时不发送。
   # skip-cert-verify 不能覆盖 fingerprint；pin 是证书 SHA-256，不是客户端伪造指纹。
   # 叶 pin 直接决定信任；非叶 pin 作为根继续验证链和名称。所有策略均验证握手签名。
-  # 不支持 REALITY、fp、ECH、mTLS 或 session/padding 调参字段，详见 outbounds.md#anytls。
+  # name-cert-verify 只改变证书验证名；certificate/private-key 为成对内联 PEM 或文件路径 客户端身份。
+  # 支持共享 client-fingerprint 和静态/动态 ech-opts；普通TLS、ShadowTLS v3或JLS身份单选。
+  # 不支持 REALITY 或 padding 调参，详见 outbounds.md#anytls。
+  # 两个 idle 时间字段为整数秒，<=5 回落30秒；min-idle-session 只保留现有空闲会话。
   # TCP 使用 AnyTLS session；udp: true 使用 UoT v2 datagram mode。
   - name: anytls-edge
     type: anytls
     server: anytls.example.com
     port: 443
     password: "private-anytls-password"
+    idle-session-check-interval: 30
+    idle-session-timeout: 30
+    min-idle-session: 0
+    disable-reuse: false
+    client-metadata: "" # 原样进入 Settings.client，不自动生成设备或产品标识
     sni: anytls.example.com
     # alpn: [h2, http/1.1]
     skip-cert-verify: false
@@ -370,7 +697,7 @@ proxies:
   # AES password 可用 iPSK1:...:iPSKn:uPSK 身份链，其他算法仅单一 Base64 PSK。
   # 以下仅为公开测试 key，不可用于真实服务。UDP 默认 false。
   # 上游 padding 风险和验收边界见 outbounds.md#shadowsocks-2022；
-  # 完整互通尚未签收。dialer-proxy 可引用具体节点或 select 组。
+  # dialer-proxy 可指定 DIRECT 或引用具体节点、策略组。互通范围见 acceptance.md。
   - name: ss-edge
     type: ss
     server: ss.example.com
@@ -378,7 +705,14 @@ proxies:
     cipher: 2022-blake3-aes-128-gcm
     password: "BwcHBwcHBwcHBwcHBwcHBw=="
     udp: true
-    # 可选 TCP 包装，两字段必须成对。仅 strict ShadowTLS v3 / TLS1.3。
+    # 可选流式插件，plugin/plugin-opts成对且只选一种：
+    # obfs: {mode: http 或 tls, host: bing.com}
+    # v2ray-plugin/gost-plugin: {mode: websocket, host: bing.com, path: /, mux: true, tls: false}
+    # v2ray-plugin另接受v2ray-http-upgrade/v2ray-http-upgrade-fast-open。
+    # TLS开启后才接受plugin-opts内的skip-cert-verify/name-cert-verify/fingerprint、
+    # 配对certificate/private-key与ech-opts；Host头同时确定SNI。
+    # jls: {host: cover.invalid, username: jls-user, password: jls-password, alpn: [h2, http/1.1]}
+    # ShadowTLS仅显式v3，使用完整TLS1.3认证。
     # UoT 默认关闭。开启须 udp: true，UDP 经 SS TCP（含可选插件），不回退原生 UDP。
     # udp-over-tcp: true
     # udp-over-tcp-version: 2 # 开启时省略或整数 2；关闭时不得配置版本
@@ -392,24 +726,47 @@ proxies:
     #   skip-cert-verify: false
     #   fingerprint: "<SHA-256 certificate pin, 64 hex digits>"
     #   name-cert-verify: verified.example.com # 可选独立证书验证名
-    # client-fingerprint: chrome # 仅有插件时允许；共享七值，缺省/none/空串关闭命名模板
+    # client-fingerprint: chrome # 仅有插件时允许；共享命名模板（须具备TLS1.3能力），缺省/none/空串关闭命名模板
 
-# 可选的静态 `select` 代理组。字段外形是严格 Mihomo 子集：每组只接受 name、
-# type、proxies 和可选 default-selected，type 只能是 select，proxies 至少一项。
-# 成员可精确引用具体节点、另一个 select 组、DIRECT 或 REJECT；RULES 不是成员。
-# 组声明顺序、成员顺序和重复成员全部保留，节点与组的完整混合图必须无环；组数、成员数和嵌套
-# 深度没有独立上限，仍受 256 KiB 配置总大小和 O(V+E) 无环校验约束。
+# select/url-test/fallback/load-balance 组支持静态 proxies 与动态 use；include-all 同时包含静态节点和所有 providers，
+# 也可分别使用 include-all-proxies / include-all-providers。后者启用时忽略 use。
+# filter 筛选动态成员；exclude-filter / exclude-type 同时排除显式成员。
+# 名称正则区分大小写；支持 lookahead、定长 lookbehind、数字/ASCII命名 backreference。
+# 命名组接受 (?<name>...) / (?'name'...)，引用接受 \k<name> / \k'name'；注释接受 (?#...)。
+# 混合捕获按 .NET 规则先给未命名组编号，再给命名组编号；数字回引、$1 / ${1} / $+ 使用该编号。
+# 反引号分隔的多表达式按匹配顺序排列。节点改名另支持 ${name} / $$ 等 .NET replacement。
+# 重复命名、显式数字组和递归/条件/平衡组不支持，不宣称完整.NET方言。
+# 复杂表达式有内部编译/执行预算；失败候选保留旧资源，不静默当不匹配。
+# 静态成员保留顺序与重复项。
+# 过滤后组成员为空时使用 empty-fallback（缺省 COMPATIBLE，即 DIRECT），可指定节点或内置目标。
+# disable-udp 缺省 false；true 禁用该组的业务 UDP。规则模式跳过不支持 UDP 的目标，
+# 继续匹配后续规则；global 模式及显式 DNS 出口仍会拒绝。hidden/icon 为 Controller 元数据。
+# 节点与组的完整混合图必须无环。资源更新后保留仍存在的当前选择，否则使用默认/首成员。
+# 未显式定义 GLOBAL 时，自动追加一个 select 组；成员依次为 DIRECT、REJECT、
+# 所有节点和声明的组，默认 DIRECT。可显式声明 GLOBAL 覆盖其成员及初始选择。
 #
-# default-selected 省略时选中第一项；显式值必须是当前组的直接成员。重复名称按
-# 第一项命中。没有 Controller 时，该初始选择在本次 session 内固定；有 Controller
-# 时可实时切换。选择只存于 Vole 当前 session 内存，Vole 不写回 YAML；宿主若需
-# 跨 session 保留，必须持久化选择并在下次配置中注入 default-selected。
-#
-# 切换只影响之后新建的物理 TCP 连接、UDP association/transport 和 DNS transport；
-# 既有 TCP 连接、UDP association、DNS cache/singleflight、DNS TCP pool 和其中的
-# transport 不迁移、不清空。选中成员失败时原样失败，代理组不自动换成员。
+# select 的 default-selected 省略、null、空串或未命中时选中第一项；有效缓存选择优先。名称精确匹配。
+# url-test 按 URL 探测延迟选择，tolerance（毫秒，默认 0）抑制小幅切换；fallback
+# 按声明顺序选择首个健康成员，恢复后可回到前面的成员。全部失败时返回首成员。
+# 四种组均接受 url/interval/timeout/lazy/expected-status/max-failed-times。
+# url 缺省使用首个 provider 的健康 URL，否则 https://www.gstatic.com/generate_204。
+# interval 单位秒，自动组缺省/0 为 300；select 缺省 0，不主动周期探测。
+# timeout 单位毫秒，缺省/0 为 5000；lazy 默认 true，无近期使用时跳过周期探测。
+# expected-status 省略/空/* 接受所有最终 HTTP 状态；单值可写整数 204 或字符串 "204"，区间用 "200-299"。
+# max-failed-times 缺省/0 为 5，建链失败达到阈值后触发探测，不重试同一次业务连接。
+# HTTP 探测结果不代表 UDP 可用性，业务 UDP 仍检查节点能力与 disable-udp。
+# Controller 可手动固定 url-test/fallback 成员，成员不可用时恢复自动选择。
+# load-balance 的 strategy 为 consistent-hashing（缺省）、round-robin、sticky-sessions。
+# 一致性哈希按目标可注册主域名或 IP 分桶；轮询跳过不健康成员；粘滞会话按来源 IP
+# 与目标主域名/IP 缓存 10 分钟，最多 1000 项。哈希种子属于当前进程，不承诺重启后相同。
+# hash-key 仅接受空字符串（缺省）或 in-user；in-user 仅用于一致性哈希/粘滞策略，
+# 使用已认证用户名单独分桶，无用户名时回退地址策略。业务路由和 dialer-proxy 都保留此身份。
+# load-balance 没有 now/手动选择；UDP 按目标会话固定叶节点，健康变化不迁移旧会话。
+# 自动或手动切换只影响新连接；既有连接、认证会话及其中复用的流仍保留原路径。
 # 组作为 dialer-proxy 时，与路由共用当前选择，但不重新执行业务规则；DIRECT 连接
-# 当前节点的服务器而不是业务目标，REJECT 在建链时失败且不回退。单次建链对每个组
+# 当前节点的服务器而不是业务目标，REJECT 在建链时失败且不回退。成员也可为 PASS/
+# PASS-RULE；仅 rule 模式消费控制，global、dialer-proxy 或显式 DNS 出口选中时拒绝。
+# 单次建链对每个组
 # 只读一次选择，SOCKS5 UDP 控制流与 relay 路径共用该快照和期限；不同组没有原子
 # 快照保证。复用旧 AnyTLS 会话的新业务流仍沿用该会话路径，只有新建底层 transport
 # 才读取新选择。Hysteria2/TUIC 已建立会话的新逻辑流、Hysteria2 跳端口 socket
@@ -429,32 +786,228 @@ proxy-groups:
     proxies: [vless-edge, fallback-select, DIRECT, REJECT, vless-edge]
     default-selected: vless-edge
 
-# 运行时 DNS 可省略；enable: true 时主 nameserver 必须有 1–4 项。ipv6 省略时
-# 默认为 true；false 时直接 AAAA 查询返回空结果，域名解析不查询 AAAA。nameserver
-# 只接受裸 IP、udp://IP[:port] 或 tcp://IP[:port]。没有 fragment 时固定 DIRECT；
-# fragment 只接受 DIRECT、RULES、实际节点名或代理组名。`PROXY`/`#PROXY` 没有
-# 默认出口含义，只有存在同名 route target 时才有效。DNS route 选中代理组后，
-# 仅新建物理 transport 解析当前成员；cache 与既有 TCP pool 不随切换清空。
-# nameserver-policy 按顺序匹配
-# `geosite:<selector>[,<selector>...]`，逗号项为 OR，命中后只在当前组内故障转移。
-# selector 可为 cn、cn@ads@cn、!cn@ads；多个属性为 key 存在性 AND（忽略 bool/int 值），
-# 前置 ! 取反整个匹配结果，@!cn 是字面 key。相同归一 selector 不能跨项重复，
-# 但相同基础分类的不同交集/正反选可共存；资产不可用不因反选变成全匹配。
+# 资源声明及使用示例。http 支持 HTTP(S)，file 读取本地文件，inline 使用 payload。
+# path 必须位于 dataDir 内；HTTP 缺省路径在 proxies/ 或 rules/ 下按实际 URL/header/UA 请求摘要分配。
+# HTTP interval 单位秒，0 只获取一次；file 监测文件变化。下载失败退避重试。
+# proxy 指定当前运行配置中的出口；缺省按规则选路。不会等待新资源才能建立下载连接。
+# header 值为字符串数组；size-limit 单位字节，0 不设下载上限，解析仍有容量边界。
+# proxy provider 支持 {proxies: [...]} YAML、URI 列表及标准 Base64 编码的 URI 列表。
+# URI 转换后仍执行原名称过滤、override 与完整严格节点/依赖图校验。
+# 支持当前协议范围内的 vless/vmess/trojan/ss/anytls/hy2/hysteria2/tuic/mierus，
+# 以及 socks/socks5/socks5h/http/https；SS 仍只允许 SS2022，TUIC 仅 v5。
+# URI HTTPS 节点保持默认验证证书，不复制参考转换器的隐式 skip-cert-verify。
+# 可用 filter/exclude-filter/exclude-type。URI 转换失败保留旧资源，不记录原始 URI。
+# HTTP 来源 URL 的 userinfo 使用 Basic；跨 origin 跳转不转发原认证/Cookie。
+# gzip 流式解压后写缓存；size-limit、hash 与后续解析针对解压内容，gzip 损坏或超限不发布。
+# 来源摘要绑定精确 URL、实际 header/UA；旧 URL-only 元数据保留可用内容但不复用 ETag。
+# provider 的 dialer-proxy 覆盖每个节点的同名字段，override 最后应用；
+# 它只控制节点上游，资源下载仍使用独立的 proxy 字段。
+# override 支持 tfo、mptcp、udp、udp-over-tcp、up/down、dialer-proxy、ip-version、interface-name、routing-mark、skip-cert-verify、name-cert-verify、
+# additional-prefix/suffix、proxy-name: [{pattern: '表达式', target: '替换文本'}]、override-expr 字符串数组；
+# 协议专属覆盖只用于支持该字段的节点。未实现的覆盖字段严格拒绝。
+# override-expr 为原生有限 yq 方言，校验时预编译：原名称过滤 → 结构化 override / 改名 / 前后缀
+# → 表达式按列表顺序执行 → 严格节点及引用图校验。每项须产出一个 mapping，失败保留旧资源。
+# 支持根/字段/引号字段、正负数组索引、[] 通配、select 目标、= / |= / += / -= / *=、del、
+# pipeline / 逗号流 / 数组收集 / mapping / 插值、标量、算术/比较/and/or/默认值 //。
+# 函数：length/keys/has/contains/select；reverse/sort/unique/flatten/any/all；
+# map/map_values/filter/to_entries/from_entries/with_entries/any_c/all_c；
+# test/sub/split/join/upcase/downcase/trim/tostring/tonumber/type/not。
+# transform 函数允许分号分隔的独立参数流；any_c/all_c 按成员短路，from_entries 要求 key/value。
+# upcase/downcase 使用 Rust 标准 Unicode 全映射，单字符可扩展为多个字符；trim 独立处理空白。
+# 整数 literal 为有符号 64 位，含 -9223372036854775808；超出该范围的整数 literal 拒绝。
+# = 右侧读取根，|= 读取旧目标；赋值右侧的 pipeline/and/or 须带括号，多结果须收集。
+# mapping 值取最后结果，无结果省略；插值取首结果。sub 全局替换，使用 Go 的 $capture。
+# 每项最多 16 KiB/4096 tokens 与节点、深度 32；整份配置编译最多 512 KiB/65536 tokens
+# 与节点/1 秒。整份候选共享取消、20 万步、100ms、32 MiB 累积值分配估算、值深度 64
+# 与 32 个有界线性正则预算。无 shell/yq、变量、reduce、动态路径、递归下降、文件/环境或文档流。
+# 最终节点仍须符合本文协议范围；表达式不提供任意脚本或额外配置字段。
+# proxy providers 的 health-check 接受 enable/url/interval/timeout/lazy/expected-status；
+# enable 默认 false，开启后 interval 缺省/0 为 300 秒。空 URL 不发起探测。
+# 相同节点/URL 的检查共享结果，每批最多 10 个并发，超时与停止均取消 I/O。
+# 更新先解析并校验整个依赖图，成功才替换；失败保留旧配置与 HTTP 缓存。
+# HTTP proxy provider 的订阅用量来自 Subscription-Userinfo 响应头，成功更新和 304 后
+# 随缓存保存；缺少该头保留旧值，失败候选不更新。Controller 不用本地流量填充订阅用量。
+# proxy providers 的 age-secret-key 可含多行 X25519/Hybrid AGE 私钥，空行和 # 注释跳过。
+# HTTP/file 来源写法：age-secret-key: |，下方缩进填写私钥；不用于 rule providers。
+# 配置期验证私钥；仅精确 AGE armor 前缀触发原生解密，之后识别 YAML/URI/Base64。
+# file、初始缓存和 HTTP 更新共用解密；缓存/hash/ETag 保留原密文，解密失败不发布候选。
+# 私钥最多 16 KiB/128 个，AGE 头最多 64 KiB/1024 次身份尝试；解密输出限 8 MiB，
+# URI、JSON 选项和多端口节点转换共用 32 MiB 内部展开计费；不是整进程 RSS 保证。
+# 读取/解密共享 90 秒期限，并在读块和密钥操作之间检查取消。
+# 新连接使用新资源，旧 TCP/UDP 会话保留原资源；停止等待下载、解析和资源释放。
+# rule providers 支持 domain/ipcidr/classical，format 为 yaml/text/mrs；MRS 仅 domain/ipcidr。
+# YAML 规则文件为 {payload: [...]}，text 每行一条，支持空行和 # 注释。
+# classical 接受已支持的无动作规则，不接受 MATCH、RULE-SET、SUB-RULE。
+# 文本/MRS 解压上限 64 MiB；YAML 沿用 8 MiB 输入和 32 MiB 展开预算。
+# 非inline规则provider可设置path-in-bundle（例如rules/cn.mrs），从dataDir/BundleMRS.7z读取成员。
+# 有效缓存优先，其次bundle，再用原file/http来源；坏缓存同样可以回退bundle。
+# bundle只读取指定压缩块，支持COPY/LZMA1/LZMA2及已列入资源契约的filter；超预算/坏成员回退原来源。
+# inline忽略path-in-bundle；proxy-providers不接受此字段。
+proxy-providers:
+  local-nodes:
+    type: inline
+    # override:
+    #   override-expr: ['.name |= (trim | upcase)', '.udp = true']
+    payload: []
+    health-check:
+      enable: false
+      url: https://www.gstatic.com/generate_204
+      interval: 300
+      timeout: 5000
+      lazy: true
+      expected-status: "204"
+rule-providers:
+  local-domains:
+    type: inline
+    behavior: domain
+    payload: ["+.internal.example"]
+# 动态组写法：{name: automatic-members, type: select, use: [local-nodes]}
+# 规则写法：RULE-SET,local-domains,DIRECT；ipcidr/classical 可追加 no-resolve。
+# DNS policy 支持 rule-set:local-domains（逗号分隔多个集合）；只接受 domain/classical，
+# classical 在 DNS 场景使用域名与 GeoSite 条件，支持仅由这些条件组成的 AND/OR/NOT。
+# 混合 IP、端口、来源或网络条件的逻辑项不参与域名 selector。
+
+# hosts 支持单 IP、IP 数组、域名别名与 Clash 域名通配。
+# 值恰好为 lan 或 [lan] 时，启动准备捕获接口 IP，排除回环和 link-local；空快照使启动失败。
+# 校验不读取网卡；快照不随地址变化或 Provider 更新刷新，不限于私有网段。
+hosts:
+  "internal.example": [192.0.2.10]
+  "alias.example": internal.example
+
+# DNS 的 enable、ipv6 默认 false，use-hosts/use-system-hosts 默认 true。
+# enable 关闭时不接管 TUN DNS，内部解析使用系统 resolver；配置中的 hosts 仍可用于内部解析。
+# enable 开启时使用配置的 resolver，不因上游失败回退到系统 DNS。
+# nameserver 默认 [https://doh.pub/dns-query, tls://223.5.5.5:853]，不能显式留空。
+# 支持裸 IP、UDP/TCP、tls://、http(s)://、quic://（DoQ 默认 853），允许上游域名。
+# DoH GET 使用 ID 0 与无 padding
+# Base64URL dns=；清除原 query/fragment，URL userinfo 转 Basic，不进入 Host/path 或日志。
+# HTTPS 实际 ALPN 协商 H2/H1，无 ALPN 回退 H1；明文 HTTP 仅 H1，无 h2c。
+# prefer-h3: true 让 HTTPS 首次建连竞争已认证 H3 与 TCP TLS，第一条成功胜出；失败允许另一条继续。
+# HTTPS #h3=true 强制实际 H3，不降级 H2/H1；明文 HTTP 的 h3/prefer-h3 不改变 H1 行为。
+# DoT、DoH、DoQ 使用共享 TLS 信任根，校验证书与名称；QUIC 使用受控 UDP，不绕过 DNS 出口/平台绑定。
+# default-nameserver 接受 IP 上游或显式 system，用于 bootstrap。
+# system、system://、dhcp://system 使用物理系统 DNS；dhcp://<精确接口名> 使用该接口的 DHCP DNS。
+# 各角色、policy、fallback 均支持；DHCP 接口不能用于 default-nameserver。来源始终物理直连，
+# fragment/代理规则不改变物理出口，但 ECS/类型过滤包装仍适用。
+# 只读现有网络来源；缺失、加密要求无法满足或物理绑定失败时不可用。
+# rcode://success/format_error/server_failure/name_error/not_implemented/refused 返回本地 RCODE 0–5，
+# 可用于各 nameserver 列表与 policy（default-nameserver 除外）；不建立网络连接或额外设置 RA。
+# 无 fragment 时默认 DIRECT；respect-rules: true 时默认 RULES，且必须配置
+# proxy-server-nameserver。显式 fragment 可选 DIRECT、COMPATIBLE、REJECT、REJECT-DROP、RULES 或已配置的节点/组名；
+# fragment 使用 #出口或接口&参数=值，整个 fragment 先百分号解码，再拆分；重复项以后者为准。
+# 出口名优先；没有同名节点/组时按接口直接连接，覆盖全局接口并沿用全局 mark。
+# 接口身份隔离 DoT/DoH/DoQ 的连接复用；system/DHCP、RCODE 和节点私有 DNS 保持自身出口语义。
+# ecs=IP/CIDR 与 ecs-override=true 控制 ECS，保留其他 EDNS 参数。
+# disable-ipv4=true、disable-ipv6=true、disable-qtype-N=true 抑制相应 question 并过滤全部响应 sections；
+# ECS/过滤适用于 system、DHCP、RCODE 及各 resolver 角色，DHCP 接口名不含 fragment。
+# skip-cert-verify=true、name-cert-verify 用于 DoT/DoH/DoQ；显式名称验证优先且不改变 SNI。
+# disable-reuse=true 仅禁用指定 DoT 复用；HTTPS 仍可复用，未知键值参数拒绝。
+# proxy-server-nameserver 专门解析节点，direct-nameserver
+# 专门解析 DIRECT 业务目标；未配置时复用 nameserver。两者不隐式开启 respect-rules。
+# direct-nameserver-follow-policy 默认 false；true 让直连解析遵循 nameserver-policy。
+# 新建 DNS 连接采用当前组选择，cache 和已有连接不随选择改变而清空。
+# nameserver-policy 接受域名、Clash 通配域名和 geosite；值为单个 nameserver 字符串
+# 或非空数组。域名可用逗号连接；* 匹配一层，.example.com 仅匹配子域，
+# +.example.com 匹配本域及所有子域。连续域名项优先匹配字面标签，其次 *，最后 .；
+# 相同归一域名模式以后项为准。GeoSite 项隔开域名区块，区块与 GeoSite 按声明顺序匹配。
+# `geosite:<selector>[,<selector>...]` 的逗号项为 OR，selector 可为 cn、cn@ads@cn、
+# !cn@ads；多个属性为 key 存在性 AND（忽略 bool/int 值），前置 ! 取反整个匹配结果，
+# @!cn 是字面 key。资产不可用不因反选变成全匹配。命中后仅使用当前策略的上游。
 dns:
   enable: true
   ipv6: true
+  prefer-h3: false
+  ipv6-timeout: 100 # 毫秒；内部 A/AAAA 并发，A 完成后最多等待 AAAA；0 同缺省 100
+  cache-max-size: 4096 # 每个 DNS 角色的结果总条目数；0 同缺省 4096，A/AAAA 和 wire 共用
+  cache-algorithm: lru # 精确 arc 使用 ARC；缺省与其他字符串使用 LRU，与 Mihomo 一致
+  fallback: [] # A/AAAA 的备用解析组；不是 nameserver 内部的故障转移
+  fallback-lazy-query: false # false：与主组同时查询；true：确定需要时才查询
+  fallback-filter:
+    geoip: true # 非本地地址且不属于 geoip-code 时使用 fallback
+    geoip-code: CN
+    ipcidr: [] # 任意返回地址命中时使用 fallback
+    domain: [] # Clash 域名通配，匹配后只查询 fallback
+  enhanced-mode: redir-host # 或 fake-ip；内部节点/直连解析始终取得真实地址
+  fake-ip-range: 198.18.0.1/16
+  fake-ip-range6: "" # 设置 IPv6 CIDR 且启用 IPv6 后分配 AAAA
+  fake-ip-ttl: 1 # 秒；运行时最小为 1，不决定映射寿命
+  fake-ip-filter-mode: blacklist # blacklist / whitelist / rule
+  fake-ip-filter: [dns.msftnsci.com, www.msftnsci.com, www.msftconnecttest.com]
+  # blacklist：命中返回真实地址；whitelist：只有命中才分配 fake-IP。
+  # 普通过滤项支持 Clash 域名通配、geosite: 和 rule-set:。
+  # rule：使用 DOMAIN-SUFFIX,example.com,real-ip 等域名规则；动作 real-ip/fake-ip。
+  # rule 未命中分配 fake-IP；两种地址池均保留网络地址后的前三个地址及广播地址。
+  use-hosts: true
+  use-system-hosts: true
+  respect-rules: false
+  default-nameserver: [114.114.114.114, 223.5.5.5, 8.8.8.8, 1.0.0.1]
+  proxy-server-nameserver: [223.5.5.5]
+  proxy-server-nameserver-policy:
+    "+.internal.example": 192.0.2.53
+  direct-nameserver: [223.5.5.5]
+  direct-nameserver-follow-policy: true
   nameserver:
     - "tcp://1.1.1.1:53#main-select"
   nameserver-policy:
+    "blocked.example": "rcode://refused"
+    "internal.example": "223.5.5.5"
+    "+.example.com": ["tcp://1.1.1.1:53#DIRECT"]
     "geosite:private,cn,apple":
       - "tcp://223.5.5.5:53#DIRECT"
       - "tcp://1.1.1.1:53#main-select"
 
-# rules 是运行配置必填项，按顺序首条命中。DIRECT 与 REJECT 是内置动作，其他
-# 动作必须精确使用实际节点名或代理组名。`PROXY` 没有特殊别名。rules 不能为空，
-# 必须恰好以一个指向实际节点或代理组的 MATCH 结束；不存在隐式 MATCH 或 DIRECT
-# 回退。选中组时使用当前成员，组本身不做 health check、测速或自动 failover。
+# rules 可省略或为空；rule 模式按顺序首条命中，未命中 DIRECT。MATCH 可放在任意
+# 位置，普通目标命中后其后规则不再执行。内置 DIRECT/COMPATIBLE 直连，REJECT 拒绝，
+# REJECT-DROP 的 TCP 等待 60 秒或 Stop（期间不发往远端），UDP 逐包丢弃。其他出口精确引用节点或组。
+# 支持 DOMAIN、DOMAIN-SUFFIX、DOMAIN-KEYWORD、DOMAIN-WILDCARD、DOMAIN-REGEX、
+# GEOSITE、GEOIP、SRC-GEOIP、IP-ASN、SRC-IP-ASN、IP-CIDR、IP-CIDR6、SRC-IP-CIDR、
+# IP-SUFFIX、SRC-IP-SUFFIX、DST-PORT、SRC-PORT、NETWORK、
+# IN-TYPE、IN-NAME、IN-USER、IN-PORT、REMATCH-NAME、RULE-SET、SUB-RULE、AND/OR/NOT 和 MATCH。来源信息来自实际入站会话。
+# PROCESS-NAME、PROCESS-PATH 及各自 -WILDCARD/-REGEX 支持已确认的本机 socket owner，忽略大小写。
+# Linux/Android 还接受 UID（uint32 单值/范围，/ 分隔，最多 28 段）；UID 0 不匹配。
+# 进程路径保留 Unicode，最多 32 KiB；正则沿同一编译/决策预算，不当作域名处理。
+# Linux 查询当前网络 namespace 的完整源/目标元组，再以 inode 找进程；macOS 使用公开 libproc，
+# Windows 使用 owner-PID 表与普通 limited-information 句柄。权限不足、LAN/跨 namespace、
+# wildcard/复用归属不明确或查询预算耗尽时身份未知，不提权；iOS/tvOS 无跨 App 进程信息。
+# Android 不新增宿主回调；受平台 /proc 权限约束，不承诺包名或任意应用身份可得。
+# 同时最多四个扫描，许可最多等待 100 ms，每扫描最多 100 ms/16384 项/1 MiB 表。
+# strict 无身份条件及 off 不扫描；一次决策不重试，Stop 等待已开始的系统查询结束。
+# CIDR 两种别名都按 payload 实际地址族解析；GEOIP/IP-ASN/CIDR/IP-SUFFIX/RULE-SET 可追加 src，自动禁止 DNS。
+# IP-SUFFIX 的 address/bits 比较低 bits 位，保留原地址，按 IPv4/IPv6 分族；0 位匹配同族全部。
+# SRC-IP-SUFFIX 只使用真实来源地址；目的后缀支持 no-resolve，并复用既有惰性 DNS 结果。
+# RULE-SET 的 src 在局部视图交换源/目标 IP 与端口，保留域名、入口类型和身份。
+# IN-TYPE 为 / 分隔的 Mihomo 类型名，大小写无关，SOCKS 展开为 SOCKS4/SOCKS5；
+# IN-NAME 为 / 分隔、区分大小写的入口名：TUN为DEFAULT-TUN，mixed的HTTP/SOCKS5为DEFAULT-MIXED；内部请求为空。
+# IN-USER 为 / 分隔、区分大小写的已认证用户名。三种列表逐项 trim，空项报错。
+# IN-PORT/DST-PORT/SRC-PORT 为 uint16 端口或范围，/ 分隔，含 0，逆序范围归一，
+# 最多 28 段；分隔中的空段跳过。真实入口和服务器端口仍须非零。
+# 通配符 * 匹配任意长度、? 匹配一个字符；DOMAIN-REGEX 默认忽略大小写，普通表达式走线性引擎。
+# 有限复杂语法支持前向正/负断言、固定宽度后向断言、数字及 ASCII 命名 backreference、原子组，
+# 命名捕获支持 (?<name>...) 与 (?'name'...)；引用支持 \k<name> 与 \k'name'。
+# 混合命名/未命名捕获的数字引用沿 .NET 编号；每模式最多512个捕获，转译仅改变编号。
+# 不支持重复命名、显式数字组、递归、条件/平衡组、possessive quantifier或变长后向断言；
+# 此有限方言不保证全部 regexp2/.NET Unicode、锚点或捕获语义等价。无法编译或越界明确报错。
+# 每模式限制 4 KiB、512 AST 节点/32 层、有限重复 1024，委托编译/搜索缓存有近似大小边界。
+# 一次决策跨逻辑/子规则、classical provider、候选地址和 DNS 续跑共享 sticky 执行预算：
+# 每次复杂匹配预留 2049 回溯额度，总共 65536；所有谓词及正则共同消费 64 Mi work units；
+# 累计实际正则调用耗时上限 2 ms，DNS 等待不计入。时间/取消仅在同步引擎调用前后检查，
+# 不能中途抢占或保证严格 2 ms/Stop 上界。执行失败终止当前决策，不视作未匹配或 DIRECT。
+# 逻辑规则例如 AND,((DOMAIN-SUFFIX,example.com),(SRC-PORT,1000-2000)),DIRECT；
+# NOT 恰好一个子规则，逻辑最多嵌套 32 层。主列表与所有 sub-rules 共用 65536 条、
+# 单条 16 KiB、文本合计 8 MiB 的预算；子规则名计入文本。子规则调用最多 32 层，
+# 名称必须存在且全图无环；定义共享存储，不按调用次数复制。
+# SUB-RULE,(纯条件),名称 在条件匹配时进入指定列表；子列表耗尽则继续调用者。
+# PASS（含组选择为 PASS）退出所有子调用并继续主列表下一条；PASS-RULE 仅继续
+# 当前子列表，出现在主列表时为 REJECT。两者不能出现在逻辑谓词或 classical 集合中。
+# REMATCH-NAME,blue/Green,DIRECT 按 / 分隔、逐项 trim，名称非空且区分大小写。
+# rematch 节点更新本次决策标记或根列表，从首条重新求值，不创建连接或回到调用位置。
+# 重入保留已完成 DNS/process、来源/目标及原期限、取消、预算、规则禁用快照。
+# 同次决策最多 32 个 rematch 节点，节点名重复即失败；不增加可调递归参数。
+# 组的控制目标先于 disable-udp/节点 UDP 检查；跳过不推进轮询。实际出口只选择一次。
 # GEOSITE 支持 [!]<code>[@<attr>...]，GEOIP 支持 [!]<code> 和可选 no-resolve。
+# SRC-GEOIP 与 GEOIP,...,src 等价，来源规则不触发 DNS；lan 为无需资产的内置 GeoIP。
+# IP-ASN 按实际目标 IP 查询 ASN.mmdb，可带 no-resolve；SRC-IP-ASN 使用实际来源 IP。
+# ASN payload 逐字匹配，不转换 AS 前缀或补零；仅引用时加载，数值型数据库无记录匹配 0。
 # 例如 GEOSITE,google@ads,REJECT / GEOSITE,!cn@ads,main-select / GEOIP,!CN,DIRECT。
 # geolocation-!cn 为字面分类名；GeoIP DAT reverse_match 接受但忽略，取反由 ! 控制。
 # GEOSITE 没有域名不匹配；分类缺失不匹配，而有效空属性交集的反选匹配非空域名。
@@ -463,15 +1016,20 @@ rules:
   - GEOSITE,cn,DIRECT
   - GEOIP,CN,DIRECT,no-resolve
   - DOMAIN-SUFFIX,anytls.example,anytls-edge
-  - NETWORK,UDP,anytls-edge
+  - SUB-RULE,(NETWORK,UDP),udp-policy
   - MATCH,main-select
 
-# measureDelay 使用独立的 node-only 配置：顶层只能包含 proxies，不能包含
+sub-rules:
+  udp-policy:
+    - DOMAIN-SUFFIX,example.com,PASS-RULE
+    - NETWORK,UDP,anytls-edge
+
+# measureDelay 使用独立的 node-only 配置：顶层只接受 proxies 和 tls.custom-certifactes，不能包含
 # proxy-groups。节点字段和代理图校验与上文一致，但不能出现 mixed-port/authentication、
-# tun、sniffer、Controller、DNS、rules 或 GeoData；此接口的 dialer-proxy 只能引用具体
+# tun、sniffer、Controller、DNS、rules 或 GeoData；此接口的 dialer-proxy 可指定 DIRECT 或具体
 # 节点。Vole 从“未被任何 dialer-proxy 引用”的节点推导唯一链头，且该链必须覆盖
 # 全部节点。测速不创建监听器、公共实例、TUN/protect 租约、DNS、规则引擎、代理组
-# 或 GeoData 注册。
+# 或 GeoData 注册。rematch 是路由控制，不属于可测量的具体节点，测速配置拒绝它。
 #
 # 最小测速示例：
 # proxies:
diff --git a/docs/controller-api.md b/docs/controller-api.md
index fbb0301..c97a70c 100644
--- a/docs/controller-api.md
+++ b/docs/controller-api.md
@@ -1,25 +1,81 @@
 # 运行时 Controller API
 
-Controller 是当前 Running Session 的回环 HTTP 接口。它提供一次性 TUN 流量快照，以及静态 `select` 代理组的状态查询和实时选择；它不是 Invoke API，也不承诺完整 Mihomo Dashboard 兼容。
+Controller 是当前 Running Session 的 HTTP 接口。它提供业务连接管理、有效设置与规则查询、单次 TUN 流量快照、按需 WebSocket 推送，以及静态与动态 `select`、`url-test`、`fallback`、`load-balance` 代理组的状态查询和实时选择；它不是 Invoke API，也不承诺完整 Mihomo Dashboard 兼容。
 
 ## 配置与生命周期
 
 ```yaml
 external-controller: 127.0.0.1:9090
+external-controller-tls: 127.0.0.1:9443 # 可单独启用或与 HTTP 同时启用
+external-controller-unix: controller.sock # Linux，可独立启用
+external-controller-routing-mark: 0 # Linux，仅管理 TCP
+external-controller-cors:
+  allow-origins: ["https://ui.example"]
+  allow-private-network: false
 secret: "vole-runtime-secret"
 ```
 
-- 省略 `external-controller` 表示不启动 Controller，此时不能单独配置 `secret`。含代理组但没有 Controller 的配置合法，组在本次 session 内保持初始选择。
-- `external-controller` 只接受带显式非零端口的回环 IP 地址。它要求启用 TUN 或至少定义一个 `proxy-groups`；非 TUN 配置须通过 `mixed-port` 满足运行配置的入站要求。
-- 只要同时配置代理组与 Controller，`secret` 就必填；仅有 TUN 流量接口时可省略。`secret` 出现时必须为 1–255 UTF-8 字节，并保护本文定义的全部路由。
+- 三个 Controller 地址均省略或空串时不启动 Controller，也不采集业务连接、规则命中和建链诊断；配置中的 `secret` 可保留。代理组选择、健康检查、资源更新与 TUN 原始流量统计独立运行。
+- `external-controller` 接受 IP、`localhost` 或空 host 与数值端口组成的地址，如 `127.0.0.1:9090`、`0.0.0.0:9090`、`[::]:9090`、`localhost:9090`、`:9090`。端口范围为 0–65535，0 由系统选择端口；`localhost` 使用 IPv4 回环。其他域名和命名服务端口不在当前范围内。静态节点、纯 DIRECT 及关闭业务入口的配置均可使用。
+- 空 host、`0.0.0.0` 和 `[::]` 均优先使用允许 IPv4 映射连接的双栈通配监听，仅地址族不可用时改用 IPv4。Controller 的地址族选择独立于顶层 `ipv6`。
+- `external-controller-tls` 使用相同地址格式、绑定与端口范围。HTTP/HTTPS 共享当前会话、API handler、选择状态和 Bearer 认证；HTTPS 按实际 ALPN 提供 H2/H1，无 ALPN 使用 H1；明文 HTTP 仅 H1。
+- `external-controller-unix` 是 Linux 文件系统路径，空串关闭；相对路径从 dataDir 解析，不自动创建父目录。
+  bind 前通过实际 socket fd 限制创建权限，绑定后在 listen 前恢复当前用户 0600 权限并复验捕获的 dev+ino；
+  已有文件、目录、符号链接或 socket 都使绑定失败，不接管旧对象。
+  本地 HTTP/1 与 WebSocket 共用现有 API、CORS、资源和订阅限额，通过文件权限授权，不要求 Bearer 或 token。
+  网络 HTTP/HTTPS 保留原 secret；本地访问不会修改它。Stop 和启动失败只清理本次创建且 dev+ino 仍一致的 socket，
+  也覆盖绑定后尚未 serve 就丢弃的情况；其它平台启动该入口返回不支持。
+- `external-controller-routing-mark` 仅作用 Linux HTTP/HTTPS 的 TCP listener 和已接受 socket，
+  在 bind 前设置 SO_MARK；Unix socket 与业务 Dialer 不受影响。0 不设置；沿用 socket mark 的
+  32 位范围（负的 i32 值转换为同位模式的 u32）。SO_MARK 权限或系统错误原样导致绑定／接受失败，
+  不静默清零或回退；非 Linux 在启用网络监听且 mark 非零时返回不支持。
+- `secret` 始终可选，省略或空串表示不要求认证；配置非空值时保护本文定义的业务路由，CORS 预检在认证之前处理。配置仅受整体 YAML 大小预算约束，HTTP 请求头仍限 32 KiB。
 - `measureDelay` 的 node-only 配置不能包含 Controller 或代理组字段。
-- `validateConfig` 只校验字段；`prepare` 不监听端口；`start` 绑定端口，绑定失败则启动失败。`stop` 和 `destroyInstance` 关闭监听器。
+- `validateConfig` 只校验 Controller 字段；`start` 加载服务端证书并绑定端口，任一失败则启动失败。`stop` 和 `destroyInstance` 关闭全部监听器并等待请求与证书 watcher 回收。
 
-Controller 与公共运行时 session 同生共灭。代理组选择只保存在 Vole 当前 session 的内存中；Vole 不写回配置。宿主如需跨 session 保留选择，必须自行持久化，并在下次 `configYaml` 中提供对应的 `default-selected`。
+Controller 与公共运行时 session 同生共灭。`profile.store-selected` 默认 true，Core 将显式选择保存到 dataDir/selected.json，在下次启动时恢复有效成员；不写回 YAML。关闭该选项后只保留会话内选择。写入失败不回滚已生效的选择，`GET /proxies` 的 `selectionError` 给出脱敏原因。
+
+## HTTPS 证书与客户端认证
+
+```yaml
+tls:
+  certificate: controller.pem
+  private-key: controller.key
+  client-auth-type: require-and-verify
+  client-auth-cert: controller-client-ca.pem
+```
+
+`certificate/private-key` 接受配对 PEM 内容或 dataDir 内的文件路径。两者均空时生成随机 RSA 2048 密钥与自签证书，没有配置域名或公共信任；没有 HTTPS 地址时不加载服务端材料。内联证书在本会话中固定，文件证书对每秒检查一次：匹配且有效的完整候选原子替换，坏候选保留旧证书；在途 TLS 使用已选择的证书，新握手取得新候选。只读取普通文件，证书对合计最多 8 MiB；错误不输出内容、私钥或路径。
+
+`client-auth-type` 对客户端证书的要求如下；TLS 始终校验客户端 CertificateVerify 握手签名。
+
+| 值 | 无客户端证书 | 提供客户端证书 |
+| --- | --- | --- |
+| 省略、空串或其他字符串 | 允许，不请求证书 | 不要求证书 |
+| `request` | 允许 | 校验结构与握手签名，不校验信任链 |
+| `require-any` | 拒绝 | 校验结构与握手签名，不校验信任链 |
+| `verify-if-given` | 允许 | 必须通过配置 CA 的证书验证 |
+| `require-and-verify` | 拒绝 | 必须通过配置 CA 的证书验证 |
+
+默认模式携带非空 `client-auth-cert` 时自动提升为 `require-and-verify`；显式 `request/require-any` 保留原要求。CA 接受 PEM 内容或 dataDir 内普通文件，最多 8 MiB，只在启动读取；不随服务端证书 watcher 自动更新。客户端认证与 API Bearer 分别执行，成功的 TLS 握手不会跳过非空 secret。服务端证书、客户端 CA 与 `tls.custom-certifactes` 的出站信任根分别消费。
+
+## CORS
+
+`external-controller-cors.allow-origins` 缺省、空数组或含 `*` 时允许全部来源，响应为 `Access-Control-Allow-Origin: *`；其它列表按忽略大小写的精确匹配或单个 `*` 通配匹配，成功时回显请求来源。无 Origin 或来源不匹配时不返回允许来源头，普通 API 请求仍走原路由与 Bearer。
+
+OPTIONS 携带 Origin 和非空 `Access-Control-Request-Method` 时为预检，在 Bearer 前返回 200。允许 GET/POST/PUT/PATCH/DELETE，OPTIONS 同样有效；请求头仅允许 Content-Type、Authorization 与参考自动加入的 Origin，缓存 300 秒，不返回 Allow-Credentials。拒绝的预检仍为 200，但不返回允许头。普通响应含 `Vary: Origin`，预检另含请求 method/headers 的 Vary。
+
+`allow-private-network` 缺省 true；只对成功预检且请求 `Access-Control-Request-Private-Network: true` 返回相应允许头，显式 false 禁止返回该头。CORS 不改变 Controller 地址、secret 或 API 支持范围。
+
+与 Mihomo 一致，`allow-origins` 只控制 CORS 响应头，不按 `Origin` 拒绝 WebSocket Upgrade。浏览器 WebSocket 不受 Fetch CORS 约束；订阅访问仍由独立的 secret/token 鉴权决定，空 secret 不要求认证。
+
+## 请求预算与停止
+
+HTTP/HTTPS/Unix 合计最多 8 条活动连接。普通 H1 每连接处理一个请求后关闭，WebSocket 升级后保持当前订阅；H2 每连接最多 8 条并发请求，超出准入复位 stream，接收窗口每流 1 KiB、连接 8 KiB，发送缓冲每流 16 KiB。头部上限 32 KiB/100 字段，H2 target 上限 8 KiB，组选择与 PATCH body 上限 1 KiB，内联配置 PUT body 上限 8 MiB；握手、H1 读头、body 与写响应各有 5 秒期限。停止取消活动请求与订阅、关闭协议 driver，并等待所有 H2 请求和文件候选读取完成。
 
 ## Bearer 鉴权
 
-配置 `secret` 后，每个请求都必须携带：
+配置非空 `secret` 后，除上述 CORS 预检外每个请求都必须携带：
 
 ```http
 Authorization: Bearer vole-runtime-secret
@@ -30,8 +86,14 @@ Authorization: Bearer vole-runtime-secret
 - scheme 必须精确为 `Bearer`，token 必须与当前 session 配置完全一致；
 - 缺失、重复、格式错误或不匹配都返回 `401 Unauthorized`；
 - 比较过程不能通过日志、响应或明显的提前返回时序泄漏 token；
-- 未配置 `secret` 时不要求 `Authorization`；Controller 不使用 HTTP Basic，顶层 `authentication` 只属于 HTTP/SOCKS5 业务代理。
-- `allow-lan` 只控制业务代理监听，不改变 Controller 的回环限制或 Bearer 鉴权。
+- 省略或空串 `secret` 时不要求 `Authorization`；Controller 不使用 HTTP Basic，顶层 `authentication` 只属于 HTTP/SOCKS5 业务代理。
+- `allow-lan` 只控制业务代理监听，不改变 Controller 的监听地址或 Bearer 鉴权。
+
+WebSocket 浏览器可在下述四个升级路径使用唯一的 `token` query；非空 secret 时 token 优先于 Authorization。缺失 token 则沿用相同 Bearer 校验。重复 token 返回 400，错误 token 返回 401；普通 REST 不接受 token 替代 Bearer。token 不进入日志。
+
+## `GET /version`
+
+返回 `{"meta":false,"version":"..."}`。version 是当前 Vole crate 版本，meta 为 false；该接口不宣称自身为 Mihomo，也不增加 Invoke/Windows 协商字段。
 
 ## `GET /traffic`
 
@@ -55,13 +117,13 @@ Authorization: Bearer vole-runtime-secret
 
 Apple utun 的四字节包信息头不计入统计。统计只覆盖跨过 TUN L3 边界的包，包括 TUN DNS 和 ICMP；不重复计算 TLS、XHTTP 或其他代理封装，也不包含 HTTP/SOCKS5 代理入站、GeoData 下载、Controller 请求和 `measureDelay`。
 
-请求不会等待下一次采样，不保持分块响应，不升级 WebSocket，也不为调用方保存“上次读取”状态。首个采样窗口完成前和空闲窗口内，`up`/`down` 为 0；累计值在同一 session 内单调不减并采用饱和语义。没有 TUN 的代理组 Controller 对该路由返回 `404 Not Found`。
+普通 GET 不会等待下一次采样，不保持分块响应，也不为调用方保存“上次读取”状态；升级订阅见下文。首个采样窗口完成前和空闲窗口内，`up`/`down` 为 0；累计值在同一 session 内单调不减并采用饱和语义。没有 TUN 的代理组 Controller 对该路由返回 `404 Not Found`。
 
 TUN 按最多 8 包中有效消费／平台报告成功的包合并记账，取消或错误不会遗漏已经完成的前缀。批次恰好跨越一秒采样边界时，该批字节统一归入记账时的窗口，累计值不受影响；流量快照不是逐包时间戳统计。
 
 ## 代理组查询
 
-`GET /group` 按 YAML 声明顺序返回全部代理组：
+`GET /group` 按 YAML 声明顺序返回代理组，并在末尾包含自动生成的 `GLOBAL`（如未显式声明）：
 
 ```json
 {
@@ -83,11 +145,60 @@ GET /group/{name}
 GET /proxies/{name}
 ```
 
-- `name` 是组定义名，`type` 固定为 `Selector`；
+- `name` 是组定义名，`type` 分别为 `Selector`、`URLTest`、`Fallback` 或 `LoadBalance`；
 - `all` 是配置中的直接成员，严格保留顺序和重复项；
 - `now` 是当前选中的直接成员名。若该成员是嵌套组，`now` 仍返回组名，不展开为最终叶节点；
 - 名称和值大小写敏感并精确匹配，不做大小写折叠或 Unicode normalization。
 
+`GET /proxies` 返回以名称为键的 `proxies` 对象，包含组状态及节点的 `alive/history`。
+`GET /proxies/{name}` 也可查询节点。history 当前保留最近一次探测，delay 单位毫秒，
+time 为 Unix 秒；未探测节点初始 alive 为 true、history 为空。HTTP 健康状态不声明 UDP 可用性。
+
+load-balance 根据每条新连接的元数据选择成员，响应不含 `now`，不接受手动选择。业务 UDP 按目标会话固定出口。
+
+url-test/fallback 的手动选择在该成员健康时保持固定，失败后恢复自动选择。url-test 使用 tolerance 抑制小幅切换，fallback 按成员顺序选择与恢复。这两类组的 `fixed` 是固定成员名字符串；未固定为空串，select/load-balance 不返回该字段。
+
+`DELETE /proxies/{name}` 清除 url-test/fallback 的固定成员，使用已有健康结果重新进行自动选择，并按 profile 设置保存空选择；不主动探测、不改变现有业务路径。成功返回 204，未知名称 404，普通节点、select 或 load-balance 返回 400。
+
+## 主动探测与内存
+
+`GET /proxies/{name}/delay?url=https%3A%2F%2Fexample.com%2F&timeout=5000&expected=200-299`
+通过当前节点或代理组探测 URL，成功返回 `{"delay":12}`，单位毫秒。
+`GET /group/{name}/delay` 使用相同 query，返回成功成员的名称到毫秒映射，并清除自动组的手动固定选择。
+url-test 组采用配置中的测试 URL，其他组采用请求 URL。
+`timeout` 必须传入：节点路由为有符号 16 位毫秒，组路由为有符号 32 位毫秒；非正数立即到期。
+`expected` 可省略，或使用现有状态范围语法。未知目标返回 404，无效请求 400，探测超时 504，节点失败或零 delay 503。
+HTTP 响应完成时即返回延迟，即使状态不符合 `expected`；该 URL 的健康记录会记为失败。
+节点的一般存活状态记录传输是否完成，与配置 URL 的健康状态分开。
+
+`GET /providers/proxies/{name}/healthcheck` 使用 Provider 已配置的健康 URL、timeout 和 expected-status，
+完成后返回 204；单个成员失败写入共享健康状态，不使整个响应失败。探测使用当前资源代际、DNS 和出口，
+排除业务连接和流量统计，不触碰 lazy 活动时间。主动与自动探测共用每代际 10 个并发槽，停止取消所有等待。
+每个节点只保留一份最近手动结果；任意 URL 不增加无界历史。同 URL 的配置探测状态同步更新，供自动组选路使用。
+
+`GET /memory` 返回一次 `{"inuse":123456,"oslimit":null}` 快照：Linux/Android 读取自身 `/proc/self/status` 的 VmRSS，
+Apple 使用自身 Mach task resident size，Windows 使用当前进程 working set。单位均为字节；读取失败为 null。
+未获取进程内存上限，oslimit 为 null。普通 GET 不启动后台采样；不同平台口径不能直接横比。
+
+## WebSocket 订阅
+
+在 HTTP/1.1 上使用标准 WebSocket Upgrade；HTTPS 使用 H1 ALPN，现有 H2 请求继续提供普通 REST，不启用扩展 CONNECT。认证和 CORS 复用同一请求处理链，升级响应含适用的 CORS 头。
+
+| 路径 | 消息内容 | 发送时机 |
+| --- | --- | --- |
+| `/traffic` | `up/down/upTotal/downTotal` | 每秒 |
+| `/memory` | 与普通 GET 相同的 `inuse/oslimit` | 每秒，直接读取真实值 |
+| `/connections` | 与普通 GET 相同的业务快照 | 立即一次，其后按 `interval` 毫秒；缺省 1000，内部接受 100–60000 |
+| `/logs` | `type/payload`，或 `format=structured` 时的 `time/level/message/fields` | 有日志时 |
+
+**WebSocket `/traffic` 使用业务 Registry 的应用负载字节**，与 `/connections` 累计值一致；速率是本订阅实际采样间隔内的字节/秒。普通 GET `/traffic` 仍是 TUN L3 包统计，两者不能混用。Provider 更新不重置业务累计值。
+
+`/logs?level=info` 支持 debug/info/warning/error/silent，缺省 info，并受当前运行时 log-level 过滤，debug 同时接收 tracing 的 TRACE 事件。结构化 time 为 UTC 时分秒，warning 转为 warn。日志总线属于当前运行时，独立于宿主 tracing subscriber；完整保留已生成事件的 target、message 和所有字段，包括字符串、错误和 Debug 值，不按敏感字段脱敏或截断内容。它不提供历史回放。
+
+HTTP/HTTPS 合计最多 4 个订阅，仍占用既有 8 条连接名额。每条输出消息最多 256 KiB，序列化扩容前检查；connections 订阅至多捕获 512 条引用，超预算关闭当前订阅，普通 REST 快照保持完整。接收缓冲/消息/帧各限 1 KiB，业务 Text/Binary 不作为 Controller 命令；Ping/Pong/Close 按协议处理。写入和控制帧 flush 最多 5 秒，慢客户端只保留当前发送消息，不排队后续快照。
+
+日志环仅在有订阅时创建，保留 64 条共享事件，不另设每秒条数限制；队列过载时慢订阅者会落后，最后订阅离开释放历史缓冲。WebSocket 仍受上述消息大小和写入期限约束，超出消息预算时关闭订阅，不发送被截断的事件。无订阅时不格式化日志，也不运行周期采样或日志轮询。Stop 取消并 join 当前连接任务，释放订阅许可与日志接收器。
+
 ## `PUT /proxies/{name}`
 
 切换组的当前直接成员：
@@ -115,43 +226,166 @@ Content-Length: 26
 
 ## 名称与路径
 
-节点和代理组定义名共享一个命名空间。名称必须为 1–64 UTF-8 字节，首尾不能是任何 Unicode 空白字符，不能含控制字符或 `, # / ? & = % \\`，也不能是 `.` 或 `..`。定义名额外保留 `DIRECT`、`REJECT` 和 `RULES`；前两者仍可作为组成员，`RULES` 只作为 DNS sentinel。内部普通空格、CJK 和 emoji 可以使用。
+节点和代理组定义名共享一个大小写敏感的命名空间，名称为非空 UTF-8 字符串。保留定义名为 `DIRECT`、`REJECT`、`REJECT-DROP`、`COMPATIBLE`、`PASS` 和 `PASS-RULE`；其中 DIRECT/COMPATIBLE 直连，REJECT/REJECT-DROP 按对应拒绝语义执行，PASS/PASS-RULE 属于规则控制。
 
-路径中的 `{name}` 必须是单个 segment。Controller 对 percent-encoding 严格解码一次，再执行相同的 UTF-8 和名称校验；无效 `%`、无效 UTF-8、解码后的 `/`、二次编码形式、query 和 fragment 都会失败。客户端应对非 ASCII 或路径保留字节执行一次标准 percent-encoding；`+` 不会被当作空格。
+路径中的 `{name}` 对 percent-encoding 严格解码一次；原始路径分隔符、无效 `%` 和无效 UTF-8 会失败。名称中的 `/`、`?`、`#`、`%` 等字符应 percent-encode；`%252F` 表示字面名称 `%2F`，不会再次解码。`+` 保留为 `+`。请求总大小仍受 HTTP 边界约束。
 
 ## 选择生效边界
 
-代理组成员列表在配置期固定，只有当前选择可在 Running Session 内改变：
+静态成员来自配置，动态成员随 provider 成功更新；Controller 读取当前可用的成员和选择：
 
 - 新建的物理 TCP 连接使用切换后的当前叶节点；既有 TCP 连接保持原路径；
-- 新建的 UDP association/物理 transport 使用切换后的当前叶节点；既有 association 不迁移；
+- 新建 UDP 目标会话使用切换后的当前叶节点；既有目标会话不迁移；
 - 新建的 DNS transport 使用切换后的当前叶节点；DNS cache、singleflight 状态和已在池中的 TCP transport 不清空、不迁移；
-- 切换不主动断开连接、不刷新缓存、不重启运行时，也不修改 YAML 或下一次 session 的默认值；
-- 选中节点、`DIRECT` 或 `REJECT` 时按原样执行；选中嵌套组时继续解析其当前成员。失败按原样返回，不自动选择其他成员。
+- 切换不主动断开连接、不刷新缓存、不重启运行时，也不修改 YAML；可按 profile 配置保存选择；
+- 选中节点、`DIRECT` 或 `REJECT` 时按原样执行；选中嵌套组时继续解析其当前成员。select 的失败按原样返回；自动组根据探测结果选择后续连接的成员。
 
-`dialer-proxy` 与规则、DNS 共享同一组选择，但经共享连接器直接建链，不重新执行业务规则。上游组的 `DIRECT` 连接当前节点预解析的服务器，`REJECT` 使建链失败。单次建链对同一组只读取一次选择，SOCKS5 UDP 的控制连接和 relay 路径共享该快照；不同组之间不提供原子快照。已经读取旧选择的在途握手继续原路径。复用旧 AnyTLS 会话的新业务流也保留原路径，只有真正新建底层 transport 才读取新选择。
+`dialer-proxy` 与规则、DNS 共享同一组选择，但经共享连接器直接建链，不重新执行业务规则。上游组的 `DIRECT` 连接当前节点按需解析的服务器，`REJECT` 使建链失败。单次建链对同一组只读取一次选择，SOCKS5 UDP 的控制连接和 relay 路径共享该快照；不同组之间不提供原子快照。已经读取旧选择的在途握手继续原路径。复用旧 AnyTLS 会话的新业务流也保留原路径，只有真正新建底层 transport 才读取新选择。
 
 Hysteria2 已认证 QUIC 会话也保留其 `dialer-proxy` 上游组快照，包括复用该会话的新业务流和端口跳跃所需的新物理 socket；这些不是新的认证会话，不能因切组而迁移原路径。只有重新建立的认证会话才读取新的上游组选择。节点本身作为路由组成员时，后续业务的路由选节点仍按当前组选择执行。
 
+## Provider 资源
+
+`GET /providers/proxies` 与 `GET /providers/rules` 返回 `{"providers":{"name":{...}}}`；
+`GET /providers/{proxies|rules}/{name}` 查询单个资源，`PUT` 同一路径主动刷新，成功返回 204。
+配置缺失返回 404，下载、解析或候选校验失败返回 503，旧资源继续服务。
+
+状态包含 `name/type/vehicleType`、`available`、`downloaded`、`updating`、`updatedAt`、
+`count` 与脱敏的 `error`。`updatedAt` 为 Unix 秒，未成功获取时为空；inline 或 bundled payload
+可以在未下载时可用。响应不包含订阅 URL、认证头或节点凭据。
+
+HTTP proxy provider 收到 `Subscription-Userinfo` 后另含 `subscriptionInfo` 对象，
+字段为 `Upload`、`Download`、`Total`、`Expire`，均为有符号整数；前三项为订阅字节数，
+Expire 为 Unix 秒。未知时省略该对象，缺失子项为 0；不以本地业务流量代替订阅信息。
+数值接受十进制整数、有限小数和科学计数法，小数向零截断；非法或超范围子项忽略。
+成功候选或合法 304 才更新元信息；未带该头时保留旧值，失败更新保留已发布对象。
+缓存恢复只接受与精确 URL、实际请求 header/UA 的摘要及内容 hash 一致的元信息。
+
+更新将节点、组和规则作为完整候选检查，发布时保留仍存在的当前选择。
+既有会话持有旧资源，最后一个使用者释放后回收；下载通过当前可用的运行配置建立出口，
+不等待候选资源。空动态组使用配置的 `empty-fallback`，默认 COMPATIBLE（直连）。
+组响应另含 `hidden` 与 `icon`，`disable-udp` 会拒绝该组的业务 UDP。
+
+## 业务连接和诊断
+
+`GET /connections` 返回 Mihomo 对应字段 `uploadTotal`、`downloadTotal`、`connections`、
+`memory`。业务连接包含 `id`、`metadata`、`upload`、`download`、`start`、`chains`、
+`providerChains`、`rule`、`rulePayload`。时间使用 RFC 3339；端口为字符串。
+
+- 只统计 TUN、HTTP、SOCKS5 的业务 TCP/UDP 负载，排除 TUN DNS 拦截、ICMP、Controller、
+  Core 资源下载和健康探测。累计值在本次 Running Session 内保留，provider 更新不会重置。
+- TCP 为一条业务流，UDP 为同一来源与目标的会话；各目标独立计数、取消并固定所选出口。
+  XUDP 对同一来源、同一具体节点和未改写的 IP 目标共享物理关联，其它路径保留独立 transport。
+  任一目标退出后，该共享关联仅服务既有目标；新目标使用新关联，避免旧回复串入新会话。
+  会话超时、关闭或新的 QUIC flow-id 后重新选择出口。资源代际不会迁移既有会话。
+- `chains` 按叶节点到业务路由组排列；当前不展开节点内部的 `dialer-proxy` 协议链。
+  `providerChains` 给出这些节点关联的 provider 名称，可与 provider 状态中的脱敏 `error` 对照。
+- `metadata` 提供来源、目标、入口、协议、嗅探域名与 `dnsMode`；`uid`、`process`、
+  `processPath` 来自本次业务选路实际取得的本机身份，未知分别为 0、空串、空串。
+  Controller 查询不追加身份查询，是否获取沿 `find-process-mode`；不查询 ASN。
+  扩展字段 `dnsPath` 是当前建链任务实际经过的有界 DNS 阶段标签，例如缓存、policy、
+  fallback、fake-IP 与解析角色；不包含上游地址、URL 或认证头。
+- 扩展字段 `errors` 最多保留最近 32 次建链/数据报失败的连接信息与固定错误码，
+  不返回底层错误原文。`memory` 是本次请求采集的当前进程 resident bytes，不可用时为 null。
+
+连接元数据保存原生地址、端口和时间，重复的节点、组及规则文本共享存储。
+查询只在短锁内取得连接引用，再固定计数和 DNS 路径并直接序列化；快照不保活
+业务 I/O 或资源代际。字节计数即时饱和累计，零字节 I/O 不更新计数。
+
+入站首次改写前保存不可变原目标、真实 socket tuple、入口及认证身份；嗅探、DNS、
+上游代理链不会覆盖它。Controller 沿现有字段展示有效目标；有效目标仍是未解析域名时，
+`destinationIP` 可取保存的原 IP。TCP 身份核查使用实际入站 socket，HTTP CONNECT 的
+业务目标不冒充入站 socket 的本地端点；UDP 身份按当前目标流获取，不按数据包建快照。
+未启用 Controller 的 mixed UDP 保留原有逐包选路；其进程查询按该次决策执行，
+原始事实使用栈值，不逐包分配共享快照。TUN 与 Controller 管理的 UDP 流沿现有流缓存。
+
+`DELETE /connections/{id}` 取消指定连接，`DELETE /connections` 取消当前全部连接。
+均返回 204，未知 ID 同样返回 204；取消唤醒正在等待的 I/O 并释放对应流资源。
+这不禁止用户重新建连，也不重置累计流量。正常 stop 会取消全部连接并沿既有停止屏障回收。
+
+`GET /rules` 返回 `rules` 数组，包括规则索引、类型、payload、目标及命中次数和最后命中时间。
+只列出主规则。普通 SUB-RULE 命中归入主调用行；rematch 选中的独立子列表没有主规则索引，
+不增加任意主行的命中计数，其业务连接的 rule/rulePayload 为空。返回主列表后按实际命中行记录。
+计数属于当前资源代际，只记录业务的新选路，不将每个 UDP 包重复计为一次选路。
+没有采集未命中次数、GeoData 记录大小；`size` 为 -1。规则列表反映当前有效路由模式，
+`extra.disabled` 来自与实际路由共用的一份临时开关快照。
+
+`PATCH /rules/disable` 接受 JSON 索引到布尔值对象，例如 `{"0":true,"2":false}`。
+`true` 跳过该主规则，`false` 恢复；跳过 SUB-RULE 入口时不会进入其子规则。
+请求要求唯一 `Content-Length` 和严格 `application/json`，正文最多 1 KiB，不接受 chunked。
+索引必须是当前列表范围内的非负整数，值只能是 bool；重复索引、未知索引、非法 JSON 或多份 JSON
+使整请求返回 400，任何规则都不改变。空对象返回 204。有效请求一次原子发布，成功返回 204。
+并发请求在提交时合并到当时的开关状态，不丢失其他索引已经成功提交的改动；同一索引以最后提交为准。
+新选路取得一个快照，后续 DNS／进程惰性查询继续沿用该快照；已建立 TCP 和 UDP 会话保留原路径。
+
+临时开关不修改 YAML，也不持久化。任何新规则程序编译与资源代际发布（含 provider 更新或配置替换）
+都清除临时开关，失败候选保留原状态。请求只在一个当前快照内校验并应用；接口没有 generation 字段，
+旧列表中的数字索引在重载后不保证仍表示同一规则，调用方应在资源变更后重新获取列表。
+开关使用不可变紧凑位集，最多 8 KiB 位数据，首次实际禁用时才分配；诊断只共享开关状态，不保活整个程序。
+
+`GET /configs` 返回归一化后的运行设置：mixed 入口、mode、log-level、IPv6、sniffing、
+连接选项、profile 和 TUN 字段。它使用字段白名单，不提供完整 YAML、节点凭据、订阅位置、
+认证头、Controller secret 或认证用户列表。在线修改使用下文的
+[`PATCH /configs`、`PUT /configs`](#patch-configsput-configs)，受候选准入与需重连条件限制。
+
+`GET /dns/query?name=example.com&type=A` 使用当前上游 resolver 与相同缓存查询，
+接受 Mihomo Controller DNS 类型表的精确名称，包括 A、AAAA、TXT、MX、SRV、HTTPS、SVCB 和 DNSSEC 类型；
+类型名称区分大小写，省略或空 type 使用 A，不接受数字或 `TYPE1234` 形式。重复、未知 query 参数返回 400。
+响应保留 `Status/Question/Answer/TC/RD/RA/AD/CD` 和扩展 `QueryPath`，非空的权威与附加段另含
+`Authority/Additional`。每条记录提供 `name/type/TTL/data`，名称包含末尾点，TTL 使用本次响应的实际值，
+RDATA 使用 DNS 展示格式；未知记录使用 RFC 3597 十六进制形式。Answer 保持数组，空权威与附加段省略。
+与 Mihomo 一样，此诊断接口跳过入口的 hosts、fake-IP 与 IPv6 响应过滤，返回上游真实答案；
+policy 与 fallback 仍生效。展示借用现有最多 4096 字节 wire 响应，不建立后台记录树或查询日志，
+JSON 转义和名称展开后的正文最多 256 KiB。DNS 关闭、查询失败、无效或截断的 wire 响应、输出超限返回 500，
+不以部分记录或伪造 TC 标记返回成功；该展示层不另加记录数量限制，上游仍沿用 DNS 解析预算。
+
+这些接口复用 Controller 的 Bearer 鉴权。目标与 DNS 路径只通过显式查询返回，
+不会写入普通日志。`/connections` 与 WebSocket `/traffic` 是业务负载统计，普通 GET `/traffic` 表示 TUN 原始 IP 包流量，
+`/proxies` 的节点健康数据继续表示探测结果，三者不可相互替代。
+
+`POST /cache/dns/flush` 清除当前资源代际所有 DNS 角色的普通地址、负响应、原始响应缓存和
+域名提示，成功返回 204；DNS 未启用时同样返回 204。旧在途查询可以完成，但不能回填
+清理后的缓存，新查询不会复用这些旧查询。fake-IP 映射和活动业务会话保留。
+
 ## HTTP 状态与协议边界
 
 | 状态 | 含义 |
 | --- | --- |
 | `200 OK` | 查询成功，返回 `application/json` |
-| `204 No Content` | 选择成功，正文为空 |
-| `400 Bad Request` | 路径、JSON、长度格式或成员无效 |
+| `204 No Content` | 选择、规则开关、配置应用、刷新或清理成功，正文为空 |
+| `400 Bad Request` | 路径、JSON、长度格式、成员或候选配置无效 |
 | `401 Unauthorized` | Bearer 鉴权失败 |
-| `403 Forbidden` | 请求来源不是回环地址 |
-| `404 Not Found` | 路由、组或当前 session 中的 TUN 流量资源不存在 |
+| `404 Not Found` | 路由、组、当前 session 的 TUN 流量或配置应用资源不存在 |
 | `405 Method Not Allowed` | 路由存在但方法不允许 |
 | `408 Request Timeout` | header 或 body 读取超时 |
-| `411 Length Required` | PUT 缺少 `Content-Length` |
-| `413 Payload Too Large` | PUT 正文超过 1 KiB |
-| `415 Unsupported Media Type` | PUT 不是严格 `application/json` |
+| `409 Conflict` | 在线配置修改涉及需重连的启动资源 |
+| `411 Length Required` | 管理写请求缺少 `Content-Length` |
+| `413 Payload Too Large` | 管理写请求正文超过对应路径预算 |
+| `415 Unsupported Media Type` | 管理写请求不是严格 `application/json` |
+| `503 Service Unavailable` | 探测、资源更新或候选准备失败，订阅准入已满，配置应用忙碌或已停止 |
+| `504 Gateway Timeout` | 主动探测或配置应用等待超时 |
 
-第一版不提供 provider/`use`、health check、自动 failover、`url-test`/`fallback`/`load-balance`、delay 测试、连接管理、配置修改、WebSocket 推送、Controller 版本协商或完整 Dashboard response。除 `GET /traffic`、`GET /group`、`GET /group/{name}`、`GET /proxies/{name}` 和 `PUT /proxies/{name}` 外，其他路径和方法均不属于公共协议。
+公开范围为本文列出的版本、连接、规则、配置查询与在线应用、DNS、主动探测、内存、provider、代理组查询/选择/固定清除，以及四个 WebSocket 路径。它不承诺完整 Dashboard response；其他路径和方法不属于公共协议。
 
 Windows WinRT VPN 的完整运行时和 Controller 位于独立 Session Host；桌面 Wintun 的
-Controller 位于普通业务运行时。宿主通过回环 HTTP 直接访问实际 Running Session；
+Controller 位于普通业务运行时。宿主通过配置的 HTTP 地址直接访问实际 Running Session；
 组查询和切换不经过 `VoleInvoke`、Windows bridge 或 Provider 控制管道，
 不携带 `instanceId`，也不占用 Invoke 命令锁。
+
+
+## `PATCH /configs`、`PUT /configs`
+
+配置应用与 Invoke `updateConfig(configYaml)` 共用一个候选许可和运行时 worker，不更改持久 YAML。`Content-Type` 必须为 `application/json`，必须提供唯一有效的 `Content-Length`，不接受 chunked body。Bearer 与 CORS 沿用普通 REST 规则；无 query 参数。
+
+PATCH 仅接受 `mode`、`log-level`、`sniffing`、`tcp-concurrent`、`find-process-mode`、`interface-name`。`sniffing` 是 Mihomo Controller 的 API 字段，对应配置的 `sniffer.enable`；不向 YAML 增加同名旧字段。其余字段和值由严格配置解析器验证；未知字段失败。PUT 只接受 `{"payload":"完整 Mihomo YAML"}`，不接受任意本地路径。成功返回 204。
+
+候选基于新的本地可用 provider 内容完整构图后发布，HTTP provider 继续遵循既有本地缓存／bundle／后续更新语义，204 不表示所有远端订阅都已同步刷新。配置、图与 provider 模板一起替换；后续订阅更新使用新模板。坏配置保留活动代际；已建立业务保持其原代际，新连接取得新代际。可继承且仍存在的组选择保留。
+
+地址、监听／TUN、全局 IPv6、TLS 根与 Controller 证书、安全配置、fake-IP 范围、profile 存储和系统网络相关启动资源需要宿主重新连接，在线更改返回 409。Linux 原生 auto-route 持有的物理出口隔离同样不在在线重建范围。在线 DNS 策略／hosts 改动在共享缓存 epoch 下清缓存与域名提示；退休 DNS 树继续服务其已持有业务，但不能重新填充活动域名提示。fake-IP 映射保持。
+
+许可在扩展请求 body 和解析前取得，忙时返回 503。解析错误返回 400，准备失败返回固定脱敏 503；应用等待上限 90 秒，超时返回 504，并取消候选。等待 future 被取消会取消候选；普通请求半关闭不代表取消。已开始的阻塞任务继续由 worker 等待收尾，并持有候选许可；返回错误或超时不承诺所有收尾已同步完成。Stop 关闭准入、取消候选并等待完整 worker 收尾。没有运行时资源的 Controller 返回 404。
+
+`POST /configs/geo` 强制检查当前所需的 GeoData，复用现有下载、ETag、校验和原子发布；
+不下载未被活动注册引用的资产。`POST /cache/fakeip/flush` 清除 DNS 结果及 fake-IP 前向分配绑定，
+保留反向映射和分配游标，已有地址仍受原池的容量与正常复用约束；持久化事务完成后才改内存。
+两者不接受正文，成功为 204；与配置应用共用单候选许可，Stop 等待已开始的文件事务和管理任务。
diff --git a/docs/geodata.md b/docs/geodata.md
index 8b71d18..259fed8 100644
--- a/docs/geodata.md
+++ b/docs/geodata.md
@@ -1,11 +1,17 @@
 # GeoData 规则与资产
 
-Vole 管理 `dataDir/geodata` 下的 `geosite.dat` 和 `geoip.dat`，只为当前配置实际引用的
-分类与属性交集构建匹配器。所有平台均不设 GeoData 条数上限，不按数量截断记录，
+Vole 管理 `dataDir/geodata` 下的 `geosite.dat`、DAT 模式的 `geoip.dat` 和独立 `ASN.mmdb`，
+国家 MMDB 位于 `dataDir` 根目录。`geodata-mode` 缺省为 false（MMDB），true 使用 DAT。
+只为当前配置实际引用的
+分类与属性交集构建匹配器。主规则和所有 `sub-rules` 定义中的谓词、逻辑子项及
+classical provider 内容共同收集引用；每个定义只遍历一次，不沿调用边展开。所有平台均不设 GeoData 条数上限，不按数量截断记录，
 也不设总内存预算。资产缺失或加载失败时，对应种类不可用，跳过相应 Geo 规则并继续
 普通选路；卸载前的下载或结构校验失败保留当前快照。配置、格式、整数表示和
 可恢复分配错误仍然失败关闭。
 
+分类加载与 CIDR 无损压缩完成后回收自有数组和字面值 arena 的扩容余量；保留全部
+记录、属性交集和正则。容量账本计入可能的旧、新缓冲重叠，实际 RSS 仍由 allocator 决定。
+
 ## 规则
 
 ```yaml
@@ -21,25 +27,33 @@ rules:
 
 ```text
 GEOSITE,[!]<code>[@<attribute>...],<target>
-GEOIP,[!]<code>,<target>[,no-resolve]
+GEOIP,[!]<code>,<target>[,no-resolve][,src]
+SRC-GEOIP,[!]<code>,<target>
+IP-ASN,<asn>,<target>[,no-resolve][,src]
+SRC-IP-ASN,<asn>,<target>
 ```
 
 - 规则类型和 `code` 不区分 ASCII 大小写，route target 名称大小写敏感并精确匹配。
-- `target` 只能是 `DIRECT`、`REJECT`、实际代理节点名或静态 `select` 组名。
+- `target` 可以是 `DIRECT`、`REJECT`、当前资源中的代理节点或已支持的代理组。
 - 基础 `code` 必须匹配 `[A-Za-z0-9][A-Za-z0-9._+!-]{0,63}`，按 ASCII 大小写折叠后定位。
-- `GEOSITE` 恰好三段；`GEOIP` 只允许可选且大小写敏感的 `no-resolve`。
+- `GEOSITE` 恰好三段；`GEOIP` 接受大小写敏感的 `no-resolve`、`src`，顺序无关。
+  `src` 和 `SRC-GEOIP` 使用真实来源 IP，不触发 DNS。
 - `GEOSITE,cn@ads@cn,DIRECT` 只保留同时存在 `ads` 和 `cn` 属性 key 的记录，多个属性为 AND。
   属性只检查 key 存在，不解释 bool/int 值；`false`、`0` 或无 typed value 均不代表 key 缺失。
 - 属性名按 Mihomo 的先小写、后 Unicode simple-fold 比较语义归一；交集顺序与重复 key 不改变
   结果。空 `@` 项忽略，非空属性首尾空白移除，但内部空白、控制字符和逗号不允许。
 - 前置 `!` 对整个正向匹配结果取反：`!cn@ads` 是 NOT(匹配 `cn@ads`)，不是“没有 ads 的记录”。
   `cn@!ads` 查找字面 key `!ads`；`geolocation-!cn` 是字面分类名。
-- GeoIP 支持前置 `!`，不支持属性。业务规则不支持单条多个 code、源地址 GeoIP 或隐式局域网分类。
-- 规则按顺序首条命中，最终 `MATCH` 必须指向实际代理节点或代理组。
+- GeoIP 支持前置 `!`，不支持属性或单条多个 code。`lan` 是内置分类：私有、未指定、
+  回环、多播与链路本地单播地址；来源与目标均可使用，不读取 GeoIP 资产。
+- `IP-ASN` 的 payload 逐字匹配 ASN 十进制值，不转换 `AS` 前缀或补零；
+  `src` 和 `SRC-IP-ASN` 使用实际来源 IP，不触发 DNS。不可用的 ASN 不触发惰性 DNS。
+- rule 模式按顺序首条命中，未命中 DIRECT；可选的 `MATCH` 使用 `DIRECT`、`REJECT`、实际代理节点或代理组。
 
 DNS `nameserver-policy` 中的 `geosite:<selector>[,<selector>...]` 接受相同的属性与反选语义，
 逗号连接的 selector 为 OR。业务规则与 DNS policy 共享基础分类、value arena 与正则，
 每个基础分类只解码一次；不同属性交集保留各自匹配索引，正反选不复制记录。
+普通域名与通配域名 policy 不加载 GeoData，其匹配顺序见 [DNS Policy](tun-icmp-dns.md#policy)。
 
 存在分类但属性筛选为空时，该 selector 仍可用：正选不匹配，反选匹配所有合法非空域名。
 分类缺失、资产不可用或未声明的 selector 不能通过反选变成全匹配；没有域名时所有 GeoSite
@@ -48,59 +62,120 @@ Unicode 版本的 Mihomo 在所有新字符上完全等价。
 
 ## 资产格式
 
+默认资产和统一验证来源采用 [MetaCubeX/meta-rules-dat 官方完整资产](https://github.com/MetaCubeX/meta-rules-dat#readme)，
+保留原始文件，仅按配置引用加载分类。
+
 | 规则 | 文件 | 顶层消息 | 内容 |
 | --- | --- | --- | --- |
 | `GEOSITE` | `geosite.dat` | `GeoSiteList` | code 与 Domain 记录 |
 | `GEOIP` | `geoip.dat` | `GeoIPList` | code 与 IPv4/IPv6 CIDR |
-
-- 文件路径固定，YAML 不能指定本地路径或环境变量。
-- 文件必须是普通文件；校验外层帧、code、分类引用、实际选中的 CIDR / Domain 记录。
-- 第一遍扫描建立 code 到文件范围的索引，容量按需增长；第二遍只解析被配置引用的分类。
+| `GEOIP`（默认模式） | 根目录 `country.mmdb`、`geoip.db` 或 `geoip.metadb` | MaxMind DB | 直接 IPv4/IPv6 国家/分类索引查询 |
+| `IP-ASN` / `SRC-IP-ASN` | 上游 `GeoLite2-ASN.mmdb`，管理名 `ASN.mmdb` | MaxMind DB | IPv4/IPv6 ASN 索引 |
+| `RULE-SET` | `*.mrs` | Zstd 压缩的 MRSv1 | `domain` / `ipcidr` rule provider，与 GeoData 分别配置 |
+
+增强 GeoSite 仍使用相同的 DAT 格式，支持四种 Domain 类型与属性标签，不按提供方区别加载。
+MRS 不能直接替代 GeoSite/GeoIP 资产；sing-box 的 `geosite.db` 与 SRS 不是 Mihomo 的 GeoSite 输入格式。
+
+- GeoData 的 YAML 字段不能指定本地路径或环境变量。MMDB 在 `dataDir` 的直接子文件中按文件名字典序，
+  不区分大小写寻找 `Country.mmdb`、`geoip.db`、`geoip.metadb`，选择第一个并保留实际名称；
+  不因它损坏而改选另一个数据库。缺省下载目标为 `geoip.metadb`。
+- 所有资产必须是普通文件；DAT 校验外层帧、code、分类引用、实际选中的 CIDR / Domain 记录。
+- DAT 第一遍扫描建立 code 到文件范围的索引，容量按需增长；第二遍只解析被配置引用的分类。
 - 只引用属性交集时，先流式检查属性；未命中任何交集的记录按 wire/length 边界跳过，
   不校验 value 或编译 Regex。引用无属性 selector 时则包含该分类的全部记录。
-- 目标 code 缺失、重复或损坏时，整份对应种类的快照不可用，不能当作空分类。
-- GeoSite 和 GeoIP 分别校验和报告可用性，一类不可用不影响基础规则。
+- DAT 目标 code 缺失、重复或损坏时，整份对应种类的快照不可用，不能当作空分类。
+- GeoSite、GeoIP 和 ASN 分别校验和报告可用性，一类不可用不影响其他种类或基础规则。
+
+## 国家 MMDB
+
+国家库支持 MaxMind `country.iso_code`、`sing-geoip` 根字符串和 `Meta-geoip0` 根字符串/字符串数组。
+`.db`、`.metadb` 和 `.mmdb` 是文件命名；实际 schema 由 MMDB metadata 识别，不使用 SQLite。
+MaxMind 国家代码按 ASCII 大小写折叠，sing/Meta 保留原字符串大小写。国家库与 DAT 二选一，
+GEOIP、来源规则、classical/地址选择器及 DNS fallback 共用一个国家库快照。
+MaxMind/sing 使用 owned Reader，查询借用字符串。Meta 完整校验后优先将配置引用的
+分类投影为与 DAT 共用的紧凑 CIDR，正反选择器共享分类，保留多 code、IPv4/IPv6、
+别名地址及无记录地址的语义；构建完成后释放原始文件缓冲，磁盘资产保持原样。
+投影不更省内存、遍历不适合或记录无法按 Meta schema 解码时，保留原 Reader，
+不截断记录或拒绝原本可用的库。Reader 路径的多 code 临时索引只保存字符串引用。
+不建立逐地址缓存。缺库、坏索引和无效记录
+不通过反选成为全匹配；有效库的无记录地址按空 code 集合处理。
+保留 maxminddb 的默认单次解码与索引验证保护；解码错误不当作合法的空记录。
+官方 `sing-geoip` / `Meta-geoip0` 的空 description 可加载：只在元数据图已完整验证且
+唯一错误为描述为空时，以临时描述完成原库的全部索引与数据校验，再恢复原字节和元数据。
+此兼容不改写磁盘资产，不放宽指针、separator 或数据图验证。
+
+国家 MMDB 更新与 ASN 同样先借用候选字节完整校验，旧读者排空后构建国家库表示，
+或将同一缓冲移动到 owned Reader；
+无效候选、取消或提交失败保留/恢复旧代。模式和实际文件名共同绑定调度来源与 ETag/hash，
+下载暂存及原子替换始终使用被选中的实际路径，GeoSite/ASN 的存储与状态目录不变。
+
+## ASN MMDB
+
+仅在规则或 classical 内容引用 ASN 时读取 `ASN.mmdb`。支持数据库类型
+`GeoLite2-ASN`、`DBIP-ASN-Lite (compat=GeoLite2-ASN)` 和
+`ipinfo generic_asn_free.mmdb`；前两者读取 `autonomous_system_number`，后者读取
+`asn` 并移除其 `AS` 前缀。合法的数值型数据库无记录时按 ASN `0` 匹配；数据库
+不可用、索引错误或记录字段无效不会被当作 ASN `0`。IPinfo 无记录不匹配。
+
+使用一个拥有文件字节的 MMDB Reader，直接查询 IPv4/IPv6 索引，不展开 CIDR，也不
+建立按地址增长的缓存。查询只解码所需字段，不复制完整记录。ASN 与目标 GEOIP 共用
+既有惰性 DNS 路径；`no-resolve` 不主动解析，但可使用先前规则已解析的地址。
+
+更新先以唯一候选字节缓冲构造借用 Reader，完整校验 metadata、树、separator 和
+数据图；校验失败时保留当前内存与磁盘代次。校验期间旧文件字节与候选字节必然重叠，
+验证还会临时分配第三方 metadata 和图检查状态。借用 Reader 释放后，暂停新快照读取、
+等待旧读者结束；超时或取消时恢复旧快照。旧存储析构后才将同一候选缓冲移入 owned
+Reader，重建 metadata，避免另一份全量候选复制。
+
+ASN 提交保留旧磁盘文件的 hard link（不可用时复制）；提交失败先丢弃候选内存，再
+恢复旧稳定文件和调度状态并重新加载旧匹配器。恢复磁盘或状态遇真实 I/O 错误时报告
+该错误；不能恢复旧文件时 ASN 降级，其他健康种类继续可用。停止仍等待管理任务完成。
+普通 DAT 更新与外部重载保留后文的独立降级契约。
 
 ## 自动更新
 
-更新配置必须整体出现或整体省略：
+HTTP 传输由共享资源模块维护，所有跳转经过当前 Core dispatcher。下载、管理阻塞任务和解析均在停止屏障内；取消及下载 future 被丢弃时清理未发布的暂存文件。
+
+四个 URL 字段独立可选。缺省使用 MetaCubeX meta-rules-dat 的 latest GeoIP/GeoSite DAT、
+国家 `geoip.metadb` 与
+`GeoLite2-ASN.mmdb` URL；自动更新默认关闭，周期默认 24 小时：
 
 ```yaml
+geodata-mode: true # DAT；省略或 false 使用国家 MMDB
 geox-url:
   geoip: https://assets.example.com/geoip.dat
+  mmdb: https://assets.example.com/geoip.metadb
   geosite: https://assets.example.com/geosite.dat
+  asn: https://assets.example.com/ASN.mmdb
 geo-auto-update: true
 geo-update-interval: 24
 ```
 
 约束：
 
-- `geox-url` 只能包含 `geoip` 和 `geosite`；URL 必须是以域名为主机、无 userinfo/fragment 的绝对 HTTPS URL。
-- `geo-update-interval` 只接受整数 `24`。
-- `validateConfig` 和 `prepare` 不下载。实例启动后，只有自动更新已开启且规则实际需要资产时才运行更新任务。
-- 下载固定使用最终 `MATCH` route target。若它是代理组，每次新建下载物理 transport 时沿嵌套组解析到当时选中的具体节点、`DIRECT` 或 `REJECT`；失败不自动换成员，也不隐式回退 DIRECT 或系统代理。
-- 缺失资产立即检查；失败后按 1 分钟、5 分钟、15 分钟、1 小时退避，之后保持 1 小时上限。成功后恢复 24 小时周期。
-- ETag、SHA-256、源 URL 和下次检查时间保存在 Vole 管理的状态中。合法 304 在匹配器
+- `geox-url` 只能包含 `geoip`、`mmdb`、`geosite` 和 `asn`；URL 必须是以域名为主机、无 fragment 的绝对 HTTPS URL。
+  URL userinfo 按百分号编码解码后用于 HTTP Basic，不进入 Host、请求路径或日志；跨 origin 跳转不转发原认证。
+- `geo-update-interval` 单位为小时，支持非负整数；0 停用周期更新。
+- `validateConfig` 和准备阶段不下载。运行后仅为当前引用的资产启动资源任务；缺失或不可用时获取默认或配置的 URL，自动更新控制可用资产的周期检查。
+- 下载按当前 mode 与业务规则选路，未命中使用 DIRECT；可选目标包含内置动作、节点和代理组。选中代理组时，每次新建下载物理 transport 时沿嵌套组解析到当时选中的叶节点；失败不自动换成员，也不隐式回退 DIRECT 或系统代理。
+- 缺失资产立即检查；失败后按 1 分钟、5 分钟、15 分钟、1 小时退避，之后保持 1 小时上限。成功后恢复配置的更新周期。
+- `global-ua` 控制资源请求的 User-Agent，默认 `Vole/` 加 Core 版本；`etag-support` 默认 true，false 时不发送条件请求。ETag、SHA-256、精确来源 URL 的摘要、脱敏 origin 和下次检查时间保存在 Vole 管理的状态中。
+  身份摘要包含认证和 query，改变来源不会复用另一份凭据的 ETag。旧无凭据来源可导出摘要；旧带凭据元数据不授权 304。
+  合法 304 在匹配器
   已可用时只推进调度；有必需种类不可用时，先按相同重载流程从本地资产恢复匹配器。
-- 下载以固定大小缓冲流式写入同目录暂存文件，不限制资产总字节；保留 90 秒期限、取消、HTTPS/HTTP 解析边界和字节计数溢出检查。流式落盘期间保留当前快照；文件大小、wire 结构和 staging 检查通过后，先卸载并排空旧匹配器，再构建候选。分类需求校验成功后原子替换文件，SHA-256 随状态保存；失败保留上一份磁盘资产，不保证恢复旧内存快照。
+- 下载以固定大小缓冲流式写入同目录暂存文件，自动解压 gzip 并校验完整性；SHA-256 与字节计数针对解压内容，不限制资产总字节。
+  保留 90 秒期限、取消、HTTPS/HTTP 解析边界和字节计数溢出检查。流式落盘期间保留当前快照；文件大小、wire 结构和 staging 检查通过后，先卸载并排空旧匹配器，再构建候选。分类需求校验成功后原子替换文件，SHA-256 随状态保存；失败保留上一份磁盘资产，不保证恢复旧内存快照。
 - 跨进程更新锁和原子重命名只保护共享数据目录，不提供多实例调度协议。
 
-隔离实验可显式编译独立、非默认 `benchmark-geodata-http` feature，使 GeoData 更新
-接受以域名为主机、无 userinfo/fragment 的 HTTP fixture；仍通过同一个 dispatcher 和
-流式下载器，不建立 TLS。HTTP 重定向可保持 HTTP 或升级到 HTTPS，HTTPS 不允许降级。
-该入口没有环境变量或新的 YAML/FFI 开关；未编译该 feature 时仍强制 HTTPS，HTTPS 的
-公开根和完整证书验证不变。平台构建及 delivery 拒绝该测试 feature。HTTP 实验只验收
-更新逻辑与资源占用，不构成生产 HTTPS 信任链验收，不应启用 `interop-test`。
-
 ## GeoSite 匹配
 
 TUN 的 IP 目标采用以下选路提示优先级：
 
 ```text
-嗅探域名 > TUN DNS 提示 > 无域名
+嗅探域名 > 原始/恢复的域名 > DNS 提示 > 无域名
 ```
 
-目标本来是域名时使用目标域名，不受提示覆盖。嗅探和 DNS 提示只参与选路，不改写
+DNS 提示只在目标缺少域名时使用；嗅探域名优先参与域名规则。启用嗅探的目标覆盖时替换
 实际出站目标。没有域名时，`GEOSITE` 不匹配，也不触发 DNS。
 
 运行时目标、嗅探和 DNS 提示的域名规范化（不是资产加载条件）：
@@ -148,6 +223,11 @@ Domain/Full 在加载时原地排序紧凑记录，运行时对完整名称及
 不再承诺 Regex 热路径无分配。Domain/Full 的紧凑无分配查找保持不变。
 库的局部保护不是全部正则合计内存或整进程峰值的上界。
 
+GeoSite 正则保持上述大小写敏感的 Go/RE2 类行为，不使用 `DOMAIN-REGEX` 的默认 IgnoreCase
+或复杂引擎。业务规则、DNS selector、fake-IP filter 与嗅探决策把其线性搜索计入同一
+sticky 执行预算；预算失败向调用者传播，不能通过反选变为命中或默认直连。此预算限制
+单次决策的执行工作，不限制 GeoData 记录数量、加载量或资产总内存。
+
 ## GeoIP 与 `no-resolve`
 
 - 目标已经是 IP 时直接匹配同地址族 CIDR，`no-resolve` 不改变结果。
@@ -155,7 +235,8 @@ Domain/Full 在加载时原地排序紧凑记录，运行时对完整名称及
 - 之后首条不带 `no-resolve` 的 IP 类规则最多触发一次运行时 DNS，结果只供当前和后续规则复用。
 - A 结果先于 AAAA；第一个命中 CIDR 的有效地址成为当前会话或数据报的固定目标。
 - `dns.ipv6: false` 时不请求或采用 AAAA。
-- 运行时 DNS 不可用或失败时继续下一条规则，不使用引导解析器替代。
+- 运行时 DNS 不可用或上游失败时继续下一条规则，不使用引导解析器替代；
+  规则执行预算、取消或引擎错误终止本次决策。
 - `GEOIP,!cn,...` 对同一次 CIDR 匹配结果取反，不执行反向 DNS。DAT 的 `reverse_match`
   字段按 Mihomo loader 行为接受但忽略；是否取反只由 selector 的前置 `!` 决定。
 
@@ -167,6 +248,7 @@ Domain/Full 在加载时原地排序紧凑记录，运行时对完整名称及
 - 更新在下载和 staging 检查期间继续使用当前快照。构建新匹配器前，原子发布空匹配器、
   释放 Manager 的旧快照引用，并等待最后一位旧选路读者完成、旧匹配器存储析构结束。
   此后只构建一次候选；磁盘与调度状态提交成功后直接原子发布，不从最终文件重复加载。
+  国家 MMDB 与 ASN 使用前文的完整预校验与失败恢复流程。
 - 注册、重载与更新提交通过 Manager 管理锁串行，避免旧重载覆盖新发布；业务和 DNS
   的 ArcSwap 读取不获取该锁，也不等待排空。旧读者继续完成本次求值；排空、加载期间
   新请求复用首次资产缺失的语义，仅跳过不可用的 Geo 规则，继续普通规则与既有 DNS
@@ -175,7 +257,7 @@ Domain/Full 在加载时原地排序紧凑记录，运行时对完整名称及
   取消不构建或发布新候选。后台状态观测、开始更新、提交和 304 恢复均移出业务 worker，
   Stop 取消后仍等待管理任务结束，不遗留后台发布。已开始的 CPU 加载不能中途强制
   中断；结束后检查取消并丢弃候选，因此 25 ms 不是完整 Stop 的耗时保证。
-- 重载按已注册的 selector 重建属性索引与匹配器，两类可用性独立。卸载后的所选记录
+- 重载按已注册的 selector 与 ASN 需求重建匹配器，三类可用性独立。卸载后的所选记录
   加载失败使对应种类保持不可用，仍发布另一类健康数据；不重新安装旧整体快照。
   更新候选无效时保留旧磁盘文件并记录失败，后续继续按现有调度重试。
 - 重载首次取消检查前先记录待重载状态。卸载前取消保留旧匹配器；即使新磁盘代次
@@ -183,7 +265,8 @@ Domain/Full 在加载时原地排序紧凑记录，运行时对完整名称及
   排空超时或卸载后取消保持空匹配器及待重载状态，自动更新关闭时亦可恢复。
   已发布的独立降级结果不标记为待重载，失败种类保持不可用，直到下一次明确重载或更新。
 - 新流使用当时的可用快照；已经完成的 TCP 选路和 TUN UDP 固定 action 不回溯。
-  当前完整重建所需两类数据，不跨代复用分类存储；排空防止两代 matcher 存储同时存活，
+  当前完整重建所需的各类数据，不跨代复用分类存储；排空防止两代 owned matcher 同时存活，
+  ASN 校验期的字节重叠见上文，
   不保证 allocator 立即归还 RSS，也不限制单代加载峰值。
 - 分类表在加载时按 code 排序，运行时大小写无关二分定位；规则仍按配置顺序首命中。
   每次业务选路捕获一份当前不可变快照，整次求值复用，不在每条 Geo 规则上重复读取 ArcSwap。
@@ -208,8 +291,8 @@ Domain/Full 在加载时原地排序紧凑记录，运行时对完整名称及
 
 所有平台均不设置 GeoData 原始记录、分类、唯一引用、累计 value/Regex 源码字节或
 资产文件大小的独立额度，也不设置 GeoData 总内存预算；不因数量静默截断或丢弃记录。
-DNS GeoSite policy 没有独立项数/引用数上限。普通 YAML 256 KiB、显式 rules 1,024 条/
-合计 128 KiB/单条 1 KiB 仍是配置入口边界，不是 DAT 内记录数限制。
+DNS GeoSite policy 没有独立项数/引用数上限。普通 YAML 8 MiB、显式 rules 65,536 条/
+合计 8 MiB/单条 16 KiB 仍是配置入口边界，不是 DAT 内记录数限制。
 
 基础分类、字面值和正则只存一份，属性交集使用共享 arena 的紧凑索引；多个交集仍会
 增加索引容量与加载成本，不能把共享存储理解为内存常量。保留 checked arithmetic、
@@ -221,19 +304,21 @@ fallible Vec 扩容、合法 protobuf 帧/长度、code、选中匹配值的 UTF
 
 容量账本仅作诊断：统计 Vole 自有 matcher/index/value/临时 Vec 的可见容量，扩容时
 记录新旧缓冲可能重叠的容量；没有最大值、不控制准入。`regex::bytes::Regex` 不提供
-完整内部状态的准确 `memory_usage`，所以账本**不包含正则内部编译状态、搜索缓存、
+完整内部状态的准确 `memory_usage`；国家/ASN 文件缓冲容量计入快照容量，借用候选
+验证期的新旧字节重叠、Meta 投影构建期间的源字节、Reader 路径的多 code 临时引用索引与
+MMDB metadata/图校验状态未计入。因此账本**不包含正则内部编译状态、搜索缓存、
 动态 scratch、配置需求集合、allocator 开销或整个进程 footprint**。这些未计入的
 内存并不是零；accounted peak 不能作为加载或运行期峰值上界。
-50,000,000 bytes 是限定输入与联合负载下的进程实测验收目标，不是加载器保证。
+进程 RSS 的硬上限与默认 1 / 2 Gbps 分档压力标准统一见[验收边界](acceptance.md#性能采纳标准)，
+它们是压力测试标准，不是加载器保证。
 
-互通和内存/吞吐压力由公开 [container-benchmark](https://github.com/YuanDevTeam/container-benchmark)
-维护；`interop`、`stress` 和 `compare` 以 `--source vole=PATH` 显式指定被测 checkout。
+互通和内存/吞吐压力由独立容器测试工具维护，结果与结论统一保存在 benchmark 工程；
+`interop`、`stress` 和 `compare` 以 `--source vole=PATH` 显式指定被测 checkout。
 Vole 自有脚本仅负责编译。压力与横向比较固定只引用完整 `geosite:cn` / `geoip:cn`，
-更新下载保留原始增强 DAT，但不因此加载其他分类。真实资产的类型分布、明确标识的四类型/复杂正则合成用例、
-属性/反选见证、加载与真实更新期间的峰值、联合吞吐/DNS/RSS 结果以 benchmark 的本轮文字结论为准。
-历史 Domain/Full 子集或单纯离线加载不能替代完整真实资产的 fd-TUN 压力，也不能证明
-任意正则的加载峰值。Linux RSS 不替代 Apple Network Extension physical footprint；
-少量转发见证不等同逐条规则语义穷举。
+更新下载保留原始增强 DAT，但不因此加载其他分类。加载峰值、热更新覆盖范围与
+联合吞吐/DNS/RSS 以 benchmark 工程的实际记录为准。
+合成回归和离线加载不替代完整真实资产的 TUN 压力，少量转发不等同逐条规则穷举。
+Linux RSS 不替代 Apple Network Extension physical footprint。
 
 ## 失败语义
 
@@ -242,8 +327,8 @@ Vole 自有脚本仅负责编译。压力与横向比较固定只引用完整 `g
   wire 结构或 staging 检查失败发生在卸载之前，当前快照继续可用。
 - 首次加载、外部资产重载或卸载后的所选记录加载失败，使对应种类不可用；健康种类
   独立发布。排空超时或卸载后取消也保持已卸载状态，不能通过反选绕过不可用语义。
-  失败更新保留旧磁盘资产，但不恢复旧内存快照；后续成功加载再恢复分流。
-- 不可用的 GeoIP 规则不得触发惰性 DNS。
+  DAT 失败更新保留旧磁盘资产，不恢复旧内存快照；国家 MMDB 与 ASN 更新按前文恢复旧代。
+- 不可用的 GeoIP 或 ASN 规则不得触发惰性 DNS。
 - 调度状态损坏时在更新锁内重置；异常退出留下的更新状态在锁释放后恢复。
 
 自动化与实机覆盖范围见 [验收矩阵](acceptance.md)。
diff --git a/docs/http-processing.md b/docs/http-processing.md
new file mode 100644
index 0000000..adecc91
--- /dev/null
+++ b/docs/http-processing.md
@@ -0,0 +1,118 @@
+# HTTP 处理
+
+独立 HTTP 配置作用于 TUN 和 mixed-port 的业务 TCP。Core 的 DNS、provider、GeoData、节点握手及 Controller 不进入业务重写。主代理配置仍使用 Mihomo YAML。
+
+## 配置与资源
+
+`httpConfigYaml` 使用单份 YAML 文档。未知字段、旧格式、重复键、类型错误及 `null` 冒充省略值均拒绝。四个顶层字段均可省略：
+
+```yaml
+http-ports: [80, 8080]
+rewrite-providers: {}
+rewrite:
+  enabled: false
+  rules: []
+mitm:
+  enabled: false
+  ports: [443]
+  domains: []
+  exclude-domains: []
+```
+
+端口有效且不可重复。`rewrite.enabled` 控制真实执行，关闭仍校验直接规则与 inline 内容；规则和引用的 `enabled` 默认 true。关闭引用不读取来源。MITM 为独立本机授权，远程规则不能扩大它。
+
+```yaml
+rewrite-providers:
+  local: {type: file, path: ./rules/local.yaml}
+  remote:
+    type: http
+    url: https://rules.example.com/http.yaml
+    path: ./rewrite-cache/remote.yaml
+    interval: 86400
+    header:
+      Authorization: ['Bearer example-token']
+  builtin:
+    type: inline
+    payload:
+      - {url: 'https://example.com/debug', match: exact, action: reject}
+rewrite:
+  enabled: true
+  rules:
+    - {url: 'http://old.example/v1/', match: prefix, action: replace, replacement: 'https://new.example/v2/'}
+    - {rule-set: local}
+    - {rule-set: remote}
+    - {rule-set: builtin, enabled: false}
+```
+
+file 只接受必填 `path`；inline 只接受必填 `payload`；http 接受必填 `url` 和可选 `path`、`interval`、多值 `header`。外部文件只有 `payload`，与本机直接规则同形，不能嵌套引用或携带本机授权／CA。按引用位置展开，不允许重复引用或未知名称。
+
+file 相对路径锚定宿主提供的 HTTP 文件目录，HTTP 缓存锚定初始化的数据目录；缓存不能与主文件、源文件或其他缓存冲突。URL 与规范化请求头绑定来源；认证变化不能借用旧缓存。304 要求完整有效的同来源内容。全部来源及总体编译通过后，才提交缓存与完整待应用候选；失败保留旧内容。
+
+file 在显式准备时读取；http 的 interval 默认 86400 秒，0 只关闭周期更新。准备与下载使用底层资源路径，不经过本次 HTTP 业务处理。
+
+当前工程上限为主文档与实际外部内容合计 1 MiB、展开规则 64 条、选择器／搜索各 2 KiB、非正文规则文本合计 64 KiB、单个 URL 结果 8 KiB。正则编译与 DFA 缓存分别限 128／64 KiB；YAML 别名、模板输出及并行准备也受限。超限失败，不截断规则；这些准入上限不代表进程 RSS。
+
+HTTP 处理需要编译启用 `inbound-http`。缺少该能力时，非空 HTTP 配置在静态校验时拒绝，不读取 provider 或私密 CA；省略或空输入仍表示不启用。
+
+## URL 阶段
+
+规则共有必填 `url`、`action`，可选 `match`、`enabled` 和展示用 `name`。`match` 为 regex（默认）、exact 或 prefix，不根据文本猜测。URL 动作为 replace、redirect302、redirect307、reject；前三者必须有 replacement，reject 不接受替换参数。
+
+`replacement-mode` 默认 match：exact 替换整个 URL，prefix 保留后缀，regex 仅替换首个匹配片段。显式 url 使用整个展开结果。prefix 只在无查询的 replacement 以 `/` 结尾、后缀也以 `/` 开头时去掉一个边界斜杠，不拼接路径或合并查询。
+
+正则模板支持 `$0`、`$N`、`${N}`、`${name}`、`$$`，不支持 `$name`；未知捕获加载失败，可选未参与捕获为空。字面模式不展开捕获。仅接受合法绝对 HTTP(S) URL，拒绝 userinfo、fragment、端口 0、控制／空白字符和反斜杠。离线输入 trim 并去掉 fragment；配置目标不允许 fragment。
+
+所有阶段按原始规范化 URL（U0）筛选。URL 动作首条命中产生 U1，不递归。非法生成目标本地返回空 502；redirect 与 reject 本地结束，不访问原站，reject 为空 403。相同 origin 的路径／查询改写保留已选 IP；跨 origin 重选路、重建 authority，先清理收到的 Authorization／Cookie。原始目标与入口身份保留。
+
+## Header 与正文
+
+`request-header-set/add/remove/replace` 和 `response-header-set/add/remove/replace` 按规则顺序累计执行。`header` 为字段名；set/add 必须有字面 `value`，remove 不携带值，replace 使用 `search` 与 `replacement`。多值字段逐项处理；set 覆盖原值，add 追加独立值。协议控制字段、Connection 提名字段不能修改。阶段失败时整个 header 阶段回退；跨 origin 清理旧凭据后，规则可明确设置新的 Authorization／Cookie。
+
+正文动作是 `request-body-set/replace/json-patch` 和对应的 `response-body-*`。set 使用 UTF-8 字面 `value`，包含空字符串；replace 使用 `search`、`replacement`。`search-mode` 默认 literal，可选 regex；`occurrences` 默认 all，可选 first。只有 regex search 的替换展开其自身捕获，其他值不展开 URL 捕获。所有正文操作按序执行，一条失败则整个正文阶段原文旁路，保留独立 header 阶段的成功修改。
+
+```yaml
+rewrite:
+  enabled: true
+  rules:
+    - {url: 'https://api.example/v1/', match: prefix, action: request-header-set, header: X-Client, value: Vole}
+    - url: 'https://api.example/v1/settings'
+      match: exact
+      action: response-body-json-patch
+      patch:
+        - {op: add, path: /enabled, value: true}
+        - {op: replace, path: /message, value: ready}
+    - {url: 'http://example.com/', match: prefix, action: response-body-replace, search: old, replacement: new}
+```
+
+JSON Patch 支持 RFC 6902 的 add/remove/replace/move/copy/test 和 RFC 6901 Pointer；`value` 可为真正的 null、布尔、数值、字符串、数组、对象。配置数值必须能无损转换，不能静默舍入；业务 JSON 保留数值原文并拒绝重复键。空 patch 不触发解析或重新编码。非法 JSON、Pointer 或失败的 test 导致整个正文阶段原样旁路。
+
+只有被正文规则选中的消息才缓冲。原始、解码、中间和最终正文各限 256 KiB；进程共享 2 MiB 正文工作区，包含 JSON 与 codec 临时空间。先预留再分配，无额度直接旁路；发送期间保留额度。未知长度最多探测上限加一字节，超限按原实体字节回放已读前缀和余下数据，不截断。传输中断、超时和取消仍是错误，不能假装完成。
+
+支持 identity、gzip、deflate、br；按收到的 Content-Type、charset、Content-Encoding 和原始请求 Accept-Encoding 判断资格。改写后使用 UTF-8 identity，修正长度与表示元数据并删除失效的校验／签名字段。没有实际改动时保留原始编码表示。未知编码、非法文本、压缩校验失败或预算不足均整阶段原文旁路。
+
+HEAD、无正文状态、206/Content-Range、CONNECT、Upgrade、SSE、gRPC、multipart 及带 trailer 的消息不做正文改写，普通 header 规则仍可执行。选中正文的 H1 Expect: 100-continue 在读取前完成握手；未匹配消息保持原有流式背压、早响应和半关闭语义。H1/H2 与成功解密的 HTTPS 共用规则与预算。
+
+## 选择性 HTTPS
+
+```yaml
+mitm:
+  enabled: true
+  domains:
+    - {pattern: private.example}
+    - {pattern: '*.example.net', enabled: true}
+  exclude-domains:
+    - {pattern: excluded.example.net}
+  ports: [443]
+```
+
+域名项只有 pattern 和默认 true 的 enabled。支持精确名称及 `*.suffix` 子域匹配，后者不包含域本身；启用排除项优先，关闭项仍校验。开启要求有效允许域名、端口及匹配的有效 CA／私钥。关闭不构造 CA；宿主提供独立私密输入，规则、payload 和普通快照不承载私钥。
+
+MITM 支持 HTTP/1.1 与 HTTP/2。HTTP/3 MITM 暂不支持；UDP／QUIC（含 H3）按原字节透明转发，不进入 URL/header/body rewrite，也不通过阻断 QUIC 强制客户端回落。
+
+只终止允许的 SNI／端口；无 SNI、ECH（含 GREASE）和未授权名称保持透明。每个原始 HTTP authority 独立授权，同一 H2 连接不扩大权限。最终上游按实际目标验证证书，使用受保护出口；不通过关闭验证处理 pinning 或客户端证书要求。
+
+H1 上游协商 HTTP/1.1，H2 下游对接实际协商的 H2 或 H1。普通 H2 CONNECT 返回 405；WebSocket 使用 H1 Upgrade。叶证书最多 32 项、材料预算 256 KiB、空闲 10 分钟，有效期不超过 24 小时或 CA。
+
+H2 每连接最多 8 个活动请求，流／连接接收窗口 32／64 KiB，头最多 32 KiB／100 字段，帧 16 KiB，关闭动态 HPACK 表。上游不跨请求复用。上传使用 30 秒无进展期限；上传完成后响应头另有 30 秒等待期限，提前响应仍与上传并发。取消和 Stop 覆盖上下游、正文与驱动。
+
+当前会话固定主设置、实际 payload、授权和 CA。保存／资源刷新只产生待应用候选，节点选择和分流更新继承 active。显式重连准备候选后切换，后续启动失败使用旧实际内容恢复，不重读已变化文件；普通 Stop 释放私密材料。共享入口见 [Invoke API](invoke-api.md) 与 [CLI](cli.md)。
diff --git a/docs/inbounds.md b/docs/inbounds.md
index 2eadbb3..ef1ac3f 100644
--- a/docs/inbounds.md
+++ b/docs/inbounds.md
@@ -1,11 +1,11 @@
 # HTTP 与 SOCKS5 混合入站
 
-HTTP 与 SOCKS5 共用一个混合入口，并和 TUN 共用 Dispatcher、规则、DNS、静态 select 组及出站图。
+HTTP 与 SOCKS5 共用一个混合入口，并和 TUN 共用 Dispatcher、规则、DNS、动态策略组及出站图。
 字段全集见[配置协议](config.yaml)，Controller 另见[接口](controller-api.md)。
 
 ## 监听与认证
 
-- `mixed-port` 省略或 0 关闭，启用时为 1–65535；混合入口和 TUN 至少启用一个。
+- `mixed-port` 省略或 0 关闭，启用时为 1–65535；关闭混合入口和 TUN 的配置仍可启动。
   同一 TCP 端口接入 HTTP 转发、CONNECT、Upgrade 和 SOCKS5 CONNECT、UDP ASSOCIATE。
   SOCKS5 UDP 随入口启用并绑定同地址、同端口，不提供独立入站 UDP 开关。
 - 顶层 `port`、`socks-port`、`udp` 和 `listeners` 均拒绝，不迁移或忽略旧字段。
@@ -15,15 +15,37 @@ HTTP 与 SOCKS5 共用一个混合入口，并和 TUN 共用 Dispatcher、规则
 - `allow-lan: false` 绑定 IPv4 回环，true 绑定通配地址。`ipv6: true` 增加独立
   IPv6-only 回环/通配 socket。仅系统明确不支持地址族时可省略 IPv6，其余绑定错误
   整体回滚。取得 Controller 和全部业务 socket 后才启动接收任务。
+- `bind-address` 默认为 `*`；`allow-lan: true` 时可指定单个 IPv4/IPv6 地址，false 仍绑定回环。
+  `localhost` 始终使用回环策略，并随 `ipv6` 控制 IPv6 回环 socket。
+  `lan-allowed-ips` 默认允许全部 IPv4/IPv6，`lan-disallowed-ips` 的拒绝规则优先。
+  两者作用于 TCP 来源；SOCKS5 UDP 必须属于已获准的 TCP 关联。
+  `skip-auth-prefixes` 只跳过匹配来源的认证，不跳过来源访问控制。
 - `allow-lan` 与 `authentication` 独立；通配绑定不强制认证。
-  `authentication` 省略或空列表时，HTTP/SOCKS5 在任何绑定地址均免认证；
-  非空必须恰好一项 `user:password`，
-  按第一个冒号拆分，两项各 1–255 UTF-8 字节，不 trim。null 不视为省略。
-  配置凭据后 HTTP/SOCKS5 均校验凭据；共享或非空凭据须有启用的混合入口消费。
-- Basic / SOCKS 用户密码没有链路加密，只适合可信网络。Controller 仍独立回环监听，
-  使用自己的 Bearer 认证，不随共享开关开放。
+  `authentication` 省略、null 或空列表时，HTTP/SOCKS5 在任何绑定地址均免认证；
+  非空接受多个 `user:password`，相同用户名以最后一项为准，
+  按第一个冒号拆分，不 trim，允许空用户名或密码。配置和 HTTP 不套用 SOCKS5 的
+  长度限制；HTTP 凭据受整个 32 KiB 请求头预算约束，SOCKS5 各字段仍使用一字节 wire 长度。
+  配置凭据后 HTTP/SOCKS5 均校验凭据；混合入口关闭时允许保留合法的共享和认证配置。
+- Basic / SOCKS 用户密码没有链路加密，只适合可信网络。Controller 按 external-controller 独立监听，
+  使用自己的可选 Bearer 认证，不随共享开关改变地址或认证。
 - 不设置全局业务连接/关联准入数。Stop 取消并等待全部连接、relay 和接收任务，
   返回后端口可重新绑定。
+- 接收的 TCP 连接启用 `TCP_NODELAY`，小包应答不等待 Nagle 聚合。
+
+## 选路元数据
+
+`IN-TYPE` 使用实际入口类型：普通 HTTP/Upgrade 为 HTTP，CONNECT 为 HTTPS，
+SOCKS5 为 SOCKS5；HTTPS 类型只表示 CONNECT，不检查目标 TLS。`IN-PORT` 读取
+接收连接或授权 UDP socket 的真实本地端口。
+
+`IN-USER` 与 load-balance 的 `hash-key: in-user` 只使用验证成功的配置用户名。
+HTTP 每个请求重新验证，SOCKS TCP 和 UDP 授权关联保留握手身份。无认证或
+`skip-auth-prefixes` 旁路时身份为空，即使请求声称一个 Proxy-Authorization 用户。
+身份随请求/关联保存，只持有用户名，不保存密码、请求头或完整配置代际；Debug 不输出用户名。
+业务路由和 dialer-proxy 共用该身份，内部 DNS、资源下载及主动测速没有入口用户。
+
+Mihomo 当前实现不把 SOCKS TCP 身份传给独立 UDP 接收；Vole 的授权 UDP 保留
+真实握手身份。Mihomo HTTP 在无认证时也可能记录请求声称的用户，Vole 保持为空。
 
 ## HTTP
 
@@ -51,7 +73,8 @@ HTTP/1.0 和 HTTP/1.1 使用绝对 `http://host[:port]/path?query` URI。每个
 
 ### 隧道
 
-CONNECT 在上游成功后才返回 200，保留头后的预读数据。Upgrade 只接受无正文请求；
+CONNECT 通常在上游成功后返回 200，保留头后的预读数据。匹配 TCP 嗅探策略时先返回 200，
+再读取有界业务前缀并按嗅探结果建链；此后建链失败直接关闭隧道。Upgrade 只接受无正文请求；
 合法 101、Connection/Upgrade 一致且选中请求协议时才切隧道，保留双方预读和 TCP
 半关闭。非 101 按普通响应处理，非法切换返回 502。
 
@@ -62,13 +85,15 @@ CONNECT 在上游成功后才返回 200，保留头后的预读数据。Upgrade
 
 头 32 KiB/100 字段、读头/建链 10 秒；每方向预读/复制 8 KiB。chunk 行 1 KiB，
 trailer 8 KiB/100 字段，每个最终响应前最多 16 个临时响应。正文逐次读写空闲期限
-30 秒；响应开始后独立计算读头总期限，上传结束后等待响应最多 10 秒。正文长度不
-决定分配大小，Stop 覆盖认证、建链、正文及隧道。
+30 秒。上传与响应读取并行；上传完成后，当前完整响应头的总等待上限为 30 秒，
+观察到首字节后另受 10 秒绝对读头期限约束，两者取较早者。每个临时响应转发后
+重新开始下一响应头的等待。正文长度不决定分配大小，Stop 覆盖认证、建链、正文及隧道。
 
 ## SOCKS5
 
 仅支持 RFC 1928/1929 的 SOCKS5 CONNECT、UDP ASSOCIATE 和用户名密码协商。
-不降级绕过已配置认证。精确读取握手并保留 CONNECT 后业务字节；上游成功才回复成功。
+不降级绕过已配置认证。精确读取握手并保留 CONNECT 后业务字节；通常在上游成功后回复成功。匹配 TCP 嗅探策略
+时先确认 CONNECT，取得业务前缀后建链，失败关闭已确认的连接。
 目标保留 IPv4、IPv6 或域名交给 Dispatcher，入站不提前解析。TCP 每方向复制 4 KiB，
 保留半关闭。
 
@@ -92,3 +117,6 @@ wire 最大 65,507 字节，额外 sentinel 识别截断，自有 UDP socket 请
 TUN 使用独立 MTU；SOCKS5 数据不计入 Controller 的 TUN 流量。
 
 [验收边界](acceptance.md)区分容器双栈与真实 LAN/物理 IPv6，不能相互替代。
+
+
+显式启用独立 HTTP 配置时，mixed HTTP/CONNECT 与 TUN 共用[URL rewrite](http-processing.md)和同代 Dispatcher。规则先确定最终 URL，再选路；本地动作不连接旧目标。请求正文与 Upgrade 继续复用本文件的流式 framing／relay；入口认证和用户名语义保持。
diff --git a/docs/invoke-api.md b/docs/invoke-api.md
index 2cf865b..1d580ab 100644
--- a/docs/invoke-api.md
+++ b/docs/invoke-api.md
@@ -1,8 +1,10 @@
 # Vole Invoke API
 
-业务实例通过内联的 `configYaml` 启动，测速通过 `configYamls` 传入节点配置；前台 `foreground` 操作负责从文件或标准输入加载同一配置。每份已加载的 Vole 运行时最多拥有一个公共实例。业务代理入口仅通过 `mixed-port` 配置，HTTP/SOCKS5 TCP 与 SOCKS5 UDP 共用端口；顶层 `port`、`socks-port`、`udp` 和 `listeners` 都会失败。代理组实时选择沿用 Controller。静态 ECH 只使用节点内联配置，不新增 bootstrap DNS 入参。
+业务实例通过内联的 `configYaml` 启动，测速通过 `configYamls` 传入节点配置；前台 `foreground` 操作负责从明确的 Base64、文件或标准输入加载同一配置。每份已加载的 Vole 运行时最多拥有一个公共实例。业务代理入口仅通过 `mixed-port` 配置，HTTP/SOCKS5 TCP 与 SOCKS5 UDP 共用端口；顶层 `port`、`socks-port`、`udp` 和 `listeners` 都会失败。代理组实时选择沿用 Controller。ECH 使用节点内联静态配置或运行时节点 DNS 角色；measureDelay 的动态 ECH 使用原 Dialer 的 system-source 原始 HTTPS 记录叶服务，平台物理来源不可用时失败，不增加 DNS 或宿主元数据入参。
 
-共享请求处理位于 `src/invoke/`。Rust 调用方使用 `vole::invoke::invoke_bytes(&[u8]) -> Vec<u8>`；CLI 和 C ABI 都调用该入口。`invoke` feature 提供共享操作，`cli` 和 `ffi` 分别添加命令行与原生传输适配。
+共享请求处理位于 `src/invoke/`。Rust 调用方使用 `vole::invoke::invoke_bytes(&[u8]) -> Vec<u8>`；C ABI 使用同一入口。
+CLI 使用共用解析、准入、派发和 panic 边界的 `invoke_owned_bytes(Vec<u8>)`，
+将序列化输入的所有权交给 Invoke，使其在进入长驻前台操作前清零并释放原始 JSON；不增加 JSON 方法。`invoke` feature 提供共享操作，`cli` 和 `ffi` 分别添加命令行与原生传输适配。
 
 ## C ABI
 
@@ -53,7 +55,7 @@ void VoleFree(char *response);
 - 运行时级方法必须省略 `instanceId`；实例级方法必须携带 Vole 返回的非空 ID。
 - 未知或已移除的 envelope 字段和 payload 字段都会失败，不静默忽略。
 - 无业务数据的方法成功时返回空对象，不返回 `null`。
-- Invoke envelope 最大 3 MiB，单份 YAML 最大 256 KiB。
+- Invoke envelope 上限为 240 MiB + 64 KiB（五份 YAML 的 JSON 最坏转义及 envelope），单份 YAML 最大 8 MiB。
 
 ## 初始化与生命周期
 
@@ -90,7 +92,7 @@ stopped -> preparing -> prepared -> starting -> running
 - `validateConfig` 是可并发的纯校验方法，不要求或执行 `initialize`。
 - `measureDelay` 使用独立批次和私有工作器，不进入公共实例表。
 - 公开生命周期为 `initialize -> createInstance -> start(configYaml) -> stop -> destroyInstance`。`preparing`、`prepared` 和 `starting` 是 `start` 内部阶段，没有公共 `prepare` 方法。
-- 不支持配置热重载；切换配置需要 `stop -> start(新 configYaml)`。唯一的运行期路由变更是通过 Controller 修改静态 `select` 组的当前选择，它不修改启动配置。
+- `updateConfig` 与 Controller 共用一个候选应用器；路由、节点、provider 和允许的 DNS/连接策略更新只影响新连接。TUN、监听器、系统网络等启动资源变更需要 `stop -> start(新 configYaml)`。既有连接保留原资源和路径。
 - `stop` 在 stopped 状态幂等；`destroyInstance` 是最终同步清理屏障。
 
 ## 方法
@@ -119,6 +121,29 @@ stopped -> preparing -> prepared -> starting -> running
 
 参数和幂等语义见“初始化与生命周期”。成功时返回规范化后的 `dataDir`。
 
+### `updateDnsNetwork`
+
+初始化后的运行时级方法，不带 `instanceId`。宿主提供完整、只读的物理网络 DNS 快照；不改变 `start(configYaml)`，不配置接口、路由、DNS 或 App 生命周期。
+
+```json
+{
+  "method": "updateDnsNetwork",
+  "payload": {
+    "generation": 1,
+    "system": [
+      {"address": "192.0.2.53", "interface": "en0", "scopeId": 0, "requiresEncryption": false}
+    ],
+    "dhcp": [
+      {"interface": "en0", "servers": [{"address": "192.0.2.54", "scopeId": 0}], "requiresEncryption": false}
+    ]
+  }
+}
+```
+
+`generation` 必须是正整数并单调增加；相同代次的相同内容幂等，不同内容或较旧代次失败。system/dhcp 必填，空数组撤销来源；一个 DHCP 接口只能出现一次。所有层级拒绝未知字段，metadata 原始 JSON（含内部空白）及规范化快照各限 64 KiB；在完整 JSON Value 解析前通过借用 RawValue 准入，额外 envelope 字节（含外部空白）独立限 64 KiB。这与其他方法沿用的全 envelope 上限不同。地址只接受非回环的单播字面 IP；IPv6 link-local 必须提供匹配物理接口的非零 scopeId，IPv4 scopeId 必须为 0。interface 是 1–256 字节的精确名称或 UWP 的绑定 GUID，不允许控制字符、路径分隔符或首尾空白。scopeId 默认 0，requiresEncryption 默认 false，宿主必须如实标记加密要求，不能将无法确认的数据描述为明文来源。
+
+成功返回 `{}`。快照在同一运行时内共享，优先于 OS 发现，并与全部仍活跃资源代次的 DNS cache/hints 清理共用 epoch 屏障；旧查询不能回填，fake-IP 和活跃流保留。Windows 前台进程和 Session Host 的 runtime registry 各自独立，本方法不提供 IPC。平台可用性和物理绑定见 [DNS 来源](tun-icmp-dns.md#显式系统与-dhcp-来源)。
+
 ### `getGeoDataState`
 
 运行时级只读方法，要求已经初始化：
@@ -127,7 +152,7 @@ stopped -> preparing -> prepared -> starting -> running
 {"method":"getGeoDataState","payload":{}}
 ```
 
-返回 `geosite` 和 `geoip` 两项：
+返回 `geosite`、`geoip` 和 `asn` 三项；三种资产分别报告需求与可用性：
 
 ```json
 {
@@ -150,10 +175,22 @@ stopped -> preparing -> prepared -> starting -> running
     "lastError": null,
     "etag": null,
     "hash": null
+  },
+  "asn": {
+    "required": false,
+    "available": false,
+    "updating": false,
+    "lastSuccess": null,
+    "nextCheck": null,
+    "lastError": null,
+    "etag": null,
+    "hash": null
   }
 }
 ```
 
+`asn` 使用相同的 `required`、`available`、`updating`、`lastSuccess`、`nextCheck`、
+`lastError`、`etag` 和 `hash` 字段。
 时间使用 Unix 秒，hash 为小写 SHA-256。调用不会创建实例、联网或改变更新调度。
 
 ### `createInstance`
@@ -191,11 +228,11 @@ stopped -> preparing -> prepared -> starting -> running
 }
 ```
 
-无需 `initialize`，完成大小、YAML、结构、共享 route-target 命名空间、引用和字段组合校验。节点的 `dialer-proxy` 可引用节点或组；全部上游和组成员边（包括未选成员）统一做无环校验。不创建实例、不解析远端域名、不联网，也不读取 GeoData。资产缺失不影响纯配置校验。
+无需 `initialize`，完成大小、YAML、结构、共享 route-target 命名空间、引用和字段组合校验。节点的 `dialer-proxy` 可指定 DIRECT 或引用节点、组；全部上游和组成员边（包括未选成员）统一做无环校验。不创建实例、不解析远端域名、不联网，也不读取 GeoData。资产缺失不影响纯配置校验。显式引用的客户端证书与密钥文件在校验时读取；相对路径使用已初始化的 dataDir，未初始化时使用当前工作目录。
 
 ### `start`
 
-实例级方法，只允许 stopped 状态。唯一 payload 字段是内联配置：
+实例级方法，只允许 stopped 状态。`configYaml` 必填，独立 HTTP 设置与私密上下文可选：
 
 ```json
 {
@@ -211,8 +248,8 @@ TUN 资源参数来自 YAML 的 `tun`，平台包格式由内核选择。
 同一命令内先准备配置，再获取平台资源并启动：
 
 - 读取当时可用的本地 GeoData，不启动或等待下载。
-- 为所有潜在物理首跳执行引导 DNS：节点无上游，或其上游组经纯组成员链能选到 DIRECT 时，预解析节点服务器及独立 VLESS 下载端点，包括尚未选中的 DIRECT 路径。候选解析失败则启动失败；仅经代理访问的域名交给下一跳。切换 DIRECT 不新增系统 DNS。
-- 校验每个静态 `select` 组的初始选择；省略 `default-selected` 时使用第一项，显式值必须是直接成员。启动时创建本次 session 的可变选择状态。
+- 准备阶段只构建并校验代理图；实际建立物理首跳时，通过运行时节点 resolver 解析服务器及独立 VLESS 下载端点。未选中的备用节点不会因 DNS 故障阻塞启动。仅经代理访问的域名交给下一跳；系统解析仅用于 DNS 关闭的配置。
+- 按当前资源构建代理组。`profile.store-selected` 开启时优先恢复仍有效的缓存选择，否则使用有效的 `default-selected` 或首成员；动态空组使用 `empty-fallback`。自动组随后依据健康探测选择成员。
 - 含 TUN 的配置从内部 preparing 阶段起持有运行时本地的 TUN/protect 租约，直到停止或销毁。Android 必须在 `start` 前注册 protect controller。
 - 所有监听器和关键数据面成功后才进入 running。准备、资源获取或启动失败均清理本次临时资源并回到 stopped；重试需要再次提交完整 `configYaml`。
 - GeoData 更新只在启动后按需后台运行，不属于启动关键路径。
@@ -223,10 +260,16 @@ Apple 使用 utun 包头，Android 与 Linux 使用 raw-IP。Linux 要求真实
 PI/VNET header，并验证实际 MTU 与 `tun.mtu` 相同；跨网络命名空间的校验需要宿主提供权限。
 
 `tun.file-descriptor` 省略或为 0 时，Linux 与 macOS 根据 `tun.device` 创建或打开原生
-TUN；移动平台仍需要宿主描述符。接口地址、DNS、路由和物理出口隔离由宿主配置，Vole
-不自动管理系统路由。`tun.mtu` 省略或为 0 使用 9000；完整六字段契约及借用 fd 边界见
+TUN；移动平台仍需要宿主描述符。Linux 自建 TUN 的 IPv6 地址、CIDR 捕获/排除、
+UID/端口范围、路由索引和 strict-route 从同一配置读取；借用 fd 与 App 管理的平台
+由宿主应用，运行期变更需要重配/重连。Linux 自建 TUN 支持 `auto-route`、
+`auto-detect-interface` 与 systemd-resolved 接管；其他平台和借用 fd 的系统网络由宿主配置。
+`tun.mtu` 省略或为 0 使用 9000；字段契约及借用 fd 边界见
 [配置参考](config.yaml)与 [TUN 平台层](tun-platform.md)。
 
+物理出口来自同一 YAML 的全局/节点 `interface-name/routing-mark` 与普通 DNS `#接口`，
+不增加 Invoke 参数。平台能力、继承和 auto-route 共存边界见[出站契约](outbounds.md)。
+
 Windows 编译时选择互斥的 `windows-wintun` 或 `windows-uwp`：
 
 - Wintun 构建中，业务 `start(configYaml)` 在 `tun.enable: true` 时自动打开或创建
@@ -240,6 +283,24 @@ Windows 编译时选择互斥的 `windows-wintun` 或 `windows-uwp`：
 Stop 关闭本次持有的 fd、session 和原生句柄；Wintun 不承诺移除宿主已有的同名接口
 或卸载驱动。平台启动失败不切换另一种 Windows 后端。
 
+### `updateConfig`
+
+实例级方法，只允许 running 状态。接受 `configYaml`、可选 `httpConfigYaml` 与只含 `baseDir` 的 `httpContext`；不接受 CA：
+
+```json
+{"method":"updateConfig","instanceId":"1","payload":{"configYaml":"rules: [MATCH,DIRECT]"}}
+```
+
+共享 Controller 的单候选许可、解析、完整图准备与原子发布，不建立第二个运行时。
+先取得许可，再解码最多 8 MiB 的 YAML；并发应用返回 busy。无效候选或准备失败保留旧代，
+改变启动资源返回 reconnect required。成功仅表示候选配置及当前可用资源已经发布；HTTP provider
+继续沿原更新流程刷新，不表示所有远端订阅已下载。Controller GET `/configs` 可确认当前有效值。
+
+沿用实例命令锁：调用完成前，同实例 Stop/getState/其他命令返回 busy；候选等待上限 90 秒。
+超时或取消会阻止未发布候选继续提交；工作器保留许可并回收已开始的准备任务，Stop 仍等待其完成。如超时与发布同时发生，
+通过 Controller 查询确认当前值。既有连接仍持有旧代至结束；新连接使用新代。Provider 身份和
+Windows Session Snapshot 不由此重建；Windows UWP 的活动 Provider 配置仍由宿主管理和重连。
+
 ### `foreground`
 
 运行时级前台操作，省略 `instanceId`：
@@ -270,8 +331,32 @@ Stop 关闭本次持有的 fd、session 和原生句柄；Wintun 不承诺移除
 若定义 `XDG_CONFIG_HOME`，使用 `<XDG_CONFIG_HOME>/vole`。相对数据目录和显式
 配置路径分别从启动工作目录解析并折叠 `.`/`..`，绝对路径原样保留；
 配置默认 `<dataDir>/config.yaml`。
-`configPath: "-"` 从标准输入读取。文件必须是普通文件，文件和标准输入均最多 256 KiB；
-不会下载、创建模板或改写配置。详细命令行映射见 [CLI](cli.md)。
+`configPath: "-"` 从标准输入读取。文件必须是普通文件，文件和标准输入均最多 8 MiB；
+证书/密钥相对路径从选定 dataDir 解析，validate 也读取身份文件但不初始化目录。
+不会下载、创建模板或改写配置。
+可选 `configString` 和 `ageSecretKey` 是 UTF-8 文本，分别取 `VOLE_CONFIG_STRING`、
+`VOLE_AGE_SECRET_KEY` 的环境默认；显式空值清除该默认。非空 `configString` 按带 padding 的
+标准 Base64 解码（允许 CR/LF），优先于配置路径，因此即使路径为 `-` 也不打开或锁定标准输入。
+没有非空 Base64 时才使用明确选择的 `-`（含 `VOLE_CONFIG_FILE=-`）或文件，不探测输入。
+编码文本最多 11,184,812 字节，解码后的内容、主文件和标准输入均最多 8 MiB。
+输入以标准 AGE armor 开头时复用资源层的认证解密，身份最多 16 KiB，解密后 YAML 最多 8 MiB；
+解密受 30 秒处理期限约束，运行模式的退出信号取消并 join 解码工作器后返回。
+临时身份与私密请求缓冲清零，编码／密文在后续阶段及时释放。配置仍只解析一次后交给共享启动路径。
+运行模式可选 `externalController`、`externalControllerTls`、`externalControllerUnix` 和 `secret` 文本覆盖，
+分别对应 `VOLE_OVERRIDE_EXTERNAL_CONTROLLER`、`VOLE_OVERRIDE_EXTERNAL_CONTROLLER_TLS`、
+`VOLE_OVERRIDE_EXTERNAL_CONTROLLER_UNIX`、`VOLE_OVERRIDE_SECRET` 的环境默认。显式参数优先，空串仅清除环境默认，不清空原 YAML 字段。
+地址复用主配置的既有严格解析器，覆盖在 foreground 解析／校验后应用到同一启动配置；没有任意 map 合并。
+`validate` 保持 Mihomo 的配置测试语义，不读取这些环境值或解析／应用覆盖。`help` 也不读取。
+另有可选数值 `externalControllerRoutingMark`，对应 `VOLE_OVERRIDE_EXTERNAL_CONTROLLER_ROUTING_MARK` 的十进制环境默认；
+非零值才覆盖，显式 0 不读环境且不清除 YAML mark。仅 Linux 网络 Controller 消费，沿用既有 socket mark 范围；
+它不更改业务 mark 或本地 Unix 入口。CLI 先执行 Go flag 整数语法检查，`validate` 仍不读取该环境默认或应用运行期覆盖。
+覆盖元数据不进入普通 `start` payload 或 Mihomo YAML schema；Controller 的 TLS 身份仍由主配置提供。新激活的入口保留主配置中的 secret/CORS；Unix 本地入口另依文件权限授权，不改变网络鉴权。
+前台运行可通过 `VOLE_SAFE_PATHS` 的系统原生路径列表扩展 provider 授权根；仅用于主配置 file provider 读取、
+HTTP provider 缓存正文及 sidecar 写入。目录在初始化时 canonicalize 并冻结，沿普通候选、HUP 和恢复快照继承；
+重复初始化不得改变已明确设置的授权上下文。空项不授权工作目录，读取不创建目录，路径 traversal 与符号链接逃逸拒绝。
+本次显式主配置／独立 HTTP 输入禁止被缓存覆盖，显式私密 CA 路径禁止 provider 读写。
+它不扩展主配置写回、客户端身份／私密 CA、独立 HTTP 设置或 Controller 清理权限，也不进入 YAML／普通 initialize payload。
+详细命令行映射见 [CLI](cli.md)。
 
 普通 Unicode 路径使用 JSON 字符串。需要保留平台原生编码时，Unix 可使用
 `{"unixBytes":[47,116,109,112,255]}`，Windows 可使用
@@ -281,9 +366,21 @@ Stop 关闭本次持有的 fd、session 和原生句柄；Wintun 不承诺移除
 `run` 同步占用当前调用直到会话结束；同一运行时只允许一个前台运行操作。它消费进程的
 标准输入和退出信号，并安装有界 stderr 诊断，适用于前台进程宿主。嵌入式、服务或 VPN
 宿主继续用普通业务生命周期方法和自身的退出机制。
+解析后的配置直接交给同一启动路径，不重复读取或解析。
+CLI 与普通 `start` 共用统一的 TUN allocator 策略、内存诊断和 Stop 后回收；
+无 TUN 的会话不修改 allocator。
+GNU/Linux 的设置是进程级、一次性的，显式 allocator 环境覆盖仍优先，
+完整语义见[运行时资源策略](runtime-resource-policy.md#统一内存策略)。
 Unix 等待 SIGINT/SIGTERM，Windows 等待 Ctrl+C/Ctrl+Break；标准输入先读取，之后在
 内部准备和启动前注册信号。启动中收到信号仍等待启动工作器结束，再停止和销毁；运行期
-通过引擎完成通知等待结束，随后 join 确认结果，不持有命令锁等待信号。启动、关键数据面、
+通过引擎完成通知等待结束，随后 join 确认结果，不持有命令锁等待信号。
+Unix SIGHUP 只通过已有候选许可与工作器热更新主配置：文件源有界重读，Base64／stdin 复用首次有效 YAML。
+后者不保留 Base64、AGE 密文或原始 JSON；文件 AGE 仅保留已解析身份，不重读密钥环境或独立 HTTP 私密 CA 文件。
+同一请求启动时的具体 Controller 覆盖继续应用于新候选。错误候选保留当前配置；启动资源变化返回
+reconnect required 的本地摘要并保留当前会话，HUP 不自动 Stop/start，也不关闭或替换宿主 fd。
+候选继承活动 HTTP policy 的同一实际 payload／CA，普通 provider 更新继续正常执行；独立 HTTP 文件和
+HTTP pending 不由 HUP 读取或应用。退出信号／引擎结束取消并等待重载的已开始工作，Stop 保留原同步屏障。
+启动、关键数据面、
 信号或清理失败返回失败响应，错误保留有界摘要；操作返回前完成本次清理。
 
 ### `stop`
@@ -336,10 +433,11 @@ Unix 等待 SIGINT/SIGTERM，Windows 等待 Ctrl+C/Ctrl+Break；标准输入先
 
 - `configYamls` 接受 1–5 份非空节点配置，`timeout` 为 1–30 秒。
 - 同一运行时一次只允许一个测速批次，最多并发五个私有工作器。
-- 节点配置顶层只允许 `proxies`，不接受 `proxy-groups`；`dialer-proxy` 也只能引用具体节点。Vole 推导唯一链头，且该链必须覆盖全部节点。
+- 节点配置顶层只允许 `proxies` 和客户端信任 `tls.custom-certifactes`，不接受服务端 TLS 字段或 `proxy-groups`；`dialer-proxy` 可指定 DIRECT 或引用具体节点。Vole 推导唯一链头，且该链必须覆盖全部节点。
+- `type: rematch` 是运行时规则控制，不属于具体可测节点，测速配置拒绝它。
 - 工作器只准备出站图并执行 TCP、可选 TLS 和 HTTP/1.1 HEAD；不创建公共实例、监听器、TUN、DNS、规则、嗅探器或 GeoData。
 - 宿主测量组成员时，按当前选择快照展开具体链后提交；上游选到 DIRECT 时移除相应 `dialer-proxy`，选到 REJECT 时不发起该项测量。该快照不改变运行中的组选择。
-- URL 必须是无 userinfo 和 fragment 的绝对 HTTP/HTTPS URL；HTTPS 使用发布信任根。
+- URL 必须是无 userinfo 和 fragment 的绝对 HTTP/HTTPS URL；HTTPS 与本次节点握手共享内置、可读系统及配置自定义信任根；各测量工作器的信任互相隔离。
 - 任意合法 HTTP 状态都表示探测成功；不跟随重定向、不读取正文。
 - 单项失败不取消其他项；方法返回前释放全部私有任务。
 
@@ -379,7 +477,7 @@ ProtectFd(fd) -> bool
 - 每个出站 TCP/UDP socket 在 connect 前同步调用 protect。
 - socket 初始化和 protect 可以在受跟踪的 Tokio 阻塞线程执行；不保证回调来自某个
   固定业务线程。取消不能中断已经开始的同步回调，Stop 返回前必须等待其完成。
-- TCP/UDP 共用每初始化作用域 64 个未完成提交的内部许可；提交前异步等待并继承
+- TCP/UDP 共用每初始化作用域 4 个未完成提交的内部许可；提交前异步等待并继承
   调用方取消/期限，不因繁忙拒绝业务连接。许可直到阻塞任务实际结束才释放。
 - 返回 false、抛出异常或 controller 失效都会使当前连接失败关闭。
 - 回调必须快速、同步、非阻塞，且不能重入 Invoke 或注册接口。
@@ -388,9 +486,9 @@ ProtectFd(fd) -> bool
 
 ## Controller
 
-配置 `external-controller` 后，运行时可提供回环 `GET /traffic`、`GET /group`、`GET /group/{name}`、`GET /proxies/{name}` 和 `PUT /proxies/{name}`。代理组 Controller 可以在非 TUN 的 `mixed-port` 配置中运行；此时 `/traffic` 不存在。只要 Controller 管理代理组，`secret` 就必填并保护全部路由。
+配置 `external-controller` 后，运行时可提供 HTTP `GET /traffic`、`GET /group`、`GET /group/{name}`、`GET /proxies/{name}` 和 `PUT /proxies/{name}`。代理组 Controller 可以在非 TUN 的 `mixed-port` 配置中运行；此时 `/traffic` 不存在。`secret` 省略或空串时免认证；非空时保护全部路由，监听地址由配置决定。
 
-组成员列表是配置期固定的，选择只存于当前 Running Session。成功切换只影响之后新建的物理 TCP、UDP 和 DNS transport，不迁移既有连接、UDP association、DNS 状态或 TCP pool，也不触发 failover。已认证 Hysteria2 会话的后续逻辑流和跳端口 socket 保留初始上游选择；新的认证会话才读取新选择。Controller 查询不携带 `instanceId`，不进入 Invoke 命令锁；完整语义见 [Controller API](controller-api.md)。
+静态成员来自配置，动态成员随 provider 成功更新；显式选择按 `profile.store-selected` 保存。成功切换只影响之后新建的物理 TCP、UDP 和 DNS transport，不迁移既有连接、UDP association、DNS 状态或 TCP pool。自动组根据健康状态处理后续连接的选择与恢复；select 的连接失败按原样返回。已认证 Hysteria2 会话的后续逻辑流和跳端口 socket 保留初始上游选择；新的认证会话才读取新选择。Controller 查询不携带 `instanceId`，不进入 Invoke 命令锁；完整语义见 [Controller API](controller-api.md)。
 
 ## Windows 安装包桥接
 
@@ -473,10 +571,72 @@ ProtectFd(fd) -> bool
 ## 编码与安全边界
 
 - 所有 JSON DTO 拒绝未知字段。
-- 配置、错误和日志按 UTF-8 字节计数并受固定上限约束。
+- 配置和错误按 UTF-8 字节计数并受固定上限约束；CLI 与 Controller 日志完整输出已生成的事件，级别与订阅预算见各自契约。
 - TUN 原始数据包按 `tun.mtu` 限制；最终代理 UDP 响应最多为该 MTU 减去 48 字节。默认 9000 对应 8952 字节；显式 1500 对应 1452 字节，Windows UWP 的最高 1400 对应 1352 字节。
 - 嵌套 UDP 协议可以增加有界帧头，但解封装后的最终负载仍受该平台响应上限限制。
-- 节点和代理组定义名共享大小写敏感的严格 UTF-8 命名空间；`DIRECT`、`REJECT` 和 `RULES` 不能用作定义名。
-- Secret、password、UUID、REALITY key、short ID、目标地址和完整配置不得进入日志。
+- 节点和代理组定义名共享大小写敏感的严格 UTF-8 命名空间；内置动作名称保留，具体名称与编码规则见 [Controller](controller-api.md#名称与路径)。
+- Invoke 不额外记录完整配置或凭据；CLI 与 Controller 不对已生成的日志消息或字段进行二次脱敏。
 - Apple Unified Logging 的 subsystem 固定为 `io.github.yuandevteam.vole`，category 为
   `vole`，不继承宿主应用的 bundle identifier；Console 或 `log stream` 应按该标识筛选。
+
+
+## 独立 HTTP 设置与私密上下文
+
+`validateConfig`、`start`、`reconnect` 可选 `httpConfigYaml`。HTTP YAML 不承载 CA；旧数组规则、字符串域名项和共享 PEM 字段均拒绝。字段、动作与 provider 见 [HTTP 处理](http-processing.md)。
+
+```json
+{
+  "method": "start",
+  "instanceId": "1",
+  "payload": {
+    "configYaml": "rules: ['MATCH,DIRECT']",
+    "httpConfigYaml": "mitm: {enabled: true, domains: [{pattern: example.com}]}",
+    "httpContext": {
+      "baseDir": "/absolute/http-settings",
+      "ca": {"certificate": "...PEM...", "privateKey": "...PEM..."}
+    }
+  }
+}
+```
+
+baseDir 使用原生路径元数据并且必须绝对；相对 file 来源必须有该上下文。HTTP 缓存使用已初始化 dataDir。CA 仅由 start／reconnect 和 Windows startVpn 接受；私密 DTO 不可普通序列化、Debug 脱敏，临时密钥输入在释放时零化。关闭 MITM 不要求 CA。
+
+validateConfig 只静态校验，不读取外部 HTTP provider 或 CA。返回 `httpResourcesValidated` 表示外部资源是否全部可在输入中校验，`httpsReady` 固定 false；静态通过不代表真实 HTTPS 就绪。foreground 的 validate 也不读取 `httpCaPath`。
+
+### `reconnect`
+
+实例级、只允许 running，payload 与 start 相同。先准备新资源候选，再执行停止屏障并启动。后续启动失败时用临时保留的旧主配置、实际 provider 内容及原 HTTP／CA 快照恢复，方法仍报告失败。新候选准备失败不停止旧引擎。恢复也失败则回到 stopped 并明确报告；普通 Stop 不长期保留恢复密钥。
+
+updateConfig 省略 HTTP 时继承 active；同设置可继续使用 active。显式改变 HTTP（包括空串关闭）或来源基目录返回 reconnect required，整个 routing 更新失败；不把待应用候选混入当前会话。节点切换与普通 provider 更新也不应用 pending HTTP。
+
+### `refreshHttpProviders`
+
+运行时级，要求 initialize，无须创建或启动实例。只接受 `httpConfigYaml` 与可选只含 baseDir 的 httpContext：
+
+```json
+{"method":"refreshHttpProviders","payload":{"httpConfigYaml":"...","httpContext":{"baseDir":"/absolute/http-settings"}}}
+```
+
+完整准备与缓存提交成功返回 `{"resourcesReady":true,"applied":false}`。未运行时只执行一轮；运行时与现有资源更新共用受保护出口、候选许可、取消和 Stop 屏障。周期 HTTP 更新只发布待应用候选；file 不 watch，interval 0 不周期刷新。Windows UWP 的物理更新由已绑定的 Session Host 承担，普通前台 Invoke 不回退到未绑定 socket。
+
+### `testHttp`
+
+运行时级离线演算，不初始化、不联网、不读文件、不读取 CA。输入必填 httpConfigYaml 和 url，可选只含 baseDir 的 httpContext、request／response 样本：
+
+```json
+{
+  "method":"testHttp",
+  "payload":{
+    "httpConfigYaml":"rewrite: {rules: [{url: '.', action: reject}]}",
+    "url":"https://example.com/path",
+    "request":{"method":"POST","headers":[["Content-Type","application/json"]],"bodyBase64":"e30="},
+    "response":{"status":200,"headers":[["Content-Type","application/json"]],"bodyBase64":"e30="}
+  }
+}
+```
+
+method 默认 GET，response.status 必填；headers 是保留顺序与重复项的二元数组，bodyBase64 表示原始编码实体。外部资源只取同来源已准备内存候选；缺少则返回 resourcesReady false／unprepared，不伪装为未命中。总开关关闭仍可演算启用规则；没有样本只报告被选中。结果包含 U0/U1、来源索引、URL 结果、各阶段执行或旁路与样本输出，httpsReady 不宣称真实信任就绪。结果不含 CA，也不持久化正文。
+
+### foreground 私密文件
+
+可选 httpConfigPath、httpCaPath 都是明确的普通文件路径，不自动搜索、不从环境获取；HTTP 文件最多 1 MiB。私密文件格式为 `{"certificate":"...PEM...","privateKey":"...PEM..."}`，Unix 要求当前用户所有、group／other 权限全关闭，并拒绝符号链接。foreground 保留 HTTP 文件目录作为 baseDir。CLI 只传路径，读取仍归 Invoke；空路径与 `-` 拒绝。
diff --git a/docs/mihomo-compatibility.md b/docs/mihomo-compatibility.md
new file mode 100644
index 0000000..709251c
--- /dev/null
+++ b/docs/mihomo-compatibility.md
@@ -0,0 +1,114 @@
+# Mihomo 兼容原则与范围
+
+## 兼容原则
+
+Vole Core 的性能优化综合评估**吞吐、CPU、内存和丢包率的实测收益与代价**，所有指标都允许渐进式改进；优化采纳与最终验收分别遵循[验收边界](acceptance.md#性能采纳标准)。与 Mihomo 的兼容要求是：在 Vole 支持的协议和模式范围内，与 **Mihomo listener 和官方协议 server 端互通**，不寻求配置字段行为完全一致。
+
+TUIC v5 的 native／quic 服务端互通目标为官方 [Itsusinn/tuic](https://github.com/Itsusinn/tuic)。
+官方服务端未提供的 UoT v2 与服务端 mTLS 客户端证书认证使用 Mihomo 验证，分别保留对应对端的验收范围。
+
+实现策略、默认值、窗口、缓冲区、定时器和资源生命周期可按 Vole 的性能目标取舍；差异必须在对应契约中明确说明，并保持协议数据正确性、认证和安全边界。字段名称继续参考 Mihomo，当前接受的配置仍以 Vole 文档为准。
+
+兼容验收以真实对端的握手、认证、数据传输和关闭验证为依据；内存与吞吐通过相同输入和目标负载的压力测试验证。逐字段对照用于确认支持范围和说明差异，不以字段行为相等作为验收门槛。性能对照客户端固定为 Vole 和 Mihomo；兼容问题独立记录，实际收发吞吐包含错误数据，CPU、内存和丢包率照常比较。逐指标判据与测量边界见[验收边界](acceptance.md#性能采纳标准)，服务端互通目标保持。
+
+## 当前支持范围
+
+配置名称以 [Mihomo v1.19.32](https://github.com/MetaCubeX/mihomo/tree/88dcbf7f1614a67c3b36b848ee3592dfa92ada36) 为参考。
+Vole 接受的字段与限制以 [config.yaml](config.yaml) 为准；兼容配置子集不等于完整替代 Mihomo。
+未知字段和不支持的组合明确拒绝，不静默修改输入。已废弃的 dns.fallback-filter.geosite 不接受，使用 nameserver-policy 的 geosite 选择器。
+
+| 范围 | 当前支持 |
+| --- | --- |
+| 配置与选路 | YAML anchor/merge；rule/global/direct；内置 DIRECT/COMPATIBLE/REJECT/REJECT-DROP；域名、地址、端口、网络、GeoData、RULE-SET 和 AND/OR/NOT |
+| 物理出口 | 全局/节点 interface-name、Linux routing-mark、节点 tfo/mptcp 与 Provider 对应 override、物理 TCP 与指定 UDP 节点的 IP4P 转换、普通 DNS #接口；平台约束和 auto-route 防环见出站与 TUN 契约 |
+| 资源 | HTTP/file/inline proxy/rule providers；YAML/URI/标准 Base64 订阅、AGE；共享流式 gzip/URL Basic；动态成员、筛选、覆盖、健康检查；Provider dialer-proxy 与 HTTP 订阅信息；YAML/Text 与 domain/ipcidr MRS；有界离线规则bundle；失败保留旧代 |
+| 策略组 | select/url-test/fallback/load-balance；默认和持久选择；延迟容差、恢复、三种负载均衡策略；旧连接保持原路径 |
+| DNS | hosts（含启动 LAN 地址快照）、bootstrap/节点/直连解析角色、policy、respect-rules；UDP/TCP/DoH/DoT/DoQ、DoH/H3；fallback；redir-host/fake-IP 与映射持久化 |
+| mixed-port | HTTP/SOCKS5 TCP 与 SOCKS5 UDP；LAN 地址限制、多用户认证、认证跳过网段；allow-lan 不强制认证 |
+| 出站 | 具名 direct/dns/reject；HTTP(S) CONNECT、SOCKS5、AnyTLS、Trojan、VMess AEAD、VLESS、Hysteria2、TUIC v5、Shadowsocks 2022、标准 WireGuard 单/多 peer、TrustTunnel H2/H3、Mieru TCP/UDP 载体、MASQUE H2/H3 IP 与 H3 L4；协议依赖启用的 Cargo feature |
+| sing-mux | h2mux/smux v1/yamux、padding、TCP/UDP；brutal-opts 远端带宽协商及受限 Linux 本地发送侧设置 |
+| QUIC 配置 | HY2 独立 initial/max 接收窗口、秒 handshake-timeout；TUIC v5 入口ip、毫秒heartbeat、反向命名的stream/connection窗口、所有者池阈值、frame/fragment限制、PMTUD与UoT v2 |
+| 客户端 TLS | tls.custom-certifactes 证书内容；启动时合并可读系统根、WebPKI 与显式根并跨组件共享；TUIC v5 与其它 TLS 节点复用 cert/private-key 身份加载 |
+| 嗅探 | TUN/mixed TCP 的 HTTP1/HTTP2/TLS；TUN 与授权 SOCKS5 UDP 共用 QUIC v1/v2；域名/地址排除、强制条件和目标覆盖 |
+| Linux 自建设备 | auto-detect-interface、auto-route、IPv6 地址、CIDR 捕获/排除、输入接口与 UID/端口作用域、路由索引、strict-route 与 systemd-resolved DNS 接管；失败和停止时恢复本次修改 |
+| 运行状态 | 连接快照、流量计数和关闭；组与资源状态；规则命中、有效配置、受限 DNS 诊断 |
+
+[业务 HTTP 处理](http-processing.md) 是独立扩展：URL rewrite 与选择性 HTTPS MITM 使用单独输入，
+不向 Mihomo 主配置增加字段；CA 信任与安全存储归宿主管理。
+
+## 必须保留的边界
+
+- 业务入口只有 mixed-port 与 TUN；不支持 port、socks-port、listeners、redir/tproxy 或服务端协议配置。
+- tls 同时接受客户端信任根及 Controller 服务端 TLS 配置；无效显式客户端信任根拒绝配置，Mihomo 会跳过无效项。iOS/tvOS、Android 不保证取得完整系统信任库；
+  所有后端仍使用 WebPKI 校验，未复制 Go 的原生系统验证器。详细范围见 [TLS 契约](tls-client-fingerprint.md)。
+  独立测量 YAML 只接受 proxies 与同名客户端 tls 子集，不接受 TLS 服务端配置。
+- Shadowsocks 只支持三个 2022 cipher；插件支持 obfs 的 http/tls、v2ray-plugin/gost-plugin 的 websocket、JLS 和 strict ShadowTLS v3，UoT 仅 v2。
+  通用 ShadowTLS v3/JLS 与 VMess/Trojan 的流式 REALITY 沿实际 TCP TLS 消费路径接入，
+  各协议和 XHTTP 两腿的组合门禁见出站契约；不把公共字段推导成所有载体均可使用。
+- DNS 不提供独立 listen。DoQ、DoH/H3、prefer-h3、ECS、上游类型过滤、TLS 验证参数、
+  DoT 独立禁用复用、LRU/ARC 与显式 system/DHCP 上游已支持，
+  来源发现和物理绑定的可用平台及参考差异以 DNS 契约为准。
+  DoH 使用 GET、URL Basic 与实际 H3/H2/H1；详细解析角色、缓存、预算与过滤行为见 [DNS 契约](tun-icmp-dns.md)。
+- Provider/group 名称筛选、改名和 DOMAIN-REGEX 使用有界的常用复杂表达式子集，
+  支持 lookahead、定长 lookbehind、数字/ASCII 命名 backreference 与两种命名拼写。
+  混合捕获按 .NET 的未命名优先、命名随后编号，匹配与名称替换使用同一编号；
+  普通表达式保留 Rust regex 快速路径。不支持重复命名、显式数字组、递归、条件/平衡组或
+  完整 .NET 方言。编译、执行和输出预算保持；GeoSite regex 的现有线性语义不扩展。
+- gRPC 三协议共用选项和节点连接池。负 ping-interval 明确拒绝，不复制固定参考
+  HTTP/2 客户端的立即重复 PING；超出本机可表示期限的正秒数也明确拒绝，不复制 Duration 溢出。
+- 出站 mTLS 的文件身份由既有资源工作器检查，整对校验后供新物理连接使用；旧连接可继续，
+  更新不重建代理图或重置健康状态。活跃文件对的已发布 PEM 输入合计最多 8 MiB，超限或失败保旧；
+  内联身份与业务 HTTP/MITM CA 固定，详见 [TLS 身份](tls-client-fingerprint.md)。
+- 订阅元信息只在成功候选或合法 304 后发布，失败响应或坏候选保留旧值；
+  与 Mihomo 在读取响应头时更新的时点不同。数值仅接受有限且可表示的十进制数，
+  不保留非有限/溢出浮点转换的参考行为。
+- URI 转换接受 SIP003 的 obfs、v2ray-plugin 参数，不把插件 URI 参数通透转为 YAML。空 host 沿严格插件的默认值，
+  WebSocket TLS 仅由明确的 `tls` 标记启用。转换仍受当前严格节点/版本范围限制；HTTPS URI 节点默认校验证书，不复制参考
+  转换器的隐式跳过校验。Provider 缓存按精确 URL 与实际 header/UA 摘要隔离，
+  GeoData 按精确 URL 摘要隔离；凭据不写入来源元数据或 Debug。
+- WireGuard 使用标准用户态单/多 peer、最长前缀选择、reserved（数组或 Base64）、节点远端 DNS 与按需端点更新；
+  每个本地地址族最多一个地址，MTU 至少1280。无 peers 时顶层 allowed-ips 与参考一致地忽略。
+  peer 仅在实际使用时解析/建链；Mihomo 在节点初始化时解析所有 peer。
+- `mptcp` 是物理 TCP 首跳的可选能力，不改变协议报文。仅 Linux 的宿主管理、无
+  protector、显式/自动接口、专用 DNS binding 或源 IP 约束路径尝试；其余路径使用普通
+  受控 TCP，保留原保护与绑定的失败关闭。本机/对端不支持时允许 TCP 回退；
+  系统路径管理器、额外子流与出口网络配置仍归宿主，不将初始 socket 绑定推导为全部子流受控。
+  这比 Mihomo 的统一 MPTCP 开关更保守；原生 UDP/QUIC 不消费该字段。
+- `smux.brutal-opts.enabled/up/down` 的远端协商不限定客户端平台，要求对端实际启用
+  TCP Brutal；本地模块缺失不否定有效远端协商。Linux 仅对可确认独占的直连物理
+  TCP 尝试本地设置，不解包代理 hop、共享 H2/gRPC、XHTTP 多腿或 QUIC 的逻辑流，
+  `mptcp: true` 同样不设置本地 Brutal。Core 不加载模块或修改系统规则；单会话与
+  退役等待保持有界，详见 [sing-mux 契约](xhttp.md#通用-sing-mux)。
+- VLESS `packet-encoding` 省略、`xudp` 或 `none` 均使用 XUDP；`packetaddr` / `packet` 保留逐包 IP 地址编码，Vision 可使用 `none`。
+- Hysteria2/TUIC 的业务 UDP 始终可用；节点 `udp` 可省略或填 true/false，均不禁用它，组 `disable-udp` 仍生效。
+- 节点 UDP 能力按 [出站契约](outbounds.md) 声明；rule 模式跳过不支持 UDP 的目标，继续匹配后续规则。
+  global 模式和显式 DNS 出口不执行此跳过。负载均衡组按其声明能力参与规则匹配，实际选中成员仍须支持 UDP。
+- 未启用 mixed-port 或 TUN 时仍可运行 Controller 和资源任务。Controller 接受通配 IP、localhost 和空 host；secret 可选，见 [Controller API](controller-api.md)。
+  CORS 按 origins/预检/私网字段处理；HTTP 与 HTTPS H2/H1 共用 handler 与 Bearer，支持服务端证书文件更新和五种客户端认证模式。
+  /dns/query 查询真实上游；连接表按 UDP 目标流管理，memory 返回当前进程 resident bytes，平台口径不同。
+- fake-IP TTL 最小一秒；映射生命周期独立于 TTL。本地选择和映射存储不保证与 Mihomo 数据库互读。
+- DNS、fake-IP 与嗅探的 classical selector 对完整 AND/OR/NOT 求值；参考只提供域名或目标 IP，
+  其余元数据沿零值 TCP/HTTP、端口0、空入口名和未知身份，不伪造业务来源、53端口或进程身份。
+  selector 不发起额外地址解析或进程扫描，仍共用原决策预算。业务 IN-NAME 使用固定的
+  DEFAULT-TUN/DEFAULT-MIXED，内部请求没有业务入口名，不新增 listeners。
+- Apple、Android、Windows UWP 的网络设置、权限和 App 生命周期仍归宿主；Windows Wintun 使用外置 DLL。
+  借用 Unix fd 只复制并保留原描述符。Linux 本机捕获范围与网络恢复见 TUN 契约；旁路由、防火墙/NAT 不在当前范围。
+  六类进程规则与 find-process-mode 按真实可获取的本机身份工作，UID 仅 Linux/Android；
+  不复制 port-only、跨 namespace 或任一同 UID 进程的弱归属推断。权限、预算或平台无法证明时未知，
+  不提权、不增加 Android owner 回调；范围和扫描预算见配置契约。
+
+平台编译、内存回归、CLI 对照诊断、协议互通和压力测试是不同的验证层次，见
+[验收边界](acceptance.md)。任一层通过都不代表所有字段取值、组合、平台或真机行为已验证。
+
+QUIC 使用官方 Quinn 固定 Middle 接收窗口：每流为 max(initial, min(maximum, 4 MiB))，
+连接为 initial，不复现 Mihomo 的自适应窗口。initial>max 保留初值，max 大于 VarInt clamp，
+无法编码的 initial 明确拒绝；credit 通告沿 Quinn 原生实现。
+HY2 默认每流 64 KiB、连接 initial 4 MiB，优先多流公平性与接收驻留；
+较高 RTT 的单流可显式增大窗口，配置不按这些默认值钳位。
+HY2 正 handshake-timeout 的共享建链由节点持有，单次调用退出不会提前销毁它；
+每个等待调用仍受自己的期限约束，失败与 Stop 等待驱动清理。TUIC max-open-streams=1 接受但实际不能取得业务所有权；
+frame 无法容纳 TUIC 头时可解析，业务 UDP 发送失败，不额外拒绝TCP配置。支持模式的互通与窗口增大后的 RSS/吞吐/UDP loss 不由
+这些内存 fixture 证明，由最终 CLI/container 对照分别记录。
+
+Provider override 表达式的 upcase/downcase 使用 Rust 标准 Unicode 全映射，可能产生多个字符；
+输出、取消和计算预算保持。它不固定到 Go 的 Unicode 15 单字符映射，也不改变 IDNA 域名处理。
diff --git a/docs/outbounds.md b/docs/outbounds.md
index ce4fce2..9acdf65 100644
--- a/docs/outbounds.md
+++ b/docs/outbounds.md
@@ -7,33 +7,352 @@ VLESS/Vision/Encryption/JLS/ECH 见 [VLESS](vless.md)，XHTTP/sing-mux 见[专
 
 - 物理 TCP/UDP 只能由共享 Dialer 创建，保留 Android protect、Windows 物理绑定和受控解析。
   传输包装器只消费 IO，不另建 socket 或系统 resolver。
-- `dialer-proxy` 可引用节点或静态 select 组；与业务路由共享选择，完整 DAG 在配置期验证。
+- 全局与节点 `interface-name/routing-mark` 使用同一物理出口策略：节点非空接口/非零 mark
+  分别覆盖全局，空/0 继承；未指定接口时保留平台默认或 Linux TUN 自动识别。
+  接口支持 Linux、Apple 和 Windows；名称在建 socket 时核验，失效不回退。
+  回环物理目标保留本机路径，不套用公开接口或 mark；UWP 原有字面量回环门禁不变。
+  Android 显式接口尚不可用，protect 仍强制执行；非零 mark 仅 Linux 可用。
+  UWP 显式接口只能匹配 Provider 当前物理适配器，不能替换源地址/索引。
+  Linux 自建 TUN auto-route 的捕获规则只匹配零 mark；物理首跳保留非零公开 mark，
+  只有未配置 mark 才注入私有防环值。动态 Provider 候选沿用相同策略，失败仍保留旧代。
+- 代理链只由实际物理首跳消费出口策略；当前节点不覆盖其上游节点的策略。
+  上游组选择 DIRECT 时使用当前节点策略。XHTTP 两腿、多端点刷新、跳端口和新 QUIC
+  socket 沿用其所属路径的策略与选择快照；已建立连接不迁移。DNS、Provider、GeoData
+  和健康检查继续使用当前运行图的受控出口，不建立额外裸 socket。
+- `dialer-proxy` 省略/空串使用物理 Dialer，也可指定 DIRECT、COMPATIBLE 或引用节点、策略组；与业务路由共享选择，完整 DAG 在配置期验证。
   一次建链使用组快照和同一绝对期限；已有连接不随切组迁移，无自动 failover 或 DIRECT 回落。
+- 节点 `tfo` 缺省 false，具名 direct 同样可用。Linux 在只剩一个允许的物理 TCP 地址时
+  使用 TCP Fast Open；多地址保留普通串行/并发建链，其他系统使用普通受控 TCP。
+  代理链由实际物理首跳消费自己的 `tfo`，组选择 DIRECT 时使用当前节点值；不影响原生 UDP。
+  TFO 不把尚未连接的 socket 当成地址竞速赢家；实际地址来自同一出口校验/转换，
+  首读、空写、flush 和零上传半关闭也推进握手，并保留同一建链期限与同步 Stop。
+  不缓存、重新拨号或重放已接受的业务字节。Provider 同名覆盖保留显式 false。
+- 节点 `mptcp` 缺省 false，具名 direct 同样可用，Provider 同名覆盖保留显式 false；
+  均只接受非 null 布尔值。Linux 的无约束物理 TCP 首跳可尝试 MPTCP，保留既有
+  routing-mark 与防环策略；路径管理器、额外路径与系统路由由宿主管理，Core 不配置子流。
+  有 socket protector、显式或自动接口绑定、专用 DNS binding、源 IP 约束时使用普通
+  受控 TCP，避免内核额外子流越过初始 socket 的保护范围。Linux 自建 TUN 的
+  `auto-detect-interface` 同样属于接口约束；启用 MPTCP 的宿主须自行确保物理路径与防环。
+  其他系统或本机/对端没有 MPTCP 能力时允许普通 TCP 回退，但保护、绑定及实际 IO 错误
+  不触发绕过策略的重拨。代理链仅实际物理首跳消费自身值，组落到 DIRECT 时使用
+  当前节点值；原生 UDP/QUIC 不受影响。多路径协商不代表已建立多条子流。
+- 普通协议节点和具名 direct 的 `ip-version` 为 `dual`（默认）、`ipv4`、`ipv6`、`ipv4-prefer` 或 `ipv6-prefer`。
+  限制或排序该节点的物理服务器地址与本地解析结果，仍受全局 IPv6 开关约束。
+  不要求远端代理按相同地址族解析业务域名。
+- `experimental.dialer-ip4p-convert` 缺省 false；开启后，物理 TCP 与 SS2022、SOCKS5、WireGuard
+  的原生 UDP 节点端点识别 `2001:0000::/32`，按编码的 IPv4/端口建立实际首跳。
+  转换先于实际地址族、源地址和接口绑定；逻辑 server、TLS SNI、认证、代理链目标保持原值，
+  收包校验使用实际端点。经代理的逻辑端点不在本地强制转换，实际物理首跳按其自身策略处理。
+  不转换 DIRECT 无连接业务 UDP、DNS 答复或其他原生 QUIC 节点入口，不增加缓存或连接池。
+  域名的编码地址不能通过转换取得新的回环例外；UWP 物理绑定下同样拒绝编码地址转为回环。
+  显式普通回环节点保留原行为；解析查询仍遵循 DNS 的既有 IPv6 开关，不为 IP4P 自动增加 AAAA 查询。
 - gRPC/legacy H2 首次读取延迟响应头时先检查原建链期限，即使响应已就绪也不能绕过
-  超时；响应头已确认后的业务读取不再受该期限限制。
+  超时；响应头已确认后的业务读取不再受该期限限制。VMess／Trojan gRPC 由外层在原期限内
+  等待对端 H2 SETTINGS、提交并 flush 完整认证请求，此后允许 client-first 业务等待响应，
+  不再沿用该期限；未完成 H2 握手或请求提交时仍受原期限限制。
 - HTTP、SOCKS5、TUN、DNS 选路及 node-only `measureDelay` 使用同一连接器。
-  UDP 默认为 false；收发预算分别逐层扣封装开销，超限不截断交付。
+  除 Hysteria2/TUIC 的业务 UDP 始终可用外，普通协议节点的业务 UDP 默认为 false；
+  组 `disable-udp` 仍可禁用业务 UDP。收发预算分别逐层扣封装开销，超限不截断交付。
+  Hysteria2/TUIC 的固有能力声明不替代对端、上游和实际数据报预算的检查。
+- UDP 关联复用由共享路由层管理。DIRECT、Mieru、TrustTunnel、WireGuard 内层 UDP、
+  MASQUE/IP 内层 UDP 和 VMess packetaddr 均提供逐包目标与实际回包来源，可复用多目标关联。
+  开启逐目标连接追踪时，仅同一来源、同一具体出站实例和同一资源代际的未改写 IP 目标共享；
+  逐目标路由、统计、关闭、关联退役和旧回复隔离见[资源策略](runtime-resource-policy.md#udp)。
+  域名、fake-IP 和需要地址还原的目标保持独立。VMess raw 的首目标约束不变；
+  Gecko 等固定对端的底层适配也不因此获得多目标能力，外层业务关联按自身能力处理。
+  每层明确声明共享能力，透明包装传递底层声明，不根据外层协议或字段推断其内部载体可共享。
+- 所有普通节点都可启用公共 `smux` 包装，使用节点自己的正常 TCP 传输与独立 mux 池，
+  业务路由、`dialer-proxy`、provider 代际与测速都使用最终包装器。
+  `only-tcp: false` 提供 mux UDP，包括底层 `udp: false` 或仅支持 TCP 的节点；
+  true 则原样委托底层 UDP，继承其能力。组 `disable-udp` 仍生效。
+  对端必须解码 sing-mux；普通 HTTP/SOCKS5 listener 不因此自动提供解码。
+  字段、半关闭及池边界见 [通用 sing-mux](xhttp.md#通用-sing-mux)。
+- `smux.brutal-opts` 在新 mux 会话接纳业务前完成一次远端 TCP Brutal 带宽协商，
+  不限定客户端平台；对端必须支持并启用它。本地上行仅在 Linux 可证明独占的直连
+  物理 TCP 上尝试，保护与绑定保持。代理 hop、共享/多腿传输及 `mptcp: true` 不设置
+  本地算法，即使 MPTCP 已回退普通 TCP；完整协议范围见上述 sing-mux 契约。
+  Core 不安装或加载模块，本地不可用不否定有效远端协商；参数设置失败恢复旧算法，
+  恢复失败终止物理 socket。Brutal 使用单会话池，退役等待旧业务释放，沿原期限与 Stop。
 - TLS 使用共享 WebPKI、叶证书 pin/非叶信任锚与 skip 策略。pin 不匹配不能被 skip 绕过，
-  TLS 握手签名始终验证。节点策略与恢复缓存不可变、互相隔离，标准 TLS 总票据预算为 4。
+  TLS 握手签名始终验证。节点策略固定，恢复缓存按节点和身份代隔离，标准 TLS 总票据预算为 4。
   字段及模板详见 [TLS 证书与指纹](tls-client-fingerprint.md)。
-- 未知字段、null、错型、非法枚举或不适用的传输选项在网络 IO 前拒绝。
+  SNI/servername 空串使用协议默认名称；pin/name-cert-verify 空串关闭对应覆盖。
+  certificate/private-key 均省略或为空时不启用客户端身份；非空身份仍须成对且有效。
+- 未知字段、错型、非法枚举或不适用的传输选项在网络 IO 前拒绝；显式 null 通常也拒绝，
+  HTTP 出站已有的可选 TLS 字段保留 null 等同省略的行为。
   凭据、UUID、业务目标和完整请求不进入 Debug/错误；资源与 Stop 见[公共策略](runtime-resource-policy.md)。
 
+`experimental.quic-go-disable-gso` 缺省 false，`quic-go-disable-ecn` 缺省 true。
+这两个会话配置只由 Linux 上 TUIC、XHTTP H3、DoQ/DoH H3 的 DIRECT 物理首跳消费，
+使用共享 Dialer 已保护、已绑定的同一 socket；不修改宿主进程环境。
+GSO 分段批次依实际路径与预算每次最多 10 段、整批最多 65,507 字节，每段保留原 UDP 预算。
+未分段的数据报沿用原方向预算，IPv6 可达 65,527 字节；关闭 GSO 后只发独立数据报。
+DoQ/DoH H3 的当前 DIRECT 发送预算为 IPv4 65,507、IPv6 65,527 字节，接收预算为 4 KiB，分段能力为 1；
+这些 DNS 路径使用同 socket 的原生收发与 ECN 元数据，不据此声称实际 GSO 批量发送。
+ECN 开启时传递实际发送标记和接收元数据；关闭时不发送/交付 ECN 标记。
+系统无法开启 ECN 接收元数据时，保留同一受保护 socket，沿用原单包、无元数据路径。
+GRO 保持关闭，接收仍使用一个有界完整包，不放大 QUIC 接收区或 socket 缓冲。
+代理 hop、HY2 的 pacer/混淆/Realm、quiche 后端以及非 Linux 平台当前保持单包且不保留 ECN；
+这些路径不声称消费新元数据能力。停止时撤销物理 socket 的共同租约；保留已关闭的 QUIC
+连接或写就绪 poller 不会延长物理 fd 的生命周期。GSO 的明确能力错误只关闭后续批量发送，失败批次
+作为 UDP 丢失交给 Quinn 的正常 ACK/重传；不会立即重发该批次，不掩盖地址、策略或 ECN 错误。H3 的正常传输、认证、PMTUD、取消及同步 Stop 仍沿原所有者。
+
+VMess + TLS、Trojan、AnyTLS、TrustTunnel、VLESS 和 Hysteria2 支持 `ech-opts.enable/config/query-server-name`，
+静态优先和动态节点 DNS 来源、后端算法及失败边界见 [ECH](vless.md#ech)。
+TUIC 的固定参考未消费 ECH，因此不接受该字段。
+
+## 流式安全身份
+
+VMess/VLESS 在 `tls: true` 时接受 `shadow-tls-opts` 或 `jls-opts`；Trojan/AnyTLS
+沿其固定 TLS 路径接受这两种身份，不增加 `tls` 开关。ShadowTLS 必须显式
+`version: 3` 和非空 `password`，SNI 使用节点现有 `servername/sni`；SS2022 插件
+仍使用自己的 `plugin-opts.host`。普通 TLS、ShadowTLS、JLS、REALITY 是同一腿的互斥模式，
+不叠第二次 TLS，也不在认证失败后降级。ShadowTLS/JLS 只用于对应节点已有的 TCP 承载传输；
+XHTTP 仅 H1/H2，主腿和下载腿独立持有身份。两者不能与 Vision 或 ECH 混用。
+
+ShadowTLS cover 接受共享 pin/skip/name-cert-verify 与成对 `certificate/private-key`，
+它们只影响 cover 握手；JLS 以用户名/密码认证，不能混用证书策略或 mTLS。
+ShadowTLS/JLS 均使用原生完整 TLS 1.3 认证且关闭会话恢复；指纹不能替代密码认证。
+受控上游、建立期限、取消和 Stop 仍由原连接器所有者管理。
+
+VMess 的 TCP/HTTP/H2/gRPC、Trojan 的 TCP/gRPC 可用 `reality-opts`，须提供有效的
+`client-fingerprint`；WS/HTTPUpgrade 不接受 REALITY。REALITY 不混用证书策略、
+mTLS 或 ECH，沿用 [REALITY](reality-wire-protocol.md) 的无回退身份与密钥交换边界。
+
+## 功能出站
+
+具名 `direct`、`dns`、`reject` 只需 `name/type`，没有代理服务器端点，均提供 UDP。
+`direct` 另接受 `ip-version/interface-name/routing-mark/tfo/mptcp`，通过共享 Dialer 直连业务目标，
+域名使用当前会话的 `direct-nameserver` 角色，并保留其取消和地址族策略。
+`dns/reject` 不接受未被其实际消费的节点出口参数。
+
+`type: dns` 将普通规则选中的 TCP/UDP DNS 查询交给当前会话的共享解析器；目标端口不限于 53，
+不新增 DNS 监听端口或解析引擎。TCP 与 TUN DNS 接管共用有界的长度帧处理，支持连续查询及半关闭；
+UDP 保留原目标作为响应源，每个关联只保留一个活动查询、一个待处理请求和一个待交付响应，
+队列已满时丢弃新请求。查询及响应上限为 4096 字节，响应还受入口实际 UDP 预算限制。
+丢弃会话取消其任务，停止节点关闭准入并等待所有工作退出。独立测量没有运行会话解析器时，
+不能使用具名 DNS 出站。
+
+具名 `reject` 立即结束 TCP，丢弃 UDP 并立即结束其接收路径；没有 `action` 字段。
+内置 `REJECT` 保持建链拒绝及 UDP 逐包丢弃。
+内置 `REJECT-DROP` 的 TCP 读写等待同一个 60 秒期限，不发往远端、不另留请求副本，
+Stop 立即取消等待；UDP 逐包丢弃，沿用关联的正常空闲清理，不套用 TCP 延迟。
+`COMPATIBLE` 在规则、代理组、DNS 上游选择和 `dialer-proxy` 中使用直连语义。
+
+## 规则重匹配
+
+`type: rematch` 是规则控制，只有 `name/type/target-rematch-name/target-sub-rule`，
+没有服务器、物理连接或额外任务。两个 target 字段至少提供一个非 null 值；null 与省略一致。
+省略某字段保留本次决策原值。`target-rematch-name: ''` 清除标记；非空字符串按原样设置，
+`REMATCH-NAME,a/b` 将各项 trim 后逐字、区分大小写比较，不接受空项。
+
+`target-sub-rule` 指向已定义子规则列表时，从该列表首条重新求值；存在但为空的列表耗尽后 DIRECT。
+空字符串或不存在的名称回到主列表首条；省略时保留当前根列表。
+它不是 `SUB-RULE` 调用，不返回原调用位置，也不要求名称在配置时存在。
+主列表中的普通 `SUB-RULE` 调用和 `PASS/PASS-RULE` 保留原作用域。
+
+业务 rule 模式及 DNS `#RULES` 共享此流程，组间接选中 rematch 时也生效，先于 UDP 能力检查。
+重入保留来源、目标、已解析地址、process 结果和同一次决策的取消、期限、总执行预算与规则开关快照。
+同一决策最多进入 32 个 rematch 节点，重复节点名称或超预算即失败关闭；不会建立空连接或回落 DIRECT。
+已建立连接保持原路径。global 模式、显式 DNS 出口、`dialer-proxy`、健康探测和 node-only
+`measureDelay` 不执行该控制；物理建链选中它时拒绝，测速配置直接拒绝 rematch 节点。
+
+## HTTP / HTTPS CONNECT
+
+`type: http` 提供 TCP CONNECT；`tls: true` 在代理链路使用共享 TLS 与证书策略。
+支持 `username/password`、`headers`、`sni`、`skip-cert-verify`、`name-cert-verify`、
+`fingerprint` 及成对的 `certificate/private-key`（PEM 或文件路径）。用户名和密码均非空时发送 Basic 认证。
+HTTP CONNECT 本身不提供 UDP，也不接受 `udp` 字段。公共 smux 可承载 UDP。
+握手沿用原期限，失败关闭，
+成功后保留响应头后的业务字节。启用此协议需要 `outbound-http` feature。
+
+## TrustTunnel
+
+`type: trusttunnel` 提供 H2/H3 CONNECT TCP/UDP，使用 `outbound-trusttunnel`。
+quic 缺省 false 使用 TLS + HTTP/2；true 使用 QUIC v1/TLS1.3 + HTTP/3，无 0-RTT。
+username/password 默认空字符串，始终发送 Basic 认证；不增加非空限制。
+SNI 缺省/空串使用 server，ALPN 缺省/空列表随模式使用 h2/h3，自定义列表必须包含该值，
+H3 实际握手必须协商 h3；H2 接受协商 h2，或在对端未返回 ALPN 时使用 H2 prior knowledge，
+兼容 Mihomo listener。明确协商其他协议仍拒绝，不回退 HTTP/1。两模式使用共享证书策略、mTLS 和 ECH。
+client-fingerprint 仅 H2 消费；H3 接受该字符串但不校验模板名、不应用 TCP ClientHello 模板。
+
+三项 max-connections/min-streams/max-streams 全为 0 才应用 8/5/0。
+逻辑客户端池先选择活跃流最少的客户端，零活跃流始终复用。
+max-connections > 0 时，达到客户端数上限或该客户端流数 < min-streams 即复用；
+max-connections <= 0 时，只在 max-streams > 0 且流数 < max-streams 时复用。
+各分支未满足复用条件时增加客户端。
+混合配置和负阈值不额外拒绝；池参数是分配阈值，不是业务流总量上限。
+每个逻辑客户端复用自己的物理连接，空闲30秒后关闭；H3 的 QUIC 空闲期限74秒，
+不增加周期 QUIC keepalive。逻辑空闲回收与 QUIC 传输空闲是不同期限。
+
+TCP 流使用原始字节，无 gRPC 帧；建立流后独立消费响应头，允许服务端等待 client-first 业务。
+udp 缺省 false，开启后使用 `_udp2` CONNECT 承载多目标数据报。
+health-check 缺省 false，开启后使用 `_check` CONNECT；成功 CONNECT 响应重置 7 秒计时，
+单次探测期限为7秒。两模式的UDP业务都使用可靠CONNECT流，不使用QUIC DATAGRAM。
+关闭只结束当前逻辑流；节点Stop取消并join池、探测、H2/H3及QUIC驱动，释放受控上游。
+
+H3 外层无论业务 udp 是否开启，都要求受控上游提供双向至少1200字节UDP路径；
+QUIC payload 最大1400并取实际双向上游预算交集，PMTUD不超过该预算，不回落TCP或DIRECT。
+congestion-controller 的 cubic、new_reno 使用官方 quiche 算法；bbr、bbr_meta_v1、
+bbr_meta_v2 均使用 quiche 的 Bbr2Gcongestion。省略或未知名称使用 cubic。
+H2 不消费 congestion-controller。
+
+## Mieru
+
+`type: mieru` 使用 `outbound-mieru`，底层 transport 必填 TCP 或 UDP，
+两者均承载 TCP 和 `udp: true` 的多目标 UDP Associate。用户名、密码各为1–64 UTF-8字节，
+不 trim；XChaCha20-Poly1305 分段认证使用物理连接建立时的时间派生密钥。
+UDP 载体发送复用既有 boring 的原位 AEAD；接收在启用低熵编码时保留 RustCrypto，
+其余接收使用 boring。收发方向各独占认证上下文，后端选择不改变低熵编码或协议字节。
+TCP 载体保留 RustCrypto，均使用原 ring PBKDF2 派生规则，不启用 TLS。
+业务目标通过协议内 SOCKS 请求传递，不进行 SOCKS 认证方法协商。
+
+port 与非空 port-range 互斥；范围完整匹配十进制 `起点-终点`，两端为1–65535且起点不大于终点。
+每次新物理连接随机选择范围内端口，通过共享 Dialer 建链，复用连接保留原上游选择。
+MULTIPLEXING_DEFAULT/LOW 对应因子1，MIDDLE/HIGH为2/3；按可复用连接数及因子随机选择
+复用或新建，OFF始终新建。DEFAULT/LOW 将TCP CONNECT与UDP Associate分池。
+TCP载体的TCP CONNECT仅复用没有活动会话和建流预留的空闲连接，并发TCP会话使用独立载体，
+避免慢读会话阻塞兄弟流；UDP Associate保留活动连接的概率复用。
+UDP载体的两类业务均保留各自池内的活动连接概率复用，分别持有发送字节预算与命令队列。
+DEFAULT/LOW 的 UDP载体 UdpAssociate 独立池，在原单向流预算恰为32 KiB时，每物理载体
+共享96 KiB发送信用；同载体各SID共用，待确认分片继续持有许可，首次发送不归还信用。
+这是原默认资源策略的例外：低层显式传入相同32 KiB值也使用96 KiB载体发送信用；
+其他非默认小/大预算、TCP业务、TCP载体及OFF/MIDDLE/HIGH仍取原值。
+每SID接收预算、发送块上限、四写准入、命令FIFO2和物理TX8不随此信用扩大。
+LOW的UDP载体在原复用桶内优先选择活动会话与建流预留合计较少的连接，同负载按原随机起点选择；
+新建桶概率不变。该合计是建流时的非原子调度估计，不作为容量准入或会话上限。
+上述分池不扩大接收预算，但分池和并发TCP仍可能增加物理连接和驱动数量。MIDDLE/HIGH保持两类业务共池，
+共享TCP载体仍可能发生慢读队头阻塞。因子不是业务流上限。空闲和累计传输量使连接停止接收新流，
+已有流继续工作；退休连接在空闲期限后回收。
+
+HANDSHAKE_DEFAULT/STANDARD 发送请求并等待 SOCKS 回复；HANDSHAKE_NO_WAIT 延迟至
+首个业务写入发送请求和数据，再确认回复。枚举必须使用完整前缀。
+标准握手完成后直接交付逻辑字节流，不保留懒握手状态。
+关闭单个流仅释放其会话；节点 Stop 取消并 join 物理读写、清理及 UDP 读取任务。
+写队列、接收字节及 UDP 单包受运行时预算约束；取消不会重放加密帧。
+TCP 载体的 UDP Associate 接收信用取原流容量与单包接收预算（含最大 SOCKS 首部和
+四字节封装）的较小值；发送块与 TCP CONNECT 窗口不变。跨信用边界的已解密帧
+按块复制，包括最后的短尾片，避免排队切片继续持有整帧；物理读取仍先完整认证一帧。
+UDP 包解析后由响应持有已验证的接收缓冲，仅移除 SOCKS 首部视图，避免再次复制 payload。
+UDP 载体的 UDP Associate 写入在原字节预算与命令 FIFO 准入后返回，不逐包等待首次物理发送。
+同会话最多连续准入四笔逻辑写；第五笔非空写在分配新payload与许可前，等待同批最新写入的首次发送回执。
+最新回执完成后才开启下一批；空写不作发送屏障，已就绪的首次发送错误仍优先返回。
+显式 flush 和 shutdown 仍等待同会话最新写入的首次发送完成；准入不释放发送许可。
+TCP业务的写入和flush，以及TCP载体的完成边界保持不变。
+UDP 载体的标准握手 TCP CONNECT 流在显式 shutdown 时，先等原首次发送完成，再等本会话
+待确认数据的累计 ACK，随后发送原 Close。flush仍只等待首次发送，不等待整个物理载体。
+对端关闭或底层终止保留原结果；NoWait、UDP Associate、物理TCP、Drop和活动Stop沿原关闭边界，
+不新增ACK等待期限。
+UDP载体上已opened的TCP会话本地Close首发完成后，同一物理载体最多保留16条小型关闭元数据，
+以100 ms间隔调度至多两次best-effort重发；满额只放弃最旧重发记录，不拒新业务或改变原首发。
+重发在接收处理后优先占用原每轮TX8中的至多一次机会，不扩大TX额度；本轮接收耗尽额度时顺延。
+缓存不持有会话State、payload或发送许可；认证后的CloseResponse或同SID新写入撤销旧记录。
+Stop和载体原退休直接释放记录，不等待重发，也不延长接收grace或ACK等待。
+这是有限关闭恢复，不是可靠FIN，不补偿接收方向缺失的DATA，也不保证拥塞下的关闭期限。
+UDP 底层使用可靠会话，提供累计 ACK、重传、有序交付、分片和窗口。
+UDP Associate 在每次成功发送后固定该次重传间隔，后续 RTT 更新不移动已发送段的期限；
+TCP CONNECT 仍按最新 RTT 计算。两类业务保留原退避、超时上限、快速重传与超时 flight 归并。
+密钥固定于物理载体，每包使用显式 nonce；重传保留明文，重新生成 nonce 和时间戳。
+收发分别取1400字节 MTU 与真实上游预算的交集。正常接收的应用未读队列与乱序缓存
+分别持有接收字节预算，默认各32 KiB。TCP CONNECT在原预算至少32 KiB且可容纳单包时，
+给乱序缓存额外32 KiB固定余量，默认乱序容量64 KiB；UDP Associate保持原预算。
+额外余量不通告给对端，窗口仍扣除该余量与缺失首片预留，沿原预算计算。
+累计 ACK 只在连续数据成功进入应用队列后前移。
+乱序缓存优先保留较近的前缀，信用不足时只回收更远且尚未累计确认的数据。
+小于单包的应用预算沿用一个物理 Partial 槽。远端关闭保留已接收的连续前缀供读取。
+已建立 TCP 的正常 CloseRequest 若在原至少32 KiB预算下携带尚未收齐的末尾序号且无 Partial，
+最多保留首次收到关闭后的100 ms来接收该序号前的在途数据；重复关闭不延长期限，
+原乱序、字节及交付预算不变，新写入仍被关闭。错误关闭、UDP Associate及小预算沿原关闭路径。
+Stop 结束驱动并回收驱动缓存，不等待应用读取；外部仍持有流的已递交数据由读取或释放流回收。
+待确认明文仍持有发送预算。物理驱动每轮最多接收8个就绪数据报、发送8个数据报，
+ACK 优先于该会话的批量数据，会话轮换服务；接收每8包让出一次执行机会。
+Mieru UDP 向共享 Dialer 请求512 KiB物理接收缓冲；当前Linux接受时通常为1 MiB有效容量。
+这是内部性能提示，OS可钳位或拒绝；保留原socket、protect、接口绑定及停止所有权，
+不改变逻辑包预算，不新增配置字段，协议自有池仍管理自己的物理载体。
+创建60秒后的 UDP 载体停止接纳新会话，已有会话继续。
+`traffic-pattern` 接受标准 Base64 编码的 Mieru protobuf，保留可选字段的省略与显式零值。
+支持 seed、unlockAll、TCP 控制帧分片/间隔、nonce 前缀、padding 及低熵编码；
+省略或空值使用协议默认策略。模式仅控制发送，接收不要求对端使用相同模式。
+低熵编码作用于数据密文，认证 tag 保持原值；按真实载体预算缩小明文分片，
+不会扩大队列或接收预算。重传重新应用 nonce 与 padding，控制帧分片由物理写任务完成。
+
+## MASQUE
+
+`type: masque` 由 `outbound-masque` 提供。缺省、空串及非 `h2`/`h3-l4proxy`
+的 network 使用 H3 `cf-connect-ip`；每个节点按需建立一条共享 IP 隧道，TCP/UDP
+经同一个内部 `vole-netstack`，不创建系统 TUN。`network: h2` 使用严格 H2 TLS
+与普通 CONNECT，设置 `cf-connect-proto: cf-connect-ip` 和 `pq-enabled: false`；
+精确 HTTP 200 后交付隧道，DATA 内 DATAGRAM capsule 直接携带原始 IP，不添加 context ID。
+H2 每 30 秒发送空闲 PING，ACK 期限为 15 秒；不因隧道暂时空闲而回收。
+H3 等待实际 peer SETTINGS 中的
+现代 DATAGRAM 支持，同时发送现代与旧 DATAGRAM setting；原始 IP 使用请求流关联及
+context ID 0。控制 capsule 有界解析，发送 IPv4/IPv6 完整 route advertisement。
+H3 IP 模式在所有受控抽象 socket 平台启用有界 QUIC PMTUD；具有 IPv6 本地地址时，
+就绪前确认真实 DATAGRAM 预算可承载 1280 字节 IP 包，未满足时按建链期限失败。
+`ip`/`ipv6` 最多提供两条本地 prefix，标签不强制地址族；未带前缀分别补 /32 与 /128。
+mapped IPv4 归一，重复地址取较长前缀，同族两地址按目标选择源地址。
+MTU 缺省/零值为 1280；只有 IPv4 时允许 68..65535，存在实际 IPv6 时至少 1280。
+收包预算与发包 MTU 分离；TCP 的有效 MSS 和经过活动 tuple/已发送序号验证的 ICMP
+PMTU 反馈按连接生效，通过包层软件分段恢复，重传由官方 smoltcp 的定时器触发。
+初始发送 MTU 取配置与真实隧道预算的交集，避免已知预算下的持续二次分段。
+内部队列、capsule 和 packet 均有界，停止等待其工作任务回收。
+H3 IP 的物理 UDP 请求沿原受控 dialer 携带 512 KiB 接收缓冲提示；系统可限制或忽略该提示，不构成进程 RSS 或真机内存保证。
+当底层实际报告发送预算缩小时，只反馈当前过大包，不关闭其它业务流。
+稳定路径的 MTU 下降目前不会自动触发 QUIC PMTU 重新探测。
+
+`network: h3-l4proxy` 使用 Cloudflare L4 HTTP/3 CONNECT，每个 TCP 目标独占请求流，共享受控 QUIC 连接；
+等待 2xx 响应后才交付业务流，拒绝响应不取消其它流，节点 Stop 等待所有驱动退出。
+基础 UDP 始终关闭，`udp: true` 也不启用它。
+
+`remote-dns-resolve: true` 且 `dns` 非空时启用节点私有 DNS；否则忽略 dns 内容，
+业务域名沿原受控本地解析。IP 模式的 DNS 查询通过同一个内部栈，L4 仅支持经节点的
+TCP DNS 传输，不将 UDP 查询改为 TCP 或改走 DIRECT。节点 DNS 沿用 Core DNS 上游格式，
+不继承全局 prefer-h3；解析上游域名仍使用节点外部的 bootstrap 上下文，避免自递归。
+system/DHCP 来源沿共享物理来源策略处理，网络快照更新清理节点缓存；不可用时失败。
+私有 resolver 不保留空闲连接，由节点 Stop 关闭并等待驱动。
+
+IP 模式 `handshake-timeout` 为整数秒：0 使用创建调用的建立期限，创建者取消会终止
+尚未就绪的创建；正值使用节点拥有的独立期限，创建者或其它等待者取消不终止共享创建。
+已交付业务不继承建立期限；节点 Stop 取消创建和业务并等待全部任务。
+
+private-key 是标准 Base64 SEC1 ECDSA 私钥，public-key 是标准 Base64 ECDSA SPKI。
+客户端发送对应自签证书，服务端每张证书都必须使用固定公钥；不检查证书名称、
+信任根或有效期。skip-cert-verify 只关闭公钥固定，握手签名仍验证；
+name-cert-verify 是 Mihomo 保留的占位字段，不消费。每个物理连接使用独立 TLS 配置，
+关闭恢复与 0-RTT；H2 使用 rustls/ring，H3 使用 quiche 与共享 Boring，
+两者保留相同的公钥固定与握手签名校验。
+
+SNI 缺省或空串在 IP 模式使用 consumer-masque.cloudflareclient.com，
+L4 使用 consumer-masque-proxy.cloudflareclient.com。IP URI 缺省为
+https://cloudflareaccess.com，不支持含变量的 IP flow URI template。
+L4 不解析 ip/ipv6/uri，不消费 mtu 或正 handshake-timeout；负超时拒绝。
+QUIC 使用 20 字节 CID、初始 payload 1242 与受控预算交集、30 秒 keepalive；
+拥塞字段采用上述 TrustTunnel H3 的算法映射。
+`ip-stack` 支持省略/auto 与省略/cubic，不把其它栈或算法映射为现有栈。
+
 ## SOCKS5
 
 仅 SOCKS5 CONNECT / UDP ASSOCIATE；用户名密码成对配置，不支持 SOCKS4。
 TCP 保留域名交由上游解析；UDP 由控制连接拥有，校验 relay 来源并保留实际回包目标。
+Controller 跟踪的同源、同具体节点和同代际的未改写 IP 目标共享 UDP ASSOCIATE，
+逐目标统计与关闭保持独立；目标退出使关联退役，新目标使用新关联，旧回复不能进入重建目标。
 上游为 select 组时，控制连接和后续 UDP 数据报使用同次建链快照。
-SOCKS5 不提供 TLS、证书 pin 或 ClientHello 模板；它的预算独立于 TUN MTU。
+`tls: true` 使用共享 TLS、`skip-cert-verify`、`name-cert-verify`、`fingerprint` 和
+成对的 `certificate/private-key`（PEM 或文件路径）。TLS 名称固定使用 server；不接受 sni、alpn
+或 ClientHello 模板。TLS 保护 CONNECT / UDP ASSOCIATE 控制连接，普通 UDP relay
+数据不经过 TLS；预算独立于 TUN MTU。TLS 关闭时不能配置证书字段。
 
 ## AnyTLS
 
 支持 v2、兼容 v1 的会话、内置填充与 UoT v2。password 为 1–1024 UTF-8 字节；
 SNI 默认 server；ALPN 省略/空列表不发送，非空保持顺序，不强制选中某协议。
-不开放 TLS 版本、ECH、mTLS、REALITY、填充和会话参数；命名指纹沿用共享 TLS。
+支持独立的 `name-cert-verify` 和成对内联 PEM 或文件路径 `certificate/private-key` 客户端身份；
+支持共享静态/动态 `ech-opts`，强制真实 TLS1.3 接受后才能发送认证与业务；
+不开放 TLS 版本、REALITY和填充参数。命名指纹沿用共享 TLS。
 
 连接先发送 SHA-256 密码摘要、认证填充和首个会话批次。Settings 固定声明 v=2 和
-填充方案 MD5，不附产品/版本标识；合法 ServerSettings v>=2 启用 v2，否则兼容 v1。
+填充方案 MD5，`client-metadata` 原样写入 client 值，缺省为空，不自行填产品/版本标识；
+metadata 不含换行且须适合 u16 Settings 帧。合法 ServerSettings v>=2 启用 v2，否则兼容 v1。
 首个流与认证批次一起发送。复用空闲会话时，v2 写 SYN 和目标后即返回流，再监视
 最长 3 秒 SYNACK；v1 不等待。非空 SYNACK、超时、协议/读写器错误销毁整个会话，
 已返回流在后续 IO 报错。仅 open 返回前发现空闲会话失效时可新建一次；不重放业务。
@@ -41,12 +360,20 @@ SNI 默认 server；ALPN 省略/空列表不发送，非空保持顺序，不强
 未知流、控制 ID/方向错误、越界负载或非法设置是会话级错误；Alert/非空 SYNACK
 仅返回固定诊断，不向日志或调用方回显远端内容。
 一个物理会话同时仅一个活动流，完整结束后入空闲列表；优先复用序号最大者。
-检查/空闲超时均 30 秒，不预热；首次使用才启动清理 worker。ID/序号耗尽关闭会话。
+`idle-session-check-interval` / `idle-session-timeout` 使用整数秒，缺省或 <=5 回到30秒；
+`min-idle-session` 缺省/负值为0，只保留现有空闲会话，不预热。回收从最新会话开始，
+未过期项计入保留数，必要时刷新已过期项的空闲时间。首次使用才启动清理 worker。
+`disable-reuse: true` 不启动回收 worker、不领取/归还空闲会话，逻辑流结束即关闭该会话。
+ID/序号耗尽关闭会话。
 
 写命令队列 2 项，流接收容量按运行时预算推导且至少 1；活动会话不设全局数量上限。
 UoT v2 使用 `sp.v2.udp-over-tcp.arpa:0` 数据报模式，首包含请求，之后每包携带
 IP/域名目标，协议负载最多 65,535 字节并取调用方预算交集；响应队列 1 项。
-关闭/取消/丢弃 UoT 同时结束读取任务和底层流。
+同一源关联、具体节点和资源代际内，未改写 IP 目标共享 UoT 传输；逐目标统计、
+关闭和固定出口保持独立，具体退役边界见[资源策略](runtime-resource-policy.md#udp)。
+单次发送 future 被取消时，最多保留一个未完成帧及写入偏移；后续发送或接收先完成该帧，
+不重复首部或破坏后续边界。首帧仍沿用原建链期限；实际 IO 失败或超时使关联失效。
+显式关闭、父作用域取消或丢弃 UoT 同时结束读取任务和底层流，不等待未提交帧的写入容量。
 
 填充为内置方案；新物理会话持有不可变快照，合法 UpdatePaddingScheme 仅影响后续
 会话，非法更新只产生有界警告。文本、条目、逻辑填充量和帧负载都有界。
@@ -62,9 +389,12 @@ begin_shutdown 同步禁止新流、清空空闲并取消所有会话；shutdown
 
 SNI 默认 server；WS Host 只覆盖 HTTP authority，不作为 SNI 回退。ALPN 默认 TCP 空、
 WS http/1.1、gRPC h2，显式列表及实际协商均须满足传输，不能静默降级。
+`name-cert-verify` 只覆盖证书验证名；成对的内联 PEM 或文件路径 `certificate/private-key`
+用于客户端 mTLS 身份，共用标准 TLS 的验证、指纹与恢复策略。
 
 WS path 默认 /，可带 query；头字段不得覆盖握手保留头或大小写重复。early-data
-0–2048 字节，启用时默认 Sec-WebSocket-Protocol，可自定义；空头名表示路径后缀，
+按配置最大值与当前请求16KiB头预算的较小值发送，不预留配置上限。path 的 `?ed=N`
+覆盖显式ED配置并移除ed参数；启用时默认 Sec-WebSocket-Protocol，可自定义；空头名表示路径后缀，
 此时禁止 query。禁用时不能附 ED 头名。首请求头与剩余数据只按序发送一次。
 `ws-opts.v2ray-http-upgrade:true` 使用原始 HTTPUpgrade 流，不发送 WebSocket 帧。
 普通模式在有效 101 后发送剩余认证前缀；`v2ray-http-upgrade-fast-open:true` 提前
@@ -74,10 +404,21 @@ fast-open 需要 upgrade。
 Upgrade 的 ED 仅允许默认 Sec-WebSocket-Protocol 头（大小写不敏感），不支持
 自定义头或路径 ED。101/头限额/截断失败不重放前缀，响应头后的字节保留给协议。
 这些选项同样适用于 VMess 的明文和标准 TLS；不改变各协议认证、UDP 编码或关闭责任。
-gRPC service-name 必填，普通名映射 /name/Tun，以 / 开头则为完整路径；不开放池参数。
+gRPC 的 HTTP authority 使用非空 SNI，否则使用 server，不包含端口；不改变物理拨号地址。
+gRPC 选项与 VMess/VLESS 共用：省略或空 service-name 默认 GunService，普通名映射 /name/Tun，以 / 开头使用完整路径；省略或空 user-agent 默认 grpc-go/1.36.0。
+ping-interval 为秒，0 不主动 PING，负值明确拒绝；max-connections/min-streams/max-streams 接受带符号整数，负阈值禁用相应分支。三项池阈值省略或字面全零时归一为4/0/0，Mihomo为1/0/0；显式 max-connections=1 或2保留各自策略。正 max-connections 优先于 max-streams。
+每个节点独立拥有连接池，空闲连接总是复用；复用保留原上游选择、TLS 身份和认证策略，每条逻辑流仍单独发送 Trojan 认证头。
+
+Trojan 私有 gRPC 池在原绝对期限内等待 H2 SETTINGS、提交并 flush 完整认证请求，
+随后允许 client-first 上传等待迟到的 HTTP 响应，不把建链期限继续套用到业务。
+迟到的 HTTP/gRPC 状态仍完整校验；未完成认证提交、TLS 或 H2 握手继续受原期限约束。
 
 TCP 保留半关闭；gRPC duplex 发送 END_STREAM，不用 RST_STREAM 提前结束读侧。
 UDP 使用同一已认证流上的地址/长度/CRLF 帧，无额外 socket/读取泵/池。
+同一来源、具体节点和资源代际内，未改写 IP 目标共享该流，回复按每帧地址分流；
+逐目标统计、关闭及旧回复隔离沿用[资源策略](runtime-resource-policy.md#udp)。
+不同来源、域名及需要地址还原的目标保持独立；关闭一个目标不关闭仍有成员的流，
+但部分发送取消仍使整条关联失效，不重放已提交的帧。
 payload 最多 8192 字节，待解析最多 8455 字节，并与调用方收发预算分别取交集。
 非法/截断帧关闭，合法超接收预算整包丢弃；取消读取保留进度，部分发送取消使关联失效。
 运行时先取消并 join 入站所有者，再等待节点 gRPC 驱动。
@@ -87,27 +428,36 @@ Mihomo IP 路径可传空包；Xray 不转发空包，且域名回复的 8192 
 
 ## VMess AEAD
 
-标准 UUID，alterId 仅省略/0，请求和响应头均 AEAD，无旧认证回退。cipher 为 auto、
+UUID 接受标准、紧凑、花括号、URN 表示，其他字符串按 UUIDv5(nil, 原始 UTF-8) 映射，不 trim。
+alterId 仅省略/0，请求和响应头均 AEAD，无旧认证回退。cipher 不区分 ASCII 大小写，为 auto、
 aes-128-gcm、chacha20-poly1305、none；zero 归一 none。auto 按实际 AES 硬件能力选择。
 none 只关闭 body 加密，仍验证响应身份；不能启用 global-padding/authenticated-length，
 两开关默认 false。
 
-network 默认 tcp，另支持 ws/grpc/http/h2；均可明文或标准 TLS。tls 默认 false，
+物理出口、安全身份、传输握手及完整认证请求的写入和 flush 共用原建立绝对期限；
+请求提交后，服务端可等待业务上传再发送响应头，不继承旧建立期限。响应 AEAD、身份和长度仍须
+验证通过才交付下行数据；失败关闭、传输自身的握手期限、取消和 Stop 边界不变。
+
+network 省略/空串为 tcp，另支持 ws/grpc/http/h2；均可明文或 TLS，安全身份范围见上文。tls 默认 false，
 关闭时禁止 TLS 字段，即便空串、空列表或 false。认证名依次为 servername、WS Host
 去端口、server；HTTP 伪装 Host/H2 authority 不替代认证名。WS 需 http/1.1，gRPC/H2 需 h2。
+TLS 支持独立的 `name-cert-verify` 和成对内联 PEM 或文件路径 `certificate/private-key` 客户端身份。
 
 - WS ED/路径/头及 HTTPUpgrade 普通/fast-open 约束同 Trojan。
-- gRPC service-name 必填，普通名/完整路径规则同 Trojan，无额外池调度器。
+- gRPC 选项、默认值和节点连接池与 Trojan/VLESS 共用，每条逻辑流独立生成 VMess AEAD 认证；关闭逻辑流不关闭物理连接或兄弟流。
+  authority 使用非空 servername，否则使用 server:port；name-cert-verify 不参与 authority。
 - http 是 TCP 首包伪装：method 默认 GET，path 列表省略/空为 /，按 URL.Path 转义；
   头为字符串列表，每次握手独立选择路径/头值，Host 默认物理 server authority。
   仅首包封装一次，之后恢复原流；禁止 Content-Length/Transfer-Encoding。
-- h2 需要非空 authority 列表，path 默认 /，每流选一个 authority，通过 HTTP/2 PUT body
+  完整 HTTP 首请求与认证前导写入、flush 沿用原建链期限；成功提交后，首个 HTTP
+  响应可等待业务下行，不再继承旧建链期限。头解析上限、取消和整流关闭保持。
+- h2 的 authority 列表省略/空时使用 www.example.com，path 省略/空时为 /，每流选一个 authority，通过 HTTP/2 PUT body
   双向传输；明文 prior knowledge、TLS h2，无 gRPC 帧。
 
 关闭对齐 Mihomo：TCP/WS 可保留上传 EOF 后的读取；gRPC/HTTP/H2 关闭整条逻辑流，
 完整响应应在关闭前读取，不统一要求半关闭尾包。
 
-UDP packet-encoding 默认空串（raw），外层仍 TCP：
+UDP packet-encoding 默认空串（raw），外层为所选可靠流：
 
 | 编码 | 目标与预算 |
 | --- | --- |
@@ -119,40 +469,92 @@ UDP body 最多 15,000 字节；packetaddr 另扣 IPv4 7 / IPv6 19 字节，未
 预检；超限一字节即写前失败，不拆业务包。对端可能更小，V2Ray 部分返回路径总缓冲
 仅 2048 字节，不能当作 Vole 上限。body wire 解析最多 16 KiB，响应头/XUDP 元数据有界。
 三种 UDP 编码均不接受零长度业务包；HTTPUpgrade 不改变这个边界。
-TCP 写块最多 4 KiB 以适配 Mihomo 拷贝边界；UDP 不按此切块。16 位帧计数耗尽前关闭，
-不重复 nonce。半帧发送取消关闭，接收取消保留进度；认证/地址/标签错误使关联失效。
-gRPC/H2 driver 由节点跟踪并同步退出，无全局会话额度或历史表。
+TCP 写块最多 4 KiB 以适配 Mihomo 拷贝边界；UDP 不按此切块。
+AES/ChaCha body 的收发记录计数各自按 16 位回绕，与 Mihomo/sing-vmess 和 V2Ray-core
+一致；跨越 65,536 条记录时不额外断开、重连、重放或更换 cipher。长度认证沿用同一记录索引。
+该协议行为会在同一密钥下重复 nonce，不提供回绕后的 nonce 唯一性保证；外层 TLS 不更新
+内层 body 密钥。认证标签、长度、地址及其它解析错误仍失败关闭。
+raw/packetaddr 半帧发送取消关闭；XUDP 保留一个待写帧并在下次收发时完成，
+遵循[VLESS 的 XUDP 取消边界](vless.md#udp)。接收取消保留进度；认证/地址/标签错误使关联失效。
+gRPC 池与 legacy H2 driver 由节点拥有并同步退出，无全局会话额度或历史表。
 
 ## Hysteria2
 
 始终 QUIC/TLS 1.3，使用官方 rustls；不接受 tls/network/client-fingerprint/REALITY。
 port 为 1–65535，仅提供 ports 时可省略；显式非法 port 仍拒绝。password 默认空、
 保留原值，须为最长 8192 字节的合法 HTTP 头值。SNI 默认 server；ALPN 省略/空为 h3。
-支持共享证书 pin/skip 和成对内联 PEM mTLS；udp 只控制业务 UDP，不关闭 QUIC 载体。
+支持共享证书 pin/skip、独立 `name-cert-verify` 和成对内联 PEM 或文件路径 mTLS；
+验证名不改变 SNI。业务 UDP 始终可用；`udp` 可省略或填 true/false，均不禁用它，
+组 `disable-udp` 仍生效。外层 QUIC 始终需要数据报路径。
 
 - up/down 独立非负整数或十进制整数字符串，裸值 Mbit/s；单位 [KMGT]?[bB]ps 使用
   十进制倍率，bit 向下取整为 byte/s。省略/归一零为自动；拒绝小数、符号、溢出。
-- udp-mtu 缺省/0 为 1197，其他值 64–65535，限制编码后单分片并取实际 DATAGRAM
+- udp-mtu 缺省/0 为 1400，其他值 64–65535，限制编码后单分片并取实际 DATAGRAM
   预算交集，不是 TUN MTU。
-- obfs 只允许 salamander，须配非空独立 obfs-password。
-- ports 是归一去重的非空端口/闭区间集合，优先于合法 port。hop-interval 仅随 ports：
-  整数秒 N、字符串 N 或 N-M，默认 30，5 ≤ N ≤ M ≤ u32::MAX；过短严格拒绝。
-
-每节点一个当前认证 QUIC 会话，逻辑流/关联复用且互不取消。HTTP/3 POST hysteria/auth
+- obfs 支持 salamander 或 gecko，须配非空独立 obfs-password。Gecko 对 QUIC 长头随机分片并填充，
+  短头只用 Salamander；`obfs-min-packet-size/obfs-max-packet-size` 默认512/1200，
+  正值且 min≤max≤2048，只用于 Gecko。max 是填充目标，不是 QUIC MTU，实际片仍受物理预算限制。
+- ports 为端口/闭区间集合，接受逗号或斜线分隔，逆序范围归一并去重；有效非空集合优先于 port，
+  此时 port 可省略或为0。空集合或 `*` 使用非零 port，不启用跳跃。
+  hop-interval 随 ports 使用整数秒 N、字符串 N 或 N-M，范围先排序，0 使用30秒，
+  正数小于5归一为5，最终上界至少为归一后的下界；仍须可表示为 u32。
+
+`realm-opts.enable: true` 使用 Realm 控制面/STUN/UDP 打洞，和 ports 跳端口互斥。
+必填 server-url、realm-id 与非空 stun-servers；token 默认空，服务端按实际认证处理。
+server-url 为无 userinfo/query/fragment 的 HTTP(S) base URL，不跟随重定向。
+STUN 可用 IP/域名及可选端口，默认3478；每个域名使用一个受控解析地址，同时探测两族应列出两族端点。
+HTTPS 控制面独立接受 sni/alpn、skip-cert-verify/name-cert-verify/fingerprint 与成对
+certificate/private-key（内联 PEM 或相对配置目录的文件）；它们不改变业务 QUIC 身份。
+实际 UDP 对端由 Realm 发现，但原节点 server/SNI 仍用于 QUIC 认证，不解析未使用的原 server。
+
+最多2个候选UDP association、16个STUN、32个控制面peer、128个打洞候选；首部/body各16KiB，
+所有网络操作使用同一节点受控出口、建立期限和取消。胜出的原 association 移交 Quinn，
+失败/取消/Stop 关闭未交付候选并等待驱动。无额外 resolver、物理 socket 工厂或 DIRECT 回落。
+Gecko 重组最多8个消息/每消息8片/1400字节，TTL8秒，不保留 padding backing。
+
+每节点按需使用最多两个当前认证 QUIC 会话，自动和显式带宽模式共用此有界池，
+按来源地址稳定选择，分担对端逐连接 UDP 处理。上行共用节点 wire pacer，
+下行声明按连接分配且总和保持配置值；down 为一字节/秒时保留单连接。
+单条流的下载上限受所在连接的分配值限制，空闲连接不转移其声明额度。
+各连接内的逻辑流/关联复用且互不取消。HTTP/3 POST hysteria/auth
 在业务前要求 233；TCP 类型 0x401，响应可延迟到首次读取，允许先写业务。
-认证/上游/请求共用绝对 10 秒预算。旧会话失败后新流可新建会话，已有业务不重放。
+认证/上游/请求提交共用绝对 10 秒预算。请求已提交后的业务及延迟响应不再使用建链期限；
+响应失败仍使当前逻辑流失效。旧会话失败后新流可新建会话，已有业务不重放。
 写 EOF 关闭当前逻辑 TCP 双向通道，与 Mihomo 一致，不影响兄弟流。
 
-每流接收窗口 256 KiB、连接收发各 1 MiB、DATAGRAM 收发各 256 KiB；最多 8 条单向
+四个 initial/max 接收窗口按字节配置；0 独立使用默认：stream 64 KiB，connection 4 MiB。
+采用固定 Middle 策略：每流信用为 max(initial, min(maximum, 4 MiB))，连接信用为 initial；
+不执行消费量或 RTT 驱动的自适应增长。默认窗口优先多流公平性和较小的未读数据。
+较高 RTT 的单流吞吐受固定流窗口约束，可通过现有初始/最大窗口字段显式增大，同时增加接收驻留。
+initial 大于 max 时保留初始值，不缩小或额外拒绝；max 限制到 QUIC VarInt，无法编码的
+initial 拒绝。窗口是信用额度，不预分配整个缓冲。handshake-timeout 为整数秒，正值使共享
+建链由节点持有并使用独立期限；各调用仍受自身原建立期限约束，短等待退出不取消有效 pending。
+每槽位最多一个 pending，失败驱动清理后才能替换；<=0 保留创建调用的期限与取消语义。
+成功后的业务/端口跳跃不重新应用此期限，Stop 取消并等待全部驱动。
+
+节点可靠发送窗口总额 1 MiB、DATAGRAM 接收预算 2 MiB、发送预算 4 MiB，
+按固定会话槽位数均分；未使用槽位的额度不转移。可靠接收信用仍按连接配置，
+第二会话另有独立协议状态、队列和物理 socket，因此这些预算不代表节点总内存不变。
+每连接最多 8 条单向
 控制流，拒绝主动双向流。PMTUD 关闭，最大 QUIC payload 1400 并取上游预算交集；
 空闲 30 秒/保活 10 秒。认证头 16 KiB，TCP 响应消息 2048/padding 4096 字节。
+共享 Dialer 为每个物理 UDP socket 请求 2 MiB 接收缓冲以承接突发，实际大小由系统决定；
+原 socket 的保护、绑定和所有权继续保留，逻辑包预算及 QUIC 接收信用独立。
 业务 UDP 原生 DATAGRAM，payload 最多 4096，最多 255 分片；未知关联不创建状态。
 重组按关联/包/地址隔离，最多 64 个待完成包/256 KiB、TTL 5 秒，关联交付队列 32 包。
+每条认证连接另有 32 项原始消息发送队列；同一连接任务顺序编码分片，不增加后台任务。
+满队列等待可取消的准入，准入成功才使用 Packet ID；关闭关联后未发送项丢弃，Stop 取消并释放队列。
 重复未完成分片忽略；完成后立即释放 16 位 Packet ID，允许后续重用，**不做业务去重**。
+缓存满时淘汰最早开始的未完成包以接纳新包，避免缺片占满缓存后使后续包停滞至 TTL；
+总项数、总负载字节及单包预算保持不变。
+同一来源、具体节点和资源代际内，未改写的 IP 目标共用一个 UDP session ID 和交付队列；
+逐目标统计、取消与出口固定仍由路由层管理，退役及旧回复隔离沿用[资源策略](runtime-resource-policy.md#udp)。
 
-down 写入 Hysteria-CC-RX。up=0 或服务端 auto 使用 BBR，否则取 up 与服务端正上限
+down 写入 Hysteria-CC-RX。up=0 或服务端 auto 使用官方 Quinn CUBIC，否则取 up 与服务端正上限
 较小值（服务端 0 无限），使用固定带宽控制与实际 wire-byte pacer。Mihomo down=0
 可能返回 RxAuto，优先自动模式。丢包补偿五秒窗口、最小采样量、ACK 比例下限 0.8。
+自动模式采用 CUBIC 的本地策略，符合 [Hysteria 拥塞控制协议](https://hysteria.network/docs/developers/Protocol/#congestion-control)，
+不承诺与 Mihomo/官方客户端的 BBR 在高 RTT 或有损网络下性能相同。
 Salamander 采用公开 salt + XOR/BLAKE2b-256，每包加 8 字节，先扣 QUIC 预算但计入
 pacer；这是混淆不是认证，错误密钥由 QUIC 拒绝，短包有界丢弃。
 
@@ -167,43 +569,92 @@ pacer；这是混淆不是认证，错误密钥由 QUIC 拒绝，短包有界丢
 ## TUIC v5
 
 固定 QUIC/TLS 1.3，复用官方 Quinn、rustls/ring 与共享受控数据报适配器。
-仅 v5；必填标准 UUID 与原样 UTF-8 password，后者可空、最长 65,535 字节。
+仅 v5，native／quic 服务端互通目标为官方 Itsusinn/tuic，UoT v2 与服务端 mTLS 使用 Mihomo；
+必填标准 UUID。password 为原样 UTF-8，省略/空串为空密码，最长 65,535 字节。
 SNI 缺省 server，ALPN 缺省 h3；显式空列表拒绝，非空有序列表必须实际协商命中。
-使用共享 pin/skip/独立验证名；无命名 TCP 指纹、mTLS、ECH、0-RTT 或跨节点恢复。
+`disable-sni: true` 只关闭 ClientHello 的 SNI，仍验证原认证名/显式 name-cert-verify 和 pin，
+不隐式关闭证书验证。
+使用共享 pin/skip/独立验证名，支持配对内联 PEM 或文件路径的 certificate/private-key 客户端身份；无命名 TCP 指纹、ECH、0-RTT 或跨节点恢复。
 拥塞使用官方 Quinn cubic（默认）、new_reno 或 bbr，不承诺与其他实现的吞吐相同。
+`log-level: debug` 在物理会话建立后记录实际 controller 的固定算法标签；
+标签不包含节点、凭据或业务目标，配置验证和复用同一会话不重复记录。
 
 认证使用当前真实 TLS 会话 exporter，UUID 为 label，原样 password 为 context。
 Authenticate 与 Connect 没有成功 ACK；本地 open 成功不是密码通过证明，错误身份
 必须由最终拒绝和原站零业务验证。Connect 为双向 QUIC 流，不引入 HTTP/3 请求。
 流关闭结束该逻辑双向通道，与 Mihomo 对齐，不影响兄弟流。
 
-业务 udp 默认 false，但外层 QUIC 始终需要有效双向至少 1200 字节的数据报路径。
+业务 UDP 始终可用；`udp` 可省略或填 true/false，均不禁用它，组 `disable-udp` 仍生效。
+外层 QUIC 始终需要有效双向至少 1200 字节的数据报路径。
 未开放 DATAGRAM、预算不足、protect 失败或只支持 TCP 的上游均失败，不回退 TCP
-或 DIRECT。`udp` 业务路由开关不替代上游实际数据报能力和预算检查。
+或 DIRECT。业务 UDP 能力声明不替代上游实际数据报能力和预算检查。
 SS UoT、AnyTLS 与支持 UDP ASSOCIATE 的 SOCKS5 可作为上游；组快照绑定物理会话。
 
 `udp-relay-mode` 为 native（默认）或 quic。native 使用 DATAGRAM，按实际容量拆为
 最多 255 片；quic 每包使用一条单向流，不受单 DATAGRAM MTU 限制，也不是 UoT。
+quic 收齐声明长度的报文后立即交付并释放接收流，TCP 通道的关闭与 FIN 保留规则不变。
 两者逐包携带 IPv4/IPv6/域名，业务负载取 u16 和调用方双向预算交集，超限不截断。
 未知关联不分配状态；每关联最多 64 个未完成包、256 KiB 分片负载、TTL 5 秒和
-32 项完成包交付队列。重复相同片忽略、冲突片丢弃；完成后释放 Packet ID，可回绕，
-不做业务去重。发送过的关联关闭时发送有界 Dissociate，未发包关闭不创建对端状态。
-
-每节点按需共享物理会话，流 credit 等待沿用调用方原期限。关联 ID 在同一物理会话
+32 项完成包交付队列。未完成包槽满时，新分片包逐出最老的未完成包；字节预算和 TTL 保持。
+重复相同片忽略、冲突片丢弃；完成后释放 Packet ID，可回绕，
+不做业务去重。协议不携带跨片报文代次或完整内容校验；同一关联、相同 Packet ID 的
+跨包互补分片无法一般性区分，QUIC 对单片的认证不代替完整业务内容校验。
+发送过的关联关闭时发送有界 Dissociate，未发包关闭不创建对端状态。
+
+启用逐目标连接追踪时，native 与 quic 模式允许同一 TUN UDP 来源、同一具体出站实例的
+未改写 IP 目标共用一个 TUIC 关联，每包仍携带目标地址；逐目标路由、统计与取消保留。
+目标改写、域名目标及不同出站实例在该追踪路径保留独立关联。
+未启用追踪时沿用既有路由缓存的关联复用规则。
+
+每节点按需复用物理会话。native 按完整来源地址（含端口）稳定分配至两个按需池，
+同源 TCP/UDP 保持池亲和；UoT v2 保持原共享池。quic relay 的 TCP 与原生 UDP
+各自按需使用独立池，避免逐包单向流的回包积压占用 TCP 所在连接。每池仍沿原所有者
+阈值准入、退役与释放，不增加单个连接的窗口或远端单向流信用。两个当前池不是全节点
+总连接上限；退役会话仍由既有所有者生命周期释放。流 credit 等待沿用调用方原期限。
+native 模式（不含 UoT v2）向共享 Dialer 请求512 KiB物理 UDP 接收缓冲；
+这是可钳位或拒绝的性能提示，沿用同一个受保护、已绑定的 socket，不改变 QUIC 信用、
+应用队列或逻辑包预算。quic relay 与 UoT v2 不请求该提示；Linux 内核缓冲与进程 RSS 分开核算。
+关联 ID 在同一物理会话
 不重用；65,536 个 ID 用尽后新业务新建会话，旧流继续，最后一个旧所有者退出即回收。
 TCP shutdown 立即完成逻辑关闭，发送所有权保留到 FIN/数据确认或最多 5 秒，防止
 退役池提前丢弃已接受的末尾上传；该等待归节点所有，Stop 直接取消并 join。
 切组不迁移已有池；故障后只有新业务可创建新池，已发送业务不自动重放。
 
-每流接收窗口 256 KiB，连接收发各 1 MiB，DATAGRAM 收发各 256 KiB；最多 32 条
-入站单向控制流，半条控制流最长 5 秒；拒绝服务端主动双向流。QUIC payload 最大
-1400 并取路径预算交集，PMTUD 关闭。保活/Heartbeat 每 10 秒，空闲 30 秒；两种
-UDP 模式的 Heartbeat 均用 DATAGRAM。Stop 等待认证、收发、重组、心跳及上游释放，
-关闭交换最多一秒；这些都是局部结构限制，不是全局业务会话额度。
+`ip` 覆盖物理拨号地址，逻辑 server/SNI 保留。heartbeat-interval 单位毫秒，<=0 回落
+10000，同时控制 QUIC keepalive 与实际 v5 HEARTBEAT，两种 UDP relay 模式均用 DATAGRAM。
+recv-window-conn 实际为 stream，recv-window 实际为 connection；正值同时设 initial/max，
+缺省或零值分别按 15 MiB/10、2 MiB 初值与 15 MiB、64 MiB 最大值归一化，
+随后采用上述 Middle 策略，默认实际为固定 stream 4 MiB / connection 2 MiB。
+窗口是信用额度，不预分配全部缓冲；显式正值不按默认窗口钳位。
+
+max-open-streams 控制客户端 TCP/UDP 所有者池，不扩大 Quinn 内部远端 stream 表；
+远端双向流信用固定为 0，单向流为 32。0 使用100；参考客户端100阈值转换90，入池计数必须严格小于阈值，所以
+默认89个同时所有者，其它正N为N-1；1和负值可解析但无法开启业务。饱和新建物理
+会话，退役会话继续服务已有所有者，最后所有者退出回收，不重放已发送业务。
+
+max-datagram-frame-size 是按规范 type/length varint 编码计的完整 frame 上限，最多1400；缺省以
+max-udp-relay-packet-size（0使用1252）+IPv6最坏TUIC头29计算。native relay 的业务
+fragment 上限取 frame-29 与实际路径扣头容量交集；能在实际容量内发送的包不分片。
+quic relay 按参考在一条单向流发送完整 u16 packet，不使用 native fragment 限额。
+frame 配置限制本机发送与分片，不修改 Quinn transport parameter。接收按独立物理预算、
+关联和完整包重组预算校验，允许对端采用不同分片大小；未知关联或超预算负载在解码前丢弃。
+DATAGRAM 累计收发缓冲仍各256 KiB，独立于 frame 上限。disable-mtu-discovery 缺省
+false，PMTUD 探测始终限制在受控双向路径预算内，QUIC payload 最多1400。
+
+udp-over-stream 默认关闭；开启后使用 TUIC Connect 到 `sp.v2.udp-over-tcp.arpa:0` 的 UoT v2，
+udp-over-stream-version 省略或整数2均使用v2，其余版本拒绝。首包含 Datagram-mode request，
+后续每包携带目标与长度。仍需要 QUIC 数据报物理入口；
+首包保留原绝对建链期限；取消单次发送保留一帧进度，后续收发继续完成。
+实际错误或超时使关联失效。响应队列1项、任务归节点Stop同步回收。
+UoT在可靠流中传输，有丢包导致的队头阻塞成本，不应用原生TUIC分片额度。
+
+连接未确认发送缓冲1 MiB；最多32个并行入站控制解码器，半条控制流最长5秒，
+拒绝服务端主动双向业务流。空闲30秒。Stop等待认证、收发、重组、心跳及上游释放，
+关闭交换最多一秒；这些是局部结构限制，不是全局业务会话额度。
 
 ## Shadowsocks 2022
 
-原样复用官方 shadowsocks-rust，仅三算法：
+使用官方 shadowsocks-rust 的加密实现，仅三算法：
 
 | cipher | 密钥 |
 | --- | --- |
@@ -212,15 +663,39 @@ UDP 模式的 Heartbeat 均用 DATAGRAM。Stop 等待认证、收发、重组、
 | 2022-blake3-chacha20-poly1305 | 单一 32 字节 Base64 PSK |
 
 标准 Base64 可省末尾 padding；空段/非法编码/长度错误拒绝，凭据不 trim。
-官方库只包装已有 TCP 流，UDP codec 单包有界交接，不调用其 socket 工厂。
+TCP 使用官方 `CryptoStream` 的加解密与记录分帧，Vole 构造目标地址与 padding 前导。
+原生 UDP 使用 Vole 的 SIP022 包层适配官方公共 `UdpCipher`，处理包头、EIH、padding 与地址，
+只消费已有受控 IO，不调用 socket 工厂。每关联持有一个当前 TX cipher；AES 至多保留两个
+已认证 server session 的 RX cipher，ChaCha 收发复用同一 PSK cipher。未知 server ID 仅使用
+临时 cipher，通过认证、类型、时间、client session、地址、负载及重放校验后才保留。
+接收复用既有有界缓冲；取消、重放窗口与受控 IO 的生命周期见下文，close/Stop 回收关联 cipher。
+
+### 流式传输插件
+
+一个 SS2022 节点最多使用一个 `plugin/plugin-opts`，包装位于官方 SS2022 codec 之前；
+原生 UDP 使用独立受控路径。插件不启动子进程，也不绑定本地代理端口。
+
+- `plugin: obfs`：`mode: http/tls`，`host` 默认 `bing.com`；TLS 模式是 simple-obfs 报文，
+  与提供身份认证的 ShadowTLS 不同。HTTP 首个响应头和 TLS 记录均有大小上限，保留尾部字节。
+- `plugin: v2ray-plugin` 或 `gost-plugin`：`mode: websocket`，支持 `host/path/headers/tls/mux`。
+  host 缺省为 `bing.com`，空 path 使用 `/`，mux 缺省 true。TLS 模式使用 HTTP/1.1 ALPN，
+  支持 `skip-cert-verify/name-cert-verify/fingerprint/certificate/private-key/ech-opts`；
+  未启用 TLS 时不接受这些选项。Host 头同时确定 TLS SNI。v2ray-plugin 另外接受
+  `v2ray-http-upgrade/v2ray-http-upgrade-fast-open`。两种 mux 分别是单通道 V2Ray mux 和裸 smux，
+  不附加 sing-mux 的目标与响应头；它们的关闭结束整个下层会话。
+- `plugin: jls`：`host/username/password/alpn`；ALPN 缺省 h2、http/1.1，显式空列表保持为空。
+  节点 `client-fingerprint` 作用于 JLS 握手；不增加标准证书策略或客户端证书字段。
+
+`client-fingerprint` 仅 ShadowTLS/JLS 插件消费，其余插件不接受该字段。
+插件参数只接受对应模式的字段；队列、窗口、连接池和配置范围均有界，取消/Stop 不等待远端回包。
 
 ### ShadowTLS v3
 
 SS 三算法的 TCP 可配置 `plugin: shadow-tls` 与完整 `plugin-opts`，不是新的代理类型。
 仅整数 version 3，始终 strict/TLS 1.3；不提供 v1/v2、弱认证或版本回退。
 host 为独立 cover DNS 名/IP，不参与拨号或业务解析；password 保留原始 UTF-8。
-ALPN 缺省 `[h2, http/1.1]`、空列表不发送；共享 pin/skip/name-cert-verify 与
-节点 client-fingerprint 只影响 cover，不能替代 ShadowTLS 密码。
+ALPN 缺省 `[h2, http/1.1]`、空列表不发送；支持共享 pin/skip/name-cert-verify、
+成对内联 PEM 或文件路径的 certificate/private-key；节点 client-fingerprint 只影响 cover，不能替代 ShadowTLS 密码。
 
 顺序为受控上游流 → 原生完整 TLS 握手与 relay 认证 → v3 记录流 → 官方 SS2022。
 借用原建链期限、取消和组快照，握手失败不发送 SS 目标或业务；pin/skip 不绕过
@@ -236,17 +711,19 @@ v3 的额外四字节记录特征仍存在，完整认证和互通不等于不
 ### UDP over TCP v2
 
 `udp-over-tcp` 默认 false；true 要求 `udp: true`，三算法均可用于裸 SS 或
-ShadowTLS v3。开启时 `udp-over-tcp-version` 省略或整数 2 均固定使用 v2；
+任一流式插件。开启时 `udp-over-tcp-version` 省略或整数 2 均固定使用 v2；
 关闭时不得提供版本，不支持 v1、协商或原生 UDP 降级。无 SS feature 在 IO 前拒绝。
 
-每个关联独占一条既有 SS TCP 路径，支持 TCP-only SOCKS5 上游与 select 组。
+同一源关联、具体节点和资源代际内，未改写 IP 目标共用一条既有 SS TCP 路径；
+其它关联保持独立，不跨来源池化。支持 TCP-only SOCKS5 上游与 select 组。
 目标固定为 `sp.v2.udp-over-tcp.arpa:0`；v2 non-connect 请求只发送一次，之后每包
 携带地址和 u16 长度。业务域名先经过受控 `ResolutionContext` 转为 IP，magic 不参与
 DNS 或路由。AnyTLS 复用同一有界 codec，但保留自己的域名与会话/FIN 所有权。
 
 SS 首包写入并 flush 成功前阻止后台读取；零长度 UDP 仍有非空 UoT 帧。
 延迟首包沿用原建链 deadline，成功建立后的业务不再使用旧期限。未发包关闭直接释放
-底层 IO，不触发官方空 SS 握手；半帧写取消使关联失效，不重发。每关联最多一个读取
+底层 IO，不触发官方空 SS 握手；半帧写取消保留一帧偏移，后续收发继续，不重发前缀。
+实际错误或超时使关联失效。每关联最多一个读取
 任务、一个排队响应及一个正在解析/等待入队的响应；接收取消不丢 parser 状态，超接收
 预算完整排空该包再读下一包。Stop 取消并等待读任务，释放流；不跨关联池化。
 
@@ -256,31 +733,89 @@ UoT 对端使用 16 KiB 接收缓冲；容器数据验收覆盖该实际边界
 
 ### 共享 SS 流与数据报行为
 
-- TCP 每次最多交付 16 KiB；读或关闭先于首次写时，完成并刷新官方空首写，
-  但受下述空首包限制影响，不承诺可靠 server-first。Pending 继续同次握手，已有首写不重复目标头。
+- TCP 每次最多交付 16 KiB；首次非空写与目标前导合并。首次读、显式空写或上传半关闭
+  可发送不含业务数据的前导，padding 长度为 1–900 字节，内容明确初始化为随机字节，
+  并在读取响应前完成刷新，支持 server-first。Pending 继续同次握手，不重复目标头或业务。
+  握手完成后的空写不发送额外记录；零容量读取和单独 flush 不启动握手。
+  SS 层上传半关闭保留读侧，外层传输与对端仍遵循各自的关闭契约；
+  Drop、取消与 Stop 不额外启动握手。
 - 背压适配最多暂存一个 16 KiB 原文块并立即报告接受；后续保持同缓冲完成写入，
   避免官方重试长度误计。flush/关闭排空，读取也推进待写但不被写背压阻塞。
 - 原生 UDP 取消前预留 packet ID，底层实际发送后才成功；Pending 不重编码，无后台发送队列。
   接收验证来源、认证、关联与完整负载，外层 wire 最大 65,507。
+  每次成功发送后，在下一包编码前合作退让；不添加发送队列或限速器。
+  同一来源、具体节点和资源代际内，未改写 IP 目标共享受控 socket、codec 缓冲和重放窗口；
+  逐目标统计、取消及旧回复隔离沿用[资源策略](runtime-resource-policy.md#udp)。
 - 每关联随机 client session ID、递增 packet ID，最多两个 server session 的 8128 包
   重放窗口；旧 session 一分钟仍有有效包时不替换，ID 将溢出时换 client ID 并清空窗口。
   close 清空并关闭底层，不新增后台任务。
 
 依赖仅 crates.io 版本，不使用 Git/path/源码补丁。AWS-LC 仅允许沿 shadowsocks →
 shadowsocks-crypto 链使用，TLS/REALITY 不消费它，详见[TLS 依赖](tls-dependencies.md)。
-启用 SS 时通过 log 的 max_level_off/release_max_level_off 关闭整个依赖图该 facade，
-防止上游日志泄密；Vole tracing 不受影响。上游 Debug 不暴露。
 重放窗口派生代码的来源/完整许可保留在源码头，发布仍审计实际链接图。
 
-**已知风险：**原样上游空 TCP 首写/空 UDP padding 路径扩展长度而未显式初始化，
-存在把残留缓冲传给可解密对端的风险；普通 echo 或自有背压修复不代表此风险已解决。
-官方空 TCP 首写还可能随机生成零 padding，被其严格服务端拒绝；Vole 不修改或重试
-该上游行为。裸 SS、EIH 和外包 ShadowTLS v3 的 TCP 均受影响；入站转发先轮询读取时，
-即使业务计划随后发送请求，也可能触发空首写。TCP 数据验收使用已提交非空首段的
-client-first 路径，server-first/空首包列为已知限制，不计成功；其他协议的 server-first
-要求不变。内存回归分别验证适配器刷新与确定性的零 padding 拒绝，不将 codec
-级回复算作 server-first 互通通过。SS UoT 的非空请求帧与专用读取门控独立验证。
+TCP 前导不使用上游私有的 padding 构造器；响应在交付前校验 request-salt 与本连接
+发送 salt 的绑定，类型、时间与认证仍由官方 codec 校验。裸 SS、AES EIH 与外包
+ShadowTLS v3 共用此路径，不通过伪造业务字节或握手失败重拨支持 server-first。
+空原生 UDP 使用调用者持有的临时编码缓冲：按 nonce、身份、地址、最大 900 字节
+padding 和 tag 的完整上界初始化，SIP022 包层仅将已初始化字节交给官方 cipher。
+缓冲不常驻，不为普通非空数据报增加整包初始化；session/packet ID、取消和重放保护不变。
+SS UoT 仍由非空请求帧和专用读取门控完成首包，不触发独立空 SS 握手。
 首次固定头不够单次读取时，上游按探测防护拒绝，不改成 read_exact。
 Mihomo 仅提供单 PSK；原样 ssserver 验证 AES 单层 EIH 多用户 TCP/UDP 终结及错误身份。
 MTU1500 大包夹具显式启用官方双向 IP 分片。自有 1/2 层身份中继不是原生任意多层证明。
 所有结果与平台/发布签收分开，见[验收边界](acceptance.md)。
+
+
+## WireGuard
+
+`type: wireguard` 使用官方 boringtun 的标准 Noise 协议和用户态 IP 栈。
+`outbound-wireguard` 可独立启用，不依赖 TUN；不创建系统接口、路由或 NAT。
+private-key 必填，ip/ipv6 至少提供一个本地地址；地址接受 IP 或 CIDR，保留主机地址，
+每族最多一个。密钥必须是解码后 32 字节的标准 Base64，保存时清零回收，Debug/错误不暴露密钥。
+
+未配置 peers 时，server/port/public-key 必填，pre-shared-key 可选；顶层 allowed-ips
+与 Mihomo 一致地忽略，每个本地地址族使用全地址路由。有 peers 时，顶层端点与公钥
+不参与选择，每个 peer 必须提供 server/port/public-key 与非空 allowed-ips CIDR 列表。
+发送目的地址与解密包的来源地址使用同一不可变最长前缀表；相同前缀最后声明的 peer
+优先。同一公钥的重复声明更新端点，保留未覆盖的 PSK，并追加允许前缀。
+
+reserved 缺省为空（全零），否则接受三字节数组或解码后恰好三字节的标准 Base64 字符串。peer 缺省继承顶层值；发送时写入
+WireGuard 消息头的保留字节，接收时清零后验证 Noise。MTU 省略/0 为 1408，范围
+1280–65503；外层实际双向 UDP 预算必须至少为 MTU+32，不足时关闭上游，不静默缩小。
+udp 缺省 false，只控制业务 UDP；外层始终需要双向数据报。persistent-keepalive 为
+uint16 秒，0 关闭定期保活。当前不接受 Amnezia、workers、ip-stack 或系统接口模式字段。
+
+每节点、资源代际按需拥有一套 TCP 栈；每个实际使用的 peer 独立拥有 Noise、外层会话
+和驱动，未使用的 peer 不启动网络任务。内层 UDP 使用真实临时端口。外层经过共享
+Dialer/UpstreamPath，节点端点由 Core 代理 DNS 角色解析；旧会话保留建链组快照与已认证
+入站身份。真实握手完成才交付业务流，握手重试与保活使用官方定时器；一个 peer
+失败不会关闭其他 peer 或整个共享栈，后续新业务可重建失败会话，不重放旧业务。
+
+remote-dns-resolve 默认 false；只有 true 且 dns 非空时，业务域名使用节点私有 DNS，
+查询经过该 WireGuard 节点的内层 TCP/UDP。dns 支持 Core 的 UDP/TCP/DoT/DoH/DoQ/RCODE
+上游；fragment 中的出口 token（包括未定义的名称）不改变这个固定出口，键值参数仍按
+通用 DNS 契约解码一次并消费 ECS、类型过滤、证书策略和 DoT 复用设置。私有解析器
+不继承全局 prefer-h3，HTTPS 的显式 h3=true 仍强制使用 H3。DNS 上游域名仍由 Core 的代理 DNS 角色 bootstrap，
+不通过节点私有解析器解析自身端点。私有缓存有界，查询由调用方持有，不保留空闲 TCP
+连接或独立后台清理任务。关闭该开关或 dns 为空时使用受控本地 DNS；两种路径都遵循
+节点 ip-version、全局 IPv6 开关、本地地址族与原建链期限，失败不回落 DIRECT。
+
+refresh-server-ip-interval 默认 0，关闭更新；非零值以秒计，新业务在间隔到期后触发
+所有已建立 peer 的端点重新解析，负值每次检查均到期。不创建额外周期任务。IP 不变时保留物理会话；
+变化时保留共享栈、TCP 状态和 UDP 端口，替换外层会话并重新握手。解析或新上游配置失败
+保留原端点，下次业务重试。
+
+节点 raw 包队列和各 peer 发送队列各 32 项；每 UDP 关联响应队列 64 项。UDP 负载上限
+为 MTU 减本地 IP/UDP 头，再与调用方收发预算分别取交集；双栈保守扣 48 字节，IPv4
+扣 28 字节。TCP 栈输出交给已就绪 peer 时先尝试入队；Full 时只暂持当前包与原 peer
+代际，释放 peer 槽位锁后，在同一次队列准入的轮询之间给一次协作调度机会，仍满则丢弃，
+TCP 依赖重传。全局取消优先结束输出 pump，其次处理原 peer 取消，不把待交付包改投新代际。
+这次退让会暂缓共享输出 pump，不承诺其他 peer 零等待或固定墙钟时限。
+解密后到栈的 raw 包与 UDP 响应仍在满队列时丢当前包；业务 UDP 发送保留直接等待原 peer
+发送队列的可取消路径，不经过 TCP 输出 pump。解密后校验本地目的地址、来源地址族、
+最长前缀所属 peer 和关联端口；这些是局部结构边界，不是业务连接总数限制。
+
+握手、收发、更新与重试均可取消；驱动由节点持有，调用方 future 丢弃不会丢失任务
+所有权。Stop 关闭新准入，取消并等待所有 peer 与退役驱动，关闭各上游（分别最多一秒），
+随后等待用户态栈退出；私有 DNS 使用弱节点引用，不延长节点生命周期。
diff --git a/docs/reality-wire-protocol.md b/docs/reality-wire-protocol.md
index b6f7120..ed2d977 100644
--- a/docs/reality-wire-protocol.md
+++ b/docs/reality-wire-protocol.md
@@ -1,6 +1,6 @@
 # REALITY V1 客户端协议
 
-本文定义 Vole 的 REALITY V1 客户端线上行为。它不是通用 REALITY 规范。经典模式为默认，可显式要求混合密钥交换。可选的四套 ClientHello 模板及混合兼容边界见 [TLS 指纹](tls-client-fingerprint.md)。
+本文定义 Vole 的 REALITY V1 客户端线上行为。它不是通用 REALITY 规范。经典模式为默认，可显式允许混合密钥交换。命名 ClientHello 模板及版本边界见 [TLS 指纹](tls-client-fingerprint.md)。
 
 ## 版本边界
 
@@ -10,7 +10,7 @@ V1 只支持：
 
 - 客户端模式；
 - TLS 1.3；
-- 经典 X25519，或显式要求 X25519MLKEM768 的 TLS 密钥交换；
+- 经典 X25519，或显式允许 X25519MLKEM768 的 TLS 密钥交换；
 - classic Ed25519 临时证书认证；
 - 0–8 字节 short ID，在线上右侧补零到 8 字节；
 - BoringSSL 原生握手和加密实现。
@@ -28,11 +28,12 @@ Vole 不能读取该私钥，也不能为两个用途生成不同密钥。
 
 原生封装按实际 GroupID 找到唯一 X25519 share，不依赖 share 下标。Firefox 可保留
 额外 P-256 share，但认证始终绑定同一 X25519 临时私钥。Chrome133 的普通 TLS
-ML-KEM group/share 在 classic REALITY 中裁剪。显式混合模式保留模板中的真实混合 share；
-无命名指纹时只提供混合 share。若同时存在独立 X25519，优先用它派生认证，否则使用
+ML-KEM group/share 在 classic REALITY 中裁剪。显式允许混合时保留模板中的真实 share；
+Chrome133 与无命名指纹提供 X25519MLKEM768/X25519 双 share，其他 TLS1.3 模板保留
+各自经典 share。若同时存在独立 X25519，优先用它派生认证，否则使用
 实际混合 share 内的 X25519 分量，与 Mihomo 的认证取值一致。
-重复/缺失认证 share、低阶点均失败。显式混合模式还在 ServerHello 处理时要求
-实际选择 group 4588，经典组或 HRR 立即失败，不重新发起经典握手。REALITY 身份
+重复/缺失认证 share、低阶点均失败。服务端可在本次握手选择允许的经典或混合组，
+不因此重试；HRR 仍立即失败。Android/360 模板仅有 TLS1.2，不能用于 REALITY。REALITY 身份
 认证仍是经典 X25519/Ed25519，不能将混合 TLS 密钥交换称为后量子身份认证。
 
 ClientHello 的 legacy session ID 固定为 32 字节。生成密文前先把该字段清零，再编码完整 TLS Handshake `ClientHello`，将其作为 AES-GCM 的 AAD。
diff --git a/docs/runtime-resource-policy.md b/docs/runtime-resource-policy.md
index 64af05d..1fd2a37 100644
--- a/docs/runtime-resource-policy.md
+++ b/docs/runtime-resource-policy.md
@@ -28,11 +28,12 @@ Release 构建优先吞吐（`opt-level = 3`），保留 thin LTO 与现有缓
 包队列                          256
 普通事件 / TCP accept           128
 每关联 UDP 入站                 64
-普通 UDP 响应                   4,096
+普通 UDP 响应                   256
 DNS 响应                        128
-每个 TCP 方向缓冲区             32 KiB
-TLS / XHTTP 缓冲区              64 KiB
-DNS 类型化缓存                  256 项
+每个 TUN TCP 方向缓冲区         4 KiB
+TLS / 流式 XHTTP 缓冲区         64 KiB
+XHTTP packet-up 单批             H1/H2 64 KiB；H3 128 KiB
+DNS 结果总容量（每角色）         默认 4,096 项，dns.cache-max-size
 DNS 原始响应缓存                64 项 / 256 KiB
 TUN 域名提示                    256 项（按需）
 ```
@@ -41,6 +42,7 @@ MTU 由 `tun.mtu` 配置，默认值和平台限制统一见 [TUN 平台层](tun
 
 - 普通 UDP 在 reader 同步分流并直接提交到每源关联，不经过 TCP Driver 或共享 UDP 入站队列；DNS 查询独立提交受跟踪任务。
 - 每关联请求、普通响应和 DNS 响应使用独立内部容量，不扩大 128 项的 TCP accept，也不增加公开配置字段。
+- netstack 每轮维护 socket 与连接请求后，优先处理已就绪的原始入站批次，再处理内部通知；停止保持最高优先级。原始入站暂满时，当前包最多保留一个协作调度回合并重试，持续满时丢弃；UDP、DNS 和停止继续独立推进，队列容量保持原值。
 - TUN 域名提示只在 TUN 配置实际包含域名规则时创建，并从空容量按需增长。
 - 域名提示的读写使用短同步锁，临界区内不等待 IO 或执行异步操作；新 TUN IP 流读取当前提示，活动 UDP 五元组保持既定 action。
 - ICMP 响应复用原始包出站队列，不创建独立任务或长期状态。
@@ -52,41 +54,92 @@ MTU 由 `tun.mtu` 配置，默认值和平台限制统一见 [TUN 平台层](tun
 
 ## TCP 与握手
 
-- TCP 流按需创建任务，每方向缓冲区固定为 32 KiB。
-- rustls/XHTTP 的配置缓冲区为 64 KiB；boring 每次应用写入最多 min(节点缓冲预算, 16 KiB)，原生 TLS 记录有界，命名模板证书消息/解压输出另限 128 KiB。
+- TCP 流按需创建任务；TUN 转发每方向缓冲区为 4 KiB。
+- netstack 的 TCP 应用队列从空分配按实际写入有界增长，保留每方向 16 KiB 逻辑上限；排空不收缩，连接释放时销毁。smoltcp 收发缓冲仍各为 16 KiB，不用进程内存或连接总数改变容量。
+- WireGuard 与 MASQUE H2/IP 的私有主动栈使用 64 KiB TCP 发送总预算：
+  smoltcp 32 KiB 与按需应用队列 32 KiB。接收总预算仍为 32 KiB；
+  MASQUE H3/IP、共享 TUN 与通用 netstack 默认值保持原样。
+  节点业务与私有 DNS 的 TCP 共用该主动栈；此预算不改变内层 UDP、原始包队列或连接数量策略。
+- rustls/流式 XHTTP 的配置缓冲区为 64 KiB；boring 每次应用写入最多 min(节点缓冲预算, 16 KiB)，原生 TLS 记录有界，命名模板证书消息/解压输出另限 128 KiB。
 - 标准 TLS 恢复会话总预算为 4，按节点（含独立下载端点）分配；每个缓存绑定不可变的 SNI、ALPN 和证书策略，绝不跨节点复用。TLS 1.3 票据有界、一次性消费，TLS 1.2 会话占用同一额度；额度为 0 则禁用恢复。REALITY 不参与该缓存。
-- 共享 TLS 客户端的显式验证名、协议版本、客户端证书身份和 ClientHello profile 也属于不可变策略，单独构造缓存，不跨身份共享。boring 只保存当前节点/SSL 上下文产生的票据，应用层 ALPN 接受前不发布，失败或取消丢弃临时票据。标准 TLS 和 REALITY CloseWrite 只发送 close_notify，刷新最多5秒，保持读方向和底层传输；Drop 释放整个流。XHTTP 仍以逻辑连接整体关闭为准。
+- 共享 TLS 客户端的显式验证名、协议版本和 ClientHello profile 固定。内联客户端身份固定；文件身份整对校验后供新物理连接取快照，旧连接保留原身份。票据按节点和身份代隔离，换代后拒绝旧票据和旧连接晚到的票据，各代共用原节点总容量。boring 在应用层 ALPN 接受前不发布票据，失败或取消丢弃临时票据。标准 TLS 和 REALITY CloseWrite 只发送 close_notify，刷新最多5秒，保持读方向和底层传输；Drop 释放整个流。XHTTP 仍以逻辑连接整体关闭为准。
 - 半开连接、出站握手和活动会话只记录当前值和峰值，不触发资源错误。
 - 超时、取消、EOF 和协议错误负责回收；停止必须等待全部已跟踪任务结束。
 - 引导解析器最多使用四个工作线程；全部忙时在调用方既有期限内等待，不返回人为容量错误。
 
 ### 物理 socket 初始化
 
-TCP/UDP 共用 Dialer：创建 socket、nonblocking、源地址/Windows 接口绑定与 protect
-在当前 Tokio runtime 的受跟踪阻塞任务中完成，避免 FD 表扩容等同步系统调用占满
-业务 worker。异步 connect、reactor 注册与收发仍在原 runtime，不新增独立线程池、
-CPU 数判断、业务数量配额、FD 预热或 DNS socket 复用。
+TCP/UDP 共用 Dialer。Linux 普通 socket 的创建、原生选项和 bind 在当前异步任务中
+完成，使用同一初始化许可、取消令牌和停止跟踪；此路径不执行宿主回调、名称解析或
+接口发现。配置 TFO、MPTCP、protect、源地址、显式接口、DNS binding 或自动接口发现
+时，继续使用原受跟踪阻塞任务；其他平台也保留该路径。异步 connect、reactor 注册与
+收发仍在原 runtime，不新增线程池、CPU 数判断、业务数量配额、FD 预热或 DNS socket 复用。
 
-每个初始化作用域最多持有 64 个未完成的阻塞提交，TCP/UDP 共用内部许可。
-在登记任务、创建 socket 和 `spawn_blocking` 前异步等待许可，不因繁忙返回容量错误；
-等待继承调用方期限和取消，Stop 关闭准入并唤醒等待者。许可由阻塞任务持有到真正
-完成或被丢弃，调用方提前取消不会释放已开始工作的许可。它不限制已建立连接，
+每个初始化作用域最多持有 4 个未完成的初始化操作，TCP/UDP 共用内部许可。
+在登记、创建 socket 或提交阻塞任务前异步等待许可，不因繁忙返回容量错误；
+等待继承调用方期限和取消，Stop 关闭准入并唤醒等待者。许可持有到初始化真正
+完成或被丢弃，调用方提前取消不会释放已开始阻塞工作的许可。它不限制已建立连接，
 不增加独立线程池或公开配置；也不把等待调用的数量或整进程内存变成有界保证。
 
-取消关闭结果接收器并跳过尚未开始的初始化；已开始的系统调用或同步 protect 不能
-强制中断，完成后丢弃未交付的 socket。每个 Running Session/测速图拥有独立的
+WireGuard 物理 UDP 路径通过原上游请求和共享 Dialer，尽力申请 512 KiB 接收缓冲。
+系统可以拒绝、放大或限制该提示；继续使用同一受保护 socket，不改变逻辑包预算、
+队列、初始化或停止契约。Linux 内核 socket 缓冲通常不计入进程 RSS，增加提示并不
+等于没有内存成本，也不能替代 Apple physical footprint 或真机验证。
+
+阻塞路径取消时关闭结果接收器并跳过尚未开始的初始化；原生路径在创建前、策略执行后
+和返回前检查同一取消令牌。已开始的系统调用或同步 protect 不能强制中断，完成后
+丢弃未交付的 socket。每个 Running Session/测速图拥有独立的
 初始化作用域。Stop 先关闭 admission，再取消并等待业务/协议任务，最后等待已登记
-初始化任务完成，才释放平台回调租约。测速 runtime 的销毁也使用完整 join，不能
+初始化操作完成，才释放平台回调租约。测速 runtime 的销毁也使用完整 join，不能
 以有限 shutdown timeout 脱离在途初始化。protect 仍必须快速、同步、非阻塞；
 线程位置变化不放宽宿主回调契约，也不改变保护失败关闭或 Windows 双绑定策略。
 
 ## 共享流传输基础
 
-`stream-transport` 仅包装传入 IO，不创建 socket 或 DNS。WS/HTTP响应首部最多16 KiB、100字段；WS用户请求头最多100字段，额外固定升级头和early-data仍计入16 KiB总预算。WS early-data最多2,048原始字节，头名称/路径后缀由类型化选项区分。WS消息和单帧最多64 KiB，写入切块16 KiB；HTTP首包正文直接写入，不整体复制或持续按HTTP正文定界。
-
-共享的无池gRPC/legacy H2适配器每个实例仅拥有一条底层连接与一个逻辑流，不是全局并发许可；VLESS另有下文描述的节点级gRPC池。流窗口64 KiB、连接窗口128 KiB、最大HTTP/2帧和发送缓冲各16 KiB、解码负载64 KiB。读侧按实际消费量释放窗口；每poll最多处理32个片段/控制消息。原有gRPC和legacy H2的shutdown关闭整个逻辑连接；Trojan使用独立duplex模式，仅发送END_STREAM并保留读取。关闭前已接受的数据须到达所提供IO的flush边界，不能仅排入h2队列后立即reset/abort；每个逻辑写端最多一个待确认数据块，Stop可取消等待。两种模式的owner.stop都等待驱动任务退出；Drop只做取消兜底，不作为同步停止通过证据。WS/HTTP适配器按底层CloseWrite语义工作，协议包装层可以根据Mihomo契约结束整个逻辑流。所有握手使用调用方同一个绝对deadline。
-
-XUDP现在只拥有已认证流上的帧编码；VLESS响应头由VLESS包装层处理。元数据仍最多512字节，单payload仍受调用方预算和u16 wire上限约束，不新增全局会话额度。
+`stream-transport` 仅包装传入 IO，不创建 socket 或 DNS。WS/HTTP响应首部最多16 KiB、100字段；WS用户请求头最多100字段，额外固定升级头和early-data仍计入16 KiB总预算。WS early-data最多11,904原始字节，并按当前请求的实际剩余首部预算进一步缩小；头名称/路径后缀由类型化选项区分。WS消息和单帧最多64 KiB，写入切块16 KiB；HTTP首包正文直接写入，不整体复制或持续按HTTP正文定界。
+
+共享的无池gRPC/legacy H2适配器每个实例仅拥有一条底层连接与一个逻辑流，不是全局并发许可。Trojan/VMess/VLESS共用节点级gRPC池，物理连接按节点实例隔离，复用保留原上游与安全策略，每条逻辑流独立认证。流窗口64 KiB、连接窗口128 KiB、最大HTTP/2帧和发送缓冲各16 KiB、解码负载64 KiB。读侧按实际消费量释放窗口；每poll最多处理32个片段/控制消息。Trojan池使用内部duplex模式，仅发送END_STREAM并保留读取和lease；VMess/VLESS只结束当前逻辑流。关闭前已接受的数据须到达所提供IO的flush边界，不能仅排入h2队列后立即reset/abort；每个逻辑写端最多一个待确认数据块，Stop可取消等待。节点池最多保留4条空闲连接，PING ACK期限15秒；节点Stop取消并join全部物理驱动。无池模式的owner.stop同样等待驱动任务退出；Drop只做取消兜底，不作为同步停止通过证据。WS/HTTP适配器按底层CloseWrite语义工作，协议包装层可以根据已声明的协议关闭契约结束整个逻辑流。所有握手使用调用方同一个绝对deadline。
+
+Trojan/VMess/VLESS 的 YAML gRPC 池阈值省略或三项字面全零时采用 4/0/0，Mihomo 为 1/0/0。显式
+`max-connections: 1` 或 `max-connections: 2` 保留各自策略。连接按需建立，不预建四条，也不提高单连接的
+窗口或缓冲上限；新增连接仍增加自身的驱动、协议状态及接收信用。内部无池传输与
+TrustTunnel/MASQUE 的 CONNECT 所有者不使用这项 YAML 默认值，保留原连接策略。
+
+MASQUE H2 CONNECT-IP 单独采用 128 KiB 流接收信用，连接接收信用仍为 128 KiB。
+其它共享流传输的 64 KiB 流窗口、16 KiB 发送缓冲和最大帧保持原样；信用按实际消费
+释放，不预分配全部额度，也不改变 capsule、flush、FIN 或同步 Stop 语义。
+
+H2 CONNECT-IP 只合并已就绪的 capsule，每批最多16次出队／16 KiB编码字节，
+不等待凑批；无效包也计入扫描预算。每条隧道复用一个16 KiB聚合缓冲，最多暂存
+一个已编码的溢出 capsule。合法大包仍独立发送，不因聚合阈值拒绝。
+每批仍通过原IO完成 write_all 与强flush后才处理下一批；TTL只调整一次，
+结束前提交已取得的前缀，取消与Stop仍由原所有者回收，不增加后台发送任务。
+
+Gun 读侧只暂存最多9字节的gRPC/protobuf头；校验后直接从当前H2帧交付负载前缀，
+不累计完整消息或复制到第二份正文缓存。头部移入解析状态、负载交付给调用方后才释放
+对应H2信用；未读帧尾继续持有信用。取消保留头、帧与剩余长度；合法前缀交付后发现
+正文截断仍返回原协议错误。负载上限、空消息、trailers及写侧flush/FIN/Stop边界保持。
+
+XUDP现在只拥有已认证流上的帧编码；VLESS响应头由VLESS包装层处理。元数据仍最多512字节，单payload仍受调用方预算和u16 wire上限约束，不新增全局会话额度。接收直接填充既有的单帧有界缓冲，保留合并到同次读取中的后续帧与取消后的解析进度，不增加固定暂存区。
+
+Trojan UDP 接收直接读入既有的有界帧缓存，每次最多读取 2 KiB，不在等待中的
+异步接收状态内另留 2 KiB 临时区。开始读取时按需预留缓存，取消保留已接收的
+帧前缀；帧上限、包预算和关闭语义保持不变，关联释放时销毁缓存。
+
+公共 sing-mux 包装器按节点拥有独立池，只消费底层协议到约定目标的 TCP IO。
+每池最多保留16条闲连接；命令/物理写队列16项、写块16 KiB。smux接收帧共享每物理连接的字节预算，单流队列槽数由该预算推导；当前默认值见[XHTTP/sing-mux](xhttp.md#通用-sing-mux)。
+h2mux每流接收窗口64 KiB、连接接收窗口512 KiB，按实际读取量释放信用。
+连接额度允许少量未读取流占住各自窗口时，其他逻辑流继续接收；不预分配全部窗口。
+yamux单连接累计接纳64流后退役，连接接收窗口16 MiB；活动兄弟流继续。
+满足 XHTTP PacketUp 自主写条件的私有 h2mux，普通 DATA 仅在现有 h2 capacity
+范围内移交驱动后接纳，16 KiB 发送缓冲不变。每逻辑流固定一个确认状态，物理 flush
+列表每流至多一个弱引用登记；不按 DATA 保留 oneshot。显式 flush/END_STREAM 前仍确认
+真实 supplied IO flush，首帧期限、部分写取消、来源隔离和同步 Stop 不变；不新增任务或全局额度。
+私有 h2mux 的底层写入有正进度而 flush Pending 时，以一个布尔状态触发一次驱动重调度；
+没有后续写入便不再自唤醒。重调度不分配队列或确认状态，也不把 Pending 当作 flush 完成。
+h2mux/yamux上传半关闭保留读取与lease，smux v1关闭整条逻辑流。
+图只登记最终包装器；begin_shutdown同时关闭mux和底层准入，shutdown先join全部
+mux驱动，再等待底层协议。provider代际与node-only测速复用此屏障，没有全局池。
 
 ## 协议局部预算
 
@@ -98,9 +151,15 @@ XUDP现在只拥有已认证流上的帧编码；VLESS响应头由VLESS包装层
 
 普通 TUN UDP 关联：
 
+- 共享已发布代际的不可变节点和策略组注册表，不为每个关联复制指针数组；旧会话保留原代际直到释放；
 - 关联表不设固定项数；
 - 每个关联的入站队列最多 64 项，满时只丢当前数据报，不等待慢关联并阻塞其他来源；
-- 普通响应队列最多 4,096 项，满时只丢当前响应；没有共享 UDP 入站中转队列；
+- 普通响应队列最多 256 项；满时每源关联最多暂持一个已接收响应，暂停该关联继续接收，
+  同时等待写回容量、处理请求和取消，不增加队列或任务。取消或错误时丢弃未提交响应；
+  没有共享 UDP 入站中转队列；
+- 每源关联每处理 32 个实际响应显式退让；共享响应队列占用达到四分之一时提前退让，
+  让唯一 writer 与其他关联推进。不等待凑批、不预取包、不按忙碌情况拒绝关联。
+  接收的原生合作预算继续保留。
 - reader 拥有关联表和入站分发，唯一 TUN writer 直接、公平消费普通/DNS/TCP raw 三个通道；写回等待不阻塞 reader，不增加逐关联写回任务；
 - TCP/ICMP ingress 满时非阻塞丢当前完整 IP 包，避免阻塞 UDP/DNS，记录 packet queue drop；TCP 重传恢复，不引入 pending FIFO；
 - 使用代次感知所有权和子取消令牌；
@@ -115,28 +174,101 @@ XUDP现在只拥有已认证流上的帧编码；VLESS响应头由VLESS包装层
   响应队列满不会延长源关联所有者的生命周期。
 - reader EOF、错误或取消时，先取消其 UDP 子作用域，再删除、取消并等待全部关联和 DNS 任务；父运行时统一取消并等待唯一 writer 与 netstack。UDP 子作用域停止不取消调用者令牌。
 
+开启 Controller 的业务 UDP 按目标独立统计、取消并固定出口。`DatagramTransport` 必须显式声明
+多目标共享能力，没有默认值；透明包装传递底层能力，不能在包装时退回隐式独占。
+公共路由层统一决定复用，仅允许同一源关联、同一具体节点和资源代际内的未改写 IP 目标。
+支持路径包括 DIRECT、SOCKS5 UDP、Trojan UDP、XUDP、VLESS/VMess packetaddr、UoT、
+原生 SS2022、HY2 UDP、TUIC native/quic、Mieru、TrustTunnel，以及 WireGuard/MASQUE/IP 的内层 UDP。
+内层复用只合并端口租约、逻辑会话或响应交接；底层物理隧道的已有池化保持原状。
+raw VLESS/VMess、Gecko、固定物理 peer、尚未确定具体出站的路由包装保留独立传输。
+VMess packetaddr 的 AES/ChaCha 与 none/zero body 沿用相同共享门禁；body cipher 不改变逐包目标编码。
+fake-IP、QUIC 目标改写、域名及其它需要地址还原的请求始终隔离，即使底层支持多目标；
+两个原目标可能解析到同一个真实端点，不能仅靠回包源地址区分。
+共享路径只有一个接收者，按回复地址找到仍有效的目标，未请求或过期回复丢弃。
+帧写入中途取消时，不能重试已损坏的可靠流：整条关联失败关闭，其成员按关联错误退出。
+目标正常退出后物理关联退役，继续服务既有目标，新目标另建关联；防止目标重建或 flow-id 更换后
+旧回复串入新会话，不保留历史目标墓碑。最后目标退出关闭关联，Stop 同步释放全部关联。
+每目标只登记取消通知，不分配逐目标接收 future、任务或负载队列。
+DIRECT 在源关联内共用一个延迟分配的接收暂存缓冲，保留预算加一字节的超长包检测；
+交付包只持有实际负载。持续的就绪队列每目标最多一个通知，接收只轮询被唤醒的目标，
+不新增逐目标任务或负载队列。Mieru 通过私有单槽响应交接提供相同的就绪轮询，
+容量仍为一项，满槽使后台完整包解析器等待；取消、关闭及 reader join 保留。
+未提供轮询接口的协议继续使用取消安全的异步接收。
+成功接收后的本地 FIFO 重排不唤醒正在运行的接收者；外部就绪、取消和工作预算耗尽仍保留唤醒。
+目标访问时检查自身过期，整个表每 10 秒清理并回收多余容量；流量不会推迟该期限。
+DELETE 通过取消令牌立即唤醒等待中的接收，关闭与 flow-id 替换移除旧就绪注册。
+
 ### 定向数据报预算与受控 QUIC
 
 `DatagramBudget` 分别表达当前层的发送和接收 payload 上限。嵌套协议先为下层申请有界 envelope 空间，再按实际协议/地址族开销扣除下层能力，与调用方预算取交集；不能把接收上限直接当作发送能力。DIRECT、SOCKS5、SS 2022、SS/AnyTLS UoT 和 VLESS XUDP 保留对端/地址校验。超出发送预算在写入前失败，超出接收预算丢当前包并有界让出执行权，close 后不能恢复收发。UoT 的流头不从 UDP payload 预算扣除；SS 首包门控、读取任务与单响应队列的局部上限见[出站](outbounds.md#udp-over-tcp-v2)。
 
-`quic-transport` 只把已有 `DatagramTransport` 适配成 Quinn 的受控 UDP 接口，没有内部 bind、DNS 或 DIRECT 回落。每个连接双向各最多32个排队数据报，另允许一个正在发送的包；TX满返回WouldBlock，RX满暂停读取。接收等待不会持有发送队列锁；Pending发送不会重复提交。单逻辑peer/物理peer映射和来源校验独立保留，不接受未请求的目标、GSO或源地址覆盖。物理 socket 仍只能来自 Dialer。
+UoT 写入最多暂持一帧及偏移；取消单次发送后，后续收发先完成它，原建链期限不重置。
+实际写入失败或超时使关联失效；关闭丢弃未提交帧，并取消、等待既有读取任务。
+
+`quic-transport` 只把已有 `DatagramTransport` 适配成 Quinn/quiche 共用的受控 UDP 接口，没有内部 bind、DNS 或 DIRECT 回落。每个连接双向各最多32个排队数据报，另允许一个正在发送的包；TX满返回WouldBlock，RX满暂停读取。接收等待不会持有发送队列锁；Pending发送不会重复提交。单逻辑peer/物理peer映射和来源校验独立保留，不接受未请求的目标、GSO或源地址覆盖。物理 socket 仍只能来自 Dialer。
+已打开且受保护的 UDP 路径可借出一个在途发送操作；驱动等待发送或 pacing 时继续接收，保持32包队列与一个发送中的包。首次发送仍由原路径完成初始化；上游不支持此能力时沿用原发送。停止先释放在途操作，再关闭并释放上游。
+立即就绪的读取、发送容量与发送完成检查不登记新的等待者；仅在同一状态锁内确认 Pending 后登记唤醒，保留后续数据、容量恢复、取消与 Stop 的通知。
+队列通知采用边沿：TX由空变非空、RX由满变为有容量时通知驱动；已排队TX由就绪条件继续推进。
+普通RX消费保持底层已有的接收等待，避免逐包取消并重建同一等待。
+
+XHTTP 和 DoH/H3 通过 `quinn-h3-transport` 使用官方 h3/h3-quinn，共享取消安全的请求包装与
+非 DATA 帧编码预算；它不创建 socket、查询池或额外业务 body 队列。未完成发送的请求丢弃时 reset，
+成功提交 FIN 后不因丢弃发送半而 reset，也不等待逐请求 QUIC ACK。各协议窗口和并发边界见
+[XHTTP](xhttp.md) 与 [DNS](tun-icmp-dns.md)。
+
+未显式配置 reuse-settings 的 XHTTP H3 复用既有活动连接，每条最多 4 个逻辑租约；
+最后一个租约释放即移出候选池并按既有预算收尾，不缓存空闲连接。
+满足 [XHTTP 固定出口与安全边界](xhttp.md#http-transport-复用) 的 VLESS 私有 H2 腿采用相同 active-only 模型，每条最多 4 个逻辑租约，上传/显式下载各自隔离；其它 H2 路径、H1 与显式复用参数保持原契约。阈值溢出创建新物理连接，不拒绝逻辑流，不改变每流窗口或缓冲。
+
+XHTTP packet-up 的单批 backing（含正在发送的正文）上限为 H1/H2 64 KiB、H3 128 KiB，
+并与该 writer 采样的 POST 上限取较小值；按需扩容，不积累第二份正文。普通路径等待完整
+POST 响应才释放写背压和确认 flush。无 Encryption、无独立下载、无 padding 且 only-tcp=false
+的 VLESS h2mux，仅 H3 packet-up body/auto 上传保留最多两个未退役响应槽：发送 FIN 完成、
+最后正文引用释放并归还唯一 Vec，且槽未满后才能复用正文；flush 仍等待连续成功响应。
+每批只有一份有界 owner 元数据，不复制正文，也不增加 QUIC 窗口、队列或停止预算。该 backing
+上限不是进程 RSS 上限；HTTP/QUIC codec、发送窗口和 allocator 的共同持有峰值需实测。
+
+`quiche-h3-transport` 为 TrustTunnel/MASQUE 使用官方 quiche 的低层驱动，共享上述数据报适配器，不创建新的 socket。
+接收时移动既有队列中的数据报，独占存储直接交给 quiche 原地解密；共享或不可变存储
+使用按接收预算延迟分配的复用暂存缓冲。Quinn 的借用接收接口和两端队列上限保持不变。
+每个 quiche H3 stream 的已读取 body 最多保留 64 KiB，每次业务写入最多 16 KiB；
+只有本地主动请求创建业务状态，未知 DATAGRAM flow 丢弃，已注册 flow 的交付队列最多 64 项。
+这些是局部缓存界限，不宣称 QUIC 库内部总内存固定，也不限制活动业务流总数。
+TrustTunnel H3 使用 quiche 的本地发送容量比例 0.5，按当前可用拥塞窗口与对端信用
+折算应用写入额度，不足时沿原异步背压等待；不改变拥塞控制算法、接收窗口或协议帧，也不是固定字节或 RSS 上限。
+容量不足不能单独证明对端流控信用耗尽，不据此丢弃业务 UDP 帧。
+帧开始写入后必须完成；部分写入失败或被取消时关闭该来源关联，不丢弃帧尾后继续发送下一帧。
+MASQUE 与其余 quiche H3 默认使用原生比例 1.0。
 
 QUIC双向可用payload至少1,200字节；endpoint必须显式把QUIC MTU限制在有效预算内。IPv4/IPv6路径MTU分别先扣除28/48字节IP+UDP头，边界和单字节不足均有定向测试。
 
-QUIC owner.stop先取消并等待驱动，再关闭并释放上游；上游close最多1秒。Driver Drop仅为取消/abort兜底，不能作为同步Stop验收。队列容量是单连接局部界限，不是全局QUIC连接准入数。
+Linux 受控物理 UDP 的收发与就绪注册可并发借用同一 socket。借用不跨 Pending 或 await，
+不转移 socket 所有权；退役先关闭准入，再等待在途借用结束并取走资源，保留的 poller 不延长 fd 生命周期。
 
-TUIC 与 Hysteria2 共用这一接点；TUIC 的独立会话、关联 ID 退役、控制流、分片负载
+QUIC owner.stop先取消并等待驱动，再关闭并释放上游；上游close最多1秒。H3 的关闭预算内停止新请求准入并执行关闭交换，XHTTP 和 quiche 物理连接退役还保留有界的传输收尾机会，不承诺逐流远端 ACK。Driver Drop仅为取消/abort兜底，不能作为同步Stop验收。队列容量是单连接局部界限，不是全局QUIC连接准入数。
+
+TUIC 与 Hysteria2 共用这一接点。接收窗口通过官方 Quinn API 固定设置：
+每流 max(initial, min(maximum, 4 MiB))，
+连接 initial；默认 TUIC 4 / 2 MiB，HY2 64 KiB / 4 MiB，不预分配全部信用额度。
+DoQ 初始及最小发送 payload 为 1200 字节，接收预算独立保留，允许较大的合法对端包。
+
+TUIC 的独立会话、关联 ID 退役、控制流、分片负载
 及交付队列边界见 [TUIC v5](outbounds.md#tuic-v5)。旧池的待建流也持有所有权，
 不能在等待 credit 时被当成空闲池回收。TUIC 业务 UDP 队列使用独立观测类别。
+native 接收循环每处理最多 512 个就绪事件主动让出执行权，quic relay 保持 32 个；
+底层异步等待和协作式调度可更早让出，不增加接收或交付队列。
 
 ## DNS
 
+- 生产运行时从归一化的`dns.cache-max-size`构造缓存，缺省或零值为4,096项。主、bootstrap及已配置的节点/直连解析角色各拥有独立结果容量；A/AAAA类型化结果与原始响应共用每个角色的这份条目数。原始响应另受64项/256KiB预算约束，TUN域名提示独立为256项。
+- `ResourceLimits::dns_address_cache_entries`默认256，只是显式低层构造可传入的容量，生产启动不会用它覆盖`dns.cache-max-size`。WireGuard/MASQUE的私有节点resolver通过独立`DnsConfig::default()`构造，当前默认同为4,096项，不继承用户全局缓存容量覆盖；DNS关闭时的系统ECH metadata resolver另固定64项。这些局部容量不构成进程RSS上限。
 - 不设置固定的活动请求或活动传输总许可数。
 - 相同 key 的 cache miss 使用 singleflight；leader 取消后 follower 重新选举。
 - UDP 传输属于单次请求，同一尝试的重发复用当前传输。
-- 显式 TCP nameserver 按 endpoint 和配置的 route target 复用；一条连接同时只处理一个查询。
+- 上游尝试仅在选择 TCP/TLS 或 DoQ 后分配对应的异步状态；普通 UDP 不内嵌未使用的握手状态。装箱不创建额外任务，取消仍直接丢弃该尝试及其拥有的状态。
+- TCP、DoT、DoH 按上游身份、endpoint 和 route target 复用；TCP、DoT、HTTP/1.1 一条连接同时只处理一个查询，HTTP/2 和 HTTP/3 每连接最多 32 个并发查询。DNS TLS 不保留恢复票据，复用已认证连接。
 - 活动 TCP 不设固定数量上限；空闲连接总数最多 4，同 key 最多 2，空闲超时 30 秒。
-- 查询、单次尝试和 UDP 重发期限分别为 5 秒、3 秒和 1 秒。
+- 查询、单次尝试和 UDP 重发期限分别为 5 秒、3 秒和 1 秒。每次查询最多并发 4 个上游，胜出后取消其余尝试；UDP TC 转同一上游 TCP。
 - 响应最多扫描 64 条记录，类型化缓存和提示最多保留 16 个唯一 IP。
 - 停止取消打开、发送、接收、重试和响应发送，并释放全部传输。
 
@@ -146,21 +278,75 @@ IP-only协议接点持有`ResolutionContext`，runtime DNS通过Weak绑定，不
 
 ## 代理组与 Controller
 
-- 静态 `select` 组只拥有不可变的有序成员和每组一个可原子替换的当前索引，不拥有协议连接、后台任务、队列、缓存或独立 worker。
-- 组数、每组成员数、重复成员数和嵌套深度没有独立固定上限，统一受 256 KiB YAML 上限约束；配置期使用 O(V+E) 的迭代 DAG 校验，运行时也以迭代方式解析当前叶节点。
+- 每个资源代际内的组成员保持有序且不可变；组保存当前选择、健康与策略状态，协议连接仍由节点拥有。健康探测由该资源代际统一调度，最多并发 10 项，停止时取消并等待完成。
+- provider 候选整体验证后发布，既有会话保留原资源代际；不再被使用的旧代际停止探测并释放资源。选择与 fake-IP 持久化由各自的存储所有者管理。
+- 组数、每组成员数、重复成员数和嵌套深度没有独立固定上限，统一受 8 MiB YAML 输入与 32 MiB 展开计费上限约束；配置期使用 O(V+E) 的迭代 DAG 校验，运行时也以迭代方式解析当前叶节点。
 - 节点上游和全部组成员在同一 DAG 中校验；组连接器只持有声明依赖，按逆依赖顺序释放。建链快照只按需记录本次遇到的组，不成为全局缓存。Hysteria2 的已认证连接为后续端口跳跃保留该快照，直到此物理会话退出；它不再读取实时选择，也不延长原建链期限。
 - 同组成功选择是线性化的，不同组独立；选择失败不改变状态，也不创建重试或自动 failover 任务。
 - 切换不扫描或迁移现有 TCP、UDP、DNS transport，不刷新 DNS cache/singleflight 或 TCP pool；资源仍由原所有者按既有 timeout、EOF、取消和 stop 语义回收。
-- Controller 同时最多跟踪 8 个连接任务。请求 header 和 PUT body 各有 5 秒读取期限，PUT body 最大 1 KiB；超时、超限和解析失败只终止当前请求。
+- Controller 同时最多跟踪 8 个连接任务，包含最多 4 个 WebSocket 订阅。header、body 和输出各有 5 秒 I/O 期限；普通 PUT body 最大 1 KiB，`PUT /configs` 在取得独立配置应用许可后允许最多 8 MiB，并使用配置候选的 90 秒总期限。超时、超限和解析失败只终止当前请求。
+- WebSocket 按需采样，不为每个订阅保存历史快照；输出 JSON 在扩容前限制 256 KiB，连接快照先限制 512 个引用。客户端缓冲/消息/帧各 1 KiB，慢写取消当前订阅。日志总线仅在订阅时保留 64 条共享事件，不截断事件内容或另设每秒条数限制；无订阅不格式化或轮询，Stop join 连接并释放订阅。
 
 完整接口见 [运行时 Controller](controller-api.md)。
 
+## Provider 与 HTTP 资源
+
+Provider 在现有 AGE 解密后读取 YAML、URI 列表或标准 Base64 URI 订阅，转换结果继续走
+名称过滤、override、完整节点与依赖图校验及资源代次发布。输入和解密结果最多 8 MiB，
+URI 转换使用 32 MiB 保守空间计费，单行最多 64 KiB，嵌套最多 64 层。
+URL/query、凭据解码、JSON/YAML 转换和选项 clone 前按单行最坏结构预留临时空间；
+展开节点及名称索引单独保留计费，多端口来源逐个加入候选。外层 Base64 清理与解码
+先检查并存空间。JSON 先做不构建值树的语法检查，再复用有界 YAML visitor。
+这份估算不包含调用者已持有的源文件，不代表 allocator 精确容量或进程 RSS 上界；
+不足时整个候选失败，不增加业务数量准入或新的配置字段。
+
+HTTP(S) 资源共用流式 gzip 解码与 URL Basic。压缩 framing 与解压内容分别计数，
+size-limit 作用于解压内容；完整 gzip 校验和落盘成功后才返回候选，坏流或取消删除暂存。
+解码输出块检查同一取消与期限，不整包缓冲解压结果。跨 origin 不转发原认证或 Cookie。
+Provider 来源身份摘要绑定精确 URL 和实际请求 header/UA；GeoData 用精确 URL 摘要。
+来源元数据和 Debug 不保存或输出明文凭据，GeoData 的来源显示仅保留 origin。
+Provider 旧 URL-only 身份须无条件刷新；旧内容可用与其 ETag/订阅元信息可信度分别判断，
+来源身份不符时保留内容但无条件重新获取，不用旧身份授权 304。
+
+## 离线规则 bundle
+
+`rule-providers.*.path-in-bundle` 使用 `dataDir/BundleMRS.7z` 中的精确成员名；
+不展开到目录、不预置资产、不对其他 Provider 生效。初始化依次尝试有效缓存、bundle、
+原 file/http 来源；缺失或无效 bundle 沿用原来源。有效成员按原格式解析，原始字节与
+无 ETag 的本地来源标识原子写入缓存；本地来源不算已完成 HTTP 获取，重启也保留这一语义。
+
+单次初始化按顺序读取各资源，同一读取只有一个单线程解码器。先检查签名与 CRC、
+128 KiB header/decoded header、单 encoded-header packed stream（16 MiB）及至多8个 coder，
+再让官方 `sevenz-rust2` 读取 metadata。拒绝加密、外置 metadata 与未审核 codec；
+支持 COPY、LZMA1/2、Delta 及 x86/ARM/ARM Thumb BCJ。随后检查所选压缩块的单输入链、
+4096项文件表、128 MiB压缩输入和256 MiB解码总量；仅保留目标成员，最多64 MiB，
+并受 size-limit 进一步约束。solid前置成员流式丢弃，目标读至EOF后才接受校验结果。
+
+字典、输出和保守metadata计费共享96 MiB准入估计；该估计不包括allocator、解析后的规则
+及整个进程其他资源，不能当RSS上界。检查在官方 decoder分配之前执行，metadata中的
+计数由受限header长度约束。超过局部边界的bundle使用原来源，不静默截断成员。
+读取与解码检查取消、30秒局部期限、累计256 MiB来源读取和65536次I/O操作。
+使用同一个打开的文件句柄，异步调用者等待阻塞任务完成，不以丢弃JoinHandle替代停止。
+
+## Provider 名称表达式
+
+普通筛选表达式继续使用线性时间的 `regex`。必要的 lookaround/backreference 使用
+`fancy-regex`，限制复杂源码 4 KiB、AST 512 节点/32 层、有限重复数 4096、委托编译和
+DFA 缓存各 512 KiB；不接受递归、条件式和控制动词。每次复杂匹配最多 10,000 回溯，
+输入名称最多 4 KiB。一次候选共享最多 10,000 次复杂匹配/改名匹配和 100 ms 执行窗口；
+改名输出最多 64 KiB，后续表达式继续计费。单次库调用不能中途抢占，调用间检查取消。
+编译、预算、运行错误与取消均使候选失败，保留当前资源和 HTTP 缓存，不静默漏选节点。
+这些边界仅用于名称表达式，不改变 GeoData/DOMAIN-REGEX 或业务连接准入。
+
 ## GeoData
 
 - 所有平台完整加载被引用分类的所选记录，不设记录条数硬上限或截断；GeoIP 与 GeoSite 没有优先额度分配。
 - 同种基础 code 按 ASCII 大小写归一，业务规则与 DNS policy 共用分类和值存储。属性取交集；正反选择器共享匹配器，多种属性筛选共享值及已编译正则，不重复解码同一分类。未引用分类不构建匹配器。
 - 各平台均不设独立 GeoData 分类、引用、文件大小、累计源码/值字节或总加载内存预算；DNS GeoSite policy 也不保留独立项数/引用数上限。
-- Loader 只解析被引用的分类，其他分类按 wire 长度跳过。
+- DAT Loader 只解析被引用的分类，其他分类按 wire 长度跳过。默认国家 MMDB 与 DAT 二选一；
+  Meta 国家库在完整校验后优先将配置引用的分类编为紧凑 CIDR，并释放原始文件缓冲；
+  投影不更省或不适合时保留原 Reader。其他国家 schema 与 ASN 保留拥有字节的 Reader，
+  按索引借用查询。各路径均不建立逐地址缓存，不截断记录或增加 GeoData 内存准入。
 - Domain/Full 匹配器使用紧凑连续存储，运行期查找不分配。Regex 使用共享的
   `regex::bytes::Regex` 并关闭 Unicode 匹配模式；库管理编译状态和搜索缓存，搜索可能
   分配 scratch、增长缓存或竞争共享缓存，不能将 Domain/Full 的无分配性质扩展到 Regex。
@@ -183,22 +369,34 @@ IP-only协议接点持有`ResolutionContext`，runtime DNS通过Weak绑定，不
   排空响应间隔不等于整体 Stop 时限，释放存储也不保证 allocator 立即归还 RSS。
 - 卸载后的加载失败只使对应种类不可用，健康另一类仍发布；不恢复旧整体快照。
   卸载前的下载/结构失败保留当前匹配器，失败更新均保留旧磁盘资产并按现有调度重试。
+  国家 MMDB 与 ASN 先借用候选校验，再排空旧快照，构建投影或移动候选字节，失败保留/恢复旧代。
   304 在 matcher 已可用时只调度，不可用时重载本地资产。既有 TCP 选路与 TUN UDP
   固定 action 不回溯；没有新增公开 API、业务数量配额或 GeoData 内存预算。
 
-GeoData 行为见 [规则与资产](geodata.md)。性能与压力测试由
-[container-benchmark](https://github.com/YuanDevTeam/container-benchmark) 维护，
-测试结果记录在对应运行中。
+GeoData 行为见 [规则与资产](geodata.md)。性能与压力测试由独立容器测试工具执行，
+结果与结论统一保存在 benchmark 工程。
+
+## 统一内存策略
 
-## Apple 内存遥测
+所有平台与构建共享上述队列、缓冲、缓存、QUIC 窗口与线程策略。
+CLI 和 FFI 使用同一 Invoke 启动路径，无独立内存编译开关、YAML 字段或 Invoke 参数。
 
-iOS/tvOS TUN 通过 `TASK_VM_INFO` 尽力记录当前 physical footprint、进程生命周期峰值和限频阈值事件，运行期间最多每 30 秒采样一次。macOS 不启用该周期任务；平台接入与事件标识见 [TUN 平台层](tun-platform.md)。
+TUN 在生命周期边界及运行期间每 30 秒尽力记录进程内存和限频阈值事件。
+Apple 使用 `TASK_VM_INFO` 的当前与生命周期峰值 physical footprint；Linux 使用
+procfs 的 VmRSS/VmHWM。其他平台的采样不可用时只报告一次诊断，不伪造读数。
 
-- 采样失败只记录一次警告；
-- 遥测不写入 `lastError`；
-- 读数和阈值越界不改变 prepare、start、running、stop 或 panic recovery；
-- 停止后的 allocator pressure relief 同样是尽力而为；
-- 固定阈值只是诊断信号，不是产品内存承诺或 admission gate。
+GNU/Linux 的 TUN 在工作线程启动前，进程内一次性尝试设置 glibc arena 为 1、
+mmap 阈值为 32 KiB；显式 `MALLOC_ARENA_MAX`、`MALLOC_MMAP_THRESHOLD_` 或
+`GLIBC_TUNABLES` 覆盖优先。这是进程级 allocator 设置，可能影响同进程中的宿主分配。
+Stop 的同步释放屏障完成后，Apple 通过 malloc zone、GNU/Linux 通过 `malloc_trim`
+尽力归还空闲内存；不支持该接口的平台保留原 allocator 行为。
+
+- 未使用 TUN 时不配置 allocator、不启动周期采样或 Stop 回收。
+- 采样失败只记录一次警告，不写入 `lastError`。
+- 43/45 MiB 阈值分别对应默认 1 Gbps 与 2 Gbps 的预算，仅作诊断；Core 不推断负载档位，最终由 benchmark 按实际负载判定。这些观测不改变 prepare、start、running、stop 或 panic recovery。
+- Stop 后的 allocator 回收只执行一次且尽力而为，不保证立即降低进程内存。
+
+内存预算与真实设备范围见[验收边界](acceptance.md)。
 
 ## 日志与观测
 
@@ -207,10 +405,11 @@ iOS/tvOS TUN 通过 `TASK_VM_INFO` 尽力记录当前 physical footprint、进
 独立 netstack 的 `udp_drops` 只记录通用 UDP endpoint 的入站丢弃；生产 TUN 使用
 TCP-only netstack，因此该值为零不代表 UDP 无丢包。运行时记录
 `udp_association_queue_drops` 和 `udp_response_queue_drops`，保留两者合计的
-`udp_queue_drops`；TCP/ICMP ingress Full 记录 `packet_queue_drops`。这些计数
+`udp_queue_drops`。普通响应暂持等待容量不计丢包，取消或错误后实际丢弃才计数；
+TCP/ICMP ingress Full 记录 `packet_queue_drops`。这些计数
 不包含物理 socket、内核 TUN 或对端设施中的丢包。
 
-日志必须有界且脱敏，不记录目标、DNS question、UUID、凭据、密钥、负载或完整配置。
+CLI 与 Controller 按日志级别完整输出事件的 target、message 和字段，不按敏感内容脱敏或删减。Controller 的订阅队列、WebSocket 消息与写入期限仍按上文限制；超过消息预算时关闭订阅，不发送截断事件。
 
 仅`cfg(test)`/`interop-test`启用的`ResourceProbe`按测试作用域记录RAII当前值/峰值；子任务显式继承作用域，不使用进程全局reset或更换生产allocator。当前接入物理TCP/UDP、共享流/QUIC驱动与session、数据报association、DNS池/等待者及既有运行时活动guard。Hysteria2 的待完成分片通过 `Reassembly` 登记，交付后释放 Packet ID 和重组资源；零计数必须与实际执行过的重组路径一起解释。
 
@@ -225,3 +424,13 @@ TCP-only netstack，因此该值为零不代表 UDP 无丢包。运行时记录
 4. 记录主机和对应物理平台证据。
 
 没有测量证据时不增加新的资源控制层。实际验证范围见 [验收矩阵](acceptance.md)。
+
+
+## 在线配置候选
+
+Controller 与 Invoke 共用每实例一个候选许可，在完整请求 body／JSON 分配前准入；队列仅一项。候选复用 provider 代际 worker，所有已启动阻塞解析、图准备、路径准备与 GeoData 注册操作均由该 worker join。失败不发布新图，不覆盖活动 provider body／metadata；完成图验证后可以创建受 dataDir 约束的缓存目录。配置替换原子发布模板、图、DNS、组和可用资源快照，退休代际由活动业务持有。此局部准入不限制正常业务连接数，也不将 YAML 上限描述为整进程 RSS 限制。
+
+
+SS2022 插件复用受控 TCP、原有 TLS 预算和 Stop 所有者。obfs/V2Ray mux 每次最多保留
+一个 16 KiB 输出帧；HTTP 头最大16 KiB，mux元数据最大512字节。裸smux的物理命令队列和
+聚合接收字节数均有界；取消/Stop等待全部自有驱动结束。
diff --git a/docs/testing-isolation.md b/docs/testing-isolation.md
index 16ebf57..ea7f02e 100644
--- a/docs/testing-isolation.md
+++ b/docs/testing-isolation.md
@@ -4,8 +4,8 @@
 均在隔离容器中运行。宿主只运行待测客户端、测试驱动和观察工具。
 纯内存、编解码和离线配置测试可在宿主执行；容器不可用时报告未执行，不回退到宿主服务端。
 
-编排、对端下载和压力测试由 [container-benchmark](https://github.com/YuanDevTeam/container-benchmark)
-管理，执行时显式传入 `--source vole=PATH`。Vole 编译不依赖 benchmark checkout。
+编排、对端下载和压力测试由独立容器测试工具管理，执行时显式传入
+`--source vole=PATH`。Vole 编译不依赖测试工具 checkout。
 
 ## 执行要求
 
@@ -14,10 +14,14 @@
 2. 对端使用官方最新稳定发行二进制和官方稳定镜像，记录实际版本。保留 Mihomo 回环
    保护及第三方默认 socket 行为。仅 Caddy 可按需使用官方 xcaddy 构建并注明来源。
 3. 地址来自容器网络；配置、证书和凭据放临时目录，fixture 只读挂载，日志有界且脱敏。
-4. 启动前注册清理，成功、失败、超时和中断均回收本次拥有的资源。构建、下载、配置、
-   日志和采样等临时文件随运行清除；公共依赖缓存与生产发布产物独立保留。
-5. 结果记录实际命令、环境、输入、流量、指标、失败和清理状态。双向业务应校对内容，
+4. 启动前登记资源所有权，成功、失败、超时和中断均停止并等待本次容器退出。
+   先保存文字结论，再删除本次临时容器、网络和中间产物；已验证的共享依赖缓存独立保留。
+   清理前复查资源归属；清理失败时保留必要现场并记录错误。
+5. 结果记录实际命令、环境、输入、流量、指标、失败、停止和清理状态。双向业务应校对内容，
    认证拒绝应确认原站未收到被拒绝的业务，客户端超时本身不能证明拒绝生效。
+6. CLI、原生 Invoke/FFI、协议、DNS、生命周期和压力的网络业务统一经过真实 TUN。
+   使用隔离的负载网络命名空间、真实 raw-IP fd，并校验 TUN 流量和回收；
+   Controller 仅作管理入口。纯内存、离线和编译检查不要求 TUN。
 
 互通、压力和设备验收分别执行，范围见 [验收边界](acceptance.md)。具体对端与用例参数
-由 benchmark 维护，本仓库不复制运行记录。
+与实测结论统一由 benchmark 工程维护。
diff --git a/docs/tls-client-fingerprint.md b/docs/tls-client-fingerprint.md
index 43e117d..0dc8be4 100644
--- a/docs/tls-client-fingerprint.md
+++ b/docs/tls-client-fingerprint.md
@@ -5,26 +5,34 @@
 | 字段 | 含义 | 接受值 |
 | --- | --- | --- |
 | `fingerprint` | 服务端证书 DER 的 SHA-256 pin | 64 个十六进制字符，可带冒号 |
-| `client-fingerprint` | 客户端 ClientHello 的命名模板 | 下列七值；空串也关闭 |
+| `client-fingerprint` | 客户端 ClientHello 的命名模板 | 下列十值；空串也关闭 |
 
 | 公开值 | 实际模板 |
 | --- | --- |
 | `none` | 关闭命名指纹，不关闭 TLS 或 REALITY 认证 |
 | `chrome` | Chrome133 |
-| `chrome120` | Chrome120（固定） |
-| `firefox` / `firefox120` | Firefox120 |
-| `safari` / `safari16` | Safari16.0 |
+| `firefox` | Firefox120 |
+| `safari` | Safari16.0 |
+| `ios` | iOS14 |
+| `android` | Android11 OkHttp，TLS1.2 |
+| `edge` | Edge85 |
+| `360` | 360 Browser7.5 的已实现能力子集，TLS1.2；YAML 中写为字符串 |
+| `qq` | QQ11.1 |
+| `random` | 进程首次按 Chrome133/Safari16/iOS14/Firefox120 = 6:3:2:1 选中一个模板 |
 
 节点省略时关闭，显式启用推荐 `chrome`；这是节点级选项，无全局默认。
-大小写敏感，未知名称、`null`、错型全部拒绝；不接受 `chrome133`、`safari16.0`、
-移动端、随机或 PSK/PQ 专用名称。短名只随显式依赖升级和验收变更，不随 OS 自动选择。
+大小写敏感，未知名称、`null`、错型全部拒绝；不接受带版本号的名称、
+其它未列出名称、废弃的 `randomized` 或 PSK/PQ 专用名称。短名只随显式依赖升级和验收变更，不随 OS 自动选择。
+`random` 仅共享不可变模板选择，后续连接、配置替换及 Stop/Start 不重抽，不共享 TLS 会话。
+兼容约束按实际选中模板检查，不能通过 random 绕过 TLS 版本或 H3 限制。
 
 ## 适用范围
 
-AnyTLS、Trojan、VMess + TLS、VLESS + TLS/REALITY/JLS 使用同一共享连接器。
+AnyTLS、Trojan、VMess、VLESS 的普通 TLS 和已支持的 REALITY/JLS/ShadowTLS 身份复用共享连接器；
+TrustTunnel H2 保持标准 TLS。各协议可用身份与传输范围见 [出站](outbounds.md#流式安全身份)。
 TCP、WS、gRPC、HTTP 首包伪装、legacy H2、Vision、XHTTP H1/H2 仍遵守各自的协议约束。
-关闭 TLS 时不能携带该字段。SS2022 + ShadowTLS v3 复用上述模板，作用于 cover
-握手并强制 TLS1.3；其未命名握手也由 boring 执行。SOCKS5 和裸 SS 不接入 TLS 指纹。
+关闭 TLS 时不能携带该字段。SS2022 + ShadowTLS v3/JLS 复用上述模板，作用于插件握手；两种身份均强制 TLS1.3，
+未命名握手也由 boring 执行。SOCKS5 和裸 SS 不接入 TLS 指纹。
 
 XHTTP `download-settings.client-fingerprint` 缺省继承主腿，显式名称覆盖，`none` / 空串清除。
 下载腿即使与主腿使用同一服务器，也拥有独立的 TLS 策略、身份和缓存。
@@ -42,64 +50,120 @@ client-fingerprint: chrome
 - 默认验证公开信任链、名称及有效期。叶证书 pin 匹配时以叶证书为显式信任依据，
   不再要求公共根、名称或有效期；匹配非叶证书时将其作为信任锚，仍验证叶链、名称和有效期。
   skip 只跳过常规验证，不能覆盖不匹配的 pin；所有策略仍验证握手签名。
-- 未启用指纹的标准 TLS 和 QUIC 使用 crates.io 官方 rustls + ring，不依赖 rustls fork。
+- 未启用指纹的流 TLS，以及 HY2/TUIC/DoQ/XHTTP H3/DoH H3 的 Quinn QUIC，使用官方 rustls + ring。
+  TrustTunnel/MASQUE 的 H3 使用官方 quiche 与同一 boring；H3 不应用命名指纹。
 - 命名指纹的标准 TLS，以及所有 REALITY/JLS，使用自有 boring fork；开发及 PR/发布的来源规则见 [TLS 依赖](tls-dependencies.md)。
-- 普通 TLS 两条路径共用同一个 WebPKI 证书验证器和发布信任根；叶 pin、非叶信任锚、
+- 普通 TLS、Quinn 与采用标准 TLS 认证的 quiche H3 共用同一个 WebPKI 证书验证器和会话信任根；叶 pin、非叶信任锚、
   独立验证名、skip 优先级不变。TLS 握手签名仍由各自后端强制验证。
-- VLESS mTLS 继续使用配对的内联 PEM，密钥匹配在使用 IO 前检查；profile 不修改身份。
+- HTTP、SOCKS5、AnyTLS、Trojan、TrustTunnel、VMess、VLESS、Hysteria2、TUIC v5 与 SS2022 ShadowTLS cover 的 mTLS 使用配对内联 PEM 或文件路径，
+  配置校验与资源生成时读取文件并检查密钥匹配；客户端证书不增加服务端信任根，profile 不修改身份。
+- quiche H3 的 ECH 仅支持 X25519/HKDF-SHA256，AEAD 为 AES128/256-GCM 或 ChaCha20-Poly1305。
+  静态和 DNS 来源按该后端选择；不兼容或未实际接受时失败，不用 GREASE 替代，不降级为明文 ClientHello。
 - REALITY 仅允许自身临时证书认证，不能混用 pin/skip/mTLS 或降级到普通站点证书。
 - [JLS](vless.md#jls) 使用共享凭据身份和完整原生 TLS1.3，不启用恢复或 PKI 回退；profile 不改变身份。
-- 连接器只包装 Dialer/上游交付的 IO，不解析 DNS、不创建 socket、不绕过平台 protect。
-
-## 四模板边界
+- 连接器只包装 Dialer/上游交付的 IO；动态 ECH 通过既有解析上下文请求原始 HTTPS 记录，
+  DNS 角色与物理 IO 仍由运行时和共享 Dialer 拥有，不绕过平台 protect。
+
+证书与密钥的相对路径从初始化的 `dataDir` 解析；CLI 校验模式使用 `-d` 的目录而不初始化它。
+未初始化的普通 `validateConfig` 和直接 Rust `Config::parse_yaml` 使用当前工作目录，绝对路径原样使用。
+每个资源生成过程读取的身份文件合计最多 8 MiB，只接受普通 UTF-8 PEM 文件；错误不回显路径或内容。
+内联身份固定；文件身份由运行时既有资源工作器每秒检查元数据，稳定读取并校验整对后发布，
+失败保留旧身份。TLS 握手不读取文件。配置对象仍保留校验时的内联快照，文件更新不重建
+代理图、不重置规则、DNS 或健康状态，也不更新业务 HTTP/MITM CA。
+活跃的不同文件对按其当前已发布 PEM 输入大小合计最多 8 MiB；被旧 Provider 节点持有的
+来源也计入，同一路径对共享材料。新来源或更新超出预算时保留可用身份/资源；文件读取候选
+同样有界。已建立的连接只持有其实际 TLS 所需的旧代材料，不能阻塞同一文件对继续轮换。
+
+## 客户端信任根
+
+`tls.custom-certifactes` 使用 Mihomo 的真实字段拼写，接受证书内容字符串数组，
+不读取路径，也不增加 `custom-certificates` 别名。内容在配置校验时解码，非法证书
+使 Vole 校验失败；与 Mihomo 对非法条目发警告后继续的行为不同。未知 TLS 字段
+继续拒绝。同一个顶层 `tls` 对象也接受 HTTPS Controller 的服务端证书与客户端认证字段，
+由独立的服务端加载器消费，不加入出站信任根；契约见 [Controller](controller-api.md)。
+独立测量配置仅接受客户端 `custom-certifactes` 子集。
+
+启动时读取可用系统根，合并内置 WebPKI 和自定义根，构造一份会话共享的不可变根库。
+普通/指纹 TLS、QUIC、DNS 各角色、WireGuard 私有 DNS、Provider/GeoData 下载及
+健康探测都使用该根库。资源更新复用它，不重读系统根；新启动才能取得新的系统信任。
+独立 `measureDelay` 配置也接受该客户端对象，节点与最终 HTTPS 探测共享其工作器根库。
+纯校验只解析显式证书内容，不读取系统证书存储。客户端身份不增加服务端根。
+
+系统读取使用官方 rustls-native-certs：macOS 读取可导出的信任设置，Windows 读取
+Current User ROOT，Linux 发现 CA 文件/目录。SSL_CERT_FILE/SSL_CERT_DIR 可按该库
+规则覆盖来源，读取失败保留基础根和有效自定义根，不关闭验证或转为明文。
+导出根后的证书验证仍为 WebPKI，不承诺 native verifier 的全部信任、撤销与策略行为。
+Android、iOS 和 tvOS 在此库的 Unix 发现分支中，不能完整读取平台系统/用户信任；
+这些平台保留内置与自定义根，实际可读文件仅补充来源，不宣称完整系统信任等价。
+Windows UWP/AppContainer 的真实根读取仍需独立设备验证；交叉编译不构成签收。
+
+## 命名模板边界
 
 模板由 fork 固定密码套件、组/share、签名算法、扩展排列及受限扩展编码。
 
 | 模板 | 主要差异 |
 | --- | --- |
-| Chrome120 | 经典 X25519 share，GREASE/乱序、ECH GREASE、Brotli、条件 padding、旧 ALPS 17513 |
-| Chrome133 | 普通 TLS 与显式混合 REALITY 使用原生 X25519MLKEM768 和 X25519 双 share；新 ALPS 17613，无 padding |
+| Chrome133 | 普通 TLS 与显式混合 REALITY 使用原生 X25519MLKEM768 和 X25519 双 share，无 padding |
 | Firefox120 | 自有 cipher 顺序、固定扩展顺序、X25519/P-256 双 share，无 GREASE/ALPS/证书压缩 |
 | Safari16.0 | 固定扩展和签名顺序、GREASE、条件 padding、真实 Zlib 解压，模板本身不加 ECH/ALPS |
+| iOS14 | 独立套件与扩展顺序、GREASE、条件 padding，无证书压缩；真实 c023/c027/003c CBC-SHA256 协商 |
+| Android11 OkHttp | 独立套件与扩展顺序，无 GREASE、证书压缩或 TLS1.3 声明 |
+| Edge85 | 固定扩展顺序、GREASE、X25519 share、Brotli 证书解压 |
+| 360 Browser7.5 | TLS1.2、P-256/P-384/P-521；不启用假 DHE/DSA、RC4 或禁用套件 |
+| QQ11.1 | 独立命名模板，固定扩展顺序、GREASE、X25519 share、Brotli 证书解压 |
 
 TLS 版本范围、SNI、ALPN、证书策略、身份和恢复预算仍由节点及传输决定。
+Android/360 的参考模板只有 TLS1.2 能力；要求 TLS1.3 的身份与传输拒绝此组合，不伪造 share 或改名。
 因此名称表示版本固定的 TLS 模板，不承诺完整浏览器行为或所有上下文的逐字节相同。
-最低 TLS1.2；Safari 的 TLS1.0/1.1 声明裁剪，Vision/XHTTP/REALITY 继续强制 TLS1.3。
+最低 TLS1.2；Safari/iOS 的 TLS1.0/1.1 声明裁剪，Vision/XHTTP/REALITY 继续强制 TLS1.3。
 普通 Vision/XHTTP 的版本约束同时省略 TLS1.2 cipher 及仅用于旧握手的
 EC point formats、extended master secret、session ticket、renegotiation info 扩展。
 命名 REALITY 则保留模板的 TLS1.2 声明与字段，由原生 REALITY 在 ServerHello 阶段
 拒绝非 TLS1.3 协商；这与关闭命名指纹时的 TLS1.3-only 默认 offer 分开。
-ALPS 仅在实际提供 h2 时发送，不复制 Mihomo 某些 WS 调用中的额外 h2 ALPS。
+Core 使用标准 H2 SETTINGS，不声明 TLS ALPS，也不复制 Mihomo 某些 WS 调用中的额外 h2 ALPS。
 classic REALITY 移除 Chrome133 的 ML-KEM group/share，并绑定实际 X25519 私钥；
 Firefox 的额外经典 share 不产生第二份 REALITY 身份。REALITY 仍拒绝 HRR、恢复和 0-RTT。
 
-`reality-opts.support-x25519mlkem768`：默认 false，true 要求实际
-发送且协商 X25519MLKEM768（4588），经典选组即失败，不重试或降级。只兼容 `chrome`
-或关闭命名指纹；后者使用原生混合-only offer，不自动切到 chrome。Chrome120、Firefox120、
-Safari16.0 在配置期拒绝该组合。下载腿继承/整体替换 REALITY 后，再独立验证最终 profile。
+`reality-opts.support-x25519mlkem768`：默认 false，true 允许在同次握手中协商
+真实 X25519MLKEM768（4588）或经典组。Chrome133 与未命名 profile 提供混合/X25519
+双 share，其余 TLS1.3 模板保留各自真实经典 share，不伪造混合能力或自动改成 Chrome。
+Android/360 的模板只有 TLS1.2，不能用于 REALITY；这项限制来自实际模板版本，
+并非新增协议限制。下载腿继承/整体替换 REALITY 后独立验证最终 profile。
+服务端选择允许的经典组不触发重试；HRR、认证失败仍终止，不降级为普通 WebPKI。
 ML-KEM 增强 TLS 密钥交换，REALITY 身份认证仍基于 X25519，不宣称后量子身份认证。
 
-Firefox 的 FFDHE、delegated credentials、record size limit 及 Safari 的模板专用
+Firefox 的 FFDHE、delegated credentials、record size limit 及 Safari/iOS 的模板专用
 cipher 声明不开放新的配置能力；不能真实完成的对端选择明确失败，不静默换模板。
+iOS 的 c024/c028/003d 与 Safari/iOS 的 c008 仅声明，对端选中会失败；003c 使用
+已有原生 RSA/AES-CBC/SHA256 实际协商，并保留 deprecated 标记，默认套件不启用。
 
 模板不模拟浏览器 HTTP/2 SETTINGS、QUIC 参数，也不会自动启用实际 ECH。
-VLESS 可另行显式配置[静态 ECH](vless.md#静态-ech)：四模板均可使用，届时强制 TLS1.3、
+VLESS/VMess/Trojan/AnyTLS/Hysteria2 可另行显式配置 [ECH](vless.md#ech)：具备 TLS1.3 能力的六种模板可使用，届时强制 TLS1.3、
 加入真实 ECH 并关闭恢复；不再声称与未启用 ECH 的历史浏览器模板逐字节相同。
-当前 HTTP 驱动不导入 TLS ALPS 中的应用设置，因此**非空 ALPS 响应明确失败**；
-未协商或协商空设置可用。Brotli/Zlib 解压输出和原生证书消息上限均为 128 KiB；
+当前 HTTP 驱动不导入 TLS ALPS 中的应用设置，握手时不声明该可选扩展，
+由标准 SETTINGS/ACK 初始化。意外协商的非空 ALPS 仍失败，不能静默忽略设置。Brotli/Zlib 解压输出和原生证书消息上限均为 128 KiB；
 超限、截断、错误算法和损坏压缩流失败，不能绕过证书认证。
 
 ## 所有权与关闭
 
-节点的 SNI、ALPN、验证策略、mTLS 身份、版本范围、profile 和 SSL 上下文不可变。
+节点的 SNI、ALPN、验证策略、版本范围和 profile 不随文件更新改变。每条新物理 TLS/QUIC
+连接使用一次已发布的 mTLS 身份快照；既有 H2/gRPC/QUIC 物理连接可继续使用原身份。
+rustls 按身份代缓存不可变 resolver/config，Boring 在独立 SSL 对象中安装该次身份，
+quiche 在该条物理连接的上下文中安装身份，均不修改进行中的握手。
+原生证书表示只由实际使用它的 TLS 客户端持有，材料登记只保留弱缓存；失败候选释放其原生需求和缓存。
 每次独立构造建立独立缓存，clone 只共享同一节点。标准 TLS 的运行时票据总预算为 4；
+文件身份换代后，旧代票据不能恢复新连接，旧连接晚到的票据也不进入新代缓存；
+各代共享原节点的固定容量，不随轮换次数增加缓存。身份检查工作器随资源工作器同步停止。
 TLS 1.3 票据只消费一次，TLS 1.2 会话也计入预算，过期票据清除，零预算关闭恢复。
 非零 TLS1.2 ticket lifetime hint 与原生 session timeout 取较短者；零提示不扩大原生期限。
-Safari16 不声明 TLS1.2 session-ticket 扩展，该版本的恢复使用会话 ID，不能把不存在的
+Safari16/iOS14 不声明 TLS1.2 session-ticket 扩展，该版本的恢复使用会话 ID，不能把不存在的
 票据提示当作它的过期时间。TLS1.3 的票据期限已由原生握手收敛。
 握手及应用层 ALPN 策略通过前，暂存票据不会进入节点缓存。REALITY 始终不恢复。
-别名只复用模板，不扩大节点/下载腿缓存归属。冷连接和恢复连接分开验收；Vole 的
+同一模板的使用不扩大节点/下载腿缓存归属。冷连接和恢复连接分开验收；Vole 的
 票据策略不同于 Mihomo，恢复 hello 不宣称逐字段相同，也不伪造 PSK/binder。
+quiche H3 为每条物理连接构造独立原生 TLS 上下文，禁用恢复与 0-RTT；
+节点内已认证的 H3 连接仍可复用，关闭和取消由其驱动所有者同步回收。
+XHTTP H3 与 DoQ/DoH H3 同样禁用恢复与 0-RTT；ECH 从完整来源按 rustls 后端选择，未接受时握手失败。
 
 CloseWrite 刷新 close_notify 最多 5 秒，保留底层连接和读方向；重复关闭幂等，
 关闭后拒绝写入。Vision direct 切换保留同一 TLS 记录边界，先排空明文/刷新密文，
diff --git a/docs/tls-dependencies.md b/docs/tls-dependencies.md
index 15540f9..3746f3b 100644
--- a/docs/tls-dependencies.md
+++ b/docs/tls-dependencies.md
@@ -6,29 +6,56 @@
 
 | 用途 | 来源与约束 |
 | --- | --- |
-| 普通 TLS、QUIC、WebPKI | 官方 rustls/tokio-rustls，ring provider |
-| 命名 ClientHello、REALITY、JLS、ShadowTLS v3 | YuanDevTeam/boring，release 分支及锁定 revision |
+| 普通流 TLS、WebPKI | 官方 rustls/tokio-rustls，ring provider；rustls-native-certs 只读取可用平台根，不替换验证器 |
+| Quinn QUIC | HY2、TUIC、DoQ、XHTTP H3 和 DoH/H3 使用官方 registry Quinn 0.11.12 / quinn-proto 0.11.19、rustls/ring；窗口与数据报预算通过公开 API 和 Core 包装处理；Linux DIRECT 的有限 GSO/ECN 使用同一受保护 fd 的 Linux ancillary API，不另建 socket |
+| Quinn HTTP/3 | HY2 认证、XHTTP 和 DoH/H3 使用 registry h3 0.0.8 + h3-quinn 0.0.10，MIT；HY2 认证与业务共用同一 Quinn 连接，XHTTP/DNS 的取消和帧预算由 Core 公开 trait 包装处理，不修改上游源码 |
+| quiche HTTP/3 | TrustTunnel 和 MASQUE 使用 registry quiche 0.30.0，BSD-2-Clause；自有低层驱动使用公开 API，共用同一 boring/boring-sys，不启用 quiche FFI、qlog 或另一套 TLS 来源 |
+| QUIC 拥塞控制 | HY2/TUIC 保留其 Quinn 控制器；XHTTP/DoH 使用 Quinn 原生默认控制器，TrustTunnel/MASQUE 使用 quiche 原生控制器，配置映射见 [出站](outbounds.md) |
+| MASQUE 密钥 TLS | H2 使用 rustls/ring，H3 使用 quiche + 同一 boring；ECDSA 身份、逐证书 SPKI pin 与握手签名认证保持独立于 WebPKI |
+| Controller 随机服务端身份 | 官方 rsa 仅生成 RSA 2048 密钥；rcgen + ring 签发自签证书，实际 TLS 和握手签名仍由 rustls + ring 处理；随 Controller 入站 feature 启用 |
+| 业务 HTTPS 处理 | rcgen + ring 使用宿主提供的 CA 签发短期叶证书；官方 x509-parser 校验 CA、密钥匹配与有效期，不生成根 CA 或安装信任，见 [HTTP 处理](http-processing.md) |
+| 命名 ClientHello、REALITY、JLS、ShadowTLS v3 | YuanDevTeam/boring；开发使用同一 fork 的本地 path，PR 和发布使用固定 commit |
 | SS 2022 | 官方 shadowsocks，仅 `aead-cipher-2022` |
+| Mieru 分段认证 | UDP 低熵编码及 TCP 保留官方 RustCrypto chacha20poly1305 0.11.0；其余 UDP 复用同一 boring/boring-sys 的安全可变 XChaCha20-Poly1305 原位 AEAD，均用 ring PBKDF2；Mieru 不使用 TLS，不引入另一套 TLS provider |
 | Encryption | 同一 boring 的 X25519、ML-KEM、AEAD、AES-CTR；官方 blake3 |
-| 静态 ECH | 官方 hpke + rustls HPKE trait，命名模板使用 boring ECH 接口 |
+| 静态/动态 ECH | rustls 使用官方 hpke + 公开 HPKE trait；命名模板及 quiche H3 使用同一 boring ECH selector |
+| Provider AGE | 官方 age/age-core 的 armor、MAC 和 STREAM；Hybrid 身份用官方 hpke XWing，关闭插件与 CLI |
+
+Quinn 与 quinn-proto 均来自官方 registry，使用其原生拥塞实现。
+CI 核对锁定版本、registry 来源、wrapper 依赖边及 rustls/ring provider；不维护 protocol fork。
 
 AWS-LC 只用于 `shadowsocks → shadowsocks-crypto → aws-lc-rs → aws-lc-sys`，
 不用于 TLS/REALITY。禁止 FIPS、2022-extra 和第二套 REALITY 后端。
 BoringSSL 子模块保持原样，fork 补丁通过 feature 控制。
 
+AGE 使用获准的官方兼容稳定版本 `age 0.11.5` 与 `age-core 0.11.0`。
+其 0.12 系列强制依赖的旧 ML-KEM 与当前 `hpke 0.15.1` 的正式 KEM 依赖不兼容；
+此版本例外仅限上述两项，Hybrid 保持最新稳定 HPKE/RustCrypto 路径。
+
 ## 开发与升级
 
-1. 本地开发可将 boring、tokio-boring、测试用 boring-sys 一起切为同一自有 fork 的
-   相对 path，保留版本与 feature 约束并更新 Cargo.lock。
-2. 发起或更新 PR 前，将 fork 改动发布至 YuanDevTeam/boring 的 `release`，三个 crate
-   一起切回 Git release 来源；更新锁文件和 CI 批准 revision。
-3. 在不依赖本地 fork 的 checkout 执行 locked 构建，核对来源、provider/feature graph，
+1. 本地开发将 boring、tokio-boring、boring-sys 的直接／开发依赖，以及
+   `[patch.crates-io]` 中 quiche 使用的 boring/boring-sys，统一指向
+   `../boring/{boring,tokio-boring,boring-sys}` 对应的相对 path；保留版本与 feature
+   约束并更新 Cargo.lock。
+2. 发起或更新 Vole PR 前，检查 Boring checkout 的源码变更和拟引用提交的公开状态。
+   若所需自有修改尚未提交、推送或进入 Boring PR，先整理提交并推送，发起或更新
+   对应 Boring PR，确认所需变更已包含于可公开获取的 commit。
+3. 将三个 crate 的直接／开发依赖和两个 patch 一起切为相同 Git URL 与 `rev`，
+   使用完整 40 位 commit SHA；更新 Cargo.lock，CI 以清单中的 `rev` 核对实际来源。
+   可以引用已推送的 Boring PR head commit，来源不绑定分支或 tag。
+4. 在不依赖本地 fork 的 checkout 执行 locked 构建，核对来源、provider/feature graph，
    运行受影响的 TLS、协议和平台回归。回退同样通过新提交恢复已验证的锁文件。
 
+`stream-security` 由 VMess/Trojan/AnyTLS/VLESS 共同启用，不依赖另一个出站协议；
+Vision 仍单独随 VLESS 编译。ShadowTLS 由 `shadow-tls-v3` 独立控制。
 普通 TLS 与 REALITY 使用独立的不可变连接器。REALITY/JLS 握手、临时密钥和原生
 验证边界见 [REALITY](reality-wire-protocol.md)；模板与证书策略见 [TLS 指纹](tls-client-fingerprint.md)。
-Encryption 的二进制 context 使用 [薄 FFI](../crates/vole-blake3-raw/README.md) 中未修改的
-官方 BLAKE3 C 源码，保留其来源、许可证和符号隔离。
+Encryption 的二进制 context 使用 [薄 FFI](../crates/vole-blake3-raw/README.md) 调用
+官方 BLAKE3 C API；平台脚本通过官方 vcpkg 准备静态包，编译时隔离符号，不内置第三方源码。
+
+本地 path 验证需要配套 fork checkout，不代表固定 Git commit 的独立构建通过。
+PR 和发布验收使用实际锁定 commit；直接依赖、quiche patch、锁文件与 CI 必须一致。
 
 ## 原生构建
 
@@ -36,3 +63,12 @@ Encryption 的二进制 context 使用 [薄 FFI](../crates/vole-blake3-raw/READM
 同 ABI、同 NDK 的 `libc++_shared.so`。
 
 构建与发布入口见 [编译与发布](../scripts/README.md)。
+
+ECH 接收算法按实际后端区分。rustls HPKE adapter 支持 X25519、P-256/P-384/P-521、
+ML-KEM-768/1024、X-Wing、ML-KEM-768+P-256 和 ML-KEM-1024+P-384；
+KDF 为 HKDF-SHA256/384/512、SHAKE128/256，AEAD 为 AES128/256-GCM 或 ChaCha20-Poly1305。
+使用官方 hpke 的 `nistp/mlkem/shake` feature 和公开 HPKE trait，不增加 TLS fork。
+命名模板与 quiche H3 的原生 ECH selector 只接收 X25519/HKDF-SHA256 和上述三种 AEAD。
+静态和动态来源均按最终后端重新选择；没有兼容配置则明确失败，不关闭 ECH、不降级或重拨。
+quiche H3 在发送首包前通过公开 SSL 接口配置 ECH，握手后检查实际接受状态与 ALPN，
+通过后才开放 HTTP 请求。不能以原生通用 HPKE API 的值域推断 ECH selector 支持。
diff --git a/docs/tun-icmp-dns.md b/docs/tun-icmp-dns.md
index 7dbfad6..60c1f00 100644
--- a/docs/tun-icmp-dns.md
+++ b/docs/tun-icmp-dns.md
@@ -1,6 +1,6 @@
 # TUN ICMP 与 DNS
 
-Vole 在 TUN netstack 内回答受支持的 ICMP Echo Request。启用运行时 DNS 后，匹配 `tun.dns-hijack` 的 TUN TCP/UDP、选路惰性解析和内部查询共享同一套有界 DNS 实现。
+Vole 在公共 TUN 入口处理 ICMP Echo：Linux 可经受控物理接口实际发送，接口内地址、fake-IP 与禁用转发的请求保留本地合成回应；其他平台保持 netstack 本地回应。启用运行时 DNS 后，匹配 `tun.dns-hijack` 的 TUN TCP/UDP、选路惰性解析和内部查询共享同一套有界 DNS 实现。
 
 顶层 `ipv6: false` 时，IPv6 原始包会在进入 netstack 前被丢弃，因此不会触发 ICMPv6 回应或 IPv6 上的 DNS/业务流量；运行时 DNS 的有效 IPv6 能力同时要求顶层 `ipv6` 和 `dns.ipv6` 为 `true`。
 
@@ -11,18 +11,47 @@ Vole 在 TUN netstack 内回答受支持的 ICMP Echo Request。启用运行时
 | IPv4 | type 8, code 0 | type 0, code 0 |
 | IPv6 | type 128, code 0 | type 129, code 0 |
 
-响应会交换源地址和目标地址，保留 identifier、sequence 和 payload，重建最小 IP 头，将 TTL/Hop Limit 设为 64，并重新计算所有校验和。该路径完全位于 netstack 内，不调用 DNS、规则、出站、protect 或物理接口。
-
-输入要求：
-
-- 校验 IP 版本、头长度、声明长度、地址和校验和；
-- IPv4 可以携带合法 options，但响应不复制 options；
-- 不重组 IPv4 分片或 IPv6 Fragment Header；
-- IPv6 base Next Header 必须直接是 ICMPv6；
-- 非 Echo、非零 code、截断和非单播地址一律丢弃；
-- 单包失败不停止 netstack，也不生成 ICMP error。
-
-smoltcp 负责生成 Echo Reply，Vole 负责更严格的输入分类和运行时门禁。响应直接尝试进入现有原始包出站队列；队列满时只丢当前低优先级响应并更新统计，不创建等待任务或积压队列。
+Linux 的 `tun.disable-icmp-forwarding` 缺省 false。合法 Echo Request 按以下方式处理：
+
+- 目标属于启动时读取的真实 TUN 接口地址前缀，或属于启用的 fake-IP 地址池时，由 netstack 本地合成回应；借用 TUN 的前缀从其所属网络 namespace 读取，不以配置的设备名或任意物理 LAN 网段代替。
+- `disable-icmp-forwarding: true` 时，所有合法 Echo 保留本地回应，不打开物理 ping socket；合成耗时不代表目标的真实 RTT。
+- 其余请求经共享 Dialer 的 DIRECT 物理出口发送，不执行 DNS、普通 TCP/UDP 规则、代理节点或组，也不声称普通代理协议可以承载 ICMP。
+
+`tun.icmp-timeout` 单位为整数秒，缺省或 0 使用 10 秒，控制请求准入至物理答复匹配的期限。
+负值、超出有符号 64 位的整数及本机单调时钟无法表示的期限均拒绝，不复制 Duration 溢出。
+这两个字段仅 Linux 接受；其他平台将其视为未知字段，保持原本地合成行为。
+运行中改变归一化后的值须显式重连，沿用现有配置应用门禁，不增加独立控制 API。
+
+真实请求先经过 IP 长度、单播地址、IPv4 头及 ICMP 校验和验证；IPv6 校验包含实际地址的伪头。
+IPv4 可携带合法 options，但不重组分片；IPv6 base Next Header 必须直接为 ICMPv6，不处理扩展首部链。
+已识别的非法 Echo、非零 code、截断、分片或不支持的形状直接丢弃，不回退到自动合成。
+非 Echo 与既有可验证 PMTU 仍交给原 netstack 路径，不将物理错误解释为成功。
+
+真实 TUN 前缀快照读取失败时启动失败；显式禁用转发时不读取该快照。
+Linux 使用 `SOCK_DGRAM` ping socket；安装器或宿主须预先在相应出口 network namespace 中，
+通过 `net.ipv4.ping_group_range` 授权运行组。Core 不写 sysctl、不请求提权，也不回退 IP raw socket。
+创建、源地址、protect、物理接口与 mark 均复用共享 Dialer 的初始化和停止所有者。
+权限不足、出口错误、不可达、超时或容量不足只丢弃相应真实请求，不伪造本地成功。
+
+每会话最多两个物理 ping socket（每地址族一个），由一个驱动收发；不按目标创建任务或长期 socket。
+真实请求总共最多持有 64 个许可，入站与响应队列各 8 项，单个完整 IP 包最多 `min(tun.mtu, 2048)` 字节。
+发送后 pending 只保留地址、原始与 wire identifier/sequence、长度、SHA-256 摘要、期限和许可，不保留 payload。
+物理答复须携带有效接收接口与本地地址元数据，并匹配实际对端、校验和、wire 标识、长度、摘要及未过期记录；重复或不匹配答复丢弃。
+到期、发送失败、队列满或取消均释放对应所有权；不增加重传、无界目标表或待发送积压。
+这些是局部资源边界，不是进程 RSS 上限。
+
+真实答复和本地合成答复均恢复原 TUN 请求的 identifier、sequence、地址方向与 payload，
+重建最小 IP 头、TTL/Hop Limit 64 及校验和。本地合成继续使用 netstack 的原有 MTU 和有界 raw 出站队列，
+不受真实转发的 2048 字节上限限制。真实答复进入独立有界通道，与 TCP/raw、UDP、DNS 共用唯一 TUN writer；
+许可保留到写入完成、最终丢弃或取消。Stop 取消并等待驱动、reader 与 writer，释放 pending、队列和物理 socket；
+返回后不再向 TUN 回包。上述物理路径仅限 Linux，不扩展其他平台的权限或网络设置职责。
+
+TUN 的被动 TCP 与 MASQUE 的内部主动客户端均支持 ICMP PMTU 反馈：验证外层校验和、本地地址、
+被引用的活动 TCP tuple 及实际发送且尚未确认的序号，只降低对应连接的 MTU并重新分段。
+IPv6 宣告 MTU 小于 1280 时忽略，IPv4 小于 68 时取 68。
+分段使用官方 smoltcp 的包层适配，重传沿用其 TCP 定时器；元信息保存已发序号，
+不保留报文正文，容量独立有界，关闭连接时清除。其他 ICMP error 不转发或创建新流，
+不改变 TUN 的 MTU 门禁或 Echo 配置。
 
 ## TUN DNS 入口
 
@@ -50,7 +79,51 @@ UDP 读取器只做有界 wire 分类和任务提交，不同步等待上游。
 
 SVCB、HTTPS、TXT、PTR、MX、SRV、NS、SOA、DNSSEC 和未知 16 位 qtype 都可按原始查询转发。A/AAAA 响应中的可达 CNAME 链继续执行严格地址和 TTL 校验。
 
-TUN 域名提示存储只在启用 TUN 且业务规则包含域名类规则时创建。嗅探域名优先于 DNS 提示，两者都不改写实际目标。
+redir-host 域名提示在 DNS 开启且规则需要域名或已启用嗅探时创建，供业务入口共用。DNS 提示本身不改写目标；嗅探是否覆盖目标由 override-destination 控制。
+
+## 嗅探
+
+HTTP/TLS 用于 TUN 与 mixed TCP；QUIC v1/v2 多包识别由 TUN 和已授权的 SOCKS5 UDP 共用。
+`parse-pure-ip` 控制无域名目标，`force-dns-mapping` 控制 redir-host 提示，均默认 true。
+fake-IP 恢复后的域名与显式域名只在 `force-domain` 匹配时强制嗅探。
+`skip-src-address` / `skip-dst-address` 在读取前排除地址；`skip-domain` 排除识别结果。
+域名项支持通配、GeoSite 和 domain/classical 规则集合；地址项支持 CIDR、GeoIP 与
+ipcidr/classical 集合。classical 对完整 AND/OR/NOT 求值；只提供对应域名或目标 IP，
+其余元数据沿参考零值 TCP/HTTP、端口0、空入口名和未知身份，不发起地址解析或进程扫描。
+
+全局 `override-destination` 默认 true，协议级值优先。false 只将识别域名提供给规则，
+保留实际目标；true 替换为识别域名，DIRECT 或必须 IP 的传输再解析。
+UDP 覆盖保留原始目标供回包使用，活动流不随后续查询变更。
+
+HTTP/TLS 端口可重叠。每连接共享最多 64 KiB 预读，首字节最多一秒，随后解析最多一秒；
+优先识别 TLS，再识别 HTTP。失败、超时或跳过均保留已读数据供业务转发。
+HTTP 识别 HTTP/1.x Host、absolute-form 与 CONNECT 目标，以及 HTTP/2 首个请求的 authority/Host。
+HTTP/2 接收完整 HEADERS/CONTINUATION 后解码 HPACK，动态表上限 4 KiB，最多 128 帧/字段，
+编码与解码字节受相同 64 KiB 预算限制；歧义字段或非法帧不产生域名提示。
+TLS/QUIC 识别 ClientHello，检测到 ECH 时不使用外层 SNI。
+不嗅探劫持的 DNS。没有列出任何协议时不读取业务数据。
+
+## Fake-IP
+
+`enhanced-mode: fake-ip` 在 TUN DNS 回答 A/AAAA 时分配合成地址；hosts 优先。
+TCP 和 UDP 的 TUN / mixed 入口恢复域名后选路，节点、DIRECT 与必须 IP 的出站通过内部解析器取得真实地址。
+SVCB/HTTPS 在选择 fake-IP 时返回空回答；过滤到真实地址的查询仍转发。
+
+IPv4 池默认 `198.18.0.1/16`，IPv6 池默认关闭。每个池从网络地址 +4 开始分配，
+排除广播地址并循环复用；没有配置相应地址池时返回 NODATA。
+`fake-ip-ttl` 最小为一秒，只控制 DNS 回答 TTL。内存模式每个地址族最多保留 1,000 项，
+按使用情况淘汰。未知或已淘汰的合成地址不能作为真实目标拨号。
+
+`fake-ip-filter-mode` 支持 blacklist、whitelist 和 rule。前两种使用域名通配、GeoSite 或
+域名规则集合；rule 按声明顺序匹配域名规则并使用 `real-ip` / `fake-ip` 动作，未匹配时分配。
+默认 blacklist 只包含三个 Microsoft 连通性探测域名，详见配置示例。
+
+`profile.store-fake-ip: true` 将双向映射和分配位置写入 `dataDir/fake-ip.redb`，
+写入完成后才返回地址。磁盘存储的缓存有界，映射不受内存模式的 1,000 项限制。
+相同地址池在重启后保留系统 DNS 缓存中的旧地址；修改池范围时清除对应地址族映射。
+资源更新共享当前地址池，过滤器可独立更新。关闭持久化后重启不保证旧映射有效。
+活动 UDP 流保留首包选择和真实目标，并使用独立传输区分解析到相同真实端点的不同名称；
+回复恢复原合成地址，空闲和停止时释放。
 
 ## Nameserver 与出口
 
@@ -61,45 +134,151 @@ dns:
   nameserver:
     - "tcp://1.1.1.1:53#main-select"
   nameserver-policy:
+    "+.example.com": "223.5.5.5"
     "geosite:private,cn":
       - "tcp://223.5.5.5:53#DIRECT"
 ```
 
 ### Endpoint
 
-- 主 nameserver 必须有 1–4 项。
-- 只接受裸 IPv4/IPv6、`udp://IP[:port]` 和 `tcp://IP[:port]`。
+- `dns.enable`、`dns.ipv6` 默认 false。主 nameserver 默认使用 DoH/DoT，可显式替换为非空列表。
+- 接受裸 IPv4/IPv6、`udp://`、`tcp://`、`tls://`、`https://`、`http://` 和 `quic://`。加密连接复用会话的内置、可读系统与 `tls.custom-certifactes` 信任根；各解析角色及 WireGuard/MASQUE 私有 DNS 同样适用，平台边界见 [TLS 契约](tls-client-fingerprint.md)。HTTPS 根据实际 ALPN 使用 HTTP/2 或 HTTP/1.1；没有 ALPN 时使用 HTTP/1.1。明文 HTTP 仅支持 HTTP/1.1，不启用 h2c。
+- `rcode://success`、`rcode://format_error`、`rcode://server_failure`、`rcode://name_error`、`rcode://not_implemented`、`rcode://refused` 分别返回本地 RCODE 0–5；可用于 nameserver、policy、fallback、节点和直连 resolver，不能用于 default-nameserver。
+- 同一个上游列表中存在本地 RCODE 时使用第一项本地响应，不建立网络连接，也不把 SERVFAIL/REFUSED 当作上游故障重试。响应保留原查询的 flags 和 additional，仅设置 QR 与 RCODE；不额外开启 RA，不写入结果缓存。
 - `dns.ipv6: false` 不限制 IPv6 nameserver；顶层 `ipv6: false` 会阻止通过 DIRECT（含 `RULES` 选中 DIRECT）的 IPv6 nameserver 在本机物理建链，并继续当前组的故障转移。
-- Endpoint 必须是 IP 字面量，不支持 hostname、system 或 DHCP resolver。
-- 无 fragment 时固定使用 DIRECT。
-- Fragment 只接受 `DIRECT`、`RULES`、实际代理节点名或静态 `select` 组名。
+- 上游域名由 `default-nameserver` 引导解析，后者允许 IP 上游和显式 system。未启用 DNS 时，内部解析使用系统 resolver；启用后不因查询失败回退系统解析。
+- `system`、`system://`、`dhcp://system` 使用物理系统 DNS；`dhcp://<精确接口名>` 仅使用该接口的 DHCP DNS，不匹配其他接口。各 nameserver 角色、policy 和 fallback 均支持；DHCP 接口不能用于 default-nameserver。来源始终直连物理接口，fragment 与 respect-rules 不改其出口。
+- 无 fragment 时默认 DIRECT；`respect-rules: true` 改为 RULES，要求非空 `proxy-server-nameserver`。
+- Fragment 使用 `#出口或接口&参数=值`；出口接受 `DIRECT`、`COMPATIBLE`、`REJECT`、`REJECT-DROP`、`RULES`、实际代理节点名或支持的代理组名。
+  仅提供参数时沿用默认出口；整个 fragment 先百分号解码，再按 `&` 和首个 `=` 拆分，
+  同名参数和出口 token 以后项为准。节点/组名称优先，没有同名目标时作为物理接口名。
+  指定接口直接连接该 DNS 上游，覆盖全局接口、沿用全局 mark；接口失效时失败，不回退。
+  DoT/DoH/DoQ 的连接池身份包含接口，不能跨接口复用。未知键值参数拒绝。
+  system/DHCP 来源始终使用物理出口，忽略出口 token；节点私有 DNS 也忽略出口 token。
 - `#RULES` 只按 nameserver endpoint 和传输执行业务规则，不把 DNS question 当作选路域名。
-- 规则结果为 `REJECT` 时，当前尝试失败并继续当前组下一项。
-
-代理组成员可以是具体节点、嵌套组、`DIRECT` 或 `REJECT`。DNS exchange 需要新建物理 transport 时解析当时的当前叶节点；选中成员失败不会使代理组自动改选，但 nameserver 列表仍按本节已有故障转移语义继续下一项。
+- 规则模式下，UDP 跳过不支持 UDP 的节点或组，继续匹配后续规则；显式出口和 global 模式不做此跳过。
+- `RULES` 与业务 TCP/UDP 使用同一子规则求值器：`SUB-RULE`、`PASS`、`PASS-RULE` 的作用域一致，`rematch` 与 `REMATCH-NAME` 保留同一决策上下文；规则控制和组控制先于 UDP 能力检查。
+- `COMPATIBLE` 使用直连语义；`REJECT` 结束当前尝试，`REJECT-DROP` 的 TCP 等待仍受当前 DNS 查询期限和 Stop 限制，UDP 立即结束。失败后继续当前上游组下一项。
+
+代理组成员可以是具体节点、嵌套组、`DIRECT`、`COMPATIBLE`、`REJECT`、`REJECT-DROP`、`PASS` 或 `PASS-RULE`。PASS、PASS-RULE 和具名 rematch 仅在 rule 模式的 `RULES` 中参与规则流程；global 模式、显式命名组/节点或 dialer-proxy 选中控制目标时拒绝连接。DNS exchange 需要新建物理 transport 时解析当时的当前叶节点；选中成员失败不会使代理组自动改选，但 nameserver 列表仍按本节已有故障转移语义继续下一项。
+
+### 上游参数
+
+UDP/TCP/DoT/DoQ URL 只消费主机与端口；userinfo、路径和 query 与 Mihomo 一样忽略，
+不形成认证或请求路径。fragment 的上游参数仍按下述规则消费。
+
+`ecs` 接受 IPv4/IPv6 IP 或 CIDR，裸 IP 使用完整位数。已有 EDNS ECS 默认原样保留；
+`ecs-override=true` 只替换首个 ECS，保留其 scope、OPT flags 和其他 option，编码时掩去前缀外的位。
+缺少 OPT 时添加 UDP size 为零的新 OPT。包装作用于所有解析角色和 system、DHCP、RCODE，
+DHCP 接口名只取 URL endpoint，fragment 不参与接口查找。
+
+`disable-ipv4=true`、`disable-ipv6=true` 和 `disable-qtype-<编号>=true` 抑制对应 question，
+直接返回 NOERROR 空响应并设置 AA、RA，不读取来源或建链；编号限固定 Mihomo 参考已有 RR constructor。
+其他请求先验证上游响应，再过滤 Answer、Authority、Additional 中对应 RR。
+全报文通过官方 `domain` codec 重编码，保持所有存留名称引用有效；RFC 3597 未知 RDATA 保持原始字节。
+报文大小、记录数和名称压缩跳数仍受本节预算约束，不能通过过滤移除错误记录来绕过验证。
+类型参数和 `ecs-override` 仅在字面 `true` 时启用，与顶层及 DNS 的 IPv6 门禁独立。
+
+DoT/DoH/DoQ 的 `skip-cert-verify=true` 和 `name-cert-verify` 接共享 TLS 安全层，显式名称验证
+先于跳过验证且不改变 SNI。`disable-reuse=true` 仅使指定 DoT 上游每次新建并关闭连接，
+不改变 HTTPS 或其他上游的复用。不同参数的上游保持池身份隔离。
+
+### DoH 请求
+
+URL 只保留协议、带默认端口的主机、路径和 userinfo；丢弃原 query/fragment。
+路径按解码后的值重新编码，userinfo 百分号解码后生成 `Basic base64(用户名:密码)`，
+省略密码视为空串。认证值不出现在 Host、请求路径或 Debug/日志中，也不会跨池身份复用。
+请求使用 GET、`Accept: application/dns-message`，没有 body 和默认 User-Agent；
+`dns=` 为完整 DNS wire 的无 padding Base64URL。传输前 ID 改为 0，响应 ID 必须为 0，
+之后恢复原 ID 并执行原有 question、完整报文及缓存校验。
+
+H1/H2/H3 的请求及响应头各限 16 KiB，DNS body 仍限 4,096 字节。
+仅接受 HTTP 200 与 `application/dns-message`，响应长度声明、分帧及完整 DNS 校验必须通过。
+
+`dns.prefer-h3` 默认 false。true 时 HTTPS 的冷初始化同时建立已认证的 TCP TLS 与实际 H3，
+第一条成功连接用于查询；某条先失败时继续等待另一条。TCP 获胜时取消 QUIC 初始化并等待其 driver / adapter 收尾；
+H3 获胜时丢弃本次 TCP checkout，底层已开始的初始化由 Dialer / connector 的 Stop barrier 回收。
+这不是 DNS 响应竞速；已选 H3 的查询失败不自动重放到 TCP。复用已选连接，H1/H2 的版本选择最多保留 4 项、空闲 30 秒，失败后重新选择；不为每次查询重新探测。
+`https://…#h3=true` 仅建立 H3，失败不能降级；明文 HTTP 的 h3/prefer-h3 不改变 H1 行为。
+bootstrap、主、节点和直连 DNS 角色均应用全局 prefer-h3；WireGuard/MASQUE 私有 DNS 与固定参考一致，
+不继承全局偏好，但支持 URL `h3=true`。H3 共用 GET/Basic/ID 与包装，不启用 0-RTT 或恢复，
+使用官方 Quinn、h3 与 h3-quinn，通过共享 TLS 1.3 / rustls 证书政策建立严格 `h3` ALPN；DoQ 同样使用 Quinn。
+普通 H3 请求 FIN 不等待逐请求 QUIC ACK。取消丢弃当前请求所有者，未完成发送 reset，接收半关闭使用原生 STOP(0)，
+不关闭仍可用的兄弟请求；响应错误仍使该连接不再接受新查询。GOAWAY 停止新请求准入，已存在的查询可完成。
+
+### DoQ
+
+`quic://host[:port]` 默认 853，使用受控 UDP、TLS 1.3 与实际 `doq` ALPN。
+每条查询使用独立双向 stream：两字节网络序长度、完整 DNS wire，ID 设为 0，并结束写方向。
+响应必须是一份 12..=4,096 字节的完整 DNS message，ID 为 0，读至 FIN 后恢复原 ID 并校验；
+空长度、超限、截断或额外消息均拒绝。并发查询共享连接，取消只停止当前 stream。
+DoQ/H3 都沿用原 DNS 路由、bootstrap、证书政策与查询包装，不新增 socket 工厂或系统解析回退。
+独立 `dns-quic` feature 提供两种能力，默认构建和 Invoke 生产入口启用；显式关闭该 feature 的
+精简 Core 构建拒绝 `quic://`、`prefer-h3: true` 和 HTTPS `h3=true`，不会接受后忽略。
 
 ### Policy
 
 `nameserver-policy` 是有序映射：
 
 - 项数与 GeoSite 唯一引用数不设独立上限，仍受整个 YAML 输入大小约束；
-- selector 只接受 `geosite:<selector>[,<selector>...]`，同一项内为 OR；每个 selector 可为
-  `code`、`code@attr@attr` 或前置 `!` 的反选，属性为 key 存在性 AND；
-- 归一后的相同 selector 不能跨项重复；相同基础 code 的不同属性交集或正反选可并存，
-  与业务规则共享分类和记录；`@!cn` 是字面属性 key，不是属性排除；
-- value 必须是 1–4 个 nameserver；
-- 首项命中后只在该组内顺序故障转移，组内耗尽不查询主组；
+- 接受普通域名和 Clash 通配域名，也可以用逗号连接多个模式；域名不区分大小写。
+  `*.example.com` 匹配一层子域，`.example.com` 匹配所有子域，`+.example.com` 包含本域和所有子域；
+- 连续域名项合为一个区块，按字面标签、`*`、前导 `.` 的优先级匹配；同一区块内重复的归一模式以后项为准；
+- `geosite:<selector>[,<selector>...]` 同一项内为 OR，前缀不区分大小写；每个 selector 可为
+  `code`、`code@attr@attr` 或前置 `!` 的反选，属性为 key 存在性 AND。与业务规则共享分类和记录，
+  `@!cn` 是字面属性 key，不是属性排除；
+- GeoSite 项隔开域名区块，区块与 GeoSite 项按声明顺序匹配；重复 GeoSite selector 也按此顺序处理；
+- value 接受单个 nameserver 字符串或非空数组；`rule-set:` 引用 domain/classical 集合。
+  classical 以域名和其余零值元数据执行完整逻辑；不继承触发查询的业务端口、来源或入口身份；
+- 命中后只在所选列表内并发查询，列表耗尽不查询其他 policy 或主组；
 - GeoSite 资产或分类不可用时该 policy 不命中，不能因反选变成全匹配；
 - 存在分类但属性筛选为空时仍可用，正选不命中、反选匹配合法非空名称。
 
+hosts 和 fake-IP 分配先于 policy；命中 fake-IP 过滤器、需要真实响应时才应用 policy 中的 RCODE。
+policy 的本地响应不进入 fallback；主 nameserver 的本地响应没有地址，已配置 fallback 时沿用
+本节的 fallback 选择规则。未配置 fallback 时直接返回本地响应。
+
 Policy 只决定当前 DNS exchange，不改写后续业务动作。分类、属性归一和语义边界见
 [GeoData 规则](geodata.md#规则)；所有平台均不按 GeoData 条数截断记录。
 每次同步 policy 选择捕获一份不可变 GeoData 快照，所有 selector 与 policy 项共用，
-不在一次求值中混用旧代、空快照和新代。捕获空快照时沿用资产缺失的主组回落语义。
+不在一次求值中混用旧代、空快照和新代。捕获空快照时跳过 GeoSite 项，继续其余 policy；
+均未命中时使用主组。普通域名 policy 不依赖 GeoData。
 快照在选择函数返回时释放，不复制规则，也不跨后续上游 I/O 的 `await` 持有。
 Regex selector 记录与业务规则共用 `regex::bytes::Regex`；其搜索缓存由正则库管理，
 可能分配 scratch 或发生缓存竞争，不承诺 DNS policy 正则搜索零分配。
 
+业务规则中的 DOMAIN-REGEX 与 classical rule-set 使用有界的独立复杂正则入口；GeoSite
+保留大小写敏感的线性入口。DNS 请求的 fake-IP filter、nameserver-policy、fallback domain
+及 respect-rules 出口共用执行预算，并跨 A/AAAA、别名、引导和并发上游候选保留。规则
+执行错误不选择默认上游、fallback、系统 DNS 或 synthetic IP，不写入缓存/域名提示；
+wire 查询返回 SERVFAIL，内部解析返回脱敏规则错误。嗅探计划的地址/force/skip 选择同样
+共享预算，错误关闭当前会话/数据报，不忽略该失败继续连接。
+
+### 显式系统与 DHCP 来源
+
+App 通过运行时级 [`updateDnsNetwork`](invoke-api.md#updatednsnetwork) 提供完整网络快照，地址必须是字面 IP，接口必须精确。快照优先于 OS 发现，空数组明确撤销来源。替换时原子推进 DNS epoch 并清理全部角色的类型化/wire 缓存及 redir-host 提示；保留 fake-IP 映射和活跃流。旧查询可返回原调用者，但不能回填新网络缓存，新查询不加入旧 singleflight。DNS TCP 连接池按来源代次、接口和地址区分复用。
+
+Linux CLI 无宿主快照时仅调用已有 `/usr/bin/busctl`，读取 systemd-resolved 的物理 link DNS 或 NetworkManager 已激活接口的 DHCP4 `domain_name_servers`；原生 DHCP 还需现有 resolved link 的加密策略，无法确认策略时不可用。不启动服务、不读 VPN stub、不发送 DHCP DISCOVER，也不读取其他接口的租约。发现仅在后续 DNS miss 按需刷新，元数据缓存 20 秒；到期本身不主动清结果缓存。重新发现的 endpoint、加密要求或绑定变化时，原子推进共享 epoch/source generation 并清 cache/hints，连接池不能复用旧来源 key。整体发现期限 3 秒，stdout/stderr 各限 64 KiB；取消会关闭并等待子进程。缺服务、无可靠租约或加密要求无法满足时来源不可用。被接管的 TUN 接口、回环/stub 地址和自身网关被排除。与 Mihomo 主动 DISCOVER/DHCPOFFER 的 DHCP 来源机制不同。
+
+Apple 使用宿主快照和 `IP_BOUND_IF`/`IPV6_BOUND_IF`；App 负责取得真实物理 DNS 数据。Android 和 Wintun 当前没有可证明的精确物理接口绑定，显式 system/DHCP 来源不可用，不改变现有 protect 与宿主网络隔离合约。UWP 仅在实际 Session Host 的既有物理 GUID 绑定内发现系统 DNS；前台 Invoke registry 不是 IPC，不能通过它更新另一个进程的 VPN 会话。DHCP 租约 metadata 不可靠时保持不可用。来源要求加密但当前 UDP/TCP 路径无法满足时失败关闭，不降级为明文，也不补充公共 DNS。
+
+
+## Fallback
+
+`fallback` 只作用于主 resolver 的 A/AAAA。先应用 nameserver-policy；命中的 policy
+独立查询自己的上游，不再进入 fallback。否则，`fallback-filter.domain` 的 Clash 通配
+命中时直接查询 fallback，不启动主组。GeoSite 分流使用 `nameserver-policy` 配置。
+
+其余查询先取主组结果。主组失败、没有地址，或任一地址命中 `ipcidr` / GeoIP 条件时
+使用 fallback 的结果。`geoip` 默认 true、`geoip-code` 默认 CN：非本地且不属于该分类的
+地址触发 fallback；私有、回环、链路本地、多播和未指定地址不触发 GeoIP 条件，
+但仍可被显式 `ipcidr` 匹配。GeoData 与业务规则共用快照；缺失分类不当作反选全匹配。
+
+`fallback-lazy-query` 默认 false，两组并发查询，主组结果可接受时立即返回并取消剩余尝试；
+true 只在确定需要时发起 fallback。fallback 返回后不再次套用过滤条件。
+选定的最终结果进入主 resolver 缓存，fake-IP 回答和 hosts 不触发上游查询。
+bootstrap、单独配置的节点/直连 resolver，以及非地址 qtype 不使用这组 fallback。
+
 ## Wire 校验
 
 - DNS message 最大 4,096 字节。
@@ -114,48 +293,108 @@ Regex selector 记录与业务规则共用 `regex::bytes::Regex`；其搜索缓
 
 ## 缓存与 singleflight
 
-### 类型化缓存
+### 结果缓存
 
-A/AAAA 缓存最多 256 项，从空容量按需增长。TUN 域名提示存储启用时同样最多 256 项，并按 TTL 失效。
+`dns.cache-max-size` 控制每个 DNS 角色的结果总条目数，缺省或零值为 4,096。
+A/AAAA 的类型化结果和其他 qtype 的原始响应共享这份容量与替换策略。
+客户端携带 EDNS 或额外语义 flags 的 A/AAAA 使用同一有界原始响应缓存，以完整查询摘要区分
+ECS、DO、CD 等上下文并保留响应 additional/flags；普通 A/AAAA 仍使用小型地址缓存。
+`dns.cache-algorithm` 精确为 `arc` 时使用 ARC，缺省和其他字符串使用 LRU。
+LRU 命中和替换将条目移到最近使用端；满容量时淘汰最久未使用的结果，命中不延长 TTL。
+哈希索引和安全槽位链表按需分配，查询时只检查命中条目的寿命。运行时过期正结果按下节返回旧答复并刷新；其他过期结果重新查询。
+类型化结果仍最多保留 16 个地址，负缓存仍保留 30 秒。
+TUN 域名提示独立保留最多 256 项并按 TTL 失效；fake-IP 映射不计入这份结果缓存。
+
+ARC 分别保留近期与常用结果，命中提升到常用组，使用两组淘汰历史自适应调整比例。
+历史项只保留 key 和过期时间，不持有地址或原始响应；有效结果最多为配置容量，
+历史项最多为同样容量，所有索引和槽位最多为两倍容量。
+旧正结果仍占 resident 容量，旧答复只更新原列表内的最近使用顺序，不提升到常用组；超过旧答复保留期或历史项到期时直接删除，不新增淘汰历史。清空和解析器释放会回收结果、历史项及其存储。
 
 ### 原始响应缓存
 
-- 最多 64 项，总保留内存 256 KiB，单响应最大 4,096 字节。
+- 在结果总容量内额外限制为最多 64 项、总保留内存 256 KiB，单响应最大 4,096 字节。
+  原始响应的 key、TTL 偏移及条目索引/链表元数据计入字节预算，ARC 的原始响应历史项也计入。
+  此预算满时先删除原始响应历史项，再淘汰最久未使用的原始响应，不改变 ARC 的自适应比例。
 - Key 包含规范化 question、qclass、qtype 和移除 transaction ID 后的完整查询语义 SHA-256。
 - 命中时恢复调用方 transaction ID 和 RD，并按剩余寿命更新所有可缓存 TTL。
 - 正缓存寿命取可缓存记录的最小 TTL，并限制在 30–3,600 秒。
 - NXDOMAIN 固定负缓存 30 秒；NOERROR 空 answer 只有在 authority 含 IN/SOA 时才缓存为 NODATA。
 - Referral、TTL 0、无可缓存记录和扩展错误码不缓存。
-- 原始响应缓存不生成 TUN 域名提示。
+- 非地址 qtype 的原始响应不生成 TUN 域名提示；A/AAAA 仍按既有地址校验生成提示。
+
+### 过期答复与刷新
+
+运行时的完整正结果到期后，以 TTL=1 立即回答，并在后台刷新。旧结果最多保留到原到期时间后一小时，命中不延长寿命；它与新结果共用原有容量及原始响应字节预算，不另设旧记录池。原 TTL 为零、负答复、错误和不完整结果不延续为旧答复；hosts 与 fake-IP 仍在结果缓存之前处理。
+
+原始响应带 DO、AD、CD 或 DNSSEC 记录时仅按原有效期缓存，不返回过期安全声明。普通类型化 A/AAAA 缓存只保存地址并重新合成无 AD/CD 的响应；非地址 qtype 不产生域名提示。过期 A/AAAA 沿当前 epoch 和资源退役门禁补充有界域名提示，提示仍使用原容量和 TTL 规则。
+
+每个会话的 DNS 树及节点私有解析器共享最多四个后台刷新许可，无待执行队列；每个 key 复用原 singleflight，失败完成后五秒内不重试。单次刷新沿原五秒总查询期限。许可不足或已有刷新时仍立即返回旧答复。各资源树与私有解析器分别拥有取消和任务等待屏障，停止一个节点不停止主解析器；资源退役禁止新增刷新并取消旧刷新。Stop 等待全部刷新结束，不留下无所有者任务。没有运行时所有者的独立解析器保持原有过期 miss 行为。
 
 ### Singleflight
 
-未命中缓存时，以规范化 question 和 wire 语义摘要作为 key：
+未命中缓存时，以规范化 question、wire 语义摘要和缓存 epoch 作为 key：
 
-- Leader 在发起方任务内运行；
+- 前台 miss 的 Leader 在发起方任务内运行；过期命中不等待，刷新 Leader 由上述运行时所有者持有；
 - Leader 被取消或释放时，RAII 通知 follower 重新选举；
 - 每个调用方恢复自己的 transaction ID 和 endpoint，并独立应用失败策略；
 - 不同 key 可以并行。
 
+### 清理
+
+Controller `POST /cache/dns/flush` 清理主 resolver、bootstrap、节点和直连角色的类型化与
+原始响应缓存、ARC 历史项和 redir-host hints。所有角色共享一次 epoch 边界；清理完成后
+的新查询不能加入旧 singleflight，旧在途查询仍可向原调用方返回结果，但不能回填缓存或 hints。
+资源替换保留这份 epoch，旧资源 generation 也不能回填共享 hints。
+fake-IP 映射、活动业务会话、在途查询和上游连接池继续保留。
+
+## Hosts 与解析职责
+
+`hosts` 支持 IP、IP 数组和域名别名，匹配规则沿用 Clash 域名通配；默认包含 localhost，别名循环在配置阶段拒绝。`use-hosts`、`use-system-hosts` 独立控制配置与系统 hosts，默认均为 true；系统 hosts 在运行时创建时读取。TCP、UDP 节点的 TLS SNI 和逻辑目的名称不因解析为 IP 而改变。
+
+值恰好为 `lan` 或 `[lan]` 时，启动准备捕获全部接口 IP，排除回环和 link-local，
+包含可用的公网与 TUN 接口地址，不仅限私有网段。校验只保留内部标记，不读取网卡。
+无可用地址或枚举失败使启动失败；运行期间及 Provider 更新均保留启动快照。
+
+`default-nameserver` 仅引导上游域名。`proxy-server-nameserver` 与其 policy 用于节点解析；`direct-nameserver` 用于直连，`direct-nameserver-follow-policy` 决定是否使用业务 policy。各角色拥有独立 cache/singleflight，未配置节点或直连 resolver 时复用主 resolver。有限并发、取消与连接池适用于各角色，依赖循环不会等待自身的 singleflight。
+
+启用有效 IPv6 时，内部地址解析并发请求 A/AAAA，结果按 IPv4、IPv6 排列。
+`dns.ipv6-timeout` 单位为毫秒，缺省或 0 使用 100；从 A 完成后开始等待 AAAA，
+不改变整个解析的五秒期限。任一地址族失败不丢弃另一族的有效地址；等待到期或调用方
+取消时释放未完成查询。IPv6 关闭时只查询 A。TUN 客户端直接 A/AAAA 查询仍保留原有
+wire/RCODE 语义，不使用这段地址合并等待。
+
 ## 查询、故障转移与连接复用
 
 - 查询总期限 5 秒；单 nameserver 尝试最多 3 秒，并受剩余时间限制。
 - UDP 尝试只打开一个传输；首次发送后 1 秒无合法响应时，在同一传输和 ID 上最多重发一次。
 - 前两次 peer/ID/question 不匹配只丢当前响应，第三次使当前尝试失败。
-- 超时、I/O、格式错误、SERVFAIL、REFUSED、TC 或规则 REJECT 会继续当前组下一项。
-- NXDOMAIN 和 NODATA 是终态。
-- UDP TC 不自动切换 TCP；只有显式 `tcp://` endpoint 使用 TCP。
+- 同一上游策略最多同时发起 4 个实际 endpoint 尝试，字面上游和显式来源展开的 endpoint 共用许可；bootstrap/fallback 是独立子查询，不是全链或全局 socket 额度。优先返回有效响应并取消其余尝试。超时、I/O、格式错误、SERVFAIL、REFUSED 或 REJECT 不作为成功结果。
+- 未启用 fallback 或命中 nameserver-policy 时，NXDOMAIN 和 NODATA 是终态。
+- 验证来源、ID 和 question 后，UDP TC 在原期限内改用同一 endpoint 的 TCP。TCP TC 仍是失败响应。
 - 全部上游失败时生成 SERVFAIL；非法 UDP 查询只丢当前数据报。
 
-显式 TCP nameserver 使用每运行时独立连接池：
+TCP、DoT 和 DoH 使用解析器所属的连接池：
 
-- Key 为 endpoint 和配置的 route target；
-- 一条连接同时只处理一个查询，不做 pipeline；
-- 活动连接不设固定业务数量上限；空闲连接总数最多 4、同 key 最多 2、超时 30 秒；
-- 完成帧和响应校验后才能归还连接；
-- 复用连接遇到 EOF、I/O、reset 或响应不匹配时，在原尝试期限内最多新建一次连接；
+- Key 包含上游地址、TLS 验证策略、查询包装、传输、HTTP 路径与 Basic 身份、endpoint、最终 route target、
+  来源 generation 和物理接口绑定；
+- TCP、DoT、HTTP/1.1 一条连接只处理一个查询，不做 pipeline；这部分空闲连接总数最多 4、同 key 最多 2、超时 30 秒；
+- HTTP/2 同 key 首次建连串行发布，之后共享 sender；每连接最多 32 个并发 stream，超出时在查询原期限内等待。流接收窗口 4 KiB、连接接收窗口 128 KiB，禁用 server push；H2 空闲连接另限 4、超时 30 秒；
+- DoQ/H3 同 key 串行初始化后复用，每连接最多 32 条查询；QUIC stream 固定接收窗口 4,098 字节、connection 接收窗口 128 KiB，发送额度 128 KiB，不接收服务器双向 stream 或 QUIC DATAGRAM。DoQ 不接收单向 stream；H3 最多接收 8 条单向 stream，控制流与业务流均从 4,098 字节信用开始，消费后由 Quinn 通告后续信用。该信用不是完整 HEADERS parser 内存上限。空闲 QUIC 连接另限 4、超时 30 秒；
+- 活动物理连接不设固定业务数量上限；完整响应校验后才能归还 H1 连接或继续复用 H2；
+- TCP/DoT/H1 复用连接遇到 EOF、I/O、reset 或响应不匹配时，在原尝试期限内最多新建一次连接；
 - 非法、截断或超限响应不重试、不归还连接。
 
+HTTP/2 单流取消发送 RST，其他流可继续使用原连接；响应错误使该连接不再接受新查询。
+解析器拥有连接 driver 与有界空闲回收任务，Session Stop 和资源代际退役关闭全部解析角色并等待 driver 结束；WireGuard/MASQUE 私有 DNS 同样由节点 Stop 关闭且不保留空闲连接。MASQUE IP 查询经过节点内部栈，L4 仅可使用 TCP DNS 传输；system/DHCP 始终沿物理来源策略，不因节点模式改变出口。
+DoQ/H3 的连接取消和退役最多等待一秒 QUIC close exchange，随后停止并等待
+Quinn 原生任务与受控 datagram driver；未发布初始化、握手取消和移交前的准备失败同样属于此 Stop 所有权。
+初始发送 MTU 为 1200 字节，H3 的 PMTUD 上限受当前发送路径预算约束；接收广告独立使用实际接收预算，
+不把 fixture 中的 4096 字节接收值作为所有路径的统一上限。任一方向不足 1200 的 QUIC 路径拒绝。
+H3 在非 DATA 帧声明长度完整时提前检查：HEADERS 编码长度最多 24 KiB，SETTINGS 最多 256 字节，
+CANCEL_PUSH / GOAWAY / MAX_PUSH 长度为 1..8 字节，PUSH_PROMISE 最多 24 KiB 加 8 字节且非空。
+未知 H3 帧也限 24 KiB，超限立即拒绝，不先累计完整 payload；这比 quiche 对未知帧最多 16 MiB 的跳过范围更严格。
+DATA 仍按应用读取流式处理，DNS body 保持 4096 字节限制；QPACK 与未知单向 stream 的分类沿官方 h3 实现。
+
 Controller 切换代理组后，只在后续需要创建新 DNS transport 时使用新选择。类型化/原始响应 cache、singleflight 状态和已经位于 TCP pool 中的 transport 不清空、不迁移；因此命中 cache 或复用既有 TCP transport 时，不会为切换单独建链。停止 session 才统一释放这些状态。
 
 ## 队列与生命周期
@@ -164,11 +403,11 @@ Controller 切换代理组后，只在后续需要创建新 DNS transport 时使
 | --- | ---: |
 | 每普通 UDP 关联入站 | 64 |
 | DNS 响应 | 128 |
-| 普通 UDP 响应 | 4,096 |
+| 普通 UDP 响应 | 256 |
 
-reader 在进入 TCP netstack 前分流 UDP，拥有按源地址建立的关联表，没有共享 UDP 入站接收器或独立 DNS 请求准入数。每普通 UDP 关联有独立请求队列；DNS 查询继续提交受跟踪的任务，不等待上游。队列满时只丢当前请求或响应，不阻塞 reader；TCP accept 仍为 128 项。TUN UDP 响应按有效 MTU 减去 48 字节保守限制；默认 9000 MTU 时为 8,952 字节；显式 1500 为 1,452 字节，Windows UWP 使用 1400 时为 1,352 字节。
+reader 在进入 TCP netstack 前分流 UDP，拥有按源地址建立的关联表，没有共享 UDP 入站接收器或独立 DNS 请求准入数。每普通 UDP 关联有独立请求队列；DNS 查询继续提交受跟踪的任务，不等待上游。入站或 DNS 响应队列满时只丢当前数据报，不阻塞 reader。普通响应队列满时，每源关联最多暂持一个已接收响应并暂停继续接收，等待容量期间仍可发送请求或取消，不增加任务；取消或错误时丢弃未提交响应。TCP accept 仍为 128 项。TUN UDP 响应按有效 MTU 减去 48 字节保守限制；默认 9000 MTU 时为 8,952 字节；显式 1500 为 1,452 字节，Windows UWP 使用 1400 时为 1,352 字节。
 
-唯一受跟踪的 TUN writer 公平读取普通 UDP、DNS 和 TCP/ICMP raw 三个通道，任一通道关闭不丢弃其他通道的待写响应。UDP 构包后直接写平台，不再转发到共享 raw output。DNS 查询观测 permit 保留至该包被平台接受、最终丢弃或取消，写回阻塞和 ENOBUFS 重试不提前释放；WinRT Adapter 成功处理不等于框架最终交付。MTU/地址族错误只丢当前响应。
+唯一受跟踪的 TUN writer 公平读取普通 UDP、DNS 和 TCP/ICMP raw 通道，Linux 的真实 Echo 使用第四个有界通道；任一通道关闭不丢弃其他通道的待写响应。UDP 构包后直接写平台，不再转发到共享 raw output。DNS 查询观测 permit 保留至该包被平台接受、最终丢弃或取消，写回阻塞和 ENOBUFS 重试不提前释放；WinRT Adapter 成功处理不等于框架最终交付。MTU/地址族错误只丢当前响应。
 
 运行时停止会取消 open、send、receive、retry 和 response-send，释放全部传输并等待已跟踪任务结束。停止返回后不得再向 TUN 回包。
 
@@ -183,18 +422,35 @@ DNS 提示或 GeoData 更新改路；新流使用当前数据。每目标按同
 
 ## IP-only协议与独立测速接点
 
-公共`ResolutionContext`仅在协议必须取得IP地址的边界解析业务目标或逻辑上游；原始`Destination`保持不变，HTTP Host、TLS SNI和路由仍使用逻辑名称。代理endpoint的prepare bootstrap与该运行期解析分离，不递归使用尚未建立的同一出口。当前静态ECH不查询DNS；动态ECH及其可选宿主bootstrap入口尚未实现，不属于当前Invoke接口。
+`experimental.dialer-ip4p-convert` 只在已声明的物理 connected TCP 和指定 UDP 节点端点生效。
+物理端点解析后先解码、再按实际 IPv4/IPv6 应用地址族及 source/interface 绑定；
+解析角色、逻辑 host/port、认证和代理链不改变。DNS 的查询族与缓存仍遵循原配置，
+不自动开启 AAAA、不改写对外 DNS 记录或通用 IP-only 业务解析结果。
+
+公共`ResolutionContext`仅在协议必须取得IP地址的边界解析业务目标或逻辑上游；原始`Destination`保持不变，HTTP Host、TLS SNI和路由仍使用逻辑名称。代理服务器在实际建链时通过节点 resolver 解析，准备阶段不解析备用节点。静态 ECH 不查询 DNS；动态 ECH 通过同一解析上下文消费节点角色的原始 HTTPS 记录。查询名可独立覆盖，不改业务/服务器逻辑名称；沿原建链期限、取消和 weak runtime 所有权，不增加 Invoke DNS 入参。DNS 关闭和独立测速使用物理 system source，不可用时失败。
 
-Running Session上下文仅弱引用本session的RuntimeDns，使用上文nameserver/policy与出口；未绑定、DNS关闭、上游不可达或session已停止时明确失败，不调用系统resolver兜底。IP字面量仍执行端口/地址族政策。解析共享同一次建链期限，Stop取消当前及后续查询；在进入可能等待自身的singleflight之前拒绝同名递归依赖，嵌套依赖深度最多32层。不会因为DNS经代理出口就无条件禁止整个图。
+Running Session上下文仅弱引用本 session 的 RuntimeDns；业务 IP-only 解析使用 nameserver/policy，代理服务器使用 proxy-server-nameserver/policy，DIRECT 目标使用 direct-nameserver。未绑定、上游不可达或 session 已停止时失败；只有配置关闭 DNS 时才使用系统解析。IP字面量仍执行端口/地址族政策。解析共享同一次建链期限，Stop取消当前及后续查询；在进入可能等待自身的singleflight之前拒绝同名递归依赖，嵌套依赖深度最多32层。不会因为DNS经代理出口就无条件禁止整个图。
 
 独立`measureDelay`使用测量生命周期的受控bootstrap resolver，仅在IP-only边界解析域名；不创建Running Session、RuntimeDns或DNS监听服务，也不改变现有endpoint准备流程。通用 IP-only connector 覆盖最终节点和 `dialer-proxy` 上游的受控解析、期限与取消。该公共接点继续供 packetaddr 等必须 IP 的消费者使用；通用机制测试不替代各协议的实际数据闭环。
 
 ## 不支持
 
-- 真实 ICMP 转发、ICMP error、Traceroute、ICMP 选路规则或 ICMP 测速；
-- DoH、DoT、DoQ、hostname/system/DHCP nameserver；
-- 代理组 provider/health check/自动 failover、并行 nameserver 竞速、DNS fallback group、fake IP 和 hosts；
-- 用户可配置的缓存容量、超时、重试或并发度；
+- Linux Echo 以外的真实 ICMP 转发、PMTU 以外的 ICMP error、Traceroute、ICMP 选路规则或 ICMP 测速；
+- 运行中随接口变化自动刷新 hosts: lan；
+- 用户可配置的查询总超时、重试或并发度；
 - 使用 DNS question 执行业务规则，或用 DNS 出口改写后续业务动作。
 
 自动化和物理 TUN 覆盖范围见 [验收矩阵](acceptance.md)。
+
+## 入站规则元数据
+
+TUN TCP 的 `IN-TYPE` 为 TUN，`IN-PORT` 为虚拟连接的原始目标端口；TUN UDP
+没有本地监听端口，`IN-PORT` 为 0。两者没有认证用户，来源规则读取原始来源 IP/端口。
+这与 Mihomo 默认 MIPS 栈一致；其他栈的内部 TCP listener 端口可能不同。
+
+业务规则中的 `IN-NAME` 为区分大小写的固定入口名：TUN 为 DEFAULT-TUN；
+mixed 的 HTTP/SOCKS5 为 DEFAULT-MIXED。内部请求的名称为空，不新增可命名 listeners。
+Core 的 DNS、GeoData 下载及测速入口均映射为 INNER，端口为 0、用户为空。
+DNS `respect-rules` 使用同一个规则求值器，但不继承触发解析的业务用户。
+classical selector 的空元数据是单独参考视图（TCP/HTTP、端口0、无入口名和身份），
+并不把内部 DNS 路由伪装成业务 HTTP 连接。
diff --git a/docs/tun-platform.md b/docs/tun-platform.md
index 48e8206..451e46d 100644
--- a/docs/tun-platform.md
+++ b/docs/tun-platform.md
@@ -11,19 +11,20 @@ TunRuntime -> TunRsIo -> 宿主持有的 TUN fd 副本
 - iOS/tvOS/macOS：宿主提供 utun 文件描述符，适配器处理四字节 packet-information 头。
 - Android：`VpnService` 提供 raw-IP 文件描述符。
 - Linux：真实单队列 TUN，使用 `IFF_TUN | IFF_NO_PI`、无 VNET header；接口实际 MTU
-  必须与 `tun.mtu` 一致。宿主负责地址、网络命名空间和路由，Vole 不自动接管系统网络。
+  必须与 `tun.mtu` 一致。借用 fd 的地址、网络命名空间和路由由宿主负责。
 
 `tun.file-descriptor` 缺省或 0 时，Linux / macOS 由 core 打开本机 TUN，Android / iOS /
 tvOS 仍需宿主提供 fd。`tun.device` 控制原生打开的接口名：空值在 Linux 使用 `Vole`，
-macOS 自动选择 utun。core 只设置自有接口的 MTU 和自有 fd 的 nonblocking，不配置地址、
-DNS 或路由；Stop 关闭自有句柄，不承诺删除宿主已有接口。创建失败没有备用数据面。
+macOS 自动选择 utun。macOS 只设置自有接口的 MTU 和 nonblocking，网络配置仍由宿主负责。
+Linux 自建接口的自动网络配置见下节；关闭自动路由时只设置 MTU/nonblocking。
+Stop 关闭自有句柄，不承诺删除宿主已有接口。创建失败没有备用数据面。
 正数 file-descriptor 选择下述借用路径；fd 数字必须对当前进程有效，CLI 不增加专用 fd 参数。
 
 宿主始终拥有原始文件描述符。Vole 启动时：
 
 1. 验证文件描述符有效且已设置 `O_NONBLOCK`；
 2. 通过 `F_DUPFD_CLOEXEC` 创建 Vole 持有的副本；
-3. 把副本交给 `tun-rs::SyncDevice::from_fd`，并用 Tokio `AsyncFd` 驱动；
+3. 把副本交给 `tun-rs::SyncDevice::from_fd`，再用 Tokio `AsyncFd::register` 驱动；
 4. 停止时只关闭副本。
 
 借用路径不调用会修改共享 open-file-description 标志的异步构造器，也不重配置接口。
@@ -47,16 +48,16 @@ Linux 压测可以把 TUN 创建在客户端 namespace，再把借用 fd 交给
 首轮验证为 GNU/glibc 原生构建与容器真实 TUN；musl、其他架构、安装交付和设备验收
 不由一次 Linux 容器压测推导。Linux RSS/VmHWM 与 Apple physical footprint 分开报告。
 
-tvOS 首版为 17.0+、ARM64 真机和 Apple Silicon 模拟器，共用原有 TunIo、netstack 和
-Dialer；不新增低内存数量上限，不改变其他平台默认行为。iOS/tvOS 的 TUN 生命周期接入
-Apple Unified Logging、TASK_VM_INFO 当前/进程峰值观察及停止后的 allocator pressure relief。
-既有 35/40/45 MiB 阈值仅发出诊断，不是系统限额或业务准入条件；macOS 不启用这组
-移动扩展周期采样。tvOS 事件使用 tvos_memory_*，iOS 保留 ios_memory_*。
+tvOS 首版为 17.0+、ARM64 真机和 Apple Silicon 模拟器，共用 TunIo、netstack 和
+Dialer。所有平台使用统一的 TUN 内存诊断、allocator 配置和 Stop 后回收策略，
+缓冲、队列和线程策略也不按平台或内存模式切换。内存按默认压力负载统一验收：1 Gbps 不超过 43 MiB，
+2 Gbps 不超过 45 MiB；真实 iOS/tvOS 扩展按整个进程的 physical footprint
+验收，完整口径见[验收边界](acceptance.md)。
 
 Apple 公开 NEPacketTunnelFlow API 是 packetFlow 的包读写，不承诺可取得 raw fd。
-Vole 的借用 fd 契约不能证明宿主 KVC 提取 fd 是稳定公开方案。模拟器 socketpair 只验证
-合成 utun 数据面；真实宿主的 fd 获取/桥接、签名与 entitlement、系统路由、设备生命周期
-及物理内存须独立验收。当前没有新增 packetFlow 回调 ABI，也不暗中回退其他接入路径。
+Vole 的借用 fd 契约不能证明宿主 KVC 提取 fd 是稳定公开方案。真实宿主的 fd 获取/桥接、
+签名与 entitlement、系统路由、设备生命周期及物理内存须独立验收。
+当前没有新增 packetFlow 回调 ABI，也不暗中回退其他接入路径。
 
 包 I/O 规则：
 
@@ -84,7 +85,7 @@ Unix 读缓冲区和公共批次容器复用；非法包只丢该槽位，不丢
 共享 UDP 入站中转队列。TCP/ICMP 使用独立有界 ingress；满时丢当前完整 IP 包并
 计数，TCP 可重传，不等待容量而阻塞其他来源的 UDP/DNS。
 
-唯一 writer 公平轮转 TCP/ICMP raw、普通 UDP 响应和 DNS 响应三个独立通道。
+唯一 writer 公平轮转 TCP/ICMP raw、普通 UDP 响应和 DNS 响应；Linux 真实 Echo 另有独立有界通道。
 UDP 直接在复用的 MTU frame 中构包，不再经过 response writer 和 raw output
 的二次交接；每批最多处理 8 个已就绪项目，非法响应也消耗工作预算。DNS permit
 保留到对应包被平台接受、最终丢弃或取消，ENOBUFS 待重试时不释放；Windows
@@ -105,16 +106,108 @@ token 归还容量。满输出保留尚未处理的 TCP 包和协议状态，低
 丢当前请求。writer 消费包会显式唤醒 Driver；满输出不以零延迟 timer 忙重试，
 输出端关闭则停止 Driver、释放 socket 并唤醒全部等待者。
 
-netstack 的 TCP 接收与发送缓冲可独立配置，各方向的容量包含 smoltcp 与应用
-缓冲，两层各占一半。生产 TUN 仍从现有资源策略取得每方向 32 KiB，合计每流
-64 KiB 数据缓冲；不扩大默认容量、不新增用户 YAML 参数，也不改变其他协议
-的缓冲策略。该容量不包含代理 relay、包队列或 allocator 的内存。
+netstack 的 TCP 接收与发送缓冲可独立配置，各方向的容量包含 smoltcp 缓冲与应用
+队列，两层上限各占一半。生产 TUN 仍使用每方向 32 KiB、合计每流 64 KiB 的数据
+容量上限。应用队列从空分配开始，按实际写入有界增长，分配请求不超过该队列的
+逻辑上限；排空后保留已分配空间直到连接释放。smoltcp 缓冲容量、背压、唤醒、
+flush 与关闭语义保持不变。该容量不包含代理 relay、包队列或 allocator 的内存，
+也不保证进程 RSS 与数据容量相同。
 
 Linux 目前不启用 GRO/GSO：`tun-rs` 的 Linux offload 示例通过 builder 创建并
 配置带 VNET header 的设备，而 Vole 的原生和借用路径均不启用该模式。对现有 raw-IP
 设备调用 `recv_multiple` 不会自动合并读取或启用 offload。Vole 保留宿主
 MTU/格式与 fd 标志，原生 builder 只打开 raw-IP TUN，不暗中启用 offload 或改变借用接口。
 
+## Linux 自建 TUN 的系统网络
+
+`tun.file-descriptor: 0` 的 Linux 路径支持 `auto-route` 和 `auto-detect-interface`，
+两者缺省 true。其他平台缺省 false；借用 fd 路径不修改宿主网络，无论这两个字段的值。
+
+- `auto-detect-interface` 从主路由表检测每个地址族的默认物理出口，最多缓存一秒。
+  新建 TCP/UDP socket 绑定该接口，所有协议、DNS、资源下载共用 Dialer；没有出口时失败。
+  已有 socket 不迁移，下一次建链重新检测。回环目标保持本机访问。
+  全局/节点 `interface-name` 的显式非空值优先于自动识别，DNS `#接口` 优先于全局接口；
+  system/DHCP 来源保留自己的物理接口约束。显式接口不存在或绑定失败不会回退自动识别。
+- `auto-route` 独占创建配置命名的 raw-IP TUN，已有同名接口失败。IPv4 使用
+  `dns.fake-ip-range` 的原始 IPv4 地址（默认 `198.18.0.1`），前缀固定 /30；IPv6 地址从 `inet6-address` 读取。
+  路由表 `iproute2-table-index`（缺省/0 为 2022）、规则优先级
+  `iproute2-rule-index` 到 `+8`（缺省/0 从 9000 开始）必须空闲；保留主表的非默认路由，
+  缺省仅本机未标记流量经 TUN，显式输入接口作用域见下节。物理 socket 保留全局/节点
+  继承后的非零 `routing-mark`；只有零 mark 才注入内部防环值，两者均绕过本会话捕获。
+  不依靠 source IP 避免递归，也不新增覆盖用户策略路由的旁路规则。配置接口与路由直接
+  通过内核接口完成，不调用 ip 子进程。动态 Provider 候选沿用相同 socket 策略。
+  回环物理目标继续忽略公开 mark/接口并使用私有隔离；system/DHCP 保留其精确物理绑定。
+  借用 fd 和关闭 auto-route 的路径不注入私有 mark，保留原配置 mark。
+- 自动路由启用，且 `dns.enable: true`、`dns-hijack` 匹配接口 IPv4 下一地址的 53 端口时，
+  通过 systemd-resolved 给新接口设置 DNS（默认 `198.18.0.2`）、路由域 `~.` 和 default-route。
+  系统须使用 systemd-resolved；调用 `/usr/bin/resolvectl --no-ask-password`，
+  每次最多五秒并收回子进程。未启用 DNS 或关闭匹配劫持时保留系统 DNS 行为。
+  不覆盖 `/etc/resolv.conf` 或其他接口设置，也不新增 DNS 配置字段。
+- 启动失败逆序撤销已应用的操作；正常 Stop 先停止业务，再恢复 DNS、规则与路由，
+  最后释放自建接口。清理期间额外持有接口 fd，避免接口索引被提前复用。
+  已被外部移除的自有路由视为完成，其他清理错误作为停止错误返回。
+
+安装包负责权限：`packaging/linux/post-install` 为 `/usr/bin/vole` 设置
+`CAP_NET_ADMIN`，并把执行权限限制给 `vole` 组。安装器为获授权用户添加组成员关系，
+将 `50-vole-resolved.rules` 安装到 `/usr/share/polkit-1/rules.d/`，并依赖 systemd-resolved、
+polkit 与提供 setcap 的包。deb postinst / rpm %post 每次更新二进制后执行该脚本。
+运行时不弹出提权请求，不使用 sudo，也不把 capability 传给 resolvectl 子进程；
+后者使用已安装的 [resolve1 授权](https://github.com/systemd/systemd/blob/main/src/resolve/org.freedesktop.resolve1.policy)。
+CLI 的进程启动、后台管理及用户授权仍由调用方负责。
+
+### Linux 捕获范围
+
+`inet6-address` 是接口地址列表，保留地址的 host bits，缺省为
+`fdfe:dcba:9876::1/126`；显式 `[]` 不配置 IPv6 捕获，顶层 `ipv6: false`
+也不配置该地址族。IPv4 地址仍从有效 fake-IP 范围导出 `/30`，不新增独立 IPv4 地址字段。
+
+`route-address` 与 `route-exclude-address` 接受统一的 IPv4/IPv6 CIDR。
+每个可用地址族没有指定捕获网段时使用默认网段；排除网段优先，先做精确 CIDR 相减，
+再安装本会话独占表中的路由。保留 main 表的非默认路由；53 端口先尝试捕获表，
+排除网段仍可绕过。捕获作用域内的未标记流量进入规则，Core 的非零公开或私有出口 mark 不进入捕获。
+
+`include-interface/exclude-interface` 是 Linux RPDB 的输入接口名称筛选，不是物理出口。
+本机 output 使用 `lo`。非空 include 仅捕获所列输入，优先于 exclude（此时不使用 exclude）；
+要同时捕获本机须列出 `lo`。include 为空、exclude 非空时捕获未排除的输入和本机；
+两者均空保留仅本机的缺省作用域。TUN 自身输入与 Core 的带标记物理 socket 始终绕过。
+接口名在配置阶段按 Linux 名称语法与 15 字节上限验证，不要求接口已存在；
+缺失或消失的名称不匹配其他输入，之后出现或恢复同名接口可再次匹配，无需监视任务或重建规则。
+IPv4/IPv6 使用相同接口筛选；只改变本会话的捕获，不设置 forwarding、NAT 或防火墙。
+
+`include-uid/include-uid-range` 限定本机 UID 捕获范围；省略时为全部 UID。
+`exclude-uid/exclude-uid-range` 优先排除，端口排除使用
+`exclude-src-port/exclude-src-port-range/exclude-dst-port/exclude-dst-port-range`。
+范围格式为 `start:end`，不枚举范围内每个 UID 或端口。排除流量跳过本会话捕获规则，
+由后续系统路由决定去向。UID 仅排除本机应用，端口排除作用于所选输入流量；这些选项不改变出口的 protect/物理绑定。
+
+`strict-route: true` 在自动路由中拒绝所选输入使用没有 TUN 地址的 IPv6 族，
+UID/端口的显式旁路仍生效。它不代替宿主防火墙、权限设置或网络故障时的独立 kill switch。
+配置最多 256 项网络输入、派生最多 4096 条 CIDR 路由；超过预算在创建接口前失败。
+路由索引、输入接口、UID、端口和 CIDR 改动需要重建捕获计划，运行期应用会返回需要重连。
+
+这些自动设置仅用于 Core 自建 Linux TUN 且 `auto-route: true` 的路径。
+借用 fd 与 Apple/Android/UWP/Wintun 的接口地址、捕获范围、DNS 和权限由宿主应用；
+Core 不修改借用接口或将跨平台解析成功视为系统网络配置完成。
+
+## Linux 物理 ICMP Echo
+
+Linux 的真实 Echo 在公共 TUN reader 进入 netstack 前分流，复用共享 Dialer 的受控物理出口，
+只走 DIRECT，不解释 TCP/UDP 代理图。`tun.icmp-timeout` 缺省或 0 为 10 秒；
+`disable-icmp-forwarding` 缺省 false。两个字段只在 Linux 配置中存在，其他平台拒绝未知字段并保留原本地合成行为。
+归一化后的 timeout 或 disable 变化由整个 TunConfig 的现有重连门禁处理。
+
+真实 TUN 地址前缀在启动时从实际接口及其 network namespace 读取；这些前缀、启用的 fake-IP 池
+及禁用转发的合法 Echo 使用原本地回应。物理失败、权限不足或容量不足不合成成功。
+Linux 通过普通 DGRAM ping socket 收发 IPv4/IPv6，安装器或宿主须预先用
+`net.ipv4.ping_group_range` 授权运行组；现有 TUN 所需 CAP_NET_ADMIN 不替代此授权。
+Core 不改 sysctl、不运行提权命令、不回退 IP raw socket，也不修改借用 TUN 的地址、路由或 fd 标志。
+
+一个驱动最多持有每族一个物理 ping socket、合计 64 个请求许可，入站/响应队列各 8 项；
+真实包上限为 `min(tun.mtu, 2048)`，发送后的 pending 只留元数据与摘要。
+答复验证实际物理源地址、校验和、标识、长度、摘要和期限后，由现有唯一 TUN writer 公平写回。
+Stop 取消并等待全部所有者，清理 pending、队列、许可和 ping socket；停止后不得再回包。
+详细输入和合成边界见 [ICMP 契约](tun-icmp-dns.md#icmp-echo)。
+
 ## Windows Wintun
 
 桌面 Wintun 使用宿主提供的动态库与原始 IP 适配器，通过同一 `TunIo` 边界进入
@@ -125,7 +218,7 @@ TunRuntime、netstack、DNS、规则和出站图。启用 TUN 的普通 Windows
 宿主提供与程序架构一致的官方 `wintun.dll`。加载路径固定为进程可执行文件所在目录下的
 `wintun.dll`；适配器名由 `tun.device` 控制，空值为 `Vole`，启动可打开已有同名适配器或创建新适配器。
 Vole 不下载或打包该动态库，不搜索 PATH 或启动工作目录。
-系统接口地址、DNS、路由与防递归出口配置由宿主完成；YAML 不提供 DLL 路径或路由字段。
+系统接口地址、DNS、路由与防递归出口配置由宿主完成；YAML 不提供 DLL 路径，网络字段由宿主应用。
 Wintun 使用配置的 MTU，共享原始包校验、IPv6 政策、局部队列预算和同步停止屏障。
 UWP 的 1400 MTU 上限只适用于该安装包路径；超过上限明确拒绝，不静默截断。
 Windows 不接受 Unix file-descriptor 借用路径。
@@ -178,14 +271,16 @@ UWP 因 `StartWithMainTransport` 平台上限要求配置不超过 1400；packet
 包队列                        256
 普通事件 / TCP accept         128
 每关联 UDP 入站               64
-普通 UDP 响应                 4,096
+普通 UDP 响应                 256
 DNS 响应                      128
 ```
 
 TCP 会话、普通 UDP 关联、半开连接和出站握手不设固定业务数量上限。结构安全由有界队列、每流缓冲区、解析大小、超时、空闲清理和缓存提供。
 
 每关联入站、普通响应和 DNS 响应是独立内部队列预算，不扩大 TCP accept。
-满时只丢当前数据报；容量不构成公开配置或活动业务数量上限。TUN 使用 TCP-only
+入站或 DNS 响应队列满时只丢当前数据报；普通响应队列满时，每源关联最多暂持一个
+已接收响应并暂停继续接收，等待容量期间仍可发送请求或取消。取消或错误时丢弃未提交响应。
+容量不构成公开配置或活动业务数量上限。TUN 使用 TCP-only
 netstack 端点及纯 UDP codec，独立 crate 的通用 UDP endpoint 不在生产 TUN 路径上。
 写回受阻时 reader 仍可处理新请求。停止会取消并等待唯一 writer、reader 所有的
 关联/DNS 任务和 netstack，不依赖输出队列腾出容量。
@@ -196,8 +291,8 @@ netstack 端点及纯 UDP codec，独立 crate 的通用 UDP endpoint 不在生
 
 ## 物理出口
 
-- Linux：宿主负责网络命名空间或等效路由隔离，确保被捕获的客户端流量进入 TUN，
-  Vole 出站绕过 TUN；不能把仅绑定 source IP 当作绕路保证。没有自动路由配置或降级路径。
+- Linux：自建接口使用上述自动出口与内部路由隔离；借用 fd 继续由宿主负责命名空间
+  或等效路由隔离。仅绑定 source IP 不能作为绕路保证。
 - Android：每个出站 TCP/UDP socket 在 connect 前调用宿主 protect；失败则当前连接失败关闭。
 - Windows WinRT：Provider 为当前会话选择不可变的物理网络绑定；每个地址族只从非 link-local 地址中选择一个源 IP 和接口索引交给 Session Host，同时独立保留物理适配器全部去重的 on-link prefixes（包括 link-local）用于 VPN 路由。普通出站 socket 必须同时绑定源地址和 WinSock 接口索引。
 - Windows WinRT 只有配置中显式使用 `127.0.0.0/8` 范围内的 IPv4 字面量或 `::1` 的本地出站可以跳过物理绑定；物理代理服务器的域名解析到任何回环地址都会失败关闭。
diff --git a/docs/vless.md b/docs/vless.md
index c6f33a3..4233dc7 100644
--- a/docs/vless.md
+++ b/docs/vless.md
@@ -5,24 +5,27 @@
 
 ## 配置与传输
 
-`type: vless`，`server`、非零 `port` 和标准格式 `uuid` 必填。`udp` 默认 false；`network` 默认 `tcp`，`tls` 默认 false。`encryption` 省略、空或 `none` 关闭该层；其他值见下文。`flow` 省略、空或 `xtls-rprx-vision`。未知字段、null、错型或不匹配的传输选项失败，不隐式迁移配置。
+`type: vless`，`server`、非零 `port` 和字符串 `uuid` 必填。UUID 接受标准、紧凑、花括号或 URN 表示；其他字符串按 UUIDv5(nil, 原始 UTF-8) 映射，不 trim，与 VMess 共用转换。`udp` 默认 false；`network` 默认 `tcp`，`tls` 默认 false。`encryption` 省略、空或 `none` 关闭该层；其他值见下文。`flow` 省略、null 或空串时关闭，也接受 `xtls-rprx-vision`。其余不接受 null 的字段、未知字段、错型或不匹配的传输选项失败，不隐式迁移配置。
 
 - TCP/WS/gRPC/HTTP 首包伪装/legacy H2 可明文或标准 TLS。TLS 支持 1.2/1.3，TCP 默认不发送 ALPN，WS 默认 `[http/1.1]`，gRPC/H2 默认 `[h2]`。有序 ALPN 保留且必须包含传输要求值；标准 TLS 检查协商结果。`servername` 优先显式值、WS Host 去端口、server；不会改变拨号地址。TLS 关闭时禁止安全选项。
-- 标准 TLS 支持 `skip-cert-verify`、SHA-256 `fingerprint`、独立 `name-cert-verify`；沿用共享证书验证器的叶 pin / 非叶信任锚优先级。`certificate` / `private-key` 是配对的内联 PEM，解析或密钥不匹配在 IO 前失败，禁止文件路径。REALITY 不能混用这些标准证书策略。
-- `client-fingerprint` 使用 [TLS 指纹](tls-client-fingerprint.md)的七值/四模板，适用于 TCP 上的标准 TLS/REALITY（含 Vision 和 XHTTP H1/H2），与证书 pin 独立；`none` / 空串关闭，H3 拒绝已启用的 profile。
-- WS 的 ED 支持默认头、自定义头或路径（上限 2048 字节）。`v2ray-http-upgrade` 开启升级后裸流；`v2ray-http-upgrade-fast-open` 必须与前者一起启用，只允许默认 ED 头。fast-open 提前发协议首包但仍等待合法 101，拒绝不返回连接成功。
-- gRPC 接入 `grpc-user-agent`（默认 `grpc-go/1.36.0`）、非负秒数 `ping-interval`（0 不主动 PING），以及三项池阈值。空闲连接总是复用；max-connections>0 时按连接上限/min-streams 扩容，否则按 max-streams 复用阈值扩容。三项全零归一 max-connections=1；显式正 max-connections 与正 max-streams 互斥。阈值不是硬流数上限。物理连接归节点所有，关闭逻辑流不会杀死兄弟流；复用不重选上游组。
+- 标准 TLS 支持 `skip-cert-verify`、SHA-256 `fingerprint`、独立 `name-cert-verify`；沿用共享证书验证器的叶 pin / 非叶信任锚优先级。`certificate` / `private-key` 接受配对的内联 PEM 或文件路径，相对路径从数据目录解析，解析或密钥不匹配在网络 IO 前失败。REALITY 不能混用这些标准证书策略。
+- `client-fingerprint` 使用 [TLS 指纹](tls-client-fingerprint.md)的命名模板，适用于 TCP 上的标准 TLS/REALITY（含 Vision 和 XHTTP H1/H2），与证书 pin 独立；`none` / 空串关闭，H3 拒绝已启用的 profile。
+- WS 的 ED 支持默认头、自定义头或路径。`path` 的 `?ed=N` 覆盖显式 ED 配置并删除 ed 参数；实际早数据按当前请求剩余的16KiB头预算限制，不按配置上限预分配。`v2ray-http-upgrade` 开启升级后裸流；`v2ray-http-upgrade-fast-open` 必须与前者一起启用，只允许默认 ED 头。fast-open 提前发协议首包但仍等待合法 101，拒绝不返回连接成功。
+- gRPC 与 Trojan/VMess 共用配置：省略或空 `grpc-service-name` 默认 `GunService`，普通名映射 `/name/Tun`，`/` 开头使用完整路径；省略或空 `grpc-user-agent` 默认 `grpc-go/1.36.0`。`ping-interval` 为带符号秒数，0 不主动 PING，负值明确拒绝；三项池阈值接受带符号整数，负阈值禁用相应分支。空闲连接总是复用；max-connections>0 时按连接上限/min-streams 扩容，否则按 max-streams 复用阈值扩容。三项池阈值省略或字面全零时归一为4/0/0，Mihomo为1/0/0；显式 max-connections=1 或2保留各自策略。正 max-connections 优先于 max-streams。阈值不是硬流数上限。物理连接归节点所有，关闭逻辑流不会杀死兄弟流；复用不重选上游组。
 - gRPC 不新增业务流/建链数量额度；每个物理连接一个自有驱动，每个等待调用只保留自身 future、取消与原期限，不派生队列任务。每节点最多保留 4 条空闲连接，多余空闲连接退役且不影响活动流。空闲 PING 等待 ACK 最多 15 秒，节点 Stop 取消并 join 所有驱动。
-- `network: xhttp` 支持 H1/H2 明文、TLS1.3 或 REALITY，H3 仅标准 TLS1.3。请求字段、独立下载腿、池与版本选择见 [XHTTP](xhttp.md)。H3 的物理 UDP 仍由原 Dialer/上游图创建。
-- `smux` 以独立的 h2mux/smux v1/yamux 承载逻辑 TCP/UDP；不是 XUDP。only-tcp、调度及关闭边界见 [XHTTP 与 sing-mux](xhttp.md)。
-- Vision 仅允许 `network: tcp`，要求 TLS 1.3/REALITY 或 Encryption；UDP 仅 XUDP。启用 Encryption 后外层 TLS 可省略，存在时仍保持独立认证。配置阶段拒绝 WS/gRPC/HTTP/H2/XHTTP、raw/packetaddr、sing-mux 与 Vision 的组合，包括未启用业务 UDP 但显式选错编码。ECH 和附加安全封装仍拒绝。
+- gRPC 在原建链期限内等待有效 HTTP/2 SETTINGS 并提交完整 VLESS 请求；提交后可持续上传，等待 HTTP 响应不再消耗建链期限。延迟响应仍须通过原状态、内容类型及协议校验，Stop 取消并唤醒活动读写。
+- gRPC authority 使用非空显式 `servername`，否则使用 server:port；`name-cert-verify` 只改变证书验证名称。legacy H2 的 host 省略或为空列表时使用 www.example.com，path 省略或为空时使用 `/`。
+- `network: xhttp` 支持 H1/H2 明文、TLS1.3、REALITY、JLS 或 ShadowTLS v3，H3 仅标准 TLS1.3。请求字段、独立下载腿、池与版本选择见 [XHTTP](xhttp.md)。H3 的物理 UDP 仍由原 Dialer/上游图创建。
+- 公共节点 `smux` 以独立的 h2mux/smux v1/yamux 承载逻辑 TCP/UDP；VLESS 只提供正常 TCP 到约定目标，不拥有第二个 mux 池。它不是 XUDP；only-tcp、调度及关闭边界见 [通用 sing-mux](xhttp.md#通用-sing-mux)。
+- Vision 仅允许 `network: tcp`，要求 TLS 1.3/REALITY 或 Encryption；UDP 仅 XUDP，`packet-encoding: none` 同样归一为 XUDP。启用 Encryption 后外层 TLS 可省略，存在时仍保持独立认证。配置阶段拒绝 WS/gRPC/HTTP/H2/XHTTP、packetaddr、sing-mux 与 Vision 的组合，包括未启用业务 UDP 但显式选错编码。ECH 和附加安全封装仍拒绝。
 - Vision 请求不自动降级；对端用户不支持 Vision 时业务失败。Mihomo 服务端允许为 Vision 用户显式配置空 flow，这属于普通 VLESS 模式，不是错误 flow 的拒绝用例。
 
 ## REALITY
 
-`reality-opts.support-x25519mlkem768` 为非 null 布尔值，默认 false。true 强制真实混合
-TLS 密钥交换，服务端选择经典组时失败；可用于主连接和 XHTTP 独立下载连接。
-仅 `chrome` 或未命名 profile 兼容，模板及下载继承约束见 [TLS 指纹](tls-client-fingerprint.md)。
+`reality-opts.support-x25519mlkem768` 为非 null 布尔值，默认 false。true 允许同次握手
+协商真实混合或经典 TLS 密钥交换，可用于主连接和 XHTTP 独立下载连接。
+`chrome` 和未命名 profile 提供混合/X25519 双 share，其余 TLS1.3 模板保留真实经典 share；
+不改写模板、重试握手或放宽 REALITY 认证。模板及下载继承约束见 [TLS 指纹](tls-client-fingerprint.md)。
 
 ## JLS
 
@@ -34,7 +37,7 @@ TLS 密钥交换，服务端选择经典组时失败；可用于主连接和 XHT
   主连接不接受空对象；未知字段、null、错型、缺项及超限在 IO 前拒绝。
 - 必须 `tls: true`。同一腿不能混用 REALITY、标准证书策略或客户端证书；
   ECH、其他安全封装、Vision 和 HTTP/3 也不属于此组合。
-- `servername`、有序 ALPN、传输必需 ALPN 与已支持的七值/四模板
+- `servername`、有序 ALPN、传输必需 ALPN 与具备 TLS1.3 能力的命名模板
   `client-fingerprint` 沿用共享配置，不增加全局默认或别名。
 - `download-settings.jls-opts` 缺省继承整个身份；非空对象必须完整替换两项，
   `{}` 清除，不能按叶继承另一个身份的密码。其他下载字段独立覆盖。
@@ -57,32 +60,38 @@ TLS 1.2 和 HRR 都不能满足 JLS；失败不发伪装 HTTP 探测、不重发
 JLS 继续承载 TLS 记录，CloseWrite 沿用共享 TLS 有界关闭；XHTTP 保持整流关闭。
 Encryption 位于外层传输内，身份彼此独立，不能由单层成功推断组合验收。
 
-## 静态 ECH
+## ECH
 
-仅显式静态 ECHConfigList；保护内层 ClientHello 名称，不隐藏 IP、外层名称或流量形态。
-无动态 HTTPS RR/bootstrap、公共 DNS 后备或自动更新。
+静态 ECHConfigList 或运行时 HTTPS 记录来源保护内层 ClientHello 名称，
+不隐藏 IP、外层名称或流量形态。VMess/Trojan/AnyTLS/Hysteria2 共用此配置和失败契约。
 
 ### 配置
 
 ```yaml
 ech-opts:
   enable: true
-  config: "<服务端提供的标准 Base64 ECHConfigList>"
+  # config: "<服务端提供的标准 Base64 ECHConfigList>" # 非空时优先，不查询 DNS
+  # query-server-name: query.example # 只覆盖 DNS 查询名；省略时查询 servername
 ```
 
 - 仅标准 TLS，内层 `servername` 必须是 DNS 名，实际只协商 TLS 1.3。
   同腿不能与 REALITY、JLS 或 Vision 混用；可与 VLESS Encryption、证书策略、
   mTLS 和既有传输组合。命名指纹仍只用于 TCP TLS，H3 仍拒绝命名指纹。
-- `enable` 默认 false。启用必须同时提供非空 `config`；不查询 HTTPS RR，
-  不接收 `query-server-name`，没有公共 DNS 后备或自动更新配置。
+- `enable` 默认 false，关闭时忽略 config/query-server-name。启用且 config 为空或省略时，
+  每条新物理 TLS/QUIC 连接通过节点 DNS 角色查询 HTTPS (65)，消费第一个含二进制
+  ECH key 5 参数的有效记录；沿用有界 wire cache 和 singleflight。静态 config 优先。
+- `query-server-name` 只覆盖查询名，不改实际拨号目标、SNI、证书验证名、ALPN 或端口。
+  不查询 SVCB (64) 后备，不按服务优先级重排，不自行跟随 AliasMode。
+  DNS 启用时使用 proxy-server-nameserver 角色；关闭 DNS 和 node-only measureDelay 时
+  使用原 Dialer 的物理 system DNS 元数据。平台来源不可用则失败，无额外公共 DNS 后备。
 - `config` 是标准带填充 Base64，不是 URL、文件路径或 PEM。解码后的完整
-  ECHConfigList 最多 65,537 字节，仍受整份配置 256 KiB 上限限制。
-- 支持 ECH 版本 `0xfe0d`、X25519/HKDF-SHA256，以及 AES-128-GCM、
-  AES-256-GCM、ChaCha20-Poly1305。预检选取第一个双方后端均支持的条目，
-  保留其原始编码；未知版本或不兼容条目可跳过，无兼容条目、畸形长度、非法
-  public_name 或不支持的必需扩展在 IO 前失败。不能依赖 BoringSSL 静默忽略。
-- `{}` / `{enable: false}` 清除 ECH。关闭时不允许携带非空 config，以免
-  用户认为给出的隐私配置已经生效。null、未知字段、错型均拒绝；诊断不回显配置。
+  ECHConfigList 最多 65,537 字节，仍受整份配置 8 MiB 上限限制。
+- ECH 版本为 `0xfe0d`。按实际 [后端算法](tls-dependencies.md) 选取第一个兼容条目，
+  保留其原始编码；下载腿切换后端时按完整来源重新选择。未知版本或不兼容条目可跳过，
+  无兼容条目、畸形长度、非法 public_name 或不支持的必需扩展失败，不能依赖 BoringSSL 静默忽略。
+- public_name 要求多标签 LDH 名称；Rustls 的名称类型另限制每标签 63 字节并拒绝纯数值末段，
+  Boring 命名指纹还拒绝十六进制 IP lookalike。这里保留真实后端限制，不能宣称任意 Go DNS 名称均兼容。
+- `{}` / `{enable: false}` 清除 ECH。null、未知字段、错型均拒绝；诊断不回显配置或查询名。
 
 `xhttp-opts.download-settings.ech-opts` 缺省继承整个主腿对象；出现时整对象替换，
 不逐字段合并，替换密钥须同时写 `enable: true`。显式 `{}` 可仅清除下载腿 ECH。
@@ -91,18 +100,22 @@ ech-opts:
 
 ### 后端与失败边界
 
-无指纹 TCP TLS 与 H3 使用官方 rustls + ring，通过公开 HPKE trait 接入官方
-`hpke`；命名指纹使用锁定的自有 boring fork 既有 ECH 接口。本次不修改
-第三方 TLS 实现，不恢复 rustls fork，也不扩展 Shadowsocks 的 AWS-LC 例外。
+无指纹 TCP TLS 与 XHTTP H3 的 Quinn 使用官方 rustls + ring，通过公开 HPKE trait 接入官方
+`hpke`；命名指纹使用锁定的同一 boring ECH 接口。XHTTP H3 保留 rustls 的完整 ECH
+算法范围；Boring 命名指纹限定 X25519/HKDF-SHA256，加 AES128/256-GCM 或 ChaCha20-Poly1305。
+切换下载腿时按完整静态来源和实际后端重新选择，动态来源也按实际后端解析；
+没有兼容配置就失败。动态来源只获取配置，不扩大后端算法范围。
 
 两后端都必须真正接受 ECH 才交出业务连接。rustls QUIC 的 ECH 拒绝作为原生
-握手错误传播，H3 在握手完成前不发送 HTTP 请求；TCP 另检查 accepted 状态。
+握手错误传播，XHTTP H3 还检查实际 ALPN，通过前不发送 HTTP 请求。
+TCP 同样检查 accepted 状态。
 不把 GREASE 当真实 ECH，不自动采用 retry config，不重拨、不回放业务，也不
-降级为未加密 ClientHello 的成功连接。错误或轮换后的旧密钥需要宿主更新配置。
+降级为未加密 ClientHello 的成功连接。静态旧密钥需宿主更新配置；动态新连接随 DNS 缓存有效期取得来源。
 
-静态 ECH 连接禁用 TLS 会话恢复和 0-RTT；XHTTP/gRPC 的已认证物理连接仍可在
+ECH 连接禁用 TLS 会话恢复和 0-RTT；XHTTP/gRPC 的已认证物理连接仍可在
 原节点内复用。不同节点、主/下载腿、配置替换和后续运行实例不会共享 TLS 票据。
-本层只包装调用方提供的 IO，不创建 resolver、socket、后台任务或全局缓存。
+本层只包装调用方提供的 IO；DNS 查询由原建链期限和解析上下文取消拥有，
+只弱引用运行时 DNS，不创建独立 resolver、socket、后台刷新任务或全局可变缓存。
 
 正常 ECH 接受后沿用内层证书名称、pin 和 mTLS 策略。拒绝分支不返回业务成功，
 也不能发送客户端证书。boring 使用原生 outer-name override，按外层名称和默认
@@ -146,27 +159,45 @@ Vision padding、TLS 记录过滤和读写切换状态独立管理。内层非 T
 
 ## UDP
 
-`packet-encoding` 默认 **xudp**，与既有 Vole 行为一致：
+`packet-encoding` 默认 **xudp**，`none` 与 `xudp` 使用相同编码：
 
 | 配置 | 线上语义 | 目标 |
 | --- | --- | --- |
-| 省略 / `xudp` | VLESS CommandMux + 共享 XUDP 帧 | 每包携带 IP / 域名 |
-| `none` | VLESS CommandUDP + 两字节长度 | 固定首包目标，后续换目标失败 |
+| 省略 / `xudp` / `none` | VLESS CommandMux + 共享 XUDP 帧 | 每包携带 IP / 域名 |
 | `packetaddr` / `packet` | CommandUDP 到原生约定地址，长度帧内再带地址 | IP-only，域名经受控 ResolutionContext 解析 |
 
-`none` 是 Vole 的显式 raw 拼写，不是对 Mihomo 同名字段的兼容承诺。原生约定地址不做本地 DNS。UDP 443 不额外过滤。
+packetaddr 的原生约定地址不做本地 DNS。UDP 443 不额外过滤。
 
-raw/packetaddr 每关联只拥有一个已建流，首次发送前已固定物理上游选择和建链期限；等待首包不会重新选择组或重启期限。packetaddr 不调用系统 resolver：运行期使用本 Running Session DNS，独立测速使用受控 bootstrap。
+VLESS 不发送非零 XUDP GlobalID，不请求服务端跨载体继承 UDP 关联。同一来源可能同时拥有
+不同节点、资源代际、域名隔离或退役后仍服务兄弟目标的通道；这些通道保持独立，不能仅按
+来源生成相同 GlobalID。当前关联失败后关闭，不自动重连或恢复服务端原有 UDP 出口映射。
 
-收发预算独立与调用方预算取交集。raw/XUDP payload 受 u16 上限约束，packetaddr 另扣 IPv4 7 / IPv6 19 字节地址头（未解析域名按较大开销预检）。raw/packetaddr 接收 wire 最多 65,537 字节，逐段读取，合法超接收预算的整包丢弃。对端可能有更小容量，原生夹具预算不能冒充生产协议上限。
+packetaddr 每关联只拥有一个已建流，首次发送前已固定物理上游选择和建链期限；等待首包不会重新选择组或重启期限。packetaddr 不调用系统 resolver：运行期使用本 Running Session DNS，独立测速使用受控 bootstrap。
 
-部分发送取消立即关闭 IO，不允许接着发送半帧；接收取消保留帧进度。非法帧或响应头关闭关联，不切换编码、不回退 DIRECT。显式 close 后不能恢复收发。
+收发预算独立与调用方预算取交集。XUDP payload 受 u16 上限约束，packetaddr 另扣 IPv4 7 / IPv6 19 字节地址头（未解析域名按较大开销预检）。packetaddr 接收 wire 最多 65,537 字节，逐段读取，合法超接收预算的整包丢弃。对端可能有更小容量，原生夹具预算不能冒充生产协议上限。
+
+XUDP 在既有单帧字节预算内读取已就绪字节，消费当前帧后保留后续帧的尾部；不等待凑批，
+也不为每个长度或地址字段分别进入底层 TLS/HTTP 接收。
+省略回复目标仅在关联始终使用同一目标时可恢复；多目标关联收到无目标回复会关闭，避免串流交付。
+无 VLESS Encryption 的 H1/H2/H3 XHTTP 由自有驱动独立推进已接受的写入，XUDP 首包保留建链 flush，
+后续帧交给既有有界发送队列；其它传输仍逐帧 flush。
+packetaddr 在同一适用范围保留 VLESS 请求头与首个 DATA 帧的强制 flush，首个 DATA
+仍受原建链绝对期限约束。后续完整帧被既有有界 writer 接纳后即可返回，不额外逐帧等待
+packet-up 的 POST 响应；容量不足时仍沿原背压等待。timer／IO 驱动独立推进末帧，
+不依赖下一次收发。启用 VLESS Encryption 或非 XHTTP 路径仍逐帧 flush。
+返回成功表示接纳，不代表远端确认；显式 close／Stop 可以取消尚未确认的 UDP，
+不承诺排空这些帧。来源隔离、目标地址恢复、部分发送取消及原有 TCP FIN／XHTTP 整流关闭合同保持。
+
+packetaddr 和 XUDP 在关联中最多保留一个待写帧及偏移；取消发送后，下次收发先完成该帧与必要的 flush，再处理新包，保持共享通道边界。packetaddr 在发布关联前完成固定魔法目的的传输准备，首次报文仍受原建链期限约束，不因取消重置。相同来源、相同具体节点且无需地址恢复的 IP 目标可共享一条 packetaddr wire；每包回包地址用于分发，域名、fake-IP 与嗅探覆盖路径仍保留独立 wire。最后所有者关闭可直接终止未完成帧，不在其中插入 END 帧。接收取消保留帧进度。非法帧或响应头关闭关联，不切换编码、不回退 DIRECT。显式 close 后不能恢复收发。
 
 ## 关闭和期限
 
-VLESS 响应头允许延迟到业务响应前；TCP 不等待它才允许发送请求。读取、首次响应和传输握手共用原建链期限，错误或超时释放 IO。UUID 和业务目标不进入 Debug/诊断。
+VLESS 响应头允许延迟到业务响应前；TCP 不等待它才允许发送请求。传输握手及请求头写入、flush 共用原建链期限，请求头成功提交后结束该期限；响应头随后按需读取、校验，持续上传不因缺少下行响应被原建链期限中断。业务等待由调用者期限、取消、EOF及运行时停止控制，格式错误仍释放IO。UUID 和业务目标不进入 Debug/诊断。
+
+HTTP 首包伪装在完整请求前导提交后按需解析首响应，不为该响应保留旧建链期限；
+VLESS Encryption 等仍未完成的协议握手继续受原建链期限约束，不从 HTTP 前导提交推定完成。
 
-普通 TCP/TLS 按底层 CloseWrite 语义工作；HTTP 首包伪装没有 Mihomo CloseWrite，shutdown 释放整个逻辑流并唤醒读侧。gRPC/H2 结束当前逻辑流，gRPC 的兄弟流与节点池不受影响。XHTTP 上传 EOF/shutdown 关闭整条逻辑连接，包括下载腿；需要完整响应时在关闭前读完。验收分别检查正常完整性和对齐 Mihomo 的关闭行为，不要求所有传输半关闭后都收到尾包。
+普通 TCP/TLS 按底层 CloseWrite 语义工作；HTTP 首包伪装没有 Mihomo CloseWrite，shutdown 释放整个逻辑流并唤醒读侧。gRPC/H2 结束当前逻辑流，gRPC 的兄弟流与节点池不受影响。XHTTP 上传 EOF/shutdown 关闭整条逻辑连接，包括下载腿；需要完整响应时在关闭前读完。验收检查正常数据完整性、与支持对端的互通，以及 Vole 声明的关闭、取消和 Stop 契约，不要求所有传输半关闭后都收到尾包。
 
 ## 验证边界
 
@@ -179,6 +210,8 @@ HTTP/H2/扩展 WS 可用 Xray TLS 网关 → V2Ray transport；需 UDP/Encryptio
 Mihomo 解码。网关使用官方 XRAY_BUF_SPLICE=disable，避免下行 raw splice 绕过 TLS；
 不代表 V2Ray 直接支持 ECH。无指纹 JLS/gRPC 及 Safari ECH/gRPC 的官方对照缺口采用
 明确标注的 Chrome 关闭参照；Vole 原配置的数据面单独验证，不声称同配置差分。
-VLESS 不接受动态 ECH、ShadowTLS 或 Restls 配置；ShadowTLS v3 仅用于 SS2022 插件。
+VLESS 的 `shadow-tls-opts` 仅接已有 TCP 承载传输及 XHTTP H1/H2，包含独立下载腿；
+须 `tls: true`、显式 version 3 和 password，不能与 Vision/JLS/REALITY/ECH 同腿混用。
+cover 的证书策略与 mTLS 独立于业务身份，行为见 [流式安全身份](outbounds.md#流式安全身份)。
 
-WS + REALITY（普通 WS、HTTPUpgrade、fast-open）的数据及认证使用真实 Mihomo listener；关闭验证采用明确标注的分层参照。当前 Mihomo WS 客户端分支未接入 REALITY，不能作为同组合对照，因此使用标准 TLS 的同种传输客户端关闭基线，并独立验证 REALITY。不得将该结果写成 Mihomo WS + REALITY 客户端互通或同组合差分通过。
+REALITY 只接流式 TLS 消费路径；普通 WS、HTTPUpgrade 及其 fast-open 与 REALITY 的组合在配置期拒绝。
diff --git a/docs/windows-vpn.md b/docs/windows-vpn.md
index cf7343c..667d849 100644
--- a/docs/windows-vpn.md
+++ b/docs/windows-vpn.md
@@ -151,8 +151,15 @@ Session Host 的每个非回环出站 socket 必须同时应用：
 
 只绑定其中一项不满足契约。只有配置中显式使用 `127.0.0.0/8` 范围内的 IPv4 字面量或 `::1` 的本地出站可以跳过；物理代理服务器的域名在准备阶段解析到任何回环地址都会失败关闭。局域网和私有地址不属于例外。缺少地址族、源地址绑定或接口设置失败时，当前连接失败关闭。
 
+全局/节点 `interface-name` 和普通 DNS `#接口` 只允许选择同一个 Provider 物理适配器。
+友好名、系统接口名和 GUID 由 Windows SDK 转换为实际接口身份；不匹配时当前连接失败，
+不改变绑定源地址、接口索引或会话快照。非零 `routing-mark` 在 Windows 上不可用。
+桌面 Wintun 的显式接口选择仅设置普通出站 socket，不取得 Provider 绑定或代替宿主路由配置。
+
 `AssociateTransport` 只用于 Provider 的受管理唤醒传输，不用于普通代理流。Session Host 不持有 `VpnChannel`，不能给逐流 socket 获取同类豁免。
 
+显式 `system` DNS 仅由实际 Session Host 在显式查询按需读取既有物理适配器 GUID 的 DNS 数据（metadata 缓存 20 秒），继续执行同一 `(源 IP, 接口索引)` 绑定；不读取前台 Invoke registry，也不改变控制协议。`GetInterfaceDnsSettings` v3 不可用或存在无法满足的加密要求时来源不可用。原生 IPv6 DNS 的加密策略无法通过该只读查询确认，也保持不可用。无法确认 DHCP option 6 来源时 `dhcp://<接口>` 不可用。系统 DNS 发现不配置或恢复系统网络，App 仍负责原有网络设置和生命周期。
+
 ## 网络变化
 
 Provider 是物理网络状态的唯一权威，并订阅 `NetworkStatusChanged`。事件到达后等待 2 秒，再复验适配器 GUID、选定源地址、全部去重 on-link prefixes 和 network identity；任一项变化就停止当前 VPN。
@@ -180,7 +187,7 @@ vole-windows-vpn-host.exe
 vole-windows-session-host.exe
 ```
 
-- manifest 只有一个主 Application，三个可执行参与者相互独立；产物架构一致，Rust 使用静态 CRT；
+- manifest 只有一个主 Application，三个可执行参与者相互独立；产物架构一致，UWP 的 Rust 和原生依赖统一使用动态 CRT，安装包负责声明并部署对应架构的 Visual C++ Runtime 依赖；
 - Session Host 是 `windows.fullTrustProcess` extension，不显示在应用列表，也不注册 StartupTask 或 URI；
 - Provider 的 `windows.backgroundTasks` extension 显式使用 `windowsApp + appContainer`；
 - Provider activation class 来自 `vole.dll`；
@@ -337,10 +344,10 @@ Stopped { version, packetCounters }
 
 ## Controller 与本地 SOCKS
 
-- Controller 由 Session Host 监听完全信任的回环地址；
+- Controller 由 Session Host 按 YAML 的 `external-controller` 地址监听；
 - `RuntimeReady` 前必须完成绑定，失败则连接失败；
 - 前台宿主持有配置中的端口和 secret，并调用 `GET /traffic`、`GET /group`、`GET /group/{name}`、`GET /proxies/{name}` 或 `PUT /proxies/{name}`；
-- 配置代理组与 Controller 时 secret 必填并保护全部路由；仅有 TUN 流量 Controller 时 secret 仍可省略；
+- `secret` 可省略或为空；配置非空 `secret` 时保护全部路由，与是否配置代理组无关；
 - 代理组选择属于 Session Host 中实际 Running Session 的内存状态，不经过 Windows bridge、Provider 控制管道或 Session Snapshot 写回；
 - 成功切换只影响之后新建的物理 TCP、UDP 和 DNS transport，不迁移既有连接、UDP association、DNS 状态或 TCP pool，也不执行自动 failover；
 - 宿主如需跨 VPN session 保留选择，必须自行持久化，并在下次 `startVpn` 的 YAML 中注入对应 `default-selected`；
@@ -360,5 +367,13 @@ Stopped { version, packetCounters }
 - [`VpnManagementAgent`](https://learn.microsoft.com/uwp/api/windows.networking.vpn.vpnmanagementagent)
 - [`FullTrustProcessLauncher`](https://learn.microsoft.com/uwp/api/windows.applicationmodel.fulltrustprocesslauncher)
 - [Package identity](https://learn.microsoft.com/windows/apps/desktop/modernize/package-identity-overview)
+- [UWP 与 C Runtime](https://learn.microsoft.com/cpp/c-runtime-library/windows-store-apps-the-windows-runtime-and-the-c-run-time)
 - [`RoInitialize`](https://learn.microsoft.com/windows/win32/api/roapi/nf-roapi-roinitialize)
 - [`CoIncrementMTAUsage`](https://learn.microsoft.com/windows/win32/api/combaseapi/nf-combaseapi-coincrementmtausage)
+
+
+`startVpn` 可选 `httpConfigYaml` 和 `httpContext` 接收[独立 HTTP 规则](http-processing.md)与 baseDir／私密 CA。断开状态可准备来源；活动前台不使用默认 socket 获取资源。canonical Session Snapshot 固定主设置、实际 payload、原生基目录和公开 CA 指纹，参与 token；私钥仅在当前用户 DPAPI sidecar 中，entropy 绑定 package family 与 token，先发布 sidecar 再发布普通快照。随机密文不参与 token。
+
+Session Host 完成 token 握手后才读取并解密 sidecar，复验 token、CA 身份和证私匹配；恢复实际规则不重读源文件。运行中的周期更新使用原 PhysicalBinding 的直接出口，只产生 pending；Stop 等待更新结束。私密 sidecar 随当前／上一份快照保留并同步清理，不进入普通缓存、Controller、日志或包通道。
+
+主配置保持 8 MiB 上限，独立 HTTP 输入与实际来源合计保持 1 MiB；内部展开 HTTP 快照最多 8 MiB。普通 Session Snapshot 在写出前精确计算 JSON 转义后的大小，只预留实际所需字节；读取上限同时计入这两份内容、原生基目录和有界 backend 元数据。bridge 请求仍最多 1 MiB。公开 CA 身份使用证书 DER 的 SHA-256，不依赖 PEM 排版；真正使用 CA 时仍验证有效期、CA 约束和证私匹配。编译不代替实际 Windows DPAPI／VPN 验证。
diff --git a/docs/xhttp.md b/docs/xhttp.md
index 48e87c6..00b3638 100644
--- a/docs/xhttp.md
+++ b/docs/xhttp.md
@@ -1,19 +1,19 @@
-# XHTTP 与 VLESS sing-mux
+# XHTTP 与通用 sing-mux
 
 XHTTP/sing-mux 使用严格字段与类型；未知、null、无效或被忽略的组合在 IO 前拒绝。
-REALITY、JLS、静态 ECH 的身份规则见 [VLESS](vless.md)，实际验证边界见[验收说明](acceptance.md)。
+REALITY、JLS、ECH 的身份规则见 [VLESS](vless.md)，实际验证边界见[验收说明](acceptance.md)。
 
 ## HTTP 版本和连接模式
 
 `network: xhttp` 使用现有 Dialer、上游图、保护接口与 SecurityClient，不另建系统解析器或裸 socket。`alpn: [http/1.1]` 选择 H1；空列表、`[h2]` 或包含 H1/H2 的列表选择 H2；只有独占 `[h3]` 选择 H3。不会静默降级 HTTP 版本。
 
-H1/H2 可使用明文、标准 TLS 1.3、REALITY（经典默认、显式混合模式）或 JLS。H3 必须使用标准 TLS 1.3，不允许同腿明文、REALITY 或 JLS。QUIC 收发走受控数据报，上游有效预算小于 1200 字节即拒绝，不绕开代理、protect 或接口绑定；路径 MTU 探测关闭。
+H1/H2 可使用明文、标准 TLS 1.3、REALITY（经典默认、显式混合模式）、JLS 或 ShadowTLS v3。H3 使用官方 h3/h3-quinn 与 Quinn，必须使用标准 TLS 1.3，不允许同腿明文、REALITY、JLS 或 ShadowTLS。QUIC 收发走受控数据报，上游任一方向有效预算小于 1200 字节即拒绝，不绕开代理、protect 或接口绑定；发送从 1200 字节起探测 MTU，探测上限受发送预算约束，接收广告独立使用实际接收预算。
 
-`xhttp-opts.mode` 接受 `auto`（默认）、`packet-up`、`stream-up`、`stream-one`。auto 在 REALITY 无下载配置时选择 stream-one，有下载配置时选择 stream-up，其余选择 packet-up。stream-one 是一条双工 POST，不允许 `download-settings`；其余模式以同一会话 ID 关联上传与下载。`path` 默认 `/`，`host` 显式非空优先，否则使用该腿 servername/server；IPv6 authority 使用方括号。主腿与下载腿的 host 均禁止 userinfo（`@`）。
+`xhttp-opts.mode` 接受 `auto`（省略或空串默认）、`packet-up`、`stream-up`、`stream-one`。auto 在 REALITY 无下载配置时选择 stream-one，有下载配置时选择 stream-up，其余选择 packet-up。stream-one 是一条双工 POST，不允许 `download-settings`；其余模式以同一会话 ID 关联上传与下载。`path` 省略或空串默认 `/`，`host` 显式非空优先，否则使用该腿 servername/server；IPv6 authority 使用方括号。主腿与下载腿的 host 均禁止 userinfo（`@`）。
 
 ## 请求字段
 
-区间字段均为字符串 `"N"` 或 `"N-M"`，不接受数字、负数、倒置区间、空串或溢出。每次采样保持在闭区间内。
+区间字段接受字符串 `"N"` 或 `"N-M"`；`uplink-chunk-size`、`sc-max-each-post-bytes`、`sc-min-posts-interval-ms` 还接受 YAML 整数，使用相同的范围与配套校验。空串或纯空白使用字段默认，字符串中的数字及区间两端允许外围空白和正号。其他区间字段不接受数字类型；所有字段均拒绝 null、浮点数、布尔值、负数、倒置区间或溢出。每次采样保持在闭区间内。
 
 | 字段 | 默认及约束 |
 | --- | --- |
@@ -25,16 +25,16 @@ H1/H2 可使用明文、标准 TLS 1.3、REALITY（经典默认、显式混合
 | `x-padding-key` | 混淆 queryInHeader/query/cookie 时必填；header 不使用此字段 |
 | `x-padding-header` | 混淆 header/queryInHeader 时必填合法头名；其他位置不使用 |
 | `x-padding-method` | repeat-x；开启混淆后也可 tokenish，按 HPACK 编码后的长度生成 |
-| `uplink-http-method` | POST，也接受 PUT/PATCH/DELETE；不将 GET 或 OPTIONS 用于上传 |
+| `uplink-http-method` | 默认 POST，接受合法的自定义 HTTP method token；GET 下载与 OPTIONS 预检不能用于上传 |
 | `session-placement` / `session-key` | path（不填写 key）；header 默认 X-Session，query/cookie 默认 x_session |
 | `session-table` | 空：32 字符随机 hex；uuid：标准 UUID v4；或预定义/自定义去重 ASCII 字符表 |
 | `session-length` | 字符表模式默认 `"16-32"`，1–128；全部长度构成的命名空间至少 2^31。空表/uuid 不接受显式长度 |
 | `seq-placement` / `seq-key` | 仅 packet-up；path，或 header 默认 X-Seq、query/cookie 默认 x_seq |
 | `uplink-data-placement` | body，auto 归一 body；header/cookie 仅用于 packet-up |
 | `uplink-data-key` | header/cookie payload 必填，body 不接受 |
-| `uplink-chunk-size` | header/cookie 默认 `"0"` 自适应；显式区间 64–8192。自适应 header 3072–4096、cookie 2048–3072 |
+| `uplink-chunk-size` | header/cookie 默认 `"0"` 自适应；非零区间小于64归一到64，上限8192。自适应 header 3072–4096、cookie 2048–3072 |
 | `sc-max-each-post-bytes` | packet-up，`"1000000"`，1–16 MiB；这是 POST 上限，不是预分配缓冲大小 |
-| `sc-min-posts-interval-ms` | packet-up，`"30"`，0–60000 且最大值须为正；允许 `"0-N"`，不允许纯零 |
+| `sc-min-posts-interval-ms` | packet-up，`"10"`，0–60000 且最大值须为正；允许 `"0-N"`，不允许纯零 |
 
 session/sequence 均支持 path/query/header/cookie。键使用至多 64 字节的 HTTP 安全 token，禁止互相冲突以及覆盖 padding、payload 或既有 query/header。字符表预定义值包括 `ALPHABET`、`Alphabet`、`alphabet`、`BASE36`、`base36`、`Base62`、`HEX`、`hex`、`number`。
 
@@ -42,27 +42,59 @@ session/sequence 均支持 path/query/header/cookie。键使用至多 64 字节
 
 header/cookie payload 使用无填充 Base64URL，并按实际请求预算拆块；完整请求（URI、生成字段和自定义头）不超过 16 KiB / 128 项。业务数据按有界块处理，不把整个 POST 限额、对端声明或业务流读入无界 Vec。
 
-packet-up 在发送间隔内聚合小块写入，而不是把每个 write 变成一个 POST。最多保留一个待发送批次和一个在途批次，每批最多 64 KiB，并与本连接采样的 POST 上限取较小值；头部 payload 仍按请求预算拆分。write 完成只表示数据已进入有界缓冲，flush 等待对应 POST 确认；计时器无需调用方再次读写即可发送。shutdown 立即尝试 flush 未发送批次，卡住的 POST 仍受一秒上限控制。计时器/上传任务归节点所有，Stop 同步等待。
+H3 响应 HEADERS 的解码字段预算为 16 KiB，编码 payload 预算为其 1.5 倍（24 KiB），在帧声明长度到达时检查；SETTINGS payload 最多 256 字节，携带单个 varint 的控制帧为 1–8 字节。未知非 DATA 帧也受 24 KiB 编码预算限制，超额提前拒绝，不等待完整 payload。这比 quiche 路径最多 16 MiB、流式跳过未知帧的范围更窄，以避免官方 h3 解码器累计整帧造成内存增长；DATA 仍增量交付，不受该整帧预算限制。
+
+Quinn H3 接收适配层分别交付帧头和正文，不跨帧预读；至多保留一个原生接收块的剩余切片，
+与原块共享内存。这使应用的读取进度持续约束 QUIC 接收额度，避免合并小 DATA 帧在解码层积压。
+
+packet-up 在发送间隔内聚合小块写入，而不是把每个 write 变成一个 POST。最多保留一个批次，包括 HTTP 正在发送的正文；H1 与普通 H3 单响应路径每批最多 48 KiB，H2 每批最多 64 KiB，下述共享 H3 双响应路径每批最多 128 KiB，均与本连接采样的 POST 上限取较小值。普通路径在 POST 在途时向写入方施加背压，不另外积累下一批；头部 payload 仍按请求预算拆分。write 完成只表示数据已进入有界缓冲，flush 等待对应 POST 确认；计时器无需调用方再次读写即可发送。shutdown 立即尝试 flush 未发送批次，卡住的 POST 仍受一秒上限控制。计时器/上传任务归节点所有，Stop 同步等待。
+
+批次缓冲按需扩容，分配容量也受该批次上限约束，避免不规则帧尺寸使倍增扩容超过预算；writer 不预分配完整批次。普通路径在 POST 确认后复用已独占的正文 backing；HTTP 尚持有引用时释放本地引用，不为回收再复制正文。每个 writer 至多保留这一批缓冲，逻辑连接关闭时释放。H3 的批次 backing 上限不等于进程 RSS 增量；HTTP/QUIC 编码及发送窗口可能同时持有其它有界数据。
+
+VLESS 无 Encryption、无显式下载设置，且启用无 padding 的 h2mux、only-tcp=false 时，H3 packet-up 的 body/auto 上传串行发送正文，最多保留两个尚未退役的响应槽。正文仍只有一个不超过 128 KiB 的工作区：真实发送 FIN 完成且最后一个正文引用释放后，独占归还同一 Vec，才允许复用。每批增加一个有界 owner 元数据对象，不复制正文；两个响应槽满时连第三批预填也暂停。 同一qualified H3物理连接初始发送留存仍64KiB；只有该连接上一次业务mux UDP请求的元数据成功写入并flush后，才同步升至192KiB直到退役（不是peer确认）。同physical的TCP与UDP共享升档，未见UDP的其它physical及排除路径仍64KiB；不拆池、不增加队列/task/连接，不改变FIN/Stop。200 响应及不超过 16 KiB 的响应体读取成功，才按序确认连续前缀；后到先完成的响应仍占槽，flush 不跨过缺口。等待打开请求、发送、FIN 和缓冲归还时共同推进已有响应；错误取消未完成上传，Stop 沿用节点的取消与 join。其它路径保持单响应背压。
+
+body/auto 模式的 POST 共享已冻结批次的不可变 backing，不额外复制一份业务负载；
+发送任务和批次所有者分别释放引用，头部/cookie 模式继续使用有界编码。
+H1 编码保留正文 backing，不将整批正文再次拼入头部写缓冲；每次向所供应 IO 提供的正文片段最多 16 KiB，避免一次提交整批正文使 TLS 同时缓冲多个记录，
+并保留原有 flush 确认与 Stop 屏障。
+H1 请求命令队列以指针槽持有完整请求，避免底层分块队列为空槽预留整个请求对象；
+逻辑队列容量、请求顺序、正文共享及取消/Stop 所有权保持不变。
+
+省略或留空间隔时，普通路径的部分批次使用 10 ms 聚合；上述共享 H3 双响应路径使用 2 ms。
+达到对应批次上限后立即提交，正文仍只使用一个有界工作区。
+显式配置的间隔与范围保持原值，满批仍遵守该间隔。
+未满批次及显式间隔以 POST 发起时间计时，前次交换和空闲时间计入间隔。
+空闲超过间隔后可立即发送新批次。底层准入和网络可能推迟发送，计时不代表线上首字节间隔。
 
 ## 独立下载腿
 
 `download-settings` 缺省和 `{}` 不等价：存在即启用独立下载连接/池，但仍共用一次 VLESS 握手、会话 ID 和建链上下文。两腿必须汇聚到**同一个原生 XHTTP handler 的会话表**；两个独立 listener 不能构成共享会话。
 
-可覆盖 `server/port/tls/servername/alpn/host/path/headers`、`client-fingerprint`、普通 TLS 的 `skip-cert-verify/name-cert-verify/fingerprint/certificate/private-key/ech-opts`、`reality-opts`、`jls-opts` 和 `reuse-settings`。
+可覆盖 `server/port/tls/servername/alpn/host/path/headers`、`client-fingerprint`、普通 TLS 的 `skip-cert-verify/name-cert-verify/fingerprint/certificate/private-key/ech-opts`、`reality-opts`、`jls-opts`、`shadow-tls-opts` 和 `reuse-settings`。
 
 - 缺省叶字段继承主腿。headers 是整体替换，`{}` 清空；显式空 host 恢复下载认证名/server 推导。
 - `skip-cert-verify: false` 必须覆盖主腿 true；空 name-cert-verify/fingerprint 清除对应 override/pin。
-- `client-fingerprint` 缺省继承，显式名称覆盖，`none` / 空串清除。下载腿切到明文或 H3 前必须清除继承的已启用 profile；它不属于证书策略，不因切换 TLS/REALITY 自动清除。七值/四模板见 [TLS 指纹](tls-client-fingerprint.md)。
+- `client-fingerprint` 缺省继承，显式名称覆盖，`none` / 空串清除。下载腿切到明文或 H3 前必须清除继承的已启用 profile；它不属于证书策略，不因切换 TLS/REALITY 自动清除。十值/八模板见 [TLS 指纹](tls-client-fingerprint.md)。
 - certificate/private-key 必须配对替换或同时空串清除；PEM 与密钥匹配在 IO 前检查。
 - reality-opts 缺省继承整个对象，`{}` 清除；非空对象必须提供 public-key，short-id 缺省空、support-x25519mlkem768 缺省 false，不按叶合并旧对象。仅提供混合开关不等同空对象，仍须提供 public-key。null 拒绝。
 - jls-opts 缺省继承整个身份，非空对象必须完整替换 username/password，`{}` 清除；同腿与 REALITY 和证书策略互斥，切换时须显式清除旧对象。JLS 仅 H1/H2，实际 TLS1.3，无恢复；完整约束见 [JLS](vless.md#jls)。
-- ech-opts 缺省继承、非空对象整体替换，启用必须同时提供 enable=true 和静态 config；`{}` 清除。仅标准 TLS，可用于 H1/H2/H3。没有动态查询或自动重试；切换到 REALITY/JLS/明文前必须显式清除继承的 ECH。
+- shadow-tls-opts 缺省继承整个身份，非空对象须完整提供 version 3/password，`{}` 清除。仅 H1/H2，与 REALITY/JLS/ECH 互斥；cover 证书策略和 mTLS 按下载腿重算，模式切换须显式清除冲突身份。
+- ech-opts 缺省继承、对象整体替换，`{}` 清除。`enable: true` 使用非空静态 config 或节点 DNS 的 HTTPS key 5，静态优先；query-server-name 只覆盖查询名。按下载腿实际 TLS backend 从完整来源重选配置。仅标准 TLS，可用于 H1/H2/H3；切换到 REALITY/JLS/明文前必须显式清除继承的 ECH。失败不重拨或重放。
 - 切换到明文或 REALITY 不会悄悄丢弃继承的证书策略；须显式清除冲突字段。每条腿独立重新校验最终安全配置。
-- 独立地址/端口在 prepare 时分别准备；两腿共享原绝对期限和每个上游组的选择快照，下载失败不会另起超时预算或绕过原图。
+- 独立地址/端口在实际建立物理连接时通过节点 resolver 分别解析；两腿共享原绝对期限和每个上游组的选择快照，下载失败不会另起超时预算或绕过原图。
 
 ## HTTP transport 复用
 
-`reuse-settings` 缺省禁用节点池；`{}` 启用默认池。下载配置缺省继承整个主腿 reuse 对象，显式对象整体替换，未填写项回到零，不逐字段继承。
+`reuse-settings` 缺省时，H1 和通用 H2 transport 构造保持独立物理连接；H3 只共享活动物理连接，每条最多承载 4 个活动逻辑租约。
+仅 VLESS packet-up 且存在显式 download-settings、上传和下载均为 H2 与静态普通 TLS、JLS 或 REALITY 时，可按每腿的字面 IP、固定直接上游和固定物理出口证明共享活动连接，每条最多 4 个逻辑租约。上传与显式下载腿各有独立池，不跨节点或资源代复用；单腿、stream-one/stream-up、明文和其它版本组合保持原路径。
+REALITY 的公钥、short ID、SNI、指纹与混合密钥交换选项固定于各腿节点；新物理连接仍执行原生 REALITY 认证，不跨两腿或身份复用握手材料。
+实际租约同时受对端 HTTP/2 并发 stream 额度约束；收到 GOAWAY 后新逻辑请求另建物理连接，现有流继续排空，不重放已发送正文。
+域名、动态组/代理上游、文件客户端证书、动态 ECH、ShadowTLS、opaque protect、DNS/source/interface binding、自动出口发现、非 dual IP-version、MPTCP 和 Windows adapter binding 保持原独立路径；请求 TCP-control 的逻辑建链也独立。它们仍受支持，不增加配置拒绝。
+每次逻辑租约保留原路径预检：LazyDirect 使用字面端点 resolver，预解析 Direct 保留其端点而不新增 resolver 依赖，两者均保留 deadline/cancellation/地址族/IP4P 检查；Dialer 停机、节点 Stop、物理连接退役及原建链期限也覆盖等待池创建与命中活动连接的路径。mark、TFO、TLS 参数、HTTP 请求模板及队列预算保持原腿配置，不通过新默认 Dialer 重拨。
+最后一个租约释放后立即移出候选池，并进入既有的有界传输收尾流程，不保留空闲候选。
+这限制了并行连接的重复开销，不是全节点业务准入额度。
+`{}` 启用显式复用池，使用下表默认值与有界空闲缓存。
+下载配置缺省继承整个主腿 reuse 对象，显式对象整体替换，未填写项回到零，不逐字段继承。
 
 | 字段 | 语义 |
 | --- | --- |
@@ -75,31 +107,90 @@ packet-up 在发送间隔内聚合小块写入，而不是把每个 write 变成
 
 前五项接受 0–i32::MAX 的字符串区间。h-max-request-times 和 h-max-reusable-secs 只有最大值为零才禁用；例如 `"0-1"` 采样到零仍按零预算或立即到期处理。c-max-reuse-times 则与 Mihomo 一样，采样值为零即不启用该项限制。两腿池与计数独立。已建物理连接保持原上游选择；创建新连接时才使用当前选择。H1 仅复用完整结束的上传请求连接，不复用取消的下载 GET。节点空闲缓存有界；它不构成业务流数量额度。
 
-## VLESS sing-mux
-
-节点级 `smux` 接受 enabled、protocol、max-connections、min-streams、max-streams、padding、only-tcp。enabled 默认 false；protocol 默认 h2mux，也支持 smux v1/yamux。计数是 0–i32::MAX 整数；正 max-connections 与正 max-streams 互斥。padding、only-tcp 默认 false。Vision 与启用的 sing-mux 互斥。
-
-空闲物理会话优先复用；max-connections>0 分支按连接数量与 min-streams 扩容，否则按 max-streams 阈值复用。max-connections=max-streams=0 时 min-streams 归一为 8，但不会将其解释为所有调度分支的硬额度。单流关闭不关闭兄弟流，节点 Stop 才取消和等待所有自有驱动。
-
-每条逻辑流的状态字节沿用该次建链的绝对期限；读取前先检查超时，状态已缓冲也不例外。
-物理连接复用不重置期限；状态已确认后的业务读取不受原建链期限限制。
-
-smux 单流 shutdown 先等待已接受帧写入并 flush，再安排 FIN；h2mux 同样等待数据
-到达上游 IO 的 flush 边界再 reset。节点 Stop 或 Drop 可取消待写，不承诺异常终止交付。
+## 通用 sing-mux
+
+所有已启用的普通节点协议都接受 `smux`，字段为 enabled、protocol、max-connections、min-streams、max-streams、padding、only-tcp、statistic、brutal-opts。enabled 默认 false；protocol 缺省/空为 h2mux，也支持 smux v1/yamux。计数为带符号平台整数；负阈值禁用，两个正 max 字段同时配置时采用 max-connections 分支。padding、only-tcp、statistic 默认 false。Vision 与启用的 sing-mux 互斥。精简构建可独立启用 `sing-mux`，不要求 VLESS；未启用此 feature 时拒绝 enabled=true。
+
+`smux.brutal-opts` 接受 `enabled/up/down`。enabled 默认 false；带宽默认为零，
+裸数或纯数字字符串以 Mbps 为单位，也接受十进制 K/M/G/T 的 bps/Bps，b 表示位、
+B 表示字节。速率转换检查整数溢出；不接受小数、负数或二进制单位。
+开启后，每条新物理会话在业务准入前，沿同一个绝对建链期限完成一次 Mihomo
+sing-mux 带宽协商；控制目标不进入业务路由、DNS 或连接表。down 告知服务端本端
+接收带宽，远端拒绝、截断、无效回复或超时使本次物理会话失败，错误不包含远端消息。
+本地是否安装 TCP Brutal 模块不影响远端协商。Linux 上，HTTP/SOCKS5、
+VLESS/VMess 的 RAW 或 WS、Trojan 的 RAW 或 WS，以及不启用插件 mux 的 SS2022，
+可在确认独占且直连的物理 TCP 上设置本地发送侧 Brutal，速率取 up 与服务端接收
+带宽的较小值。保护、绑定与普通拨号路径相同，TFO 使用同一个受控 socket。
+其它平台、MPTCP、dialer-proxy 的代理首跳、gRPC/XHTTP、共享池、多腿和 QUIC
+路径只协商远端发送侧，不透传本地 socket 控制能力。
+
+Core 不安装或加载内核模块，不修改全局拥塞控制与系统规则。模块缺失、本地
+速率不适用或本地参数设置失败不把远端成功变成协商失败；参数设置失败会尝试
+恢复原拥塞控制，恢复失败则终止该物理 socket，避免保留意外默认发送速率。
+控制能力由物理 IO 所有者管理，关闭后立即失效，不复制 socket 或延长 Stop。
+
+开启 Brutal 时，同一节点池同时只准入一条物理会话，不按 max-connections、
+min-streams 或 max-streams 扩容。yamux 仍保留累计 64 流退役边界，协商控制流
+也占一个流 ID；退役后等待既有租约全部释放，再为新请求建立会话，不并行复制
+完整配置带宽。等待使用调用方原期限，可被 Stop 取消；现有业务与关闭语义保持。
+
+`statistic: true` 在 Running Session 的连接注册表记录每条真实底层认证流，类型 Inner、
+目标 sp.mux.sing-box.arpa:444，节点和 provider 名称共享不可变文本。复用流共用一条
+Inner 记录。它的字节单独可见，不重复计入业务 uploadTotal/downloadTotal；Controller
+关闭此记录会终止底层 I/O 和所有兄弟复用流。退出/Stop 同步回收 driver 与记录。
+
+空闲物理会话优先复用；max-connections>0 分支按连接数量与 min-streams 扩容，否则按 max-streams 阈值复用。两个 max 字段字面值均为零时 min-streams 归一为 8；归一在负阈值禁用之前执行，不把该值解释为所有调度分支的硬额度。每节点和资源代际的池独立，单流关闭不关闭兄弟流，节点 Stop 才取消和等待所有自有驱动。
+
+物理建链、mux 请求元数据与 Brutal 控制协商沿用调用方的原绝对期限，复用不重置期限。
+业务流在首个正长度 payload 写入被底层接受，或读取到合法成功状态后，结束 setup 计时；
+因此纯上传可持续运行，不因对端尚未产生下行 HTTP headers 或 mux 状态而超时。
+无业务首写时，首次读取与写入仍检查原期限；空 write、flush、shutdown 和空 read 不解除它。
+期限结束前未建立的流关闭 IO 与租约；迟到状态不能复活。解除期限后仍完整校验状态，
+拒绝、非法状态或截断照常失败；不改变单流关闭、兄弟流与节点 Stop 的所有权。
+
+smux v1 单流 shutdown 先等待已接受帧写入并 flush，再安排 FIN 并结束整条逻辑流。
+smux 的物理读写循环都遵守每轮 I/O 处理预算，主动让出调度。接收帧共用每连接 4 MiB 的分配预算，逐帧计入负载与管理费用，整帧释放后归还；有界单流队列的槽数由总预算推导，避免在总预算尚有余量时阻塞兄弟流。本地关闭立即释放排队数据，远端 FIN 仍在已收 DATA 排空后返回 EOF；写队列、flush 和帧顺序保持。
+VLESS XHTTP、无 VLESS Encryption 且未启用 sing-mux padding 时，smux DATA 帧的完成仅表示
+帧已完整进入自主驱动的底层 IO，不逐帧等待 POST 确认。显式 flush 仍通过同一有界命令队列
+等待真实底层 flush，shutdown 与 FIN 的顺序不变；其它路径保持逐批强 flush。
+该路径的 UDP 首帧保留原期限内的 setup flush，后续完整帧由 XHTTP 自有任务推进。
+最多仍保留一个待写 UDP 帧；取消后的偏移、首帧期限和 Stop 屏障保持。
+VLESS 的 PacketUp XHTTP、无 VLESS Encryption 且无 sing-mux padding 时，h2mux
+普通 DATA 先申请既有 h2 容量，实际移交 Connection 驱动后返回；不逐帧等待 POST 确认。
+每个逻辑写端以固定确认状态合并进度，每次物理 flush 前至多登记一次；不按 DATA 分配
+oneshot，也不增加 payload 队列。显式 flush、元数据与首 UDP 帧仍等待真实底层 flush；
+后续 UDP 尾帧无需额外 write 即可推进。其它 h2mux 和普通 gRPC/legacy H2/CONNECT 保持原行为。
+该私有路径在底层实际写出字节、但强 flush 尚待完成时，主动再调度一次已有的 H2 驱动，
+使已排队 DATA 继续填充同一有界 PacketUp 批次。没有新写入进度便不重复唤醒，
+也不提前完成 flush 确认；显式 flush、FIN 与 Stop 仍遵守原屏障。
+h2mux 和 yamux 关闭上传后保留读取与租约，允许对端继续发送尾部；h2mux 的上传
+数据须到达上游 IO 的 flush 边界再发送 END_STREAM。节点 Stop 或 Drop 可取消待写，
+不承诺异常终止交付。
 
 yamux 的内部资源边界是单物理连接累计分配 64 个流后退役；旧流继续，新请求另建连接，空闲即回收。该边界避免逻辑取消与库内 reset 回收不同步时误关兄弟流，不是全节点额度，详见 [资源策略](runtime-resource-policy.md)。
 
-sing-mux 的外层是普通 VLESS TCP 到约定目标，**不是 VLESS CommandMux/XUDP**。only-tcp=false 时 UDP 使用 mux 的逐包地址格式，经受控解析处理域名；true 时保留所选 raw/XUDP/packetaddr 编码。`udp: false` 始终禁止业务 UDP。padding 覆盖握手及最初 16 个物理写入帧；接收增量解析和丢弃 padding，不按声明长度无限分配。
+同一 UDP 来源、相同具体节点且目标 IP 无需还原时，多个目标共享一条逐包地址 mux 流；
+Controller 仍逐目标记录与关闭业务连接。域名、fake-IP 和 QUIC 目标覆盖继续使用独立流，
+避免响应地址歧义。发送至多保留一个受报文预算约束的帧及其写入进度，取消不会丢失
+已提交的前缀；下一次发送或接收先完成该帧与所需的 flush，再处理新报文。首帧仍受原建链
+期限约束，取消不会延长期限；实际 I/O 错误、超时与节点 Stop 终止该逻辑 UDP 流。
+显式关闭丢弃未完成帧并释放 IO，不额外等待发送；接收侧继续增量解析并保留取消进度。
+
+sing-mux 的外层是底层协议的普通 TCP 到 `sp.mux.sing-box.arpa:444`，VLESS 使用 CommandTCP。对端必须提供 sing-mux 解码；普通 HTTP/SOCKS5 服务器不会自动解码，接受包装配置不等于默认服务器互通。only-tcp=false 时 UDP 使用 mux 的逐包地址格式，经受控解析处理域名，并提供有效 UDP 能力，即使底层 `udp: false`；true 时原样委托底层 UDP，保留其能力、编码、会话和预算。组 disable-udp 仍限制业务。padding 覆盖握手及最初 16 个物理写入帧；接收增量解析和丢弃 padding，不按声明长度无限分配。
 
 ## 关闭、安全与验收边界
 
-XHTTP 按 Mihomo 整条逻辑连接关闭：shutdown 先尝试送完已接受的上传，再取消下载，
+XHTTP 关闭整条逻辑连接：shutdown 先尝试送完已接受的上传，再取消下载，
 所有模式的待决上传最多等待一秒；超时或节点 Stop 可以取消，异常终止不承诺交付。
-H1/H2 flush 等待已接受的 payload 到达所供应 IO 的 flush 边界；H3 flush 等待上传任务
-写入 QUIC，shutdown 进一步等待该请求上传的 QUIC 确认，再释放物理连接租约。
+H1/H2 流式 flush 等待已接受的 payload 到达所供应 IO 的 flush 边界；H3 stream-one / stream-up
+flush 等待上传任务写入 QUIC。packet-up flush 等每批 POST 的成功响应与有界响应 body 结束。
+shutdown 提交上传 FIN 后释放物理连接租约，不提供逐请求的远端 ACK 屏障。
 这些等待不依赖下载响应。需要完整回复的应用必须在关闭前读完；不承诺 TCP 半关闭
 后继续收到尾包。复用只延长物理 transport 生命周期，不改变单个逻辑连接的关闭范围。
 
-H3 的 QUIC 驱动、数据报适配器和后台任务归节点所有。Stop 先执行有界关闭交换，再取消/join 内部任务和上游 IO，不把 Drop 或“等一会儿资源消失”当作完成屏障。
+H3 的 QUIC 驱动、数据报适配器和后台任务归节点所有。物理连接退役立即停止新请求准入，
+在既有一秒关闭预算内继续发送和接收，再关闭并 join 内部任务与上游 IO；这段传输收尾
+不构成远端 ACK 屏障。未完成的上传取消会 reset 当前请求，已提交 FIN 的发送不因此 reset，
+兄弟流继续。shutdown 返回不代表物理驱动已退出；Stop 返回以任务回收为准，不把 Drop 或等待时间当作完成证明。
 
 H1/H2 原生验证优先使用官方 latest Mihomo；H3 使用官方 latest Xray。不被 Xray 直接解码的 packetaddr/sing-mux 使用明确标注的 Xray XHTTP → Mihomo VLESS 分层拓扑；mTLS 使用已批准的 xcaddy/Caddy H3 网关，后端仍是同一个 Xray handler。分层成功不改写直接对端失败。所有服务端与原站在隔离容器中，配置和私钥不入 Git；原生数据、公共入口、资源、跨平台构建和阶段签收分别记录。
diff --git a/packaging/linux/50-vole-resolved.rules b/packaging/linux/50-vole-resolved.rules
new file mode 100644
index 0000000..c23f640
--- /dev/null
+++ b/packaging/linux/50-vole-resolved.rules
@@ -0,0 +1,12 @@
+// Installed authorization for the group allowed to execute the VPN binary.
+polkit.addRule(function(action, subject) {
+    var actions = [
+        "org.freedesktop.resolve1.set-dns-servers",
+        "org.freedesktop.resolve1.set-domains",
+        "org.freedesktop.resolve1.set-default-route",
+        "org.freedesktop.resolve1.revert"
+    ];
+    if (subject.isInGroup("vole") && actions.indexOf(action.id) !== -1) {
+        return polkit.Result.YES;
+    }
+});
diff --git a/packaging/linux/post-install b/packaging/linux/post-install
new file mode 100755
index 0000000..4439aa9
--- /dev/null
+++ b/packaging/linux/post-install
@@ -0,0 +1,7 @@
+#!/bin/sh
+# Run from deb postinst or rpm %post after placing the root-owned binary/rule.
+set -eu
+getent group vole >/dev/null || groupadd --system vole
+chown root:vole /usr/bin/vole
+chmod 0750 /usr/bin/vole
+setcap cap_net_admin=ep /usr/bin/vole
diff --git a/readme/README.ru.md b/readme/README.ru.md
index 7b6f811..a5987d0 100644
--- a/readme/README.ru.md
+++ b/readme/README.ru.md
@@ -6,36 +6,44 @@
 
 Vole — прокси-ядро на Rust для VPN-клиентов и локальных прокси, доступное как нативная библиотека и CLI переднего плана. Оно маршрутизирует TCP/UDP-трафик через прямые соединения, прокси-узлы, группы и цепочки, объединяя DNS, GeoData и кроссплатформенную плоскость данных TUN.
 
-Конфигурация использует **совместимый с Mihomo YAML в пределах поддерживаемых возможностей**. Vole ориентирован на клиентские функции и не реализует все поля Mihomo или его полный Dashboard API.
+Конфигурация использует **YAML в стиле Mihomo в пределах поддерживаемых возможностей**. Приоритет Vole — оптимизация памяти и достижение целевой пропускной способности. Совместимость означает взаимодействие с listener Mihomo и официальными серверами протоколов без требования одинакового поведения каждого поля; см. [принципы совместимости](../docs/mihomo-compatibility.md#兼容原则).
 
 ## Что умеет Vole
 
 - **Принимать трафик приложений и VPN:** пересылка HTTP, CONNECT и Upgrade; SOCKS5 CONNECT и UDP ASSOCIATE; IPv4/IPv6-пакеты TUN, предоставленные хостом.
-- **Маршрутизировать по назначению:** правила по домену, суффиксу или ключевому слову домена, IP CIDR, порту назначения, TCP/UDP, GeoSite и GeoIP, с явными действиями DIRECT и REJECT.
-- **Выбирать прокси и строить цепочки:** вложенные группы `select`, переключение групп во время работы и цепочки `dialer-proxy`, ссылающиеся на узлы или группы. Изменения выбора применяются к новым физическим транспортным соединениям, не перенося существующие.
-- **Обрабатывать DNS:** управляемые UDP/TCP-серверы, политики выбора серверов по GeoSite, последовательное переключение при отказе, кеширование и объединение одинаковых запросов; перехват заданных TCP/UDP DNS-адресов в TUN (по умолчанию порт 53).
-- **Определять трафик для маршрутизации:** извлечение домена из HTTP, TLS и QUIC, а также DNS-подсказки TUN, без изменения фактического назначения. На ICMPv4/ICMPv6 Echo ядро отвечает локально.
-- **Управлять данными маршрутизации:** загрузка используемых категорий из `geosite.dat` / `geoip.dat` по запросу и обновление файлов через заданный маршрут. GeoSite поддерживает Domain, Full, Plain и Regex, пересечение атрибутов и инверсию; GeoIP поддерживает инверсию. На всех платформах выбранные записи сохраняются без жёсткого лимита количества или усечения; общая квота памяти GeoData не задана. См. [границы GeoData](../docs/geodata.md#内存与安全边界).
-- **Предоставлять средства управления клиенту:** Controller на loopback-интерфейсе для выбора групп, текущей скорости и общего объёма TUN-трафика, а также изолированное измерение задержки узлов и цепочек через Invoke API.
+- **Маршрутизировать трафик:** режимы rule/global/direct; домены, IP и порты источника и назначения, TCP/UDP, GeoSite/GeoIP, наборы правил и логические условия; правила процессов/UID на поддерживаемых платформах, именованные direct/dns/reject и встроенные действия маршрутизации.
+- **Выбирать прокси и строить цепочки:** вложенные группы select/url-test/fallback/load-balance, проверки доступности и сохранение выбора; `dialer-proxy` ссылается на узлы или группы. Существующие соединения сохраняют свой маршрут.
+- **Обрабатывать DNS:** hosts, отдельные bootstrap/узловые/прямые резолверы, UDP/TCP/DoH/DoT/DoQ, политики по доменам/GeoSite/rule-set, fallback, ограниченный кеш, redir-host и постоянные fake-IP; перехват DNS в TUN по конфигурации.
+- **Определять трафик для маршрутизации:** HTTP/1, HTTP/2 и TLS для TUN и mixed TCP; QUIC v1/v2 для TUN и ассоциаций SOCKS5 UDP, условия принудительного анализа и исключения, настраиваемая замена назначения. Ответы на ICMPv4/ICMPv6 Echo формируются локально.
+- **Управлять ресурсами:** HTTP/file/inline providers узлов и правил, подписки URI/Base64/AGE, динамические группы, фильтры и переопределения; YAML/Text и domain/ipcidr MRS. GeoData полностью загружает выбранные категории, поддерживает маршрутизируемые загрузки и периодические обновления; ошибки обновления сохраняют рабочее состояние. См. [границы GeoData](../docs/geodata.md#内存与安全边界).
+- **Предоставлять управление:** состояние групп и ресурсов, список и закрытие соединений, счётчики правил, действующая конфигурация, ограниченные потоки WebSocket и DNS-диагностика; поддерживаемые обновления конфигурации, метрики TUN и изолированное измерение задержки. Границы обновлений описаны в [контракте Controller](../docs/controller-api.md).
+- **Обрабатывать выбранный HTTP-трафик:** переписывание URL и перенаправления; выборочный MITM для явно разрешённых HTTPS-доменов с CA от хоста и ограниченная потоковая передача H1/H2. Используется [отдельная HTTP-конфигурация](../docs/http-processing.md).
 
 ## Прокси-протоколы
 
-Все восемь протоколов ниже включены в сборку по умолчанию. Поддержка UDP настраивается для каждого узла.
+В сборке по умолчанию включены перечисленные ниже протоколы. Поддержка UDP зависит от режима протокола и конфигурации узла.
 
 | Протокол | Возможности |
 | --- | --- |
-| [VLESS](../docs/vless.md) | TCP, WebSocket / HTTPUpgrade, gRPC, HTTP-маскировка первого пакета, legacy H2, [XHTTP H1/H2/H3](../docs/xhttp.md); Vision, Encryption, REALITY, JLS, статический ECH и sing-mux в поддерживаемых сочетаниях |
-| [VMess AEAD](../docs/outbounds.md#vmess-aead) | TCP, WebSocket / HTTPUpgrade, gRPC, HTTP-маскировка первого пакета и legacy H2; TCP/UDP, транспорт без TLS или со стандартным TLS |
+| [VLESS](../docs/vless.md) | TCP, WebSocket / HTTPUpgrade, gRPC, HTTP-маскировка первого пакета, legacy H2, [XHTTP H1/H2/H3](../docs/xhttp.md); Vision, Encryption, REALITY, JLS, ECH и sing-mux в поддерживаемых сочетаниях |
+| [VMess AEAD](../docs/outbounds.md#vmess-aead) | TCP, WebSocket / HTTPUpgrade, gRPC, HTTP-маскировка первого пакета и legacy H2; TCP/UDP, транспорт без TLS или с поддерживаемыми режимами TLS |
 | [Trojan](../docs/outbounds.md#trojan) | TCP/UDP через TLS TCP, WebSocket / HTTPUpgrade или gRPC |
-| [Shadowsocks 2022](../docs/outbounds.md#shadowsocks-2022) | TCP/UDP; AES-128-GCM, AES-256-GCM и ChaCha20-Poly1305; цепочки идентификации AES; опциональный strict ShadowTLS v3 для TCP и UoT v2 |
+| [Shadowsocks 2022](../docs/outbounds.md#shadowsocks-2022) | TCP/UDP; три алгоритма 2022 и цепочки идентификации AES; плагины obfs, WebSocket, JLS или strict ShadowTLS v3; UoT v2 |
 | [AnyTLS](../docs/outbounds.md#anytls) | TLS-сессии и UDP over TCP v2 |
+| [HTTP / HTTPS CONNECT](../docs/outbounds.md#http--https-connect) | TCP CONNECT, опциональная аутентификация прокси и TLS |
 | [SOCKS5](../docs/outbounds.md#socks5) | CONNECT и UDP ASSOCIATE, с опциональной аутентификацией по имени пользователя и паролю |
-| [Hysteria2](../docs/outbounds.md#hysteria2) | TCP/UDP через QUIC, управление пропускной способностью, Salamander, смена портов и mTLS |
-| [TUIC v5](../docs/outbounds.md#tuic-v5) | TCP/UDP через QUIC, режимы передачи UDP native/quic и выбор алгоритма управления перегрузкой |
+| [Hysteria2](../docs/outbounds.md#hysteria2) | TCP/UDP через QUIC, управление пропускной способностью, Salamander/Gecko, смена портов или Realm/STUN и mTLS |
+| [TUIC v5](../docs/outbounds.md#tuic-v5) | TCP/UDP через QUIC, native/quic UDP, UoT v2, выбор алгоритма управления перегрузкой; `disable-sni` сохраняет проверку сертификата |
+| [WireGuard](../docs/outbounds.md#wireguard) | TCP/UDP через стандартный WireGuard, несколько пиров и DNS узла, с пользовательским IP-стеком |
+| [TrustTunnel](../docs/outbounds.md#trusttunnel) | TCP/UDP через H2/H3 CONNECT; аутентификация, проверки состояния, mTLS и ECH |
+| [Mieru](../docs/outbounds.md#mieru) | TCP/UDP через транспорт TCP или UDP; мультиплексирование, STANDARD/NO-WAIT и traffic-pattern |
+| [MASQUE](../docs/outbounds.md#masque) | TCP/UDP через H2/H3 CONNECT-IP; режим H3 L4 поддерживает только TCP |
 
-Стандартные TLS-соединения поддерживают проверку сертификатов и закрепление сертификата по SHA-256. Поддерживаемые TCP-пути с TLS могут использовать шаблоны ClientHello Chrome, Firefox или Safari; `client-fingerprint` не зависит от `fingerprint` сертификата. Точные имена и сочетания описаны в [профилях TLS и политике сертификатов](../docs/tls-client-fingerprint.md). Эти функции не гарантируют неотличимость от браузера или произвольные сочетания протоколов.
+VMess, VLESS, Trojan и AnyTLS поддерживают ShadowTLS v3 или JLS на своих поддерживаемых TCP-транспортах; VMess и Trojan также поддерживают REALITY. Ограничения транспортов и взаимоисключение режимов описаны в [общем контракте потоковой безопасности](../docs/outbounds.md#流式安全身份).
 
-SS2022 использует официальную Rust-библиотеку без изменений; известные риски пустой первой записи, сценария server-first и padding описаны в [контракте Shadowsocks](../docs/outbounds.md#shadowsocks-2022).
+Стандартные TLS-соединения поддерживают проверку сертификатов и закрепление сертификата по SHA-256. Поддерживаемые TCP-пути с TLS могут использовать шаблоны ClientHello Chrome, Firefox, Safari или iOS; `client-fingerprint` не зависит от `fingerprint` сертификата. Точные имена и сочетания описаны в [профилях TLS и политике сертификатов](../docs/tls-client-fingerprint.md). Эти функции не гарантируют неотличимость от браузера или произвольные сочетания протоколов.
+
+SS2022 использует официальные Rust-криптографию и кодеки без изменений; Vole инициализирует padding и обрабатывает server-first. См. [контракт Shadowsocks](../docs/outbounds.md#shadowsocks-2022).
 
 ## Конфигурация в стиле Mihomo
 
@@ -70,13 +78,13 @@ rules:
   - MATCH,Proxy
 ```
 
-Замените адрес сервера и учётные данные в примере. Для правил GeoSite/GeoIP нужны соответствующие файлы в `<dataDir>/geodata`; без них эти типы правил недоступны. См. [полный справочник конфигурации](../docs/config.yaml) и [поведение GeoData](../docs/geodata.md).
+Замените адрес сервера и учётные данные. GeoSite/GeoIP используют файлы в `<dataDir>/geodata`; отсутствующие необходимые ресурсы загружаются через заданный маршрут. До успешной загрузки соответствующие правила недоступны. См. [конфигурацию](../docs/config.yaml) и [поведение GeoData](../docs/geodata.md).
 
 `mixed-port` принимает HTTP и SOCKS5 на одном TCP-порту и включает SOCKS5 UDP на том же порту. `allow-lan` управляет адресом привязки независимо от `authentication`: если `authentication` отсутствует или равен `[]`, аутентификация не требуется ни на loopback, ни на всех интерфейсах; заданные учётные данные проверяются HTTP и SOCKS5. Поля верхнего уровня `port`, `socks-port`, `udp` и `listeners` отклоняются; `port` и `udp` прокси-узла сохраняют смысл параметров исходящего соединения.
 
-Совместимость ограничена документированными полями и поведением и не распространяется на произвольные конфигурации Mihomo. Группы пока поддерживают статический `select`; DNS-серверы задаются буквальными IP-адресами и используют UDP/TCP. Providers, автоматический выбор в группах, зашифрованный DNS и fake-IP не входят в текущий набор возможностей. Неизвестные поля и недопустимые сочетания отклоняются, а не игнорируются; особенности семантики Vole отмечены в соответствующих контрактах.
+Поддерживается документированное подмножество конфигурации Mihomo. Неизвестные поля и неподдерживаемые сочетания отклоняются. Ограничения платформ и протоколов описаны в [границах совместимости](../docs/mihomo-compatibility.md) и соответствующих контрактах.
 
-Хост запускает экземпляр библиотеки с inline `configYaml`; устройство TUN, дескриптор, MTU, перехват DNS и тайм-аут UDP задаются в `tun`. Платформенные callbacks регистрируются локально в runtime. CLI передаёт параметры через тот же Invoke API, чья операция foreground читает файл `-f`. Адреса интерфейса, DNS и системные маршруты настраивает хост.
+Хост запускает экземпляр библиотеки с inline `configYaml`; устройство TUN, дескриптор, MTU, перехват DNS и тайм-аут UDP задаются в `tun`. Платформенные callbacks регистрируются локально в runtime. CLI передаёт параметры через тот же Invoke API, чья операция foreground читает файл `-f`. Для собственного TUN в Linux ядро поддерживает автоматические маршруты и DNS через systemd-resolved; заимствованные fd и сеть платформ приложений остаются под управлением хоста.
 
 ## CLI
 
@@ -97,12 +105,12 @@ vole -t -f ./config.yaml
 | iOS / macOS | Дескриптор utun от хоста; macOS также может открыть или создать нативный utun |
 | tvOS 17+ | Дескриптор файла utun, предоставленный хостом; ARM64-устройства и симулятор |
 | Android | Дескриптор `VpnService` с защитой исходящих сокетов |
-| Linux | Настоящий raw-IP TUN с одной очередью через заимствованный fd или устройство, открытое ядром; системную сеть настраивает хост |
+| Linux | Настоящий raw-IP TUN с одной очередью через заимствованный fd или устройство, открытое ядром; собственный TUN в Linux поддерживает автоматические маршруты и системный DNS |
 | Windows | Взаимоисключающие сборки `windows-wintun` для настольного процесса и `windows-uwp` для пакетного Provider/Session Host; общее ядро |
 
-Vole предоставляет нативные библиотеки и CLI; настройка системной сети остаётся обязанностью хоста. На Unix исходный дескриптор TUN принадлежит хосту; Vole использует и закрывает собственную копию. Публичный API packetFlow от Apple не гарантирует доступ к raw fd, поэтому интеграция с Network Extension и проверка на устройствах остаются ответственностью хоста. См. [интеграцию TUN](../docs/tun-platform.md) и [границы приёмки платформ](../docs/acceptance.md).
+Vole предоставляет нативные библиотеки и CLI. На Apple, Android и Windows системной сетью и жизненным циклом приложения управляет хост; собственный TUN в Linux дополнительно поддерживает автоматические маршруты и системный DNS. На Unix исходный дескриптор TUN принадлежит хосту; Vole использует и закрывает собственную копию. Публичный API packetFlow от Apple не гарантирует доступ к raw fd, поэтому интеграция с Network Extension и проверка на устройствах остаются ответственностью хоста. См. [интеграцию TUN](../docs/tun-platform.md) и [границы приёмки платформ](../docs/acceptance.md).
 
-Настольный Wintun загружает предоставленный хостом `wintun.dll` из каталога исполняемого файла процесса. Адреса интерфейса, DNS, маршруты и физический выход настраивает хост; проверка Wintun на устройстве независима от результатов пакетного VPN. Использование CLI и поставка описаны в [документации CLI и релизов по тегам](../docs/cli.md).
+Настольный Wintun загружает предоставленный хостом `wintun.dll` из каталога исполняемого файла процесса. Адреса интерфейса, DNS, маршруты и физический выход настраивает хост; Wintun и пакетный UWP требуют отдельных проверок на устройстве. Использование CLI и поставка описаны в [документации CLI и релизов по тегам](../docs/cli.md).
 
 Кроссплатформенный C ABI принимает JSON-запросы через Invoke API:
 
@@ -113,20 +121,11 @@ void VoleFree(char *response);
 
 Один публичный экземпляр проходит жизненный цикл `initialize → createInstance → start(configYaml) → stop → destroyInstance`; подготовка выполняется внутри `start`. `validateConfig` не требует инициализации. CLI использует явную операцию foreground Invoke для файлов, окружения, сигналов и очистки. API также предоставляет запросы состояния, статус GeoData и измерение задержки. См. [Invoke API](../docs/invoke-api.md), [Controller API](../docs/controller-api.md) и [пример интеграции Windows](../example/windows-uwp/README.md).
 
-## Benchmark
-
-[**TUN-бенчмарк Vole / Mihomo**](https://github.com/YuanDevTeam/container-benchmark) содержит воспроизводимую методику, результаты измерений и сравнительные графики для обоих ядер в одинаковой среде с нативным Linux TUN.
-
-Проект benchmark также выполняет проверку совместимости протоколов (`interop`) и тесты нагрузки на память (`stress`), используя явно указанный checkout `--source vole=PATH`. Собственные скрипты Vole только компилируют ядро и платформенные артефакты.
-
-Он измеряет смешанный TCP/UDP-трафик на **1 / 1,5 / 2 Гбит/с** с **1 000 DNS-запросов/с** и расширенными правилами `geosite:cn` / `geoip:cn`, показывая фактическую пропускную способность, CPU, наблюдаемый пиковый Linux RSS, потери UDP-пакетов и успешные DNS-запросы. Проверяется путь TUN/DNS/маршрутизации с выходом через DIRECT, а не пропускная способность зашифрованных прокси; Linux RSS не отражает потребление памяти Apple Network Extension.
-
-Отдельная команда `stress` использует те же полные категории `geosite:cn` / `geoip:cn` с нагрузкой 2 Гбит/с, 60 секунд и 1 000 DNS-запросов/с. Исходные DAT загружаются без усечения, но в память выбираются только категории CN. Опция `--geodata-update` добавляет реальную загрузку и перезагрузку во время трафика. Типы входных записей, измерения и ошибки приведены в README benchmark. Отдельное наблюдение не гарантирует память ниже 50 000 000 байт для произвольного входа и не заменяет проверку на устройствах Apple.
-
 ## Документация
 
 - [Указатель документации](../docs/README.md)
 - [Справочник конфигурации](../docs/config.yaml)
+- [Границы совместимости с Mihomo](../docs/mihomo-compatibility.md)
 - [Сборка ядра и платформенных артефактов](../scripts/README.md)
 - [CLI и релизы по тегам](../docs/cli.md)
 - [Регрессионные тесты ядра](../tests/README.md)
@@ -138,6 +137,7 @@ void VoleFree(char *response);
 Vole использует публичные зависимости и опирается на реализации протоколов и примеры платформенной интеграции:
 
 - Зависимости TUN: локальный [`vole-netstack`](../crates/vole-netstack/README.md) использует [smoltcp](https://github.com/smoltcp-rs/smoltcp), а пакетный I/O на Unix и Windows Wintun — [tun-rs](https://github.com/tun-rs/tun-rs) (Apache-2.0).
+- WireGuard: [boringtun](https://github.com/cloudflare/boringtun) (BSD-3-Clause), без host-device, FFI и JNI.
 - [Wintun](https://www.wintun.net/): DLL предоставляет хост; Vole её не включает. Исходный [заголовок API](https://github.com/tun-rs/tun-rs/blob/2.8.11/src/platform/windows/tun/wintun.h) в tun-rs имеет copyright 2018–2021 WireGuard LLC и лицензию `GPL-2.0 OR MIT`; при распространении связанных API bindings необходимо сохранить copyright и уведомление об альтернативной лицензии MIT.
 - Архитектурные ориентиры для сети и маршрутизации: [clash-rs](https://github.com/Watfaq/clash-rs), [netstack-smoltcp](https://github.com/cavivie/netstack-smoltcp), [Mihomo](https://github.com/MetaCubeX/mihomo), [Xray-core](https://github.com/XTLS/Xray-core) и [Leaf](https://github.com/eycorsican/leaf). Эти проекты не являются зависимостями netstack.
 - TLS и Shadowsocks: [rustls](https://github.com/rustls/rustls), [boring](https://github.com/cloudflare/boring), [BoringSSL](https://boringssl.googlesource.com/boringssl/) и [shadowsocks-rust](https://github.com/shadowsocks/shadowsocks-rust). Заимствованный код replay-window сохраняет [уведомления MIT](../src/outbound/shadowsocks/packet_window.rs).
diff --git a/readme/README.zh_CN.md b/readme/README.zh_CN.md
index 0585008..b7b0371 100644
--- a/readme/README.zh_CN.md
+++ b/readme/README.zh_CN.md
@@ -6,36 +6,44 @@
 
 Vole 是用于 VPN 客户端和本地代理的 Rust 代理内核，提供原生库和前台 CLI。它通过直连、代理节点、代理组和代理链转发 TCP/UDP 流量，并集成 DNS、GeoData 和跨平台 TUN 数据面。
 
-配置采用**与 Mihomo 兼容的 YAML，兼容范围限于 Vole 已支持的功能**。Vole 聚焦客户端能力，并未实现 Mihomo 的全部字段或完整 Dashboard API。
+配置采用 **Mihomo 风格的 YAML，范围限于 Vole 已支持的功能**。Vole 以内存优化和吞吐达标为第一目标；兼容要求是与 Mihomo listener 和官方协议 server 端互通，不寻求逐字段行为完全一致，见 [兼容原则](../docs/mihomo-compatibility.md#兼容原则)。
 
 ## 内核能做什么
 
 - **接入应用与 VPN 流量：**HTTP 转发、CONNECT 和 Upgrade；SOCKS5 CONNECT 和 UDP ASSOCIATE；宿主提供的 IPv4/IPv6 TUN 数据包。
-- **按目标路由：**支持域名、域名后缀/关键字、IP CIDR、目标端口、TCP/UDP、GeoSite 和 GeoIP 规则，以及明确的 DIRECT 和 REJECT 动作。
-- **选择和串联代理：**支持嵌套 `select` 组、实时切换组选择，以及引用节点或组的 `dialer-proxy` 代理链。选择变化只影响新建的物理传输连接，不迁移既有连接。
-- **处理 DNS：**支持指定出口的 UDP/TCP 上游、基于 GeoSite 的上游策略、顺序故障转移、缓存与重复查询合并；按配置拦截 TUN TCP/UDP DNS 目标，默认 53 端口。
-- **识别流量用于路由：**通过 HTTP、TLS、QUIC 域名嗅探与 TUN DNS 提示辅助路由，不改写实际目标地址。ICMPv4/ICMPv6 Echo 在本地应答。
-- **管理路由数据：**按需从 `geosite.dat` / `geoip.dat` 加载被引用的类别，并通过配置的路由更新文件。GeoSite 支持 Domain、Full、Plain 和 Regex、属性交集及反选；GeoIP 支持反选。所有平台完整保留所选记录，不设条数硬上限或截断，也不设 GeoData 总内存预算。详见 [GeoData 边界](../docs/geodata.md#内存与安全边界)。
-- **提供客户端控制：**回环 Controller 支持代理组选择及 TUN 流量速率/累计量查询；Invoke API 提供隔离的节点/代理链延迟测量。
+- **路由流量：**支持 rule/global/direct 模式，域名、来源/目标 IP 与端口、TCP/UDP、GeoSite/GeoIP、规则集合及逻辑规则；在支持的平台使用进程/UID 规则，提供具名 direct/dns/reject 出站与内置路由动作。
+- **选择和串联代理：**嵌套 select/url-test/fallback/load-balance 组、健康检查与选择持久化；`dialer-proxy` 可引用节点或组。既有连接保留原路径。
+- **处理 DNS：**hosts、独立 bootstrap/节点/直连解析角色，UDP/TCP/DoH/DoT/DoQ、域名/GeoSite/rule-set policy、fallback、有界缓存、redir-host 和持久 fake-IP；按配置接管 TUN DNS。
+- **识别流量用于路由：**TUN/mixed TCP 的 HTTP1/HTTP2/TLS 嗅探与 TUN、SOCKS5 UDP 关联的 QUIC v1/v2 嗅探，支持强制/排除条件和目标覆盖开关；本地应答 ICMPv4/ICMPv6 Echo。
+- **管理路由数据：**HTTP/file/inline 节点与规则 providers、URI/Base64/AGE 订阅、动态组、筛选和覆盖；YAML/Text 及 domain/ipcidr MRS。GeoData 完整加载引用类别，支持指定出口下载和周期更新，坏更新保留旧状态。详见 [GeoData 边界](../docs/geodata.md#内存与安全边界)。
+- **提供客户端控制：**组与资源状态、连接快照与关闭、规则命中、有效配置、有界 WebSocket 推送和 DNS 诊断；支持范围内的配置更新、TUN 流量与隔离的节点/代理链延迟测量。更新边界见 [Controller 契约](../docs/controller-api.md)。
+- **处理选定的业务 HTTP：**URL 改写和重定向，可使用宿主提供的 CA 对明确授权的 HTTPS 域名进行选择性解密，并以有界 H1/H2 流式转发。使用[独立 HTTP 配置](../docs/http-processing.md)。
 
 ## 代理协议
 
-默认构建启用下列全部八种协议。UDP 支持按节点配置。
+默认构建启用下列协议。UDP 支持以协议模式和节点配置为准。
 
 | 协议 | 能力 |
 | --- | --- |
-| [VLESS](../docs/vless.md) | TCP、WebSocket / HTTPUpgrade、gRPC、HTTP 首包伪装、传统 H2、[XHTTP H1/H2/H3](../docs/xhttp.md)；在支持的组合中提供 Vision、Encryption、REALITY、JLS、静态 ECH 和 sing-mux |
-| [VMess AEAD](../docs/outbounds.md#vmess-aead) | TCP、WebSocket / HTTPUpgrade、gRPC、HTTP 首包伪装和传统 H2；TCP/UDP，明文或标准 TLS |
+| [VLESS](../docs/vless.md) | TCP、WebSocket / HTTPUpgrade、gRPC、HTTP 首包伪装、传统 H2、[XHTTP H1/H2/H3](../docs/xhttp.md)；在支持的组合中提供 Vision、Encryption、REALITY、JLS、ECH 和 sing-mux |
+| [VMess AEAD](../docs/outbounds.md#vmess-aead) | TCP、WebSocket / HTTPUpgrade、gRPC、HTTP 首包伪装和传统 H2；TCP/UDP，明文或支持的 TLS 模式 |
 | [Trojan](../docs/outbounds.md#trojan) | 通过 TLS TCP、WebSocket / HTTPUpgrade 或 gRPC 传输 TCP/UDP |
-| [Shadowsocks 2022](../docs/outbounds.md#shadowsocks-2022) | TCP/UDP；AES-128-GCM、AES-256-GCM 和 ChaCha20-Poly1305；AES 身份链；可选 strict ShadowTLS v3 TCP 包装和 UoT v2 |
+| [Shadowsocks 2022](../docs/outbounds.md#shadowsocks-2022) | TCP/UDP；三种 2022 算法与 AES 身份链；可选 obfs、WebSocket、JLS 或 strict ShadowTLS v3 插件；UoT v2 |
 | [AnyTLS](../docs/outbounds.md#anytls) | TLS 会话与 UDP over TCP v2 |
+| [HTTP / HTTPS CONNECT](../docs/outbounds.md#http--https-connect) | TCP CONNECT、可选代理认证与 TLS |
 | [SOCKS5](../docs/outbounds.md#socks5) | CONNECT 和 UDP ASSOCIATE，可选用户名/密码认证 |
-| [Hysteria2](../docs/outbounds.md#hysteria2) | QUIC TCP/UDP、带宽控制、Salamander、端口跳跃和 mTLS |
-| [TUIC v5](../docs/outbounds.md#tuic-v5) | QUIC TCP/UDP、native/quic UDP 转发模式，以及可选的拥塞控制算法 |
+| [Hysteria2](../docs/outbounds.md#hysteria2) | QUIC TCP/UDP、带宽控制、Salamander/Gecko、端口跳跃或 Realm/STUN，以及 mTLS |
+| [TUIC v5](../docs/outbounds.md#tuic-v5) | QUIC TCP/UDP、native/quic UDP 转发、UoT v2、拥塞控制选择；`disable-sni` 仍保留证书验证 |
+| [WireGuard](../docs/outbounds.md#wireguard) | 标准 WireGuard TCP/UDP、多 peer 与节点 DNS，使用用户态 IP 栈 |
+| [TrustTunnel](../docs/outbounds.md#trusttunnel) | H2/H3 CONNECT 承载 TCP/UDP，支持认证、健康检查、mTLS 和 ECH |
+| [Mieru](../docs/outbounds.md#mieru) | TCP/UDP 载体承载 TCP/UDP，支持复用、STANDARD/NO-WAIT 握手与 traffic-pattern |
+| [MASQUE](../docs/outbounds.md#masque) | H2/H3 CONNECT-IP 承载 TCP/UDP；H3 L4 模式仅支持 TCP |
 
-标准 TLS 连接支持证书验证与 SHA-256 证书固定。适用的 TCP TLS 路径可使用 Chrome、Firefox 或 Safari ClientHello 模板；`client-fingerprint` 与证书 `fingerprint` 相互独立。准确的名称和支持组合见 [TLS 配置与证书策略](../docs/tls-client-fingerprint.md)。这些功能不保证与浏览器不可区分，也不支持任意协议组合。
+VMess、VLESS、Trojan 与 AnyTLS 可在各自支持的 TCP 载体上使用 ShadowTLS v3 或 JLS；VMess 与 Trojan 还支持 REALITY。传输限制与身份互斥遵循[共享流式安全约束](../docs/outbounds.md#流式安全身份)。
 
-SS2022 使用未经修改的官方 Rust 库；已知的空首写入、服务端先发送和 padding 风险见 [Shadowsocks 契约](../docs/outbounds.md#shadowsocks-2022)。
+标准 TLS 连接支持证书验证与 SHA-256 证书固定。适用的 TCP TLS 路径可使用 Chrome、Firefox、Safari 或 iOS ClientHello 模板；`client-fingerprint` 与证书 `fingerprint` 相互独立。准确的名称和支持组合见 [TLS 配置与证书策略](../docs/tls-client-fingerprint.md)。这些功能不保证与浏览器不可区分，也不支持任意协议组合。
+
+SS2022 复用未经修改的官方 Rust 加密与编解码，由 Vole 初始化 padding 并处理 server-first，详见 [Shadowsocks 契约](../docs/outbounds.md#shadowsocks-2022)。
 
 ## Mihomo 风格配置
 
@@ -70,13 +78,13 @@ rules:
   - MATCH,Proxy
 ```
 
-请替换示例中的服务器地址与凭据。GeoSite/GeoIP 规则需要 `<dataDir>/geodata` 下的对应数据文件；缺失文件时，相应规则类型不可用。详见[完整配置参考](../docs/config.yaml)与 [GeoData 行为](../docs/geodata.md)。
+请替换示例中的服务器地址与凭据。GeoSite/GeoIP 使用 `<dataDir>/geodata` 下的数据文件；缺失的必需资产通过配置出口下载，加载成功前对应规则不可用。详见[配置参考](../docs/config.yaml)与 [GeoData 行为](../docs/geodata.md)。
 
 `mixed-port` 在同一 TCP 端口接入 HTTP 与 SOCKS5，并在同端口启用 SOCKS5 UDP。`allow-lan` 控制绑定地址，与 `authentication` 独立：`authentication` 省略或为 `[]` 时，回环与通配绑定均免认证；配置凭据后 HTTP 与 SOCKS5 均校验。顶层 `port`、`socks-port`、`udp` 和 `listeners` 都会拒绝；代理节点的 `port` 与 `udp` 保留出站含义。
 
-兼容范围限于文档列出的字段和行为，不覆盖任意 Mihomo 配置。代理组目前支持静态 `select`；DNS 上游使用固定 IP，通过 UDP/TCP 查询。Providers、自动代理组选择、加密 DNS 和 fake-IP 不在当前功能范围内。未知字段与无效组合会被拒绝，不会静默忽略；Vole 特有的语义会在相应契约中说明。
+兼容范围限于文档列出的 Mihomo 配置子集。未知字段与不支持的组合明确拒绝；当前平台和协议边界见 [Mihomo 兼容范围](../docs/mihomo-compatibility.md)与各项契约。
 
-库接口由宿主使用内联 `configYaml` 启动实例；TUN 设备、描述符、MTU、DNS 拦截和 UDP 超时归属于 `tun` 配置，平台回调仍在运行时本地注册。CLI 通过同一 Invoke API 传递参数，由其前台操作读取 `-f` 指定的配置。接口地址、DNS 与系统路由由宿主配置。
+库接口由宿主使用内联 `configYaml` 启动实例；TUN 设备、描述符、MTU、DNS 拦截和 UDP 超时归属于 `tun` 配置，平台回调仍在运行时本地注册。CLI 通过同一 Invoke API 传递参数，由其前台操作读取 `-f` 指定的配置。Linux 自建 TUN 可配置自动路由与 systemd-resolved DNS；借用 fd 和 App 平台的网络仍由宿主管理。
 
 ## CLI
 
@@ -97,12 +105,12 @@ vole -t -f ./config.yaml
 | iOS / macOS | 宿主提供 utun 文件描述符；macOS 也可打开或创建原生 utun |
 | tvOS 17+ | 宿主提供 utun 文件描述符；支持 ARM64 真机和模拟器目标 |
 | Android | `VpnService` 文件描述符与出站 socket 保护 |
-| Linux | 借用 fd 或由内核打开设备的真实单队列 raw-IP TUN；宿主负责系统网络配置 |
+| Linux | 借用 fd 或由内核打开设备的真实单队列 raw-IP TUN；Linux 自建设备支持自动路由与系统 DNS |
 | Windows | 编译时互斥的 `windows-wintun` 桌面后端与 `windows-uwp` 安装包 Provider/Session Host；共用内核 |
 
-Vole 提供原生库和前台 CLI；系统网络配置仍由平台宿主负责。Unix 宿主持有原始 TUN 描述符；Vole 使用并关闭自己复制的描述符。Apple 公开的 packetFlow API 不保证可获取 raw fd，因此实际 Network Extension 集成和设备验证仍由宿主负责。详见 [TUN 集成](../docs/tun-platform.md)与[平台验收边界](../docs/acceptance.md)。
+Vole 提供原生库和前台 CLI。Apple、Android、Windows 的系统网络与 App 生命周期由宿主负责；Linux 自建 TUN 另外支持自动路由和系统 DNS。Unix 宿主持有原始 TUN 描述符；Vole 使用并关闭自己复制的描述符。Apple 公开的 packetFlow API 不保证可获取 raw fd，因此实际 Network Extension 集成和设备验证仍由宿主负责。详见 [TUN 集成](../docs/tun-platform.md)与[平台验收边界](../docs/acceptance.md)。
 
-桌面 Wintun 从进程可执行文件所在目录加载宿主提供的 `wintun.dll`。接口地址、DNS、路由与物理出口由宿主配置；Wintun 设备验收独立于已有安装包 VPN 结果。命令行使用与交付见 [CLI 与 tag 发布](../docs/cli.md)。
+桌面 Wintun 从进程可执行文件所在目录加载宿主提供的 `wintun.dll`。接口地址、DNS、路由与物理出口由宿主配置；Wintun 与安装包 UWP 分别进行设备验收。命令行使用与交付见 [CLI 与 tag 发布](../docs/cli.md)。
 
 跨平台 C ABI 通过 Invoke API 接受 JSON 请求：
 
@@ -113,20 +121,11 @@ void VoleFree(char *response);
 
 单个公共实例遵循 `initialize → createInstance → start(configYaml) → stop → destroyInstance` 生命周期，准备过程由 `start` 内部完成；`validateConfig` 不要求初始化。CLI 通过显式的前台 Invoke 操作处理文件、环境默认值、信号与清理。API 还提供状态查询、GeoData 状态与延迟测量。详见 [Invoke API](../docs/invoke-api.md)、[Controller API](../docs/controller-api.md)与 [Windows 集成示例](../example/windows-uwp/README.md)。
 
-## Benchmark
-
-[**Vole / Mihomo TUN benchmark**](https://github.com/YuanDevTeam/container-benchmark) 提供两个内核在相同原生 Linux TUN 环境下的可复现测试设置、实测结果与对比图表。
-
-benchmark 工程同时负责协议互通（`interop`）与内存压力（`stress`），通过显式 `--source vole=PATH` 提供被测 checkout；Vole 自有脚本只编译核心与平台产物。
-
-测试使用 **1 / 1.5 / 2 Gbps** 混合 TCP/UDP 流量、**每秒 1,000 次 DNS 查询**和增强的 `geosite:cn` / `geoip:cn` 规则，报告实际吞吐量、CPU、观察到的 Linux 峰值 RSS、UDP 丢包与成功的 DNS 查询数。它使用 DIRECT 出口评估 TUN/DNS/路由路径，不衡量加密代理吞吐量；Linux RSS 不等同于 Apple Network Extension 内存占用。
-
-独立 `stress` 命令使用同样的完整增强 `geosite:cn` / `geoip:cn`，叠加 2 Gbps / 60 秒 / 1,000 QPS DNS。原始 DAT 不裁剪，但只加载 CN 分类；可选 `--geodata-update` 在流量期间执行真实下载与重载。实际输入类型、测量和失败见 benchmark README。任何单次观测都不是任意输入低于 50,000,000 字节的保证，也不替代 Apple 真机验收。
-
 ## 文档
 
 - [文档索引](../docs/README.md)
 - [配置参考](../docs/config.yaml)
+- [Mihomo 兼容范围](../docs/mihomo-compatibility.md)
 - [核心与平台构建](../scripts/README.md)
 - [CLI 与 tag 发布](../docs/cli.md)
 - [核心回归测试](../tests/README.md)
@@ -138,6 +137,7 @@ benchmark 工程同时负责协议互通（`interop`）与内存压力（`stress
 Vole 使用并参考以下公开依赖、协议实现和平台资料：
 
 - TUN 依赖：自有 [`vole-netstack`](../crates/vole-netstack/README.md) 使用 [smoltcp](https://github.com/smoltcp-rs/smoltcp)，Unix 与 Windows Wintun 包 I/O 使用 [tun-rs](https://github.com/tun-rs/tun-rs)（Apache-2.0）。
+- WireGuard：[boringtun](https://github.com/cloudflare/boringtun)（BSD-3-Clause），不启用 host-device、FFI 或 JNI。
 - [Wintun](https://www.wintun.net/)：运行时 DLL 由宿主提供，不随 Vole 捆绑。tun-rs 中的上游 [API 头文件](https://github.com/tun-rs/tun-rs/blob/2.8.11/src/platform/windows/tun/wintun.h) 版权为 2018–2021 WireGuard LLC，许可证为 `GPL-2.0 OR MIT`；分发链接的 API bindings 时须保留其版权和 MIT 可选许可证声明。
 - 网络与路由参考：[clash-rs](https://github.com/Watfaq/clash-rs)、[netstack-smoltcp](https://github.com/cavivie/netstack-smoltcp)、[Mihomo](https://github.com/MetaCubeX/mihomo)、[Xray-core](https://github.com/XTLS/Xray-core) 和 [Leaf](https://github.com/eycorsican/leaf)。这些参考项目并非 netstack 依赖。
 - TLS 与 Shadowsocks：[rustls](https://github.com/rustls/rustls)、[boring](https://github.com/cloudflare/boring)、[BoringSSL](https://boringssl.googlesource.com/boringssl/) 和 [shadowsocks-rust](https://github.com/shadowsocks/shadowsocks-rust)。衍生的重放窗口代码保留了 [MIT 声明](../src/outbound/shadowsocks/packet_window.rs)。
diff --git a/scripts/README.md b/scripts/README.md
index ea0e196..1c7d2e1 100644
--- a/scripts/README.md
+++ b/scripts/README.md
@@ -1,6 +1,7 @@
 # 编译与发布
 
-在 Vole 根目录执行。需要 Rust、uv、C/C++、CMake、Perl 和 libclang，以及对应平台工具链。
+在 Vole 根目录执行。需要 Rust、uv、Git、C/C++、CMake、Perl 和 libclang，以及对应平台工具链。
+Linux 自动准备原生依赖还需要 curl、zip、unzip 和 tar。
 
 ```sh
 uv run --project scripts --locked vole-scripts build cli
@@ -34,6 +35,33 @@ Android 优先使用 `ANDROID_NDK_HOME`，否则在 `ANDROID_HOME/ndk` 中选择
 `VOLE_ANDROID_NDK_VERSION` 可指定版本，`VOLE_ANDROID_API` 默认 24。
 `CARGO_TARGET_DIR` 按 Cargo 约定覆盖中间产物目录；其余本地覆盖见 `builds.py`。
 
+所有编译入口自动准备官方 BLAKE3 1.8.7 C 静态库。依赖通过
+`native/blake3/vcpkg.json` 锁定正式 vcpkg registry/port，正常 bootstrap 和 install
+使用宿主网络及用户缓存；首次构建需要联网。默认缓存位于 macOS 的
+`~/Library/Caches/vole/native`、Linux 的 `$XDG_CACHE_HOME/vole/native`
+（未设置时为 `~/.cache/vole/native`）、Windows 的 `%LOCALAPPDATA%/vole/native`，
+可用 `VOLE_NATIVE_CACHE_DIR` 覆盖。第三方源、工具、头文件和静态库留在依赖缓存，
+不加入仓库或发布归档。自有 triplet 为 C 符号设置 `vole_c_` 编译宏；官方 port 和源码不改。
+Apple 使用对应 SDK 和上述最低版本，Android 使用同一 NDK/API，Windows 区分
+Windows/WindowsStore；Wintun 使用静态 CRT，UWP 的 Rust、BoringSSL 和 BLAKE3
+统一使用动态 CRT，BLAKE3 本身仍为静态库。UWP 宿主安装包负责声明并部署对应架构的
+Visual C++ Runtime 依赖；各目标安装目录独立。
+
+直接执行 Cargo 时可先准备宿主依赖：
+
+```sh
+uv run --project scripts --locked vole-scripts deps
+```
+
+该命令打印两个目标后缀环境变量；在当前 shell 中设置后执行 Cargo。
+Windows UWP 使用 `deps --backend uwp`，还需设置输出的 `CARGO_ENCODED_RUSTFLAGS`，
+使 Rust 和原生依赖使用相同的动态 CRT。
+CI 使用 `deps --github-env "$GITHUB_ENV"` 自动传给后续步骤。
+显式提供 `VOLE_BLAKE3_INCLUDE_DIR_<TARGET>` 与 `VOLE_BLAKE3_LIB_DIR_<TARGET>`
+可复用已准备的同目标 namespaced 静态包；`<TARGET>` 为大写 Rust target，连字符改成下划线。
+无后缀的两变量仅在宿主原生构建有效。缺少一项或路径无效直接失败，不回退到其他架构。
+平台构建命令本身不需要手工设置这些变量。
+
 ## 发布
 
 [Release workflow](../.github/workflows/release.yml) 在 `vX.Y.Z` tag push 时构建并发布，
diff --git a/scripts/cmake/windows-arm64.toolchain.cmake b/scripts/cmake/windows-arm64.toolchain.cmake
index 14a748c..4e83c75 100644
--- a/scripts/cmake/windows-arm64.toolchain.cmake
+++ b/scripts/cmake/windows-arm64.toolchain.cmake
@@ -11,4 +11,12 @@ set(CMAKE_ASM_COMPILER "$ENV{CC_aarch64_pc_windows_msvc}")
 set(CMAKE_C_COMPILER_TARGET aarch64-pc-windows-msvc)
 set(CMAKE_CXX_COMPILER_TARGET aarch64-pc-windows-msvc)
 set(CMAKE_ASM_COMPILER_TARGET aarch64-pc-windows-msvc)
-set(CMAKE_MSVC_RUNTIME_LIBRARY MultiThreaded)
+# Match Cargo's selected CRT, including UWP's dynamic CRT. An explicit setting
+# from a native build script takes precedence over this toolchain default.
+if(NOT DEFINED CMAKE_MSVC_RUNTIME_LIBRARY)
+  if("$ENV{CARGO_CFG_TARGET_FEATURE}" MATCHES "(^|,)crt-static(,|$)")
+    set(CMAKE_MSVC_RUNTIME_LIBRARY MultiThreaded)
+  else()
+    set(CMAKE_MSVC_RUNTIME_LIBRARY MultiThreadedDLL)
+  endif()
+endif()
diff --git a/scripts/native/blake3/namespace.cmake b/scripts/native/blake3/namespace.cmake
new file mode 100644
index 0000000..273e2aa
--- /dev/null
+++ b/scripts/native/blake3/namespace.cmake
@@ -0,0 +1,54 @@
+# Vole-owned package configuration. The official source and port stay intact.
+# Only the blake3 package receives compile-time namespaces; dependency tools do not.
+if(PORT STREQUAL "blake3")
+  set(_vole_blake3_symbols
+    blake3_version
+    blake3_hasher_init
+    blake3_hasher_init_keyed
+    blake3_hasher_init_derive_key
+    blake3_hasher_init_derive_key_raw
+    blake3_hasher_update
+    blake3_hasher_finalize
+    blake3_hasher_finalize_seek
+    blake3_hasher_reset
+    blake3_compress_subtree_wide
+    blake3_compress_in_place
+    blake3_compress_xof
+    blake3_xof_many
+    blake3_hash_many
+    blake3_simd_degree
+    blake3_compress_in_place_portable
+    blake3_compress_xof_portable
+    blake3_hash_many_portable
+    blake3_compress_in_place_sse2
+    blake3_compress_xof_sse2
+    blake3_hash_many_sse2
+    blake3_compress_in_place_sse41
+    blake3_compress_xof_sse41
+    blake3_hash_many_sse41
+    blake3_hash_many_avx2
+    blake3_compress_in_place_avx512
+    blake3_compress_xof_avx512
+    blake3_hash_many_avx512
+    blake3_xof_many_avx512
+    blake3_hash_many_neon
+    blake3_hash4_sse2
+    blake3_hash4_sse41
+    blake3_hash8_avx2
+    blake3_hash4_avx512
+    blake3_hash8_avx512
+    blake3_hash16_avx512
+    blake3_xof4_avx512
+    blake3_xof8_avx512
+    blake3_xof16_avx512
+  )
+  foreach(_vole_symbol IN LISTS _vole_blake3_symbols)
+    string(APPEND VCPKG_C_FLAGS " -D${_vole_symbol}=vole_c_${_vole_symbol}")
+    string(APPEND VCPKG_CXX_FLAGS " -D${_vole_symbol}=vole_c_${_vole_symbol}")
+  endforeach()
+  # Preprocessor namespaces apply to the official intrinsics C implementations.
+  # The unpreprocessed MSVC assembly exports cannot follow those definitions.
+  if(VCPKG_TARGET_ARCHITECTURE MATCHES "^(x64|x86)$")
+    list(APPEND VCPKG_CMAKE_CONFIGURE_OPTIONS "-DBLAKE3_SIMD_TYPE=x86-intrinsics")
+  endif()
+endif()
diff --git a/scripts/native/blake3/tvos.cmake b/scripts/native/blake3/tvos.cmake
new file mode 100644
index 0000000..9ec0486
--- /dev/null
+++ b/scripts/native/blake3/tvos.cmake
@@ -0,0 +1,11 @@
+# vcpkg recognizes tvOS but has no dedicated chainload toolchain. Reuse its
+# Apple compiler/flag setup after selecting CMake's tvOS platform explicitly.
+set(CMAKE_SYSTEM_NAME tvOS CACHE STRING "")
+# The main toolchain propagates Z_VCPKG_ROOT_DIR to nested try_compile checks.
+# Initial port configuration supplies _VCPKG_ROOT_DIR before that cache exists.
+if(DEFINED Z_VCPKG_ROOT_DIR)
+  set(_vole_vcpkg_root "${Z_VCPKG_ROOT_DIR}")
+else()
+  set(_vole_vcpkg_root "${_VCPKG_ROOT_DIR}")
+endif()
+include("${_vole_vcpkg_root}/scripts/toolchains/ios.cmake")
diff --git a/scripts/native/blake3/vcpkg.json b/scripts/native/blake3/vcpkg.json
new file mode 100644
index 0000000..e6d532d
--- /dev/null
+++ b/scripts/native/blake3/vcpkg.json
@@ -0,0 +1,18 @@
+{
+  "name": "vole-native-dependencies",
+  "version-string": "0.1.0",
+  "builtin-baseline": "9eec002df1cd109f8f104cd966a763daf9751489",
+  "dependencies": [
+    {
+      "name": "blake3",
+      "default-features": false
+    }
+  ],
+  "overrides": [
+    {
+      "name": "blake3",
+      "version": "1.8.7",
+      "port-version": 0
+    }
+  ]
+}
diff --git a/scripts/native/blake3/windows-arm64.cmake b/scripts/native/blake3/windows-arm64.cmake
new file mode 100644
index 0000000..69e699d
--- /dev/null
+++ b/scripts/native/blake3/windows-arm64.cmake
@@ -0,0 +1,16 @@
+# Use the same native ARM64 Clang/MSVC ABI as the Core build. The official
+# vcpkg toolchain retains the selected SDK, CRT and UWP API-family restrictions.
+set(CMAKE_C_COMPILER "$ENV{CC_aarch64_pc_windows_msvc}")
+set(CMAKE_CXX_COMPILER "$ENV{CXX_aarch64_pc_windows_msvc}")
+set(CMAKE_C_COMPILER_TARGET aarch64-pc-windows-msvc)
+set(CMAKE_CXX_COMPILER_TARGET aarch64-pc-windows-msvc)
+if(DEFINED Z_VCPKG_ROOT_DIR)
+  set(_vole_vcpkg_root "${Z_VCPKG_ROOT_DIR}")
+else()
+  set(_vole_vcpkg_root "${_VCPKG_ROOT_DIR}")
+endif()
+if(CMAKE_SYSTEM_NAME STREQUAL "WindowsStore")
+  include("${_vole_vcpkg_root}/scripts/toolchains/uwp.cmake")
+else()
+  include("${_vole_vcpkg_root}/scripts/toolchains/windows.cmake")
+endif()
diff --git a/scripts/pyproject.toml b/scripts/pyproject.toml
index 07ab29e..1fe618e 100644
--- a/scripts/pyproject.toml
+++ b/scripts/pyproject.toml
@@ -10,10 +10,10 @@ dependencies = []
 vole-scripts = "vole_scripts.cli:main"
 
 [dependency-groups]
-dev = ["ruff>=0,<1"]
+dev = ["ruff>=0.17.3,<1"]
 
 [build-system]
-requires = ["uv-build>=0.12,<0.13"]
+requires = ["uv-build>=0.13.6,<0.14"]
 build-backend = "uv_build"
 
 [tool.ruff]
diff --git a/scripts/src/vole_scripts/blake3.py b/scripts/src/vole_scripts/blake3.py
new file mode 100644
index 0000000..77770a8
--- /dev/null
+++ b/scripts/src/vole_scripts/blake3.py
@@ -0,0 +1,263 @@
+"""Prepare the official static C package outside the source checkout."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import platform
+import re
+import subprocess
+from pathlib import Path
+
+CONFIG_DIR = Path(__file__).resolve().parents[2] / "native/blake3"
+DEPENDENCY_NAMES = ("VOLE_BLAKE3_INCLUDE_DIR", "VOLE_BLAKE3_LIB_DIR")
+ARCHITECTURES = {"aarch64": "arm64", "x86_64": "x64", "armv7": "arm"}
+APPLE = {
+    "aarch64-apple-ios": ("iOS", "iphoneos", "IPHONEOS", "13.0"),
+    "aarch64-apple-ios-sim": ("iOS", "iphonesimulator", "IPHONEOS", "14.0"),
+    "aarch64-apple-darwin": ("Darwin", "macosx", "MACOSX", "11.0"),
+    "x86_64-apple-darwin": ("Darwin", "macosx", "MACOSX", "10.15"),
+    "aarch64-apple-tvos": ("tvOS", "appletvos", "TVOS", "17.0"),
+    "aarch64-apple-tvos-sim": ("tvOS", "appletvsimulator", "TVOS", "17.0"),
+}
+ANDROID_ABIS = {
+    "aarch64-linux-android": "arm64-v8a",
+    "x86_64-linux-android": "x86_64",
+    "armv7-linux-androideabi": "armeabi-v7a",
+}
+
+
+def _run(command: list[str], env: dict[str, str]) -> None:
+    subprocess.run(command, env=env, check=True)
+
+
+def _quote(value: str | Path) -> str:
+    text = str(value).replace("\\", "/")
+    if "\n" in text or "\r" in text:
+        raise ValueError("native dependency paths cannot contain line breaks")
+    return '"' + text.replace("$", "\\$").replace('"', '\\"') + '"'
+
+
+def _minimum(value: str, minimum: str) -> str:
+    if not re.fullmatch(r"\d+\.\d+(?:\.\d+)?", value):
+        raise ValueError("invalid Apple deployment target")
+    return max((value, minimum), key=lambda item: tuple(map(int, item.split("."))))
+
+
+def _triplet(target: str, env: dict[str, str], backend: str) -> tuple[str, list[Path]]:
+    try:
+        architecture = ARCHITECTURES[target.split("-", 1)[0]]
+    except KeyError as error:
+        raise ValueError("unsupported BLAKE3 target architecture") from error
+    windows = target.endswith("-pc-windows-msvc")
+    runtime = "static" if windows and backend != "uwp" else "dynamic"
+    lines = [
+        f"set(VCPKG_TARGET_ARCHITECTURE {architecture})",
+        "set(VCPKG_LIBRARY_LINKAGE static)",
+        "set(VCPKG_BUILD_TYPE release)",
+        f"set(VCPKG_CRT_LINKAGE {runtime})",
+        "list(APPEND VCPKG_CMAKE_CONFIGURE_OPTIONS "
+        '"-DCMAKE_POSITION_INDEPENDENT_CODE=ON")',
+    ]
+    tracked = [CONFIG_DIR / "namespace.cmake"]
+    if target in APPLE:
+        system, sdk, deployment, minimum = APPLE[target]
+        key = deployment + "_DEPLOYMENT_TARGET"
+        env[key] = _minimum(env.get(key, minimum), minimum)
+        sdk_path = subprocess.run(
+            ["xcrun", "--sdk", sdk, "--show-sdk-path"],
+            env=env,
+            check=True,
+            stdout=subprocess.PIPE,
+            text=True,
+        ).stdout.strip()
+        lines += [
+            f"set(VCPKG_CMAKE_SYSTEM_NAME {system})",
+            f"set(VCPKG_OSX_SYSROOT {_quote(sdk_path)})",
+            f"set(VCPKG_OSX_ARCHITECTURES "
+            f"{'x86_64' if architecture == 'x64' else 'arm64'})",
+            f"set(VCPKG_OSX_DEPLOYMENT_TARGET {env[key]})",
+        ]
+        if system == "tvOS":
+            tracked.append(CONFIG_DIR / "tvos.cmake")
+            lines.append(f"set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE {_quote(tracked[-1])})")
+    elif target in ANDROID_ABIS:
+        ndk = Path(env["ANDROID_NDK_HOME"]).resolve()
+        api = env.get("VOLE_CMAKE_ANDROID_API", env.get("VOLE_ANDROID_API", "24"))
+        if not api.isdigit() or int(api) < 21:
+            raise ValueError("Android BLAKE3 API must be 21 or newer")
+        lines += [
+            "set(VCPKG_CMAKE_SYSTEM_NAME Android)",
+            f"set(VCPKG_CMAKE_SYSTEM_VERSION {api})",
+            "set(VCPKG_ENV_PASSTHROUGH ANDROID_NDK_HOME)",
+            "list(APPEND VCPKG_CMAKE_CONFIGURE_OPTIONS "
+            f"{_quote('-DANDROID_ABI=' + ANDROID_ABIS[target])} "
+            f"{_quote('-DCMAKE_ANDROID_NDK=' + str(ndk))} "
+            '"-DANDROID_STL=c++_shared")',
+        ]
+    elif target.endswith("-unknown-linux-gnu"):
+        lines.append("set(VCPKG_CMAKE_SYSTEM_NAME Linux)")
+    elif windows:
+        if backend not in {"wintun", "uwp"}:
+            raise ValueError("Windows BLAKE3 backend must be wintun or uwp")
+        # vcpkg identifies desktop Windows with an empty system name, unlike
+        # CMake. A chainloaded Clang toolchain still needs the native SDK env.
+        system = "WindowsStore" if backend == "uwp" else '""'
+        lines += [
+            f"set(VCPKG_CMAKE_SYSTEM_NAME {system})",
+            "set(VCPKG_LOAD_VCVARS_ENV ON)",
+        ]
+        # This is a C library, with no C++/CX or WinRT types. UWP still uses
+        # the official WindowsStore toolchain and its API-family definitions.
+        lines.append("set(VCPKG_MSVC_CXX_WINRT_EXTENSIONS OFF)")
+        if backend == "uwp":
+            lines.append(
+                "list(APPEND VCPKG_CMAKE_CONFIGURE_OPTIONS "
+                '"-DCMAKE_TRY_COMPILE_CONFIGURATION=Release" '
+                '"-DVCPKG_MSVC_CXX_WINRT_EXTENSIONS=OFF" '
+                '"-DCMAKE_TRY_COMPILE_PLATFORM_VARIABLES='
+                'VCPKG_MSVC_CXX_WINRT_EXTENSIONS")'
+            )
+        if architecture == "arm64":
+            tracked.append(CONFIG_DIR / "windows-arm64.cmake")
+            lines += [
+                f"set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE {_quote(tracked[-1])})",
+                "set(VCPKG_ENV_PASSTHROUGH "
+                "CC_aarch64_pc_windows_msvc CXX_aarch64_pc_windows_msvc)",
+            ]
+    else:
+        raise ValueError("unsupported BLAKE3 Rust target")
+    lines.append(
+        "list(APPEND VCPKG_HASH_ADDITIONAL_FILES "
+        + " ".join(map(_quote, tracked))
+        + ")"
+    )
+    lines.append(f"include({_quote(CONFIG_DIR / 'namespace.cmake')})")
+    return "\n".join(lines) + "\n", tracked
+
+
+def _cache_dir(env: dict[str, str]) -> Path:
+    if override := env.get("VOLE_NATIVE_CACHE_DIR"):
+        return Path(override).expanduser().resolve()
+    if platform.system() == "Windows":
+        root = Path(env["LOCALAPPDATA"])
+    elif platform.system() == "Darwin":
+        root = Path.home() / "Library/Caches"
+    else:
+        root = Path(env.get("XDG_CACHE_HOME", str(Path.home() / ".cache")))
+    return root / "vole/native"
+
+
+def _paths(target: str, include: str, lib: str) -> dict[str, str]:
+    suffix = "_" + target.upper().replace("-", "_")
+    archive = "blake3.lib" if target.endswith("-msvc") else "libblake3.a"
+    for value, name in ((include, "blake3.h"), (lib, archive)):
+        path = Path(value)
+        if not path.is_absolute() or not (path / name).is_file():
+            raise RuntimeError(f"missing absolute BLAKE3 dependency path: {name}")
+    return dict(
+        zip((name + suffix for name in DEPENDENCY_NAMES), (include, lib), strict=True)
+    )
+
+
+def environment(
+    target: str, host: str, env: dict[str, str], backend: str = "wintun"
+) -> dict[str, str]:
+    """Keep explicit dependency overrides; otherwise install the locked package."""
+    env = env.copy()
+    suffix = "_" + target.upper().replace("-", "_")
+    overrides = [
+        env[name + suffix]
+        if name + suffix in env
+        else env.get(name)
+        if target == host
+        else None
+        for name in DEPENDENCY_NAMES
+    ]
+    if any(value is not None for value in overrides):
+        if any(value is None for value in overrides):
+            raise RuntimeError("set both BLAKE3 include and library dependency paths")
+        return env | _paths(target, *overrides)
+
+    manifest = (CONFIG_DIR / "vcpkg.json").read_bytes()
+    registry = json.loads(manifest)["builtin-baseline"]
+    triplet_text, tracked = _triplet(target, env, backend)
+    # Only our small package configuration enters this cache identity. Third-
+    # party source acquisition and package ABI tracking remain vcpkg's job.
+    identity = hashlib.sha256(manifest + triplet_text.encode())
+    for path in tracked:
+        identity.update(path.read_bytes())
+    triplet = f"{target.replace('_', '-')}-vole-{identity.hexdigest()[:12]}"
+    cache = _cache_dir(env)
+    overlay = cache / "triplets"
+    overlay.mkdir(parents=True, exist_ok=True)
+    (overlay / (triplet + ".cmake")).write_text(triplet_text, encoding="utf-8")
+    checkout = cache / ("vcpkg-" + registry)
+    if not (checkout / ".git").is_dir():
+        _run(
+            [
+                "git",
+                "clone",
+                "--filter=blob:none",
+                "--no-checkout",
+                "https://github.com/microsoft/vcpkg.git",
+                str(checkout),
+            ],
+            env,
+        )
+        _run(["git", "-C", str(checkout), "checkout", "--detach", registry], env)
+    current = subprocess.run(
+        ["git", "-C", str(checkout), "rev-parse", "HEAD"],
+        env=env,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout.strip()
+    if current != registry:
+        raise RuntimeError("managed vcpkg checkout does not match the locked registry")
+    windows = platform.system() == "Windows"
+    executable = checkout / ("vcpkg.exe" if windows else "vcpkg")
+    if not executable.is_file():
+        bootstrap = checkout / (
+            "bootstrap-vcpkg.bat" if windows else "bootstrap-vcpkg.sh"
+        )
+        command = (
+            [env.get("COMSPEC", "cmd.exe"), "/d", "/c", "call", str(bootstrap)]
+            if windows
+            else ["bash", str(bootstrap)]
+        )
+        _run([*command, "-disableMetrics"], env)
+    host_architecture = ARCHITECTURES[host.split("-", 1)[0]]
+    host_system = {"Windows": "windows", "Darwin": "osx", "Linux": "linux"}[
+        platform.system()
+    ]
+    installed = cache / "installed" / triplet
+    command = [
+        str(executable),
+        "install",
+        f"--triplet={triplet}",
+        f"--host-triplet={host_architecture}-{host_system}",
+        f"--x-manifest-root={CONFIG_DIR}",
+        f"--overlay-triplets={overlay}",
+        f"--x-install-root={installed}",
+        "--disable-metrics",
+        "--x-wait-for-lock",
+    ]
+    try:
+        _run(command, env)
+    except subprocess.CalledProcessError:
+        for stage in ("detect_compiler", "blake3"):
+            logs = (checkout / "buildtrees" / stage).glob(f"config-{triplet}*-out.log")
+            for log in sorted(logs)[-2:]:
+                try:
+                    with log.open("rb") as stream:
+                        stream.seek(0, 2)
+                        stream.seek(max(0, stream.tell() - 16_384))
+                        detail = stream.read(16_384).decode(errors="replace")
+                except OSError:
+                    continue
+                print(f"\n{stage}/{log.name}:\n", flush=True)
+                print(detail, flush=True)
+        raise
+    package = installed / triplet
+    return env | _paths(target, str(package / "include"), str(package / "lib"))
diff --git a/scripts/src/vole_scripts/builds.py b/scripts/src/vole_scripts/builds.py
index 1f30556..080cc84 100644
--- a/scripts/src/vole_scripts/builds.py
+++ b/scripts/src/vole_scripts/builds.py
@@ -10,6 +10,8 @@
 import tempfile
 from pathlib import Path
 
+from . import blake3
+
 CORE_DIR = Path(__file__).resolve().parents[3]
 # Both transports enable the production core through invoke -> tun in Cargo.toml.
 DEFAULT_FEATURES = "ffi"
@@ -105,11 +107,31 @@ def _profile() -> tuple[str, list[str]]:
 
 def _production_features(features: str) -> str:
     names = {name.rsplit("/", 1)[-1] for name in re.split(r"[,\s]+", features)}
-    if names & {"interop-test", "benchmark-geodata-http"}:
+    if "interop-test" in names:
         raise RuntimeError("platform builds cannot enable test-only features")
     return features
 
 
+def _windows_runtime_environment(
+    target: str, env: dict[str, str], backend: str
+) -> dict[str, str]:
+    if not target.endswith("-pc-windows-msvc") or backend != "uwp":
+        return env
+    # UWP supports the dynamic CRT. Preserve Cargo's environment flag priority,
+    # then override this checkout's desktop static-CRT default for all crates.
+    if "CARGO_ENCODED_RUSTFLAGS" in env:
+        encoded = env["CARGO_ENCODED_RUSTFLAGS"]
+        flags = encoded.split("\x1f") if encoded else []
+    else:
+        target_flags = "CARGO_TARGET_" + target.upper().replace("-", "_") + "_RUSTFLAGS"
+        flags = env.get("RUSTFLAGS", env.get(target_flags, "")).split()
+    return env | {
+        "CARGO_ENCODED_RUSTFLAGS": "\x1f".join(
+            [*flags, "-C", "target-feature=-crt-static"]
+        )
+    }
+
+
 def _cargo_build(
     target: str,
     profile_flags: list[str],
@@ -118,6 +140,14 @@ def _cargo_build(
     artifacts: tuple[str, ...] = ("--lib",),
 ) -> Path:
     _production_features(features)
+    backend = "uwp" if "windows-uwp" in re.split(r"[,\s]+", features) else "wintun"
+    env = _windows_runtime_environment(target, env, backend)
+    env = blake3.environment(
+        target,
+        native_target(),
+        env,
+        backend,
+    )
     _run(
         [
             "cargo",
@@ -139,6 +169,45 @@ def _cargo_build(
     return _cargo_target_dir(env) / target / profile
 
 
+def prepare_native_dependencies(
+    target: str | None = None, backend: str = "wintun", github_env: Path | None = None
+) -> None:
+    """Prepare the same package for direct Cargo checks outside platform builds."""
+    host = native_target()
+    target = host if target is None else target
+    env = os.environ.copy()
+    if target in blake3.ANDROID_ABIS:
+        if platform.system() not in {"Darwin", "Linux"}:
+            raise RuntimeError("Android dependencies require macOS or Linux")
+        env["ANDROID_NDK_HOME"] = str(_android_ndk_home())
+    elif target in APPLE_TARGETS:
+        if platform.system() != "Darwin":
+            raise RuntimeError("Apple dependencies require macOS")
+        for variable, override, default in (
+            ("IPHONEOS", "VOLE_IOS_DEPLOYMENT_TARGET", "13.0"),
+            ("MACOSX", "VOLE_MACOS_DEPLOYMENT_TARGET", "10.15"),
+            ("TVOS", "VOLE_TVOS_DEPLOYMENT_TARGET", "17.0"),
+        ):
+            env.setdefault(variable + "_DEPLOYMENT_TARGET", _env(override, default))
+    elif target != host:
+        raise ValueError("Linux and Windows dependencies require the native target")
+    if platform.system() == "Windows":
+        env = _windows_msvc_environment(CLI_TARGETS[host][1])
+    env = _windows_runtime_environment(target, env, backend)
+    env = blake3.environment(target, host, env, backend)
+    suffix = "_" + target.upper().replace("-", "_")
+    entries = [
+        f"{name + suffix}={env[name + suffix]}" for name in blake3.DEPENDENCY_NAMES
+    ]
+    if target.endswith("-pc-windows-msvc") and backend == "uwp":
+        entries.append("CARGO_ENCODED_RUSTFLAGS=" + env["CARGO_ENCODED_RUSTFLAGS"])
+    if github_env is not None:
+        with github_env.open("a", encoding="utf-8") as stream:
+            stream.write("\n".join(entries) + "\n")
+    for entry in entries:
+        print(entry)
+
+
 def build_cli(target: str | None = None, profile: str = "release") -> Path:
     target = native_target() if target is None else target
     features = cli_features(target)
@@ -176,7 +245,12 @@ def build_linux(target: str | None = None) -> Path:
         raise ValueError("Linux FFI build requires the native GNU Rust target")
     architecture = CLI_TARGETS[target][1]
     environment = os.environ.copy()
-    release = _cargo_build(target, ["--release"], DEFAULT_FEATURES, environment)
+    release = _cargo_build(
+        target,
+        ["--release"],
+        DEFAULT_FEATURES,
+        environment,
+    )
     output = CORE_DIR / "dist/linux" / architecture
     shutil.rmtree(output, ignore_errors=True)
     (output / "include").mkdir(parents=True)
diff --git a/scripts/src/vole_scripts/cli.py b/scripts/src/vole_scripts/cli.py
index 9997cb6..c9ac152 100644
--- a/scripts/src/vole_scripts/cli.py
+++ b/scripts/src/vole_scripts/cli.py
@@ -4,8 +4,16 @@
 import subprocess
 import sys
 from collections.abc import Sequence
+from pathlib import Path
 
-from .builds import build_android, build_apple, build_cli, build_linux, build_windows
+from .builds import (
+    build_android,
+    build_apple,
+    build_cli,
+    build_linux,
+    build_windows,
+    prepare_native_dependencies,
+)
 
 
 def _parser() -> argparse.ArgumentParser:
@@ -15,6 +23,17 @@ def _parser() -> argparse.ArgumentParser:
     )
     commands = parser.add_subparsers(dest="command", required=True)
 
+    dependencies = commands.add_parser(
+        "deps", help="prepare official native dependencies"
+    )
+    dependencies.add_argument(
+        "--target", help="Rust target triple (default: native host)"
+    )
+    dependencies.add_argument("--backend", choices=("wintun", "uwp"), default="wintun")
+    dependencies.add_argument(
+        "--github-env", type=Path, help="append paths for CI Cargo checks"
+    )
+
     build = commands.add_parser("build", help="build platform artifacts")
     platforms = build.add_subparsers(dest="platform", required=True)
     for name, description in (
@@ -36,7 +55,9 @@ def _parser() -> argparse.ArgumentParser:
 def main(argv: Sequence[str] | None = None) -> int:
     args = _parser().parse_args(argv)
     try:
-        if args.platform == "cli":
+        if args.command == "deps":
+            prepare_native_dependencies(args.target, args.backend, args.github_env)
+        elif args.platform == "cli":
             build_cli(args.target, args.profile)
         elif args.platform == "apple":
             build_apple()
diff --git a/scripts/tests/test_blake3.py b/scripts/tests/test_blake3.py
new file mode 100644
index 0000000..9416b3b
--- /dev/null
+++ b/scripts/tests/test_blake3.py
@@ -0,0 +1,232 @@
+"""Check target/SDK selection and package acquisition without native builds."""
+
+import io
+import json
+import subprocess
+import tempfile
+import unittest
+from contextlib import redirect_stdout
+from pathlib import Path
+from unittest.mock import patch
+
+from vole_scripts import blake3
+
+
+class Blake3DependencyTests(unittest.TestCase):
+    def setUp(self):
+        temporary = tempfile.TemporaryDirectory()
+        self.addCleanup(temporary.cleanup)
+        self.root = Path(temporary.name)
+        self.target = "aarch64-unknown-linux-gnu"
+
+    def package(self, root):
+        for path in (root / "include/blake3.h", root / "lib/libblake3.a"):
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_bytes(b"native fixture")
+        return str(root / "include"), str(root / "lib")
+
+    def test_explicit_native_paths_do_not_install_packages(self):
+        include, lib = self.package(self.root)
+        env = dict(zip(blake3.DEPENDENCY_NAMES, (include, lib), strict=True))
+        with patch.object(blake3, "_run") as run:
+            prepared = blake3.environment(self.target, self.target, env)
+        run.assert_not_called()
+        suffix = "_AARCH64_UNKNOWN_LINUX_GNU"
+        self.assertEqual(prepared[blake3.DEPENDENCY_NAMES[0] + suffix], include)
+        self.assertEqual(prepared[blake3.DEPENDENCY_NAMES[1] + suffix], lib)
+
+    def test_partial_or_missing_explicit_packages_fail_before_acquisition(self):
+        for env in (
+            {blake3.DEPENDENCY_NAMES[0]: str(self.root)},
+            dict(zip(blake3.DEPENDENCY_NAMES, ("", ""), strict=True)),
+            dict(
+                zip(blake3.DEPENDENCY_NAMES, ("relative", str(self.root)), strict=True)
+            ),
+        ):
+            with (
+                self.subTest(env=env),
+                patch.object(blake3, "_run") as run,
+                self.assertRaises(RuntimeError),
+            ):
+                blake3.environment(self.target, self.target, env)
+            run.assert_not_called()
+
+    def test_cross_build_uses_scoped_paths_without_host_fallback(self):
+        include, lib = self.package(self.root)
+        env = dict(
+            zip(blake3.DEPENDENCY_NAMES, ("invalid host", "invalid host"), strict=True)
+        )
+        suffix = "_AARCH64_UNKNOWN_LINUX_GNU"
+        env.update(
+            {
+                name + suffix: value
+                for name, value in zip(
+                    blake3.DEPENDENCY_NAMES, (include, lib), strict=True
+                )
+            }
+        )
+        with patch.object(blake3, "_run") as run:
+            prepared = blake3.environment(self.target, "x86_64-apple-darwin", env)
+        run.assert_not_called()
+        self.assertEqual(prepared[blake3.DEPENDENCY_NAMES[0] + suffix], include)
+
+    def test_all_apple_targets_select_their_sdk_and_minimum(self):
+        expected = (
+            ("aarch64-apple-ios", "iOS", "iphoneos", "13.0"),
+            ("aarch64-apple-ios-sim", "iOS", "iphonesimulator", "14.0"),
+            ("aarch64-apple-darwin", "Darwin", "macosx", "11.0"),
+            ("x86_64-apple-darwin", "Darwin", "macosx", "10.15"),
+            ("aarch64-apple-tvos", "tvOS", "appletvos", "17.0"),
+            ("aarch64-apple-tvos-sim", "tvOS", "appletvsimulator", "17.0"),
+        )
+        for target, system, sdk, minimum in expected:
+            with (
+                self.subTest(target=target),
+                patch.object(
+                    blake3.subprocess,
+                    "run",
+                    return_value=subprocess.CompletedProcess([], 0, "/SDK\n"),
+                ) as run,
+            ):
+                text, tracked = blake3._triplet(target, {}, "wintun")
+            self.assertEqual(
+                run.call_args.args[0], ["xcrun", "--sdk", sdk, "--show-sdk-path"]
+            )
+            self.assertIn(f"set(VCPKG_CMAKE_SYSTEM_NAME {system})", text)
+            self.assertIn(f"set(VCPKG_OSX_DEPLOYMENT_TARGET {minimum})", text)
+            self.assertEqual(
+                any(path.name == "tvos.cmake" for path in tracked), system == "tvOS"
+            )
+
+    def test_android_keeps_the_selected_ndk_api_and_abi(self):
+        for target, abi in (
+            ("aarch64-linux-android", "arm64-v8a"),
+            ("x86_64-linux-android", "x86_64"),
+        ):
+            with self.subTest(target=target):
+                text, _ = blake3._triplet(
+                    target,
+                    {
+                        "ANDROID_NDK_HOME": str(self.root),
+                        "VOLE_CMAKE_ANDROID_API": "28",
+                    },
+                    "wintun",
+                )
+                self.assertIn(f"-DANDROID_ABI={abi}", text)
+                self.assertIn("set(VCPKG_CMAKE_SYSTEM_VERSION 28)", text)
+                self.assertIn(str(self.root), text)
+                self.assertIn("-DCMAKE_POSITION_INDEPENDENT_CODE=ON", text)
+
+    def test_windows_static_library_matches_backend_crt_and_app_api_family(self):
+        for architecture in ("aarch64", "x86_64"):
+            for backend, system in (("wintun", '""'), ("uwp", "WindowsStore")):
+                with self.subTest(architecture=architecture, backend=backend):
+                    text, _ = blake3._triplet(
+                        f"{architecture}-pc-windows-msvc", {}, backend
+                    )
+                    runtime = "dynamic" if backend == "uwp" else "static"
+                    self.assertIn(f"set(VCPKG_CRT_LINKAGE {runtime})", text)
+                    self.assertIn("set(VCPKG_LIBRARY_LINKAGE static)", text)
+                    self.assertIn(f"set(VCPKG_CMAKE_SYSTEM_NAME {system})", text)
+                    self.assertIn("set(VCPKG_LOAD_VCVARS_ENV ON)", text)
+                    if backend == "uwp":
+                        self.assertIn("-DCMAKE_TRY_COMPILE_CONFIGURATION=Release", text)
+                        self.assertIn("-DVCPKG_MSVC_CXX_WINRT_EXTENSIONS=OFF", text)
+                        self.assertIn(
+                            "-DCMAKE_TRY_COMPILE_PLATFORM_VARIABLES="
+                            "VCPKG_MSVC_CXX_WINRT_EXTENSIONS",
+                            text,
+                        )
+
+    def test_failed_install_reports_target_cmake_log_and_preserves_failure(self):
+        manifest = json.loads((blake3.CONFIG_DIR / "vcpkg.json").read_text())
+        registry = manifest["builtin-baseline"]
+        checkout = self.root / ("vcpkg-" + registry)
+        (checkout / ".git").mkdir(parents=True)
+        (checkout / "vcpkg.exe").touch()
+
+        def fail_install(command, environment):
+            triplet = next(
+                item.split("=", 1)[1]
+                for item in command
+                if item.startswith("--triplet=")
+            )
+            logs = checkout / "buildtrees/detect_compiler"
+            logs.mkdir(parents=True)
+            (logs / f"config-{triplet}-out.log").write_text(
+                "outside diagnostic tail\n" + "x" * 20_000 + "\nSDK rc.exe missing\n"
+            )
+            (logs / "config-other-triplet-out.log").write_text("unrelated build")
+            raise subprocess.CalledProcessError(29, command)
+
+        output = io.StringIO()
+        with (
+            patch.object(blake3.platform, "system", return_value="Windows"),
+            patch.object(blake3, "_run", side_effect=fail_install),
+            patch.object(
+                blake3.subprocess,
+                "run",
+                return_value=subprocess.CompletedProcess([], 0, registry + "\n"),
+            ),
+            redirect_stdout(output),
+            self.assertRaises(subprocess.CalledProcessError) as caught,
+        ):
+            blake3.environment(
+                "x86_64-pc-windows-msvc",
+                "x86_64-pc-windows-msvc",
+                {"VOLE_NATIVE_CACHE_DIR": str(self.root)},
+            )
+        self.assertEqual(caught.exception.returncode, 29)
+        self.assertIn("SDK rc.exe missing", output.getvalue())
+        self.assertNotIn("outside diagnostic tail", output.getvalue())
+        self.assertNotIn("unrelated build", output.getvalue())
+
+    def test_normal_install_uses_official_locked_registry_and_target_package(self):
+        manifest = json.loads((blake3.CONFIG_DIR / "vcpkg.json").read_text())
+        registry = manifest["builtin-baseline"]
+        env = {"VOLE_NATIVE_CACHE_DIR": str(self.root)}
+        commands = []
+
+        def install(command, environment):
+            commands.append(command)
+            if command[:2] == ["git", "clone"]:
+                checkout = Path(command[-1])
+                (checkout / ".git").mkdir(parents=True)
+                (checkout / "vcpkg").write_bytes(b"tool fixture")
+            elif "install" in command:
+                triplet = next(
+                    item.split("=", 1)[1]
+                    for item in command
+                    if item.startswith("--triplet=")
+                )
+                installed = next(
+                    item.split("=", 1)[1]
+                    for item in command
+                    if item.startswith("--x-install-root=")
+                )
+                self.package(Path(installed) / triplet)
+
+        target = "x86_64-unknown-linux-gnu"
+        with (
+            patch.object(blake3.platform, "system", return_value="Linux"),
+            patch.object(blake3, "_run", side_effect=install),
+            patch.object(
+                blake3.subprocess,
+                "run",
+                return_value=subprocess.CompletedProcess([], 0, registry + "\n"),
+            ),
+        ):
+            prepared = blake3.environment(target, target, env)
+        self.assertEqual(commands[0][4], "https://github.com/microsoft/vcpkg.git")
+        self.assertEqual(commands[1][-1], registry)
+        self.assertIn("--host-triplet=x64-linux", commands[-1])
+        triplet = next(
+            item.split("=", 1)[1]
+            for item in commands[-1]
+            if item.startswith("--triplet=")
+        )
+        self.assertRegex(triplet, r"^[a-z0-9-]+$")
+        self.assertIn("--x-wait-for-lock", commands[-1])
+        self.assertIn("--x-manifest-root=" + str(blake3.CONFIG_DIR), commands[-1])
+        include = prepared["VOLE_BLAKE3_INCLUDE_DIR_X86_64_UNKNOWN_LINUX_GNU"]
+        self.assertTrue((Path(include) / "blake3.h").is_file())
diff --git a/scripts/tests/test_builds.py b/scripts/tests/test_builds.py
index 49b9466..d2ecd04 100644
--- a/scripts/tests/test_builds.py
+++ b/scripts/tests/test_builds.py
@@ -1,12 +1,14 @@
 """Check platform outputs around the external compiler boundary."""
 
+import io
 import os
 import tempfile
 import unittest
+from contextlib import redirect_stdout
 from pathlib import Path
 from unittest.mock import MagicMock, patch
 
-from vole_scripts import builds
+from vole_scripts import builds, cli
 
 
 class BuildTests(unittest.TestCase):
@@ -25,6 +27,13 @@ def setUp(self):
         )
         self.commands = []
         self.enterContext(patch.object(builds, "_run", side_effect=self.compile))
+        self.enterContext(
+            patch.object(
+                builds.blake3,
+                "environment",
+                side_effect=lambda target, host, env, backend: env,
+            )
+        )
 
     def write(self, relative, data=b"library"):
         path = self.root / relative
@@ -39,6 +48,7 @@ def compile(self, command, *, env):
         elif command[:2] == ["cargo", "build"]:
             target = command[command.index("--target") + 1]
             for name in (
+                "vole",
                 "vole.exe",
                 "vole.dll",
                 "vole.dll.lib",
@@ -98,6 +108,98 @@ def test_windows_cli_and_ffi_select_their_backends(self):
             )
             self.assertEqual("--bins" in command, backend == "uwp")
 
+    def test_linux_cli_and_ffi_preserve_transport_features(self):
+        target = "aarch64-unknown-linux-gnu"
+        with (
+            patch.object(builds.platform, "system", return_value="Linux"),
+            patch.object(builds, "native_target", return_value=target),
+        ):
+            builds.build_cli()
+            builds.build_linux()
+        self.assertEqual(
+            [command[command.index("--features") + 1] for command, _ in self.commands],
+            ["cli", "ffi"],
+        )
+
+    def test_uwp_build_selects_dynamic_crt_and_preserves_cargo_flag_precedence(self):
+        target_flags = "CARGO_TARGET_AARCH64_PC_WINDOWS_MSVC_RUSTFLAGS"
+        cases = (
+            ({}, []),
+            ({target_flags: "-C debuginfo=1"}, ["-C", "debuginfo=1"]),
+            (
+                {target_flags: "--cfg ignored", "RUSTFLAGS": "-C opt-level=2"},
+                ["-C", "opt-level=2"],
+            ),
+            (
+                {
+                    target_flags: "--cfg ignored",
+                    "RUSTFLAGS": "--cfg ignored_too",
+                    "CARGO_ENCODED_RUSTFLAGS": '--cfg\x1fvalue="with space"',
+                },
+                ["--cfg", 'value="with space"'],
+            ),
+            ({"CARGO_ENCODED_RUSTFLAGS": "", "RUSTFLAGS": "--cfg ignored"}, []),
+        )
+        for overrides, expected in cases:
+            original = dict(os.environ) | overrides
+            with (
+                self.subTest(overrides=overrides),
+                patch.object(builds.platform, "system", return_value="Windows"),
+                patch.object(builds, "_windows_architecture", return_value="arm64"),
+                patch.object(
+                    builds, "_windows_msvc_environment", return_value=original
+                ),
+            ):
+                builds.build_windows("uwp")
+                self.assertEqual(
+                    self.commands[-1][1]
+                    .get("CARGO_ENCODED_RUSTFLAGS", "")
+                    .split("\x1f"),
+                    [*expected, "-C", "target-feature=-crt-static"],
+                )
+                self.assertEqual(original, dict(os.environ) | overrides)
+        with (
+            patch.object(builds.platform, "system", return_value="Windows"),
+            patch.object(builds, "_windows_architecture", return_value="arm64"),
+            patch.object(
+                builds, "_windows_msvc_environment", return_value=dict(os.environ)
+            ),
+        ):
+            builds.build_windows("wintun")
+        self.assertNotIn("CARGO_ENCODED_RUSTFLAGS", self.commands[-1][1])
+
+    def test_direct_uwp_dependencies_export_matching_cargo_crt_flags(self):
+        output = io.StringIO()
+        github_env = self.root / "github.env"
+
+        def dependency_environment(target, host, env, backend):
+            self.assertEqual((target, host), ("aarch64-pc-windows-msvc",) * 2)
+            self.assertEqual(backend, "uwp")
+            suffix = "_AARCH64_PC_WINDOWS_MSVC"
+            return env | {
+                name + suffix: str(self.root / name)
+                for name in builds.blake3.DEPENDENCY_NAMES
+            }
+
+        with (
+            patch.object(builds.platform, "system", return_value="Windows"),
+            patch.object(builds, "_windows_architecture", return_value="arm64"),
+            patch.object(
+                builds, "_windows_msvc_environment", return_value=dict(os.environ)
+            ),
+            patch.object(
+                builds.blake3, "environment", side_effect=dependency_environment
+            ),
+            redirect_stdout(output),
+        ):
+            builds.prepare_native_dependencies(backend="uwp", github_env=github_env)
+        self.assertEqual(output.getvalue(), github_env.read_text())
+        self.assertEqual(output.getvalue().count("\n"), 3)
+        self.assertIn(
+            "CARGO_ENCODED_RUSTFLAGS=-C\x1ftarget-feature=-crt-static\n",
+            output.getvalue(),
+        )
+
     def test_windows_requires_native_python(self):
         registry = MagicMock()
         with patch.dict("sys.modules", {"winreg": registry}):
@@ -211,6 +313,10 @@ def test_android_uses_matching_api_and_cpp_runtime(self):
         for command, env in self.commands:
             target = command[command.index("--target") + 1]
             abi = env["VOLE_CMAKE_ANDROID_ABI"]
+            self.assertEqual(
+                command[command.index("--features") + 1],
+                "ffi",
+            )
             self.assertEqual(
                 env[f"BINDGEN_EXTRA_CLANG_ARGS_{target}"], f"--target={target}28"
             )
@@ -244,6 +350,13 @@ def test_apple_build_stages_five_slices_from_six_targets(self):
         self.assertEqual(
             sum(command[:2] == ["cargo", "build"] for command, _ in self.commands), 6
         )
+        self.assertTrue(
+            all(
+                command[command.index("--features") + 1] == "ffi"
+                for command, _ in self.commands
+                if command[:2] == ["cargo", "build"]
+            )
+        )
         self.assertEqual(
             self.commands[-1][0][:2], ["xcodebuild", "-create-xcframework"]
         )
@@ -264,6 +377,23 @@ def test_apple_build_stages_five_slices_from_six_targets(self):
             (work / "ios-simulator/libvole.a").read_bytes(), b"aarch64-apple-ios-sim"
         )
 
+    def test_apple_preserves_production_override_and_rejects_test_features(self):
+        with (
+            patch.object(builds.platform, "system", return_value="Darwin"),
+            patch.dict(os.environ, {"VOLE_FEATURES": "ffi,controller"}),
+        ):
+            builds.build_apple_target("aarch64-apple-ios")
+        command = self.commands[-1][0]
+        self.assertEqual(command[command.index("--features") + 1], "ffi,controller")
+        self.commands.clear()
+        with (
+            patch.object(builds.platform, "system", return_value="Darwin"),
+            patch.dict(os.environ, {"VOLE_FEATURES": "ffi,interop-test"}),
+            self.assertRaisesRegex(RuntimeError, "test-only features"),
+        ):
+            builds.build_apple_target("aarch64-apple-ios")
+        self.assertEqual(self.commands, [])
+
     def test_ndk_selection_uses_latest_installed_stable_revision(self):
         for version in ("30.2.9", "30.2.10", "30.10.1", "30.99.1-beta1"):
             folder = version.removesuffix("-beta1")
@@ -273,3 +403,22 @@ def test_ndk_selection_uses_latest_installed_stable_revision(self):
             )
         with patch.dict(os.environ, {"ANDROID_HOME": str(self.root / "sdk")}):
             self.assertEqual(builds._android_ndk_home(), self.root / "sdk/ndk/30.10.1")
+
+
+class BuildCliTests(unittest.TestCase):
+    def test_arguments_reach_each_platform_builder(self):
+        for platform in ("cli", "apple", "android", "windows", "linux"):
+            args = ["build", platform]
+            positional = ()
+            if platform == "cli":
+                args += ["--target", "aarch64-apple-darwin", "--profile", "debug"]
+                positional = ("aarch64-apple-darwin", "debug")
+            elif platform == "windows":
+                args += ["--backend", "wintun"]
+                positional = ("wintun",)
+            with (
+                self.subTest(platform=platform),
+                patch.object(cli, "build_" + platform) as build,
+            ):
+                self.assertEqual(cli.main(args), 0)
+            build.assert_called_once_with(*positional)
diff --git a/scripts/uv.lock b/scripts/uv.lock
index d2a6d94..bfdb7ef 100644
--- a/scripts/uv.lock
+++ b/scripts/uv.lock
@@ -4,27 +4,27 @@ requires-python = ">=3.11"
 
 [[package]]
 name = "ruff"
-version = "0.16.10"
+version = "0.17.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/c4/49/23802c45f093eb14bde54b141d2b2f058edfa63a06db7beed047308cc08f/ruff-0.16.10.tar.gz", hash = "sha256:eff4728c4eaae93f0955cd264d24b2ab348e74bf59986ccf282ba6dc16b3b017", size = 4958724, upload-time = "2026-10-01T18:03:21.697Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/59/73/81f140c4edd9cc323de5478e6bbd3bbcfae9a82692df1a258de8cec6a6d2/ruff-0.17.3.tar.gz", hash = "sha256:a57049c8addb3662073859bb55a7ad35aa54f8a7c9ed268911d1333c5aadaaa9", size = 5339444, upload-time = "2026-10-27T00:34:05.914Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2f/21/ebce22e1d90cdb2cd691026b9c6e9bec6499f0b396089481755b5d49efff/ruff-0.16.10-py3-none-linux_armv6l.whl", hash = "sha256:488b0fe3f3574210e5cf80d9f59b9e3ab17a127a8155de3f307b392589cfb511", size = 10095557, upload-time = "2026-10-01T18:02:36.072Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/98/a54de85876a8b2612bfa0d84c7b9abfb39c6a3354aee7800b09c1649b9e3/ruff-0.16.10-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:e748ff95c934c4e978783b8e687bc174e7bd84e8ad24e3243e1ecfcda5e0282d", size = 10340577, upload-time = "2026-10-01T18:02:39.258Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/16/1a5a4a2657effe4806110f2b907313802f1367fcdbb29e8122766e407fab/ruff-0.16.10-py3-none-macosx_11_0_arm64.whl", hash = "sha256:3031a4a2e8e7b8a46f70be45f198c35a11ece509a94b80334d8d397a33c67550", size = 9774282, upload-time = "2026-10-01T18:02:41.79Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/fb/470085af734da396e68cd80fb0a3e7c109a459716ae59588c0f6fab8a17d/ruff-0.16.10-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:494401c86df4c4c25f69b9419605d944467ee98c42fb6ad405ef4fa40b8fb67d", size = 9920895, upload-time = "2026-10-01T18:02:44.458Z" },
-    { url = "https://files.pythonhosted.org/packages/57/de/f10cffe4f88a37ea6615ec460f01bf76f0bc1477737a35d9ee61a630a78b/ruff-0.16.10-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d203abc0ff2b773ee33d00ab8df0bb67046fbc7c07b119332f08b9b345cf8221", size = 9902707, upload-time = "2026-10-01T18:02:47.041Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/44/3fdcedf83ae60ef837dd239170e480dce606a9142cfa2db911afdf855fd9/ruff-0.16.10-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bd83d1235a5258d318477bc5b576303974cbdef5df0c01a1bff14efcc23bd12a", size = 10619287, upload-time = "2026-10-01T18:02:49.485Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/62/02e76a5574002153618eafbb70e159468addc72a5d2c488e65cbb4639d2d/ruff-0.16.10-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bc2610fb269fa56dd8a68669ae470fa6272902668c0fc2ebc3aa112b2633d5b8", size = 11339942, upload-time = "2026-10-01T18:02:52.008Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/c4/cde27d47ad8d4126c587e608c67c46e7feac11763f606d261a1bc8a489e6/ruff-0.16.10-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3e70175e29cc94c26ea296c80e470180b744b7419026898e58f520c6ab32578e", size = 10934316, upload-time = "2026-10-01T18:02:54.811Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/03/17234145f302a645a123e8c3bb2411ecf4669fbc350de3b0d803230a1729/ruff-0.16.10-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f33f43a864a8483eebd160e713336c8bab02c934feaff0a33cf5ccb41546d09a", size = 10387968, upload-time = "2026-10-01T18:02:57.497Z" },
-    { url = "https://files.pythonhosted.org/packages/71/29/2493af60240ee7644b38a4b821f5f9c3b5a4fa3178770fe1d0c685217395/ruff-0.16.10-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:1dfc6f0088149fb6a362c1c446bcbb3fd2157b3852fe2fa68409276eab9ad9b3", size = 10537906, upload-time = "2026-10-01T18:03:00.006Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/9a/f56b28f3b143bb9e518c34fb89ab191b626bca8b70dbf8af0d2e2d473572/ruff-0.16.10-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:6553498afc35f580f036030795810b9e6bcea31604b0fd9e8d352795473042e3", size = 10012938, upload-time = "2026-10-01T18:03:03.006Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/c4/fca37362848ea4d4d80712df13632e645e7c7cfb1bdedf140699ac7a090b/ruff-0.16.10-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:a3b8471dea115d37f123882be852bed13403746d3a76c11de4a19ec5f9ff5a03", size = 9897945, upload-time = "2026-10-01T18:03:05.818Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/c7/e0bc57664d6e0c61fd22f620af260fe9662d7e1ddb320ea7f160e76ef165/ruff-0.16.10-py3-none-musllinux_1_2_i686.whl", hash = "sha256:92e59a70bcbd9d3a5483656da906ec28edfdacfce00afd99edb8b4e9d15644be", size = 10333134, upload-time = "2026-10-01T18:03:08.25Z" },
-    { url = "https://files.pythonhosted.org/packages/21/aa/5c9f3b68737c0e4a33a1db5dfab44f7b786d96ca91a7233112ddab1e6dc2/ruff-0.16.10-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:7ae7375f803b5520dc9f546bed7e3a0acb70b91812e9bb4b19927de22f25b77d", size = 10741702, upload-time = "2026-10-01T18:03:10.775Z" },
-    { url = "https://files.pythonhosted.org/packages/78/fa/0f9c2020dc316c53d983be011720b8157cc052b97e3f4dfa7db6d0f880a6/ruff-0.16.10-py3-none-win32.whl", hash = "sha256:2a12e01cb9156c10c466f63b46eaae5ecea28dfbd21b5836353ae498e7d1349a", size = 10139176, upload-time = "2026-10-01T18:03:13.267Z" },
-    { url = "https://files.pythonhosted.org/packages/99/29/cfb0df9448d4d4ad48c2de029ada9ebd71baa6da983a6c77ee6c6cd0fe82/ruff-0.16.10-py3-none-win_amd64.whl", hash = "sha256:97f2015c92aa97105b0eab19eb5d224884399281cfc5da86a92db4ab5e7fb2ca", size = 10584734, upload-time = "2026-10-01T18:03:16.006Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/05/c16957eb287c3fc062e032619a25868d93d408a844b725bcf514f7a378ff/ruff-0.16.10-py3-none-win_arm64.whl", hash = "sha256:25a65fe998c4e6861ec079ada5826a2fc605e6cbccbe9dcd7fac1f54e791621b", size = 10366440, upload-time = "2026-10-01T18:03:19.04Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/8c/083365310c4e79c842f25bf5a842facbd9b0c0ec336f96dffa5074fe723d/ruff-0.17.3-py3-none-linux_armv6l.whl", hash = "sha256:ab86b84cd9d05e56d329742c0cabdcbe2d1d56c98f4a04aab9b5b66196febfb4", size = 10216522, upload-time = "2026-10-27T00:33:29.822Z" },
+    { url = "https://files.pythonhosted.org/packages/72/26/4b2edf31cfebe9605d8f6ed8f1d6f376d3a53d4c9a123e62661c64c440f0/ruff-0.17.3-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:e407b4a6852853a9a2cdce96963e94ad9775578bb44e7561a0f2829f3cc04b11", size = 10217786, upload-time = "2026-10-27T00:33:33.949Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/7e/537aba4b7f54397a374d2f6a6fc93e9c8015e18553f31a4a7b7dbced48b5/ruff-0.17.3-py3-none-macosx_11_0_arm64.whl", hash = "sha256:b75cc113b3aca388933d8296b667b1ac401a80317ea3074c9b0a66541199da29", size = 9440362, upload-time = "2026-10-27T00:33:35.784Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/66/283e39734f66c8a5ebaa93c22eb7b7515779a0b1d5a5c0ad20e05c0edb41/ruff-0.17.3-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ab5fa7ed5ce18554ea69d850ad162cbaa0c85fc47c08d83a569f806681c9a6ad", size = 10094281, upload-time = "2026-10-27T00:33:38.216Z" },
+    { url = "https://files.pythonhosted.org/packages/21/4c/1ffc768497bd025a32c72152771e40c0b99bddc5cc6e4f50c7949a395346/ruff-0.17.3-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c673c170e27834d1262e3a9c1e97bdc9b9c3b180c63d89173ce69747232474c1", size = 10022543, upload-time = "2026-10-27T00:33:40.181Z" },
+    { url = "https://files.pythonhosted.org/packages/73/c3/f90db547301080fcb82c92abf914c8bd57b89911d9b65a6c4cc6b52d0635/ruff-0.17.3-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6a754c0341bc9ca151b7b335988b3263921c08859f84ca219b70cee825571b6f", size = 10683921, upload-time = "2026-10-27T00:33:42.182Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/98/92d4a8a26c6c96cf1a5b34dd59036d8a71e52d650aab065c58867e964e63/ruff-0.17.3-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4590b9d86c0b1543ebb09094254e191cd43fe8edaf330baa035aab03da251532", size = 11373408, upload-time = "2026-10-27T00:33:44.19Z" },
+    { url = "https://files.pythonhosted.org/packages/43/02/1f24d2e3064c9753926deeb901afa57777b37ee46799b09ddd7aee6e5145/ruff-0.17.3-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bbde18beccd98c29a227c63c99022e3443b99258e08326df6425dfe0443705ef", size = 10977469, upload-time = "2026-10-27T00:33:46.179Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/20/fecedea2209f574ab92033b344e01a7f0c2dc76c6d6d19a14c9f8141173f/ruff-0.17.3-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7fa4b0f931cdbcb8a52044f370a3eb429fb42eb88807b0e800fcaa98dd42b24e", size = 10577491, upload-time = "2026-10-27T00:33:48.233Z" },
+    { url = "https://files.pythonhosted.org/packages/33/36/b93fdf0bc6f84f0cd487aadfb0354deb40013669ea35ac3d26855de1e959/ruff-0.17.3-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:39405f341deec934b4289634324ad695f72df2970f9121582872eaf5b722f0f5", size = 10608748, upload-time = "2026-10-27T00:33:50.284Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/b7/7d3f5f14145daead1efb0b9a8289ed1daa100f419d60774375951723ce00/ruff-0.17.3-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:68074094f55ca3d29ab19491f640282f7a84061c4c7977aa5094b968ca457e9a", size = 10075057, upload-time = "2026-10-27T00:33:52.074Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/ed/93ff7a5909ee56e2bd4b982deae9e0efb2724417874a90c9e41ad66c6dd7/ruff-0.17.3-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:27bb571ac78fef178fe5118d2827df95c2aae74a48fff2b15f6acd03af5ff5bb", size = 10022431, upload-time = "2026-10-27T00:33:54.061Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/07/a83b9eeec8c1c3c0e4eda15f06c3a91001bfd2687ea2f07b750719bf9712/ruff-0.17.3-py3-none-musllinux_1_2_i686.whl", hash = "sha256:029c37cbd3de48ca37aa12117bead2d065f15da17d66bf84e0d4274013705db2", size = 10394903, upload-time = "2026-10-27T00:33:56.158Z" },
+    { url = "https://files.pythonhosted.org/packages/af/b2/05c39857c2526fcbebe46ad93a8dc97424656dfef14d3ef933abe1ffd331/ruff-0.17.3-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:692fdb46d0fd9c71e380947dc5fc72f2c3f881073bc1f739e4579376231affbe", size = 10799780, upload-time = "2026-10-27T00:33:58.204Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/d9/47171a16739eb7a353936b31c20cf54340531e68c9af7d72fd7a784e235d/ruff-0.17.3-py3-none-win32.whl", hash = "sha256:46539cb031b01fd29ae0a02142483c46640b233ee12bb1c1b690bffa1555d5ca", size = 9908481, upload-time = "2026-10-27T00:34:00.087Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/a0/f08c1631bfd81faa6a90eaf70c37c786c11bed2046302b56bb506c25e1a0/ruff-0.17.3-py3-none-win_amd64.whl", hash = "sha256:56b8ffb3f3b3cbccb8b76b71b38261b7ed982ef5d20f5b447b1b61a7f4949b24", size = 10341333, upload-time = "2026-10-27T00:34:02.099Z" },
+    { url = "https://files.pythonhosted.org/packages/99/d5/4ad4ed31413c301430918e70d3d38ae6f097af0766cb9ab8c9d502b2a4d6/ruff-0.17.3-py3-none-win_arm64.whl", hash = "sha256:81fce74bcd6be0e9da7c67c7553fd0f1f12964a2052cd728ef917b937a5ca1d9", size = 9854332, upload-time = "2026-10-27T00:34:03.847Z" },
 ]
 
 [[package]]
@@ -40,4 +40,4 @@ dev = [
 [package.metadata]
 
 [package.metadata.requires-dev]
-dev = [{ name = "ruff", specifier = ">=0,<1" }]
+dev = [{ name = "ruff", specifier = ">=0.17.3,<1" }]
diff --git a/src/cli.rs b/src/cli.rs
index bcbaff9..5dcfca9 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -6,7 +6,8 @@ use std::{
     path::PathBuf,
     process::ExitCode,
 };
-use vole::invoke::{InvokePath, invoke_bytes};
+use vole::invoke::{InvokePath, invoke_owned_bytes};
+use zeroize::{Zeroize, Zeroizing};
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum Mode {
     Help,
@@ -15,11 +16,28 @@ enum Mode {
     Run,
 }
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(PartialEq, Eq)]
 struct Options {
     mode: Mode,
     data_dir: Option<PathBuf>,
     config_file: Option<PathBuf>,
+    config_string: Option<Zeroizing<String>>,
+    age_secret_key: Option<Zeroizing<String>>,
+    external_controller: Option<Zeroizing<String>>,
+    external_controller_tls: Option<Zeroizing<String>>,
+    external_controller_unix: Option<Zeroizing<String>>,
+    external_controller_routing_mark: Option<i64>,
+    secret: Option<Zeroizing<String>>,
+    http_config_file: Option<PathBuf>,
+    http_ca_file: Option<PathBuf>,
+}
+
+impl std::fmt::Debug for Options {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Options")
+            .field("mode", &self.mode)
+            .finish_non_exhaustive()
+    }
 }
 
 impl Options {
@@ -32,6 +50,15 @@ impl Options {
         let (mut version, mut validate) = (false, false);
         let mut data_dir = data_dir.map(PathBuf::from);
         let mut config_file = config_file.map(PathBuf::from);
+        let mut config_string = None;
+        let mut age_secret_key = None;
+        let mut external_controller = None;
+        let mut external_controller_tls = None;
+        let mut external_controller_unix = None;
+        let mut external_controller_routing_mark = None;
+        let mut secret = None;
+        let mut http_config_file = None;
+        let mut http_ca_file = None;
         while let Some(argument) = arguments.next() {
             let Some((flag, inline)) = flag_parts(&argument)? else {
                 // Like Go flag, a positional argument or -- ends parsing.
@@ -45,6 +72,15 @@ impl Options {
                         mode: Mode::Help,
                         data_dir,
                         config_file,
+                        config_string,
+                        age_secret_key,
+                        external_controller,
+                        external_controller_tls,
+                        external_controller_unix,
+                        external_controller_routing_mark,
+                        secret,
+                        http_config_file,
+                        http_ca_file,
                     });
                 }
                 b"v" | b"t" => {
@@ -55,6 +91,57 @@ impl Options {
                         validate = value;
                     }
                 }
+                b"ext-ctl-routing-mark" => {
+                    let value = inline
+                        .map(OsStr::to_owned)
+                        .or_else(|| arguments.next())
+                        .ok_or(CliError::argument(
+                            "missing value for -ext-ctl-routing-mark",
+                        ))?;
+                    external_controller_routing_mark = Some(parse_go_int(&value)?);
+                }
+                b"config" | b"age-secret-key" | b"ext-ctl" | b"ext-ctl-tls" | b"ext-ctl-unix"
+                | b"secret" => {
+                    let value = inline
+                        .map(OsStr::to_owned)
+                        .or_else(|| arguments.next())
+                        .ok_or(CliError::argument(match flag {
+                            b"config" => "missing value for -config",
+                            b"age-secret-key" => "missing value for -age-secret-key",
+                            b"ext-ctl" => "missing value for -ext-ctl",
+                            b"ext-ctl-tls" => "missing value for -ext-ctl-tls",
+                            b"ext-ctl-unix" => "missing value for -ext-ctl-unix",
+                            _ => "missing value for -secret",
+                        }))?;
+                    let value = value.into_string().map(Zeroizing::new).map_err(|value| {
+                        drop(Zeroizing::new(value.into_encoded_bytes()));
+                        CliError::argument("text option requires UTF-8")
+                    })?;
+                    match flag {
+                        b"config" => config_string = Some(value),
+                        b"age-secret-key" => age_secret_key = Some(value),
+                        b"ext-ctl" => external_controller = Some(value),
+                        b"ext-ctl-tls" => external_controller_tls = Some(value),
+                        b"ext-ctl-unix" => external_controller_unix = Some(value),
+                        _ => secret = Some(value),
+                    }
+                    drop(Zeroizing::new(argument.into_encoded_bytes()));
+                }
+                b"http-config" | b"http-ca" => {
+                    let value = inline
+                        .map(OsStr::to_owned)
+                        .or_else(|| arguments.next())
+                        .ok_or(CliError::argument(if flag == b"http-ca" {
+                            "missing value for -http-ca"
+                        } else {
+                            "missing value for -http-config"
+                        }))?;
+                    if flag == b"http-ca" {
+                        http_ca_file = Some(PathBuf::from(value));
+                    } else {
+                        http_config_file = Some(PathBuf::from(value));
+                    }
+                }
                 b"d" | b"f" => {
                     let value = inline
                         .map(OsStr::to_owned)
@@ -83,6 +170,15 @@ impl Options {
             },
             data_dir,
             config_file,
+            config_string,
+            age_secret_key,
+            external_controller,
+            external_controller_tls,
+            external_controller_unix,
+            external_controller_routing_mark,
+            secret,
+            http_config_file,
+            http_ca_file,
         })
     }
 }
@@ -110,6 +206,87 @@ fn flag_parts(argument: &OsStr) -> Result<Option<ParsedFlag<'_>>, CliError> {
     }
 }
 
+// Go flag.IntVar uses strconv.ParseInt(base=0, bitSize=strconv.IntSize).
+fn parse_go_int(value: &OsStr) -> Result<i64, CliError> {
+    let invalid = || CliError::argument("invalid integer option value");
+    let mut digits = value.as_encoded_bytes();
+    let negative = digits.first() == Some(&b'-');
+    if matches!(digits.first(), Some(b'+' | b'-')) {
+        digits = &digits[1..];
+    }
+    if digits.is_empty() {
+        return Err(invalid());
+    }
+    let mut radix = 10_u64;
+    let mut prefix = false;
+    if digits.len() > 1 && digits[0] == b'0' {
+        prefix = true;
+        let offset = match digits[1] {
+            b'x' | b'X' => {
+                radix = 16;
+                2
+            }
+            b'b' | b'B' => {
+                radix = 2;
+                2
+            }
+            b'o' | b'O' => {
+                radix = 8;
+                2
+            }
+            _ => {
+                radix = 8;
+                1
+            }
+        };
+        digits = &digits[offset..];
+    }
+    let decode = |byte: u8| {
+        match byte {
+            b'0'..=b'9' => Some(u64::from(byte - b'0')),
+            b'a'..=b'f' => Some(u64::from(byte - b'a' + 10)),
+            b'A'..=b'F' => Some(u64::from(byte - b'A' + 10)),
+            _ => None,
+        }
+        .filter(|digit| *digit < radix)
+    };
+    let limit = (isize::MAX as u64) + u64::from(negative);
+    let mut value = 0_u64;
+    let mut previous_digit = false;
+    let mut any_digit = false;
+    for (index, &byte) in digits.iter().enumerate() {
+        if byte == b'_' {
+            if !(previous_digit || index == 0 && prefix)
+                || digits
+                    .get(index + 1)
+                    .and_then(|next| decode(*next))
+                    .is_none()
+            {
+                return Err(invalid());
+            }
+            previous_digit = false;
+        } else {
+            let digit = decode(byte).ok_or_else(invalid)?;
+            value = value
+                .checked_mul(radix)
+                .and_then(|value| value.checked_add(digit))
+                .filter(|value| *value <= limit)
+                .ok_or_else(invalid)?;
+            previous_digit = true;
+            any_digit = true;
+        }
+    }
+    if !any_digit {
+        return Err(invalid());
+    }
+    let signed = if negative {
+        -(value as i128)
+    } else {
+        value as i128
+    };
+    Ok(signed as i64)
+}
+
 fn parse_bool(value: &OsStr) -> Result<bool, CliError> {
     match value.as_encoded_bytes() {
         b"1" | b"t" | b"T" | b"TRUE" | b"true" | b"True" => Ok(true),
@@ -126,6 +303,9 @@ impl CliError {
     }
 }
 fn request(options: Options) -> Value {
+    if options.mode == Mode::Help {
+        return json!({"method":"foreground","payload":{"action":"help"}});
+    }
     if options.mode == Mode::Version {
         return json!({"method":"version","payload":{}});
     }
@@ -138,12 +318,44 @@ fn request(options: Options) -> Value {
         payload["configPath"] =
             serde_json::to_value(InvokePath::from(path)).expect("native path serialization");
     }
-    json!({"method":"foreground","payload":payload})
+    for (name, value) in [
+        ("configString", options.config_string),
+        ("ageSecretKey", options.age_secret_key),
+        ("externalController", options.external_controller),
+        ("externalControllerTls", options.external_controller_tls),
+        ("externalControllerUnix", options.external_controller_unix),
+        ("secret", options.secret),
+    ] {
+        if let Some(mut value) = value {
+            payload[name] = Value::String(std::mem::take(&mut *value));
+        }
+    }
+    if let Some(mark) = options.external_controller_routing_mark {
+        payload["externalControllerRoutingMark"] = Value::from(mark);
+    }
+    if let Some(path) = options.http_config_file {
+        payload["httpConfigPath"] =
+            serde_json::to_value(InvokePath::from(path)).expect("native path serialization");
+    }
+    if let Some(path) = options.http_ca_file {
+        payload["httpCaPath"] =
+            serde_json::to_value(InvokePath::from(path)).expect("native path serialization");
+    }
+    let mut request = json!({"method":"foreground"});
+    request["payload"] = payload;
+    request
 }
-fn call(request: Value) -> Result<Value, CliError> {
-    let bytes =
-        serde_json::to_vec(&request).map_err(|_| CliError("request serialization failed"))?;
-    serde_json::from_slice(&invoke_bytes(&bytes)).map_err(|_| CliError("invalid Invoke response"))
+fn call(mut request: Value) -> Result<Value, CliError> {
+    let bytes = serde_json::to_vec(&request);
+    for name in ["configString", "ageSecretKey", "secret"] {
+        if let Some(Value::String(value)) = request["payload"].get_mut(name) {
+            value.zeroize();
+        }
+    }
+    drop(request);
+    let bytes = bytes.map_err(|_| CliError("request serialization failed"))?;
+    serde_json::from_slice(&invoke_owned_bytes(bytes))
+        .map_err(|_| CliError("invalid Invoke response"))
 }
 fn render(
     response: &Value,
@@ -198,6 +410,51 @@ mod tests {
     fn parse(args: &[&str]) -> Result<Options, CliError> {
         Options::parse(args.iter().map(OsString::from), None, None)
     }
+    #[test]
+    fn controller_mark_flag_uses_go_integer_syntax_and_numeric_invoke_metadata() {
+        for (input, expected) in [
+            ("42", 42),
+            ("0x2a", 42),
+            ("0o52", 42),
+            ("0b10_1010", 42),
+            ("052", 42),
+            ("0x_2a", 42),
+            ("-1", -1),
+            ("+0", 0),
+        ] {
+            let options = Options::parse(
+                ["-t".into(), format!("-ext-ctl-routing-mark={input}").into()],
+                None,
+                None,
+            )
+            .unwrap();
+            assert_eq!(
+                request(options)["payload"]["externalControllerRoutingMark"],
+                expected
+            );
+        }
+        for invalid in ["08", "1__2", "0x", "9223372036854775808"] {
+            assert!(
+                Options::parse(
+                    [
+                        "-t".into(),
+                        format!("-ext-ctl-routing-mark={invalid}").into()
+                    ],
+                    None,
+                    None
+                )
+                .is_err()
+            );
+        }
+    }
+    #[test]
+    fn unix_controller_flag_only_transports_the_explicit_text_value() {
+        let options = Options::parse(["-ext-ctl-unix=/run/vole.sock".into()], None, None).unwrap();
+        let value = request(options);
+        assert_eq!(value["payload"]["externalControllerUnix"], "/run/vole.sock");
+        assert!(Options::parse(["-ext-ctl-unix".into()], None, None).is_err());
+    }
+
     #[test]
     fn supported_go_flag_spellings_and_priority() {
         for value in ["true", "T", "TRUE", "1", "t", "True"] {
@@ -265,6 +522,50 @@ mod tests {
         );
     }
     #[test]
+    fn encoded_configuration_and_age_options_only_transport_text() {
+        let options = parse(&[
+            "-config",
+            "c2VjcmV0",
+            "--age-secret-key=private-fixture",
+            "-t",
+        ])
+        .unwrap();
+        assert!(!format!("{options:?}").contains("private-fixture"));
+        assert!(!format!("{options:?}").contains("c2VjcmV0"));
+        let value = request(options);
+        assert_eq!(value["payload"]["configString"], "c2VjcmV0");
+        assert_eq!(value["payload"]["ageSecretKey"], "private-fixture");
+        assert_eq!(
+            request(parse(&["-config=", "-t"]).unwrap())["payload"]["configString"],
+            ""
+        );
+        assert_eq!(
+            request(parse(&["-config=invalid", "-v"]).unwrap()),
+            json!({"method":"version","payload":{}})
+        );
+    }
+    #[test]
+    fn controller_override_options_only_transport_specific_values() {
+        let options = parse(&[
+            "-ext-ctl=:9900",
+            "--ext-ctl-tls",
+            "localhost:9943",
+            "-secret",
+            "private-token",
+            "-t",
+        ])
+        .unwrap();
+        assert!(!format!("{options:?}").contains("private-token"));
+        let value = request(options);
+        assert_eq!(value["payload"]["externalController"], ":9900");
+        assert_eq!(value["payload"]["externalControllerTls"], "localhost:9943");
+        assert_eq!(value["payload"]["secret"], "private-token");
+        assert_eq!(
+            request(parse(&["-secret=", "-t"]).unwrap())["payload"]["secret"],
+            ""
+        );
+    }
+    #[test]
     fn result_streams_and_failure_status() {
         let mut out = Vec::new();
         let mut err = Vec::new();
@@ -289,4 +590,27 @@ mod tests {
             1
         );
     }
+
+    #[test]
+    fn http_addendum_option_only_transports_an_explicit_native_path() {
+        for option in ["-http-config=extra.yaml", "--http-config=extra.yaml"] {
+            let value = request(parse(&[option, "-t"]).unwrap());
+            assert_eq!(value["payload"]["httpConfigPath"], "extra.yaml");
+        }
+        let value = request(
+            parse(&[
+                "-http-config",
+                "extra.yaml",
+                "-http-ca",
+                "private.json",
+                "-t",
+            ])
+            .unwrap(),
+        );
+        assert_eq!(value["payload"]["httpCaPath"], "private.json");
+        assert_eq!(
+            request(parse(&["-http-config", "extra.yaml", "-v"]).unwrap()),
+            json!({"method":"version","payload":{}})
+        );
+    }
 }
diff --git a/src/config/anytls.rs b/src/config/anytls.rs
new file mode 100644
index 0000000..4aca682
--- /dev/null
+++ b/src/config/anytls.rs
@@ -0,0 +1,70 @@
+use std::time::Duration;
+
+use super::invalid;
+use crate::Result;
+
+#[derive(Clone, PartialEq, Eq)]
+pub struct AnyTlsSessionOptions {
+    pub check_interval: Duration,
+    pub idle_timeout: Duration,
+    pub min_idle: usize,
+    pub disable_reuse: bool,
+    pub client_metadata: String,
+}
+
+impl Default for AnyTlsSessionOptions {
+    fn default() -> Self {
+        Self {
+            check_interval: Duration::from_secs(30),
+            idle_timeout: Duration::from_secs(30),
+            min_idle: 0,
+            disable_reuse: false,
+            client_metadata: String::new(),
+        }
+    }
+}
+
+impl std::fmt::Debug for AnyTlsSessionOptions {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("AnyTlsSessionOptions")
+            .field("check_interval", &self.check_interval)
+            .field("idle_timeout", &self.idle_timeout)
+            .field("min_idle", &self.min_idle)
+            .field("disable_reuse", &self.disable_reuse)
+            .finish_non_exhaustive()
+    }
+}
+
+impl AnyTlsSessionOptions {
+    pub(super) fn normalize(
+        interval: i64,
+        timeout: i64,
+        minimum: i64,
+        disable_reuse: bool,
+        client_metadata: String,
+    ) -> Result<Self> {
+        // Settings are a newline-delimited map. An embedded delimiter would
+        // turn metadata into other settings instead of a single client value.
+        if client_metadata.len() > usize::from(u16::MAX) - 80 || client_metadata.contains('\n') {
+            return invalid("AnyTLS client-metadata exceeds the Settings value boundary");
+        }
+        fn seconds(value: i64) -> Result<Duration> {
+            let duration = Duration::from_secs(if value <= 5 { 30 } else { value as u64 });
+            if std::time::Instant::now().checked_add(duration).is_none() {
+                return invalid("AnyTLS session interval exceeds the clock range");
+            }
+            Ok(duration)
+        }
+        Ok(Self {
+            check_interval: seconds(interval)?,
+            idle_timeout: seconds(timeout)?,
+            min_idle: usize::try_from(minimum.max(0)).map_err(|_| {
+                crate::VoleError::InvalidConfig(
+                    "AnyTLS min-idle-session exceeds the platform range".into(),
+                )
+            })?,
+            disable_reuse,
+            client_metadata,
+        })
+    }
+}
diff --git a/src/config/controller.rs b/src/config/controller.rs
new file mode 100644
index 0000000..a18a848
--- /dev/null
+++ b/src/config/controller.rs
@@ -0,0 +1,126 @@
+use std::sync::Arc;
+
+use serde::Deserialize;
+
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct ControllerCors {
+    #[serde(rename = "allow-origins", default)]
+    pub allow_origins: Vec<String>,
+    #[serde(rename = "allow-private-network", default = "private_network_default")]
+    pub allow_private_network: bool,
+}
+
+fn private_network_default() -> bool {
+    true
+}
+
+impl Default for ControllerCors {
+    fn default() -> Self {
+        Self {
+            allow_origins: Vec::new(),
+            allow_private_network: true,
+        }
+    }
+}
+
+#[derive(Clone, Default, PartialEq, Eq, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct ControllerTls {
+    #[serde(default)]
+    pub certificate: Arc<str>,
+    #[serde(rename = "private-key", default)]
+    pub private_key: Arc<str>,
+    #[serde(rename = "client-auth-type", default)]
+    pub client_auth_type: Arc<str>,
+    #[serde(rename = "client-auth-cert", default)]
+    pub client_auth_cert: Arc<str>,
+}
+
+impl std::fmt::Debug for ControllerTls {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ControllerTls").finish_non_exhaustive()
+    }
+}
+
+pub(crate) fn normalize_mark(value: i64) -> super::Result<u32> {
+    super::EgressOptions::normalize(String::new(), value).map(|options| options.routing_mark)
+}
+
+pub(crate) fn normalize_unix(value: Option<String>) -> super::Result<Option<String>> {
+    let Some(value) = value.filter(|value| !value.is_empty()) else {
+        return Ok(None);
+    };
+    if value.contains('\0') {
+        return super::invalid("external-controller-unix requires a filesystem path without NUL");
+    }
+    Ok(Some(value))
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn controller_mark_uses_socket_range_without_changing_business_egress() {
+        use super::super::Config;
+        let config = Config::parse_yaml(b"routing-mark: 9\nexternal-controller: ':9000'\nexternal-controller-routing-mark: -1\n").unwrap();
+        assert_eq!(config.egress.routing_mark, 9);
+        assert_eq!(config.external_controller.unwrap().routing_mark, u32::MAX);
+        assert!(
+            Config::parse_yaml(b"external-controller-routing-mark: 7\n")
+                .unwrap()
+                .external_controller
+                .is_none()
+        );
+        for value in [i64::from(i32::MIN) - 1, i64::from(u32::MAX) + 1] {
+            assert!(super::normalize_mark(value).is_err());
+        }
+    }
+    #[test]
+    fn controller_unix_is_independent_of_network_listeners_and_keeps_secret() {
+        use super::super::Config;
+        let config = Config::parse_yaml(
+            b"external-controller-unix: controller.sock\nsecret: network-token\n",
+        )
+        .unwrap();
+        let controller = config.external_controller.unwrap();
+        assert!(!controller.http_enabled);
+        assert!(controller.tls_listen.is_none());
+        assert_eq!(controller.unix_path.as_deref(), Some("controller.sock"));
+        assert_eq!(controller.secret.as_deref(), Some("network-token"));
+        assert!(
+            Config::parse_yaml(b"external-controller-unix: ''\nsecret: retained\n")
+                .unwrap()
+                .external_controller
+                .is_none()
+        );
+        assert!(Config::parse_yaml(b"external-controller-unix: 7\n").is_err());
+        assert!(super::normalize_unix(Some("bad\0path".into())).is_err());
+    }
+    #[test]
+    fn controller_secure_configuration_keeps_http_tls_and_client_trust_separate() {
+        let config = super::super::Config::parse_yaml(
+            b"external-controller: 127.0.0.1:0\nexternal-controller-tls: 127.0.0.1:0\nsecret: token\nexternal-controller-cors:\n  allow-origins: ['https://*.example']\n  allow-private-network: true\ntls:\n  certificate: certificate-material\n  private-key: secret-private-material\n  client-auth-type: unknown-mode\n",
+        )
+        .unwrap();
+        assert!(config.tls.certificates.is_empty());
+        let controller = config.external_controller.unwrap();
+        assert!(controller.http_enabled);
+        assert!(controller.tls_listen.is_some());
+        assert!(controller.cors.allow_private_network);
+        assert_eq!(controller.cors.allow_origins, ["https://*.example"]);
+        assert_eq!(&*controller.server_tls.client_auth_type, "unknown-mode");
+        assert!(!format!("{:?}", controller.server_tls).contains("secret-private-material"));
+        let tls_only = super::super::Config::parse_yaml(b"external-controller-tls: 127.0.0.1:0\n")
+            .unwrap()
+            .external_controller
+            .unwrap();
+        assert!(!tls_only.http_enabled);
+        assert!(tls_only.tls_listen.is_some());
+        assert!(tls_only.cors.allow_private_network);
+        let explicit: super::ControllerCors =
+            serde_yaml_ng::from_str("allow-private-network: false").unwrap();
+        assert!(!explicit.allow_private_network);
+        let omitted: super::ControllerCors = serde_yaml_ng::from_str("{}").unwrap();
+        assert!(omitted.allow_private_network);
+    }
+}
diff --git a/src/config/credentials.rs b/src/config/credentials.rs
index db4dac0..1cb9874 100644
--- a/src/config/credentials.rs
+++ b/src/config/credentials.rs
@@ -1,12 +1,11 @@
-use std::io;
+use std::{io, net::IpAddr, sync::Arc};
 
 use base64::{Engine as _, engine::general_purpose::STANDARD};
 
-/// One client-proxy credential shared by the HTTP and SOCKS5 frontends.
+/// Client-proxy credentials shared by the HTTP and SOCKS5 frontends.
 #[derive(Clone, PartialEq, Eq)]
 pub struct ProxyCredentials {
-    username: String,
-    password: String,
+    entries: Vec<(Arc<str>, String)>,
 }
 
 impl std::fmt::Debug for ProxyCredentials {
@@ -21,78 +20,181 @@ impl ProxyCredentials {
     pub fn new(username: impl Into<String>, password: impl Into<String>) -> io::Result<Self> {
         let username = username.into();
         let password = password.into();
-        for (kind, value) in [("user", &username), ("password", &password)] {
-            if !(1..=255).contains(&value.len()) {
-                return Err(io::Error::new(
-                    io::ErrorKind::InvalidInput,
-                    format!("authentication {kind} must contain between 1 and 255 UTF-8 bytes"),
-                ));
-            }
-        }
         if username.contains(':') {
             return Err(io::Error::new(
                 io::ErrorKind::InvalidInput,
                 "authentication user must not contain `:`",
             ));
         }
-        Ok(Self { username, password })
+        Ok(Self {
+            entries: vec![(Arc::from(username), password)],
+        })
     }
 
     #[must_use]
     pub fn matches(&self, username: &[u8], password: &[u8]) -> bool {
-        // Always compare both fixed-size credential slots; never expose the
-        // matching prefix or short-circuit after a successful username check.
-        let mut difference = username.len() ^ self.username.len();
-        difference |= password.len() ^ self.password.len();
-        for index in 0..255 {
-            difference |= usize::from(
-                username.get(index).copied().unwrap_or(0)
-                    ^ self.username.as_bytes().get(index).copied().unwrap_or(0),
-            );
-            difference |= usize::from(
-                password.get(index).copied().unwrap_or(0)
-                    ^ self.password.as_bytes().get(index).copied().unwrap_or(0),
-            );
+        self.authenticate(username, password).is_some()
+    }
+
+    pub(crate) fn authenticate(&self, username: &[u8], password: &[u8]) -> Option<Arc<str>> {
+        let mut matched = None;
+        for (expected_user, expected_password) in &self.entries {
+            let mut difference = username.len() ^ expected_user.len();
+            difference |= password.len() ^ expected_password.len();
+            // Cover both complete fields without an early exit on content.
+            // HTTP credentials are not limited by SOCKS5's one-byte lengths.
+            let length = username
+                .len()
+                .max(expected_user.len())
+                .max(password.len())
+                .max(expected_password.len());
+            for index in 0..length {
+                difference |= usize::from(
+                    username.get(index).copied().unwrap_or(0)
+                        ^ expected_user.as_bytes().get(index).copied().unwrap_or(0),
+                );
+                difference |= usize::from(
+                    password.get(index).copied().unwrap_or(0)
+                        ^ expected_password
+                            .as_bytes()
+                            .get(index)
+                            .copied()
+                            .unwrap_or(0),
+                );
+            }
+            if difference == 0 {
+                matched = Some(expected_user.clone());
+            }
+        }
+        matched
+    }
+    pub(crate) fn multiple(values: Vec<Self>) -> Self {
+        let mut entries = std::collections::BTreeMap::new();
+        for (username, password) in values.into_iter().flat_map(|value| value.entries) {
+            entries.insert(username, password);
+        }
+        Self {
+            entries: entries.into_iter().collect(),
         }
-        difference == 0
     }
 
     #[must_use]
     pub fn authorization_header_value(&self) -> String {
         format!(
             "Basic {}",
-            STANDARD.encode(format!("{}:{}", self.username, self.password))
+            STANDARD.encode(format!("{}:{}", self.entries[0].0, self.entries[0].1))
         )
     }
 
+    #[cfg(test)]
     pub(crate) fn verifies(&self, headers: &[(String, String)]) -> bool {
+        self.authenticate_headers(headers).is_some()
+    }
+
+    pub(crate) fn authenticate_headers(&self, headers: &[(String, String)]) -> Option<Arc<str>> {
         let mut values = headers
             .iter()
             .filter(|(name, _)| name.eq_ignore_ascii_case("proxy-authorization"))
             .map(|(_, value)| value.as_str());
         let (Some(value), None) = (values.next(), values.next()) else {
-            return false;
+            return None;
         };
         let mut parts = value.split_ascii_whitespace();
         let (Some(scheme), Some(encoded), None) = (parts.next(), parts.next(), parts.next()) else {
-            return false;
+            return None;
         };
-        if !scheme.eq_ignore_ascii_case("basic") || encoded.len() > 684 {
-            return false;
+        if !scheme.eq_ignore_ascii_case("basic")
+            || encoded.len() > crate::inbound::DEFAULT_HEADER_LIMIT
+        {
+            return None;
         }
         let Ok(decoded) = STANDARD.decode(encoded) else {
-            return false;
+            return None;
         };
-        let Some(separator) = decoded.iter().position(|&byte| byte == b':') else {
-            return false;
-        };
-        self.matches(&decoded[..separator], &decoded[separator + 1..])
+        let separator = decoded.iter().position(|&byte| byte == b':')?;
+        self.authenticate(&decoded[..separator], &decoded[separator + 1..])
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn http_credentials_cover_empty_values_and_complete_long_fields() {
+        for (user, password) in [("", ""), ("", "secret"), ("user", "")] {
+            let auth = ProxyCredentials::new(user, password).unwrap();
+            assert!(auth.verifies(&[(
+                "Proxy-Authorization".into(),
+                auth.authorization_header_value(),
+            )]));
+        }
+        let user = "u".repeat(600);
+        let password = "p".repeat(600);
+        let auth = ProxyCredentials::new(&user, &password).unwrap();
+        assert!(auth.verifies(&[(
+            "Proxy-Authorization".into(),
+            auth.authorization_header_value(),
+        )]));
+        let mut wrong_user = user.into_bytes();
+        let mut wrong_password = password.into_bytes();
+        wrong_user[599] = b'x';
+        assert!(!auth.matches(&wrong_user, &wrong_password));
+        wrong_user[599] = b'u';
+        wrong_password[599] = b'x';
+        assert!(!auth.matches(&wrong_user, &wrong_password));
+        assert!(!auth.matches(&wrong_user, &wrong_password[..599]));
+    }
+
+    #[test]
+    fn http_authentication_keeps_the_shared_header_budget() {
+        let auth = ProxyCredentials::new("user", "p".repeat(crate::inbound::DEFAULT_HEADER_LIMIT))
+            .unwrap();
+        assert!(!auth.verifies(&[(
+            "Proxy-Authorization".into(),
+            auth.authorization_header_value(),
+        )]));
     }
 }
 
 /// A fixed client-oriented listener policy, not an arbitrary address list.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct ProxyAccess {
+    pub bind_address: Option<IpAddr>,
     pub allow_lan: bool,
     pub ipv6: bool,
 }
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ProxyAccessRules {
+    pub allowed: Vec<super::IpCidr>,
+    pub denied: Vec<super::IpCidr>,
+    pub skip_auth: Vec<super::IpCidr>,
+}
+impl Default for ProxyAccessRules {
+    fn default() -> Self {
+        Self {
+            allowed: vec![
+                super::IpCidr {
+                    network: "0.0.0.0".parse().unwrap(),
+                    prefix_len: 0,
+                },
+                super::IpCidr {
+                    network: "::".parse().unwrap(),
+                    prefix_len: 0,
+                },
+            ],
+            denied: Vec::new(),
+            skip_auth: Vec::new(),
+        }
+    }
+}
+impl ProxyAccessRules {
+    pub fn permits(&self, address: IpAddr) -> bool {
+        self.allowed.iter().any(|cidr| cidr.contains(address))
+            && !self.denied.iter().any(|cidr| cidr.contains(address))
+    }
+    pub fn skips_auth(&self, address: IpAddr) -> bool {
+        self.skip_auth.iter().any(|cidr| cidr.contains(address))
+    }
+}
diff --git a/src/config/dns.rs b/src/config/dns.rs
new file mode 100644
index 0000000..46f3301
--- /dev/null
+++ b/src/config/dns.rs
@@ -0,0 +1,658 @@
+use super::*;
+
+pub(super) fn default_nameservers() -> Vec<String> {
+    ["https://doh.pub/dns-query", "tls://223.5.5.5:853"]
+        .map(str::to_owned)
+        .to_vec()
+}
+pub(super) fn default_bootstrap() -> Vec<String> {
+    ["114.114.114.114", "223.5.5.5", "8.8.8.8", "1.0.0.1"]
+        .map(str::to_owned)
+        .to_vec()
+}
+pub(super) fn redir_host() -> String {
+    "redir-host".into()
+}
+pub(super) fn default_ipv6_timeout() -> u64 {
+    100
+}
+
+impl Default for DnsConfig {
+    fn default() -> Self {
+        // Empty targets are sufficient for the built-in DIRECT upstreams.
+        let raw: RawDnsConfig = serde_yaml_ng::from_str("{}").expect("DNS defaults");
+        raw.normalize(&RouteTargetsByName::new())
+            .expect("valid DNS defaults")
+    }
+}
+impl DnsConfig {
+    pub(super) fn disabled() -> Result<Self> {
+        Ok(Self::default())
+    }
+}
+
+impl RawDnsConfig {
+    pub(super) fn normalize(self, targets: &RouteTargetsByName) -> Result<DnsConfig> {
+        if self.prefer_h3 && !cfg!(feature = "dns-quic") {
+            return invalid("DNS HTTP/3 support is disabled at build time");
+        }
+        let fake_ip = self.fake_ip()?;
+        if self.enable && self.nameserver.is_empty() {
+            return invalid("enabled DNS requires nameserver");
+        }
+        if self.default_nameserver.is_empty() {
+            return invalid("default-nameserver requires at least one server");
+        }
+        if (self.respect_rules || !self.proxy_policies.is_empty())
+            && self.proxy_nameserver.is_empty()
+        {
+            return invalid(
+                "respect-rules and proxy-server-nameserver-policy require proxy-server-nameserver",
+            );
+        }
+        let parse = |values: Vec<String>, route| {
+            values
+                .iter()
+                .map(|value| parse_dns_nameserver(value, targets, route))
+                .collect::<Result<Vec<_>>>()
+        };
+        let main_route = if self.respect_rules {
+            DnsRoute::Rules
+        } else {
+            DnsRoute::Direct
+        };
+        let default_nameservers = parse(self.default_nameserver, DnsRoute::Direct)?;
+        if default_nameservers.iter().any(|server| {
+            matches!(
+                server.address,
+                DnsAddress::Domain(_) | DnsAddress::Source(DnsSource::Dhcp(_))
+            )
+        }) {
+            return invalid("default-nameserver requires literal IP addresses");
+        }
+        let fallback = self
+            .fallback_filter
+            .normalize(parse(self.fallback, main_route)?, self.fallback_lazy_query)?;
+        Ok(DnsConfig {
+            fallback,
+            fake_ip,
+            enable: self.enable,
+            ipv6: self.ipv6,
+            prefer_h3: self.prefer_h3,
+            ipv6_timeout: Duration::from_millis(if self.ipv6_timeout == 0 {
+                default_ipv6_timeout()
+            } else {
+                self.ipv6_timeout
+            }),
+            cache_max_size: if self.cache_max_size == 0 {
+                crate::dns::MAX_CACHE_ENTRIES
+            } else {
+                self.cache_max_size
+            },
+            cache_algorithm: if self.cache_algorithm == "arc" {
+                DnsCacheAlgorithm::Arc
+            } else {
+                DnsCacheAlgorithm::Lru
+            },
+            nameservers: parse(self.nameserver, main_route)?,
+            nameserver_policies: normalize_dns_nameserver_policies(
+                self.nameserver_policies,
+                targets,
+                main_route,
+            )?,
+            default_nameservers,
+            proxy_nameservers: parse(self.proxy_nameserver, DnsRoute::Direct)?,
+            proxy_policies: normalize_dns_nameserver_policies(
+                self.proxy_policies,
+                targets,
+                DnsRoute::Direct,
+            )?,
+            direct_nameservers: parse(self.direct_nameserver, DnsRoute::Direct)?,
+            direct_follow_policy: self.direct_follow_policy,
+            use_hosts: self.use_hosts,
+            use_system_hosts: self.use_system_hosts,
+            hosts: vec![HostEntry {
+                pattern: "localhost".into(),
+                value: HostValue::Addresses(vec![IpAddr::V4(Ipv4Addr::LOCALHOST)]),
+            }],
+        })
+    }
+}
+
+pub(super) fn parse_dns_nameserver(
+    input: &str,
+    targets: &RouteTargetsByName,
+    default_route: DnsRoute,
+) -> Result<DnsNameserver> {
+    parse_dns_nameserver_with_route(input, Some(targets), default_route)
+}
+
+/// A node's private DNS fixes its dispatcher independently of the URL route
+/// token. Keep the original URL so every keyed option is decoded once.
+pub(super) fn parse_node_dns_nameserver(input: &str) -> Result<DnsNameserver> {
+    parse_dns_nameserver_with_route(input, None, DnsRoute::Direct)
+}
+
+fn parse_dns_nameserver_with_route(
+    input: &str,
+    targets: Option<&RouteTargetsByName>,
+    default_route: DnsRoute,
+) -> Result<DnsNameserver> {
+    let bad = || {
+        VoleError::InvalidConfig(
+            "invalid DNS upstream; supported transports are UDP, TCP, TLS, HTTP(S), QUIC, RCODE, system and DHCP"
+                .into(),
+        )
+    };
+    let (endpoint, fragment) = input.split_once('#').unwrap_or((input, ""));
+    let (route_name, mut options) =
+        parse_nameserver_options(fragment, !endpoint.starts_with("https://"))?;
+    // Special sources remain physical, but use the same query wrappers.
+    let source = match endpoint {
+        "system" | "system://" | "dhcp://system" => Some(DnsSource::System),
+        endpoint if endpoint.starts_with("dhcp://") => {
+            let interface = &endpoint[7..];
+            crate::dns::source::validate_interface(interface).map_err(|_| bad())?;
+            Some(DnsSource::Dhcp(interface.into()))
+        }
+        _ => None,
+    };
+    if let Some(source) = source {
+        return Ok(DnsNameserver {
+            address: DnsAddress::Source(source),
+            transport: DnsTransport::Udp,
+            port: 53,
+            route: DnsRoute::Direct,
+            path: None,
+            http_auth: None,
+            options,
+        });
+    }
+    let route = match targets {
+        Some(targets) if !route_name.is_empty() => match route_name.as_str() {
+            "DIRECT" | "COMPATIBLE" => DnsRoute::Direct,
+            "REJECT" => DnsRoute::Reject,
+            "REJECT-DROP" => DnsRoute::RejectDrop,
+            "RULES" => DnsRoute::Rules,
+            _ => match targets.get(&route_name).copied() {
+                Some(id) => DnsRoute::Route(id),
+                None => {
+                    options.interface = EgressOptions::normalize(route_name, 0)?.interface;
+                    DnsRoute::Direct
+                }
+            },
+        },
+        _ => default_route,
+    };
+    if let Ok(address) = endpoint.parse::<IpAddr>() {
+        return Ok(DnsNameserver {
+            address: address.into(),
+            transport: DnsTransport::Udp,
+            port: 53,
+            route,
+            path: None,
+            http_auth: None,
+            options,
+        });
+    }
+    let endpoint = if endpoint.contains("://") {
+        endpoint.to_owned()
+    } else {
+        format!("udp://{endpoint}")
+    };
+    let url = Url::parse(&endpoint).map_err(|_| bad())?;
+    if url.scheme() == "rcode" {
+        let host = url.host_str().ok_or_else(bad)?;
+        let rcode = match host {
+            "success" => 0,
+            "format_error" => 1,
+            "server_failure" => 2,
+            "name_error" => 3,
+            "not_implemented" => 4,
+            "refused" => 5,
+            _ => return Err(bad()),
+        };
+        // Mihomo selects the local client by URL host. Paths and query
+        // parameters do not modify its behavior; a port changes the host.
+        if url.port().is_some() {
+            return Err(bad());
+        }
+        return Ok(DnsNameserver {
+            transport: DnsTransport::Rcode(rcode),
+            address: DnsAddress::Domain(host.to_owned()),
+            port: 0,
+            route,
+            path: None,
+            http_auth: None,
+            options,
+        });
+    }
+    let (transport, default_port) = match url.scheme() {
+        "udp" => (DnsTransport::Udp, 53),
+        "tcp" => (DnsTransport::Tcp, 53),
+        "tls" => (DnsTransport::Tls, 853),
+        "https" => (DnsTransport::Https, 443),
+        "http" => (DnsTransport::Http, 80),
+        "quic" if cfg!(feature = "dns-quic") => (DnsTransport::Quic, 853),
+        "quic" => return invalid("DNS QUIC support is disabled at build time"),
+        _ => return Err(bad()),
+    };
+    let http = matches!(transport, DnsTransport::Http | DnsTransport::Https);
+    let has_userinfo = endpoint.split_once("://").is_some_and(|(_, rest)| {
+        rest.split(['/', '?'])
+            .next()
+            .is_some_and(|authority| authority.contains('@'))
+    });
+    if url.fragment().is_some() {
+        return Err(bad());
+    }
+    let http_auth = if http && has_userinfo {
+        use base64::Engine as _;
+        let mut value = percent_decode_bytes(url.username())?;
+        value.push(b':');
+        value.extend_from_slice(&percent_decode_bytes(url.password().unwrap_or_default())?);
+        let encoded_len = value.len().div_ceil(3).saturating_mul(4);
+        if encoded_len + 6 > crate::dns::MAX_HTTP_HEADER_BYTES {
+            return invalid("DNS HTTP authentication exceeds the header budget");
+        }
+        Some(DnsHttpAuth(
+            format!(
+                "Basic {}",
+                base64::engine::general_purpose::STANDARD.encode(value)
+            )
+            .into(),
+        ))
+    } else {
+        None
+    };
+    let address = match url.host().ok_or_else(bad)? {
+        Host::Ipv4(ip) => DnsAddress::Ip(ip.into()),
+        Host::Ipv6(ip) => DnsAddress::Ip(ip.into()),
+        Host::Domain(host) => match host.parse::<IpAddr>() {
+            Ok(ip) => DnsAddress::Ip(ip),
+            Err(_) => DnsAddress::Domain(crate::dns::canonicalize_name(host).map_err(|_| bad())?),
+        },
+    };
+    let path = if http {
+        // URL's browser-style parser resolves dot segments; Mihomo's URL.Path
+        // keeps them. Decode the original path before rebuilding its escapes.
+        let rest = endpoint.split_once("://").expect("DNS URL has a scheme").1;
+        let path = rest.find(['/', '?']).map_or("/", |index| {
+            let tail = &rest[index..];
+            if tail.starts_with('/') {
+                tail.split('?').next().unwrap_or("/")
+            } else {
+                "/"
+            }
+        });
+        Some(normalize_http_path(path)?)
+    } else {
+        None
+    };
+    let port = url.port().unwrap_or(default_port);
+    validate_port(port, "DNS nameserver")?;
+    Ok(DnsNameserver {
+        transport,
+        address,
+        port,
+        route,
+        path,
+        http_auth,
+        options,
+    })
+}
+
+fn parse_nameserver_options(
+    fragment: &str,
+    ignore_h3: bool,
+) -> Result<(String, DnsNameserverOptions)> {
+    let fragment = percent_decode(fragment)?;
+    let mut route = String::new();
+    let mut params = std::collections::BTreeMap::new();
+    for part in fragment.split('&') {
+        if let Some((key, value)) = part.split_once('=') {
+            params.insert(key, value);
+        } else {
+            route = part.to_owned();
+        }
+    }
+    let mut options = DnsNameserverOptions::default();
+    let mut disabled = std::collections::BTreeSet::new();
+    for (key, value) in params {
+        match key {
+            "ecs" if !value.is_empty() => {
+                let (address, prefix) = value
+                    .split_once('/')
+                    .map_or((value, None), |(a, p)| (a, Some(p)));
+                let address = address
+                    .parse::<IpAddr>()
+                    .map_err(|_| VoleError::InvalidConfig("invalid DNS ECS address".into()))?;
+                let bits = if address.is_ipv4() { 32 } else { 128 };
+                let prefix_len = prefix
+                    .map_or(Ok(bits), |p| p.parse::<u8>())
+                    .map_err(|_| VoleError::InvalidConfig("invalid DNS ECS prefix".into()))?;
+                if prefix_len > bits {
+                    return invalid("invalid DNS ECS prefix");
+                }
+                options.ecs = Some(DnsEcs {
+                    address,
+                    prefix_len,
+                });
+            }
+            "ecs" => {}
+            "ecs-override" => options.ecs_override = value == "true",
+            "disable-ipv4" if value == "true" => {
+                disabled.insert(1);
+            }
+            "disable-ipv6" if value == "true" => {
+                disabled.insert(28);
+            }
+            "disable-ipv4" | "disable-ipv6" => {}
+            key if key.starts_with("disable-qtype-") => {
+                if value == "true"
+                    && let Ok(kind) = key[14..].parse::<u16>()
+                    && valid_disabled_type(kind)
+                {
+                    disabled.insert(kind);
+                }
+            }
+            "skip-cert-verify" => options.skip_cert_verify = value == "true",
+            "name-cert-verify" => {
+                options.verification_name = normalize_verification_name(Some(value.to_owned()))?
+            }
+            "disable-reuse" => options.disable_reuse = value == "true",
+            "h3" if value != "true" || ignore_h3 => {}
+            "h3" if cfg!(feature = "dns-quic") => options.force_h3 = true,
+            _ => return invalid("unsupported DNS upstream parameter"),
+        }
+    }
+    options.disabled_types = disabled.into_iter().collect();
+    Ok((route, options))
+}
+
+fn valid_disabled_type(kind: u16) -> bool {
+    // Registered RR constructors in the fixed Mihomo miekg/dns v1.1.63
+    // reference. Unknown 16-bit questions remain forwardable, not filters.
+    matches!(kind, 1..=10 | 12..=21 | 23..=33 | 35..=37 | 39 | 41..=53 | 55..=65 | 99..=102 | 104..=109 | 128 | 249 | 250 | 255..=258 | 260 | 32768 | 32769)
+}
+
+#[cfg(test)]
+mod upstream_options_tests {
+    use super::*;
+
+    #[test]
+    fn dns_interface_selector_prefers_proxy_names_and_separates_pool_identity() {
+        let mut targets = RouteTargetsByName::new();
+        let target = RouteTargetId::Proxy(ProxyId::from_index(0));
+        targets.insert("eth0".into(), target);
+        let proxy =
+            parse_dns_nameserver("tls://192.0.2.53#eth0", &targets, DnsRoute::Direct).unwrap();
+        assert_eq!(proxy.route, DnsRoute::Route(target));
+        assert!(proxy.options.interface.is_none());
+        let interface =
+            parse_dns_nameserver("tls://192.0.2.53#eth1", &targets, DnsRoute::Rules).unwrap();
+        assert_eq!(interface.route, DnsRoute::Direct);
+        assert_eq!(interface.options.interface.as_deref(), Some("eth1"));
+        let other =
+            parse_dns_nameserver("tls://192.0.2.53#eth2", &targets, DnsRoute::Direct).unwrap();
+        let mut keys = std::collections::HashSet::new();
+        keys.insert(interface);
+        keys.insert(other);
+        assert_eq!(keys.len(), 2);
+        assert_eq!(
+            parse_dns_nameserver(
+                "tcp://192.0.2.53#Ethernet%202&disable-reuse=true",
+                &targets,
+                DnsRoute::Direct
+            )
+            .unwrap()
+            .options
+            .interface
+            .as_deref(),
+            Some("Ethernet 2")
+        );
+    }
+
+    #[test]
+    fn dns_quic_feature_gates_and_plain_http_fragment() {
+        let targets = RouteTargetsByName::new();
+        let quic = parse_dns_nameserver("quic://dns.example", &targets, DnsRoute::Direct);
+        let h3 = parse_dns_nameserver(
+            "https://dns.example/dns-query#h3=true",
+            &targets,
+            DnsRoute::Direct,
+        );
+        let raw: RawDnsConfig = serde_yaml_ng::from_str("prefer-h3: true").unwrap();
+        let preferred = raw.normalize(&targets);
+        if cfg!(feature = "dns-quic") {
+            let quic = quic.unwrap();
+            assert_eq!(quic.port, 853);
+            assert_eq!(quic.transport, DnsTransport::Quic);
+            assert!(h3.unwrap().options.force_h3);
+            assert!(preferred.unwrap().prefer_h3);
+        } else {
+            assert!(quic.is_err());
+            assert!(h3.is_err());
+            assert!(preferred.is_err());
+        }
+        let http = parse_dns_nameserver(
+            "http://dns.example/dns-query#h3=true",
+            &targets,
+            DnsRoute::Direct,
+        )
+        .unwrap();
+        assert_eq!(http.transport, DnsTransport::Http);
+        assert!(!http.options.force_h3);
+    }
+
+    #[test]
+    fn doh_url_clears_query_and_preserves_only_decoded_basic_identity() {
+        use base64::Engine as _;
+        let server = parse_dns_nameserver(
+            "https://a%3Alice:p%40ss@dns.example/a%2Fb%20c?discard=secret#DIRECT&ecs=192.0.2.1",
+            &RouteTargetsByName::new(),
+            DnsRoute::Direct,
+        )
+        .unwrap();
+        assert_eq!(server.path.as_deref(), Some("/a/b%20c"));
+        assert_eq!(server.port, 443);
+        let auth = server.http_auth.as_ref().unwrap();
+        assert_eq!(
+            base64::engine::general_purpose::STANDARD
+                .decode(auth.0.strip_prefix("Basic ").unwrap())
+                .unwrap(),
+            b"a:lice:p@ss"
+        );
+        assert_eq!(format!("{auth:?}"), "DnsHttpAuth([redacted])");
+        let dot_path = parse_dns_nameserver(
+            "https://dns.example/a/%2e%2e/b",
+            &RouteTargetsByName::new(),
+            DnsRoute::Direct,
+        )
+        .unwrap();
+        assert_eq!(dot_path.path.as_deref(), Some("/a/../b"));
+        for (userinfo, decoded) in [
+            ("alice", &b"alice:"[..]),
+            ("", &b":"[..]),
+            ("%FF:%00", &b"\xff:\0"[..]),
+        ] {
+            let server = parse_dns_nameserver(
+                &format!("http://{userinfo}@192.0.2.1?discard"),
+                &RouteTargetsByName::new(),
+                DnsRoute::Direct,
+            )
+            .unwrap();
+            assert_eq!(server.path.as_deref(), Some("/"));
+            assert_eq!(
+                base64::engine::general_purpose::STANDARD
+                    .decode(server.http_auth.unwrap().0.strip_prefix("Basic ").unwrap())
+                    .unwrap(),
+                decoded
+            );
+        }
+    }
+
+    #[test]
+    fn non_http_nameservers_ignore_http_only_url_components() {
+        for scheme in ["udp", "tcp", "tls", "quic"] {
+            if scheme == "quic" && !cfg!(feature = "dns-quic") {
+                continue;
+            }
+            let bare = format!("{scheme}://192.0.2.53#DIRECT&ecs=192.0.2.7/24");
+            let decorated = format!(
+                "{scheme}://user:password@192.0.2.53/ignored?unused=value#DIRECT&ecs=192.0.2.7/24"
+            );
+            let targets = RouteTargetsByName::new();
+            let expected = parse_dns_nameserver(&bare, &targets, DnsRoute::Direct).unwrap();
+            let actual = parse_dns_nameserver(&decorated, &targets, DnsRoute::Direct).unwrap();
+            assert_eq!(actual, expected);
+            assert_eq!(parse_node_dns_nameserver(&decorated).unwrap(), expected);
+            assert!(actual.path.is_none());
+            assert!(actual.http_auth.is_none());
+        }
+    }
+
+    #[test]
+    fn upstream_options_decode_fragments_and_use_last_values() {
+        let server = parse_dns_nameserver(
+            "tls://192.0.2.1#DIRECT%26RULES%26ecs=2001:db8::7/57%26ecs-override=true%26disable-ipv4=true%26disable-ipv6=True%26disable-qtype-16=true%26disable-qtype-65280=true%26skip-cert-verify=false%26skip-cert-verify=true%26name-cert-verify=dns.example%26disable-reuse=true",
+            &RouteTargetsByName::new(),
+            DnsRoute::Direct,
+        ).unwrap();
+        assert_eq!(server.route, DnsRoute::Rules);
+        assert_eq!(server.options.ecs.unwrap().prefix_len, 57);
+        assert!(server.options.ecs_override);
+        assert_eq!(&*server.options.disabled_types, &[1, 16]);
+        assert!(server.options.skip_cert_verify);
+        assert_eq!(
+            server.options.verification_name.as_deref(),
+            Some("dns.example")
+        );
+        assert!(server.options.disable_reuse);
+        let parameter_only = parse_dns_nameserver(
+            "192.0.2.1#disable-ipv6=true",
+            &RouteTargetsByName::new(),
+            DnsRoute::Rules,
+        )
+        .unwrap();
+        assert_eq!(parameter_only.route, DnsRoute::Rules);
+        assert_eq!(&*parameter_only.options.disabled_types, &[28]);
+    }
+
+    #[test]
+    fn upstream_options_survive_system_dhcp_and_rcode_parsing() {
+        for endpoint in [
+            "system",
+            "system://",
+            "dhcp://system",
+            "dhcp://en0",
+            "rcode://refused",
+        ] {
+            let server = parse_dns_nameserver(
+                &format!("{endpoint}#ecs=192.0.2.9&disable-ipv6=true"),
+                &RouteTargetsByName::new(),
+                DnsRoute::Direct,
+            )
+            .unwrap();
+            assert_eq!(server.options.ecs.unwrap().prefix_len, 32);
+            assert_eq!(&*server.options.disabled_types, &[28]);
+            if endpoint == "dhcp://en0" {
+                assert!(
+                    matches!(server.address, DnsAddress::Source(DnsSource::Dhcp(ref interface)) if interface.as_ref() == "en0")
+                );
+            }
+        }
+    }
+}
+
+fn percent_decode(input: &str) -> Result<String> {
+    String::from_utf8(percent_decode_bytes(input)?)
+        .map_err(|_| VoleError::InvalidConfig("invalid DNS route encoding".into()))
+}
+
+fn percent_decode_bytes(input: &str) -> Result<Vec<u8>> {
+    let mut bytes = Vec::with_capacity(input.len());
+    let mut iter = input.bytes();
+    while let Some(byte) = iter.next() {
+        if byte == b'%' {
+            let a = iter.next().and_then(|b| (b as char).to_digit(16));
+            let b = iter.next().and_then(|b| (b as char).to_digit(16));
+            match (a, b) {
+                (Some(a), Some(b)) => bytes.push((a * 16 + b) as u8),
+                _ => return invalid("invalid DNS route encoding"),
+            }
+        } else {
+            bytes.push(byte);
+        }
+    }
+    Ok(bytes)
+}
+
+fn normalize_http_path(path: &str) -> Result<String> {
+    let mut result = String::new();
+    for byte in percent_decode_bytes(path)? {
+        // Mihomo rebuilds URL.Path without RawPath. Go encodePath retains
+        // whole-path reserved separators except '?', with uppercase escapes.
+        if byte.is_ascii_alphanumeric() || b"-_.~$&+,/:;=@".contains(&byte) {
+            result.push(char::from(byte));
+        } else {
+            use std::fmt::Write as _;
+            write!(result, "%{byte:02X}").expect("writing a String cannot fail");
+        }
+        if result.len() > crate::dns::MAX_HTTP_HEADER_BYTES {
+            return invalid("DNS HTTP path exceeds the header budget");
+        }
+    }
+    if result.is_empty() {
+        result.push('/');
+    }
+    Ok(result)
+}
+
+pub(super) fn normalize_hosts(
+    raw: std::collections::BTreeMap<String, RawPolicyNameservers>,
+) -> Result<Vec<HostEntry>> {
+    let mut hosts = vec![HostEntry {
+        pattern: "localhost".into(),
+        value: HostValue::Addresses(vec![IpAddr::V4(Ipv4Addr::LOCALHOST)]),
+    }];
+    for (pattern, raw) in raw {
+        let DnsPolicySelector::Domains(patterns) = normalize_dns_policy_selector(&pattern)? else {
+            return invalid("hosts keys require domain patterns");
+        };
+        let values = match raw {
+            RawPolicyNameservers::One(value) => vec![value],
+            RawPolicyNameservers::Many(values) => values,
+        };
+        let value = if values.as_slice() == ["lan"] {
+            HostValue::Lan
+        } else if values.len() == 1 && values[0].parse::<IpAddr>().is_err() {
+            HostValue::Alias(
+                crate::dns::canonicalize_name(&values[0])
+                    .map_err(|_| VoleError::InvalidConfig("invalid hosts alias".into()))?,
+            )
+        } else {
+            let addresses = values
+                .iter()
+                .map(|value| {
+                    value.parse::<IpAddr>().map_err(|_| {
+                        VoleError::InvalidConfig("hosts requires IP addresses or one alias".into())
+                    })
+                })
+                .collect::<Result<Vec<_>>>()?;
+            if addresses.is_empty() {
+                return invalid("hosts requires a value");
+            }
+            HostValue::Addresses(addresses)
+        };
+        for pattern in patterns {
+            hosts.push(HostEntry {
+                pattern,
+                value: value.clone(),
+            });
+        }
+    }
+    crate::dns::hosts::validate(&hosts)
+        .map_err(|_| VoleError::InvalidConfig("hosts contains a domain alias cycle".into()))?;
+    Ok(hosts)
+}
diff --git a/src/config/domain_regex.rs b/src/config/domain_regex.rs
new file mode 100644
index 0000000..7d960f8
--- /dev/null
+++ b/src/config/domain_regex.rs
@@ -0,0 +1,805 @@
+//! Independent bounded DOMAIN-REGEX adapter. No GeoSite or name-filter policy.
+use super::{Result, VoleError};
+use std::{
+    fmt,
+    sync::Arc,
+    time::{Duration, Instant},
+};
+use tokio_util::sync::CancellationToken;
+
+const PATTERN_BYTES: usize = 4096;
+const AST_NODES: usize = 512;
+const AST_DEPTH: usize = 32;
+const REPEAT_BOUND: usize = 1024;
+const COMPILED_BYTES: usize = 512 * 1024;
+const DOMAIN_BYTES: usize = 253;
+const CALL_BACKTRACKS: usize = 2048;
+const DECISION_BACKTRACKS: usize = 64 * 1024;
+const DECISION_WORK: u64 = 64 * 1024 * 1024;
+const DECISION_MATCH_TIME: Duration = Duration::from_millis(2);
+
+fn invalid(message: &'static str) -> VoleError {
+    VoleError::InvalidConfig(message.to_owned())
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum MatchFailure {
+    Cancelled,
+    Budget,
+    InvalidInput,
+    Engine,
+}
+impl fmt::Display for MatchFailure {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            Self::Cancelled => "domain rule evaluation cancelled",
+            Self::Budget => "domain rule execution budget exceeded",
+            Self::InvalidInput => "domain rule input exceeds the supported boundary",
+            Self::Engine => "domain rule evaluation failed",
+        })
+    }
+}
+impl std::error::Error for MatchFailure {}
+
+/// One owned value per complete decision, including suspended DNS traversal.
+/// No Clone: recursive rules, provider predicates and retries borrow this value.
+pub(crate) struct DecisionBudget {
+    work: u64,
+    backtracks: usize,
+    match_time: Duration,
+    failure: Option<MatchFailure>,
+    cancellation: Vec<CancellationToken>,
+    deadline: Option<Instant>,
+}
+impl Default for DecisionBudget {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl DecisionBudget {
+    pub(crate) fn new() -> Self {
+        Self {
+            work: DECISION_WORK,
+            backtracks: DECISION_BACKTRACKS,
+            match_time: Duration::ZERO,
+            failure: None,
+            cancellation: Vec::new(),
+            deadline: None,
+        }
+    }
+    fn fail<T>(&mut self, failure: MatchFailure) -> std::result::Result<T, MatchFailure> {
+        let failure = *self.failure.get_or_insert(failure);
+        Err(failure)
+    }
+    pub(crate) fn check(
+        &mut self,
+        cancel: Option<&CancellationToken>,
+    ) -> std::result::Result<(), MatchFailure> {
+        if let Some(failure) = self.failure {
+            return Err(failure);
+        }
+        if cancel.is_some_and(CancellationToken::is_cancelled)
+            || self
+                .cancellation
+                .iter()
+                .any(CancellationToken::is_cancelled)
+        {
+            return self.fail(MatchFailure::Cancelled);
+        }
+        if self
+            .deadline
+            .is_some_and(|deadline| Instant::now() >= deadline)
+        {
+            return self.fail(MatchFailure::Budget);
+        }
+        Ok(())
+    }
+    /// Call once for every predicate/program visit, including non-regex rules.
+    pub(crate) fn visit(
+        &mut self,
+        cancel: Option<&CancellationToken>,
+    ) -> std::result::Result<(), MatchFailure> {
+        self.reserve(1, 0, cancel)
+    }
+    fn reserve(
+        &mut self,
+        work: u64,
+        backtracks: usize,
+        cancel: Option<&CancellationToken>,
+    ) -> std::result::Result<(), MatchFailure> {
+        self.check(cancel)?;
+        let (Some(work), Some(backtracks)) = (
+            self.work.checked_sub(work),
+            self.backtracks.checked_sub(backtracks),
+        ) else {
+            return self.fail(MatchFailure::Budget);
+        };
+        self.work = work;
+        self.backtracks = backtracks;
+        Ok(())
+    }
+    fn finish(
+        &mut self,
+        duration: Duration,
+        cancel: Option<&CancellationToken>,
+    ) -> std::result::Result<(), MatchFailure> {
+        self.match_time = self.match_time.saturating_add(duration);
+        if self.match_time > DECISION_MATCH_TIME {
+            return self.fail(MatchFailure::Budget);
+        }
+        self.check(cancel)
+    }
+}
+
+/// A decision-local budget shared by contexts, candidates and lazy DNS continuation.
+/// Synchronous matching holds the lock only while consuming the budget.
+#[derive(Clone)]
+pub struct RuleDecision(Arc<std::sync::Mutex<DecisionBudget>>);
+tokio::task_local! { static ACTIVE_DECISION: RuleDecision; }
+impl Default for RuleDecision {
+    fn default() -> Self {
+        ACTIVE_DECISION
+            .try_with(Clone::clone)
+            .unwrap_or_else(|_| Self(Arc::new(std::sync::Mutex::new(DecisionBudget::new()))))
+    }
+}
+impl fmt::Debug for RuleDecision {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("RuleDecision { .. }")
+    }
+}
+// Evaluation accounting does not change the value identity of a routing context.
+impl PartialEq for RuleDecision {
+    fn eq(&self, _: &Self) -> bool {
+        true
+    }
+}
+impl Eq for RuleDecision {}
+impl RuleDecision {
+    pub(crate) async fn scope<F: std::future::Future>(&self, future: F) -> F::Output {
+        ACTIVE_DECISION.scope(self.clone(), future).await
+    }
+    pub(crate) fn check(&self) -> std::result::Result<(), MatchFailure> {
+        self.with(|budget| budget.check(None))
+    }
+    pub(crate) fn visit(&self) -> std::result::Result<(), MatchFailure> {
+        self.with(|budget| budget.visit(None))
+    }
+    pub(crate) fn with<T>(
+        &self,
+        f: impl FnOnce(&mut DecisionBudget) -> std::result::Result<T, MatchFailure>,
+    ) -> std::result::Result<T, MatchFailure> {
+        let mut budget = self.0.lock().map_err(|_| MatchFailure::Engine)?;
+        f(&mut budget)
+    }
+    pub(crate) fn set_cancellation(&self, cancellation: CancellationToken) {
+        if let Ok(mut budget) = self.0.lock()
+            && !budget.cancellation.contains(&cancellation)
+        {
+            if budget.cancellation.len() >= 64 {
+                budget.failure.get_or_insert(MatchFailure::Budget);
+            } else {
+                budget.cancellation.push(cancellation);
+            }
+        }
+    }
+    pub(crate) fn set_deadline(&self, deadline: Instant) {
+        if let Ok(mut budget) = self.0.lock() {
+            budget.deadline = Some(budget.deadline.map_or(deadline, |old| old.min(deadline)));
+        }
+    }
+    pub(crate) fn linear(
+        &self,
+        source_bytes: usize,
+        input_bytes: usize,
+        f: impl FnOnce() -> bool,
+    ) -> std::result::Result<bool, MatchFailure> {
+        self.with(|budget| {
+            budget.reserve(
+                (source_bytes as u64 + 1).saturating_mul(input_bytes as u64 + 1),
+                0,
+                None,
+            )?;
+            let started = Instant::now();
+            let matched = f();
+            budget.finish(started.elapsed(), None)?;
+            Ok(matched)
+        })
+    }
+}
+
+/// Payload identity is preserved; pattern text is deliberately hidden in Debug/errors.
+#[derive(Clone)]
+pub struct DomainRegex(Arc<Compiled>);
+struct Compiled {
+    source: Arc<str>,
+    weight: u64,
+    engine: Engine,
+}
+enum Engine {
+    Linear(regex::Regex),
+    Complex(fancy_regex::Regex),
+}
+impl fmt::Debug for DomainRegex {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("DomainRegex { .. }")
+    }
+}
+impl PartialEq for DomainRegex {
+    fn eq(&self, other: &Self) -> bool {
+        self.as_str() == other.as_str()
+    }
+}
+impl Eq for DomainRegex {}
+impl DomainRegex {
+    pub fn new(pattern: &str) -> Result<Self> {
+        if pattern.len() > PATTERN_BYTES {
+            return Err(invalid("DOMAIN-REGEX compilation budget exceeded"));
+        }
+        let translated = common_dialect(pattern)?;
+        let (translated, _) = capture_dialect(&translated)?;
+        let tree = fancy_regex::Expr::parse_tree(&translated)
+            .map_err(|_| invalid("invalid or unsupported DOMAIN-REGEX syntax"))?;
+        let (nodes, weight, _) = inspect(&tree.expr)?;
+        let engine = if let Ok(regex) = regex::RegexBuilder::new(&translated)
+            .case_insensitive(true)
+            .nest_limit(AST_DEPTH as u32)
+            .size_limit(COMPILED_BYTES)
+            .dfa_size_limit(COMPILED_BYTES)
+            .build()
+        {
+            Engine::Linear(regex)
+        } else {
+            let fragment_bytes = (COMPILED_BYTES / nodes.max(1)).max(8192);
+            let regex = fancy_regex::RegexBuilder::new(&translated)
+                .case_insensitive(true)
+                .backtrack_limit(CALL_BACKTRACKS)
+                .seek(false)
+                .delegate_size_limit(fragment_bytes)
+                .delegate_dfa_size_limit(fragment_bytes)
+                .build()
+                .map_err(|_| invalid("invalid or unsupported DOMAIN-REGEX syntax"))?;
+            Engine::Complex(regex)
+        };
+        Ok(Self(Arc::new(Compiled {
+            source: Arc::from(pattern),
+            weight,
+            engine,
+        })))
+    }
+    pub fn as_str(&self) -> &str {
+        &self.0.source
+    }
+    pub fn is_match(
+        &self,
+        domain: &str,
+        decision: &RuleDecision,
+    ) -> std::result::Result<bool, MatchFailure> {
+        decision.with(|budget| self.match_bounded(domain, budget, None))
+    }
+    pub(crate) fn is_match_process(
+        &self,
+        value: &str,
+        decision: &RuleDecision,
+    ) -> std::result::Result<bool, MatchFailure> {
+        decision.with(|budget| self.match_input(value, budget, None, false))
+    }
+    fn match_bounded(
+        &self,
+        domain: &str,
+        budget: &mut DecisionBudget,
+        cancel: Option<&CancellationToken>,
+    ) -> std::result::Result<bool, MatchFailure> {
+        self.match_input(domain, budget, cancel, true)
+    }
+    fn match_input(
+        &self,
+        domain: &str,
+        budget: &mut DecisionBudget,
+        cancel: Option<&CancellationToken>,
+        dns: bool,
+    ) -> std::result::Result<bool, MatchFailure> {
+        budget.check(cancel)?;
+        if domain.is_empty()
+            || domain.len()
+                > if dns {
+                    DOMAIN_BYTES
+                } else {
+                    super::process::MAX_PROCESS_TEXT
+                }
+            || (dns && (!domain.is_ascii() || domain.bytes().any(|b| b.is_ascii_control())))
+            || domain.contains('\0')
+        {
+            return budget.fail(MatchFailure::InvalidInput);
+        }
+        let complex = matches!(self.0.engine, Engine::Complex(_));
+        let work = self.0.weight.saturating_mul(domain.len() as u64 + 1);
+        // fancy exposes only a per-regex backtrack bound, not actual steps or
+        // a caller-owned counter. Reserve its worst-case quota before execution.
+        // Reserving all of it prevents each rule from receiving a new total budget.
+        budget.reserve(work, if complex { CALL_BACKTRACKS + 1 } else { 0 }, cancel)?;
+        let started = Instant::now();
+        let result = match &self.0.engine {
+            Engine::Linear(regex) => Ok(regex.is_match(domain)),
+            Engine::Complex(regex) => regex.is_match(domain).map_err(|error| {
+                if matches!(
+                    error,
+                    fancy_regex::Error::RuntimeError(
+                        fancy_regex::RuntimeError::BacktrackLimitExceeded
+                    )
+                ) {
+                    MatchFailure::Budget
+                } else {
+                    MatchFailure::Engine
+                }
+            }),
+        };
+        // Post-call accounting is not preemptive: cancellation/elapsed guards
+        // cannot interrupt the synchronous third-party VM in the current API.
+        budget.finish(started.elapsed(), cancel)?;
+        if let Err(failure) = result {
+            return budget.fail(failure);
+        }
+        result
+    }
+}
+
+/// A small independent lexical compatibility fence, not a .NET parser.
+/// The third-party public AST validates the accepted grammar afterward.
+pub(super) fn common_dialect(pattern: &str) -> Result<String> {
+    let bytes = pattern.as_bytes();
+    let mut output = String::with_capacity(pattern.len());
+    let (mut index, mut in_class, mut depth) = (0, false, 0_usize);
+    let mut scopes = Vec::new();
+    let mut verbose = false;
+    while index < bytes.len() {
+        let tail = &pattern[index..];
+        if bytes[index] == b'\\' {
+            let Some(&next) = bytes.get(index + 1) else {
+                return Err(invalid("invalid DOMAIN-REGEX escape"));
+            };
+            if !in_class && tail.starts_with("\\k'") {
+                let rest = &tail[3..];
+                let end = rest
+                    .find('\'')
+                    .ok_or_else(|| invalid("invalid DOMAIN-REGEX capture reference"))?;
+                if rest[..end].is_empty() || !rest[..end].bytes().all(|b| b.is_ascii_digit()) {
+                    capture_name(&rest[..end])?;
+                }
+                output.push_str("\\k<");
+                output.push_str(&rest[..end]);
+                output.push('>');
+                index += 4 + end;
+                continue;
+            }
+            if !in_class && matches!(next, b'g' | b'K' | b'R' | b'N' | b'O' | b'h' | b'H') {
+                return Err(invalid("unsupported DOMAIN-REGEX escape"));
+            }
+            output.push('\\');
+            let next = pattern[index + 1..].chars().next().expect("byte checked");
+            output.push(next);
+            index += 1 + next.len_utf8();
+            continue;
+        }
+        if in_class {
+            if tail.starts_with("&&")
+                || tail.starts_with("--")
+                || tail.starts_with("~~")
+                || bytes[index] == b'['
+            {
+                return Err(invalid("unsupported DOMAIN-REGEX character class syntax"));
+            }
+            if bytes[index] == b']' {
+                in_class = false;
+            }
+        } else {
+            if verbose && bytes[index] == b'#' {
+                let end = tail.find('\n').map_or(tail.len(), |end| end + 1);
+                output.push_str(&tail[..end]);
+                index += end;
+                continue;
+            }
+            if let Some(rest) = tail.strip_prefix("(?#") {
+                let end = rest
+                    .find(')')
+                    .ok_or_else(|| invalid("invalid DOMAIN-REGEX comment"))?;
+                index += end + 4;
+                continue;
+            }
+            if bytes[index] == b'[' {
+                in_class = true;
+            }
+            if tail.starts_with("(?P")
+                || tail.starts_with("(*")
+                || tail.starts_with("(?~")
+                || tail.starts_with("(?|")
+                || tail.starts_with("(?(")
+            {
+                return Err(invalid("unsupported DOMAIN-REGEX group syntax"));
+            }
+            if let Some(rest) = tail.strip_prefix("(?'") {
+                let end = rest
+                    .find('\'')
+                    .ok_or_else(|| invalid("invalid DOMAIN-REGEX capture name"))?;
+                capture_name(&rest[..end])?;
+                output.push_str("(?<");
+                output.push_str(&rest[..end]);
+                output.push('>');
+                depth += 1;
+                scopes.push(verbose);
+                if depth > AST_DEPTH {
+                    return Err(invalid("DOMAIN-REGEX compilation budget exceeded"));
+                }
+                index += end + 4;
+                continue;
+            }
+            if tail.starts_with("(?<") && !tail.starts_with("(?<=") && !tail.starts_with("(?<!") {
+                let rest = &tail[3..];
+                let end = rest
+                    .find('>')
+                    .ok_or_else(|| invalid("invalid DOMAIN-REGEX capture name"))?;
+                capture_name(&rest[..end])?;
+            }
+            if matches!(bytes[index], b'*' | b'+' | b'?' | b'}')
+                && bytes.get(index + 1) == Some(&b'+')
+            {
+                return Err(invalid("unsupported DOMAIN-REGEX possessive quantifier"));
+            }
+            if bytes[index] == b'(' {
+                // Account lexical depth before calling a recursive third-party parser.
+                // Explicit common flags are accepted; Rust-only modes are rejected.
+                if let Some(rest) = tail.strip_prefix("(?") {
+                    let flags = rest
+                        .bytes()
+                        .take_while(|b| b.is_ascii_alphabetic() || *b == b'-')
+                        .count();
+                    if flags > 0
+                        && tail
+                            .as_bytes()
+                            .get(2 + flags)
+                            .is_some_and(|b| matches!(b, b':' | b')'))
+                    {
+                        let mut on = true;
+                        let old_verbose = verbose;
+                        for flag in tail[2..2 + flags].bytes() {
+                            match flag {
+                                b'-' => on = false,
+                                b'i' | b'm' | b's' => {}
+                                b'x' => verbose = on,
+                                _ => return Err(invalid("unsupported DOMAIN-REGEX inline mode")),
+                            }
+                        }
+                        if bytes[index + 2 + flags] == b')' {
+                            output.push_str(&tail[..3 + flags]);
+                            index += 3 + flags;
+                            continue;
+                        }
+                        depth += 1;
+                        scopes.push(old_verbose);
+                        if depth > AST_DEPTH {
+                            return Err(invalid("DOMAIN-REGEX compilation budget exceeded"));
+                        }
+                        output.push_str(&tail[..3 + flags]);
+                        index += 3 + flags;
+                        continue;
+                    }
+                }
+                depth += 1;
+                scopes.push(verbose);
+                if depth > AST_DEPTH {
+                    return Err(invalid("DOMAIN-REGEX compilation budget exceeded"));
+                }
+            } else if bytes[index] == b')' {
+                depth = depth
+                    .checked_sub(1)
+                    .ok_or_else(|| invalid("invalid DOMAIN-REGEX group syntax"))?;
+                verbose = scopes
+                    .pop()
+                    .ok_or_else(|| invalid("invalid DOMAIN-REGEX group syntax"))?;
+            }
+        }
+        let next = tail.chars().next().expect("within input");
+        output.push(next);
+        index += next.len_utf8();
+    }
+    if in_class || depth != 0 {
+        return Err(invalid("invalid DOMAIN-REGEX syntax"));
+    }
+    Ok(output)
+}
+fn capture_name(name: &str) -> Result<()> {
+    if name.is_empty()
+        || !name
+            .bytes()
+            .next()
+            .is_some_and(|b| b.is_ascii_alphabetic() || b == b'_')
+        || !name.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_')
+    {
+        return Err(invalid("unsupported DOMAIN-REGEX capture name"));
+    }
+    Ok(())
+}
+
+/// Return a bounded .NET-number -> engine-number map, rewriting numeric
+/// backreferences only. Both engines otherwise keep their original grammar.
+/// `pattern` has already passed common_dialect's lexical/depth fence.
+pub(super) fn capture_dialect(pattern: &str) -> Result<(String, Vec<usize>)> {
+    let bytes = pattern.as_bytes();
+    let mut groups = Vec::<Option<String>>::new();
+    let mut references = Vec::new();
+    let mut scopes = Vec::new();
+    let (mut index, mut in_class, mut verbose) = (0, false, false);
+    while index < bytes.len() {
+        let tail = &pattern[index..];
+        if bytes[index] == b'\\' {
+            let next = *bytes
+                .get(index + 1)
+                .ok_or_else(|| invalid("invalid regex escape"))?;
+            if !in_class && matches!(next, b'1'..=b'9') {
+                let end = index
+                    + 1
+                    + bytes[index + 1..]
+                        .iter()
+                        .take_while(|b| b.is_ascii_digit())
+                        .count();
+                let number = pattern[index + 1..end]
+                    .parse::<usize>()
+                    .map_err(|_| invalid("invalid regex capture reference"))?;
+                references.push((index, end, number));
+                index = end;
+                continue;
+            }
+            if !in_class && tail.starts_with("\\k<") {
+                let end = index
+                    + 3
+                    + tail[3..]
+                        .find('>')
+                        .ok_or_else(|| invalid("invalid regex capture reference"))?;
+                let key = &pattern[index + 3..end];
+                if !key.is_empty() && key.bytes().all(|b| b.is_ascii_digit()) {
+                    let number = key
+                        .parse::<usize>()
+                        .map_err(|_| invalid("invalid regex capture reference"))?;
+                    references.push((index, end + 1, number));
+                }
+                index = end + 1;
+                continue;
+            }
+            index += 1 + tail[1..].chars().next().expect("escape checked").len_utf8();
+            continue;
+        }
+        if in_class {
+            if bytes[index] == b']' {
+                in_class = false;
+            }
+        } else if verbose && bytes[index] == b'#' {
+            index += tail.find('\n').map_or(tail.len(), |end| end + 1);
+            continue;
+        } else if bytes[index] == b'[' {
+            in_class = true;
+        } else if bytes[index] == b'(' {
+            if let Some(rest) = tail.strip_prefix("(?") {
+                let flags = rest
+                    .bytes()
+                    .take_while(|b| b.is_ascii_alphabetic() || *b == b'-')
+                    .count();
+                if flags > 0
+                    && bytes
+                        .get(index + 2 + flags)
+                        .is_some_and(|b| matches!(b, b':' | b')'))
+                {
+                    let old_verbose = verbose;
+                    let mut on = true;
+                    for flag in tail[2..2 + flags].bytes() {
+                        if flag == b'-' {
+                            on = false;
+                        }
+                        if flag == b'x' {
+                            verbose = on;
+                        }
+                    }
+                    if bytes[index + 2 + flags] == b':' {
+                        scopes.push(old_verbose);
+                    }
+                    index += 3 + flags;
+                    continue;
+                }
+            }
+            scopes.push(verbose);
+            if tail.starts_with("(?<") && !tail.starts_with("(?<=") && !tail.starts_with("(?<!") {
+                let end = index
+                    + 3
+                    + tail[3..]
+                        .find('>')
+                        .ok_or_else(|| invalid("invalid regex capture name"))?;
+                let name = &pattern[index + 3..end];
+                // Duplicate .NET names share a capture history; neither engine's
+                // ordinary single-slot name lookup can represent that history.
+                if groups.iter().any(|group| group.as_deref() == Some(name)) {
+                    return Err(invalid("duplicate regex capture names are unsupported"));
+                }
+                groups.push(Some(name.to_owned()));
+                index = end + 1;
+                if groups.len() > AST_NODES {
+                    return Err(invalid("regex capture budget exceeded"));
+                }
+                continue;
+            }
+            if !tail.starts_with("(?") {
+                groups.push(None);
+                if groups.len() > AST_NODES {
+                    return Err(invalid("regex capture budget exceeded"));
+                }
+            }
+        } else if bytes[index] == b')' {
+            verbose = scopes
+                .pop()
+                .ok_or_else(|| invalid("invalid regex group syntax"))?;
+        }
+        index += tail.chars().next().expect("within pattern").len_utf8();
+    }
+    let mut numbers = Vec::with_capacity(groups.len() + 1);
+    numbers.push(0);
+    for named in [false, true] {
+        for (index, group) in groups.iter().enumerate() {
+            if group.is_some() == named {
+                numbers.push(index + 1);
+            }
+        }
+    }
+    let mut rewritten = String::with_capacity(pattern.len());
+    let mut offset = 0;
+    for (start, end, reference) in references {
+        rewritten.push_str(&pattern[offset..start]);
+        if let Some(&engine_number) = numbers
+            .get(reference)
+            .filter(|&&number| number != reference)
+        {
+            use std::fmt::Write as _;
+            write!(&mut rewritten, "\\k<{engine_number}>").expect("String write");
+        } else {
+            // Unknown references remain the engine's compile error, rather than
+            // becoming a different group or an implicit compatibility fallback.
+            rewritten.push_str(&pattern[start..end]);
+        }
+        offset = end;
+    }
+    rewritten.push_str(&pattern[offset..]);
+    Ok((rewritten, numbers))
+}
+
+fn inspect(root: &fancy_regex::Expr) -> Result<(usize, u64, usize)> {
+    use fancy_regex::{AstNode, Expr};
+    let mut pending = vec![(root, 0)];
+    let (mut nodes, mut weight, mut groups) = (0_usize, 0_u64, 0_usize);
+    while let Some((expr, depth)) = pending.pop() {
+        nodes += 1;
+        if nodes > AST_NODES || depth > AST_DEPTH {
+            return Err(invalid("DOMAIN-REGEX compilation budget exceeded"));
+        }
+        weight = weight.saturating_add(match expr {
+            Expr::Literal { val, .. } => val.len().max(1) as u64,
+            Expr::Repeat { lo, hi, .. } => {
+                if *lo > REPEAT_BOUND || (*hi != usize::MAX && *hi > REPEAT_BOUND) {
+                    return Err(invalid("DOMAIN-REGEX compilation budget exceeded"));
+                }
+                (*lo)
+                    .max(if *hi == usize::MAX { DOMAIN_BYTES } else { *hi })
+                    .max(1) as u64
+            }
+            _ => 1,
+        });
+        match expr {
+            Expr::Empty
+            | Expr::Any { .. }
+            | Expr::Assertion(_)
+            | Expr::Literal { .. }
+            | Expr::Concat(_)
+            | Expr::Alt(_)
+            | Expr::LookAround(..)
+            | Expr::Repeat { .. }
+            | Expr::Delegate { .. }
+            | Expr::Backref { .. }
+            | Expr::AtomicGroup(_) => {}
+            Expr::Group(_) | Expr::AstNode(AstNode::AstGroup { .. }, _) => {
+                groups += 1;
+            }
+            Expr::AstNode(
+                AstNode::Backref {
+                    relative_recursion_level: None,
+                    ..
+                },
+                _,
+            ) => {}
+            _ => return Err(invalid("unsupported DOMAIN-REGEX expression syntax")),
+        }
+        pending.extend(expr.children_iter().map(|child| (child, depth + 1)));
+    }
+    Ok((nodes, weight.max(1), groups))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn common_domain_expressions_compile_once_and_match() {
+        for (pattern, domain) in [
+            (r"^(?!internal\.)[a-z0-9.-]+(?=\.test$)", "Api.Example.TEST"),
+            (r"(?<=edge\.)[a-z]+(?<!private)\.test$", "edge.public.test"),
+            (r"^([a-z]+)\.\1\.test$", "repeat.REPEAT.test"),
+            (r"^(?<label>[a-z]+)\.\k<label>\.test$", "same.SAME.test"),
+            (r"^(?'label'[a-z]+)\.\k'label'\.test$", "word.WORD.test"),
+            (r"^(?#independent fixture)(?>api|www)\.test$", "API.test"),
+            (
+                r"^(?<label>[a-z]+)\.([a-z]+)\.\1\.\2\.test$",
+                "named.part.PART.NAMED.test",
+            ),
+            (
+                r"^(?'label'[a-z]+)\.([a-z]+)\.\k'1'\.\k'2'\.test$",
+                "named.part.PART.NAMED.test",
+            ),
+        ] {
+            let regex = DomainRegex::new(pattern).unwrap();
+            assert!(
+                regex
+                    .match_bounded(domain, &mut DecisionBudget::new(), None)
+                    .unwrap()
+            );
+            assert_eq!(regex, regex.clone());
+            assert_eq!(format!("{regex:?}"), "DomainRegex { .. }");
+        }
+        assert!(
+            DomainRegex::new("")
+                .unwrap()
+                .is_match("api.test", &Default::default())
+                .unwrap()
+        );
+        let fast = DomainRegex::new(r"(?i)^cdn[0-9]+\.test$").unwrap();
+        assert!(matches!(fast.0.engine, Engine::Linear(_)));
+        assert!(
+            fast.match_bounded("CDN7.test", &mut DecisionBudget::new(), None)
+                .unwrap()
+        );
+        assert!(
+            !fast
+                .match_bounded("other.test", &mut DecisionBudget::new(), None)
+                .unwrap()
+        );
+    }
+    #[test]
+    fn domain_decision_budget_is_shared_sticky_and_cancelled() {
+        let regex = DomainRegex::new(r"(?=api)api\.test$").unwrap();
+        let mut budget = DecisionBudget::new();
+        budget.backtracks = 2 * (CALL_BACKTRACKS + 1);
+        assert!(regex.match_bounded("api.test", &mut budget, None).unwrap());
+        assert!(regex.match_bounded("api.test", &mut budget, None).unwrap());
+        assert_eq!(
+            regex.match_bounded("api.test", &mut budget, None),
+            Err(MatchFailure::Budget)
+        );
+        assert_eq!(
+            DomainRegex::new("test")
+                .unwrap()
+                .match_bounded("api.test", &mut budget, None),
+            Err(MatchFailure::Budget)
+        );
+        let cancel = CancellationToken::new();
+        cancel.cancel();
+        assert_eq!(
+            regex.match_bounded("api.test", &mut DecisionBudget::new(), Some(&cancel)),
+            Err(MatchFailure::Cancelled)
+        );
+        let shared = RuleDecision::default();
+        shared.set_cancellation(cancel.clone());
+        assert_eq!(
+            regex.is_match("api.test", &shared.clone()),
+            Err(MatchFailure::Cancelled)
+        );
+        let pathological = DomainRegex::new(r"^(a|aa)+(?=z)$").unwrap();
+        assert!(
+            pathological
+                .match_bounded(&"a".repeat(50), &mut DecisionBudget::new(), None)
+                .is_err()
+        );
+    }
+}
diff --git a/src/config/ech.rs b/src/config/ech.rs
index 973edda..2bb98c7 100644
--- a/src/config/ech.rs
+++ b/src/config/ech.rs
@@ -1,9 +1,21 @@
-//! Static ECH configuration admission shared by both TLS backends. In
-//! particular, BoringSSL otherwise silently skips unsupported configurations.
+//! Bounded static or DNS-sourced ECH admission for the selected TLS backend.
+//! Admission precedes handshake setup so no backend silently skips ECH.
 use super::*;
 
-#[derive(Clone, PartialEq, Eq)]
-pub struct StaticEchConfig(Vec<u8>);
+#[derive(Clone)]
+pub struct StaticEchConfig {
+    wire: Vec<u8>,
+    source: std::sync::Arc<[u8]>,
+    query: Option<Option<String>>,
+    named: bool,
+}
+
+impl PartialEq for StaticEchConfig {
+    fn eq(&self, other: &Self) -> bool {
+        self.wire == other.wire && self.query == other.query && self.named == other.named
+    }
+}
+impl Eq for StaticEchConfig {}
 
 impl std::fmt::Debug for StaticEchConfig {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -15,6 +27,10 @@ impl StaticEchConfig {
     /// Keeps the first mutually supported config's exact wire encoding. No
     /// backend can skip an earlier unsupported entry and expose the inner SNI.
     pub fn from_config_list(bytes: &[u8]) -> Result<Self> {
+        Self::from_config_list_for_backend(bytes, true)
+    }
+
+    pub(crate) fn from_config_list_for_backend(bytes: &[u8], named: bool) -> Result<Self> {
         if bytes.len() > 65_537 {
             return invalid("ECH config list exceeds the wire bound");
         }
@@ -27,7 +43,7 @@ impl StaticEchConfig {
             let start = configs.0;
             let version = configs.u16()?;
             let contents = configs.vector16()?;
-            if version == 0xfe0d && supported(contents)? && selected.is_none() {
+            if version == 0xfe0d && supported(contents, named)? && selected.is_none() {
                 selected = Some(&start[..4 + contents.len()]);
             }
         }
@@ -36,16 +52,56 @@ impl StaticEchConfig {
         })?;
         let mut wire = (selected.len() as u16).to_be_bytes().to_vec();
         wire.extend_from_slice(selected);
-        Ok(Self(wire))
+        Ok(Self {
+            wire,
+            source: bytes.into(),
+            query: None,
+            named,
+        })
     }
 
-    #[cfg(feature = "tls-fingerprint")]
+    #[cfg(any(feature = "tls-fingerprint", feature = "ech"))]
     pub(crate) fn as_bytes(&self) -> &[u8] {
-        &self.0
+        assert!(
+            self.query.is_none(),
+            "dynamic ECH must resolve before TLS setup"
+        );
+        &self.wire
+    }
+    pub(crate) fn for_backend(&self, named: bool) -> Result<Self> {
+        if self.named == named {
+            return Ok(self.clone());
+        }
+        if self.is_dynamic() {
+            return Ok(Self {
+                named,
+                ..self.clone()
+            });
+        }
+        Self::from_config_list_for_backend(&self.source, named)
+    }
+
+    pub(crate) fn is_dynamic(&self) -> bool {
+        self.query.is_some()
+    }
+    pub(crate) async fn resolve(
+        &self,
+        server_name: &str,
+        context: &crate::outbound::EstablishContext,
+    ) -> std::io::Result<Self> {
+        let Some(query) = &self.query else {
+            return Ok(self.clone());
+        };
+        let wire = context
+            .resolution()
+            .resolve_ech(query.as_deref().unwrap_or(server_name), context.deadline())
+            .await?;
+        Self::from_config_list_for_backend(&wire, self.named)
+            .map_err(|_| std::io::Error::other("DNS has no compatible ECH configuration"))
     }
 }
 
-fn supported(bytes: &[u8]) -> Result<bool> {
+fn supported(bytes: &[u8], named: bool) -> Result<bool> {
     let mut r = Reader(bytes);
     r.take(1)?; // config_id
     let kem = r.u16()?;
@@ -55,7 +111,12 @@ fn supported(bytes: &[u8]) -> Result<bool> {
         return invalid("invalid ECH cipher suites");
     }
     let compatible_suite = suites.as_chunks::<4>().0.iter().any(|suite| {
-        suite[..2] == [0, 1] && matches!(u16::from_be_bytes([suite[2], suite[3]]), 1..=3)
+        matches!(u16::from_be_bytes([suite[2], suite[3]]), 1..=3)
+            && if named {
+                suite[..2] == [0, 1]
+            } else {
+                matches!(u16::from_be_bytes([suite[0],suite[1]]), 1..=3 | 0x10..=0x11)
+            }
     });
     r.take(1)?; // maximum_name_length
     let name_len = usize::from(r.take(1)?[0]);
@@ -69,16 +130,28 @@ fn supported(bytes: &[u8]) -> Result<bool> {
         extensions.vector16()?;
         compatible_extensions &= kind & 0x8000 == 0 && seen.insert(kind);
     }
-    Ok(kem == 0x0020
-        && key.len() == 32
+    let compatible_key = if named {
+        kem == 0x0020 && key.len() == 32
+    } else {
+        #[cfg(feature = "ech")]
+        {
+            crate::security::ech::valid_public_key(kem, key)
+        }
+        #[cfg(not(feature = "ech"))]
+        {
+            false
+        }
+    };
+    Ok(compatible_key
         && compatible_suite
         && compatible_extensions
-        && valid_public_name(name))
+        && valid_public_name(name, named))
 }
 
-fn valid_public_name(name: &[u8]) -> bool {
-    // Match the stricter fixed BoringSSL LDH/IP-lookalike admission rules.
-    if name.is_empty() || name.len() > 253 {
+fn valid_public_name(name: &[u8], named: bool) -> bool {
+    // The reference requires a multi-label LDH name. The selected backend
+    // must also represent it; BoringSSL rejects hexadecimal IP lookalikes.
+    if name.is_empty() || name.len() > 253 || !name.contains(&b'.') {
         return false;
     }
     if name.split(|b| *b == b'.').any(|label| {
@@ -94,7 +167,8 @@ fn valid_public_name(name: &[u8]) -> bool {
     }
     let last = name.rsplit(|b| *b == b'.').next().unwrap_or_default();
     !last.iter().all(u8::is_ascii_digit)
-        && !(last.len() >= 2
+        && !(named
+            && last.len() >= 2
             && last[0] == b'0'
             && matches!(last[1], b'x' | b'X')
             && last[2..].iter().all(u8::is_ascii_hexdigit))
@@ -132,6 +206,12 @@ pub(super) struct RawEch {
     enable: bool,
     #[serde(default, deserialize_with = "deserialize_present_option")]
     config: Option<String>,
+    #[serde(
+        rename = "query-server-name",
+        default,
+        deserialize_with = "deserialize_present_option"
+    )]
+    query_server_name: Option<String>,
 }
 
 impl std::fmt::Debug for RawEch {
@@ -141,23 +221,34 @@ impl std::fmt::Debug for RawEch {
 }
 
 impl RawEch {
-    pub(super) fn normalize(self) -> Result<Option<StaticEchConfig>> {
+    pub(super) fn normalize(self, named: bool) -> Result<Option<StaticEchConfig>> {
         if !self.enable {
-            if self.config.as_ref().is_some_and(|value| !value.is_empty()) {
-                return invalid("ECH config requires enable=true");
-            }
             return Ok(None);
         }
-        let encoded = self.config.ok_or_else(|| {
-            VoleError::InvalidConfig("static ECH requires an explicit config".into())
-        })?;
+        if !cfg!(feature = "ech") {
+            return invalid("ECH is not compiled in");
+        }
+        let encoded = self.config.unwrap_or_default();
+        if encoded.is_empty() {
+            let query = self.query_server_name.filter(|name| !name.is_empty());
+            if let Some(name) = &query {
+                crate::dns::canonicalize_name(name)
+                    .map_err(|_| VoleError::InvalidConfig("invalid ECH query name".into()))?;
+            }
+            return Ok(Some(StaticEchConfig {
+                wire: Vec::new(),
+                source: std::sync::Arc::from([]),
+                query: Some(query),
+                named,
+            }));
+        }
         if encoded.len() > 87_384 {
             return invalid("ECH config exceeds the wire bound");
         }
         let wire = base64::engine::general_purpose::STANDARD
             .decode(encoded)
             .map_err(|_| VoleError::InvalidConfig("invalid ECH Base64 config".into()))?;
-        StaticEchConfig::from_config_list(&wire).map(Some)
+        StaticEchConfig::from_config_list_for_backend(&wire, named).map(Some)
     }
 }
 
@@ -166,5 +257,5 @@ where
     D: Deserializer<'de>,
 {
     deserialize_present_map(deserializer)
-        .map_err(|_| serde::de::Error::custom("invalid static ECH options"))
+        .map_err(|_| serde::de::Error::custom("invalid ECH options"))
 }
diff --git a/src/config/egress.rs b/src/config/egress.rs
new file mode 100644
index 0000000..66809b0
--- /dev/null
+++ b/src/config/egress.rs
@@ -0,0 +1,124 @@
+use super::*;
+use std::sync::Arc;
+
+/// Immutable policy for the physical socket owned by a node. Empty values
+/// inherit the session default; they never clear a platform protection policy.
+#[derive(Debug, Default, Clone, PartialEq, Eq, Hash)]
+pub struct EgressOptions {
+    pub interface: Option<Arc<str>>,
+    pub routing_mark: u32,
+}
+
+impl EgressOptions {
+    pub(super) fn normalize(interface: String, mark: i64) -> Result<Self> {
+        // Windows aliases and GUIDs are not Linux IFNAMSIZ names. Only impose
+        // a common memory/string boundary here; the OS validates the name.
+        if interface.len() > 1_024 || interface.contains('\0') {
+            return invalid("interface-name must be at most 1024 bytes without NUL");
+        }
+        if mark < i64::from(i32::MIN) || mark > i64::from(u32::MAX) {
+            return invalid("routing-mark must fit a 32-bit socket mark");
+        }
+        Ok(Self {
+            interface: (!interface.is_empty()).then(|| interface.into()),
+            routing_mark: mark as u32,
+        })
+    }
+
+    #[must_use]
+    pub(crate) fn overlay(&self, node: &Self) -> Self {
+        Self {
+            interface: node.interface.clone().or_else(|| self.interface.clone()),
+            routing_mark: if node.routing_mark == 0 {
+                self.routing_mark
+            } else {
+                node.routing_mark
+            },
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn egress_options_inherit_empty_values_and_preserve_platform_names() {
+        let global = EgressOptions::normalize("Ethernet 网络 2".into(), 42).unwrap();
+        assert_eq!(global.overlay(&EgressOptions::default()), global);
+        let node = EgressOptions::normalize("en1".into(), 7).unwrap();
+        assert_eq!(global.overlay(&node), node);
+        let interface_only = EgressOptions::normalize("en2".into(), 0).unwrap();
+        assert_eq!(global.overlay(&interface_only).routing_mark, 42);
+        let mark_only = EgressOptions::normalize(String::new(), -1).unwrap();
+        assert_eq!(global.overlay(&mark_only).interface, global.interface);
+        assert_eq!(mark_only.routing_mark, u32::MAX);
+        assert!(EgressOptions::normalize(" bad name ".into(), 0).is_ok());
+        assert!(EgressOptions::normalize("bad\0name".into(), 0).is_err());
+        assert!(EgressOptions::normalize("x".repeat(1_025), 0).is_err());
+        assert!(EgressOptions::normalize(String::new(), i64::from(u32::MAX) + 1).is_err());
+    }
+
+    #[test]
+    fn native_auto_route_preserves_global_node_and_provider_marks_in_candidates() {
+        for mark in [7, u32::MAX] {
+            let yaml = format!(
+                r#"routing-mark: 42
+tun: {{enable: true, auto-route: true, file-descriptor: 0}}
+proxies:
+  - {{name: inherit, type: direct}}
+  - {{name: explicit, type: direct, routing-mark: 9}}
+proxy-providers:
+  nodes:
+    type: inline
+    override: {{routing-mark: {mark}}}
+    payload:
+      - {{name: supplied, type: direct, routing-mark: 3}}
+"#,
+            );
+            let config = Config::parse_yaml(yaml.as_bytes()).unwrap();
+            let candidate = config
+                .providers
+                .as_ref()
+                .unwrap()
+                .materialize(&super::super::providers::ProviderContents::new())
+                .unwrap();
+            for config in [&config, &candidate] {
+                assert!(config.tun.enable && config.tun.auto_route);
+                assert_eq!(config.tun.file_descriptor, 0);
+                for (name, expected) in [("inherit", 42), ("explicit", 9), ("supplied", mark)] {
+                    let node = config.proxies.iter().find(|node| node.tag == name).unwrap();
+                    assert_eq!(config.egress.overlay(&node.egress).routing_mark, expected);
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn egress_provider_overrides_materialize_before_node_and_global_inheritance() {
+        let config = Config::parse_yaml(br#"
+interface-name: global-if
+routing-mark: 42
+proxy-providers:
+  nodes:
+    type: inline
+    override: {interface-name: 'Ethernet 2', routing-mark: 7}
+    payload:
+      - {name: edge, type: socks5, server: 192.0.2.1, port: 1080, interface-name: old, routing-mark: 3}
+proxy-groups:
+  - {name: select, type: select, use: [nodes]}
+rules: ['MATCH,select']
+"#).unwrap();
+        assert_eq!(config.egress.interface.as_deref(), Some("global-if"));
+        let node = &config.proxies[0].egress;
+        assert_eq!(node.interface.as_deref(), Some("Ethernet 2"));
+        assert_eq!(node.routing_mark, 7);
+        assert_eq!(config.egress.overlay(node), *node);
+        for invalid in ["null", "true", "'7'", "4294967296"] {
+            let input = format!(
+                "proxy-providers:\n  nodes:\n    type: inline\n    override: {{routing-mark: {invalid}}}\n    payload: []\n"
+            );
+            assert!(Config::parse_yaml(input.as_bytes()).is_err());
+        }
+    }
+}
diff --git a/src/config/fake_ip.rs b/src/config/fake_ip.rs
new file mode 100644
index 0000000..af474d9
--- /dev/null
+++ b/src/config/fake_ip.rs
@@ -0,0 +1,138 @@
+use super::*;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Default)]
+#[serde(rename_all = "lowercase")]
+pub enum FakeIpFilterMode {
+    #[default]
+    Blacklist,
+    Whitelist,
+    Rule,
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct FakeIpConfig {
+    pub enabled: bool,
+    pub range: Option<FakeIpRange>,
+    pub range6: Option<FakeIpRange>,
+    pub ttl: u32,
+    pub mode: FakeIpFilterMode,
+    pub filter: Vec<DnsPolicySelector>,
+    pub rules: Vec<RuleSpec>,
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct FakeIpRange {
+    pub cidr: IpCidr,
+    pub interface_address: IpAddr,
+}
+impl FakeIpRange {
+    pub fn parse(value: &str, ipv6: bool) -> Result<Option<Self>> {
+        if value.is_empty() {
+            return Ok(None);
+        }
+        let cidr = parse_ip_cidr(value, ipv6)?;
+        if cidr.prefix_len > if ipv6 { 125 } else { 29 } {
+            return invalid("fake-IP range must leave at least three allocatable addresses");
+        }
+        let interface_address = value
+            .split('/')
+            .next()
+            .unwrap()
+            .parse()
+            .map_err(|_| VoleError::InvalidConfig("invalid fake-IP prefix".into()))?;
+        Ok(Some(Self {
+            cidr,
+            interface_address,
+        }))
+    }
+    pub(crate) fn bounds(self) -> (u128, u128) {
+        let (base, width) = match self.cidr.network {
+            IpAddr::V4(ip) => (u128::from(u32::from(ip)), 32),
+            IpAddr::V6(ip) => (u128::from(ip), 128),
+        };
+        let host_bits = width - self.cidr.prefix_len;
+        let mask = if host_bits == 128 {
+            u128::MAX
+        } else {
+            (1u128 << host_bits) - 1
+        };
+        (base, base | mask)
+    }
+    pub(crate) fn address(self, value: u128) -> IpAddr {
+        if self.cidr.network.is_ipv4() {
+            Ipv4Addr::from(value as u32).into()
+        } else {
+            Ipv6Addr::from(value).into()
+        }
+    }
+}
+pub(super) fn default_fake_range() -> String {
+    "198.18.0.1/16".into()
+}
+pub(super) fn default_fake_ttl() -> i64 {
+    1
+}
+pub(super) fn default_fake_filter() -> Vec<String> {
+    [
+        "dns.msftnsci.com",
+        "www.msftnsci.com",
+        "www.msftconnecttest.com",
+    ]
+    .map(str::to_owned)
+    .to_vec()
+}
+impl RawDnsConfig {
+    pub(super) fn fake_ip(&self) -> Result<FakeIpConfig> {
+        let enabled = match self.enhanced_mode.as_str() {
+            "redir-host" => false,
+            "fake-ip" => true,
+            _ => return invalid("dns.enhanced-mode must be redir-host or fake-ip"),
+        };
+        let range = FakeIpRange::parse(&self.fake_ip_range, false)?;
+        let range6 = FakeIpRange::parse(&self.fake_ip_range6, true)?;
+        if enabled && range.is_none() && range6.is_none() {
+            return invalid("fake-ip requires at least one range");
+        }
+        let mut filter = Vec::new();
+        let mut rules = Vec::new();
+        if self.fake_ip_filter_mode == FakeIpFilterMode::Rule {
+            for value in &self.fake_ip_filter {
+                let (predicate, action) = value.rsplit_once(',').ok_or_else(|| {
+                    VoleError::InvalidConfig("fake-IP rule requires an action".into())
+                })?;
+                let action = match action.trim().to_ascii_lowercase().as_str() {
+                    "real-ip" => "DIRECT",
+                    "fake-ip" => "REJECT",
+                    _ => return invalid("fake-IP rule action must be real-ip or fake-ip"),
+                };
+                let rule =
+                    parse_rule(&format!("{predicate},{action}"), &RouteTargetsByName::new())?;
+                if !matches!(
+                    rule.kind,
+                    RuleKind::Domain(_)
+                        | RuleKind::DomainSuffix(_)
+                        | RuleKind::DomainKeyword(_)
+                        | RuleKind::DomainWildcard(_)
+                        | RuleKind::DomainRegex(_)
+                        | RuleKind::GeoSite(_)
+                        | RuleKind::RuleSet { .. }
+                        | RuleKind::Match
+                ) {
+                    return invalid("fake-IP filter rules must match domains");
+                }
+                rules.push(rule);
+            }
+        } else {
+            for value in &self.fake_ip_filter {
+                filter.push(normalize_dns_policy_selector(value)?);
+            }
+        }
+        Ok(FakeIpConfig {
+            enabled,
+            range,
+            range6,
+            ttl: self.fake_ip_ttl.clamp(1, u32::MAX.into()) as u32,
+            mode: self.fake_ip_filter_mode,
+            filter,
+            rules,
+        })
+    }
+}
diff --git a/src/config/fallback.rs b/src/config/fallback.rs
new file mode 100644
index 0000000..029ec42
--- /dev/null
+++ b/src/config/fallback.rs
@@ -0,0 +1,59 @@
+use super::*;
+
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub struct DnsFallbackConfig {
+    pub nameservers: Vec<DnsNameserver>,
+    pub geoip: Option<String>,
+    pub ipcidr: Vec<IpCidr>,
+    pub domains: Vec<DnsPolicySelector>,
+    pub lazy: bool,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(default, deny_unknown_fields, rename_all = "kebab-case")]
+pub(super) struct RawFallbackFilter {
+    geoip: bool,
+    geoip_code: String,
+    ipcidr: Vec<String>,
+    domain: Vec<String>,
+}
+impl Default for RawFallbackFilter {
+    fn default() -> Self {
+        Self {
+            geoip: true,
+            geoip_code: "CN".into(),
+            ipcidr: Vec::new(),
+            domain: Vec::new(),
+        }
+    }
+}
+impl RawFallbackFilter {
+    pub(super) fn normalize(
+        self,
+        nameservers: Vec<DnsNameserver>,
+        lazy: bool,
+    ) -> Result<DnsFallbackConfig> {
+        let mut domains = Vec::new();
+        for pattern in self.domain {
+            let selector = normalize_dns_policy_selector(&pattern)?;
+            if !matches!(selector, DnsPolicySelector::Domains(_)) {
+                return invalid("fallback-filter.domain requires domain patterns");
+            }
+            domains.push(selector);
+        }
+        Ok(DnsFallbackConfig {
+            nameservers,
+            geoip: self
+                .geoip
+                .then(|| normalize_geo_code(&self.geoip_code, "fallback-filter.geoip-code"))
+                .transpose()?,
+            ipcidr: self
+                .ipcidr
+                .iter()
+                .map(|cidr| parse_ip_cidr(cidr, cidr.contains(':')))
+                .collect::<Result<_>>()?,
+            domains,
+            lazy,
+        })
+    }
+}
diff --git a/src/config/fingerprint_tests.rs b/src/config/fingerprint_tests.rs
index a3b6aca..5dd8d9b 100644
--- a/src/config/fingerprint_tests.rs
+++ b/src/config/fingerprint_tests.rs
@@ -14,9 +14,9 @@ fn yaml(protocol: &str, fields: &str) -> String {
 
 fn profile(config: &Config) -> Option<ClientFingerprint> {
     match &config.proxies[0].protocol {
-        ProxyProtocol::AnyTls(p) => p.tls.client_fingerprint,
-        ProxyProtocol::Trojan(p) => p.tls.client_fingerprint,
-        ProxyProtocol::Vmess(p) => p.tls.as_ref().unwrap().client_fingerprint,
+        ProxyProtocol::AnyTls(p) => p.security.client_fingerprint(),
+        ProxyProtocol::Trojan(p) => p.security.client_fingerprint(),
+        ProxyProtocol::Vmess(p) => p.security.client_fingerprint(),
         ProxyProtocol::Vless(p) => match &p.security {
             SecurityConfig::Tls(tls) => tls.client_fingerprint,
             SecurityConfig::Reality(reality) => reality.client_fingerprint,
@@ -30,7 +30,7 @@ fn profile(config: &Config) -> Option<ClientFingerprint> {
 fn named_fingerprint_is_strict_and_independent_of_certificate_pins() {
     for protocol in ["anytls", "trojan", "vmess", "vless"] {
         for (value, expected) in [
-            ("chrome120", Some(ClientFingerprint::Chrome120)),
+            ("chrome", Some(ClientFingerprint::Chrome133)),
             ("none", None),
             ("\"\"", None),
         ] {
@@ -52,15 +52,18 @@ fn named_fingerprint_is_strict_and_independent_of_certificate_pins() {
             None
         );
         for value in [
+            "chrome120",
+            "firefox120",
+            "safari16",
             "Chrome120",
             "Chrome",
             "NONE",
             "chrome133",
             "safari16.0",
-            "ios",
-            "android",
-            "edge",
-            "random",
+            "android11",
+            "edge85",
+            "3607.5",
+            "qq11.1",
             "randomized",
             "chrome_psk",
             "chrome_pq",
@@ -93,35 +96,37 @@ fn named_fingerprint_is_strict_and_independent_of_certificate_pins() {
 }
 
 #[test]
-fn selected_names_resolve_to_four_distinct_templates_and_only_documented_aliases() {
+fn selected_names_resolve_to_eight_distinct_fixed_templates() {
     for protocol in ["anytls", "trojan", "vmess", "vless"] {
         let mut templates = Vec::new();
-        for name in ["chrome", "chrome120", "firefox", "safari"] {
+        for (name, expected) in [
+            ("chrome", ClientFingerprint::Chrome133),
+            ("firefox", ClientFingerprint::Firefox120),
+            ("safari", ClientFingerprint::Safari16),
+            ("ios", ClientFingerprint::Ios14),
+            ("android", ClientFingerprint::Android11),
+            ("edge", ClientFingerprint::Edge85),
+            ("360", ClientFingerprint::ThreeSixty75),
+            ("qq", ClientFingerprint::Qq111),
+        ] {
             let config = Config::parse_yaml(
-                yaml(protocol, &format!("client-fingerprint: {name}")).as_bytes(),
+                yaml(protocol, &format!("client-fingerprint: {name:?}")).as_bytes(),
             )
             .unwrap();
             let selected = profile(&config).expect("enabled profile");
+            assert_eq!(selected, expected);
             assert!(
                 !templates.contains(&selected),
                 "{name} cannot reuse another template"
             );
             templates.push(selected);
         }
-        for (alias, template) in [("firefox120", templates[2]), ("safari16", templates[3])] {
-            let config = Config::parse_yaml(
-                yaml(protocol, &format!("client-fingerprint: {alias}")).as_bytes(),
-            )
-            .unwrap();
-            assert_eq!(profile(&config), Some(template));
-        }
     }
 }
 
 #[test]
 fn download_fingerprint_inherits_and_can_be_cleared_independently() {
     for (name, template) in [
-        ("chrome120", ClientFingerprint::Chrome120),
         ("chrome", ClientFingerprint::Chrome133),
         ("firefox", ClientFingerprint::Firefox120),
         ("safari", ClientFingerprint::Safari16),
@@ -141,15 +146,11 @@ fn download_fingerprint_inherits_and_can_be_cleared_independently() {
                 Some(ClientFingerprint::Chrome133),
             ),
             (
-                "\n        client-fingerprint: chrome120",
-                Some(ClientFingerprint::Chrome120),
-            ),
-            (
-                "\n        client-fingerprint: firefox120",
+                "\n        client-fingerprint: firefox",
                 Some(ClientFingerprint::Firefox120),
             ),
             (
-                "\n        client-fingerprint: safari16",
+                "\n        client-fingerprint: safari",
                 Some(ClientFingerprint::Safari16),
             ),
         ] {
@@ -196,6 +197,9 @@ fn download_fingerprint_inherits_and_can_be_cleared_independently() {
             "[]",
             "{}",
             "Chrome",
+            "chrome120",
+            "firefox120",
+            "safari16",
             "chrome133",
             "safari16.0",
         ] {
@@ -213,7 +217,6 @@ fn download_fingerprint_inherits_and_can_be_cleared_independently() {
 #[test]
 fn reality_accepts_named_profile_without_admitting_certificate_policy() {
     for (name, expected) in [
-        ("chrome120", Some(ClientFingerprint::Chrome120)),
         ("chrome", Some(ClientFingerprint::Chrome133)),
         ("firefox", Some(ClientFingerprint::Firefox120)),
         ("safari", Some(ClientFingerprint::Safari16)),
@@ -234,3 +237,49 @@ fn reality_accepts_named_profile_without_admitting_certificate_policy() {
         );
     }
 }
+
+#[test]
+fn ios_and_process_random_fingerprint_use_the_shared_entries() {
+    let selected = process_random_fingerprint();
+    for protocol in ["anytls", "trojan", "vmess", "vless"] {
+        for (value, expected) in [("ios", ClientFingerprint::Ios14), ("random", selected)] {
+            let config = Config::parse_yaml(
+                yaml(protocol, &format!("client-fingerprint: {value}")).as_bytes(),
+            )
+            .unwrap();
+            assert_eq!(profile(&config), Some(expected));
+        }
+    }
+    assert_eq!(process_random_fingerprint(), selected);
+    let mut counts = [0; 4];
+    for value in 0..12 {
+        counts[match weighted_fingerprint(value) {
+            ClientFingerprint::Chrome133 => 0,
+            ClientFingerprint::Safari16 => 1,
+            ClientFingerprint::Ios14 => 2,
+            ClientFingerprint::Firefox120 => 3,
+            _ => unreachable!("random keeps its four-template weights"),
+        }] += 1;
+    }
+    assert_eq!(counts, [6, 3, 2, 1]);
+}
+
+#[test]
+fn tls12_profiles_reject_only_transports_that_require_tls13() {
+    for profile in ["android", "360"] {
+        for transport in [
+            "network: xhttp",
+            "flow: xtls-rprx-vision",
+            "jls-opts: {username: fixture, password: fixture}",
+            "shadow-tls-opts: {version: 3, password: fixture}",
+            "ech-opts: {enable: true}",
+        ] {
+            let fields = format!("client-fingerprint: {profile:?}\n    {transport}");
+            assert!(Config::parse_yaml(yaml("vless", &fields).as_bytes()).is_err());
+        }
+        let fields = format!(
+            "network: xhttp\n    client-fingerprint: chrome\n    xhttp-opts:\n      mode: stream-up\n      download-settings:\n        client-fingerprint: {profile:?}"
+        );
+        assert!(Config::parse_yaml(yaml("vless", &fields).as_bytes()).is_err());
+    }
+}
diff --git a/src/config/functional.rs b/src/config/functional.rs
new file mode 100644
index 0000000..dcb8620
--- /dev/null
+++ b/src/config/functional.rs
@@ -0,0 +1,306 @@
+//! Configuration for named functional route targets without server endpoints.
+use super::*;
+use std::sync::Arc;
+
+pub(super) fn validate_fields(mapping: &serde_yaml_ng::Mapping) -> Result<()> {
+    let Some(kind) = mapping.get("type").and_then(serde_yaml_ng::Value::as_str) else {
+        return Ok(());
+    };
+    if !matches!(kind, "direct" | "dns" | "reject" | "rematch") {
+        return Ok(());
+    }
+    for key in mapping.keys().filter_map(serde_yaml_ng::Value::as_str) {
+        let accepted = matches!(key, "name" | "type")
+            || (kind == "direct"
+                && matches!(
+                    key,
+                    "interface-name" | "routing-mark" | "ip-version" | "tfo" | "mptcp"
+                ))
+            || (kind == "rematch" && matches!(key, "target-rematch-name" | "target-sub-rule"));
+        if !accepted {
+            return invalid("unsupported functional outbound field");
+        }
+    }
+    Ok(())
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct RawFunctional {
+    name: String,
+}
+
+impl RawFunctional {
+    pub(super) fn normalize(
+        self,
+        protocol: ProxyProtocol,
+    ) -> Result<(String, Option<String>, bool, ProxyProtocol)> {
+        validate_route_target_definition_name(&self.name, "proxy name")?;
+        Ok((self.name, None, true, protocol))
+    }
+}
+
+/// A routing control; omitted values preserve metadata, empty values clear it.
+#[derive(Clone, PartialEq, Eq)]
+pub struct RematchConfig {
+    pub target_rematch_name: Option<Arc<str>>,
+    pub target_sub_rule: Option<Arc<str>>,
+}
+impl std::fmt::Debug for RematchConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("RematchConfig")
+            .field("sets_name", &self.target_rematch_name.is_some())
+            .field("sets_program", &self.target_sub_rule.is_some())
+            .finish()
+    }
+}
+#[derive(Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct RawRematch {
+    name: String,
+    #[serde(rename = "target-rematch-name", default)]
+    target_rematch_name: Option<String>,
+    #[serde(rename = "target-sub-rule", default)]
+    target_sub_rule: Option<String>,
+}
+impl RawRematch {
+    pub(super) fn normalize(self) -> Result<(String, Option<String>, bool, ProxyProtocol)> {
+        validate_route_target_definition_name(&self.name, "proxy name")?;
+        if self.target_rematch_name.is_none() && self.target_sub_rule.is_none() {
+            return invalid("rematch requires target-rematch-name or target-sub-rule");
+        }
+        Ok((
+            self.name,
+            None,
+            true,
+            ProxyProtocol::Rematch(RematchConfig {
+                target_rematch_name: self.target_rematch_name.map(Arc::from),
+                target_sub_rule: self.target_sub_rule.map(Arc::from),
+            }),
+        ))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn rematch_schema_preserves_omitted_empty_and_unknown_program_names() {
+        let config = Config::parse_yaml(
+            br#"proxies:
+  - {name: marked, type: rematch, target-rematch-name: blue}
+  - {name: clear, type: rematch, target-rematch-name: '', target-sub-rule: ''}
+  - {name: unknown, type: rematch, target-sub-rule: missing}
+  - {name: null-program, type: rematch, target-rematch-name: blue, target-sub-rule: null}
+  - {name: null-mark, type: rematch, target-rematch-name: null, target-sub-rule: child}
+"#,
+        )
+        .unwrap();
+        let node = |index: usize| match &config.proxies[index].protocol {
+            ProxyProtocol::Rematch(value) => value,
+            _ => panic!("rematch protocol"),
+        };
+        assert_eq!(node(0).target_rematch_name.as_deref(), Some("blue"));
+        assert_eq!(node(0).target_sub_rule.as_deref(), None);
+        assert_eq!(node(1).target_rematch_name.as_deref(), Some(""));
+        assert_eq!(node(1).target_sub_rule.as_deref(), Some(""));
+        assert_eq!(node(2).target_sub_rule.as_deref(), Some("missing"));
+        assert_eq!(node(3).target_rematch_name.as_deref(), Some("blue"));
+        assert_eq!(node(3).target_sub_rule, None);
+        assert_eq!(node(4).target_rematch_name, None);
+        assert_eq!(node(4).target_sub_rule.as_deref(), Some("child"));
+        assert!(
+            config
+                .proxies
+                .iter()
+                .all(|node| node.server_endpoint().is_none() && node.udp)
+        );
+        for fields in [
+            "",
+            "target-rematch-name: null",
+            "target-rematch-name: null, target-sub-rule: null",
+            "target-sub-rule: 1",
+            "target-sub-rule: child, udp: true",
+            "target-sub-rule: child, dialer-proxy: DIRECT",
+            "target-sub-rule: child, smux: {enabled: false}",
+            "target-sub-rule: child, mptcp: true",
+        ] {
+            assert!(
+                Config::parse_yaml(
+                    format!("proxies: [{{name: edge, type: rematch, {fields}}}]").as_bytes()
+                )
+                .is_err()
+            );
+        }
+    }
+
+    #[test]
+    fn rematch_values_survive_provider_materialization_without_subrule_binding() {
+        let config = Config::parse_yaml(
+            br#"proxy-providers:
+  controls:
+    type: inline
+    payload:
+      - {name: mark, type: rematch, target-rematch-name: '', target-sub-rule: missing}
+proxy-groups: [{name: selected, type: select, use: [controls]}]
+rules: ['REMATCH-NAME,blue/Green,DIRECT', 'MATCH,selected']
+"#,
+        )
+        .unwrap();
+        let fresh = config
+            .providers
+            .as_ref()
+            .unwrap()
+            .materialize(&Default::default())
+            .unwrap();
+        assert_eq!(config.proxies, fresh.proxies);
+        assert_eq!(config.rules, fresh.rules);
+    }
+
+    #[test]
+    fn node_tfo_is_explicit_and_does_not_inherit_across_proxy_chain() {
+        let config = Config::parse_yaml(
+            br#"proxies:
+  - {name: leaf, type: socks5, server: 192.0.2.1, port: 1080, tfo: true, dialer-proxy: hop}
+  - {name: hop, type: socks5, server: 192.0.2.2, port: 1080}
+  - {name: local, type: direct, tfo: true}
+"#,
+        )
+        .unwrap();
+        assert!(config.proxies[0].tfo);
+        assert!(!config.proxies[1].tfo);
+        assert!(config.proxies[2].tfo);
+    }
+
+    #[test]
+    fn node_mptcp_preserves_explicit_policy_across_proxy_chain() {
+        let config = Config::parse_yaml(
+            br#"proxies:
+  - {name: leaf, type: socks5, server: 192.0.2.1, port: 1080, mptcp: true, dialer-proxy: hop}
+  - {name: hop, type: socks5, server: 192.0.2.2, port: 1080}
+  - {name: local, type: direct, mptcp: true}
+  - {name: ordinary, type: direct, mptcp: false}
+"#,
+        )
+        .unwrap();
+        assert!(config.proxies[0].mptcp);
+        assert!(!config.proxies[1].mptcp);
+        assert!(config.proxies[2].mptcp);
+        assert!(!config.proxies[3].mptcp);
+        assert!(config.proxies.iter().all(|node| !node.tfo));
+
+        for kind in ["direct", "socks5, server: 192.0.2.1, port: 1080"] {
+            for value in ["null", "'true'", "1"] {
+                let input = format!("proxies: [{{name: edge, type: {kind}, mptcp: {value}}}]");
+                assert!(Config::parse_yaml(input.as_bytes()).is_err());
+            }
+        }
+    }
+
+    #[test]
+    fn functional_outbounds_have_names_and_udp_without_server_endpoints() {
+        let config = Config::parse_yaml(
+            br#"
+proxies:
+  - {name: local, type: direct, interface-name: eth0, routing-mark: 7, ip-version: ipv4}
+  - {name: resolver, type: dns}
+  - {name: blocked, type: reject}
+rules: ['DST-PORT,53,resolver', 'DOMAIN,blocked.test,blocked', 'MATCH,local']
+"#,
+        )
+        .unwrap();
+        assert_eq!(config.proxies.len(), 3);
+        assert!(
+            config
+                .proxies
+                .iter()
+                .all(|node| node.server_endpoint().is_none() && node.udp)
+        );
+        assert_eq!(config.proxies[0].egress.interface.as_deref(), Some("eth0"));
+        assert_eq!(config.proxies[0].egress.routing_mark, 7);
+        assert_eq!(config.proxies[0].ip_version, IpVersion::Ipv4);
+    }
+
+    #[test]
+    fn functional_schema_rejects_endpoint_and_unconsumed_options() {
+        for kind in ["direct", "dns", "reject"] {
+            let mut fields = vec![
+                "server: example.test",
+                "port: 443",
+                "udp: true",
+                "dialer-proxy: DIRECT",
+                "smux: {enabled: false}",
+                "action: drop",
+            ];
+            if kind != "direct" {
+                fields.extend([
+                    "interface-name: ''",
+                    "routing-mark: 0",
+                    "ip-version: dual",
+                    "mptcp: false",
+                ]);
+            }
+            for field in fields {
+                let input = format!("proxies: [{{name: edge, type: {kind}, {field}}}]");
+                assert!(
+                    Config::parse_yaml(input.as_bytes()).is_err(),
+                    "{kind}: {field}"
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn drop_and_compatible_are_real_reserved_rule_and_group_targets() {
+        let config = Config::parse_yaml(
+            br#"
+proxy-groups:
+  - {name: selected, type: select, proxies: [REJECT-DROP, COMPATIBLE]}
+rules: ['DOMAIN,drop.test,REJECT-DROP', 'MATCH,COMPATIBLE']
+"#,
+        )
+        .unwrap();
+        assert_eq!(config.rules[0].action, RuleAction::RejectDrop);
+        assert_eq!(config.rules[1].action, RuleAction::Direct);
+        assert_eq!(
+            config.proxy_groups[0].members[0].target,
+            ProxyGroupMemberTarget::RejectDrop
+        );
+        assert_eq!(
+            config.proxy_groups[0].members[1].target,
+            ProxyGroupMemberTarget::Direct
+        );
+    }
+
+    #[test]
+    fn dns_reserved_tokens_are_not_physical_interface_names() {
+        let config = Config::parse_yaml(
+            br#"
+dns:
+  enable: true
+  nameserver:
+    - udp://192.0.2.53#COMPATIBLE
+    - tcp://192.0.2.53#REJECT
+    - udp://192.0.2.53#REJECT-DROP
+"#,
+        )
+        .unwrap();
+        assert_eq!(
+            config
+                .dns
+                .nameservers
+                .iter()
+                .map(|server| server.route)
+                .collect::<Vec<_>>(),
+            [DnsRoute::Direct, DnsRoute::Reject, DnsRoute::RejectDrop]
+        );
+        assert!(
+            config
+                .dns
+                .nameservers
+                .iter()
+                .all(|server| server.options.interface.is_none())
+        );
+    }
+}
diff --git a/src/config/groups.rs b/src/config/groups.rs
new file mode 100644
index 0000000..6a191b7
--- /dev/null
+++ b/src/config/groups.rs
@@ -0,0 +1,110 @@
+use super::*;
+
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum GroupKind {
+    #[default]
+    Select,
+    UrlTest,
+    Fallback,
+    LoadBalance,
+}
+impl GroupKind {
+    pub fn controller_type(self) -> &'static str {
+        match self {
+            Self::Select => "Selector",
+            Self::UrlTest => "URLTest",
+            Self::Fallback => "Fallback",
+            Self::LoadBalance => "LoadBalance",
+        }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
+#[serde(default, deny_unknown_fields, rename_all = "kebab-case")]
+pub struct ProfileConfig {
+    pub store_fake_ip: bool,
+    pub store_selected: bool,
+}
+impl Default for ProfileConfig {
+    fn default() -> Self {
+        Self {
+            store_selected: true,
+            store_fake_ip: false,
+        }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
+#[serde(default, deny_unknown_fields, rename_all = "kebab-case")]
+pub struct HealthCheckConfig {
+    pub enable: bool,
+    pub url: String,
+    pub interval: u64,
+    pub timeout: u64,
+    pub lazy: bool,
+    #[serde(deserialize_with = "super::scalar::string_or_integer")]
+    pub expected_status: String,
+}
+impl Default for HealthCheckConfig {
+    fn default() -> Self {
+        Self {
+            enable: false,
+            url: String::new(),
+            interval: 0,
+            timeout: 5000,
+            lazy: true,
+            expected_status: String::new(),
+        }
+    }
+}
+impl HealthCheckConfig {
+    pub(crate) fn validate(&self) -> Result<()> {
+        if !self.url.is_empty() {
+            crate::resource::probe::Target::parse(&self.url).map_err(|_| {
+                VoleError::InvalidConfig("health check requires an HTTP(S) URL".into())
+            })?;
+        }
+        status_ranges(&self.expected_status)?;
+        Ok(())
+    }
+}
+pub(crate) fn status_ranges(value: &str) -> Result<Vec<(u16, u16)>> {
+    let value = value.trim();
+    if value.is_empty() || value == "*" {
+        return Ok(Vec::new());
+    }
+    value
+        .split('/')
+        .map(|part| {
+            let (first, last) = part.split_once('-').unwrap_or((part, part));
+            let start = first
+                .parse::<u16>()
+                .map_err(|_| VoleError::InvalidConfig("invalid expected-status".into()))?;
+            let end = last
+                .parse::<u16>()
+                .map_err(|_| VoleError::InvalidConfig("invalid expected-status".into()))?;
+            if start > end {
+                return invalid("invalid expected-status range");
+            }
+            Ok((start, end))
+        })
+        .collect()
+}
+
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum BalanceStrategy {
+    #[default]
+    #[serde(alias = "")]
+    ConsistentHashing,
+    RoundRobin,
+    StickySessions,
+}
+
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Deserialize)]
+pub enum BalanceHashKey {
+    #[default]
+    #[serde(rename = "")]
+    Default,
+    #[serde(rename = "in-user")]
+    InUser,
+}
diff --git a/src/config/grpc.rs b/src/config/grpc.rs
new file mode 100644
index 0000000..4b2f501
--- /dev/null
+++ b/src/config/grpc.rs
@@ -0,0 +1,104 @@
+//! Shared Mihomo gRPC options for stream protocols.
+use super::{deserialize_present_option, invalid};
+use crate::Result;
+use serde::Deserialize;
+
+#[derive(Clone, PartialEq, Eq)]
+pub struct GrpcOptions {
+    pub user_agent: String,
+    pub ping_interval: u64,
+    pub max_connections: usize,
+    pub min_streams: usize,
+    pub max_streams: usize,
+}
+impl std::fmt::Debug for GrpcOptions {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("GrpcOptions").finish_non_exhaustive()
+    }
+}
+impl Default for GrpcOptions {
+    fn default() -> Self {
+        Self {
+            user_agent: "grpc-go/1.36.0".into(),
+            ping_interval: 0,
+            max_connections: 1,
+            min_streams: 0,
+            max_streams: 0,
+        }
+    }
+}
+
+#[derive(Default, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct RawGrpc {
+    #[serde(rename = "grpc-service-name", default)]
+    service: String,
+    #[serde(
+        rename = "grpc-user-agent",
+        default,
+        deserialize_with = "deserialize_present_option"
+    )]
+    user_agent: Option<String>,
+    #[serde(rename = "ping-interval", default)]
+    ping_interval: isize,
+    #[serde(rename = "max-connections", default)]
+    max_connections: isize,
+    #[serde(rename = "min-streams", default)]
+    min_streams: isize,
+    #[serde(rename = "max-streams", default)]
+    max_streams: isize,
+}
+
+impl RawGrpc {
+    pub(super) fn normalize(self) -> Result<(String, GrpcOptions)> {
+        if self.ping_interval < 0 {
+            return invalid("negative gRPC ping-interval is unsupported");
+        }
+        let service = if self.service.is_empty() {
+            "GunService".into()
+        } else {
+            self.service
+        };
+        let path = if service.starts_with('/') {
+            service
+        } else {
+            format!("/{service}/Tun")
+        };
+        if path.contains(['?', '\r', '\n', '#']) {
+            return invalid("invalid gRPC service path");
+        }
+        let user_agent = self
+            .user_agent
+            .filter(|value| !value.is_empty())
+            .unwrap_or_else(|| "grpc-go/1.36.0".into());
+        let ping_interval = self.ping_interval as u64;
+        if user_agent.len() > 8192
+            || user_agent.parse::<http::HeaderValue>().is_err()
+            || std::time::Instant::now()
+                .checked_add(std::time::Duration::from_secs(ping_interval))
+                .is_none()
+        {
+            return invalid("invalid gRPC options");
+        }
+        let positive = |value: isize| value.max(0) as usize;
+        // Four node-owned connections share bidirectional Gun traffic without
+        // increasing per-connection credit. Explicit and negative thresholds
+        // retain their policies; only the literal all-zero YAML default changes.
+        let max_connections =
+            if self.max_connections == 0 && self.min_streams == 0 && self.max_streams == 0 {
+                4
+            } else {
+                positive(self.max_connections)
+            };
+        Ok((
+            path,
+            GrpcOptions {
+                user_agent,
+                ping_interval,
+                max_connections,
+                min_streams: positive(self.min_streams),
+                max_streams: positive(self.max_streams),
+            },
+        ))
+    }
+}
diff --git a/src/config/http_proxy.rs b/src/config/http_proxy.rs
new file mode 100644
index 0000000..4f6f90a
--- /dev/null
+++ b/src/config/http_proxy.rs
@@ -0,0 +1,164 @@
+use super::*;
+use std::collections::BTreeMap;
+#[derive(Clone, PartialEq, Eq)]
+pub struct HttpOutboundConfig {
+    pub address: String,
+    pub port: u16,
+    pub tls: Option<TlsConfig>,
+    pub auth: Option<ProxyCredentials>,
+    pub headers: BTreeMap<String, String>,
+}
+impl std::fmt::Debug for HttpOutboundConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("HttpOutboundConfig")
+            .field("tls", &self.tls.is_some())
+            .finish_non_exhaustive()
+    }
+}
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "kebab-case")]
+pub(super) struct RawHttp {
+    name: String,
+    server: String,
+    port: u16,
+    #[serde(default)]
+    username: String,
+    #[serde(default)]
+    password: String,
+    #[serde(default)]
+    tls: bool,
+    #[serde(default)]
+    sni: Option<String>,
+    #[serde(default)]
+    skip_cert_verify: bool,
+    #[serde(default)]
+    name_cert_verify: Option<String>,
+    #[serde(default)]
+    fingerprint: Option<String>,
+    #[serde(default)]
+    certificate: Option<String>,
+    #[serde(default)]
+    private_key: Option<String>,
+    #[serde(default)]
+    headers: BTreeMap<String, String>,
+    #[serde(default)]
+    dialer_proxy: Option<String>,
+}
+impl std::fmt::Debug for RawHttp {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("RawHttp").finish_non_exhaustive()
+    }
+}
+impl RawHttp {
+    pub(super) fn normalize(self) -> Result<(String, Option<String>, bool, ProxyProtocol)> {
+        if !cfg!(feature = "outbound-http") {
+            return invalid("HTTP outbound support is disabled at build time");
+        }
+        validate_host(&self.server, "HTTP server")?;
+        validate_port(self.port, "HTTP")?;
+        let auth = if !self.username.is_empty() && !self.password.is_empty() {
+            Some(
+                ProxyCredentials::new(self.username, self.password).map_err(|_| {
+                    VoleError::InvalidConfig("invalid HTTP proxy credentials".into())
+                })?,
+            )
+        } else {
+            None
+        };
+        let mut header_bytes = 0usize;
+        for (name, value) in &self.headers {
+            header_bytes = header_bytes
+                .saturating_add(name.len())
+                .saturating_add(value.len());
+            if http::header::HeaderName::from_bytes(name.as_bytes()).is_err()
+                || http::HeaderValue::from_str(value).is_err()
+                || header_bytes > 32 * 1024
+            {
+                return invalid("invalid HTTP proxy headers");
+            }
+        }
+        if self.headers.keys().any(|key| {
+            ["content-length", "transfer-encoding"]
+                .iter()
+                .any(|reserved| key.eq_ignore_ascii_case(reserved))
+        }) {
+            return invalid("HTTP CONNECT does not carry a request body");
+        }
+        let tls = if self.tls {
+            let name = self
+                .sni
+                .filter(|name| !name.is_empty())
+                .unwrap_or_else(|| self.server.clone());
+            validate_host(&name, "HTTP sni")?;
+            let verification_name = normalize_verification_name(self.name_cert_verify)?;
+            let identity = normalize_client_identity(self.certificate, self.private_key)?;
+            Some(TlsConfig {
+                server_name: name,
+                alpn: vec![b"http/1.1".to_vec()],
+                tls13_only: false,
+                required_alpn: None,
+                ech: None,
+                client_fingerprint: None,
+                identity,
+                certificate: TlsCertificatePolicy {
+                    skip_cert_verify: self.skip_cert_verify,
+                    verification_name,
+                    fingerprint: normalize_certificate_fingerprint(self.fingerprint.as_deref())?,
+                },
+            })
+        } else {
+            if self.sni.is_some()
+                || self.skip_cert_verify
+                || self.name_cert_verify.is_some()
+                || self.fingerprint.is_some()
+                || self.certificate.is_some()
+                || self.private_key.is_some()
+            {
+                return invalid("HTTP TLS options require tls: true");
+            }
+            None
+        };
+        Ok((
+            self.name,
+            self.dialer_proxy,
+            false,
+            ProxyProtocol::Http(HttpOutboundConfig {
+                address: self.server,
+                port: self.port,
+                tls,
+                auth,
+                headers: self.headers,
+            }),
+        ))
+    }
+}
+
+#[cfg(all(test, feature = "outbound-http"))]
+mod tests {
+    use super::*;
+    #[test]
+    fn http_tls_and_common_node_options_normalize() {
+        let config = Config::parse_yaml(
+            br#"mixed-port: 1080
+proxies:
+  - name: web
+    type: http
+    server: proxy.example.com
+    port: 443
+    tls: true
+    username: u
+    password: p
+    ip-version: ipv4-prefer
+    headers: {Host: custom.example.com}
+"#,
+        )
+        .unwrap();
+        assert_eq!(config.proxies[0].ip_version, IpVersion::Ipv4Prefer);
+        let ProxyProtocol::Http(http) = &config.proxies[0].protocol else {
+            panic!()
+        };
+        assert_eq!(http.tls.as_ref().unwrap().server_name, "proxy.example.com");
+        assert!(http.auth.as_ref().unwrap().matches(b"u", b"p"));
+        assert!(!config.proxies[0].udp);
+    }
+}
diff --git a/src/config/hysteria2.rs b/src/config/hysteria2.rs
index 05bc496..474e2ba 100644
--- a/src/config/hysteria2.rs
+++ b/src/config/hysteria2.rs
@@ -1,8 +1,9 @@
 use serde::Deserialize;
 
 use super::{
-    ProxyProtocol, TlsCertificatePolicy, TlsConfig, TlsIdentityPem, deserialize_present_option,
-    invalid, validate_host, validate_port,
+    ProxyProtocol, TlsCertificatePolicy, TlsConfig, deserialize_present_option, invalid,
+    normalize_certificate_fingerprint, normalize_client_identity, normalize_verification_name,
+    validate_host, validate_port,
 };
 use crate::Result;
 
@@ -16,7 +17,27 @@ pub struct Hysteria2OutboundConfig {
     pub down: u64,
     pub udp_mtu: u16,
     pub obfs_password: Option<String>,
+    pub gecko: Option<Hysteria2Gecko>,
+    pub realm: Option<super::Hysteria2Realm>,
     pub hopping: Option<Hysteria2Hopping>,
+    pub stream_window: super::QuicReceiveWindow,
+    pub connection_window: super::QuicReceiveWindow,
+    pub handshake_timeout: std::time::Duration,
+}
+
+#[derive(Clone, PartialEq, Eq)]
+pub struct Hysteria2Gecko {
+    pub password: String,
+    pub min_packet_size: u16,
+    pub max_packet_size: u16,
+}
+impl std::fmt::Debug for Hysteria2Gecko {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Hysteria2Gecko")
+            .field("min_packet_size", &self.min_packet_size)
+            .field("max_packet_size", &self.max_packet_size)
+            .finish_non_exhaustive()
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -42,16 +63,29 @@ pub(super) struct RawHysteria2 {
     port: Option<u16>,
     #[serde(default)]
     password: String,
-    #[serde(default)]
-    udp: bool,
+    // Accepted for compatibility; Mihomo always advertises UDP for this protocol.
+    #[serde(rename = "udp", default)]
+    _udp: bool,
     #[serde(default, deserialize_with = "deserialize_present_option")]
     sni: Option<String>,
     #[serde(default, deserialize_with = "deserialize_present_option")]
     alpn: Option<Vec<String>>,
     #[serde(rename = "skip-cert-verify", default)]
     skip_cert_verify: bool,
+    #[serde(
+        rename = "name-cert-verify",
+        default,
+        deserialize_with = "deserialize_present_option"
+    )]
+    name_cert_verify: Option<String>,
     #[serde(default, deserialize_with = "deserialize_present_option")]
     fingerprint: Option<String>,
+    #[serde(
+        rename = "ech-opts",
+        default,
+        deserialize_with = "super::ech::deserialize"
+    )]
+    ech_opts: Option<super::ech::RawEch>,
     #[serde(
         rename = "certificate",
         default,
@@ -84,6 +118,26 @@ pub(super) struct RawHysteria2 {
         deserialize_with = "deserialize_present_option"
     )]
     obfs_password: Option<String>,
+    #[serde(rename = "obfs-min-packet-size", default)]
+    obfs_min_packet_size: i64,
+    #[serde(rename = "obfs-max-packet-size", default)]
+    obfs_max_packet_size: i64,
+    #[serde(
+        rename = "realm-opts",
+        default,
+        deserialize_with = "deserialize_present_option"
+    )]
+    realm: Option<super::hysteria2_realm::RawRealm>,
+    #[serde(rename = "initial-stream-receive-window", default)]
+    initial_stream_receive_window: u64,
+    #[serde(rename = "max-stream-receive-window", default)]
+    max_stream_receive_window: u64,
+    #[serde(rename = "initial-connection-receive-window", default)]
+    initial_connection_receive_window: u64,
+    #[serde(rename = "max-connection-receive-window", default)]
+    max_connection_receive_window: u64,
+    #[serde(rename = "handshake-timeout", default)]
+    handshake_timeout: i64,
     #[serde(default, deserialize_with = "deserialize_present_option")]
     ports: Option<String>,
     #[serde(
@@ -113,13 +167,13 @@ impl RawHysteria2 {
             return invalid("Hysteria2 outbound support is disabled at build time");
         }
         validate_host(&self.server, "Hysteria2 server")?;
-        if let Some(port) = self.port {
-            validate_port(port, "Hysteria2")?;
-        }
         let hopping = self
             .ports
+            .filter(|ports| !ports.is_empty())
+            .map(|ports| parse_ports(&ports))
+            .transpose()?
+            .filter(|ports| !ports.is_empty())
             .map(|ports| {
-                let ports = parse_ports(&ports)?;
                 let (min_seconds, max_seconds) = parse_interval(self.hop_interval.as_ref())?;
                 Ok::<_, crate::VoleError>(Hysteria2Hopping {
                     ports,
@@ -137,6 +191,7 @@ impl RawHysteria2 {
                 crate::VoleError::InvalidConfig("Hysteria2 requires port or ports".into())
             })?,
         };
+        validate_port(port, "Hysteria2")?;
         // The complete auth header section is bounded to 16 KiB. Validate the
         // raw value, without trimming credentials or printing them on failure.
         if self.password.len() > 8192
@@ -144,12 +199,53 @@ impl RawHysteria2 {
         {
             return invalid("invalid or over-limit Hysteria2 authentication header");
         }
-        let obfs_password = match (self.obfs.as_deref(), self.obfs_password) {
-            (None, None) => None,
-            (Some("salamander"), Some(password)) if !password.is_empty() => Some(password),
-            _ => return invalid("Hysteria2 Salamander requires obfs and a nonempty obfs-password"),
+        let realm = self.realm.map(|raw| raw.normalize()).transpose()?.flatten();
+        if realm.is_some() && hopping.is_some() {
+            return invalid("Hysteria2 Realm and ports are mutually exclusive");
+        }
+        let (obfs_password, gecko) = match (
+            self.obfs.as_deref().filter(|value| !value.is_empty()),
+            self.obfs_password,
+        ) {
+            (None, None) if self.obfs_min_packet_size == 0 && self.obfs_max_packet_size == 0 => {
+                (None, None)
+            }
+            (Some("salamander"), Some(password))
+                if !password.is_empty()
+                    && self.obfs_min_packet_size == 0
+                    && self.obfs_max_packet_size == 0 =>
+            {
+                (Some(password), None)
+            }
+            (Some("gecko"), Some(password)) if !password.is_empty() => {
+                let min = if self.obfs_min_packet_size == 0 {
+                    512
+                } else {
+                    self.obfs_min_packet_size
+                };
+                let max = if self.obfs_max_packet_size == 0 {
+                    1200
+                } else {
+                    self.obfs_max_packet_size
+                };
+                if min <= 0 || min > max || max > 2048 {
+                    return invalid("invalid Hysteria2 Gecko packet size range");
+                }
+                (
+                    None,
+                    Some(Hysteria2Gecko {
+                        password,
+                        min_packet_size: min as u16,
+                        max_packet_size: max as u16,
+                    }),
+                )
+            }
+            _ => return invalid("invalid Hysteria2 obfuscation options"),
         };
-        let server_name = self.sni.unwrap_or_else(|| self.server.clone());
+        let server_name = self
+            .sni
+            .filter(|name| !name.is_empty())
+            .unwrap_or_else(|| self.server.clone());
         validate_host(&server_name, "Hysteria2 sni")?;
         let mut alpn = self.alpn.unwrap_or_default();
         if alpn.is_empty() {
@@ -160,32 +256,18 @@ impl RawHysteria2 {
         {
             return invalid("invalid Hysteria2 ALPN list");
         }
-        let identity = match (self.certificate, self.private_key) {
-            (None, None) => None,
-            (Some(certificate), Some(private_key)) => {
-                #[cfg(feature = "outbound-hysteria2")]
-                crate::security::TlsClientIdentity::from_pem(&certificate, &private_key).map_err(
-                    |_| crate::VoleError::InvalidConfig("invalid Hysteria2 client identity".into()),
-                )?;
-                Some(TlsIdentityPem {
-                    certificate,
-                    private_key,
-                })
-            }
-            _ => return invalid("Hysteria2 certificate and private-key must be paired"),
-        };
-        let fingerprint = self
-            .fingerprint
-            .map(|pin| {
-                super::vless::parse_pin(&pin).map_err(|_| {
-                    crate::VoleError::InvalidConfig(
-                        "invalid Hysteria2 certificate fingerprint".into(),
-                    )
-                })
-            })
-            .transpose()?;
+        let ech = self
+            .ech_opts
+            .map(|raw| raw.normalize(false))
+            .transpose()?
+            .flatten();
+        if ech.is_some() && server_name.parse::<std::net::IpAddr>().is_ok() {
+            return invalid("Hysteria2 ECH requires DNS sni");
+        }
+        let identity = normalize_client_identity(self.certificate, self.private_key)?;
+        let fingerprint = normalize_certificate_fingerprint(self.fingerprint.as_deref())?;
         let udp_mtu = if self.udp_mtu == 0 {
-            1197
+            crate::limits::HY2_QUIC_PAYLOAD as u16
         } else {
             self.udp_mtu
         };
@@ -195,13 +277,13 @@ impl RawHysteria2 {
         Ok((
             self.name,
             self.dialer_proxy,
-            self.udp,
-            ProxyProtocol::Hysteria2(Hysteria2OutboundConfig {
+            true,
+            ProxyProtocol::Hysteria2(Box::new(Hysteria2OutboundConfig {
                 address: self.server,
                 port,
                 password: self.password,
                 tls: TlsConfig {
-                    ech: None,
+                    ech,
                     client_fingerprint: None,
                     server_name,
                     alpn: alpn.into_iter().map(String::into_bytes).collect(),
@@ -210,7 +292,7 @@ impl RawHysteria2 {
                     certificate: TlsCertificatePolicy {
                         skip_cert_verify: self.skip_cert_verify,
                         fingerprint,
-                        verification_name: None,
+                        verification_name: normalize_verification_name(self.name_cert_verify)?,
                     },
                     identity,
                 },
@@ -218,8 +300,29 @@ impl RawHysteria2 {
                 down: parse_rate(self.down)?,
                 udp_mtu,
                 obfs_password,
+                gecko,
+                realm,
                 hopping,
-            }),
+                stream_window: super::QuicReceiveWindow::normalize(
+                    self.initial_stream_receive_window,
+                    self.max_stream_receive_window,
+                    super::QuicReceiveWindow {
+                        initial: 64 * 1024,
+                        maximum: 64 * 1024,
+                    },
+                )?,
+                connection_window: super::QuicReceiveWindow::normalize(
+                    self.initial_connection_receive_window,
+                    self.max_connection_receive_window,
+                    super::QuicReceiveWindow {
+                        initial: 4 * 1024 * 1024,
+                        maximum: 4 * 1024 * 1024,
+                    },
+                )?,
+                handshake_timeout: std::time::Duration::from_secs(
+                    self.handshake_timeout.max(0) as u64
+                ),
+            })),
         ))
     }
 }
@@ -264,12 +367,19 @@ fn decimal(value: &str) -> Result<u32> {
 }
 
 fn parse_ports(value: &str) -> Result<Vec<u16>> {
+    if matches!(value.trim(), "" | "*") {
+        return Ok(Vec::new());
+    }
     let mut ports = std::collections::BTreeSet::new();
-    for item in value.split(',') {
+    for item in value.split([',', '/']).filter(|item| !item.is_empty()) {
         let item = item.trim();
         let (start, end) = item.split_once('-').unwrap_or((item, item));
-        let (start, end) = (decimal(start)?, decimal(end)?);
-        if start == 0 || start > end || end > 65535 {
+        let (start, end) = (
+            decimal(start.trim_matches(['[', ']', ' ']))?,
+            decimal(end.trim_matches(['[', ']', ' ']))?,
+        );
+        let (start, end) = (start.min(end), start.max(end));
+        if start == 0 || end > 65535 {
             return invalid("invalid Hysteria2 ports");
         }
         ports.extend((start..=end).map(|port| port as u16));
@@ -283,10 +393,80 @@ fn parse_interval(value: Option<&NumberOrText>) -> Result<(u32, u32)> {
         Some(NumberOrText::Number(value)) => value.to_string(),
         Some(NumberOrText::Text(value)) => value.clone(),
     };
-    let (start, end) = text.split_once('-').unwrap_or((&text, &text));
-    let (start, end) = (decimal(start)?, decimal(end)?);
-    if start < 5 || start > end {
-        return invalid("Hysteria2 hop-interval requires 5 <= min <= max <= 4294967295 seconds");
+    let text = text.trim();
+    let (start, end) = text.split_once('-').unwrap_or((text, text));
+    let (start, end) = if text.is_empty() {
+        (0, 0)
+    } else {
+        (
+            decimal(start.trim_matches(['[', ']', ' ']))?,
+            decimal(end.trim_matches(['[', ']', ' ']))?,
+        )
+    };
+    let (start, end) = (start.min(end), start.max(end));
+    let start = if start == 0 { 30 } else { start.max(5) };
+    Ok((start, end.max(start)))
+}
+
+#[cfg(all(test, feature = "outbound-hysteria2"))]
+mod p08_tests {
+    use super::*;
+
+    #[test]
+    fn hopping_accepts_reference_ranges_and_ignores_unused_zero_port() {
+        let config =
+            parse(serde_json::json!({"port":0,"ports":"8445-8443/443,,8444","hop-interval":"1-3"}))
+                .unwrap();
+        assert_eq!(config.port, 443);
+        let hopping = config.hopping.unwrap();
+        assert_eq!(hopping.ports, vec![443, 8443, 8444, 8445]);
+        assert_eq!((hopping.min_seconds, hopping.max_seconds), (5, 5));
+        let hopping = parse(serde_json::json!({"ports":"443","hop-interval":0}))
+            .unwrap()
+            .hopping
+            .unwrap();
+        assert_eq!((hopping.min_seconds, hopping.max_seconds), (30, 30));
+        assert!(
+            parse(serde_json::json!({"ports":"*"}))
+                .unwrap()
+                .hopping
+                .is_none()
+        );
+    }
+
+    #[test]
+    fn hopping_keeps_invalid_ports_and_overflow_out_of_the_socket_path() {
+        for fields in [
+            serde_json::json!({"port":0}),
+            serde_json::json!({"ports":"0/443"}),
+            serde_json::json!({"ports":"65536"}),
+            serde_json::json!({"ports":"443","hop-interval":"4294967296"}),
+        ] {
+            assert!(parse(fields).is_err());
+        }
+    }
+    fn parse(extra: serde_json::Value) -> Result<Hysteria2OutboundConfig> {
+        let mut raw = serde_json::json!({"name":"edge","server":"peer.invalid","port":443});
+        raw.as_object_mut()
+            .unwrap()
+            .extend(extra.as_object().unwrap().clone());
+        let raw: RawHysteria2 = serde_json::from_value(raw).unwrap();
+        let (_, _, _, ProxyProtocol::Hysteria2(config)) = raw.normalize()? else {
+            panic!("HY2")
+        };
+        Ok(*config)
+    }
+    #[test]
+    fn gecko_options_consume_actual_min_max_and_realm_excludes_hopping() {
+        let gecko=parse(serde_json::json!({"obfs":"gecko","obfs-password":"private","obfs-min-packet-size":600,"obfs-max-packet-size":1400})).unwrap().gecko.unwrap();
+        assert_eq!((gecko.min_packet_size, gecko.max_packet_size), (600, 1400));
+        assert!(!format!("{gecko:?}").contains("private"));
+        for fields in [
+            serde_json::json!({"obfs":"gecko","obfs-password":"private","obfs-min-packet-size":1401,"obfs-max-packet-size":1400}),
+            serde_json::json!({"obfs":"salamander","obfs-password":"private","obfs-max-packet-size":1200}),
+            serde_json::json!({"ports":"443,8443","realm-opts":{"enable":true,"server-url":"https://control.example","realm-id":"zone","stun-servers":["192.0.2.1"]}}),
+        ] {
+            assert!(parse(fields).is_err());
+        }
     }
-    Ok((start, end))
 }
diff --git a/src/config/hysteria2_realm.rs b/src/config/hysteria2_realm.rs
new file mode 100644
index 0000000..97c2a5c
--- /dev/null
+++ b/src/config/hysteria2_realm.rs
@@ -0,0 +1,179 @@
+//! Hysteria Realm control options; no server-side registration or event stream.
+use super::{
+    TlsCertificatePolicy, TlsConfig, deserialize_present_option, invalid,
+    normalize_certificate_fingerprint, normalize_client_identity, normalize_verification_name,
+    validate_host,
+};
+use crate::{Result, session::Destination};
+use serde::Deserialize;
+use std::net::{IpAddr, SocketAddr};
+
+#[derive(Clone, PartialEq, Eq)]
+pub struct Hysteria2Realm {
+    pub server_url: String,
+    pub token: String,
+    pub realm_id: String,
+    pub stun_servers: Vec<Destination>,
+    pub tls: Option<TlsConfig>,
+}
+impl std::fmt::Debug for Hysteria2Realm {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Hysteria2Realm").finish_non_exhaustive()
+    }
+}
+#[derive(Default, Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "kebab-case")]
+pub(super) struct RawRealm {
+    #[serde(default)]
+    enable: bool,
+    #[serde(default)]
+    server_url: String,
+    #[serde(default)]
+    token: String,
+    #[serde(default)]
+    realm_id: String,
+    #[serde(default)]
+    stun_servers: Vec<String>,
+    #[serde(default, deserialize_with = "deserialize_present_option")]
+    sni: Option<String>,
+    #[serde(default)]
+    skip_cert_verify: bool,
+    #[serde(default, deserialize_with = "deserialize_present_option")]
+    name_cert_verify: Option<String>,
+    #[serde(default, deserialize_with = "deserialize_present_option")]
+    fingerprint: Option<String>,
+    #[serde(default, deserialize_with = "deserialize_present_option")]
+    certificate: Option<String>,
+    #[serde(default, deserialize_with = "deserialize_present_option")]
+    private_key: Option<String>,
+    #[serde(default, deserialize_with = "deserialize_present_option")]
+    alpn: Option<Vec<String>>,
+}
+fn bad() -> crate::VoleError {
+    crate::VoleError::InvalidConfig("invalid Hysteria2 Realm endpoint".into())
+}
+fn stun(value: &str) -> Result<Destination> {
+    if let Ok(address) = value.parse::<SocketAddr>() {
+        if address.port() == 0 {
+            return Err(bad());
+        }
+        return Ok(Destination::Ip(address));
+    }
+    if let Ok(ip) = value.parse::<IpAddr>() {
+        return Ok(Destination::Ip(SocketAddr::new(ip, 3478)));
+    }
+    let (host, port) = value
+        .rsplit_once(':')
+        .map_or(Ok((value, 3478)), |(host, port)| {
+            port.parse::<u16>()
+                .map(|port| (host, port))
+                .map_err(|_| bad())
+        })?;
+    validate_host(host, "Hysteria2 Realm STUN host")?;
+    if port == 0 {
+        return Err(bad());
+    }
+    Destination::domain(host, port).map_err(|_| bad())
+}
+impl RawRealm {
+    pub(super) fn normalize(self) -> Result<Option<Hysteria2Realm>> {
+        if !self.enable {
+            return Ok(None);
+        }
+        let url = url::Url::parse(&self.server_url).map_err(|_| bad())?;
+        if !matches!(url.scheme(), "http" | "https")
+            || url.host_str().is_none()
+            || !url.username().is_empty()
+            || url.password().is_some()
+            || url.query().is_some()
+            || url.fragment().is_some()
+            || self.server_url.len() > 8192
+            || self.realm_id.is_empty()
+            || matches!(self.realm_id.as_str(), "." | "..")
+            || self.realm_id.len() > 1024
+            || self.realm_id.contains('\0')
+            || self.stun_servers.is_empty()
+            || self.stun_servers.len() > 16
+            || self.token.len() > 8192
+            || http::HeaderValue::from_str(&format!("Bearer {}", self.token)).is_err()
+        {
+            return Err(bad());
+        }
+        let stun_servers = self
+            .stun_servers
+            .iter()
+            .map(|server| stun(server))
+            .collect::<Result<Vec<_>>>()?;
+        let tls = if url.scheme() == "https" {
+            let name = self
+                .sni
+                .filter(|name| !name.is_empty())
+                .unwrap_or_else(|| url.host_str().unwrap().trim_matches(['[', ']']).to_owned());
+            validate_host(&name, "Hysteria2 Realm sni")?;
+            let alpn = self
+                .alpn
+                .unwrap_or_else(|| vec!["h2".into(), "http/1.1".into()]);
+            if alpn.iter().any(|name| name.is_empty() || name.len() > 255)
+                || alpn.iter().map(|name| name.len() + 1).sum::<usize>() > 65533
+            {
+                return invalid("invalid Hysteria2 Realm ALPN");
+            }
+            Some(TlsConfig {
+                server_name: name,
+                alpn: alpn.into_iter().map(String::into_bytes).collect(),
+                tls13_only: false,
+                required_alpn: None,
+                ech: None,
+                client_fingerprint: None,
+                certificate: TlsCertificatePolicy {
+                    skip_cert_verify: self.skip_cert_verify,
+                    verification_name: normalize_verification_name(self.name_cert_verify)?,
+                    fingerprint: normalize_certificate_fingerprint(self.fingerprint.as_deref())?,
+                },
+                identity: normalize_client_identity(self.certificate, self.private_key)?,
+            })
+        } else {
+            if self.sni.is_some()
+                || self.skip_cert_verify
+                || self.name_cert_verify.is_some()
+                || self.fingerprint.is_some()
+                || self.certificate.is_some()
+                || self.private_key.is_some()
+                || self.alpn.is_some()
+            {
+                return invalid("Hysteria2 Realm TLS options require HTTPS");
+            }
+            None
+        };
+        Ok(Some(Hysteria2Realm {
+            server_url: url.as_str().trim_end_matches('/').to_owned(),
+            token: self.token,
+            realm_id: self.realm_id,
+            stun_servers,
+            tls,
+        }))
+    }
+}
+#[cfg(all(test, feature = "outbound-hysteria2"))]
+mod tests {
+    use super::*;
+    #[test]
+    fn realm_options_bind_control_tls_and_bounded_stun_endpoints() {
+        let raw:RawRealm=serde_json::from_value(serde_json::json!({"enable":true,"server-url":"https://control.example/base/","token":"private","realm-id":"zone","stun-servers":["192.0.2.1","[2001:db8::1]:3479","stun.example"],"name-cert-verify":"identity.example","sni":"cover.example"})).unwrap();
+        let config = raw.normalize().unwrap().unwrap();
+        assert_eq!(config.stun_servers.len(), 3);
+        assert_eq!(config.server_url, "https://control.example/base");
+        assert_eq!(config.tls.as_ref().unwrap().server_name, "cover.example");
+        assert_eq!(
+            config
+                .tls
+                .as_ref()
+                .unwrap()
+                .certificate
+                .verification_name
+                .as_deref(),
+            Some("identity.example")
+        );
+        assert!(!format!("{config:?}").contains("private"));
+    }
+}
diff --git a/src/config/identity_files.rs b/src/config/identity_files.rs
new file mode 100644
index 0000000..a0e0b1e
--- /dev/null
+++ b/src/config/identity_files.rs
@@ -0,0 +1,448 @@
+use std::{
+    fs::{Metadata, OpenOptions},
+    io::Read,
+    path::{Path, PathBuf},
+    sync::Arc,
+    time::SystemTime,
+};
+
+use serde_yaml_ng::{Mapping, Value};
+
+use super::MAX_CONFIG_BYTES;
+use crate::{Result, VoleError};
+
+/// Resolve identities before normalization, keeping file I/O out of TLS clients.
+/// One resource generation has a shared, bounded file-content budget.
+pub(super) struct IdentityFiles<'a> {
+    directory: Option<&'a Path>,
+    remaining: usize,
+    origins: Vec<NodeOrigins>,
+}
+
+#[derive(Clone, PartialEq, Eq)]
+pub(crate) struct IdentityFileOrigin {
+    certificate: PathBuf,
+    private_key: PathBuf,
+    pub(crate) initial: PairStamp,
+}
+
+impl std::fmt::Debug for IdentityFileOrigin {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("IdentityFileOrigin").finish_non_exhaustive()
+    }
+}
+
+#[derive(Clone, Default, PartialEq, Eq)]
+pub(crate) struct PairStamp(FileStamp, FileStamp);
+
+impl PairStamp {
+    pub(crate) fn bytes(&self) -> usize {
+        (self.0.len as usize).saturating_add(self.1.len as usize)
+    }
+}
+
+#[derive(Clone, Default, PartialEq, Eq)]
+struct FileStamp {
+    len: u64,
+    modified: Option<SystemTime>,
+    created: Option<SystemTime>,
+    #[cfg(unix)]
+    device: u64,
+    #[cfg(unix)]
+    inode: u64,
+}
+
+impl FileStamp {
+    fn new(metadata: &Metadata) -> Result<Self> {
+        if !metadata.is_file() || metadata.len() > MAX_CONFIG_BYTES as u64 {
+            return Err(invalid_identity());
+        }
+        #[cfg(unix)]
+        use std::os::unix::fs::MetadataExt;
+        Ok(Self {
+            len: metadata.len(),
+            modified: metadata.modified().ok(),
+            created: metadata.created().ok(),
+            #[cfg(unix)]
+            device: metadata.dev(),
+            #[cfg(unix)]
+            inode: metadata.ino(),
+        })
+    }
+}
+
+impl IdentityFileOrigin {
+    pub(crate) fn stamp(&self) -> Result<PairStamp> {
+        Ok(PairStamp(
+            FileStamp::new(&std::fs::metadata(&self.certificate).map_err(|_| invalid_identity())?)?,
+            FileStamp::new(&std::fs::metadata(&self.private_key).map_err(|_| invalid_identity())?)?,
+        ))
+    }
+
+    pub(crate) fn read(&self, remaining: &mut usize) -> Result<(String, String, PairStamp)> {
+        // Open both members before reading either, and check both open handles
+        // and their current paths. A replacement cannot publish a torn pair.
+        let open = |path: &Path| {
+            let mut options = OpenOptions::new();
+            options.read(true);
+            #[cfg(unix)]
+            {
+                use std::os::unix::fs::OpenOptionsExt;
+                options.custom_flags(libc::O_NONBLOCK);
+            }
+            options.open(path).map_err(|_| invalid_identity())
+        };
+        let mut certificate = open(&self.certificate)?;
+        let mut private_key = open(&self.private_key)?;
+        let before = PairStamp(
+            FileStamp::new(&certificate.metadata().map_err(|_| invalid_identity())?)?,
+            FileStamp::new(&private_key.metadata().map_err(|_| invalid_identity())?)?,
+        );
+        let mut read = |file: &mut std::fs::File| -> Result<String> {
+            let mut content = String::new();
+            file.take(*remaining as u64 + 1)
+                .read_to_string(&mut content)
+                .map_err(|_| invalid_identity())?;
+            if content.len() > *remaining {
+                return Err(invalid_identity());
+            }
+            *remaining -= content.len();
+            Ok(content)
+        };
+        let certificate_pem = read(&mut certificate)?;
+        let private_key_pem = read(&mut private_key)?;
+        let after = PairStamp(
+            FileStamp::new(&certificate.metadata().map_err(|_| invalid_identity())?)?,
+            FileStamp::new(&private_key.metadata().map_err(|_| invalid_identity())?)?,
+        );
+        if before != after || self.stamp()? != after {
+            return Err(invalid_identity());
+        }
+        Ok((certificate_pem, private_key_pem, after))
+    }
+
+    pub(crate) fn same_files(&self, other: &Self) -> bool {
+        self.certificate == other.certificate && self.private_key == other.private_key
+    }
+}
+
+#[derive(Default)]
+struct NodeOrigins {
+    primary: Option<Arc<IdentityFileOrigin>>,
+    realm: Option<Arc<IdentityFileOrigin>>,
+    download: Option<Arc<IdentityFileOrigin>>,
+    download_inherits: bool,
+}
+
+impl<'a> IdentityFiles<'a> {
+    pub(super) fn new(directory: Option<&'a Path>) -> Self {
+        Self {
+            directory,
+            remaining: MAX_CONFIG_BYTES,
+            origins: Vec::new(),
+        }
+    }
+
+    pub(super) fn inline_node(&mut self, node: &mut Value) -> Result<()> {
+        self.origins.push(NodeOrigins::default());
+        let index = self.origins.len() - 1;
+        let Some(map) = node.as_mapping_mut() else {
+            return Ok(()); // The strict node parser reports the invalid shape.
+        };
+        if map.get("type").and_then(Value::as_str) == Some("ss")
+            && matches!(
+                map.get("plugin").and_then(Value::as_str),
+                Some("shadow-tls" | "v2ray-plugin" | "gost-plugin")
+            )
+        {
+            if let Some(options) = map.get_mut("plugin-opts").and_then(Value::as_mapping_mut) {
+                self.origins[index].primary = self.inline_pair(options)?;
+            }
+            return Ok(());
+        }
+        if !matches!(
+            map.get("type").and_then(Value::as_str),
+            Some(
+                "http"
+                    | "socks5"
+                    | "anytls"
+                    | "trojan"
+                    | "vmess"
+                    | "vless"
+                    | "hysteria2"
+                    | "tuic"
+                    | "trusttunnel"
+            )
+        ) {
+            return Ok(());
+        }
+        self.origins[index].primary = self.inline_pair(map)?;
+        if map.get("type").and_then(Value::as_str) == Some("hysteria2")
+            && let Some(realm) = map.get_mut("realm-opts").and_then(Value::as_mapping_mut)
+            && realm.get("enable").and_then(Value::as_bool) == Some(true)
+        {
+            self.origins[index].realm = self.inline_pair(realm)?;
+        }
+        if let Some(download) = map
+            .get_mut("xhttp-opts")
+            .and_then(Value::as_mapping_mut)
+            .and_then(|xhttp| xhttp.get_mut("download-settings"))
+            .and_then(Value::as_mapping_mut)
+        {
+            self.origins[index].download_inherits =
+                !download.contains_key("certificate") && !download.contains_key("private-key");
+            self.origins[index].download = self.inline_pair(download)?;
+        }
+        Ok(())
+    }
+
+    fn inline_pair(&mut self, map: &mut Mapping) -> Result<Option<Arc<IdentityFileOrigin>>> {
+        let (Some(certificate), Some(private_key)) = (
+            map.get("certificate").and_then(Value::as_str),
+            map.get("private-key").and_then(Value::as_str),
+        ) else {
+            return Ok(None); // Pair presence and types remain strict-schema checks.
+        };
+        if certificate.is_empty() || private_key.is_empty() {
+            return Ok(None);
+        }
+        if crate::security::TlsClientIdentity::from_pem(certificate, private_key).is_ok() {
+            return Ok(None);
+        }
+        let resolve = |value: &str| -> Result<PathBuf> {
+            let path = Path::new(value);
+            let path = self
+                .directory
+                .filter(|_| path.is_relative())
+                .map_or_else(|| path.to_path_buf(), |directory| directory.join(path));
+            if path.is_absolute() {
+                Ok(path)
+            } else {
+                Ok(std::env::current_dir()
+                    .map_err(|_| invalid_identity())?
+                    .join(path))
+            }
+        };
+        let mut origin = IdentityFileOrigin {
+            certificate: resolve(certificate)?,
+            private_key: resolve(private_key)?,
+            initial: PairStamp::default(),
+        };
+        let (certificate, private_key, stamp) = origin.read(&mut self.remaining)?;
+        origin.initial = stamp;
+        crate::security::TlsClientIdentity::from_pem(&certificate, &private_key)
+            .map_err(|_| invalid_identity())?;
+        map.insert("certificate".into(), certificate.into());
+        map.insert("private-key".into(), private_key.into());
+        Ok(Some(Arc::new(origin)))
+    }
+
+    pub(super) fn attach(self, proxies: &mut [super::ProxyConfig]) {
+        use super::{ProxyProtocol as P, SecurityConfig as S, ShadowsocksPlugin as Plugin};
+        fn security(config: &mut S) -> &mut Option<super::TlsIdentityPem> {
+            match config {
+                S::Tls(tls) => &mut tls.identity,
+                S::ShadowTls(tls) => &mut tls.identity,
+                S::Jls(jls) => &mut jls.tls.identity,
+                // Neither mode can contain an mTLS identity.
+                S::None | S::Reality(_) => unreachable!("identity source without standard TLS"),
+            }
+        }
+        fn bind(
+            identity: &mut Option<super::TlsIdentityPem>,
+            origin: Option<Arc<IdentityFileOrigin>>,
+        ) {
+            if let (Some(identity), Some(origin)) = (identity, origin) {
+                identity.origin = Some(origin);
+            }
+        }
+        for (proxy, origins) in proxies.iter_mut().zip(self.origins) {
+            let primary = origins.primary;
+            if let P::Vless(vless) = &mut proxy.protocol {
+                if primary.is_some() {
+                    bind(security(&mut vless.security), primary.clone());
+                }
+                if let super::VlessTransport::Xhttp(xhttp) = &mut vless.transport
+                    && let Some(download) = &mut xhttp.download
+                {
+                    let origin = if origins.download_inherits {
+                        primary
+                    } else {
+                        origins.download
+                    };
+                    if origin.is_some() {
+                        bind(security(&mut download.security), origin);
+                    }
+                }
+                continue;
+            }
+            if let P::Hysteria2(hy2) = &mut proxy.protocol {
+                bind(&mut hy2.tls.identity, primary);
+                if let Some(tls) = hy2.realm.as_mut().and_then(|realm| realm.tls.as_mut()) {
+                    bind(&mut tls.identity, origins.realm);
+                }
+                continue;
+            }
+            if primary.is_none() {
+                continue;
+            }
+            match &mut proxy.protocol {
+                P::Http(node) => {
+                    if let Some(tls) = &mut node.tls {
+                        bind(&mut tls.identity, primary);
+                    }
+                }
+                P::Socks5(node) => {
+                    if let Some(tls) = &mut node.tls {
+                        bind(&mut tls.identity, primary);
+                    }
+                }
+                P::TrustTunnel(node) => bind(&mut node.tls.identity, primary),
+                P::Tuic(node) => bind(&mut node.tls.identity, primary),
+                P::Vmess(node) => bind(security(&mut node.security), primary),
+                P::Trojan(node) => bind(security(&mut node.security), primary),
+                P::AnyTls(node) => bind(security(&mut node.security), primary),
+                P::Shadowsocks(node) => match &mut node.plugin {
+                    Some(Plugin::ShadowTls(tls)) => bind(&mut tls.identity, primary),
+                    Some(Plugin::WebSocket { tls: Some(tls), .. }) => {
+                        bind(&mut tls.identity, primary)
+                    }
+                    _ => {}
+                },
+                _ => {}
+            }
+        }
+    }
+
+    #[cfg(test)]
+    fn read(&mut self, value: &str) -> Result<String> {
+        let path = Path::new(value);
+        let path = self
+            .directory
+            .filter(|_| path.is_relative())
+            .map_or_else(|| path.to_path_buf(), |directory| directory.join(path));
+        let mut options = OpenOptions::new();
+        options.read(true);
+        #[cfg(unix)]
+        {
+            use std::os::unix::fs::OpenOptionsExt;
+            options.custom_flags(libc::O_NONBLOCK);
+        }
+        let file = options.open(path).map_err(|_| invalid_identity())?;
+        if !file.metadata().map_err(|_| invalid_identity())?.is_file() {
+            return Err(invalid_identity());
+        }
+        let mut content = String::new();
+        file.take(self.remaining as u64 + 1)
+            .read_to_string(&mut content)
+            .map_err(|_| invalid_identity())?;
+        if content.len() > self.remaining {
+            return Err(invalid_identity());
+        }
+        self.remaining -= content.len();
+        Ok(content)
+    }
+}
+
+fn invalid_identity() -> VoleError {
+    VoleError::InvalidConfig("invalid TLS client identity file".into())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn file_budget_is_shared_and_rejects_non_regular_files() {
+        let directory = tempfile::tempdir().unwrap();
+        std::fs::write(directory.path().join("first"), "ab").unwrap();
+        std::fs::write(directory.path().join("second"), "cd").unwrap();
+        let mut files = IdentityFiles::new(Some(directory.path()));
+        files.remaining = 3;
+        assert_eq!(files.read("first").unwrap(), "ab");
+        assert!(files.read("second").is_err());
+        assert!(files.read(".").is_err());
+    }
+
+    #[test]
+    fn file_pair_metadata_and_reads_share_the_input_budget() {
+        let directory = tempfile::tempdir().unwrap();
+        let certificate = directory.path().join("certificate");
+        let private_key = directory.path().join("private-key");
+        std::fs::write(&certificate, "ab").unwrap();
+        std::fs::write(&private_key, "cd").unwrap();
+        let origin = IdentityFileOrigin {
+            certificate: certificate.clone(),
+            private_key,
+            initial: PairStamp::default(),
+        };
+        let mut remaining = 3;
+        assert!(origin.read(&mut remaining).is_err());
+        let mut remaining = 4;
+        let (cert, key, stamp) = origin.read(&mut remaining).unwrap();
+        assert_eq!((cert.as_str(), key.as_str(), remaining), ("ab", "cd", 0));
+        assert!(stamp == origin.stamp().unwrap());
+        assert_eq!(stamp.bytes(), 4);
+        // A sparse oversized file is rejected by metadata, before allocating
+        // or reading its content into an identity candidate.
+        OpenOptions::new()
+            .write(true)
+            .open(certificate)
+            .unwrap()
+            .set_len(MAX_CONFIG_BYTES as u64 + 1)
+            .unwrap();
+        assert!(origin.stamp().is_err());
+        let mut remaining = MAX_CONFIG_BYTES;
+        assert!(origin.read(&mut remaining).is_err());
+        assert_eq!(remaining, MAX_CONFIG_BYTES);
+    }
+}
+
+#[cfg(all(test, feature = "outbound-hysteria2"))]
+mod realm_tests {
+    use super::*;
+    #[test]
+    fn realm_identity_files_use_the_same_generation_budget_and_directory() {
+        use base64::Engine as _;
+        let identity = rcgen::generate_simple_self_signed(vec!["client.invalid".into()]).unwrap();
+        let pem = |label: &str, bytes: &[u8]| {
+            format!(
+                "-----BEGIN {label}-----\n{}\n-----END {label}-----\n",
+                base64::engine::general_purpose::STANDARD.encode(bytes)
+            )
+        };
+        let directory = tempfile::tempdir().unwrap();
+        std::fs::write(
+            directory.path().join("client.crt"),
+            pem("CERTIFICATE", identity.cert.der()),
+        )
+        .unwrap();
+        std::fs::write(
+            directory.path().join("client.key"),
+            pem("PRIVATE KEY", &identity.signing_key.serialize_der()),
+        )
+        .unwrap();
+        let input = serde_json::json!({"proxies":[{"type":"hysteria2","name":"edge","server":"peer.invalid","port":443,"password":"synthetic","realm-opts":{"enable":true,"server-url":"https://control.invalid","realm-id":"synthetic-zone","stun-servers":["192.0.2.1"],"certificate":"client.crt","private-key":"client.key"}}]});
+        let bytes = serde_json::to_vec(&input).unwrap();
+        let config =
+            super::super::Config::parse_yaml_with_directory(&bytes, Some(directory.path()))
+                .unwrap();
+        let super::super::ProxyProtocol::Hysteria2(node) = &config.proxies[0].protocol else {
+            panic!("HY2")
+        };
+        assert!(
+            node.realm
+                .as_ref()
+                .unwrap()
+                .tls
+                .as_ref()
+                .unwrap()
+                .identity
+                .is_some()
+        );
+        let mut source: Value = serde_yaml_ng::from_slice(&bytes).unwrap();
+        let mut files = IdentityFiles::new(Some(directory.path()));
+        files.remaining = 1;
+        assert!(files.inline_node(&mut source["proxies"][0]).is_err());
+    }
+}
diff --git a/src/config/ip4p.rs b/src/config/ip4p.rs
new file mode 100644
index 0000000..5344144
--- /dev/null
+++ b/src/config/ip4p.rs
@@ -0,0 +1,118 @@
+//! IP4P physical-endpoint representation used by Mihomo's resolver/dialer.
+use super::ConnectionSettings;
+use std::net::{Ipv4Addr, SocketAddr};
+
+impl ConnectionSettings {
+    /// Decode an explicitly enabled IP4P endpoint without allocation. Logical
+    /// host/port, TLS authentication and proxy-chain destinations stay separate.
+    /// This must not be applied to connectionless DIRECT business datagrams.
+    #[must_use]
+    pub fn convert_ip4p_endpoint(self, address: SocketAddr) -> SocketAddr {
+        if self.dialer_ip4p_convert
+            && let SocketAddr::V6(encoded) = address
+        {
+            let bytes = encoded.ip().octets();
+            if bytes[..4] == [0x20, 0x01, 0, 0] {
+                return SocketAddr::from((
+                    Ipv4Addr::new(bytes[12], bytes[13], bytes[14], bytes[15]),
+                    u16::from_be_bytes([bytes[10], bytes[11]]),
+                ));
+            }
+        }
+        address
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::config::Config;
+    #[test]
+    fn physical_quic_switches_are_session_scoped_strict_and_keep_mihomo_defaults() {
+        for yaml in [
+            "rules: ['MATCH,DIRECT']",
+            "experimental: {}\nrules: ['MATCH,DIRECT']",
+        ] {
+            let settings = Config::parse_yaml(yaml.as_bytes())
+                .unwrap()
+                .connections
+                .quic;
+            assert!(!settings.disable_gso);
+            assert!(settings.disable_ecn);
+        }
+        let settings = Config::parse_yaml(b"experimental: {quic-go-disable-gso: true, quic-go-disable-ecn: false}\nrules: ['MATCH,DIRECT']").unwrap().connections.quic;
+        assert!(settings.disable_gso);
+        assert!(!settings.disable_ecn);
+        for value in ["'true'", "null", "1"] {
+            for field in ["quic-go-disable-gso", "quic-go-disable-ecn"] {
+                assert!(
+                    Config::parse_yaml(
+                        format!("experimental: {{{field}: {value}}}\nrules: ['MATCH,DIRECT']")
+                            .as_bytes()
+                    )
+                    .is_err()
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn ip4p_exact_prefix_network_port_and_default_off() {
+        let policy = ConnectionSettings {
+            dialer_ip4p_convert: true,
+            ..Default::default()
+        };
+        let encoded: SocketAddr = "[2001:0:1234:5678:9abc:1bb:c000:201]:8443".parse().unwrap();
+        assert_eq!(
+            policy.convert_ip4p_endpoint(encoded),
+            "192.0.2.1:443".parse().unwrap()
+        );
+        assert_eq!(
+            ConnectionSettings::default().convert_ip4p_endpoint(encoded),
+            encoded
+        );
+        for (encoded, expected) in [
+            ("[2001:0::0:0]:443", "0.0.0.0:0"),
+            ("[2001:0::ffff:ffff:ffff]:9", "255.255.255.255:65535"),
+            ("[2001:0::1:7f00:1]:443", "127.0.0.1:1"),
+        ] {
+            assert_eq!(
+                policy.convert_ip4p_endpoint(encoded.parse().unwrap()),
+                expected.parse().unwrap()
+            );
+        }
+        for ordinary in [
+            "192.0.2.1:443",
+            "[2001:1::1]:443",
+            "[2000:0::1]:443",
+            "[::ffff:192.0.2.1]:443",
+            "[fe80::1%7]:443",
+        ] {
+            let ordinary: SocketAddr = ordinary.parse().unwrap();
+            assert_eq!(policy.convert_ip4p_endpoint(ordinary), ordinary);
+        }
+    }
+    #[test]
+    fn ip4p_configuration_is_strict_opt_in() {
+        assert!(
+            !Config::parse_yaml(b"rules: ['MATCH,DIRECT']")
+                .unwrap()
+                .connections
+                .dialer_ip4p_convert
+        );
+        assert!(
+            Config::parse_yaml(
+                b"experimental: {dialer-ip4p-convert: true}\nrules: ['MATCH,DIRECT']"
+            )
+            .unwrap()
+            .connections
+            .dialer_ip4p_convert
+        );
+        for input in [
+            "experimental: {dialer-ip4p-convert: 'true'}",
+            "experimental: {unknown: true}",
+        ] {
+            assert!(Config::parse_yaml(input.as_bytes()).is_err(), "{input}");
+        }
+    }
+}
diff --git a/src/config/ip_suffix.rs b/src/config/ip_suffix.rs
new file mode 100644
index 0000000..f188b52
--- /dev/null
+++ b/src/config/ip_suffix.rs
@@ -0,0 +1,71 @@
+//! Independent low-order bit matcher, retaining the unmasked payload address.
+use super::{Result, VoleError};
+use std::{net::IpAddr, sync::Arc};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct IpSuffix {
+    address: IpAddr,
+    bits: u8,
+    payload: Arc<str>,
+}
+impl IpSuffix {
+    pub fn parse(payload: &str) -> Result<Self> {
+        let invalid =
+            || VoleError::InvalidConfig("IP-SUFFIX requires an address and valid bit width".into());
+        let (address, bits) = payload.split_once('/').ok_or_else(invalid)?;
+        let address: IpAddr = address.parse().map_err(|_| invalid())?;
+        if bits.is_empty() || !bits.bytes().all(|b| b.is_ascii_digit()) {
+            return Err(invalid());
+        }
+        let bits: u8 = bits.parse().map_err(|_| invalid())?;
+        let maximum = if address.is_ipv4() { 32 } else { 128 };
+        if bits > maximum {
+            return Err(invalid());
+        }
+        Ok(Self {
+            address,
+            bits,
+            payload: Arc::from(payload),
+        })
+    }
+    pub fn as_str(&self) -> &str {
+        &self.payload
+    }
+    pub fn matches(&self, candidate: IpAddr) -> bool {
+        match (self.address, candidate) {
+            (IpAddr::V4(expected), IpAddr::V4(candidate)) => {
+                let mask = u32::MAX.checked_shr(32 - u32::from(self.bits)).unwrap_or(0);
+                u32::from(expected) & mask == u32::from(candidate) & mask
+            }
+            (IpAddr::V6(expected), IpAddr::V6(candidate)) => {
+                let mask = u128::MAX
+                    .checked_shr(128 - u32::from(self.bits))
+                    .unwrap_or(0);
+                u128::from(expected) & mask == u128::from(candidate) & mask
+            }
+            _ => false,
+        }
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn address_suffix_preserves_low_bits_and_address_family() {
+        for (payload, candidate) in [
+            ("192.0.2.19/5", "203.0.113.51"),
+            ("2001:db8::12ab/13", "fd01::32ab"),
+            ("192.0.2.19/0", "203.0.113.1"),
+            ("2001:db8::19/0", "::"),
+            ("192.0.2.19/32", "192.0.2.19"),
+            ("2001:db8::19/128", "2001:db8::19"),
+        ] {
+            let suffix = IpSuffix::parse(payload).unwrap();
+            assert_eq!(suffix.as_str(), payload);
+            assert!(suffix.matches(candidate.parse().unwrap()));
+        }
+        let suffix = IpSuffix::parse("192.0.2.19/5").unwrap();
+        assert!(!suffix.matches("203.0.113.52".parse().unwrap()));
+        assert!(!suffix.matches("::ffff:192.0.2.19".parse().unwrap()));
+    }
+}
diff --git a/src/config/ip_version.rs b/src/config/ip_version.rs
new file mode 100644
index 0000000..d852c59
--- /dev/null
+++ b/src/config/ip_version.rs
@@ -0,0 +1,71 @@
+use super::*;
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Deserialize)]
+#[serde(try_from = "String")]
+pub enum IpVersion {
+    #[default]
+    Dual,
+    Ipv4,
+    Ipv6,
+    Ipv4Prefer,
+    Ipv6Prefer,
+}
+impl TryFrom<String> for IpVersion {
+    type Error = &'static str;
+    fn try_from(value: String) -> std::result::Result<Self, Self::Error> {
+        match value.to_ascii_lowercase().as_str() {
+            "dual" => Ok(Self::Dual),
+            "ipv4" => Ok(Self::Ipv4),
+            "ipv6" => Ok(Self::Ipv6),
+            "ipv4-prefer" => Ok(Self::Ipv4Prefer),
+            "ipv6-prefer" => Ok(Self::Ipv6Prefer),
+            _ => Err("invalid ip-version"),
+        }
+    }
+}
+impl IpVersion {
+    pub fn permits(self, address: IpAddr) -> bool {
+        match self {
+            Self::Ipv4 => address.is_ipv4(),
+            Self::Ipv6 => address.is_ipv6(),
+            _ => true,
+        }
+    }
+    pub(crate) fn order(self, addresses: &mut Vec<SocketAddr>) {
+        addresses.retain(|address| self.permits(address.ip()));
+        match self {
+            Self::Ipv4Prefer => addresses.sort_by_key(|address| address.is_ipv6()),
+            Self::Ipv6Prefer => addresses.sort_by_key(|address| address.is_ipv4()),
+            _ => {}
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn node_policy_orders_and_filters_physical_candidates() {
+        let addresses: Vec<SocketAddr> =
+            ["[2001:db8::1]:443", "192.0.2.1:443", "[2001:db8::2]:443"]
+                .into_iter()
+                .map(|value| value.parse().unwrap())
+                .collect();
+        let preferred = crate::dialer::Dialer::default()
+            .with_ip_version(IpVersion::Ipv4Prefer)
+            .ordered_addresses(&addresses);
+        assert_eq!(preferred, vec![addresses[1], addresses[0], addresses[2]]);
+        assert_eq!(
+            crate::dialer::Dialer::default()
+                .with_ip_version(IpVersion::Ipv4)
+                .ordered_addresses(&addresses),
+            vec![addresses[1]]
+        );
+        assert!(
+            crate::dialer::Dialer::default()
+                .with_ipv6(false)
+                .with_ip_version(IpVersion::Ipv6)
+                .ordered_addresses(&addresses)
+                .is_empty()
+        );
+    }
+}
diff --git a/src/config/jls.rs b/src/config/jls.rs
index a1867bd..86c0d44 100644
--- a/src/config/jls.rs
+++ b/src/config/jls.rs
@@ -19,6 +19,7 @@ impl std::fmt::Debug for JlsConfig {
 
 impl JlsConfig {
     pub(crate) fn validate(&self) -> Result<()> {
+        validate_tls13_fingerprint(self.tls.client_fingerprint)?;
         for value in [&self.username, &self.password] {
             if value.is_empty() || value.len() > 65_535 {
                 return invalid("JLS credentials must each contain 1..65535 bytes");
diff --git a/src/config/live_update.rs b/src/config/live_update.rs
new file mode 100644
index 0000000..5ffd473
--- /dev/null
+++ b/src/config/live_update.rs
@@ -0,0 +1,105 @@
+//! Startup resources are owned by the host; a live candidate only replaces graphs.
+use super::{Config, providers::ProviderTemplate};
+use crate::{Result, VoleError, resource::config_apply::ConfigPatch};
+use serde_yaml_ng::{Mapping, Value};
+use std::{path::Path, sync::Arc};
+
+impl ProviderTemplate {
+    pub(crate) fn update_yaml(bytes: &[u8], directory: &Path) -> Result<Arc<Self>> {
+        let mut template = Self::extract(super::yaml::parse(bytes)?)?;
+        template.identity_directory = Some(directory.to_owned());
+        Ok(Arc::new(template))
+    }
+    pub(crate) fn patched(&self, patch: &ConfigPatch) -> Result<Arc<Self>> {
+        let mut next = self.clone();
+        let base = next
+            .base
+            .as_mapping_mut()
+            .ok_or_else(|| VoleError::InvalidConfig("invalid configuration candidate".into()))?;
+        for (key, value) in [
+            ("mode", patch.mode.as_deref()),
+            ("log-level", patch.log_level.as_deref()),
+            ("find-process-mode", patch.find_process_mode.as_deref()),
+            ("interface-name", patch.interface_name.as_deref()),
+        ] {
+            if let Some(value) = value {
+                base.insert(key.into(), Value::String(value.into()));
+            }
+        }
+        if let Some(value) = patch.tcp_concurrent {
+            base.insert("tcp-concurrent".into(), Value::Bool(value));
+        }
+        if let Some(value) = patch.sniffing {
+            let sniffer = base
+                .entry(Value::String("sniffer".into()))
+                .or_insert_with(|| Value::Mapping(Mapping::new()))
+                .as_mapping_mut()
+                .ok_or_else(|| {
+                    VoleError::InvalidConfig("invalid configuration candidate".into())
+                })?;
+            sniffer.insert("enable".into(), Value::Bool(value));
+        }
+        Ok(Arc::new(next))
+    }
+}
+
+pub(crate) fn startup_compatible(current: &Config, next: &Config) -> bool {
+    current.tls == next.tls
+        && current.ipv6 == next.ipv6
+        && current.external_controller == next.external_controller
+        && current.inbounds == next.inbounds
+        && current.mixed_port == next.mixed_port
+        && current.tun == next.tun
+        && current.profile == next.profile
+        && current.geodata_update == next.geodata_update
+        && current.dns.fake_ip.enabled == next.dns.fake_ip.enabled
+        && current.dns.fake_ip.range == next.dns.fake_ip.range
+        && current.dns.fake_ip.range6 == next.dns.fake_ip.range6
+        && (!current.dns.fake_ip.enabled || current.dns.ipv6 == next.dns.ipv6)
+        && (!(current.tun.enable && current.tun.file_descriptor == 0 && current.tun.auto_route)
+            || current.egress == next.egress)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::config::{FindProcessMode, Mode, providers::ProviderContents};
+    #[test]
+    fn patch_keeps_provider_identity_and_maps_the_actual_api_sniffing_field() {
+        let config=Config::parse_yaml(b"sniffer: {enable: true, sniff: {TLS: {ports: [443]}}}\nproxy-providers: {fixture: {type: inline, payload: [{name: edge, type: direct}]}}\nproxy-groups: [{name: chosen, type: select, use: [fixture]}]\nrules: ['MATCH,chosen']\n").unwrap();
+        let template = config.providers.unwrap();
+        let next = template
+            .patched(&ConfigPatch {
+                mode: Some("direct".into()),
+                log_level: Some("warning".into()),
+                sniffing: Some(false),
+                tcp_concurrent: Some(true),
+                find_process_mode: Some("off".into()),
+                interface_name: Some("eth0".into()),
+            })
+            .unwrap();
+        assert_eq!(next.proxies, template.proxies);
+        assert!(next.base.get("sniffing").is_none());
+        let next = next.materialize(&ProviderContents::new()).unwrap();
+        assert_eq!(next.mode, Mode::Direct);
+        assert!(!next.sniffer.enable);
+        assert!(next.connections.tcp_concurrent);
+        assert_eq!(next.find_process_mode, FindProcessMode::Off);
+    }
+    #[test]
+    fn live_candidates_reject_startup_resource_changes_but_allow_new_routes() {
+        let config = Config::parse_yaml(b"ipv6: false\nrules: ['MATCH,DIRECT']\n").unwrap();
+        for yaml in [
+            b"ipv6: true\nrules: ['MATCH,DIRECT']\n".as_slice(),
+            b"ipv6: false\nmixed-port: 1080\nrules: ['MATCH,DIRECT']\n",
+            b"ipv6: false\nexternal-controller: 127.0.0.1:9090\nrules: ['MATCH,DIRECT']\n",
+            b"ipv6: false\ndns: {enhanced-mode: fake-ip}\nrules: ['MATCH,DIRECT']\n",
+        ] {
+            let next = Config::parse_yaml(yaml).unwrap();
+            assert!(!startup_compatible(&config, &next));
+        }
+        let next = Config::parse_yaml(b"ipv6: false\nrules: ['MATCH,REJECT']\nlog-level: debug\n")
+            .unwrap();
+        assert!(startup_compatible(&config, &next));
+    }
+}
diff --git a/src/config/masque.rs b/src/config/masque.rs
new file mode 100644
index 0000000..103b9a6
--- /dev/null
+++ b/src/config/masque.rs
@@ -0,0 +1,464 @@
+//! MASQUE's mode-specific Mihomo fields and dedicated ECDSA key policy.
+use super::{
+    DnsNameserver, ProxyProtocol, deserialize_present_option, invalid, validate_host, validate_port,
+};
+use crate::Result;
+use serde::Deserialize;
+
+const CONNECT_URI: &str = "https://cloudflareaccess.com";
+const CONNECT_SNI: &str = "consumer-masque.cloudflareclient.com";
+const L4_CONNECT_SNI: &str = "consumer-masque-proxy.cloudflareclient.com";
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum MasqueNetwork {
+    Quic,
+    H2,
+    H3L4Proxy,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct MasqueIpStackOptions {
+    pub mode: String,
+    pub congestion_controller: String,
+}
+
+#[derive(Clone, PartialEq, Eq)]
+pub struct MasqueOutboundConfig {
+    pub address: String,
+    pub port: u16,
+    pub private_key: String,
+    pub public_key: String,
+    pub server_name: String,
+    pub network: MasqueNetwork,
+    pub ip: String,
+    pub ipv6: String,
+    pub uri: String,
+    pub mtu: i64,
+    pub udp: bool,
+    pub handshake_timeout: i64,
+    pub skip_cert_verify: bool,
+    pub name_cert_verify: String,
+    pub congestion_controller: String,
+    pub ip_stack: MasqueIpStackOptions,
+    pub remote_dns_resolve: bool,
+    pub dns: Vec<DnsNameserver>,
+    pub local_prefixes: [Option<(std::net::IpAddr, u8)>; 2],
+}
+
+impl std::fmt::Debug for MasqueOutboundConfig {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter
+            .debug_struct("MasqueOutboundConfig")
+            .field("network", &self.network)
+            .field("udp", &self.udp)
+            .finish_non_exhaustive()
+    }
+}
+
+#[derive(Default, Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "kebab-case")]
+struct RawIpStack {
+    #[serde(default)]
+    mode: String,
+    #[serde(default)]
+    congestion_controller: String,
+}
+
+impl RawIpStack {
+    fn normalize(self) -> Result<MasqueIpStackOptions> {
+        let mode = self.mode.to_lowercase();
+        let mode = if mode.is_empty() { "auto".into() } else { mode };
+        let congestion_controller = self.congestion_controller.to_lowercase();
+        if mode != "auto" {
+            return invalid("MASQUE IP stack mode is not supported");
+        }
+        if !matches!(congestion_controller.as_str(), "" | "cubic") {
+            return invalid("MASQUE IP stack congestion controller is not supported");
+        }
+        Ok(MasqueIpStackOptions {
+            mode,
+            congestion_controller,
+        })
+    }
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "kebab-case")]
+pub(super) struct RawMasque {
+    name: String,
+    server: String,
+    port: u16,
+    private_key: String,
+    public_key: String,
+    #[serde(default)]
+    ip: String,
+    #[serde(default)]
+    ipv6: String,
+    #[serde(default)]
+    uri: String,
+    #[serde(default)]
+    sni: String,
+    #[serde(default)]
+    mtu: i64,
+    #[serde(default)]
+    udp: bool,
+    #[serde(default)]
+    handshake_timeout: i64,
+    #[serde(default)]
+    skip_cert_verify: bool,
+    #[serde(default)]
+    name_cert_verify: String,
+    #[serde(default)]
+    network: String,
+    #[serde(default)]
+    congestion_controller: String,
+    #[serde(default)]
+    ip_stack: RawIpStack,
+    #[serde(default)]
+    remote_dns_resolve: bool,
+    #[serde(default)]
+    dns: Vec<String>,
+    #[serde(default, deserialize_with = "deserialize_present_option")]
+    dialer_proxy: Option<String>,
+}
+
+impl std::fmt::Debug for RawMasque {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter.debug_struct("RawMasque").finish_non_exhaustive()
+    }
+}
+
+pub(super) fn deserialize<'de, D: serde::Deserializer<'de>>(
+    deserializer: D,
+) -> std::result::Result<RawMasque, D::Error> {
+    RawMasque::deserialize(deserializer)
+        .map_err(|_| serde::de::Error::custom("invalid MASQUE configuration fields"))
+}
+
+impl RawMasque {
+    pub(super) fn normalize(self) -> Result<(String, Option<String>, bool, ProxyProtocol)> {
+        if !cfg!(feature = "outbound-masque") {
+            return invalid("MASQUE outbound support is disabled at build time");
+        }
+        validate_host(&self.server, "MASQUE server")?;
+        validate_port(self.port, "MASQUE")?;
+        if self.handshake_timeout < 0 {
+            return invalid("MASQUE handshake timeout must be non-negative");
+        }
+        // The reference validates this object even when L4 does not create an
+        // IP stack. Unsupported stacks are not aliases for Vole's stack.
+        let ip_stack = self.ip_stack.normalize()?;
+        #[cfg(feature = "outbound-masque")]
+        crate::security::masque::validate_keys(&self.private_key, &self.public_key)
+            .map_err(|_| crate::VoleError::InvalidConfig("invalid MASQUE ECDSA keys".into()))?;
+        let network = match self.network.as_str() {
+            "h2" => MasqueNetwork::H2,
+            "h3-l4proxy" => MasqueNetwork::H3L4Proxy,
+            _ => MasqueNetwork::Quic,
+        };
+        let dns = if self.remote_dns_resolve && !self.dns.is_empty() {
+            self.dns
+                .iter()
+                .map(|nameserver| super::dns::parse_node_dns_nameserver(nameserver))
+                .collect::<Result<Vec<_>>>()?
+        } else {
+            Vec::new()
+        };
+        let server_name = if self.sni.is_empty() {
+            match network {
+                MasqueNetwork::H3L4Proxy => L4_CONNECT_SNI,
+                MasqueNetwork::Quic | MasqueNetwork::H2 => CONNECT_SNI,
+            }
+            .into()
+        } else {
+            self.sni
+        };
+        validate_host(&server_name, "MASQUE sni")?;
+        let mtu = if self.mtu == 0 { 1280 } else { self.mtu };
+        let uri = if self.uri.is_empty() {
+            CONNECT_URI.into()
+        } else {
+            self.uri
+        };
+        let mut local_prefixes = [None; 2];
+        if network != MasqueNetwork::H3L4Proxy {
+            for (index, (value, default_bits)) in
+                [(&self.ip, 32), (&self.ipv6, 128)].into_iter().enumerate()
+            {
+                if !value.is_empty() {
+                    let (address, bits) = value
+                        .rsplit_once('/')
+                        .map_or((value.as_str(), None), |(address, bits)| {
+                            (address, Some(bits))
+                        });
+                    let address = address.parse::<std::net::IpAddr>().map_err(|_| {
+                        crate::VoleError::InvalidConfig("invalid MASQUE local address".into())
+                    })?;
+                    let bits = match bits {
+                        Some(bits) => bits.parse::<u8>().map_err(|_| {
+                            crate::VoleError::InvalidConfig("invalid MASQUE address prefix".into())
+                        })?,
+                        None => default_bits,
+                    };
+                    if bits > if address.is_ipv4() { 32 } else { 128 } {
+                        return invalid("invalid MASQUE address prefix");
+                    }
+                    local_prefixes[index] = Some((address, bits));
+                }
+            }
+            let mtu = usize::try_from(mtu)
+                .map_err(|_| crate::VoleError::InvalidConfig("invalid MASQUE MTU".into()))?;
+            #[cfg(feature = "outbound-masque")]
+            {
+                let client = vole_netstack::ClientConfig {
+                    prefixes: local_prefixes.map(|prefix| {
+                        prefix.map(|(address, prefix_len)| vole_netstack::ClientPrefix {
+                            address,
+                            prefix_len,
+                        })
+                    }),
+                    receive_packet_limit: vole_netstack::MAX_RECEIVE_PACKET_SIZE,
+                    path_mtu_discovery: true,
+                }
+                .validate(mtu)
+                .map_err(|_| {
+                    crate::VoleError::InvalidConfig("invalid MASQUE client addresses or MTU".into())
+                })?;
+                local_prefixes = client
+                    .prefixes
+                    .map(|prefix| prefix.map(|prefix| (prefix.address, prefix.prefix_len)));
+            }
+            if uri.contains(['{', '}'])
+                || url::Url::parse(&uri)
+                    .ok()
+                    .is_none_or(|url| url.host_str().is_none())
+            {
+                return invalid("invalid MASQUE CONNECT-IP URI");
+            }
+        }
+        // L4 never parses the local addresses or URI and never applies MTU
+        // or a positive handshake timeout. Retain their signed/raw values.
+        let udp = self.udp && network != MasqueNetwork::H3L4Proxy;
+        Ok((
+            self.name,
+            self.dialer_proxy,
+            udp,
+            ProxyProtocol::Masque(MasqueOutboundConfig {
+                address: self.server,
+                port: self.port,
+                private_key: self.private_key,
+                public_key: self.public_key,
+                server_name,
+                network,
+                ip: self.ip,
+                ipv6: self.ipv6,
+                uri,
+                mtu,
+                udp,
+                handshake_timeout: self.handshake_timeout,
+                skip_cert_verify: self.skip_cert_verify,
+                name_cert_verify: self.name_cert_verify,
+                congestion_controller: self.congestion_controller,
+                ip_stack,
+                remote_dns_resolve: self.remote_dns_resolve,
+                dns,
+                local_prefixes,
+            }),
+        ))
+    }
+}
+
+#[cfg(all(test, feature = "outbound-masque"))]
+mod tests {
+    use super::*;
+    use crate::config::Config;
+    use base64::{Engine as _, engine::general_purpose::STANDARD};
+    use boring::{
+        ec::{EcGroup, EcKey},
+        nid::Nid,
+        pkey::PKey,
+    };
+    use serde_json::{Value, json};
+
+    fn node() -> Value {
+        let key =
+            EcKey::generate(&EcGroup::from_curve_name(Nid::X9_62_PRIME256V1).unwrap()).unwrap();
+        let private = STANDARD.encode(key.private_key_to_der().unwrap());
+        let public = STANDARD.encode(PKey::from_ec_key(key).unwrap().public_key_to_der().unwrap());
+        json!({
+            "name": "edge", "type": "masque", "server": "cover.invalid", "port": 443,
+            "private-key": private, "public-key": public, "network": "h3-l4proxy"
+        })
+    }
+
+    fn parse(node: Value) -> Result<Config> {
+        Config::parse_yaml(&serde_json::to_vec(&json!({"proxies": [node]})).unwrap())
+    }
+
+    fn options(config: &Config) -> &MasqueOutboundConfig {
+        let ProxyProtocol::Masque(options) = &config.proxies[0].protocol else {
+            panic!("MASQUE node");
+        };
+        options
+    }
+
+    #[test]
+    fn masque_l4_normalization_keeps_noop_fields_and_disables_business_udp() {
+        let config = parse(node()).unwrap();
+        assert_eq!(options(&config).server_name, L4_CONNECT_SNI);
+        assert_eq!(options(&config).uri, CONNECT_URI);
+        assert_eq!(options(&config).mtu, 1280);
+        let mut raw = node();
+        for (key, value) in [
+            ("ip", json!("not an IP")),
+            ("ipv6", json!("also not an IP")),
+            ("uri", json!("not a URI")),
+            ("mtu", json!(-1)),
+            ("udp", json!(true)),
+            ("handshake-timeout", json!(12)),
+            ("name-cert-verify", json!("not a hostname")),
+            ("congestion-controller", json!("unknown-default")),
+            ("dns", json!(["not a nameserver"])),
+            (
+                "ip-stack",
+                json!({"mode": "AUTO", "congestion-controller": "CUBIC"}),
+            ),
+        ] {
+            raw[key] = value;
+        }
+        let config = parse(raw).unwrap();
+        let options = options(&config);
+        assert!(!config.proxies[0].udp && !options.udp);
+        assert_eq!(options.ip, "not an IP");
+        assert_eq!(options.uri, "not a URI");
+        assert_eq!(options.mtu, -1);
+        assert_eq!(options.handshake_timeout, 12);
+        assert_eq!(options.name_cert_verify, "not a hostname");
+        assert_eq!(options.ip_stack.mode, "auto");
+        assert_eq!(options.ip_stack.congestion_controller, "cubic");
+        let debug = format!("{:?}", config.proxies[0]);
+        assert!(!debug.contains(&options.private_key));
+        assert!(!debug.contains(&options.public_key));
+        assert!(!debug.contains(&options.address));
+    }
+
+    #[test]
+    fn removed_quic_tuning_fields_are_rejected_in_all_modes() {
+        for network in ["h2", "quic", "h3-l4proxy"] {
+            for (field, value) in [("cwnd", json!(16)), ("bbr-profile", json!("standard"))] {
+                let mut raw = node();
+                raw["network"] = json!(network);
+                raw["ip"] = json!("192.0.2.10");
+                raw[field] = value;
+                assert!(parse(raw).is_err());
+            }
+        }
+    }
+
+    #[test]
+    fn masque_ip_defaults_and_mode_consumers_are_explicit() {
+        for network in [None, Some(""), Some("quic"), Some("unknown")] {
+            let mut raw = node();
+            raw["ip"] = json!("192.0.2.10");
+            raw["udp"] = json!(true);
+            if let Some(network) = network {
+                raw["network"] = json!(network);
+            } else {
+                raw.as_object_mut().unwrap().remove("network");
+            }
+            let config = parse(raw).unwrap();
+            let options = options(&config);
+            assert_eq!(options.network, MasqueNetwork::Quic);
+            assert_eq!(options.mtu, 1280);
+            assert_eq!(options.server_name, CONNECT_SNI);
+            assert_eq!(
+                options.local_prefixes[0],
+                Some((std::net::IpAddr::from([192, 0, 2, 10]), 32))
+            );
+            assert!(options.udp && config.proxies[0].udp);
+        }
+        let mut raw = node();
+        raw["network"] = json!("h2");
+        raw["ip"] = json!("192.0.2.10");
+        assert_eq!(options(&parse(raw).unwrap()).network, MasqueNetwork::H2);
+        let mut raw = node();
+        raw["network"] = json!("quic");
+        raw["ip"] = json!("192.0.2.10/24");
+        raw["ipv6"] = json!("192.0.2.11/32");
+        raw["mtu"] = json!(68);
+        let config = parse(raw.clone()).unwrap();
+        assert_eq!(options(&config).local_prefixes.iter().flatten().count(), 2);
+        raw["ipv6"] = json!("2001:db8::1");
+        assert!(parse(raw.clone()).is_err());
+        raw["mtu"] = json!(1280);
+        assert!(parse(raw.clone()).is_ok());
+        raw["uri"] = json!("https://example.invalid/{target}");
+        assert!(parse(raw).is_err());
+        let mut raw = node();
+        raw["remote-dns-resolve"] = json!(true);
+        raw["dns"] = json!([]);
+        assert!(parse(raw.clone()).is_ok());
+        raw["dns"] = json!(["tcp://192.0.2.53"]);
+        assert_eq!(options(&parse(raw).unwrap()).dns.len(), 1);
+        for (field, value) in [
+            ("handshake-timeout", json!(-1)),
+            ("ip-stack", json!({"mode": "mips"})),
+            ("ip-stack", json!({"congestion-controller": "bbr3"})),
+            ("private-key", json!("invalid-private-key")),
+            ("certificate", json!("must not be a TLS identity field")),
+            ("client-fingerprint", json!("chrome")),
+            ("ip-stack", json!({"hidden-field": true})),
+        ] {
+            let mut raw = node();
+            raw[field] = value;
+            assert!(parse(raw).is_err());
+        }
+    }
+
+    #[test]
+    fn masque_node_dns_activation_preserves_wrappers_and_physical_sources() {
+        use crate::config::{DnsAddress, DnsRoute, DnsSource, DnsTransport};
+        let mut raw = node();
+        raw["dns"] = json!(["not a nameserver"]);
+        assert!(options(&parse(raw.clone()).unwrap()).dns.is_empty());
+        raw["remote-dns-resolve"] = json!(true);
+        assert!(parse(raw.clone()).is_err());
+        raw["dns"] = json!([
+            "tcp://192.0.2.53#unused-route&ecs=192.0.2.255/25&disable-ipv6=true",
+            "system#unused-route&disable-ipv4=true",
+            "dhcp://physical0"
+        ]);
+        let config = parse(raw).unwrap();
+        let dns = &options(&config).dns;
+        assert_eq!(dns.len(), 3);
+        assert!(
+            dns.iter()
+                .all(|nameserver| nameserver.route == DnsRoute::Direct)
+        );
+        assert_eq!(dns[0].transport, DnsTransport::Tcp);
+        assert!(dns[0].options.ecs.is_some());
+        assert!(dns[0].options.disabled_types.contains(&28));
+        assert!(matches!(
+            dns[1].address,
+            DnsAddress::Source(DnsSource::System)
+        ));
+        assert!(dns[1].options.disabled_types.contains(&1));
+        assert!(
+            matches!(&dns[2].address, DnsAddress::Source(DnsSource::Dhcp(interface)) if interface.as_ref() == "physical0")
+        );
+    }
+
+    #[test]
+    fn masque_provider_overrides_reach_the_dedicated_policy() {
+        let config = Config::parse_yaml(&serde_json::to_vec(&json!({
+            "proxy-providers": {"nodes": {
+                "type": "inline",
+                "override": {"skip-cert-verify": true, "name-cert-verify": "placeholder", "udp": true},
+                "payload": [node()]
+            }}
+        })).unwrap()).unwrap();
+        assert!(options(&config).skip_cert_verify);
+        assert_eq!(options(&config).name_cert_verify, "placeholder");
+        assert!(!config.proxies[0].udp);
+    }
+}
diff --git a/src/config/measure.rs b/src/config/measure.rs
index d47bd8b..b1dd532 100644
--- a/src/config/measure.rs
+++ b/src/config/measure.rs
@@ -1,20 +1,17 @@
 use serde::Deserialize;
-use serde_yaml_ng::Value as YamlValue;
 
 use crate::{Result, VoleError};
 
-use super::{
-    MAX_CONFIG_BYTES, ProxyConfig, ProxyId, RawOutbound, RouteTargetId, normalize_proxy_graph,
-    reject_yaml_anchors_and_aliases, validate_json_compatible_yaml,
-};
+use super::{ProxyConfig, ProxyId, RawOutbound, RouteTargetId, normalize_proxy_graph};
 
-/// Strict node-only configuration accepted by the built-in latency runner.
+/// Strict node graph and client trust accepted by the built-in latency runner.
 ///
 /// A measurement never owns an inbound, routing rules, DNS, sniffer state, or
 /// GeoData. Keeping a separate deserializer makes those fields unknown rather
 /// than silently ignoring runtime-only behavior.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) struct MeasureConfig {
+    pub(crate) tls: super::TlsTrustConfig,
     pub(crate) proxies: Vec<ProxyConfig>,
     pub(crate) default_proxy: ProxyId,
 }
@@ -22,23 +19,33 @@ pub(crate) struct MeasureConfig {
 #[derive(Debug, Deserialize)]
 #[serde(deny_unknown_fields)]
 struct RawMeasureConfig {
+    #[serde(
+        default,
+        deserialize_with = "super::tls_trust::deserialize_client_only"
+    )]
+    tls: super::TlsTrustConfig,
     proxies: Vec<RawOutbound>,
 }
 
 impl MeasureConfig {
     pub(crate) fn parse_yaml(input: &[u8]) -> Result<Self> {
-        if input.len() > MAX_CONFIG_BYTES {
-            return Err(VoleError::InvalidConfig(format!(
-                "configuration exceeds the {MAX_CONFIG_BYTES}-byte limit"
-            )));
-        }
-        let input = std::str::from_utf8(input)
-            .map_err(|_| VoleError::InvalidConfig("configuration is not UTF-8".to_owned()))?;
+        Self::parse_yaml_with_directory(input, None)
+    }
 
-        reject_yaml_anchors_and_aliases(input)?;
-        let yaml: YamlValue = serde_yaml_ng::from_str(input)
-            .map_err(|error| VoleError::InvalidConfig(error.to_string()))?;
-        validate_json_compatible_yaml(&yaml)?;
+    pub(crate) fn parse_yaml_with_directory(
+        input: &[u8],
+        directory: Option<&std::path::Path>,
+    ) -> Result<Self> {
+        let mut yaml = super::yaml::parse(input)?;
+        if let Some(nodes) = yaml
+            .get_mut("proxies")
+            .and_then(serde_yaml_ng::Value::as_sequence_mut)
+        {
+            let mut identities = super::identity_files::IdentityFiles::new(directory);
+            for node in nodes {
+                identities.inline_node(node)?;
+            }
+        }
         let raw: RawMeasureConfig = serde_yaml_ng::from_value(yaml)
             .map_err(|error| VoleError::InvalidConfig(error.to_string()))?;
         raw.normalize()
@@ -48,6 +55,14 @@ impl MeasureConfig {
 impl RawMeasureConfig {
     fn normalize(self) -> Result<MeasureConfig> {
         let (proxies, _) = normalize_proxy_graph(self.proxies)?;
+        if proxies
+            .iter()
+            .any(|node| matches!(&node.protocol, super::ProxyProtocol::Rematch(_)))
+        {
+            return Err(VoleError::InvalidConfig(
+                "measurement requires concrete proxy nodes, not rematch controls".into(),
+            ));
+        }
         let mut referenced_as_parent = vec![false; proxies.len()];
         for proxy in &proxies {
             if let Some(RouteTargetId::Proxy(parent)) = proxy.dialer_proxy {
@@ -93,6 +108,7 @@ impl RawMeasureConfig {
         }
 
         Ok(MeasureConfig {
+            tls: self.tls,
             proxies,
             default_proxy,
         })
@@ -102,16 +118,20 @@ impl RawMeasureConfig {
 #[cfg(test)]
 mod tests {
     #[test]
-    fn measurement_rejects_future_protocols_and_oversized_documents() {
-        let _case = crate::resources::case_events::Case::new(
-            "FOUNDATIONS-SCHEMA",
-            "measurement_rejects_future_protocols_and_oversized_documents",
+    fn measurement_rejects_routing_only_rematch_nodes() {
+        assert!(
+            super::MeasureConfig::parse_yaml(
+                b"proxies: [{name: mark, type: rematch, target-rematch-name: blue}]\n"
+            )
+            .is_err()
         );
-        let yaml =
-            b"proxies:\n  - name: node\n    type: wireguard\n    server: example.com\n    port: 443\n";
-        assert!(super::MeasureConfig::parse_yaml(yaml).is_err());
+    }
+
+    #[test]
+    fn measurement_rejects_oversized_documents() {
         assert!(
-            super::MeasureConfig::parse_yaml(&vec![b'x'; super::MAX_CONFIG_BYTES + 1]).is_err()
+            super::MeasureConfig::parse_yaml(&vec![b'x'; super::super::MAX_CONFIG_BYTES + 1])
+                .is_err()
         );
     }
 
@@ -179,6 +199,27 @@ proxies:
         }
     }
 
+    #[test]
+    fn measurement_accepts_client_trust_without_accepting_tls_server_settings() {
+        use base64::{Engine as _, engine::general_purpose::STANDARD};
+        let certificate = rcgen::generate_simple_self_signed(vec!["measure.example".into()])
+            .unwrap()
+            .cert;
+        let yaml = format!(
+            "tls:\n  custom-certifactes:\n    - |\n      -----BEGIN CERTIFICATE-----\n      {}\n      -----END CERTIFICATE-----\n{NODE}",
+            STANDARD.encode(certificate.der())
+        );
+        let config = MeasureConfig::parse_yaml(yaml.as_bytes()).unwrap();
+        assert_eq!(config.tls.certificates.len(), 1);
+        assert_eq!(config.proxies.len(), 1);
+        assert!(
+            MeasureConfig::parse_yaml(
+                format!("tls: {{ certificate: cert.pem }}\n{NODE}").as_bytes()
+            )
+            .is_err()
+        );
+    }
+
     #[test]
     fn reuses_proxy_graph_validation() {
         let chain = NODE.replace(
@@ -214,10 +255,10 @@ proxies:
     }
 
     #[test]
-    fn rejects_non_json_yaml() {
+    fn accepts_bounded_yaml_templates() {
         assert!(
             MeasureConfig::parse_yaml(NODE.replace("name: proxy", "name: &tag proxy").as_bytes())
-                .is_err()
+                .is_ok()
         );
     }
 
diff --git a/src/config/mieru.rs b/src/config/mieru.rs
new file mode 100644
index 0000000..67841bc
--- /dev/null
+++ b/src/config/mieru.rs
@@ -0,0 +1,248 @@
+//! Mieru's Mihomo fields; credentials and protocol settings never enter Debug.
+use super::{ProxyProtocol, deserialize_present_option, invalid, validate_host};
+use crate::Result;
+use serde::Deserialize;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum MieruTransport {
+    Tcp,
+    Udp,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum MieruMultiplexing {
+    Off,
+    Low,
+    Middle,
+    High,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum MieruHandshake {
+    Standard,
+    NoWait,
+}
+
+#[derive(Clone, PartialEq, Eq)]
+pub struct MieruOutboundConfig {
+    pub address: String,
+    /// Inclusive physical carrier port range; a single port has equal ends.
+    pub port: u16,
+    pub port_end: u16,
+    pub username: String,
+    pub password: String,
+    pub transport: MieruTransport,
+    pub udp: bool,
+    pub multiplexing: MieruMultiplexing,
+    pub handshake_mode: MieruHandshake,
+    pub traffic_pattern: Option<String>,
+}
+
+impl std::fmt::Debug for MieruOutboundConfig {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter
+            .debug_struct("MieruOutboundConfig")
+            .field("transport", &self.transport)
+            .field("udp", &self.udp)
+            .field("multiplexing", &self.multiplexing)
+            .field("handshake_mode", &self.handshake_mode)
+            .finish_non_exhaustive()
+    }
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "kebab-case")]
+pub(super) struct RawMieru {
+    name: String,
+    server: String,
+    #[serde(default)]
+    port: i64,
+    #[serde(default)]
+    port_range: String,
+    transport: String,
+    username: String,
+    password: String,
+    #[serde(default)]
+    udp: bool,
+    #[serde(default)]
+    multiplexing: String,
+    #[serde(default)]
+    handshake_mode: String,
+    #[serde(default)]
+    traffic_pattern: String,
+    #[serde(default, deserialize_with = "deserialize_present_option")]
+    dialer_proxy: Option<String>,
+}
+
+impl std::fmt::Debug for RawMieru {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter.debug_struct("RawMieru").finish_non_exhaustive()
+    }
+}
+
+pub(super) fn deserialize<'de, D: serde::Deserializer<'de>>(
+    deserializer: D,
+) -> std::result::Result<RawMieru, D::Error> {
+    RawMieru::deserialize(deserializer)
+        .map_err(|_| serde::de::Error::custom("invalid Mieru configuration fields"))
+}
+
+impl RawMieru {
+    pub(super) fn normalize(self) -> Result<(String, Option<String>, bool, ProxyProtocol)> {
+        if !cfg!(feature = "outbound-mieru") {
+            return invalid("Mieru outbound support is disabled at build time");
+        }
+        validate_host(&self.server, "Mieru server")?;
+        let (port, port_end) = match (self.port, self.port_range.is_empty()) {
+            (0, true) => return invalid("Mieru requires port or port-range"),
+            (0, false) => parse_port_range(&self.port_range)?,
+            (port, true) if (1..=65_535).contains(&port) => (port as u16, port as u16),
+            (_, true) => return invalid("invalid Mieru port"),
+            (_, false) => return invalid("Mieru port and port-range are mutually exclusive"),
+        };
+        if self.username.is_empty()
+            || self.password.is_empty()
+            || self.username.len() > 64
+            || self.password.len() > 64
+        {
+            return invalid("Mieru credentials require 1 to 64 UTF-8 bytes each");
+        }
+        let transport = match self.transport.as_str() {
+            "TCP" => MieruTransport::Tcp,
+            "UDP" => MieruTransport::Udp,
+            _ => return invalid("Mieru transport must be TCP or UDP"),
+        };
+        let multiplexing = match self.multiplexing.as_str() {
+            "" | "MULTIPLEXING_DEFAULT" | "MULTIPLEXING_LOW" => MieruMultiplexing::Low,
+            "MULTIPLEXING_OFF" => MieruMultiplexing::Off,
+            "MULTIPLEXING_MIDDLE" => MieruMultiplexing::Middle,
+            "MULTIPLEXING_HIGH" => MieruMultiplexing::High,
+            _ => return invalid("invalid Mieru multiplexing level"),
+        };
+        let handshake_mode = match self.handshake_mode.as_str() {
+            "" | "HANDSHAKE_DEFAULT" | "HANDSHAKE_STANDARD" => MieruHandshake::Standard,
+            "HANDSHAKE_NO_WAIT" => MieruHandshake::NoWait,
+            _ => return invalid("invalid Mieru handshake mode"),
+        };
+        #[cfg(feature = "outbound-mieru")]
+        crate::outbound::mieru::pattern::validate_raw(&self.traffic_pattern)?;
+        let traffic_pattern = (!self.traffic_pattern.is_empty()).then_some(self.traffic_pattern);
+        Ok((
+            self.name,
+            self.dialer_proxy,
+            self.udp,
+            ProxyProtocol::Mieru(MieruOutboundConfig {
+                address: self.server,
+                port,
+                port_end,
+                username: self.username,
+                password: self.password,
+                transport,
+                udp: self.udp,
+                multiplexing,
+                handshake_mode,
+                traffic_pattern,
+            }),
+        ))
+    }
+}
+
+fn parse_port_range(value: &str) -> Result<(u16, u16)> {
+    // The SDK's Store validates the whole range, after Mihomo's initial
+    // Sscanf check. Preserve that effective consumer rather than its precheck.
+    let parsed = value.split_once('-').and_then(|(start, end)| {
+        if start.is_empty()
+            || end.is_empty()
+            || !start.bytes().all(|byte| byte.is_ascii_digit())
+            || !end.bytes().all(|byte| byte.is_ascii_digit())
+        {
+            return None;
+        }
+        let start: u16 = start.parse().ok()?;
+        let end: u16 = end.parse().ok()?;
+        (start != 0 && start <= end).then_some((start, end))
+    });
+    match parsed {
+        Some(ports) => Ok(ports),
+        None => invalid("invalid Mieru port-range"),
+    }
+}
+
+#[cfg(all(test, feature = "outbound-mieru"))]
+mod tests {
+    use super::*;
+    use crate::config::Config;
+
+    fn parse(transport: &str, fields: &str) -> MieruOutboundConfig {
+        let yaml = format!(
+            "proxies:\n  - name: edge\n    type: mieru\n    server: edge.invalid\n    username: ' user '\n    password: ' password '\n    transport: {transport}\n{fields}"
+        );
+        let config = Config::parse_yaml(yaml.as_bytes()).unwrap();
+        let ProxyProtocol::Mieru(node) = &config.proxies[0].protocol else {
+            panic!("expected Mieru")
+        };
+        node.clone()
+    }
+
+    #[test]
+    fn defaults_preserve_credentials_and_tcp_carrier_udp_business() {
+        let node = parse("TCP", "    port: 443\n    udp: true\n");
+        assert_eq!((node.port, node.port_end), (443, 443));
+        assert_eq!(node.transport, MieruTransport::Tcp);
+        assert!(node.udp);
+        assert_eq!(node.multiplexing, MieruMultiplexing::Low);
+        assert_eq!(node.handshake_mode, MieruHandshake::Standard);
+        assert_eq!(node.username, " user ");
+        assert_eq!(node.password, " password ");
+        let debug = format!("{node:?}");
+        assert!(!debug.contains("password") && !debug.contains(" user "));
+    }
+
+    #[test]
+    fn range_equal_endpoints_and_explicit_default_enums_are_valid() {
+        let node = parse(
+            "TCP",
+            "    port-range: 443-443\n    multiplexing: MULTIPLEXING_DEFAULT\n    handshake-mode: HANDSHAKE_DEFAULT\n",
+        );
+        assert_eq!((node.port, node.port_end), (443, 443));
+        assert_eq!(node.multiplexing, MieruMultiplexing::Low);
+        assert_eq!(node.handshake_mode, MieruHandshake::Standard);
+    }
+
+    #[test]
+    fn port_range_and_no_wait_keep_their_effective_settings() {
+        let node = parse(
+            "TCP",
+            "    port: 0\n    port-range: 4000-4002\n    multiplexing: MULTIPLEXING_OFF\n    handshake-mode: HANDSHAKE_NO_WAIT\n",
+        );
+        assert_eq!((node.port, node.port_end), (4000, 4002));
+        assert_eq!(node.multiplexing, MieruMultiplexing::Off);
+        assert_eq!(node.handshake_mode, MieruHandshake::NoWait);
+    }
+
+    #[test]
+    fn udp_carrier_does_not_enable_udp_business_by_itself() {
+        let node = parse("UDP", "    port-range: 4000-4002\n");
+        assert_eq!(node.transport, MieruTransport::Udp);
+        assert!(!node.udp);
+        assert_eq!((node.port, node.port_end), (4000, 4002));
+    }
+
+    #[test]
+    fn traffic_pattern_is_validated_without_replacing_its_encoded_configuration() {
+        // Independent public protobuf fixture: seed 0, fixed nonce, zero
+        // padding, low-entropy mode 32, control fragmentation enabled.
+        let encoded = "CAAaBAgBEAAiEAgDEAEYACAAKgZhYWJiY2MqBAgAEAAyBAgBEAA=";
+        let node = parse(
+            "TCP",
+            &format!("    port: 443\n    traffic-pattern: '{encoded}'\n"),
+        );
+        assert_eq!(node.traffic_pattern.as_deref(), Some(encoded));
+        assert_eq!(
+            parse("TCP", "    port: 443\n    traffic-pattern: ''\n").traffic_pattern,
+            None
+        );
+        let yaml = "proxies:\n- name: edge\n  type: mieru\n  server: edge.invalid\n  port: 443\n  transport: TCP\n  username: user\n  password: password\n  traffic-pattern: 'not base64'\n";
+        assert!(Config::parse_yaml(yaml.as_bytes()).is_err());
+    }
+}
diff --git a/src/config/mihomo_udp_tests.rs b/src/config/mihomo_udp_tests.rs
new file mode 100644
index 0000000..418903d
--- /dev/null
+++ b/src/config/mihomo_udp_tests.rs
@@ -0,0 +1,105 @@
+//! Public YAML normalization only; these cases do not initialize a runtime.
+
+#[cfg(any(
+    feature = "outbound-vless",
+    feature = "outbound-hysteria2",
+    feature = "outbound-tuic",
+    feature = "outbound-socks5"
+))]
+fn proxy(protocol: &str, fields: &str) -> super::ProxyConfig {
+    let credentials = match protocol {
+        "vless" => "uuid: 00000000-0000-4000-8000-000000000001\n    tls: true",
+        "hysteria2" => "password: fixture",
+        "tuic" => "uuid: 00000000-0000-4000-8000-000000000001\n    password: fixture",
+        "socks5" => "",
+        _ => unreachable!(),
+    };
+    let fields: String = fields.lines().map(|line| format!("    {line}\n")).collect();
+    let yaml = format!(
+        "proxies:\n  - name: edge\n    type: {protocol}\n    server: proxy.invalid\n    port: 443\n    {credentials}\n{fields}rules: ['MATCH,edge']\n"
+    );
+    let mut config = super::Config::parse_yaml(yaml.as_bytes()).unwrap();
+    assert_eq!(config.proxies.len(), 1);
+    config.proxies.remove(0)
+}
+
+#[cfg(feature = "outbound-vless")]
+#[test]
+fn vless_none_packet_encoding_normalizes_to_xudp() {
+    let proxy = proxy("vless", "udp: true\npacket-encoding: none");
+    let super::ProxyProtocol::Vless(vless) = proxy.protocol else {
+        panic!("expected VLESS");
+    };
+    assert!(proxy.udp);
+    assert_eq!(vless.packet_encoding, super::VlessPacketEncoding::Xudp);
+}
+
+#[cfg(feature = "outbound-vless")]
+#[test]
+fn vless_none_packet_encoding_preserves_vision() {
+    for udp in [false, true] {
+        let proxy = proxy(
+            "vless",
+            &format!("udp: {udp}\nflow: xtls-rprx-vision\npacket-encoding: none"),
+        );
+        let super::ProxyProtocol::Vless(vless) = proxy.protocol else {
+            panic!("expected VLESS");
+        };
+        assert_eq!(proxy.udp, udp);
+        assert_eq!(vless.flow, "xtls-rprx-vision");
+        assert_eq!(vless.packet_encoding, super::VlessPacketEncoding::Xudp);
+    }
+}
+
+#[cfg(feature = "outbound-vless")]
+#[test]
+fn vless_existing_packet_encodings_keep_their_normalized_values() {
+    for (fields, expected) in [
+        ("", super::VlessPacketEncoding::Xudp),
+        ("packet-encoding: xudp", super::VlessPacketEncoding::Xudp),
+        (
+            "packet-encoding: packetaddr",
+            super::VlessPacketEncoding::PacketAddr,
+        ),
+        (
+            "packet-encoding: packet",
+            super::VlessPacketEncoding::PacketAddr,
+        ),
+    ] {
+        let proxy = proxy("vless", fields);
+        let super::ProxyProtocol::Vless(vless) = proxy.protocol else {
+            panic!("expected VLESS");
+        };
+        assert_eq!(vless.packet_encoding, expected, "{fields}");
+    }
+}
+
+#[cfg(feature = "outbound-hysteria2")]
+#[test]
+fn hysteria2_udp_capability_is_intrinsic() {
+    for fields in ["", "udp: false", "udp: true"] {
+        let proxy = proxy("hysteria2", fields);
+        assert!(matches!(proxy.protocol, super::ProxyProtocol::Hysteria2(_)));
+        assert!(proxy.udp, "Hysteria2 must support UDP with {fields:?}");
+    }
+}
+
+#[cfg(feature = "outbound-tuic")]
+#[test]
+fn tuic_udp_capability_is_intrinsic() {
+    for fields in ["", "udp: false", "udp: true"] {
+        let proxy = proxy("tuic", fields);
+        assert!(matches!(proxy.protocol, super::ProxyProtocol::Tuic(_)));
+        assert!(proxy.udp, "TUIC must support UDP with {fields:?}");
+    }
+}
+
+#[cfg(feature = "outbound-socks5")]
+#[test]
+fn socks5_udp_capability_keeps_its_explicit_opt_in() {
+    for (fields, expected) in [("", false), ("udp: false", false), ("udp: true", true)] {
+        let proxy = proxy("socks5", fields);
+        assert!(matches!(proxy.protocol, super::ProxyProtocol::Socks5(_)));
+        assert_eq!(proxy.udp, expected, "{fields}");
+    }
+}
diff --git a/src/config/mod.rs b/src/config/mod.rs
index b423ae9..990a2c4 100644
--- a/src/config/mod.rs
+++ b/src/config/mod.rs
@@ -1,4 +1,34 @@
 //! Strict parsing for the current Vole YAML configuration.
+mod anytls;
+mod fake_ip;
+mod tun_network;
+pub use tun_network::{TunAddress6, TunNetworkConfig};
+#[cfg(any(feature = "invoke", test))]
+pub(crate) mod live_update;
+pub use anytls::AnyTlsSessionOptions;
+mod fallback;
+mod grpc;
+mod sing_mux;
+mod sniffer;
+pub use fake_ip::{FakeIpConfig, FakeIpFilterMode, FakeIpRange};
+pub use fallback::DnsFallbackConfig;
+pub use grpc::GrpcOptions;
+pub use sing_mux::{SingMuxConfig, SingMuxProtocol};
+mod http_proxy;
+mod ip4p;
+mod ip_version;
+mod masque;
+mod mieru;
+mod trusttunnel;
+pub use http_proxy::HttpOutboundConfig;
+pub use ip_version::IpVersion;
+pub use masque::{MasqueIpStackOptions, MasqueNetwork, MasqueOutboundConfig};
+pub use mieru::{MieruHandshake, MieruMultiplexing, MieruOutboundConfig, MieruTransport};
+pub use trusttunnel::{TrustTunnelOutboundConfig, TrustTunnelPoolOptions};
+
+mod groups;
+pub(crate) use groups::status_ranges;
+pub use groups::{BalanceHashKey, BalanceStrategy, GroupKind, HealthCheckConfig, ProfileConfig};
 
 use std::{
     collections::{HashMap, VecDeque},
@@ -12,33 +42,84 @@ use serde::{
     Deserialize, Deserializer,
     de::{MapAccess, Visitor},
 };
-use serde_yaml_ng::Value as YamlValue;
 use url::{Host, Url};
 use uuid::Uuid;
 
 use crate::{Result, VoleError};
 
+mod dns;
+mod egress;
+pub use egress::EgressOptions;
+mod domain_regex;
+mod functional;
+pub use functional::RematchConfig;
+pub(crate) mod identity_files;
+mod ip_suffix;
+mod process;
+mod security;
+pub use process::{FindProcessMode, ProcessField, ProcessRule, UidRange};
+mod name_regex;
+mod override_expr;
+pub mod providers;
+mod rule_provider;
+pub(crate) mod rules;
+pub use domain_regex::{DomainRegex, MatchFailure, RuleDecision};
+pub use ip_suffix::IpSuffix;
+mod scalar;
+pub use rule_provider::RuleCollection;
+pub(crate) mod yaml;
+pub use rules::RuleInboundType;
+use rules::parse_rule;
+
 mod credentials;
-pub use credentials::{ProxyAccess, ProxyCredentials};
+pub use credentials::{ProxyAccess, ProxyAccessRules, ProxyCredentials};
+mod controller;
+pub use controller::{ControllerCors, ControllerTls};
+pub(crate) use controller::{
+    normalize_mark as normalize_controller_mark, normalize_unix as normalize_controller_unix,
+};
 mod ech;
 pub use ech::StaticEchConfig;
+mod quic;
+pub use quic::QuicReceiveWindow;
 mod hysteria2;
-pub use hysteria2::{Hysteria2Hopping, Hysteria2OutboundConfig};
+mod hysteria2_realm;
+pub use hysteria2::{Hysteria2Gecko, Hysteria2Hopping, Hysteria2OutboundConfig};
+pub use hysteria2_realm::Hysteria2Realm;
+mod wireguard;
+pub use wireguard::{WireGuardKey, WireGuardOutboundConfig, WireGuardPeerConfig};
 mod tuic;
 pub use tuic::{TuicCongestion, TuicOutboundConfig, TuicUdpMode};
 mod jls;
 pub use jls::JlsConfig;
+mod tls_trust;
+pub use tls_trust::TlsTrustConfig;
 mod shadowsocks;
+mod shadowsocks_plugin;
 pub use shadowsocks::{ShadowTlsConfig, ShadowsocksCipher, ShadowsocksOutboundConfig};
+pub use shadowsocks_plugin::ShadowsocksPlugin;
 mod trojan;
 pub use trojan::{TrojanOutboundConfig, TrojanTransport, WebSocketHandshake};
 mod vless;
-pub use vless::{GrpcOptions, SingMuxConfig, SingMuxProtocol, VlessStreamOptions};
+pub use vless::VlessStreamOptions;
 pub(crate) mod xhttp;
 pub use xhttp::{XHttpHeaders, XHttpRequestOptions, XHttpReuseConfig, XHttpVersion};
 mod vmess;
 pub use vmess::StreamTransport as VmessTransport;
 pub use vmess::{StreamTransport, VmessCipher, VmessOutboundConfig, VmessPacketEncoding};
+#[cfg(all(
+    test,
+    feature = "outbound-anytls",
+    feature = "outbound-trojan",
+    feature = "outbound-vmess",
+    feature = "outbound-socks5",
+    feature = "inbound-http",
+    feature = "inbound-socks5"
+))]
+mod tls_policy_tests;
+
+#[cfg(test)]
+mod mihomo_udp_tests;
 
 #[cfg(feature = "invoke")]
 mod measure;
@@ -46,23 +127,30 @@ mod measure;
 #[cfg(feature = "invoke")]
 pub(crate) use measure::MeasureConfig;
 
-pub const MAX_CONFIG_BYTES: usize = 256 * 1024;
-pub const MAX_RULES: usize = 1_024;
-pub const MAX_RULE_BYTES: usize = 1_024;
-pub const MAX_RULES_TOTAL_BYTES: usize = 128 * 1024;
-pub const MAX_DNS_NAMESERVERS: usize = 4;
+pub const MAX_CONFIG_BYTES: usize = 8 * 1024 * 1024;
+pub const MAX_RULES: usize = 65_536;
+pub const MAX_RULE_BYTES: usize = 16 * 1024;
+pub const MAX_RULES_TOTAL_BYTES: usize = MAX_CONFIG_BYTES;
 pub const MAX_SNIFFER_PORT_ITEMS: usize = 64;
 pub const MAX_GEOX_URL_BYTES: usize = 4_096;
-pub const MAX_CONTROLLER_SECRET_BYTES: usize = 255;
 pub const MAX_ANYTLS_PASSWORD_BYTES: usize = 1_024;
 pub const GEO_UPDATE_INTERVAL_HOURS: u64 = 24;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Config {
+    pub tls: TlsTrustConfig,
     pub ipv6: bool,
     pub proxies: Vec<ProxyConfig>,
     pub proxy_groups: Vec<SelectProxyGroupConfig>,
-    pub default_route_target: RouteTargetId,
+    pub mode: Mode,
+    pub log_level: LogLevel,
+    pub global_ua: String,
+    pub etag_support: bool,
+    pub unified_delay: bool,
+    pub connections: ConnectionSettings,
+    pub find_process_mode: FindProcessMode,
+    pub egress: EgressOptions,
+    pub profile: ProfileConfig,
     pub geodata_update: Option<GeoDataUpdateConfig>,
     pub external_controller: Option<ExternalControllerConfig>,
     pub inbounds: Vec<InboundConfig>,
@@ -71,12 +159,82 @@ pub struct Config {
     pub sniffer: SnifferConfig,
     pub dns: DnsConfig,
     pub rules: Vec<RuleSpec>,
+    pub sub_rules: Vec<NamedRuleProgram>,
+    pub provider_members: HashMap<String, Vec<String>>,
+    pub providers: Option<std::sync::Arc<providers::ProviderTemplate>>,
+}
+
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Deserialize)]
+#[serde(try_from = "String")]
+pub enum Mode {
+    #[default]
+    Rule,
+    Global,
+    Direct,
+}
+
+impl TryFrom<String> for Mode {
+    type Error = &'static str;
+    fn try_from(value: String) -> std::result::Result<Self, &'static str> {
+        match value.to_ascii_lowercase().as_str() {
+            "rule" => Ok(Self::Rule),
+            "global" => Ok(Self::Global),
+            "direct" => Ok(Self::Direct),
+            _ => Err("mode must be rule, global, or direct"),
+        }
+    }
+}
+
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Deserialize)]
+#[serde(try_from = "String")]
+pub enum LogLevel {
+    Silent,
+    Error,
+    Warning,
+    #[default]
+    Info,
+    Debug,
+}
+
+impl TryFrom<String> for LogLevel {
+    type Error = &'static str;
+    fn try_from(value: String) -> std::result::Result<Self, &'static str> {
+        match value.to_ascii_lowercase().as_str() {
+            "silent" => Ok(Self::Silent),
+            "error" => Ok(Self::Error),
+            "warning" => Ok(Self::Warning),
+            "info" => Ok(Self::Info),
+            "debug" => Ok(Self::Debug),
+            _ => Err("log-level must be silent, error, warning, info, or debug"),
+        }
+    }
 }
 
 #[derive(Clone, PartialEq, Eq)]
 pub struct ExternalControllerConfig {
     pub listen: SocketAddr,
     pub secret: Option<String>,
+    pub http_enabled: bool,
+    pub tls_listen: Option<SocketAddr>,
+    pub unix_path: Option<String>,
+    pub routing_mark: u32,
+    pub cors: ControllerCors,
+    pub server_tls: ControllerTls,
+}
+
+impl Default for ExternalControllerConfig {
+    fn default() -> Self {
+        Self {
+            listen: SocketAddr::from(([127, 0, 0, 1], 0)),
+            secret: None,
+            http_enabled: true,
+            tls_listen: None,
+            unix_path: None,
+            routing_mark: 0,
+            cors: ControllerCors::default(),
+            server_tls: ControllerTls::default(),
+        }
+    }
 }
 
 impl std::fmt::Debug for ExternalControllerConfig {
@@ -91,36 +249,66 @@ impl std::fmt::Debug for ExternalControllerConfig {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct GeoDataUpdateConfig {
+    pub geodata_mode: bool,
     pub urls: GeoDataUrls,
     pub auto_update: bool,
     pub interval_hours: u64,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq)]
 pub struct GeoDataUrls {
     pub geoip: String,
+    pub mmdb: String,
     pub geosite: String,
+    pub asn: String,
+}
+impl std::fmt::Debug for GeoDataUrls {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("GeoDataUrls")
+            .field("geoip", &crate::resource::http::source_origin(&self.geoip))
+            .field("mmdb", &crate::resource::http::source_origin(&self.mmdb))
+            .field(
+                "geosite",
+                &crate::resource::http::source_origin(&self.geosite),
+            )
+            .field("asn", &crate::resource::http::source_origin(&self.asn))
+            .finish()
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct TunConfig {
+    pub network: TunNetworkConfig,
+    pub auto_route: bool,
+    pub auto_detect_interface: bool,
     pub enable: bool,
     pub mtu: u16,
     pub file_descriptor: i32,
     pub device: String,
     pub dns_hijack: Vec<SocketAddr>,
     pub udp_timeout: Duration,
+    #[cfg(target_os = "linux")]
+    pub icmp_timeout: Duration,
+    #[cfg(target_os = "linux")]
+    pub disable_icmp_forwarding: bool,
 }
 
 impl Default for TunConfig {
     fn default() -> Self {
         Self {
+            network: TunNetworkConfig::default(),
+            auto_route: cfg!(target_os = "linux"),
+            auto_detect_interface: cfg!(target_os = "linux"),
             enable: false,
             mtu: default_mtu(),
             file_descriptor: 0,
             device: String::new(),
             dns_hijack: vec![SocketAddr::from((Ipv4Addr::UNSPECIFIED, 53))],
             udp_timeout: Duration::from_secs(300),
+            #[cfg(target_os = "linux")]
+            icmp_timeout: Duration::from_secs(10),
+            #[cfg(target_os = "linux")]
+            disable_icmp_forwarding: false,
         }
     }
 }
@@ -139,6 +327,15 @@ impl TunConfig {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct SnifferConfig {
     pub enable: bool,
+    pub force_dns_mapping: bool,
+    pub parse_pure_ip: bool,
+    pub force_domain: Vec<DnsPolicySelector>,
+    pub skip_domain: Vec<DnsPolicySelector>,
+    pub skip_src_address: Vec<RuleSpec>,
+    pub skip_dst_address: Vec<RuleSpec>,
+    pub http_override: bool,
+    pub tls_override: bool,
+    pub quic_override: bool,
     pub http_ports: Box<[PortRange]>,
     pub tls_ports: Box<[PortRange]>,
     pub quic_ports: Box<[PortRange]>,
@@ -149,6 +346,15 @@ impl SnifferConfig {
     pub fn disabled() -> Self {
         Self {
             enable: false,
+            force_dns_mapping: true,
+            parse_pure_ip: true,
+            force_domain: Vec::new(),
+            skip_domain: Vec::new(),
+            skip_src_address: Vec::new(),
+            skip_dst_address: Vec::new(),
+            http_override: true,
+            tls_override: true,
+            quic_override: true,
             http_ports: Box::new([]),
             tls_ports: Box::new([]),
             quic_ports: Box::new([]),
@@ -173,35 +379,193 @@ impl SnifferConfig {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct DnsConfig {
+    pub fake_ip: FakeIpConfig,
+    pub fallback: DnsFallbackConfig,
     pub enable: bool,
     pub ipv6: bool,
+    pub prefer_h3: bool,
+    pub ipv6_timeout: Duration,
+    pub cache_max_size: usize,
+    pub cache_algorithm: DnsCacheAlgorithm,
     pub nameservers: Vec<DnsNameserver>,
     pub nameserver_policies: Vec<DnsNameserverPolicy>,
+    pub default_nameservers: Vec<DnsNameserver>,
+    pub proxy_nameservers: Vec<DnsNameserver>,
+    pub proxy_policies: Vec<DnsNameserverPolicy>,
+    pub direct_nameservers: Vec<DnsNameserver>,
+    pub direct_follow_policy: bool,
+    pub use_hosts: bool,
+    pub use_system_hosts: bool,
+    pub hosts: Vec<HostEntry>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum DnsCacheAlgorithm {
+    #[default]
+    Lru,
+    Arc,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct HostEntry {
+    pub pattern: String,
+    pub value: HostValue,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum HostValue {
+    Addresses(Vec<IpAddr>),
+    Alias(String),
+    /// Interface addresses are captured during runtime preparation, never validation.
+    Lan,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum DnsAddress {
+    Ip(IpAddr),
+    Domain(String),
+    Source(DnsSource),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum DnsSource {
+    System,
+    Dhcp(Box<str>),
+}
+
+impl std::str::FromStr for DnsAddress {
+    type Err = std::convert::Infallible;
+    fn from_str(value: &str) -> std::result::Result<Self, Self::Err> {
+        Ok(value
+            .parse()
+            .map(Self::Ip)
+            .unwrap_or_else(|_| Self::Domain(value.to_owned())))
+    }
+}
+
+impl From<IpAddr> for DnsAddress {
+    fn from(value: IpAddr) -> Self {
+        Self::Ip(value)
+    }
+}
+
+impl From<Ipv4Addr> for DnsAddress {
+    fn from(ip: Ipv4Addr) -> Self {
+        Self::Ip(ip.into())
+    }
+}
+impl From<Ipv6Addr> for DnsAddress {
+    fn from(ip: Ipv6Addr) -> Self {
+        Self::Ip(ip.into())
+    }
+}
+
+impl std::fmt::Display for DnsAddress {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Ip(ip) => ip.fmt(f),
+            Self::Domain(host) => host.fmt(f),
+            Self::Source(DnsSource::System) => f.write_str("system"),
+            Self::Source(DnsSource::Dhcp(_)) => f.write_str("dhcp"),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct DnsNameserver {
     pub transport: DnsTransport,
-    pub address: IpAddr,
+    pub address: DnsAddress,
     pub port: u16,
     pub route: DnsRoute,
+    pub path: Option<String>,
+    pub http_auth: Option<DnsHttpAuth>,
+    pub options: DnsNameserverOptions,
+}
+
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct DnsHttpAuth(pub(crate) Box<str>);
+
+impl std::fmt::Debug for DnsHttpAuth {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("DnsHttpAuth([redacted])")
+    }
+}
+
+#[derive(Clone, Default, PartialEq, Eq, Hash)]
+pub struct DnsNameserverOptions {
+    pub interface: Option<std::sync::Arc<str>>,
+    pub ecs: Option<DnsEcs>,
+    pub ecs_override: bool,
+    pub disabled_types: Box<[u16]>,
+    pub skip_cert_verify: bool,
+    pub verification_name: Option<String>,
+    pub disable_reuse: bool,
+    pub force_h3: bool,
+}
+
+impl std::fmt::Debug for DnsNameserverOptions {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("DnsNameserverOptions")
+            .field("has_interface", &self.interface.is_some())
+            .field("ecs", &self.ecs.is_some())
+            .field("ecs_override", &self.ecs_override)
+            .field("disabled_type_count", &self.disabled_types.len())
+            .field("skip_cert_verify", &self.skip_cert_verify)
+            .field("explicit_name", &self.verification_name.is_some())
+            .field("disable_reuse", &self.disable_reuse)
+            .field("force_h3", &self.force_h3)
+            .finish()
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+pub struct DnsEcs {
+    pub address: IpAddr,
+    pub prefix_len: u8,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct DnsNameserverPolicy {
-    pub geosite_codes: Box<[String]>,
+    pub selector: DnsPolicySelector,
     pub nameservers: Box<[DnsNameserver]>,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum DnsPolicySelector {
+    GeoSite(Box<[String]>),
+    Domains(Box<[String]>),
+    RuleSets {
+        names: Box<[String]>,
+        sets: Vec<std::sync::Arc<RuleCollection>>,
+    },
+}
+
+impl DnsNameserverPolicy {
+    pub fn geosite_codes(&self) -> &[String] {
+        match &self.selector {
+            DnsPolicySelector::GeoSite(codes) => codes,
+            DnsPolicySelector::Domains(_) | DnsPolicySelector::RuleSets { .. } => &[],
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum DnsTransport {
+    /// A local response with a Mihomo RCODE name, without network I/O.
+    Rcode(u8),
     Udp,
     Tcp,
+    Tls,
+    Https,
+    Http,
+    Quic,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum DnsRoute {
     Direct,
+    Reject,
+    RejectDrop,
     Rules,
     Route(RouteTargetId),
 }
@@ -213,14 +577,91 @@ pub struct RuleSpec {
     pub no_resolve: bool,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum RuleControl {
+    Pass,
+    PassRule,
+}
+
+impl RuleControl {
+    pub(crate) fn name(self) -> &'static str {
+        match self {
+            Self::Pass => "PASS",
+            Self::PassRule => "PASS-RULE",
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct SubRuleId(usize);
+
+impl SubRuleId {
+    pub const fn index(self) -> usize {
+        self.0
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct NamedRuleProgram {
+    pub name: String,
+    pub rules: Vec<RuleSpec>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RuntimeRuleProgram {
+    pub main: Vec<RuleSpec>,
+    pub sub_rules: Vec<NamedRuleProgram>,
+}
+
+impl From<Vec<RuleSpec>> for RuntimeRuleProgram {
+    fn from(main: Vec<RuleSpec>) -> Self {
+        Self {
+            main,
+            sub_rules: Vec::new(),
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum RuleKind {
+    Flow {
+        predicate: Box<RuleSpec>,
+        control: RuleControl,
+    },
+    SubRule {
+        predicate: Box<RuleSpec>,
+        target: SubRuleId,
+    },
+    RuleSet {
+        name: String,
+        content: Option<std::sync::Arc<RuleCollection>>,
+        source: bool,
+    },
     Domain(String),
     DomainSuffix(String),
     DomainKeyword(String),
+    DomainWildcard(String),
+    DomainRegex(DomainRegex),
+    And(Vec<RuleSpec>),
+    Or(Vec<RuleSpec>),
+    Not(Box<RuleSpec>),
+    SrcIpCidr(IpCidr),
+    SrcIpSuffix(IpSuffix),
+    SrcPorts(Vec<PortRange>),
     GeoSite(String),
     GeoIp(String),
+    SrcGeoIp(String),
+    IpAsn(String),
+    SrcIpAsn(String),
+    InTypes(Vec<RuleInboundType>),
+    InNames(Vec<String>),
+    InUsers(Vec<String>),
+    RematchNames(Vec<String>),
+    Process(ProcessRule),
+    Uid(Vec<UidRange>),
+    InPorts(Vec<PortRange>),
     IpCidr(IpCidr),
+    IpSuffix(IpSuffix),
     DstPorts(Vec<PortRange>),
     Network(Network),
     Match,
@@ -231,6 +672,7 @@ pub enum RuleAction {
     Route(RouteTargetId),
     Direct,
     Reject,
+    RejectDrop,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -286,6 +728,8 @@ pub enum ProxyGroupMemberTarget {
     Route(RouteTargetId),
     Direct,
     Reject,
+    RejectDrop,
+    Control(RuleControl),
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -296,9 +740,18 @@ pub struct ProxyGroupMemberConfig {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct SelectProxyGroupConfig {
+    pub kind: GroupKind,
+    pub strategy: BalanceStrategy,
+    pub hash_key: BalanceHashKey,
+    pub health: HealthCheckConfig,
+    pub tolerance: u16,
+    pub max_failed_times: u32,
     pub name: String,
     pub members: Vec<ProxyGroupMemberConfig>,
     pub initial_member: usize,
+    pub disable_udp: bool,
+    pub hidden: bool,
+    pub icon: String,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -307,6 +760,24 @@ pub struct IpCidr {
     pub prefix_len: u8,
 }
 
+impl IpCidr {
+    pub fn contains(&self, ip: IpAddr) -> bool {
+        match (self.network, ip) {
+            (IpAddr::V4(a), IpAddr::V4(b)) => {
+                self.prefix_len == 0
+                    || u32::from(a) >> (32 - self.prefix_len)
+                        == u32::from(b) >> (32 - self.prefix_len)
+            }
+            (IpAddr::V6(a), IpAddr::V6(b)) => {
+                self.prefix_len == 0
+                    || u128::from(a) >> (128 - self.prefix_len)
+                        == u128::from(b) >> (128 - self.prefix_len)
+            }
+            _ => false,
+        }
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct PortRange {
     pub start: u16,
@@ -321,6 +792,11 @@ pub enum Network {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ProxyConfig {
+    pub tfo: bool,
+    pub mptcp: bool,
+    pub egress: EgressOptions,
+    pub ip_version: IpVersion,
+    pub smux: Option<SingMuxConfig>,
     pub tag: String,
     pub dialer_proxy: Option<RouteTargetId>,
     pub udp: bool,
@@ -329,8 +805,17 @@ pub struct ProxyConfig {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ProxyProtocol {
+    Direct,
+    Rematch(RematchConfig),
+    Dns,
+    Reject,
+    Masque(MasqueOutboundConfig),
+    TrustTunnel(TrustTunnelOutboundConfig),
+    Mieru(MieruOutboundConfig),
+    Http(HttpOutboundConfig),
+    WireGuard(WireGuardOutboundConfig),
     Tuic(TuicOutboundConfig),
-    Hysteria2(Hysteria2OutboundConfig),
+    Hysteria2(Box<Hysteria2OutboundConfig>),
     Vmess(VmessOutboundConfig),
     Trojan(TrojanOutboundConfig),
     Vless(VlessOutboundConfig),
@@ -340,32 +825,28 @@ pub enum ProxyProtocol {
 }
 
 impl ProxyConfig {
+    /// Functional route targets have no proxy-server endpoint.
     #[must_use]
-    pub fn address(&self) -> &str {
-        match &self.protocol {
-            ProxyProtocol::Tuic(config) => &config.address,
-            ProxyProtocol::Hysteria2(config) => &config.address,
-            ProxyProtocol::Vmess(config) => &config.address,
-            ProxyProtocol::Trojan(config) => &config.address,
-            ProxyProtocol::Vless(config) => &config.address,
-            ProxyProtocol::Socks5(config) => &config.address,
-            ProxyProtocol::AnyTls(config) => &config.address,
-            ProxyProtocol::Shadowsocks(config) => &config.address,
-        }
-    }
-
-    #[must_use]
-    pub const fn port(&self) -> u16 {
-        match &self.protocol {
-            ProxyProtocol::Tuic(config) => config.port,
-            ProxyProtocol::Hysteria2(config) => config.port,
-            ProxyProtocol::Vmess(config) => config.port,
-            ProxyProtocol::Trojan(config) => config.port,
-            ProxyProtocol::Vless(config) => config.port,
-            ProxyProtocol::Socks5(config) => config.port,
-            ProxyProtocol::AnyTls(config) => config.port,
-            ProxyProtocol::Shadowsocks(config) => config.port,
-        }
+    pub fn server_endpoint(&self) -> Option<(&str, u16)> {
+        Some(match &self.protocol {
+            ProxyProtocol::Direct
+            | ProxyProtocol::Dns
+            | ProxyProtocol::Reject
+            | ProxyProtocol::Rematch(_) => return None,
+            ProxyProtocol::Masque(config) => (&config.address, config.port),
+            ProxyProtocol::TrustTunnel(config) => (&config.address, config.port),
+            ProxyProtocol::Mieru(config) => (&config.address, config.port),
+            ProxyProtocol::WireGuard(config) => (&config.address, config.port),
+            ProxyProtocol::Http(config) => (&config.address, config.port),
+            ProxyProtocol::Tuic(config) => (&config.address, config.port),
+            ProxyProtocol::Hysteria2(config) => (&config.address, config.port),
+            ProxyProtocol::Vmess(config) => (&config.address, config.port),
+            ProxyProtocol::Trojan(config) => (&config.address, config.port),
+            ProxyProtocol::Vless(config) => (&config.address, config.port),
+            ProxyProtocol::Socks5(config) => (&config.address, config.port),
+            ProxyProtocol::AnyTls(config) => (&config.address, config.port),
+            ProxyProtocol::Shadowsocks(config) => (&config.address, config.port),
+        })
     }
 }
 
@@ -412,6 +893,7 @@ pub enum VlessPacketEncoding {
     #[default]
     #[serde(rename = "xudp")]
     Xudp,
+    // Public VLESS YAML normalizes this input to XUDP; kept for the internal codec.
     #[serde(rename = "none")]
     Raw,
     #[serde(rename = "packetaddr", alias = "packet")]
@@ -424,6 +906,7 @@ pub struct Socks5OutboundConfig {
     pub port: u16,
     pub username: Option<String>,
     pub password: Option<String>,
+    pub tls: Option<TlsClientPolicy>,
 }
 
 #[derive(Clone, PartialEq, Eq)]
@@ -432,24 +915,58 @@ pub struct AnyTlsOutboundConfig {
     pub port: u16,
     pub password: String,
     pub server_name: String,
-    pub tls: AnyTlsCertificatePolicy,
+    pub security: SecurityConfig,
+    pub session: AnyTlsSessionOptions,
 }
 
 #[derive(Debug, Clone, Default, PartialEq, Eq)]
-pub struct AnyTlsCertificatePolicy {
+pub struct TlsClientPolicy {
+    pub ech: Option<StaticEchConfig>,
     pub client_fingerprint: Option<ClientFingerprint>,
     pub alpn: Vec<Vec<u8>>,
-    pub skip_cert_verify: bool,
-    pub fingerprint: Option<[u8; 32]>,
+    pub certificate: TlsCertificatePolicy,
+    pub identity: Option<TlsIdentityPem>,
 }
 
 /// A version-pinned ClientHello profile, independent of certificate pins.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ClientFingerprint {
-    Chrome120,
     Chrome133,
     Firefox120,
     Safari16,
+    Ios14,
+    Android11,
+    Edge85,
+    ThreeSixty75,
+    Qq111,
+}
+impl ClientFingerprint {
+    pub(crate) const fn supports_tls13(self) -> bool {
+        !matches!(self, Self::Android11 | Self::ThreeSixty75)
+    }
+}
+fn validate_tls13_fingerprint(profile: Option<ClientFingerprint>) -> Result<()> {
+    if profile.is_some_and(|profile| !profile.supports_tls13()) {
+        return invalid("client-fingerprint only supports TLS1.2 for this transport");
+    }
+    Ok(())
+}
+
+// Only the immutable template value is process-shared. Selection precedes all
+// node/REALITY/download-leg compatibility checks; Stop does not redraw it.
+fn process_random_fingerprint() -> ClientFingerprint {
+    static SELECTED: std::sync::OnceLock<ClientFingerprint> = std::sync::OnceLock::new();
+    *SELECTED.get_or_init(|| weighted_fingerprint(rand::random_range(0..12)))
+}
+
+fn weighted_fingerprint(value: u8) -> ClientFingerprint {
+    match value {
+        0..=5 => ClientFingerprint::Chrome133,
+        6..=8 => ClientFingerprint::Safari16,
+        9..=10 => ClientFingerprint::Ios14,
+        11 => ClientFingerprint::Firefox120,
+        _ => unreachable!("fingerprint weight outside its bounded random range"),
+    }
 }
 
 fn parse_client_fingerprint(value: Option<&str>) -> Result<Option<ClientFingerprint>> {
@@ -459,9 +976,14 @@ fn parse_client_fingerprint(value: Option<&str>) -> Result<Option<ClientFingerpr
             invalid("client-fingerprint is not compiled in")
         }
         Some("chrome") => Ok(Some(ClientFingerprint::Chrome133)),
-        Some("chrome120") => Ok(Some(ClientFingerprint::Chrome120)),
-        Some("firefox" | "firefox120") => Ok(Some(ClientFingerprint::Firefox120)),
-        Some("safari" | "safari16") => Ok(Some(ClientFingerprint::Safari16)),
+        Some("firefox") => Ok(Some(ClientFingerprint::Firefox120)),
+        Some("safari") => Ok(Some(ClientFingerprint::Safari16)),
+        Some("ios") => Ok(Some(ClientFingerprint::Ios14)),
+        Some("android") => Ok(Some(ClientFingerprint::Android11)),
+        Some("edge") => Ok(Some(ClientFingerprint::Edge85)),
+        Some("360") => Ok(Some(ClientFingerprint::ThreeSixty75)),
+        Some("qq") => Ok(Some(ClientFingerprint::Qq111)),
+        Some("random") => Ok(Some(process_random_fingerprint())),
         Some(_) => invalid("unsupported client-fingerprint"),
     }
 }
@@ -506,15 +1028,24 @@ pub enum SecurityConfig {
     Tls(TlsConfig),
     Reality(RealityConfig),
     Jls(JlsConfig),
+    ShadowTls(ShadowTlsConfig),
 }
 
 impl SecurityConfig {
+    #[must_use]
+    pub fn as_tls(&self) -> Option<&TlsConfig> {
+        match self {
+            Self::Tls(config) => Some(config),
+            _ => None,
+        }
+    }
     fn client_fingerprint(&self) -> Option<ClientFingerprint> {
         match self {
             Self::None => None,
             Self::Tls(config) => config.client_fingerprint,
             Self::Reality(config) => config.client_fingerprint,
             Self::Jls(config) => config.tls.client_fingerprint,
+            Self::ShadowTls(config) => config.client_fingerprint,
         }
     }
     #[must_use]
@@ -524,6 +1055,7 @@ impl SecurityConfig {
             Self::Tls(config) => &config.server_name,
             Self::Reality(config) => &config.server_name,
             Self::Jls(config) => &config.tls.server_name,
+            Self::ShadowTls(config) => &config.server_name,
         }
     }
 }
@@ -564,6 +1096,7 @@ impl std::fmt::Debug for TlsCertificatePolicy {
 pub struct TlsIdentityPem {
     pub certificate: String,
     pub private_key: String,
+    pub(crate) origin: Option<std::sync::Arc<identity_files::IdentityFileOrigin>>,
 }
 impl std::fmt::Debug for TlsIdentityPem {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -598,16 +1131,7 @@ pub struct RealityConfig {
 
 impl RealityConfig {
     pub(crate) fn validate_fingerprint(&self) -> Result<()> {
-        if self.support_x25519mlkem768
-            && !matches!(
-                self.client_fingerprint,
-                None | Some(ClientFingerprint::Chrome133)
-            )
-        {
-            return invalid(
-                "hybrid REALITY requires client-fingerprint chrome or no named fingerprint",
-            );
-        }
+        validate_tls13_fingerprint(self.client_fingerprint)?;
         Ok(())
     }
 }
@@ -668,6 +1192,7 @@ pub struct TunInboundConfig {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct MixedInboundConfig {
+    pub access_rules: std::sync::Arc<ProxyAccessRules>,
     pub tag: String,
     pub port: u16,
     pub access: ProxyAccess,
@@ -705,6 +1230,49 @@ impl std::fmt::Debug for HttpInboundConfig {
 #[derive(Debug, Deserialize)]
 #[serde(deny_unknown_fields)]
 struct RawVoleConfig {
+    #[serde(rename = "find-process-mode", default)]
+    find_process_mode: FindProcessMode,
+    #[serde(rename = "interface-name", default)]
+    interface: String,
+    #[serde(rename = "routing-mark", default)]
+    routing_mark: i64,
+    #[serde(default)]
+    tls: TlsTrustConfig,
+    #[serde(rename = "bind-address", default)]
+    bind_address: Option<String>,
+    #[serde(rename = "lan-allowed-ips", default)]
+    lan_allowed_ips: Option<Vec<String>>,
+    #[serde(rename = "lan-disallowed-ips", default)]
+    lan_disallowed_ips: Vec<String>,
+    #[serde(rename = "skip-auth-prefixes", default)]
+    skip_auth_prefixes: Vec<String>,
+
+    #[serde(default)]
+    experimental: RawExperimental,
+
+    #[serde(rename = "tcp-concurrent", default)]
+    tcp_concurrent: bool,
+    #[serde(rename = "keep-alive-idle", default)]
+    keep_alive_idle: i32,
+    #[serde(rename = "keep-alive-interval", default)]
+    keep_alive_interval: i32,
+    #[serde(rename = "disable-keep-alive", default)]
+    disable_keep_alive: bool,
+
+    #[serde(rename = "unified-delay", default)]
+    unified_delay: bool,
+    #[serde(default)]
+    profile: ProfileConfig,
+    #[serde(default)]
+    mode: Mode,
+    #[serde(rename = "log-level", default)]
+    log_level: LogLevel,
+    #[serde(rename = "global-ua", default = "default_global_ua")]
+    global_ua: String,
+    #[serde(rename = "etag-support", default = "default_true")]
+    etag_support: bool,
+    #[serde(default)]
+    hosts: std::collections::BTreeMap<String, RawPolicyNameservers>,
     #[serde(default = "default_true")]
     ipv6: bool,
     #[serde(
@@ -713,6 +1281,8 @@ struct RawVoleConfig {
         deserialize_with = "deserialize_present_option"
     )]
     geox_url: Option<RawGeoDataUrls>,
+    #[serde(rename = "geodata-mode", default)]
+    geodata_mode: bool,
     #[serde(
         rename = "geo-auto-update",
         default,
@@ -731,6 +1301,22 @@ struct RawVoleConfig {
         deserialize_with = "deserialize_present_option"
     )]
     external_controller: Option<String>,
+    #[serde(
+        rename = "external-controller-tls",
+        default,
+        deserialize_with = "deserialize_present_option"
+    )]
+    external_controller_tls: Option<String>,
+    #[serde(
+        rename = "external-controller-unix",
+        default,
+        deserialize_with = "deserialize_present_option"
+    )]
+    external_controller_unix: Option<String>,
+    #[serde(rename = "external-controller-routing-mark", default)]
+    external_controller_routing_mark: i64,
+    #[serde(rename = "external-controller-cors", default)]
+    external_controller_cors: ControllerCors,
     #[serde(default, deserialize_with = "deserialize_present_option")]
     secret: Option<String>,
     #[serde(
@@ -747,6 +1333,7 @@ struct RawVoleConfig {
     tun: Option<RawTunConfig>,
     #[serde(default, deserialize_with = "deserialize_present_option")]
     sniffer: Option<RawSnifferConfig>,
+    #[serde(default, deserialize_with = "deserialize_non_null_vec")]
     proxies: Vec<RawOutbound>,
     #[serde(
         rename = "proxy-groups",
@@ -756,34 +1343,158 @@ struct RawVoleConfig {
     proxy_groups: Vec<RawProxyGroup>,
     #[serde(default, deserialize_with = "deserialize_present_option")]
     dns: Option<RawDnsConfig>,
+    #[serde(default)]
     rules: Vec<String>,
+    #[serde(rename = "sub-rules", default)]
+    sub_rules: std::collections::BTreeMap<String, Vec<String>>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct RawExperimental {
+    #[serde(rename = "dialer-ip4p-convert", default)]
+    dialer_ip4p_convert: bool,
+    #[serde(rename = "quic-go-disable-gso", default)]
+    quic_disable_gso: bool,
+    #[serde(rename = "quic-go-disable-ecn", default = "default_true")]
+    quic_disable_ecn: bool,
+}
+impl Default for RawExperimental {
+    fn default() -> Self {
+        Self {
+            dialer_ip4p_convert: false,
+            quic_disable_gso: false,
+            quic_disable_ecn: true,
+        }
+    }
 }
 
 #[derive(Debug, Deserialize)]
 #[serde(deny_unknown_fields)]
 struct RawProxyGroup {
-    name: String,
-    #[serde(rename = "type")]
-    kind: String,
-    proxies: Vec<String>,
+    #[serde(default)]
+    strategy: BalanceStrategy,
+    #[serde(rename = "hash-key", default)]
+    hash_key: BalanceHashKey,
+    #[serde(default)]
+    url: String,
+    #[serde(default)]
+    interval: u64,
+    #[serde(default)]
+    timeout: u64,
+    #[serde(default = "default_true")]
+    lazy: bool,
     #[serde(
-        rename = "default-selected",
+        rename = "expected-status",
         default,
-        deserialize_with = "deserialize_present_option"
+        deserialize_with = "scalar::string_or_integer"
     )]
+    expected_status: String,
+    #[serde(default)]
+    tolerance: u16,
+    #[serde(rename = "max-failed-times", default)]
+    max_failed_times: u32,
+
+    #[serde(rename = "disable-udp", default)]
+    disable_udp: bool,
+    #[serde(default)]
+    hidden: bool,
+    #[serde(default)]
+    icon: String,
+    name: String,
+    #[serde(rename = "type")]
+    kind: GroupKind,
+    proxies: Vec<String>,
+    #[serde(rename = "default-selected", default)]
     default_selected: Option<String>,
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Deserialize)]
 #[serde(deny_unknown_fields)]
 struct RawGeoDataUrls {
+    #[serde(default = "default_geoip_url")]
     geoip: String,
+    #[serde(default = "default_mmdb_url")]
+    mmdb: String,
+    #[serde(default = "default_geosite_url")]
     geosite: String,
+    #[serde(default = "default_asn_url")]
+    asn: String,
+}
+impl std::fmt::Debug for RawGeoDataUrls {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("RawGeoDataUrls").finish_non_exhaustive()
+    }
+}
+fn default_global_ua() -> String {
+    concat!("Vole/", env!("CARGO_PKG_VERSION")).into()
+}
+fn default_geoip_url() -> String {
+    "https://github.com/MetaCubeX/meta-rules-dat/releases/download/latest/geoip.dat".into()
+}
+fn default_mmdb_url() -> String {
+    "https://github.com/MetaCubeX/meta-rules-dat/releases/download/latest/geoip.metadb".into()
+}
+fn default_geosite_url() -> String {
+    "https://github.com/MetaCubeX/meta-rules-dat/releases/download/latest/geosite.dat".into()
+}
+fn default_asn_url() -> String {
+    "https://github.com/MetaCubeX/meta-rules-dat/releases/download/latest/GeoLite2-ASN.mmdb".into()
+}
+impl Default for RawGeoDataUrls {
+    fn default() -> Self {
+        Self {
+            geoip: default_geoip_url(),
+            mmdb: default_mmdb_url(),
+            geosite: default_geosite_url(),
+            asn: default_asn_url(),
+        }
+    }
 }
 
 #[derive(Debug, Deserialize)]
 #[serde(deny_unknown_fields)]
 struct RawTunConfig {
+    #[serde(
+        rename = "inet6-address",
+        default,
+        deserialize_with = "deserialize_present_option"
+    )]
+    inet6_address: Option<Vec<String>>,
+    #[serde(rename = "route-address", default)]
+    route_address: Vec<String>,
+    #[serde(rename = "route-exclude-address", default)]
+    route_exclude_address: Vec<String>,
+    #[serde(rename = "iproute2-table-index", default)]
+    table_index: u32,
+    #[serde(rename = "iproute2-rule-index", default)]
+    rule_index: u32,
+    #[serde(rename = "strict-route", default)]
+    strict_route: bool,
+    #[serde(rename = "include-interface", default)]
+    include_interface: Vec<String>,
+    #[serde(rename = "exclude-interface", default)]
+    exclude_interface: Vec<String>,
+    #[serde(rename = "include-uid", default)]
+    include_uid: Vec<u32>,
+    #[serde(rename = "include-uid-range", default)]
+    include_uid_range: Vec<String>,
+    #[serde(rename = "exclude-uid", default)]
+    exclude_uid: Vec<u32>,
+    #[serde(rename = "exclude-uid-range", default)]
+    exclude_uid_range: Vec<String>,
+    #[serde(rename = "exclude-src-port", default)]
+    exclude_src_port: Vec<u16>,
+    #[serde(rename = "exclude-src-port-range", default)]
+    exclude_src_port_range: Vec<String>,
+    #[serde(rename = "exclude-dst-port", default)]
+    exclude_dst_port: Vec<u16>,
+    #[serde(rename = "exclude-dst-port-range", default)]
+    exclude_dst_port_range: Vec<String>,
+    #[serde(rename = "auto-route", default)]
+    auto_route: Option<bool>,
+    #[serde(rename = "auto-detect-interface", default)]
+    auto_detect_interface: Option<bool>,
     #[serde(default)]
     enable: bool,
     #[serde(default)]
@@ -800,6 +1511,12 @@ struct RawTunConfig {
     dns_hijack: Vec<String>,
     #[serde(rename = "udp-timeout", default)]
     udp_timeout: u64,
+    #[cfg(target_os = "linux")]
+    #[serde(rename = "icmp-timeout", default)]
+    icmp_timeout: i64,
+    #[cfg(target_os = "linux")]
+    #[serde(rename = "disable-icmp-forwarding", default)]
+    disable_icmp_forwarding: bool,
 }
 
 impl RawTunConfig {
@@ -838,13 +1555,51 @@ impl RawTunConfig {
         } else {
             self.udp_timeout
         });
+        #[cfg(target_os = "linux")]
+        let icmp_timeout = {
+            let seconds = u64::try_from(self.icmp_timeout).map_err(|_| {
+                VoleError::InvalidConfig("tun.icmp-timeout must be nonnegative seconds".into())
+            })?;
+            let timeout = Duration::from_secs(if seconds == 0 { 10 } else { seconds });
+            if std::time::Instant::now().checked_add(timeout).is_none() {
+                return invalid("tun.icmp-timeout exceeds the clock range");
+            }
+            timeout
+        };
         Ok(TunConfig {
+            network: tun_network::RawTunNetworkConfig {
+                inet6_address: self.inet6_address,
+                route_address: self.route_address,
+                route_exclude_address: self.route_exclude_address,
+                table_index: self.table_index,
+                rule_index: self.rule_index,
+                strict_route: self.strict_route,
+                include_interface: self.include_interface,
+                exclude_interface: self.exclude_interface,
+                include_uid: self.include_uid,
+                include_uid_range: self.include_uid_range,
+                exclude_uid: self.exclude_uid,
+                exclude_uid_range: self.exclude_uid_range,
+                exclude_src_port: self.exclude_src_port,
+                exclude_src_port_range: self.exclude_src_port_range,
+                exclude_dst_port: self.exclude_dst_port,
+                exclude_dst_port_range: self.exclude_dst_port_range,
+            }
+            .normalize()?,
+            auto_route: self.auto_route.unwrap_or(cfg!(target_os = "linux")),
+            auto_detect_interface: self
+                .auto_detect_interface
+                .unwrap_or(cfg!(target_os = "linux")),
             enable: self.enable,
             mtu,
             file_descriptor: self.file_descriptor,
             device: self.device,
             dns_hijack,
             udp_timeout,
+            #[cfg(target_os = "linux")]
+            icmp_timeout,
+            #[cfg(target_os = "linux")]
+            disable_icmp_forwarding: self.disable_icmp_forwarding,
         })
     }
 }
@@ -852,37 +1607,57 @@ impl RawTunConfig {
 #[derive(Debug, Deserialize)]
 #[serde(deny_unknown_fields)]
 struct RawSnifferConfig {
+    #[serde(default)]
     enable: bool,
+    #[serde(rename = "force-dns-mapping", default = "default_true")]
+    force_dns_mapping: bool,
+    #[serde(rename = "parse-pure-ip", default = "default_true")]
+    parse_pure_ip: bool,
+    #[serde(rename = "force-domain", default)]
+    force_domain: Vec<String>,
+    #[serde(rename = "skip-domain", default)]
+    skip_domain: Vec<String>,
+    #[serde(rename = "skip-src-address", default)]
+    skip_src_address: Vec<String>,
+    #[serde(rename = "skip-dst-address", default)]
+    skip_dst_address: Vec<String>,
+    #[serde(rename = "override-destination", default = "default_true")]
+    override_destination: bool,
     #[serde(default, deserialize_with = "deserialize_present_option")]
     sniff: Option<RawSniffConfig>,
 }
 
-#[derive(Debug, Default, Deserialize)]
-#[serde(deny_unknown_fields)]
+#[derive(Debug, Default)]
 struct RawSniffConfig {
-    #[serde(
-        rename = "HTTP",
-        default,
-        deserialize_with = "deserialize_present_option"
-    )]
     http: Option<Option<RawSniffProtocolConfig>>,
-    #[serde(
-        rename = "TLS",
-        default,
-        deserialize_with = "deserialize_present_option"
-    )]
     tls: Option<Option<RawSniffProtocolConfig>>,
-    #[serde(
-        rename = "QUIC",
-        default,
-        deserialize_with = "deserialize_present_option"
-    )]
     quic: Option<Option<RawSniffProtocolConfig>>,
 }
+impl<'de> Deserialize<'de> for RawSniffConfig {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> std::result::Result<Self, D::Error> {
+        let entries = serde_yaml_ng::Mapping::deserialize(deserializer)?;
+        let mut result = Self::default();
+        for (name, value) in entries {
+            let name = name.as_str().ok_or_else(|| {
+                serde::de::Error::custom("sniffer protocol name must be a string")
+            })?;
+            let field = match name.to_ascii_uppercase().as_str() {
+                "HTTP" => &mut result.http,
+                "TLS" => &mut result.tls,
+                "QUIC" => &mut result.quic,
+                _ => return Err(serde::de::Error::custom("unsupported sniffer protocol")),
+            };
+            *field = Some(serde_yaml_ng::from_value(value).map_err(serde::de::Error::custom)?);
+        }
+        Ok(result)
+    }
+}
 
 #[derive(Debug, Default, Deserialize)]
 #[serde(deny_unknown_fields)]
 struct RawSniffProtocolConfig {
+    #[serde(rename = "override-destination", default)]
+    override_destination: Option<bool>,
     #[serde(default, deserialize_with = "deserialize_present_option")]
     ports: Option<Vec<RawSnifferPort>>,
 }
@@ -897,17 +1672,64 @@ enum RawSnifferPort {
 #[derive(Debug, Deserialize)]
 #[serde(deny_unknown_fields)]
 struct RawDnsConfig {
+    #[serde(default)]
+    fallback: Vec<String>,
+    #[serde(rename = "fallback-filter", default)]
+    fallback_filter: fallback::RawFallbackFilter,
+    #[serde(rename = "fallback-lazy-query", default)]
+    fallback_lazy_query: bool,
+    #[serde(rename = "fake-ip-range", default = "fake_ip::default_fake_range")]
+    fake_ip_range: String,
+    #[serde(rename = "fake-ip-range6", default)]
+    fake_ip_range6: String,
+    #[serde(rename = "fake-ip-filter", default = "fake_ip::default_fake_filter")]
+    fake_ip_filter: Vec<String>,
+    #[serde(rename = "fake-ip-filter-mode", default)]
+    fake_ip_filter_mode: FakeIpFilterMode,
+    #[serde(rename = "fake-ip-ttl", default = "fake_ip::default_fake_ttl")]
+    fake_ip_ttl: i64,
+    #[serde(default)]
     enable: bool,
-    #[serde(default = "default_true")]
-    ipv6: bool,
     #[serde(default)]
+    ipv6: bool,
+    #[serde(rename = "prefer-h3", default)]
+    prefer_h3: bool,
+    #[serde(rename = "ipv6-timeout", default = "dns::default_ipv6_timeout")]
+    ipv6_timeout: u64,
+    #[serde(rename = "cache-max-size", default)]
+    cache_max_size: usize,
+    #[serde(rename = "cache-algorithm", default)]
+    cache_algorithm: String,
+    #[serde(default = "dns::default_nameservers")]
     nameserver: Vec<String>,
+    #[serde(rename = "default-nameserver", default = "dns::default_bootstrap")]
+    default_nameserver: Vec<String>,
+    #[serde(rename = "proxy-server-nameserver", default)]
+    proxy_nameserver: Vec<String>,
+    #[serde(rename = "direct-nameserver", default)]
+    direct_nameserver: Vec<String>,
+    #[serde(rename = "direct-nameserver-follow-policy", default)]
+    direct_follow_policy: bool,
+    #[serde(rename = "use-hosts", default = "default_true")]
+    use_hosts: bool,
+    #[serde(rename = "use-system-hosts", default = "default_true")]
+    use_system_hosts: bool,
+    #[serde(rename = "respect-rules", default)]
+    respect_rules: bool,
+    #[serde(rename = "enhanced-mode", default = "dns::redir_host")]
+    enhanced_mode: String,
     #[serde(
         rename = "nameserver-policy",
         default,
         deserialize_with = "deserialize_dns_nameserver_policies"
     )]
     nameserver_policies: Vec<RawDnsNameserverPolicy>,
+    #[serde(
+        rename = "proxy-server-nameserver-policy",
+        default,
+        deserialize_with = "deserialize_dns_nameserver_policies"
+    )]
+    proxy_policies: Vec<RawDnsNameserverPolicy>,
 }
 
 #[derive(Debug)]
@@ -916,6 +1738,13 @@ struct RawDnsNameserverPolicy {
     nameservers: Vec<String>,
 }
 
+#[derive(Debug, Deserialize)]
+#[serde(untagged)]
+enum RawPolicyNameservers {
+    One(String),
+    Many(Vec<String>),
+}
+
 fn deserialize_dns_nameserver_policies<'de, D>(
     deserializer: D,
 ) -> std::result::Result<Vec<RawDnsNameserverPolicy>, D::Error>
@@ -939,10 +1768,15 @@ where
             A: MapAccess<'de>,
         {
             let mut policies = Vec::with_capacity(mapping.size_hint().unwrap_or(0));
-            while let Some((selector, nameservers)) = mapping.next_entry::<String, Vec<String>>()? {
+            while let Some((selector, nameservers)) =
+                mapping.next_entry::<String, RawPolicyNameservers>()?
+            {
                 policies.push(RawDnsNameserverPolicy {
                     selector,
-                    nameservers,
+                    nameservers: match nameservers {
+                        RawPolicyNameservers::One(nameserver) => vec![nameserver],
+                        RawPolicyNameservers::Many(nameservers) => nameservers,
+                    },
                 });
             }
             Ok(policies)
@@ -952,12 +1786,111 @@ where
     deserializer.deserialize_map(OrderedPoliciesVisitor)
 }
 
+#[derive(Debug)]
+struct RawOutbound {
+    tfo: bool,
+    mptcp: bool,
+    egress: EgressOptions,
+    ip_version: IpVersion,
+    smux: Option<sing_mux::RawSingMux>,
+    protocol: RawProtocol,
+}
+impl<'de> Deserialize<'de> for RawOutbound {
+    fn deserialize<D: serde::Deserializer<'de>>(
+        deserializer: D,
+    ) -> std::result::Result<Self, D::Error> {
+        let mut value = serde_yaml_ng::Value::deserialize(deserializer)?;
+        let mapping = value
+            .as_mapping_mut()
+            .ok_or_else(|| serde::de::Error::custom("proxy requires a mapping"))?;
+        functional::validate_fields(mapping).map_err(serde::de::Error::custom)?;
+        let interface = mapping
+            .remove("interface-name")
+            .map(serde_yaml_ng::from_value::<String>)
+            .transpose()
+            .map_err(serde::de::Error::custom)?
+            .unwrap_or_default();
+        let mark = mapping
+            .remove("routing-mark")
+            .map(serde_yaml_ng::from_value::<i64>)
+            .transpose()
+            .map_err(serde::de::Error::custom)?
+            .unwrap_or_default();
+        let egress = EgressOptions::normalize(interface, mark).map_err(serde::de::Error::custom)?;
+        let tfo = value
+            .as_mapping_mut()
+            .expect("mapping checked")
+            .remove("tfo")
+            .map(serde_yaml_ng::from_value::<bool>)
+            .transpose()
+            .map_err(serde::de::Error::custom)?
+            .unwrap_or_default();
+        let mptcp = value
+            .as_mapping_mut()
+            .expect("mapping checked")
+            .remove("mptcp")
+            .map(serde_yaml_ng::from_value::<bool>)
+            .transpose()
+            .map_err(serde::de::Error::custom)?
+            .unwrap_or_default();
+        let ip_version = value
+            .as_mapping_mut()
+            .ok_or_else(|| serde::de::Error::custom("proxy requires a mapping"))?
+            .remove("ip-version")
+            .map(serde_yaml_ng::from_value)
+            .transpose()
+            .map_err(serde::de::Error::custom)?
+            .unwrap_or_default();
+        let smux = value
+            .as_mapping_mut()
+            .expect("mapping checked")
+            .remove("smux")
+            .map(|value| {
+                if !value.is_mapping() {
+                    return Err("smux requires a mapping".to_owned());
+                }
+                serde_yaml_ng::from_value(value).map_err(|error| error.to_string())
+            })
+            .transpose()
+            .map_err(serde::de::Error::custom)?;
+        let protocol = serde_yaml_ng::from_value(value).map_err(serde::de::Error::custom)?;
+        Ok(Self {
+            tfo,
+            mptcp,
+            egress,
+            ip_version,
+            smux,
+            protocol,
+        })
+    }
+}
+
 #[derive(Debug, Deserialize)]
 #[serde(tag = "type", deny_unknown_fields)]
 // This enum exists only while deserializing a configuration. Keeping the
 // protocol fields inline avoids extra heap allocations in the startup path.
 #[allow(clippy::large_enum_variant)]
-enum RawOutbound {
+enum RawProtocol {
+    #[serde(rename = "direct")]
+    Direct(functional::RawFunctional),
+    #[serde(rename = "dns")]
+    Dns(functional::RawFunctional),
+    #[serde(rename = "rematch")]
+    Rematch(functional::RawRematch),
+    #[serde(rename = "reject")]
+    Reject(functional::RawFunctional),
+    #[serde(rename = "masque")]
+    Masque(#[serde(deserialize_with = "masque::deserialize")] masque::RawMasque),
+    #[serde(rename = "trusttunnel")]
+    TrustTunnel(
+        #[serde(deserialize_with = "trusttunnel::deserialize")] trusttunnel::RawTrustTunnel,
+    ),
+    #[serde(rename = "mieru")]
+    Mieru(#[serde(deserialize_with = "mieru::deserialize")] mieru::RawMieru),
+    #[serde(rename = "wireguard")]
+    WireGuard(#[serde(deserialize_with = "wireguard::deserialize")] wireguard::RawWireGuard),
+    #[serde(rename = "http")]
+    Http(http_proxy::RawHttp),
     #[serde(rename = "tuic")]
     Tuic(#[serde(deserialize_with = "tuic::deserialize")] tuic::RawTuic),
     #[serde(rename = "hysteria2")]
@@ -978,9 +1911,9 @@ enum RawOutbound {
         #[serde(
             rename = "plugin-opts",
             default,
-            deserialize_with = "shadowsocks::deserialize_plugin"
+            deserialize_with = "shadowsocks_plugin::deserialize"
         )]
-        plugin_opts: Option<shadowsocks::RawShadowTls>,
+        plugin_opts: Option<serde_yaml_ng::Value>,
         #[serde(
             rename = "client-fingerprint",
             default,
@@ -1015,6 +1948,28 @@ enum RawOutbound {
         udp: bool,
         #[serde(default)]
         tls: bool,
+        #[serde(
+            rename = "skip-cert-verify",
+            default,
+            deserialize_with = "deserialize_present_option"
+        )]
+        skip_cert_verify: Option<bool>,
+        #[serde(
+            rename = "name-cert-verify",
+            default,
+            deserialize_with = "deserialize_present_option"
+        )]
+        name_cert_verify: Option<String>,
+        #[serde(default, deserialize_with = "deserialize_present_option")]
+        fingerprint: Option<String>,
+        #[serde(default, deserialize_with = "deserialize_present_option")]
+        certificate: Option<String>,
+        #[serde(
+            rename = "private-key",
+            default,
+            deserialize_with = "deserialize_present_option"
+        )]
+        private_key: Option<String>,
         #[serde(default, deserialize_with = "deserialize_present_option")]
         username: Option<String>,
         #[serde(default, deserialize_with = "deserialize_present_option")]
@@ -1032,22 +1987,60 @@ enum RawOutbound {
         server: String,
         port: u16,
         password: String,
+        #[serde(rename = "idle-session-check-interval", default)]
+        idle_session_check_interval: i64,
+        #[serde(rename = "idle-session-timeout", default)]
+        idle_session_timeout: i64,
+        #[serde(rename = "min-idle-session", default)]
+        min_idle_session: i64,
+        #[serde(rename = "disable-reuse", default)]
+        disable_reuse: bool,
+        #[serde(rename = "client-metadata", default)]
+        client_metadata: String,
         #[serde(default)]
         udp: bool,
         #[serde(default, deserialize_with = "deserialize_present_option")]
         sni: Option<String>,
         #[serde(default, deserialize_with = "deserialize_present_option")]
         alpn: Option<Vec<String>>,
-        #[serde(rename = "skip-cert-verify", default)]
-        skip_cert_verify: bool,
+        #[serde(
+            rename = "skip-cert-verify",
+            default,
+            deserialize_with = "deserialize_present_option"
+        )]
+        skip_cert_verify: Option<bool>,
         #[serde(default, deserialize_with = "deserialize_present_option")]
         fingerprint: Option<String>,
+        #[serde(
+            rename = "name-cert-verify",
+            default,
+            deserialize_with = "deserialize_present_option"
+        )]
+        name_cert_verify: Option<String>,
+        #[serde(default, deserialize_with = "deserialize_present_option")]
+        certificate: Option<String>,
+        #[serde(
+            rename = "private-key",
+            default,
+            deserialize_with = "deserialize_present_option"
+        )]
+        private_key: Option<String>,
         #[serde(
             rename = "client-fingerprint",
             default,
             deserialize_with = "deserialize_present_option"
         )]
         client_fingerprint: Option<String>,
+        #[serde(
+            rename = "shadow-tls-opts",
+            default,
+            deserialize_with = "security::deserialize_shadow_tls"
+        )]
+        shadow_tls_opts: Option<security::RawShadowTlsMode>,
+        #[serde(rename = "jls-opts", default, deserialize_with = "jls::deserialize")]
+        jls_opts: Option<jls::RawJls>,
+        #[serde(rename = "ech-opts", default, deserialize_with = "ech::deserialize")]
+        ech_opts: Option<ech::RawEch>,
         #[serde(
             rename = "dialer-proxy",
             default,
@@ -1165,19 +2158,19 @@ struct RawXHttpSettings {
     #[serde(
         rename = "uplink-chunk-size",
         default,
-        deserialize_with = "deserialize_present_option"
+        deserialize_with = "scalar::optional_string_or_integer"
     )]
     uplink_chunk_size: Option<String>,
     #[serde(
         rename = "sc-max-each-post-bytes",
         default,
-        deserialize_with = "deserialize_present_option"
+        deserialize_with = "scalar::optional_string_or_integer"
     )]
     sc_max_each_post_bytes: Option<String>,
     #[serde(
         rename = "sc-min-posts-interval-ms",
         default,
-        deserialize_with = "deserialize_present_option"
+        deserialize_with = "scalar::optional_string_or_integer"
     )]
     sc_min_posts_interval_ms: Option<String>,
     #[serde(
@@ -1273,6 +2266,12 @@ struct RawXHttpDownloadSettings {
         deserialize_with = "deserialize_present_map"
     )]
     reality_opts: Option<RawXHttpDownloadReality>,
+    #[serde(
+        rename = "shadow-tls-opts",
+        default,
+        deserialize_with = "security::deserialize_shadow_tls"
+    )]
+    shadow_tls_opts: Option<security::RawShadowTlsMode>,
     #[serde(rename = "jls-opts", default, deserialize_with = "jls::deserialize")]
     jls_opts: Option<jls::RawJls>,
     #[serde(rename = "ech-opts", default, deserialize_with = "ech::deserialize")]
@@ -1321,6 +2320,11 @@ struct RawRealitySettings {
 
 #[derive(Debug)]
 struct PendingProxyConfig {
+    tfo: bool,
+    mptcp: bool,
+    egress: EgressOptions,
+    ip_version: IpVersion,
+    smux: Option<SingMuxConfig>,
     tag: String,
     dialer_proxy: Option<String>,
     udp: bool,
@@ -1396,97 +2400,216 @@ fn deserialize_present_credentials<'de, D>(
 where
     D: Deserializer<'de>,
 {
-    deserialize_non_null_vec(deserializer)
-        .map(Some)
-        .map_err(|_| {
-            serde::de::Error::custom(
-                "authentication must be a non-null sequence of credential strings",
-            )
-        })
+    Option::<Vec<String>>::deserialize(deserializer).map_err(|_| {
+        serde::de::Error::custom("authentication must be a sequence of credential strings or null")
+    })
 }
 
 impl Config {
+    pub(crate) fn http_policy(&self) -> Option<std::sync::Arc<crate::http_processing::Policy>> {
+        self.providers
+            .as_ref()
+            .and_then(|template| template.http_policy.clone())
+    }
+    pub(crate) fn set_http_config(&mut self, input: Option<&str>) -> Result<()> {
+        let policy = crate::http_processing::Policy::compile_optional(input)?;
+        self.set_http_policy(policy)
+    }
+    pub(crate) fn set_http_policy(
+        &mut self,
+        policy: Option<std::sync::Arc<crate::http_processing::Policy>>,
+    ) -> Result<()> {
+        let template = self
+            .providers
+            .as_mut()
+            .ok_or_else(|| VoleError::InvalidConfig("configuration template is missing".into()))?;
+        std::sync::Arc::make_mut(template).http_policy = policy;
+        Ok(())
+    }
+
     pub fn parse_yaml(input: &[u8]) -> Result<Self> {
-        if input.len() > MAX_CONFIG_BYTES {
-            return invalid(format!(
-                "configuration exceeds the {MAX_CONFIG_BYTES}-byte limit"
-            ));
+        Self::parse_yaml_with_directory(input, None)
+    }
+
+    pub(crate) fn parse_yaml_with_directory(
+        input: &[u8],
+        directory: Option<&std::path::Path>,
+    ) -> Result<Self> {
+        let yaml = yaml::parse(input)?;
+        let mut template = providers::ProviderTemplate::extract(yaml)?;
+        template.identity_directory = directory.map(std::path::Path::to_path_buf);
+        let template = std::sync::Arc::new(template);
+        template.materialize(&providers::ProviderContents::new())
+    }
+    #[cfg(any(feature = "invoke", test))]
+    pub(crate) fn take_runtime_rules(&mut self) -> RuntimeRuleProgram {
+        match self.mode {
+            Mode::Rule => RuntimeRuleProgram {
+                main: std::mem::take(&mut self.rules),
+                sub_rules: std::mem::take(&mut self.sub_rules),
+            },
+            Mode::Direct | Mode::Global => {
+                let action = if self.mode == Mode::Direct {
+                    RuleAction::Direct
+                } else {
+                    RuleAction::Route(RouteTargetId::Group(ProxyGroupId::from_index(
+                        self.proxy_groups
+                            .iter()
+                            .position(|group| group.name == "GLOBAL")
+                            .expect("GLOBAL group exists"),
+                    )))
+                };
+                RuntimeRuleProgram::from(vec![RuleSpec {
+                    kind: RuleKind::Match,
+                    action,
+                    no_resolve: false,
+                }])
+            }
         }
-        let input = std::str::from_utf8(input)
-            .map_err(|_| VoleError::InvalidConfig("configuration is not UTF-8".to_owned()))?;
-
-        reject_yaml_anchors_and_aliases(input)?;
-        let yaml: YamlValue = serde_yaml_ng::from_str(input)
-            .map_err(|error| VoleError::InvalidConfig(error.to_string()))?;
-        validate_json_compatible_yaml(&yaml)?;
-        // Deserialize from the YAML value directly. Mapping order is part of
-        // nameserver-policy semantics and would be lost by the intermediate
-        // serde_json map representation.
-        let raw: RawVoleConfig = serde_yaml_ng::from_value(yaml)
-            .map_err(|error| VoleError::InvalidConfig(error.to_string()))?;
-        raw.normalize()
     }
 }
 
 impl RawVoleConfig {
     fn normalize(self) -> Result<Config> {
+        if self.global_ua.len() > 1024
+            || !self
+                .global_ua
+                .bytes()
+                .all(|b| b == b'\t' || (0x20..=0x7e).contains(&b))
+        {
+            return invalid("global-ua must be a bounded HTTP header value");
+        }
         let geodata_update = normalize_geodata_update(
+            self.geodata_mode,
             self.geox_url,
             self.geo_auto_update,
             self.geo_update_interval,
         )?;
 
         let mixed_port = self.mixed_port.filter(|port| *port != 0);
+        let allow_lan = self.allow_lan && self.bind_address.as_deref() != Some("localhost");
+        let bind_address = match self.bind_address.as_deref() {
+            None | Some("" | "*" | "localhost") => None,
+            Some(value) => Some(value.trim_matches(['[', ']']).parse::<IpAddr>().map_err(
+                |_| {
+                    VoleError::InvalidConfig(
+                        "bind-address must be an IP address, localhost or *".into(),
+                    )
+                },
+            )?),
+        };
+        let cidrs = |values: Vec<String>| {
+            values
+                .into_iter()
+                .map(|value| parse_ip_cidr(&value, value.contains(':')))
+                .collect::<Result<Vec<_>>>()
+        };
+        let access_rules = std::sync::Arc::new(ProxyAccessRules {
+            allowed: self
+                .lan_allowed_ips
+                .map(cidrs)
+                .transpose()?
+                .unwrap_or_else(|| ProxyAccessRules::default().allowed),
+            denied: cidrs(self.lan_disallowed_ips)?,
+            skip_auth: cidrs(self.skip_auth_prefixes)?,
+        });
         let authentication = normalize_proxy_authentication(self.authentication)?;
-        if mixed_port.is_none() && (authentication.is_some() || self.allow_lan) {
-            return invalid("authentication or allow-lan requires an enabled mixed-port");
-        }
 
         let tun = self
             .tun
             .map_or_else(|| Ok(TunConfig::default()), RawTunConfig::normalize)?;
-        if mixed_port.is_none() && !tun.enable {
-            return invalid("configuration requires mixed-port or tun.enable: true");
-        }
         let sniffer = self.sniffer.map_or_else(
             || Ok(SnifferConfig::disabled()),
             RawSnifferConfig::normalize,
         )?;
 
-        if self.proxies.is_empty() {
-            return invalid("proxies must contain at least 1 entry");
+        let mut raw_groups = self.proxy_groups;
+        let generated_global = !raw_groups.iter().any(|group| group.name == "GLOBAL");
+        if generated_global {
+            raw_groups.push(RawProxyGroup {
+                strategy: BalanceStrategy::default(),
+                hash_key: BalanceHashKey::default(),
+                disable_udp: false,
+                hidden: false,
+                icon: String::new(),
+                name: "GLOBAL".into(),
+                kind: GroupKind::Select,
+                url: String::new(),
+                interval: 0,
+                timeout: 0,
+                lazy: true,
+                expected_status: String::new(),
+                tolerance: 0,
+                max_failed_times: 0,
+                proxies: vec!["DIRECT".into(), "REJECT".into()],
+                default_selected: None,
+            });
         }
-        let (raw_proxy_groups, proxy_group_ids) =
-            normalize_proxy_group_declarations(self.proxy_groups)?;
+        let (mut raw_proxy_groups, proxy_group_ids) =
+            normalize_proxy_group_declarations(raw_groups)?;
         let (proxies, proxy_ids) =
             normalize_proxy_graph_with_groups(self.proxies, &proxy_group_ids)?;
+        // The generated GLOBAL selector lists built-ins, nodes, then declared groups.
+        if generated_global {
+            let last = raw_proxy_groups.len() - 1;
+            let mut members = vec!["DIRECT".into(), "REJECT".into()];
+            members.extend(proxies.iter().map(|proxy| proxy.tag.clone()));
+            members.extend(
+                raw_proxy_groups[..last]
+                    .iter()
+                    .map(|group| group.name.clone()),
+            );
+            raw_proxy_groups[last].proxies = members;
+        }
         let route_targets = collect_route_targets(&proxy_ids, &proxy_group_ids);
         let proxy_groups = normalize_proxy_groups(raw_proxy_groups, &route_targets)?;
         proxy_graph_order(&proxies, &proxy_groups)?;
-        let default_route_target =
-            derive_default_route_target_from_rules(&self.rules, &route_targets)?;
-        let external_controller = normalize_external_controller(
-            self.external_controller,
-            self.secret,
-            tun.enable,
-            !proxy_groups.is_empty(),
-        )?;
+        let unix_path = normalize_controller_unix(self.external_controller_unix)?;
+        let routing_mark = normalize_controller_mark(self.external_controller_routing_mark)?;
+        let mut external_controller =
+            normalize_external_controller(self.external_controller, self.secret.clone())?;
+        let tls_controller =
+            normalize_external_controller(self.external_controller_tls, self.secret.clone())?;
+        if let Some(tls) = tls_controller {
+            let controller = external_controller.get_or_insert_with(|| ExternalControllerConfig {
+                http_enabled: false,
+                ..tls.clone()
+            });
+            controller.tls_listen = Some(tls.listen);
+        }
+        if unix_path.is_some() && external_controller.is_none() {
+            external_controller = Some(ExternalControllerConfig {
+                http_enabled: false,
+                secret: self.secret.filter(|secret| !secret.is_empty()),
+                ..ExternalControllerConfig::default()
+            });
+        }
+        if let Some(controller) = &mut external_controller {
+            controller.unix_path = unix_path;
+            controller.routing_mark = routing_mark;
+            controller.cors = self.external_controller_cors;
+            controller.server_tls = self.tls.server.clone();
+        }
 
         let mut dns = self
             .dns
             .map_or_else(DnsConfig::disabled, |dns| dns.normalize(&route_targets))?;
         dns.ipv6 &= self.ipv6;
-        let rules = normalize_rules(self.rules, &route_targets)?;
+        dns.hosts = dns::normalize_hosts(self.hosts)?;
+        let (rules, sub_rules) =
+            normalize_rule_program(self.rules, self.sub_rules, &route_targets)?;
         drop(proxy_ids);
         drop(route_targets);
 
         let mut inbounds = Vec::with_capacity(2);
         if let Some(port) = mixed_port {
             inbounds.push(InboundConfig::Mixed(MixedInboundConfig {
+                access_rules,
                 tag: "mixed-in".to_owned(),
                 port,
                 access: ProxyAccess {
-                    allow_lan: self.allow_lan,
+                    bind_address,
+                    allow_lan,
                     ipv6: self.ipv6,
                 },
                 auth: authentication,
@@ -1500,10 +2623,29 @@ impl RawVoleConfig {
         }
 
         Ok(Config {
+            egress: EgressOptions::normalize(self.interface, self.routing_mark)?,
+            tls: self.tls,
             ipv6: self.ipv6,
             proxies,
             proxy_groups,
-            default_route_target,
+            mode: self.mode,
+            log_level: self.log_level,
+            global_ua: self.global_ua,
+            etag_support: self.etag_support,
+            unified_delay: self.unified_delay,
+            find_process_mode: self.find_process_mode,
+            connections: ConnectionSettings {
+                dialer_ip4p_convert: self.experimental.dialer_ip4p_convert,
+                quic: QuicSocketSettings {
+                    disable_gso: self.experimental.quic_disable_gso,
+                    disable_ecn: self.experimental.quic_disable_ecn,
+                },
+                tcp_concurrent: self.tcp_concurrent,
+                keep_alive_idle: self.keep_alive_idle,
+                keep_alive_interval: self.keep_alive_interval,
+                disable_keep_alive: self.disable_keep_alive,
+            },
+            profile: self.profile,
             geodata_update,
             external_controller,
             inbounds,
@@ -1512,75 +2654,72 @@ impl RawVoleConfig {
             sniffer,
             dns,
             rules,
+            sub_rules,
+            providers: None,
+            provider_members: HashMap::new(),
         })
     }
 }
 
-fn normalize_external_controller(
+pub(crate) fn normalize_external_controller(
     listen: Option<String>,
     secret: Option<String>,
-    tun_enabled: bool,
-    has_proxy_groups: bool,
 ) -> Result<Option<ExternalControllerConfig>> {
-    let Some(listen) = listen else {
-        if secret.is_some() {
-            return invalid("secret requires external-controller");
-        }
+    let Some(listen) = listen.filter(|listen| !listen.is_empty()) else {
         return Ok(None);
     };
-    if !tun_enabled && !has_proxy_groups {
-        return invalid("external-controller requires tun.enable: true or proxy-groups");
-    }
-    if has_proxy_groups && secret.is_none() {
-        return invalid("secret is required when external-controller manages proxy-groups");
-    }
-    let listen = listen.parse::<SocketAddr>().map_err(|_| {
-        VoleError::InvalidConfig(
-            "external-controller must be an IP socket address with an explicit port".to_owned(),
-        )
-    })?;
-    if !listen.ip().is_loopback() {
-        return invalid("external-controller must listen on a loopback address");
-    }
-    if listen.port() == 0 {
-        return invalid("external-controller port must be between 1 and 65535");
-    }
-    if let Some(secret) = &secret
-        && !(1..=MAX_CONTROLLER_SECRET_BYTES).contains(&secret.len())
-    {
-        return invalid(format!(
-            "secret must contain between 1 and {MAX_CONTROLLER_SECRET_BYTES} UTF-8 bytes"
-        ));
-    }
-    Ok(Some(ExternalControllerConfig { listen, secret }))
+    // Mihomo's tcp preResolve accepts literal IPs, localhost and an empty host
+    // without consulting DNS.
+    let listen = if let Ok(address) = listen.parse::<SocketAddr>() {
+        address
+    } else {
+        let address = listen
+            .strip_prefix("localhost:")
+            .map(|port| (IpAddr::V4(Ipv4Addr::LOCALHOST), port))
+            .or_else(|| {
+                listen
+                    .strip_prefix(':')
+                    .map(|port| (IpAddr::V6(Ipv6Addr::UNSPECIFIED), port))
+            });
+        let Some((host, port)) = address else {
+            return invalid(
+                "external-controller requires an IP, localhost or empty host and a numeric port",
+            );
+        };
+        let port = port.parse::<u16>().map_err(|_| {
+            VoleError::InvalidConfig("external-controller port must be between 0 and 65535".into())
+        })?;
+        SocketAddr::new(host, port)
+    };
+    Ok(Some(ExternalControllerConfig {
+        listen,
+        secret: secret.filter(|secret| !secret.is_empty()),
+        ..ExternalControllerConfig::default()
+    }))
 }
 
 fn normalize_geodata_update(
+    geodata_mode: bool,
     urls: Option<RawGeoDataUrls>,
     auto_update: Option<bool>,
     interval_hours: Option<u64>,
 ) -> Result<Option<GeoDataUpdateConfig>> {
-    match (urls, auto_update, interval_hours) {
-        (None, None, None) => Ok(None),
-        (Some(urls), Some(auto_update), Some(interval_hours)) => {
-            if interval_hours != GEO_UPDATE_INTERVAL_HOURS {
-                return invalid(format!(
-                    "geo-update-interval must be {GEO_UPDATE_INTERVAL_HOURS}"
-                ));
-            }
-            Ok(Some(GeoDataUpdateConfig {
-                urls: GeoDataUrls {
-                    geoip: normalize_geox_url(urls.geoip, "geox-url.geoip")?,
-                    geosite: normalize_geox_url(urls.geosite, "geox-url.geosite")?,
-                },
-                auto_update,
-                interval_hours,
-            }))
-        }
-        _ => invalid(
-            "geox-url, geo-auto-update, and geo-update-interval must be configured together",
-        ),
-    }
+    let urls = urls.unwrap_or_default();
+    let interval_hours = interval_hours.unwrap_or(GEO_UPDATE_INTERVAL_HOURS);
+    if interval_hours.checked_mul(3600).is_none() {
+        return invalid("geo-update-interval is too large");
+    }
+    Ok(Some(GeoDataUpdateConfig {
+        geodata_mode,
+        urls: GeoDataUrls {
+            geoip: normalize_geox_url(urls.geoip, "geox-url.geoip")?,
+            mmdb: normalize_geox_url(urls.mmdb, "geox-url.mmdb")?,
+            geosite: normalize_geox_url(urls.geosite, "geox-url.geosite")?,
+            asn: normalize_geox_url(urls.asn, "geox-url.asn")?,
+        },
+        auto_update: auto_update.unwrap_or(false),
+        interval_hours,
+    }))
 }
 
 fn normalize_geox_url(raw: String, field: &str) -> Result<String> {
@@ -1591,20 +2730,11 @@ fn normalize_geox_url(raw: String, field: &str) -> Result<String> {
     }
     let url = Url::parse(&raw)
         .map_err(|error| VoleError::InvalidConfig(format!("{field} is invalid: {error}")))?;
-    let allowed_scheme = url.scheme() == "https";
-    #[cfg(feature = "benchmark-geodata-http")]
-    let allowed_scheme = allowed_scheme || url.scheme() == "http";
-    if !allowed_scheme {
+    if url.scheme() != "https" {
         return invalid(format!("{field} must use HTTPS"));
     }
-    let authority = raw
-        .split_once("://")
-        .map(|(_, suffix)| suffix)
-        .and_then(|suffix| suffix.split(['/', '?', '#']).next())
-        .unwrap_or_default();
-    if !url.username().is_empty() || url.password().is_some() || authority.contains('@') {
-        return invalid(format!("{field} must not contain credentials"));
-    }
+    crate::resource::http::parse_url(&raw, &Default::default())
+        .map_err(|_| VoleError::InvalidConfig(format!("{field} has invalid URL authentication")))?;
     if !matches!(url.host(), Some(Host::Domain(_))) {
         return invalid(format!("{field} must contain a domain host"));
     }
@@ -1617,35 +2747,35 @@ fn normalize_geox_url(raw: String, field: &str) -> Result<String> {
 impl RawSnifferConfig {
     fn normalize(self) -> Result<SnifferConfig> {
         let sniff = self.sniff.unwrap_or_default();
-        let http = normalize_sniffer_protocol(sniff.http, 80, "HTTP")?;
-        let tls = normalize_sniffer_protocol(sniff.tls, 443, "TLS")?;
-        let quic = normalize_sniffer_protocol(sniff.quic, 443, "QUIC")?;
-
-        if self.enable && http.is_none() && tls.is_none() && quic.is_none() {
-            return invalid(
-                "sniffer.enable: true requires at least one HTTP, TLS, or QUIC sniffer",
-            );
-        }
-
-        let http_ports = http.unwrap_or_default();
-        let tls_ports = tls.unwrap_or_default();
-        let quic_ports = quic.unwrap_or_default();
-        if port_ranges_overlap(&http_ports, &tls_ports) {
-            return invalid("sniffer HTTP and TLS port ranges must not overlap");
-        }
-
+        let override_for = |raw: &Option<Option<RawSniffProtocolConfig>>| {
+            raw.as_ref()
+                .and_then(Option::as_ref)
+                .and_then(|raw| raw.override_destination)
+                .unwrap_or(self.override_destination)
+        };
+        let http_override = override_for(&sniff.http);
+        let tls_override = override_for(&sniff.tls);
+        let quic_override = override_for(&sniff.quic);
         Ok(SnifferConfig {
             enable: self.enable,
-            http_ports,
-            tls_ports,
-            quic_ports,
+            force_dns_mapping: self.force_dns_mapping,
+            parse_pure_ip: self.parse_pure_ip,
+            force_domain: sniffer::domains(self.force_domain)?,
+            skip_domain: sniffer::domains(self.skip_domain)?,
+            skip_src_address: sniffer::addresses(self.skip_src_address)?,
+            skip_dst_address: sniffer::addresses(self.skip_dst_address)?,
+            http_override,
+            tls_override,
+            quic_override,
+            http_ports: normalize_sniffer_protocol(sniff.http, "HTTP")?.unwrap_or_default(),
+            tls_ports: normalize_sniffer_protocol(sniff.tls, "TLS")?.unwrap_or_default(),
+            quic_ports: normalize_sniffer_protocol(sniff.quic, "QUIC")?.unwrap_or_default(),
         })
     }
 }
 
 fn normalize_sniffer_protocol(
     raw: Option<Option<RawSniffProtocolConfig>>,
-    default_port: u16,
     protocol: &str,
 ) -> Result<Option<Box<[PortRange]>>> {
     let Some(raw) = raw else {
@@ -1654,12 +2784,18 @@ fn normalize_sniffer_protocol(
     let raw = raw.unwrap_or_default();
     let ranges = match raw.ports {
         None => vec![PortRange {
-            start: default_port,
-            end: default_port,
+            start: 0,
+            end: u16::MAX,
         }],
         Some(items) => {
             if items.is_empty() {
-                return invalid(format!("sniffer.sniff.{protocol}.ports must not be empty"));
+                return Ok(Some(
+                    vec![PortRange {
+                        start: 0,
+                        end: u16::MAX,
+                    }]
+                    .into_boxed_slice(),
+                ));
             }
             if items.len() > MAX_SNIFFER_PORT_ITEMS {
                 return invalid(format!(
@@ -1725,14 +2861,11 @@ fn parse_sniffer_port_string(value: &str, protocol: &str) -> Result<u16> {
 }
 
 fn parse_sniffer_port_number(value: u64, protocol: &str) -> Result<u16> {
-    u16::try_from(value)
-        .ok()
-        .filter(|port| *port != 0)
-        .ok_or_else(|| {
-            VoleError::InvalidConfig(format!(
-                "sniffer.sniff.{protocol}.ports values must be between 1 and 65535"
-            ))
-        })
+    u16::try_from(value).ok().ok_or_else(|| {
+        VoleError::InvalidConfig(format!(
+            "sniffer.sniff.{protocol}.ports values must be between 1 and 65535"
+        ))
+    })
 }
 
 fn merge_port_ranges(mut ranges: Vec<PortRange>) -> Vec<PortRange> {
@@ -1750,20 +2883,6 @@ fn merge_port_ranges(mut ranges: Vec<PortRange>) -> Vec<PortRange> {
     merged
 }
 
-fn port_ranges_overlap(left: &[PortRange], right: &[PortRange]) -> bool {
-    let (mut left_index, mut right_index) = (0, 0);
-    while let (Some(left), Some(right)) = (left.get(left_index), right.get(right_index)) {
-        if left.end < right.start {
-            left_index += 1;
-        } else if right.end < left.start {
-            right_index += 1;
-        } else {
-            return true;
-        }
-    }
-    false
-}
-
 fn port_ranges_contain(ranges: &[PortRange], port: u16) -> bool {
     ranges
         .binary_search_by(|range| {
@@ -1784,17 +2903,17 @@ fn normalize_proxy_authentication(
     match authentication {
         None => Ok(None),
         Some(entries) if entries.is_empty() => Ok(None),
-        Some(entries) => {
-            let [credential] = entries.as_slice() else {
-                return invalid("authentication must contain exactly one user:password entry");
-            };
-            let (username, password) = credential.split_once(':').ok_or_else(|| {
-                VoleError::InvalidConfig("authentication entry must use user:password".to_owned())
-            })?;
-            ProxyCredentials::new(username, password)
-                .map(Some)
-                .map_err(|error| VoleError::InvalidConfig(error.to_string()))
-        }
+        Some(entries) => entries
+            .into_iter()
+            .map(|credential| {
+                let (username, password) = credential.split_once(':').ok_or_else(|| {
+                    VoleError::InvalidConfig("authentication entry must use user:password".into())
+                })?;
+                ProxyCredentials::new(username, password)
+                    .map_err(|error| VoleError::InvalidConfig(error.to_string()))
+            })
+            .collect::<Result<Vec<_>>>()
+            .map(|values| Some(ProxyCredentials::multiple(values))),
     }
 }
 
@@ -1811,9 +2930,6 @@ fn normalize_proxy_graph_with_groups(
     raw_proxies: Vec<RawOutbound>,
     proxy_group_ids: &HashMap<String, ProxyGroupId>,
 ) -> Result<(Vec<ProxyConfig>, ProxyIdsByTag)> {
-    if raw_proxies.is_empty() {
-        return invalid("proxies must contain at least 1 entry");
-    }
     let pending = raw_proxies
         .into_iter()
         .map(RawOutbound::normalize)
@@ -1839,13 +2955,14 @@ fn normalize_proxy_graph_with_groups(
             proxy
                 .dialer_proxy
                 .as_deref()
+                .filter(|tag| !matches!(*tag, "DIRECT" | "COMPATIBLE"))
                 .map(|tag| {
                     if let Some(id) = proxy_group_ids.get(tag) {
                         return Ok(RouteTargetId::Group(*id));
                     }
                     proxy_ids.get(tag).copied().map(RouteTargetId::Proxy).ok_or_else(|| {
                         VoleError::InvalidConfig(format!(
-                            "proxy `{}` dialer-proxy `{tag}` does not reference a configured proxy or group name",
+                            "proxy `{}` dialer-proxy `{tag}` does not reference DIRECT or a configured proxy or group name",
                             proxy.tag
                         ))
                     })
@@ -1857,6 +2974,11 @@ fn normalize_proxy_graph_with_groups(
         .into_iter()
         .zip(dialer_proxies)
         .map(|(proxy, dialer_proxy)| ProxyConfig {
+            tfo: proxy.tfo,
+            mptcp: proxy.mptcp,
+            egress: proxy.egress,
+            ip_version: proxy.ip_version,
+            smux: proxy.smux,
             tag: proxy.tag,
             dialer_proxy,
             udp: proxy.udp,
@@ -1871,12 +2993,6 @@ fn normalize_proxy_group_declarations(
 ) -> Result<(Vec<RawProxyGroup>, HashMap<String, ProxyGroupId>)> {
     let mut group_ids = HashMap::with_capacity(raw_groups.len());
     for (index, group) in raw_groups.iter().enumerate() {
-        if group.kind != "select" {
-            return invalid(format!(
-                "proxy group `{}` type must be exactly `select`",
-                group.name
-            ));
-        }
         validate_route_target_definition_name(&group.name, "proxy group name")?;
         if group.proxies.is_empty() {
             return invalid(format!(
@@ -1919,27 +3035,29 @@ fn normalize_proxy_groups(
     let groups = raw_groups
         .into_iter()
         .map(|group| {
+            if group.hash_key != BalanceHashKey::Default
+                && (group.kind != GroupKind::LoadBalance || group.strategy == BalanceStrategy::RoundRobin)
+            {
+                return invalid("hash-key requires consistent-hashing or sticky-sessions load-balance");
+            }
             let members = group
                 .proxies
                 .into_iter()
                 .map(|name| {
                     validate_route_target_name(&name, "proxy group member")?;
                     let target = match name.as_str() {
-                        "DIRECT" => ProxyGroupMemberTarget::Direct,
+                        "DIRECT" | "COMPATIBLE" => ProxyGroupMemberTarget::Direct,
                         "REJECT" => ProxyGroupMemberTarget::Reject,
-                        "RULES" => {
-                            return invalid(format!(
-                                "proxy group `{}` cannot use reserved DNS target `RULES` as a member",
-                                group.name
-                            ));
-                        }
+                        "REJECT-DROP" => ProxyGroupMemberTarget::RejectDrop,
+                        "PASS" => ProxyGroupMemberTarget::Control(RuleControl::Pass),
+                        "PASS-RULE" => ProxyGroupMemberTarget::Control(RuleControl::PassRule),
                         _ => route_targets
                             .get(&name)
                             .copied()
                             .map(ProxyGroupMemberTarget::Route)
                             .ok_or_else(|| {
                                 VoleError::InvalidConfig(format!(
-                                    "proxy group `{}` member `{name}` does not reference a configured proxy, proxy group, DIRECT, or REJECT",
+                                    "proxy group `{}` member `{name}` does not reference a configured proxy, proxy group, DIRECT, COMPATIBLE, REJECT, REJECT-DROP, PASS, or PASS-RULE",
                                     group.name
                                 ))
                             })?,
@@ -1947,22 +3065,28 @@ fn normalize_proxy_groups(
                     Ok(ProxyGroupMemberConfig { name, target })
                 })
                 .collect::<Result<Vec<_>>>()?;
-            let initial_member = match group.default_selected {
-                Some(default) => members
-                    .iter()
-                    .position(|member| member.name == default)
-                    .ok_or_else(|| {
-                        VoleError::InvalidConfig(format!(
-                            "proxy group `{}` default-selected `{default}` must name a direct member",
-                            group.name
-                        ))
-                    })?,
-                None => 0,
+            let initial_member = group
+                .default_selected
+                .and_then(|default| members.iter().position(|member| member.name == default))
+                .unwrap_or(0);
+            let health = HealthCheckConfig {
+                enable: true,
+                url: if group.url.is_empty() { "https://www.gstatic.com/generate_204".into() } else { group.url },
+                interval: if group.interval == 0 && group.kind != GroupKind::Select { 300 } else { group.interval },
+                timeout: if group.timeout == 0 { 5000 } else { group.timeout },
+                lazy: group.lazy,
+                expected_status: group.expected_status,
             };
+            health.validate()?;
             Ok(SelectProxyGroupConfig {
+                kind: group.kind, strategy: group.strategy, hash_key: group.hash_key, health, tolerance: group.tolerance,
+                max_failed_times: if group.max_failed_times == 0 { 5 } else { group.max_failed_times },
                 name: group.name,
                 members,
                 initial_member,
+                disable_udp: group.disable_udp,
+                hidden: group.hidden,
+                icon: group.icon,
             })
         })
         .collect::<Result<Vec<_>>>()?;
@@ -2031,12 +3155,21 @@ pub(crate) fn proxy_graph_order(
 
 impl RawOutbound {
     fn normalize(self) -> Result<PendingProxyConfig> {
-        let (tag, dialer_proxy, udp, protocol) = match self {
-            Self::Hysteria2(raw) => raw.normalize()?,
-            Self::Tuic(raw) => raw.normalize()?,
-            Self::Vmess(raw) => raw.normalize()?,
-            Self::Trojan(raw) => raw.normalize()?,
-            Self::Shadowsocks {
+        let (tag, dialer_proxy, udp, protocol) = match self.protocol {
+            RawProtocol::Direct(raw) => raw.normalize(ProxyProtocol::Direct)?,
+            RawProtocol::Dns(raw) => raw.normalize(ProxyProtocol::Dns)?,
+            RawProtocol::Reject(raw) => raw.normalize(ProxyProtocol::Reject)?,
+            RawProtocol::Rematch(raw) => raw.normalize()?,
+            RawProtocol::Masque(raw) => raw.normalize()?,
+            RawProtocol::TrustTunnel(raw) => raw.normalize()?,
+            RawProtocol::Mieru(raw) => raw.normalize()?,
+            RawProtocol::WireGuard(raw) => raw.normalize()?,
+            RawProtocol::Http(raw) => raw.normalize()?,
+            RawProtocol::Hysteria2(raw) => raw.normalize()?,
+            RawProtocol::Tuic(raw) => raw.normalize()?,
+            RawProtocol::Vmess(raw) => raw.normalize()?,
+            RawProtocol::Trojan(raw) => raw.normalize()?,
+            RawProtocol::Shadowsocks {
                 name,
                 server,
                 port,
@@ -2051,7 +3184,8 @@ impl RawOutbound {
                 dialer_proxy,
             } => {
                 let mut config = shadowsocks::normalize(server, port, cipher, password)?;
-                config.shadow_tls = shadowsocks::plugin(plugin, plugin_opts, client_fingerprint)?;
+                config.plugin =
+                    shadowsocks_plugin::normalize(plugin, plugin_opts, client_fingerprint, port)?;
                 if udp_over_tcp && !cfg!(feature = "outbound-shadowsocks") {
                     return invalid("Shadowsocks UoT support is not enabled in this build");
                 }
@@ -2064,54 +3198,135 @@ impl RawOutbound {
                 config.udp_over_tcp = udp_over_tcp;
                 (name, dialer_proxy, udp, ProxyProtocol::Shadowsocks(config))
             }
-            Self::Vless(raw) => raw.normalize()?,
-            Self::Socks5 {
+            RawProtocol::Vless(raw) => raw.normalize()?,
+            RawProtocol::Socks5 {
                 name,
                 server,
                 port,
                 udp,
                 tls,
+                skip_cert_verify,
+                name_cert_verify,
+                fingerprint,
+                certificate,
+                private_key,
                 username,
                 password,
                 dialer_proxy,
-            } => (
-                name,
-                dialer_proxy,
-                udp,
-                ProxyProtocol::Socks5(normalize_socks5(server, port, tls, username, password)?),
-            ),
-            Self::AnyTls {
+            } => {
+                let mut config = normalize_socks5(server, port, username, password)?;
+                if !tls
+                    && (skip_cert_verify.is_some()
+                        || name_cert_verify.is_some()
+                        || fingerprint.is_some()
+                        || certificate.is_some()
+                        || private_key.is_some())
+                {
+                    return invalid("SOCKS5 TLS options require tls: true");
+                }
+                if tls {
+                    config.tls = Some(TlsClientPolicy {
+                        certificate: TlsCertificatePolicy {
+                            skip_cert_verify: skip_cert_verify.unwrap_or(false),
+                            fingerprint: normalize_certificate_fingerprint(fingerprint.as_deref())?,
+                            verification_name: normalize_verification_name(name_cert_verify)?,
+                        },
+                        identity: normalize_client_identity(certificate, private_key)?,
+                        ..Default::default()
+                    });
+                }
+                (name, dialer_proxy, udp, ProxyProtocol::Socks5(config))
+            }
+            RawProtocol::AnyTls {
                 name,
                 server,
                 port,
                 password,
+                idle_session_check_interval,
+                idle_session_timeout,
+                min_idle_session,
+                disable_reuse,
+                client_metadata,
                 udp,
                 sni,
                 alpn,
                 skip_cert_verify,
                 fingerprint,
+                name_cert_verify,
+                certificate,
+                private_key,
                 client_fingerprint,
+                ech_opts,
+                shadow_tls_opts,
+                jls_opts,
                 dialer_proxy,
             } => {
+                let certificate_options = skip_cert_verify.is_some()
+                    || fingerprint.is_some()
+                    || name_cert_verify.is_some()
+                    || certificate.is_some()
+                    || private_key.is_some();
                 let mut config = normalize_anytls(
                     server,
                     port,
                     password,
                     sni,
                     alpn,
-                    skip_cert_verify,
+                    skip_cert_verify.unwrap_or(false),
                     fingerprint,
                 )?;
-                config.tls.client_fingerprint =
-                    parse_client_fingerprint(client_fingerprint.as_deref())?;
+                let SecurityConfig::Tls(mut tls) = config.security else {
+                    unreachable!()
+                };
+                tls.certificate.verification_name = normalize_verification_name(name_cert_verify)?;
+                tls.identity = normalize_client_identity(certificate, private_key)?;
+                tls.client_fingerprint = parse_client_fingerprint(client_fingerprint.as_deref())?;
+                config.session = AnyTlsSessionOptions::normalize(
+                    idle_session_check_interval,
+                    idle_session_timeout,
+                    min_idle_session,
+                    disable_reuse,
+                    client_metadata,
+                )?;
+                tls.ech = ech_opts
+                    .map(|raw| raw.normalize(tls.client_fingerprint.is_some()))
+                    .transpose()?
+                    .flatten();
+                if tls.ech.is_some() && config.server_name.parse::<IpAddr>().is_ok() {
+                    return invalid("AnyTLS ECH requires DNS sni");
+                }
+                config.security = security::RawSecurityModes {
+                    reality: None,
+                    jls: jls_opts,
+                    shadow_tls: shadow_tls_opts,
+                }
+                .normalize(tls, certificate_options)?;
+
                 (name, dialer_proxy, udp, ProxyProtocol::AnyTls(config))
             }
         };
+        let smux = self
+            .smux
+            .map(sing_mux::RawSingMux::normalize)
+            .transpose()?
+            .flatten();
+        if smux.is_some()
+            && matches!(&protocol, ProxyProtocol::Vless(node) if node.flow == "xtls-rprx-vision")
+        {
+            return invalid("VLESS Vision cannot use sing-mux");
+        }
+        let udp = udp || smux.as_ref().is_some_and(|options| !options.only_tcp);
         validate_route_target_definition_name(&tag, "proxy name")?;
+        let dialer_proxy = dialer_proxy.filter(|tag| !tag.is_empty());
         if let Some(dialer_proxy) = &dialer_proxy {
             validate_route_target_name(dialer_proxy, "dialer-proxy")?;
         }
         Ok(PendingProxyConfig {
+            tfo: self.tfo,
+            mptcp: self.mptcp,
+            egress: self.egress,
+            ip_version: self.ip_version,
+            smux,
             tag,
             dialer_proxy,
             udp,
@@ -2157,15 +3372,11 @@ impl RawRealitySettings {
 fn normalize_socks5(
     server: String,
     port: u16,
-    tls: bool,
     username: Option<String>,
     password: Option<String>,
 ) -> Result<Socks5OutboundConfig> {
     validate_host(&server, "SOCKS5 server")?;
     validate_port(port, "SOCKS5")?;
-    if tls {
-        return invalid("SOCKS5 tls must be false");
-    }
     match (&username, &password) {
         (None, None) => {}
         (Some(username), Some(password)) => {
@@ -2186,6 +3397,7 @@ fn normalize_socks5(
         port,
         username,
         password,
+        tls: None,
     })
 }
 
@@ -2205,7 +3417,9 @@ fn normalize_anytls(
             "AnyTLS password must contain between 1 and {MAX_ANYTLS_PASSWORD_BYTES} UTF-8 bytes"
         ));
     }
-    let server_name = sni.unwrap_or_else(|| server.clone());
+    let server_name = sni
+        .filter(|name| !name.is_empty())
+        .unwrap_or_else(|| server.clone());
     validate_host(&server_name, "AnyTLS sni")?;
     let alpn = alpn
         .unwrap_or_default()
@@ -2225,31 +3439,67 @@ fn normalize_anytls(
             "AnyTLS alpn names must be 1..255 bytes and the encoded list at most 65533 bytes",
         );
     }
-    let fingerprint = fingerprint.map(|value| {
-        let hex = value.trim().bytes().filter(|byte| *byte != b':').collect::<Vec<_>>();
-        let mut pin = [0; 32];
-        if hex.len() != 64 || hex.iter().any(|byte| !byte.is_ascii_hexdigit()) {
-            return invalid("AnyTLS fingerprint must be a SHA-256 certificate digest in hex or colon-separated hex");
-        }
-        for (index, pair) in hex.as_chunks::<2>().0.iter().enumerate() {
-            pin[index] = ((pair[0] as char).to_digit(16).unwrap() * 16 + (pair[1] as char).to_digit(16).unwrap()) as u8;
-        }
-        Ok(pin)
-    }).transpose()?;
+    let fingerprint = normalize_certificate_fingerprint(fingerprint.as_deref())?;
     Ok(AnyTlsOutboundConfig {
         address: server,
         port,
         password,
-        server_name,
-        tls: AnyTlsCertificatePolicy {
+        server_name: server_name.clone(),
+        session: AnyTlsSessionOptions::default(),
+        security: SecurityConfig::Tls(TlsConfig {
+            server_name,
+            tls13_only: false,
+            required_alpn: None,
+            ech: None,
+            identity: None,
             client_fingerprint: None,
             alpn,
-            skip_cert_verify,
-            fingerprint,
-        },
+            certificate: TlsCertificatePolicy {
+                skip_cert_verify,
+                fingerprint,
+                ..Default::default()
+            },
+        }),
     })
 }
 
+fn normalize_certificate_fingerprint(fingerprint: Option<&str>) -> Result<Option<[u8; 32]>> {
+    fingerprint
+        .filter(|value| !value.is_empty())
+        .map(vless::parse_pin)
+        .transpose()
+}
+
+fn normalize_verification_name(name: Option<String>) -> Result<Option<String>> {
+    let name = name.filter(|name| !name.is_empty());
+    if let Some(name) = &name {
+        validate_host(name, "TLS certificate verification name")?;
+    }
+    Ok(name)
+}
+
+fn normalize_client_identity(
+    certificate: Option<String>,
+    private_key: Option<String>,
+) -> Result<Option<TlsIdentityPem>> {
+    match (
+        certificate.filter(|pem| !pem.is_empty()),
+        private_key.filter(|pem| !pem.is_empty()),
+    ) {
+        (None, None) => Ok(None),
+        (Some(certificate), Some(private_key)) => {
+            crate::security::TlsClientIdentity::from_pem(&certificate, &private_key)
+                .map_err(|_| VoleError::InvalidConfig("invalid TLS client identity".into()))?;
+            Ok(Some(TlsIdentityPem {
+                certificate,
+                private_key,
+                origin: None,
+            }))
+        }
+        _ => invalid("TLS certificate and private-key must be provided together"),
+    }
+}
+
 impl RawXHttpSettings {
     fn normalize(
         self,
@@ -2266,11 +3516,11 @@ impl RawXHttpSettings {
         let headers = XHttpHeaders::normalize(self.headers.clone())?;
         let has_download = self.download_settings.is_some();
         let mode = match self.mode.as_str() {
-            "auto" if matches!(security, SecurityConfig::Reality(_)) && has_download => {
+            "" | "auto" if matches!(security, SecurityConfig::Reality(_)) && has_download => {
                 XHttpMode::StreamUp
             }
-            "auto" if matches!(security, SecurityConfig::Reality(_)) => XHttpMode::StreamOne,
-            "auto" | "packet-up" => XHttpMode::PacketUp,
+            "" | "auto" if matches!(security, SecurityConfig::Reality(_)) => XHttpMode::StreamOne,
+            "" | "auto" | "packet-up" => XHttpMode::PacketUp,
             "stream-one" if !has_download => XHttpMode::StreamOne,
             "stream-one" => {
                 return invalid("xhttp mode `stream-one` cannot be used with download-settings");
@@ -2291,8 +3541,8 @@ impl RawXHttpSettings {
             ..
         } = self;
         let host = host.filter(|value| !value.is_empty());
-        if path.is_empty()
-            || path.len() > 2_048
+        let path = if path.is_empty() { "/".into() } else { path };
+        if path.len() > 2_048
             || !path.starts_with('/')
             || path.parse::<http::uri::PathAndQuery>().is_err()
         {
@@ -2386,6 +3636,7 @@ impl RawXHttpDownloadSettings {
             private_key,
             reality_opts,
             jls_opts,
+            shadow_tls_opts,
             ech_opts,
             path,
             host,
@@ -2431,6 +3682,7 @@ impl RawXHttpDownloadSettings {
 
         let server_name = servername
             .or_else(|| default_explicit_server_name.map(str::to_owned))
+            .filter(|name| !name.is_empty())
             .unwrap_or_else(|| address.clone());
         validate_host(&server_name, "XHTTP download servername")?;
         let host = host
@@ -2481,6 +3733,7 @@ impl RawXHttpDownloadSettings {
         let mut config = match default_security {
             SecurityConfig::Tls(config) => config.clone(),
             SecurityConfig::Jls(config) => config.tls.clone(),
+            SecurityConfig::ShadowTls(config) => config.tls_config(),
             _ => TlsConfig::xhttp(server_name.clone()),
         };
         config.server_name = server_name;
@@ -2488,8 +3741,13 @@ impl RawXHttpDownloadSettings {
         config.alpn = vec![http_version.alpn().to_vec()];
         config.required_alpn = Some(http_version.alpn().to_vec());
         if let Some(raw) = ech_opts {
-            config.ech = raw.normalize()?;
+            config.ech = raw.normalize(config.client_fingerprint.is_some())?;
         }
+        config.ech = config
+            .ech
+            .as_ref()
+            .map(|ech| ech.for_backend(config.client_fingerprint.is_some()))
+            .transpose()?;
         if config.ech.is_some() && config.server_name.parse::<IpAddr>().is_ok() {
             return invalid("XHTTP download ECH requires a DNS servername");
         }
@@ -2523,6 +3781,7 @@ impl RawXHttpDownloadSettings {
                 config.identity = Some(TlsIdentityPem {
                     certificate,
                     private_key,
+                    origin: None,
                 });
             }
             _ => {
@@ -2543,10 +3802,24 @@ impl RawXHttpDownloadSettings {
                 _ => None,
             },
         };
-        if reality.is_some() && jls.is_some() {
-            return invalid("XHTTP download JLS and REALITY are mutually exclusive");
+        let shadow_tls = match shadow_tls_opts {
+            Some(raw) if raw.is_empty() => None,
+            Some(raw) => Some(raw.normalize(config.clone())?),
+            None => match default_security {
+                SecurityConfig::ShadowTls(config) => Some(config.clone()),
+                _ => None,
+            },
+        };
+        if usize::from(reality.is_some())
+            + usize::from(jls.is_some())
+            + usize::from(shadow_tls.is_some())
+            > 1
+        {
+            return invalid("XHTTP download transport identities are mutually exclusive");
         }
-        if config.ech.is_some() && (reality.is_some() || jls.is_some() || !tls) {
+        if config.ech.is_some()
+            && (reality.is_some() || jls.is_some() || shadow_tls.is_some() || !tls)
+        {
             return invalid(
                 "XHTTP download ECH requires standard TLS; clear inherited ECH before changing security mode",
             );
@@ -2556,6 +3829,9 @@ impl RawXHttpDownloadSettings {
                 "XHTTP download must explicitly clear inherited certificate policy before changing security mode",
             );
         }
+        if tls {
+            validate_tls13_fingerprint(client_fingerprint)?;
+        }
         let security = if let Some(mut reality) = reality {
             if !tls {
                 return invalid("XHTTP download REALITY requires TLS");
@@ -2571,6 +3847,18 @@ impl RawXHttpDownloadSettings {
             jls.tls = config;
             jls.validate()?;
             SecurityConfig::Jls(jls)
+        } else if let Some(mut shadow_tls) = shadow_tls {
+            if !tls {
+                return invalid("XHTTP download ShadowTLS requires TLS");
+            }
+            shadow_tls.server_name = config.server_name;
+            shadow_tls.client_fingerprint = config.client_fingerprint;
+            shadow_tls.alpn = config.alpn;
+            shadow_tls.required_alpn = config.required_alpn;
+            shadow_tls.certificate = config.certificate;
+            shadow_tls.identity = config.identity;
+            shadow_tls.validate()?;
+            SecurityConfig::ShadowTls(shadow_tls)
         } else if tls {
             SecurityConfig::Tls(config)
         } else {
@@ -2580,9 +3868,10 @@ impl RawXHttpDownloadSettings {
             return invalid("XHTTP HTTP/3 download requires standard TLS");
         }
 
-        let path = path.unwrap_or_else(|| default_path.to_owned());
-        if path.is_empty()
-            || path.len() > 2_048
+        let path = path
+            .map(|path| if path.is_empty() { "/".into() } else { path })
+            .unwrap_or_else(|| default_path.to_owned());
+        if path.len() > 2_048
             || !path.starts_with('/')
             || path.parse::<http::uri::PathAndQuery>().is_err()
         {
@@ -2604,385 +3893,159 @@ impl RawXHttpDownloadSettings {
     }
 }
 
-impl DnsConfig {
-    fn disabled() -> Result<Self> {
-        Ok(Self {
-            enable: false,
-            ipv6: true,
-            nameservers: Vec::new(),
-            nameserver_policies: Vec::new(),
-        })
-    }
-}
-
-impl RawDnsConfig {
-    fn normalize(self, route_targets: &RouteTargetsByName) -> Result<DnsConfig> {
-        if !self.enable {
-            if !self.nameserver.is_empty() || !self.nameserver_policies.is_empty() {
-                return invalid(
-                    "dns.nameserver and dns.nameserver-policy must be empty when dns.enable is false",
-                );
-            }
-            return Ok(DnsConfig {
-                enable: false,
-                ipv6: self.ipv6,
-                nameservers: Vec::new(),
-                nameserver_policies: Vec::new(),
-            });
-        }
-
-        if self.nameserver.is_empty() || self.nameserver.len() > MAX_DNS_NAMESERVERS {
-            return invalid(format!(
-                "dns.nameserver must contain between 1 and {MAX_DNS_NAMESERVERS} entries when enabled"
-            ));
-        }
-        let default_route = DnsRoute::Direct;
-        let nameservers = self
-            .nameserver
-            .iter()
-            .map(|nameserver| parse_dns_nameserver(nameserver, route_targets, default_route))
-            .collect::<Result<Vec<_>>>()?;
-        let nameserver_policies = normalize_dns_nameserver_policies(
-            self.nameserver_policies,
-            route_targets,
-            default_route,
-        )?;
-
-        Ok(DnsConfig {
-            enable: true,
-            ipv6: self.ipv6,
-            nameservers,
-            nameserver_policies,
-        })
-    }
-}
-
 fn normalize_dns_nameserver_policies(
     raw_policies: Vec<RawDnsNameserverPolicy>,
     route_targets: &RouteTargetsByName,
-    default_route: DnsRoute,
-) -> Result<Vec<DnsNameserverPolicy>> {
-    let mut normalized = Vec::with_capacity(raw_policies.len());
-    let mut seen_codes = Vec::<String>::new();
-    for raw_policy in raw_policies {
-        let selector = raw_policy
-            .selector
-            .strip_prefix("geosite:")
-            .ok_or_else(|| {
-                VoleError::InvalidConfig(format!(
-                    "invalid dns.nameserver-policy selector `{}`; expected geosite:<code>[,<code>...]",
-                    raw_policy.selector
-                ))
-            })?;
-        if selector.is_empty() {
-            return invalid("dns.nameserver-policy geosite selector must not be empty");
-        }
-
-        let mut geosite_codes = Vec::new();
-        for raw_code in selector.split(',') {
-            if raw_code.is_empty() || trim_ascii_whitespace(raw_code) != raw_code {
-                return invalid(format!(
-                    "invalid dns.nameserver-policy selector `{}`; GeoSite codes must be non-empty and contain no surrounding whitespace",
-                    raw_policy.selector
-                ));
-            }
-            let code = normalize_geo_code(raw_code, "dns.nameserver-policy GeoSite")?;
-            if seen_codes.contains(&code) {
-                return invalid(format!(
-                    "dns.nameserver-policy contains duplicate GeoSite code `{code}`"
-                ));
-            }
-            seen_codes.push(code.clone());
-            geosite_codes.push(code);
-        }
-
-        if raw_policy.nameservers.is_empty() || raw_policy.nameservers.len() > MAX_DNS_NAMESERVERS {
-            return invalid(format!(
-                "dns.nameserver-policy `{}` must contain between 1 and {MAX_DNS_NAMESERVERS} nameservers",
-                raw_policy.selector
-            ));
-        }
-        let nameservers = raw_policy
-            .nameservers
-            .iter()
-            .map(|nameserver| parse_dns_nameserver(nameserver, route_targets, default_route))
-            .collect::<Result<Vec<_>>>()?;
-        normalized.push(DnsNameserverPolicy {
-            geosite_codes: geosite_codes.into_boxed_slice(),
-            nameservers: nameservers.into_boxed_slice(),
-        });
-    }
-    Ok(normalized)
-}
-
-fn parse_dns_nameserver(
-    input: &str,
-    route_targets: &RouteTargetsByName,
-    default_route: DnsRoute,
-) -> Result<DnsNameserver> {
-    let (endpoint, route) = match input.split_once('#') {
-        Some((endpoint, fragment)) => (
-            endpoint,
-            parse_dns_route_fragment(input, fragment, route_targets)?,
-        ),
-        None => (input, default_route),
-    };
-
-    if let Ok(address) = endpoint.parse::<IpAddr>() {
-        return Ok(DnsNameserver {
-            transport: DnsTransport::Udp,
-            address,
-            port: 53,
-            route,
-        });
-    }
-
-    let (transport, endpoint) = if let Some(endpoint) = endpoint.strip_prefix("udp://") {
-        (DnsTransport::Udp, endpoint)
-    } else if let Some(endpoint) = endpoint.strip_prefix("tcp://") {
-        (DnsTransport::Tcp, endpoint)
-    } else {
-        return invalid(format!(
-            "invalid DNS nameserver `{input}`; expected IP, udp://IP[:port], or tcp://IP[:port], optionally followed by a route fragment"
-        ));
-    };
-
-    let (address, port) = parse_dns_endpoint(endpoint).ok_or_else(|| {
-        VoleError::InvalidConfig(format!(
-            "invalid DNS nameserver `{input}`; hostnames and URL paths are not supported"
-        ))
-    })?;
-    validate_port(port, "DNS nameserver")?;
-    Ok(DnsNameserver {
-        transport,
-        address,
-        port,
-        route,
-    })
-}
-
-fn parse_dns_route_fragment(
-    input: &str,
-    fragment: &str,
-    route_targets: &RouteTargetsByName,
-) -> Result<DnsRoute> {
-    if fragment.is_empty() {
-        return invalid(format!(
-            "invalid DNS nameserver `{input}`; route fragment must not be empty"
-        ));
-    }
-    if fragment.contains(['=', '&']) {
-        return invalid(format!(
-            "invalid DNS nameserver `{input}`; route fragment parameters and multiple tokens are not supported"
-        ));
-    }
-    match fragment {
-        "DIRECT" => Ok(DnsRoute::Direct),
-        "RULES" => Ok(DnsRoute::Rules),
-        fragment => route_targets
-            .get(fragment)
-            .copied()
-            .map(DnsRoute::Route)
-            .ok_or_else(|| {
-                VoleError::InvalidConfig(format!(
-                    "invalid DNS nameserver `{input}`; route fragment must be exactly DIRECT, RULES, or a configured proxy or proxy group name"
-                ))
-            }),
-    }
-}
-
-fn parse_dns_endpoint(endpoint: &str) -> Option<(IpAddr, u16)> {
-    if endpoint.is_empty()
-        || endpoint.contains(['/', '?', '#', '@'])
-        || endpoint.as_bytes().contains(&b'%')
-    {
-        return None;
-    }
-    if let Ok(address) = endpoint.parse::<IpAddr>() {
-        return Some((address, 53));
-    }
-    if endpoint.starts_with('[') {
-        let close = endpoint.find(']')?;
-        let address = endpoint.get(1..close)?.parse::<Ipv6Addr>().ok()?;
-        let suffix = endpoint.get(close + 1..)?;
-        let port = if suffix.is_empty() {
-            53
-        } else {
-            suffix.strip_prefix(':')?.parse::<u16>().ok()?
-        };
-        return Some((IpAddr::V6(address), port));
-    }
-    let endpoint = endpoint.parse::<SocketAddr>().ok()?;
-    Some((endpoint.ip(), endpoint.port()))
-}
-
-fn derive_default_route_target_from_rules(
-    rules: &[String],
-    route_targets: &RouteTargetsByName,
-) -> Result<RouteTargetId> {
-    let final_rule = rules.last().ok_or_else(|| {
-        VoleError::InvalidConfig(
-            "rules must end with MATCH targeting an exact proxy or proxy group name".to_owned(),
-        )
-    })?;
-    let fields = final_rule
-        .split(',')
-        .map(trim_ascii_whitespace)
-        .collect::<Vec<_>>();
-    if fields.len() != 2 || !fields[0].eq_ignore_ascii_case("MATCH") {
-        return invalid("rules must end with MATCH targeting an exact proxy or proxy group name");
-    }
-    route_targets.get(fields[1]).copied().ok_or_else(|| {
-        VoleError::InvalidConfig(format!(
-            "final MATCH target must be an exact configured proxy or proxy group name; found `{}`",
-            fields[1]
-        ))
-    })
-}
-
-fn normalize_rules(
-    rules: Vec<String>,
-    route_targets: &RouteTargetsByName,
-) -> Result<Vec<RuleSpec>> {
-    if rules.is_empty() {
-        return invalid("rules must not be empty");
-    }
-    if rules.len() > MAX_RULES {
-        return invalid(format!("rules exceeds the {MAX_RULES}-entry limit"));
-    }
+    default_route: DnsRoute,
+) -> Result<Vec<DnsNameserverPolicy>> {
+    let mut normalized = Vec::with_capacity(raw_policies.len());
+    for raw_policy in raw_policies {
+        let selector = normalize_dns_policy_selector(&raw_policy.selector)?;
 
-    let mut total_bytes = 0_usize;
-    let mut normalized = Vec::with_capacity(rules.len());
-    for rule in rules {
-        if rule.len() > MAX_RULE_BYTES {
-            return invalid(format!(
-                "rule exceeds the {MAX_RULE_BYTES}-byte per-entry limit"
-            ));
-        }
-        total_bytes = total_bytes
-            .checked_add(rule.len())
-            .ok_or_else(|| VoleError::InvalidConfig("rules byte length overflowed".to_owned()))?;
-        if total_bytes > MAX_RULES_TOTAL_BYTES {
+        if raw_policy.nameservers.is_empty() {
             return invalid(format!(
-                "rules exceeds the {MAX_RULES_TOTAL_BYTES}-byte cumulative limit"
+                "dns.nameserver-policy `{}` must contain at least one nameserver",
+                raw_policy.selector
             ));
         }
-        normalized.push(parse_rule(&rule, route_targets)?);
-    }
-
-    let match_count = normalized
-        .iter()
-        .filter(|rule| matches!(rule.kind, RuleKind::Match))
-        .count();
-    if match_count != 1
-        || !matches!(
-            normalized.last().map(|rule| &rule.kind),
-            Some(RuleKind::Match)
-        )
-    {
-        return invalid("explicit rules must contain exactly one MATCH as the final rule");
+        let nameservers = raw_policy
+            .nameservers
+            .iter()
+            .map(|nameserver| parse_dns_nameserver(nameserver, route_targets, default_route))
+            .collect::<Result<Vec<_>>>()?;
+        normalized.push(DnsNameserverPolicy {
+            selector,
+            nameservers: nameservers.into_boxed_slice(),
+        });
     }
     Ok(normalized)
 }
 
-fn parse_rule(input: &str, route_targets: &RouteTargetsByName) -> Result<RuleSpec> {
-    if input.is_empty() {
-        return invalid("rule must not be empty");
-    }
-    let fields = input
-        .split(',')
-        .map(trim_ascii_whitespace)
-        .collect::<Vec<_>>();
-    let rule_type = fields
-        .first()
-        .filter(|field| !field.is_empty())
-        .ok_or_else(|| VoleError::InvalidConfig("rule type must not be empty".to_owned()))?
-        .to_ascii_uppercase();
-
-    match rule_type.as_str() {
-        "MATCH" => {
-            require_rule_field_count(&fields, 2, "MATCH")?;
-            Ok(RuleSpec {
-                kind: RuleKind::Match,
-                action: parse_rule_action(fields[1], route_targets)?,
-                no_resolve: false,
-            })
-        }
-        "DOMAIN" | "DOMAIN-SUFFIX" | "DOMAIN-KEYWORD" | "GEOSITE" | "DST-PORT" | "NETWORK" => {
-            require_rule_field_count(&fields, 3, &rule_type)?;
-            let kind = match rule_type.as_str() {
-                "DOMAIN" => RuleKind::Domain(normalize_rule_domain(fields[1], "DOMAIN")?),
-                "DOMAIN-SUFFIX" => {
-                    RuleKind::DomainSuffix(normalize_rule_domain(fields[1], "DOMAIN-SUFFIX")?)
+fn normalize_dns_policy_selector(input: &str) -> Result<DnsPolicySelector> {
+    let lower = input.to_lowercase();
+    if let Some(selector) = lower.strip_prefix("geosite:") {
+        let codes = selector
+            .split(',')
+            .map(|code| {
+                if code.is_empty() || trim_ascii_whitespace(code) != code {
+                    return invalid("DNS policy GeoSite selectors must be non-empty without surrounding whitespace");
                 }
-                "DOMAIN-KEYWORD" => RuleKind::DomainKeyword(normalize_rule_keyword(fields[1])?),
-                "GEOSITE" => RuleKind::GeoSite(normalize_geo_code(fields[1], "GEOSITE")?),
-                "DST-PORT" => RuleKind::DstPorts(parse_port_ranges(fields[1])?),
-                "NETWORK" => RuleKind::Network(parse_network(fields[1])?),
-                _ => unreachable!("matched rule type"),
-            };
-            Ok(RuleSpec {
-                kind,
-                action: parse_rule_action(fields[2], route_targets)?,
-                no_resolve: false,
+                normalize_geo_code(code, "dns.nameserver-policy GeoSite")
             })
+            .collect::<Result<Vec<_>>>()?;
+        return Ok(DnsPolicySelector::GeoSite(codes.into_boxed_slice()));
+    }
+    if let Some(selector) = input.strip_prefix("rule-set:") {
+        let names = selector.split(',').map(str::to_owned).collect::<Vec<_>>();
+        if names.iter().any(|name| name.is_empty()) {
+            return invalid("DNS policy rule-set requires provider names");
         }
-        "GEOIP" | "IP-CIDR" | "IP-CIDR6" => {
-            if fields.len() != 3 && fields.len() != 4 {
-                return invalid(format!(
-                    "{rule_type} rule must contain 3 fields, or 4 fields with no-resolve"
-                ));
+        return Ok(DnsPolicySelector::RuleSets {
+            names: names.into_boxed_slice(),
+            sets: Vec::new(),
+        });
+    }
+    let domains = lower
+        .split(',')
+        .map(|domain| {
+            if domain.is_empty() || domain.ends_with('.') || domain.trim() != domain {
+                return invalid("invalid DNS policy domain pattern");
             }
-            let kind = match rule_type.as_str() {
-                "GEOIP" => RuleKind::GeoIp(normalize_geo_code(fields[1], "GEOIP")?),
-                "IP-CIDR" => RuleKind::IpCidr(parse_ip_cidr(fields[1], false)?),
-                "IP-CIDR6" => RuleKind::IpCidr(parse_ip_cidr(fields[1], true)?),
-                _ => unreachable!("matched rule type"),
-            };
-            let no_resolve = if fields.len() == 4 {
-                if fields[3] != "no-resolve" {
+            for (index, label) in domain.split('.').enumerate() {
+                if (label.is_empty() && index != 0)
+                    || (label.contains('+') && (index != 0 || label != "+" || domain == "+"))
+                    || (label.contains('*') && label != "*")
+                {
+                    return invalid("invalid DNS policy domain pattern");
+                }
+            }
+            Ok(domain.to_owned())
+        })
+        .collect::<Result<Vec<_>>>()?;
+    Ok(DnsPolicySelector::Domains(domains.into_boxed_slice()))
+}
+
+use dns::parse_dns_nameserver;
+
+fn normalize_rule_program(
+    main: Vec<String>,
+    definitions: std::collections::BTreeMap<String, Vec<String>>,
+    route_targets: &RouteTargetsByName,
+) -> Result<(Vec<RuleSpec>, Vec<NamedRuleProgram>)> {
+    let mut count = main.len();
+    let mut bytes = 0_usize;
+    let mut ids = HashMap::with_capacity(definitions.len());
+    for (index, (name, rules)) in definitions.iter().enumerate() {
+        if name.is_empty() {
+            return invalid("sub-rule name must not be empty");
+        }
+        count = count
+            .checked_add(rules.len())
+            .ok_or_else(|| VoleError::InvalidConfig("rules count overflowed".into()))?;
+        bytes = bytes
+            .checked_add(name.len())
+            .ok_or_else(|| VoleError::InvalidConfig("rules byte length overflowed".into()))?;
+        ids.insert(name.clone(), SubRuleId(index));
+    }
+    if count > MAX_RULES {
+        return invalid(format!("rules exceeds the {MAX_RULES}-entry limit"));
+    }
+    if bytes > MAX_RULES_TOTAL_BYTES {
+        return invalid(format!(
+            "rules exceeds the {MAX_RULES_TOTAL_BYTES}-byte cumulative limit"
+        ));
+    }
+    let mut normalize = |rules: Vec<String>| -> Result<Vec<RuleSpec>> {
+        rules
+            .into_iter()
+            .map(|rule| {
+                if rule.len() > MAX_RULE_BYTES {
                     return invalid(format!(
-                        "{rule_type} fourth field must be exactly `no-resolve`"
+                        "rule exceeds the {MAX_RULE_BYTES}-byte per-entry limit"
                     ));
                 }
-                true
-            } else {
-                false
-            };
-            Ok(RuleSpec {
-                kind,
-                action: parse_rule_action(fields[2], route_targets)?,
-                no_resolve,
+                bytes = bytes.checked_add(rule.len()).ok_or_else(|| {
+                    VoleError::InvalidConfig("rules byte length overflowed".into())
+                })?;
+                if bytes > MAX_RULES_TOTAL_BYTES {
+                    return invalid(format!(
+                        "rules exceeds the {MAX_RULES_TOTAL_BYTES}-byte cumulative limit"
+                    ));
+                }
+                rules::parse_program_rule(&rule, route_targets, &ids)
             })
-        }
-        _ => invalid(format!("unsupported rule type `{}`", fields[0])),
-    }
+            .collect()
+    };
+    let main = normalize(main)?;
+    let sub_rules = definitions
+        .into_iter()
+        .map(|(name, rules)| {
+            Ok(NamedRuleProgram {
+                name,
+                rules: normalize(rules)?,
+            })
+        })
+        .collect::<Result<Vec<_>>>()?;
+    rules::validate_subrule_calls(&main, &sub_rules)?;
+    Ok((main, sub_rules))
 }
 
 fn trim_ascii_whitespace(input: &str) -> &str {
     input.trim_matches(|character: char| character.is_ascii_whitespace())
 }
 
-fn require_rule_field_count(fields: &[&str], expected: usize, rule_type: &str) -> Result<()> {
-    if fields.len() != expected {
-        return invalid(format!(
-            "{rule_type} rule must contain exactly {expected} fields"
-        ));
-    }
-    Ok(())
-}
-
 fn parse_rule_action(action: &str, route_targets: &RouteTargetsByName) -> Result<RuleAction> {
     match action {
-        "DIRECT" => Ok(RuleAction::Direct),
+        "DIRECT" | "COMPATIBLE" => Ok(RuleAction::Direct),
         "REJECT" => Ok(RuleAction::Reject),
+        "REJECT-DROP" => Ok(RuleAction::RejectDrop),
         tag => route_targets
             .get(tag)
             .copied()
             .map(RuleAction::Route)
             .ok_or_else(|| {
                 VoleError::InvalidConfig(format!(
-                    "rule target must be exactly DIRECT, REJECT, or a configured proxy or proxy group name; found `{action}`"
+                    "rule target must be exactly DIRECT, COMPATIBLE, REJECT, REJECT-DROP, or a configured proxy or proxy group name; found `{action}`"
                 ))
             }),
     }
@@ -3058,37 +4121,37 @@ fn parse_ip_cidr(input: &str, require_v6: bool) -> Result<IpCidr> {
 }
 
 fn parse_port_ranges(input: &str) -> Result<Vec<PortRange>> {
-    if input.is_empty() {
-        return invalid("DST-PORT value must not be empty");
-    }
-    input
-        .split('/')
-        .map(|item| {
-            if item.is_empty() {
-                return invalid("DST-PORT contains an empty port range");
-            }
-            let (start, end) = item.split_once('-').unwrap_or((item, item));
-            if end.contains('-') {
-                return invalid("DST-PORT range must contain at most one `-`");
-            }
-            let start = parse_destination_port(start)?;
-            let end = parse_destination_port(end)?;
-            if start > end {
-                return invalid("DST-PORT range start must not exceed its end");
+    let input = input.trim();
+    if input.split('/').count() > 28 {
+        return invalid("port rule exceeds 28 ranges");
+    }
+    let mut ranges = Vec::new();
+    for item in input.split('/').filter(|item| !item.is_empty()) {
+        let item = item.trim();
+        if item.is_empty() {
+            ranges.push(PortRange { start: 0, end: 0 });
+            continue;
+        }
+        let (start, end) = item.split_once('-').unwrap_or((item, item));
+        let parse = |value: &str| -> Result<u16> {
+            let value = value.trim_matches(['[', ']', ' ']);
+            if value.is_empty() || !value.bytes().all(|byte| byte.is_ascii_digit()) {
+                return invalid("invalid rule port");
             }
-            Ok(PortRange { start, end })
-        })
-        .collect()
-}
-
-fn parse_destination_port(input: &str) -> Result<u16> {
-    let port = input
-        .parse::<u16>()
-        .map_err(|_| VoleError::InvalidConfig(format!("invalid destination port `{input}`")))?;
-    if port == 0 {
-        return invalid("destination port must be between 1 and 65535");
+            value
+                .parse()
+                .map_err(|_| VoleError::InvalidConfig("invalid rule port".into()))
+        };
+        let (start, end) = (parse(start)?, parse(end)?);
+        ranges.push(PortRange {
+            start: start.min(end),
+            end: start.max(end),
+        });
     }
-    Ok(port)
+    if ranges.is_empty() {
+        return invalid("port rule requires at least one range");
+    }
+    Ok(ranges)
 }
 
 fn parse_network(input: &str) -> Result<Network> {
@@ -3102,29 +4165,18 @@ fn parse_network(input: &str) -> Result<Network> {
 }
 
 pub(crate) fn validate_route_target_name(name: &str, field: &str) -> Result<()> {
-    let mut characters = name.chars();
-    let first = characters.next();
-    let last = characters.next_back().or(first);
-    if name.is_empty()
-        || name.len() > 64
-        || first.is_some_and(char::is_whitespace)
-        || last.is_some_and(char::is_whitespace)
-        || name.chars().any(|character| {
-            character.is_control()
-                || matches!(character, ',' | '#' | '/' | '?' | '&' | '=' | '%' | '\\')
-        })
-        || matches!(name, "." | "..")
-    {
-        return invalid(format!(
-            "{field} must be 1-64 UTF-8 bytes without surrounding whitespace, control characters, path separators, or reserved delimiters"
-        ));
+    if name.is_empty() {
+        return invalid(format!("{field} must not be empty"));
     }
     Ok(())
 }
 
 fn validate_route_target_definition_name(name: &str, field: &str) -> Result<()> {
     validate_route_target_name(name, field)?;
-    if matches!(name, "DIRECT" | "REJECT" | "RULES") {
+    if matches!(
+        name,
+        "DIRECT" | "REJECT" | "REJECT-DROP" | "COMPATIBLE" | "PASS" | "PASS-RULE"
+    ) {
         return invalid(format!("{field} `{name}` is reserved"));
     }
     Ok(())
@@ -3160,6 +4212,10 @@ fn validate_port(port: u16, kind: &str) -> Result<()> {
     Ok(())
 }
 
+fn parse_client_uuid(input: &str) -> Uuid {
+    Uuid::parse_str(input).unwrap_or_else(|_| Uuid::new_v5(&Uuid::nil(), input.as_bytes()))
+}
+
 fn parse_standard_uuid(input: &str) -> Result<Uuid> {
     let id = Uuid::parse_str(input)
         .map_err(|_| VoleError::InvalidConfig("invalid VLESS settings.id UUID".to_owned()))?;
@@ -3169,102 +4225,6 @@ fn parse_standard_uuid(input: &str) -> Result<Uuid> {
     Ok(id)
 }
 
-fn validate_json_compatible_yaml(value: &YamlValue) -> Result<()> {
-    match value {
-        YamlValue::Null | YamlValue::Bool(_) | YamlValue::Number(_) | YamlValue::String(_) => {
-            Ok(())
-        }
-        YamlValue::Sequence(values) => {
-            for value in values {
-                validate_json_compatible_yaml(value)?;
-            }
-            Ok(())
-        }
-        YamlValue::Mapping(mapping) => {
-            for (key, value) in mapping {
-                let YamlValue::String(key) = key else {
-                    return invalid("YAML map keys must be strings");
-                };
-                if key == "<<" {
-                    return invalid("YAML merge keys are not supported");
-                }
-                validate_json_compatible_yaml(value)?;
-            }
-            Ok(())
-        }
-        YamlValue::Tagged(_) => invalid("custom YAML tags are not supported"),
-    }
-}
-
-/// Anchors and aliases disappear when `serde_yaml_ng` materializes a value, so
-/// reject their node-property syntax before parsing. Quoted text and comments
-/// are intentionally ignored by this small lexical pass.
-fn reject_yaml_anchors_and_aliases(input: &str) -> Result<()> {
-    let bytes = input.as_bytes();
-    let mut index = 0;
-    let mut single_quoted = false;
-    let mut double_quoted = false;
-    let mut comment = false;
-    while index < bytes.len() {
-        let byte = bytes[index];
-        if comment {
-            if byte == b'\n' {
-                comment = false;
-            }
-            index += 1;
-            continue;
-        }
-        if single_quoted {
-            if byte == b'\'' {
-                if bytes.get(index + 1) == Some(&b'\'') {
-                    index += 2;
-                    continue;
-                }
-                single_quoted = false;
-            }
-            index += 1;
-            continue;
-        }
-        if double_quoted {
-            if byte == b'\\' {
-                index = (index + 2).min(bytes.len());
-                continue;
-            }
-            if byte == b'"' {
-                double_quoted = false;
-            }
-            index += 1;
-            continue;
-        }
-
-        match byte {
-            b'#' if index == 0 || bytes[index - 1].is_ascii_whitespace() => comment = true,
-            b'\'' => single_quoted = true,
-            b'"' => double_quoted = true,
-            b'&' | b'*' if is_yaml_node_boundary(bytes, index) => {
-                return invalid("YAML anchors and aliases are not supported");
-            }
-            _ => {}
-        }
-        index += 1;
-    }
-    Ok(())
-}
-
-fn is_yaml_node_boundary(bytes: &[u8], index: usize) -> bool {
-    let previous_is_boundary = index == 0
-        || bytes[index - 1].is_ascii_whitespace()
-        || b"[{,:?-".contains(&bytes[index - 1]);
-    let Some(next) = bytes.get(index + 1) else {
-        return false;
-    };
-    previous_is_boundary
-        && !next.is_ascii_whitespace()
-        && !b"[]{}:,#".contains(next)
-        && *next != b'\n'
-        && *next != b'\r'
-}
-
 fn invalid<T>(message: impl Into<String>) -> Result<T> {
     Err(VoleError::InvalidConfig(message.into()))
 }
@@ -3273,6 +4233,158 @@ fn invalid<T>(message: impl Into<String>) -> Result<T> {
 mod tests {
     use super::*;
 
+    #[test]
+    fn client_uuid_preserves_uuid_bytes_and_maps_named_credentials() {
+        let expected = Uuid::parse_str("00000000-0000-4000-8000-000000000001").unwrap();
+        for input in [
+            "00000000-0000-4000-8000-000000000001",
+            "00000000000040008000000000000001",
+            "{00000000-0000-4000-8000-000000000001}",
+            "urn:uuid:00000000-0000-4000-8000-000000000001",
+        ] {
+            assert_eq!(parse_client_uuid(input), expected);
+        }
+        assert_eq!(
+            parse_client_uuid("synthetic-user").hyphenated().to_string(),
+            "d17c2bfe-ad7e-5a4e-8ea9-f3158f5f8aec"
+        );
+        assert_ne!(
+            parse_client_uuid("synthetic-user"),
+            parse_client_uuid(" synthetic-user")
+        );
+    }
+
+    #[test]
+    fn modes_and_global_group_work_without_a_final_match() {
+        use crate::routing::{RoutingContext, RuleEvaluation, RuleSet};
+        let destination = crate::session::Destination::Ip("192.0.2.1:443".parse().unwrap());
+        let context = RoutingContext::new(Network::Tcp, &destination).unwrap();
+        for mode in ["rule", "DIRECT", "global"] {
+            let mut config = Config::parse_yaml(
+                format!("mixed-port: 1080\nmode: {mode}\nlog-level: Warning\n").as_bytes(),
+            )
+            .unwrap();
+            assert_eq!(config.log_level, LogLevel::Warning);
+            assert_eq!(config.proxy_groups[0].name, "GLOBAL");
+            assert_eq!(config.proxy_groups[0].members[0].name, "DIRECT");
+            let expected = if config.mode == Mode::Global {
+                RuleAction::Route(RouteTargetId::Group(ProxyGroupId::from_index(0)))
+            } else {
+                RuleAction::Direct
+            };
+            let RuleEvaluation::Matched(result) = RuleSet::compile(config.take_runtime_rules())
+                .unwrap()
+                .evaluate(&context)
+            else {
+                panic!("mode must select an action")
+            };
+            assert_eq!(result.action, expected);
+        }
+        let config = Config::parse_yaml(b"mixed-port: 1080\nproxy-groups: [{name: GLOBAL, type: select, proxies: [REJECT, DIRECT]}]\n").unwrap();
+        assert_eq!(config.proxy_groups.len(), 1);
+        assert_eq!(config.proxy_groups[0].members[0].name, "REJECT");
+    }
+
+    #[test]
+    fn ingress_source_params_types_users_ports_and_hash_schema() {
+        let mut config = Config::parse_yaml(
+            br#"
+mixed-port: 1080
+proxy-groups: [{name: pool, type: load-balance, proxies: [DIRECT], hash-key: in-user}]
+rules:
+  - SRC-GEOIP,CN,DIRECT
+  - GEOIP,CN,DIRECT,no-resolve,src
+  - GEOIP,CN,DIRECT,src,no-resolve
+  - IP-CIDR,2001:db8::/32,DIRECT,src
+  - IP-CIDR6,192.0.2.0/24,DIRECT,src
+  - IN-TYPE,HTTP / https / SOCKS / TUN / INNER,DIRECT
+  - IN-USER, Alice / Bob ,DIRECT
+  - IN-PORT,0/1081-1080//65535,DIRECT
+"#,
+        )
+        .unwrap();
+        assert_eq!(config.proxy_groups[0].hash_key, BalanceHashKey::InUser);
+        assert!(config.rules[..5].iter().all(|rule| rule.no_resolve));
+        assert_eq!(config.rules[0].kind, RuleKind::SrcGeoIp("cn".into()));
+        assert_eq!(config.rules[1], config.rules[2]);
+        assert!(matches!(
+            config.rules[3].kind,
+            RuleKind::SrcIpCidr(IpCidr {
+                network: IpAddr::V6(_),
+                ..
+            })
+        ));
+        assert!(matches!(
+            config.rules[4].kind,
+            RuleKind::SrcIpCidr(IpCidr {
+                network: IpAddr::V4(_),
+                ..
+            })
+        ));
+        assert_eq!(
+            config.rules[7].kind,
+            RuleKind::InPorts(vec![
+                PortRange { start: 0, end: 0 },
+                PortRange {
+                    start: 1080,
+                    end: 1081
+                },
+                PortRange {
+                    start: 65535,
+                    end: 65535
+                }
+            ])
+        );
+        crate::routing::RuleSet::compile(config.take_runtime_rules()).unwrap();
+        // Authentication hashing has no meaning for round robin.
+        assert!(Config::parse_yaml(b"mixed-port: 1080\nproxy-groups: [{name: pool, type: load-balance, strategy: round-robin, hash-key: in-user, proxies: [DIRECT]}]").is_err());
+    }
+
+    #[test]
+    fn yaml_templates_feed_logical_domain_and_source_rules() {
+        use crate::routing::{RoutingContext, RuleEvaluation, RuleSet};
+        let yaml = r#"
+mixed-port: 0
+allow-lan: true
+authentication: [user:password]
+tun: {enable: true}
+proxies:
+  - &base {name: "first/#%", type: socks5, server: 192.0.2.1, port: 1080}
+  - {<<: *base, name: second, port: 1081}
+rules:
+  - AND,((DOMAIN-WILDCARD,*.example.com),(SRC-IP-CIDR,10.0.0.0/8),(SRC-PORT,1000-2000),(NOT,((NETWORK,UDP)))),REJECT
+  - 'DOMAIN-REGEX,^a{1,2}\.example\.com$,second'
+"#;
+        let mut config = Config::parse_yaml(yaml.as_bytes()).unwrap();
+        assert_eq!(
+            config.proxies[1].server_endpoint(),
+            Some(("192.0.2.1", 1081))
+        );
+        let rules = RuleSet::compile(config.take_runtime_rules()).unwrap();
+        let destination = crate::session::Destination::domain("AA.example.com", 443).unwrap();
+        let mut context = RoutingContext::new(Network::Tcp, &destination).unwrap();
+        context.set_source("10.1.2.3:1500".parse().unwrap());
+        let RuleEvaluation::Matched(result) = rules.evaluate(&context) else {
+            panic!("rule match")
+        };
+        assert_eq!(result.action, RuleAction::Reject);
+        // A completed flow's budget must not be reused by another source tuple.
+        context.decision().set_deadline(std::time::Instant::now());
+        let mut context = RoutingContext::new(Network::Tcp, &destination).unwrap();
+        context.set_source("192.0.2.2:1500".parse().unwrap());
+        let evaluation = rules.evaluate(&context);
+        let RuleEvaluation::Matched(result) = evaluation else {
+            panic!("regex match: {evaluation:?}")
+        };
+        assert_eq!(
+            result.action,
+            RuleAction::Route(RouteTargetId::Proxy(ProxyId::from_index(1)))
+        );
+        assert!(
+            Config::parse_yaml(b"mixed-port: 1080\nproxies: &recursive [*recursive]\n").is_err()
+        );
+    }
+
     const CURRENT_TLS: &str = r#"mixed-port: 1080
 authentication:
   - measure:secret
@@ -3345,7 +4457,7 @@ proxies:
     fn current_yaml(fields: &str) -> String {
         let default_rules = if fields
             .lines()
-            .any(|line| line.trim_ascii_start() == "rules:")
+            .any(|line| line.trim_ascii_start().starts_with("rules:"))
         {
             ""
         } else {
@@ -3360,7 +4472,7 @@ proxies:
 
     fn with_geodata(fields: &str) -> String {
         current_yaml(&format!(
-            "{fields}\nmixed-port: 1080\nauthentication:\n  - measure:secret"
+            "geodata-mode: true\n{fields}\nmixed-port: 1080\nauthentication:\n  - measure:secret"
         ))
     }
 
@@ -3456,8 +4568,8 @@ proxies:
         assert_eq!(config.proxies[0].tag, "proxy");
         assert!(config.proxies[0].udp);
         assert_eq!(
-            config.default_route_target,
-            RouteTargetId::Proxy(ProxyId::new(0).unwrap())
+            config.rules.last().unwrap().action,
+            RuleAction::Route(RouteTargetId::Proxy(ProxyId::new(0).unwrap()))
         );
         assert_eq!(first_vless(&config).address, "203.0.113.1");
         assert!(matches!(
@@ -3515,31 +4627,42 @@ geo-update-interval: 24"#,
                 .expect("disabled updater remains explicit configuration")
                 .auto_update
         );
-        assert!(
-            Config::parse_yaml(CURRENT_TLS.as_bytes())
-                .unwrap()
-                .geodata_update
-                .is_none()
-        );
+        let defaults = Config::parse_yaml(CURRENT_TLS.as_bytes()).unwrap();
+        assert!(!defaults.geodata_update.unwrap().auto_update);
+        assert!(defaults.etag_support);
     }
 
     #[test]
-    fn geodata_update_fields_are_all_present_or_all_absent() {
-        let urls = "geox-url:\n  geoip: https://geo.example.test/geoip.dat\n  geosite: https://geo.example.test/geosite.dat";
-        for fields in [
-            urls.to_owned(),
-            "geo-auto-update: true".to_owned(),
-            "geo-update-interval: 24".to_owned(),
-            format!("{urls}\ngeo-auto-update: true"),
-            format!("{urls}\ngeo-update-interval: 24"),
-            "geo-auto-update: true\ngeo-update-interval: 24".to_owned(),
-        ] {
-            let error = Config::parse_yaml(with_geodata(&fields).as_bytes()).unwrap_err();
-            assert!(
-                error.to_string().contains("must be configured together"),
-                "{fields}: {error}"
-            );
-        }
+    fn geodata_mode_defaults_to_mmdb_and_urls_remain_independent() {
+        let default = Config::parse_yaml(b"rules: ['GEOIP,CN,DIRECT']").unwrap();
+        let update = default.geodata_update.unwrap();
+        assert!(!update.geodata_mode);
+        assert_eq!(update.urls.mmdb, default_mmdb_url());
+        let explicit = Config::parse_yaml(b"geodata-mode: true\ngeox-url: {mmdb: https://assets.example.test/country}\nrules: ['GEOIP,CN,DIRECT']").unwrap();
+        let update = explicit.geodata_update.unwrap();
+        assert!(update.geodata_mode);
+        assert_eq!(update.urls.mmdb, "https://assets.example.test/country");
+        assert_eq!(update.urls.geoip, default_geoip_url());
+    }
+
+    #[test]
+    fn geodata_fields_have_independent_defaults_and_configurable_intervals() {
+        let config = Config::parse_yaml(with_geodata("geo-auto-update: true\ngeo-update-interval: 6\netag-support: false\nglobal-ua: custom-agent\ngeox-url:\n  geosite: https://rules.example.test/site.dat").as_bytes()).unwrap();
+        assert!(!config.etag_support);
+        assert_eq!(config.global_ua, "custom-agent");
+        let update = config.geodata_update.unwrap();
+        assert!(update.auto_update);
+        assert_eq!(update.interval_hours, 6);
+        assert_eq!(update.urls.geoip, default_geoip_url());
+        assert_eq!(update.urls.geosite, "https://rules.example.test/site.dat");
+        assert_eq!(
+            Config::parse_yaml(with_geodata("geo-update-interval: 0").as_bytes())
+                .unwrap()
+                .geodata_update
+                .unwrap()
+                .interval_hours,
+            0
+        );
     }
 
     #[test]
@@ -3550,11 +4673,6 @@ geo-update-interval: 24"#,
             ))
         };
         for yaml in [
-            complete(
-                "https://geo.example.test/geoip.dat",
-                "https://geo.example.test/geosite.dat",
-                "23",
-            ),
             complete(
                 "https://geo.example.test/geoip.dat",
                 "https://geo.example.test/geosite.dat",
@@ -3576,12 +4694,12 @@ geo-update-interval: 24"#,
                 "24",
             ),
             complete(
-                "https://user:password@geo.example.test/geoip.dat",
+                "https://user%GG:password@geo.example.test/geoip.dat",
                 "https://geo.example.test/geosite.dat",
                 "24",
             ),
             complete(
-                "https://@geo.example.test/geoip.dat",
+                "https://user%3Aname:password@geo.example.test/geoip.dat",
                 "https://geo.example.test/geosite.dat",
                 "24",
             ),
@@ -3612,15 +4730,12 @@ geo-update-interval: 24"#,
     }
 
     #[test]
-    fn geodata_update_http_is_benchmark_only() {
+    fn geodata_update_requires_https() {
         for url in [
             "http://geo.example.test/geoip.dat",
             "http://geo.example.test:8080/geosite.dat",
         ] {
-            assert_eq!(
-                normalize_geox_url(url.to_owned(), "geox-url.geoip").is_ok(),
-                cfg!(feature = "benchmark-geodata-http")
-            );
+            assert!(normalize_geox_url(url.to_owned(), "geox-url.geoip").is_err());
         }
         for url in [
             "http://127.0.0.1/geoip.dat",
@@ -3634,28 +4749,20 @@ geo-update-interval: 24"#,
     }
 
     #[test]
-    fn rejects_incomplete_or_extended_geox_url_maps() {
-        for fields in [
-            r#"geox-url:
-  geoip: https://geo.example.test/geoip.dat
-geo-auto-update: true
-geo-update-interval: 24"#,
-            r#"geox-url:
-  geosite: https://geo.example.test/geosite.dat
-geo-auto-update: true
-geo-update-interval: 24"#,
-            r#"geox-url:
-  geoip: https://geo.example.test/geoip.dat
-  geosite: https://geo.example.test/geosite.dat
-  mmdb: https://geo.example.test/country.mmdb
-geo-auto-update: true
-geo-update-interval: 24"#,
-        ] {
-            assert!(
-                Config::parse_yaml(with_geodata(fields).as_bytes()).is_err(),
-                "{fields}"
-            );
+    fn geodata_url_basic_auth_keeps_validation_and_debug_private() {
+        let yaml = with_geodata(
+            "geox-url: {geoip: 'https://subscriber:password@geo.example.test/private-path?token=private-query'}",
+        );
+        let config = Config::parse_yaml(yaml.as_bytes()).unwrap();
+        let debug = format!("{:?}", config.geodata_update.as_ref().unwrap());
+        for secret in ["subscriber", "password", "private-path", "private-query"] {
+            assert!(!debug.contains(secret));
         }
+        assert!(debug.contains("https://geo.example.test"));
+        let raw: RawGeoDataUrls=serde_yaml_ng::from_str("geoip: 'https://subscriber:password@geo.example.test/private-path?token=private-query'").unwrap();
+        let debug = format!("{raw:?}");
+        assert!(!debug.contains("password"));
+        assert!(!debug.contains("private-query"));
     }
 
     #[test]
@@ -3700,7 +4807,10 @@ geo-update-interval: 24"#,
         assert!(config.sniffer.enable);
         assert_eq!(
             config.sniffer.http_ports.as_ref(),
-            &[PortRange { start: 80, end: 80 }]
+            &[PortRange {
+                start: 0,
+                end: u16::MAX
+            }]
         );
         assert_eq!(
             config.sniffer.tls_ports.as_ref(),
@@ -3716,18 +4826,18 @@ geo-update-interval: 24"#,
             ]
         );
         assert!(config.sniffer.matches_http_port(80));
-        assert!(!config.sniffer.matches_http_port(8080));
+        assert!(config.sniffer.matches_http_port(8080));
         assert!(config.sniffer.matches_tls_port(8445));
         assert!(!config.sniffer.matches_tls_port(8448));
         assert_eq!(
             config.sniffer.quic_ports.as_ref(),
             &[PortRange {
-                start: 443,
-                end: 443
+                start: 0,
+                end: u16::MAX
             }]
         );
         assert!(config.sniffer.matches_quic_port(443));
-        assert!(!config.sniffer.matches_quic_port(8443));
+        assert!(config.sniffer.matches_quic_port(8443));
 
         let http_only =
             Config::parse_yaml(with_sniffer("  enable: true\n  sniff:\n    HTTP: {}").as_bytes())
@@ -3793,21 +4903,13 @@ geo-update-interval: 24"#,
     }
 
     #[test]
-    fn rejects_invalid_sniffer_shapes_ports_and_overlap() {
+    fn rejects_invalid_sniffer_shapes_and_ports() {
         let too_many_ports = (1..=MAX_SNIFFER_PORT_ITEMS + 1)
             .map(|port| port.to_string())
             .collect::<Vec<_>>()
             .join(", ");
         for yaml in [
-            with_sniffer("  enable: true"),
-            with_sniffer("  enable: true\n  sniff: {}"),
-            with_sniffer("  sniff:\n    HTTP: {}"),
             with_sniffer("  enable: \"true\"\n  sniff:\n    HTTP: {}"),
-            CURRENT_TLS.replacen("tun:\n", "sniffer:\ntun:\n", 1),
-            with_sniffer("  enable: true\n  sniff:\n    HTTP:\n      ports: []"),
-            with_sniffer("  enable: true\n  sniff:\n    QUIC:\n      ports: []"),
-            with_sniffer("  enable: true\n  sniff:\n    HTTP:\n      ports: [0]"),
-            with_sniffer("  enable: true\n  sniff:\n    QUIC:\n      ports: [0]"),
             with_sniffer("  enable: true\n  sniff:\n    HTTP:\n      ports: [65536]"),
             with_sniffer("  enable: true\n  sniff:\n    HTTP:\n      ports: [\"\"]"),
             with_sniffer("  enable: true\n  sniff:\n    HTTP:\n      ports: [\"+80\"]"),
@@ -3817,9 +4919,6 @@ geo-update-interval: 24"#,
             with_sniffer("  enable: true\n  sniff:\n    HTTP:\n      ports: [\"443-\"]"),
             with_sniffer("  enable: true\n  sniff:\n    HTTP:\n      ports: [\"444-443\"]"),
             with_sniffer("  enable: true\n  sniff:\n    QUIC:\n      ports: [\"444-443\"]"),
-            with_sniffer(
-                "  enable: true\n  sniff:\n    HTTP:\n      ports: [\"80-90\"]\n    TLS:\n      ports: [90]",
-            ),
             with_sniffer(&format!(
                 "  enable: true\n  sniff:\n    HTTP:\n      ports: [{too_many_ports}]"
             )),
@@ -4076,12 +5175,7 @@ geo-update-interval: 24"#,
 
     #[test]
     fn rejects_unsupported_xhttp_download_fields_fail_closed() {
-        for fields in [
-            "shadow-tls-opts: {}",
-            "restls-opts: {}",
-            "mode: stream-up",
-            "typo: true",
-        ] {
+        for fields in ["restls-opts: {}", "mode: stream-up", "typo: true"] {
             let yaml = with_xhttp_download(CURRENT_TLS, fields);
             let error = Config::parse_yaml(yaml.as_bytes()).unwrap_err();
             assert!(
@@ -4090,7 +5184,7 @@ geo-update-interval: 24"#,
             );
         }
 
-        for unsupported in ["    shadow-tls-opts: {}\n", "    restls-opts: {}\n"] {
+        for unsupported in ["    restls-opts: {}\n"] {
             let yaml = CURRENT_TLS.replace(
                 "    xhttp-opts:\n",
                 &format!("{unsupported}    xhttp-opts:\n"),
@@ -4114,22 +5208,6 @@ geo-update-interval: 24"#,
             ),
             CURRENT_TLS.replace("tun:\n", "tun:\n  typo: true\n"),
             with_sniffer("  enable: true\n  typo: true\n  sniff:\n    HTTP: {}"),
-            with_sniffer("  enable: true\n  override-destination: false\n  sniff:\n    HTTP: {}"),
-            with_sniffer("  enable: true\n  force-dns-mapping: true\n  sniff:\n    HTTP: {}"),
-            with_sniffer("  enable: true\n  parse-pure-ip: true\n  sniff:\n    HTTP: {}"),
-            with_sniffer("  enable: true\n  force-domain: [example.com]\n  sniff:\n    HTTP: {}"),
-            with_sniffer(
-                "  enable: true\n  skip-src-address: [192.0.2.1/32]\n  sniff:\n    HTTP: {}",
-            ),
-            with_sniffer(
-                "  enable: true\n  skip-dst-address: [192.0.2.1/32]\n  sniff:\n    HTTP: {}",
-            ),
-            with_sniffer("  enable: true\n  skip-domain: [example.com]\n  sniff:\n    HTTP: {}"),
-            with_sniffer("  enable: true\n  sniffing: [http]"),
-            with_sniffer("  enable: true\n  port-whitelist: [80]"),
-            with_sniffer("  enable: true\n  sniff:\n    http: {}"),
-            with_sniffer("  enable: true\n  sniff:\n    quic: {}"),
-            with_sniffer("  enable: true\n  sniff:\n    HTTP:\n      override-destination: false"),
             CURRENT_TLS.replace("  - name: proxy\n", "  - typo: true\n    name: proxy\n"),
             CURRENT_TLS.replace("    server: ", "    vnext: []\n    server: "),
             CURRENT_TLS.replace("    network: xhttp", "    typo: true\n    network: xhttp"),
@@ -4175,27 +5253,18 @@ outbounds: []
 
     #[test]
     fn validates_listener_and_tun_constraints() {
-        for yaml in [
-            CURRENT_TLS.replace("mtu: 1500", "mtu: 1279"),
-            CURRENT_TLS.replace(
-                "mixed-port: 1080
-authentication:
-  - measure:secret",
-                "mixed-port: 0
-authentication:
-  - measure:secret",
-            ),
-            CURRENT_TLS
-                .replace("enable: true", "enable: false")
-                .replace(
-                    "mixed-port: 1080
-authentication:
-  - measure:secret\n",
-                    "",
-                ),
-        ] {
-            assert!(Config::parse_yaml(yaml.as_bytes()).is_err(), "{yaml}");
-        }
+        assert!(
+            Config::parse_yaml(CURRENT_TLS.replace("mtu: 1500", "mtu: 1279").as_bytes()).is_err()
+        );
+        let disabled = CURRENT_TLS
+            .replace("enable: true", "enable: false")
+            .replace(
+                "mixed-port: 1080\nauthentication:\n  - measure:secret\n",
+                "",
+            );
+        let config = Config::parse_yaml(disabled.as_bytes()).unwrap();
+        assert!(config.inbounds.is_empty());
+        assert!(!config.tun.enable);
     }
 
     #[test]
@@ -4231,11 +5300,34 @@ tun:
         assert_eq!(controller.listen, "[::1]:19091".parse().unwrap());
         assert!(controller.secret.is_none());
 
+        for (address, expected) in [
+            ("0.0.0.0:9090", "0.0.0.0:9090"),
+            ("[::]:9090", "[::]:9090"),
+            ("192.0.2.1:9090", "192.0.2.1:9090"),
+            ("127.0.0.1:0", "127.0.0.1:0"),
+            ("localhost:0", "127.0.0.1:0"),
+            (":0", "[::]:0"),
+        ] {
+            let fields = format!("external-controller: '{address}'\nsecret: ''");
+            let config = Config::parse_yaml(current_yaml(&fields).as_bytes()).unwrap();
+            let controller = config.external_controller.unwrap();
+            assert_eq!(controller.listen, expected.parse().unwrap());
+            assert!(controller.secret.is_none());
+        }
+        let secret = "s".repeat(crate::inbound::DEFAULT_HEADER_LIMIT + 1);
+        let fields = format!("external-controller: '127.0.0.1:0'\nsecret: '{secret}'");
+        let config = Config::parse_yaml(current_yaml(&fields).as_bytes()).unwrap();
+        assert_eq!(
+            config.external_controller.unwrap().secret.as_deref(),
+            Some(secret.as_str())
+        );
+
         let debug = format!(
             "{:?}",
             ExternalControllerConfig {
                 listen: "127.0.0.1:19090".parse().unwrap(),
                 secret: Some("private-token".to_owned()),
+                ..ExternalControllerConfig::default()
             }
         );
         assert!(debug.contains("authenticated: true"));
@@ -4243,45 +5335,37 @@ tun:
     }
 
     #[test]
-    fn rejects_unsafe_or_misplaced_traffic_controller_config() {
-        for (fields, expected) in [
-            (
-                "mixed-port: 1080\nauthentication:\n  - measure:secret\nsecret: token",
-                "secret requires external-controller",
-            ),
-            (
-                "mixed-port: 1080\nauthentication:\n  - measure:secret\nexternal-controller: \"127.0.0.1:19090\"",
-                "external-controller requires tun.enable",
-            ),
-            (
-                "external-controller: \"0.0.0.0:19090\"\ntun:\n  enable: true",
-                "loopback",
-            ),
-            (
-                "external-controller: \"127.0.0.1:0\"\ntun:\n  enable: true",
-                "between 1 and 65535",
-            ),
-            (
-                "external-controller: localhost:19090\ntun:\n  enable: true",
-                "IP socket address",
-            ),
-            (
-                "external-controller: \"127.0.0.1:19090\"\nsecret: \"\"\ntun:\n  enable: true",
-                "between 1 and 255",
-            ),
+    fn admits_mixed_only_direct_controller() {
+        let config = Config::parse_yaml(
+            b"mixed-port: 1080\nexternal-controller: 127.0.0.1:19090\nrules:\n  - MATCH,DIRECT\n",
+        )
+        .unwrap();
+        assert!(config.external_controller.is_some());
+        assert!(config.proxies.is_empty());
+        for controller in ["", "external-controller: \"\"\n"] {
+            let yaml = format!("{controller}secret: token\nrules: ['MATCH,DIRECT']\n");
+            let disabled = Config::parse_yaml(yaml.as_bytes()).unwrap();
+            assert!(disabled.external_controller.is_none());
+        }
+    }
+
+    #[test]
+    fn rejects_malformed_traffic_controller_addresses() {
+        for address in [
+            "127.0.0.1",
+            "127.0.0.1:65536",
+            "localhost:not-a-port",
+            "controller.example:9090",
+            "::1:9090",
         ] {
-            let error = Config::parse_yaml(current_yaml(fields).as_bytes()).unwrap_err();
+            let fields = format!("external-controller: '{address}'");
+            let error = Config::parse_yaml(current_yaml(&fields).as_bytes()).unwrap_err();
             assert!(
-                error.to_string().contains(expected),
-                "unexpected error for {fields:?}: {error}"
+                error.to_string().contains("external-controller"),
+                "unexpected error for {address:?}: {error}"
             );
         }
 
-        let oversized = current_yaml(&format!(
-            "external-controller: \"127.0.0.1:19090\"\nsecret: \"{}\"\ntun:\n  enable: true",
-            "s".repeat(MAX_CONTROLLER_SECRET_BYTES + 1)
-        ));
-        assert!(Config::parse_yaml(oversized.as_bytes()).is_err());
         assert!(
             Config::parse_yaml(
                 current_yaml("external-controller: null\ntun:\n  enable: true").as_bytes()
@@ -4309,56 +5393,66 @@ authentication:
                 .matches("用户".as_bytes(), "密:码".as_bytes())
         );
 
-        let max_user = "u".repeat(usize::from(u8::MAX));
-        let max_password = "p".repeat(usize::from(u8::MAX));
-        let max = current_yaml(&format!(
-            "mixed-port: 1080\nauthentication:\n  - \"{max_user}:{max_password}\""
-        ));
-        assert!(Config::parse_yaml(max.as_bytes()).is_ok());
-
-        for (fields, expected) in [
-            (
-                "authentication:\n  - measure:secret\ntun:\n  enable: true",
-                "authentication or allow-lan requires an enabled mixed-port",
-            ),
-            (
-                "mixed-port: 1080\nauthentication:\n  - one:secret\n  - two:secret",
-                "authentication must contain exactly one",
-            ),
-            (
-                "mixed-port: 1080\nauthentication:\n  - missing-separator",
-                "authentication entry must use user:password",
-            ),
-            (
-                "mixed-port: 1080\nauthentication:\n  - \":secret\"",
-                "authentication user must contain between 1 and 255",
-            ),
-            (
-                "mixed-port: 1080\nauthentication:\n  - \"measure:\"",
-                "authentication password must contain between 1 and 255",
-            ),
+        for (user, password) in [
+            ("", ""),
+            ("", "secret"),
+            ("user", ""),
+            (&"u".repeat(600), &"p".repeat(600)),
         ] {
-            let error = Config::parse_yaml(current_yaml(fields).as_bytes()).unwrap_err();
+            let config = Config::parse_yaml(
+                current_yaml(&format!(
+                    "mixed-port: 1080\nauthentication: ['{user}:{password}']"
+                ))
+                .as_bytes(),
+            )
+            .unwrap();
+            let [InboundConfig::Mixed(mixed)] = config.inbounds.as_slice() else {
+                panic!("missing mixed inbound");
+            };
             assert!(
-                error.to_string().contains(expected),
-                "unexpected error for {fields:?}: {error}"
+                mixed
+                    .auth
+                    .as_ref()
+                    .unwrap()
+                    .matches(user.as_bytes(), password.as_bytes())
             );
         }
+        let error = Config::parse_yaml(
+            current_yaml("mixed-port: 1080\nauthentication: [missing-separator]").as_bytes(),
+        )
+        .unwrap_err();
+        assert!(
+            error
+                .to_string()
+                .contains("authentication entry must use user:password")
+        );
+        assert!(
+            Config::parse_yaml(
+                current_yaml("mixed-port: 1080\nauthentication: measure:secret").as_bytes()
+            )
+            .is_err()
+        );
+    }
 
-        for yaml in [
-            current_yaml("mixed-port: 1080\nauthentication: null"),
-            current_yaml("mixed-port: 1080\nauthentication: measure:secret"),
-            current_yaml(&format!(
-                "mixed-port: 1080\nauthentication:\n  - \"{}:secret\"",
-                "u".repeat(usize::from(u8::MAX) + 1)
-            )),
-            current_yaml(&format!(
-                "mixed-port: 1080\nauthentication:\n  - \"measure:{}\"",
-                "p".repeat(usize::from(u8::MAX) + 1)
-            )),
-        ] {
-            assert!(Config::parse_yaml(yaml.as_bytes()).is_err(), "{yaml}");
+    #[test]
+    fn mixed_localhost_and_null_inputs_keep_reference_defaults() {
+        for authentication in ["null", "[]"] {
+            let config = Config::parse_yaml(current_yaml(&format!(
+                "mixed-port: 1080\nallow-lan: true\nbind-address: localhost\nauthentication: {authentication}"
+            )).as_bytes()).unwrap();
+            let [InboundConfig::Mixed(mixed)] = config.inbounds.as_slice() else {
+                panic!("missing mixed inbound");
+            };
+            assert!(!mixed.access.allow_lan);
+            assert!(mixed.access.bind_address.is_none());
+            assert!(mixed.auth.is_none());
         }
+        let yaml = with_proxy_groups(
+            "  - name: choice\n    type: select\n    proxies: [DIRECT, proxy]\n    default-selected: null",
+            "rules: ['MATCH,choice']",
+        );
+        let config = Config::parse_yaml(yaml.as_bytes()).unwrap();
+        assert_eq!(config.proxy_groups[0].initial_member, 0);
     }
 
     #[test]
@@ -4433,7 +5527,13 @@ authentication:
             assert!(!mixed.access.allow_lan);
             assert!(mixed.access.ipv6);
         }
-        for fields in ["tun: {enable: true}", "mixed-port: 0\ntun: {enable: true}"] {
+        for fields in [
+            "",
+            "mixed-port: 0",
+            "tun: {enable: false}",
+            "tun: {enable: true}",
+            "mixed-port: 0\ntun: {enable: true}",
+        ] {
             let config = Config::parse_yaml(current_yaml(fields).as_bytes()).unwrap();
             assert_eq!(config.mixed_port, None);
             assert!(
@@ -4453,6 +5553,7 @@ authentication:
         assert_eq!(
             mixed.access,
             ProxyAccess {
+                bind_address: None,
                 allow_lan: true,
                 ipv6: false
             }
@@ -4465,13 +5566,10 @@ authentication:
                 .matches("用户".as_bytes(), "密:码".as_bytes())
         );
         for fields in [
-            "mixed-port: 0",
             "mixed-port: -1",
             "mixed-port: 65536",
             "mixed-port: 1.0",
             "mixed-port: null",
-            "allow-lan: true\ntun: {enable: true}",
-            "mixed-port: 0\nauthentication: [u:p]\ntun: {enable: true}",
             "mixed-port: 1080\nallow-lan: null",
         ] {
             assert!(
@@ -4485,16 +5583,18 @@ authentication:
                 "用".repeat(length),
                 "密".repeat(length)
             ));
-            assert_eq!(Config::parse_yaml(yaml.as_bytes()).is_ok(), length == 85);
+            assert!(Config::parse_yaml(yaml.as_bytes()).is_ok());
         }
     }
 
     #[test]
     fn mixed_inbound_debug_redacts_credentials() {
         let inbound = MixedInboundConfig {
+            access_rules: Default::default(),
             tag: "mixed-in".to_owned(),
             port: 1080,
             access: ProxyAccess {
+                bind_address: None,
                 allow_lan: false,
                 ipv6: true,
             },
@@ -4528,14 +5628,13 @@ authentication:
     fn parses_the_strict_anytls_subset() {
         let config = Config::parse_yaml(CURRENT_ANYTLS.as_bytes()).unwrap();
         assert_eq!(
-            config.default_route_target,
-            RouteTargetId::Proxy(ProxyId::new(0).unwrap())
+            config.rules.last().unwrap().action,
+            RuleAction::Route(RouteTargetId::Proxy(ProxyId::new(0).unwrap()))
         );
         let proxy = &config.proxies[0];
         assert_eq!(proxy.tag, "anytls-node");
         assert!(!proxy.udp);
-        assert_eq!(proxy.address(), "anytls.example.com");
-        assert_eq!(proxy.port(), 443);
+        assert_eq!(proxy.server_endpoint(), Some(("anytls.example.com", 443)));
         let ProxyProtocol::AnyTls(anytls) = &proxy.protocol else {
             panic!("expected AnyTLS proxy");
         };
@@ -4568,8 +5667,8 @@ authentication:
             );
         let config = Config::parse_yaml(yaml.as_bytes()).unwrap();
         assert_eq!(
-            config.default_route_target,
-            RouteTargetId::Proxy(ProxyId::new(1).unwrap())
+            config.rules.last().unwrap().action,
+            RuleAction::Route(RouteTargetId::Proxy(ProxyId::new(1).unwrap()))
         );
         assert_eq!(
             config.proxies[1].dialer_proxy,
@@ -4608,26 +5707,12 @@ authentication:
 
     #[test]
     fn rejects_anytls_fields_outside_the_locked_subset() {
-        for field in [
-            "tls: true",
-            "ech-opts: {}",
-            "certificate: client.crt",
-            "private-key: client.key",
-            "idle-session-check-interval: 30",
-            "idle-session-timeout: 30",
-            "min-idle-session: 1",
-            "disable-reuse: false",
-        ] {
-            let yaml = CURRENT_ANYTLS.replace(
-                "    password: private-anytls-password",
-                &format!("    password: private-anytls-password\n    {field}"),
-            );
-            let error = Config::parse_yaml(yaml.as_bytes()).unwrap_err();
-            assert!(
-                error.to_string().contains("unknown field"),
-                "unexpected error for {field}: {error}"
-            );
-        }
+        let yaml = CURRENT_ANYTLS.replace(
+            "    password: private-anytls-password",
+            "    password: private-anytls-password\n    tls: true",
+        );
+        let error = Config::parse_yaml(yaml.as_bytes()).unwrap_err();
+        assert!(error.to_string().contains("unknown field"));
     }
 
     #[test]
@@ -4638,12 +5723,17 @@ authentication:
                 &format!("    password: private-anytls-password\n    {fields}"),
             )
         };
-        for fields in ["alpn: []", "skip-cert-verify: false"] {
+        for fields in ["alpn: []", "skip-cert-verify: false", "fingerprint: ''"] {
             let config = Config::parse_yaml(configured(fields).as_bytes()).unwrap();
             let ProxyProtocol::AnyTls(anytls) = &config.proxies[0].protocol else {
                 panic!()
             };
-            assert_eq!(anytls.tls, AnyTlsCertificatePolicy::default());
+            let tls = anytls.security.as_tls().unwrap();
+            assert!(tls.alpn.is_empty());
+            assert_eq!(tls.certificate, TlsCertificatePolicy::default());
+            assert!(
+                tls.identity.is_none() && tls.ech.is_none() && tls.client_fingerprint.is_none()
+            );
         }
         let plain = "aB".repeat(32);
         let colon = std::iter::repeat_n("AB", 32).collect::<Vec<_>>().join(":");
@@ -4659,11 +5749,21 @@ authentication:
                 panic!()
             };
             assert_eq!(
-                anytls.tls.alpn,
+                anytls.security.as_tls().unwrap().alpn,
                 [b"h2".to_vec(), b"http/1.1".to_vec(), b"h2".to_vec()]
             );
-            assert!(anytls.tls.skip_cert_verify);
-            assert_eq!(anytls.tls.fingerprint, Some([0xab; 32]));
+            assert!(
+                anytls
+                    .security
+                    .as_tls()
+                    .unwrap()
+                    .certificate
+                    .skip_cert_verify
+            );
+            assert_eq!(
+                anytls.security.as_tls().unwrap().certificate.fingerprint,
+                Some([0xab; 32])
+            );
         }
         for fields in [
             "alpn: null",
@@ -4672,7 +5772,6 @@ authentication:
             "skip-cert-verify: null",
             "skip-cert-verify: 'true'",
             "fingerprint: null",
-            "fingerprint: ''",
             "fingerprint: chrome",
             "fingerprint: aa:bb",
         ] {
@@ -4702,10 +5801,6 @@ authentication:
         for yaml in [
             CURRENT_TLS.replace("server: 203.0.113.1", "server: 'bad host'"),
             CURRENT_TLS.replace("port: 443", "port: 0"),
-            CURRENT_TLS.replace(
-                "uuid: 00000000-0000-4000-8000-000000000001",
-                "uuid: 00000000000040008000000000000001",
-            ),
             CURRENT_TLS.replace("encryption: none", "encryption: auto"),
             CURRENT_TLS.replace("flow: \"\"", "flow: xtls-rprx-vision"),
         ] {
@@ -4776,9 +5871,7 @@ authentication:
         for yaml in [
             CURRENT_TLS.replacen("proxies:\n", "1: value\nproxies:\n", 1),
             CURRENT_TLS.replace("name: proxy", "name: !custom proxy"),
-            CURRENT_TLS.replace("    xhttp-opts:\n", "    xhttp-opts: &defaults\n"),
             CURRENT_TLS.replace("    xhttp-opts:\n", "    xhttp-opts: *defaults\n"),
-            CURRENT_TLS.replacen("proxies:\n", "<<: {}\nproxies:\n", 1),
             CURRENT_TLS.replacen("proxies:\n", "proxies: []\nproxies:\n", 1),
             format!("{CURRENT_TLS}\n---\n{CURRENT_TLS}"),
         ] {
@@ -4833,6 +5926,7 @@ rules:
             [
                 InboundConfig::Mixed(MixedInboundConfig {
                     access: ProxyAccess {
+                        bind_address: None,
                         allow_lan: false,
                         ipv6: true
                     },
@@ -4861,24 +5955,36 @@ rules:
             config.dns.nameservers,
             [
                 DnsNameserver {
+                    path: None,
+                    http_auth: None,
+                    options: Default::default(),
                     transport: DnsTransport::Udp,
                     address: "1.1.1.1".parse().unwrap(),
                     port: 53,
                     route: DnsRoute::Direct,
                 },
                 DnsNameserver {
+                    path: None,
+                    http_auth: None,
+                    options: Default::default(),
                     transport: DnsTransport::Udp,
                     address: "2001:db8::1".parse().unwrap(),
                     port: 5353,
                     route: DnsRoute::Direct,
                 },
                 DnsNameserver {
+                    path: None,
+                    http_auth: None,
+                    options: Default::default(),
                     transport: DnsTransport::Tcp,
                     address: "8.8.8.8".parse().unwrap(),
                     port: 53,
                     route: DnsRoute::Direct,
                 },
                 DnsNameserver {
+                    path: None,
+                    http_auth: None,
+                    options: Default::default(),
                     transport: DnsTransport::Tcp,
                     address: "::1".parse().unwrap(),
                     port: 53,
@@ -4959,6 +6065,14 @@ authentication:
         );
     }
 
+    #[test]
+    fn linux_network_options_keep_borrowed_descriptor_ownership() {
+        let config = Config::parse_yaml(b"tun:\n  enable: true\n  file-descriptor: 9\n  auto-route: false\n  auto-detect-interface: false\n").unwrap();
+        assert_eq!(config.tun.file_descriptor, 9);
+        assert!(!config.tun.auto_route);
+        assert!(!config.tun.auto_detect_interface);
+    }
+
     #[test]
     fn tun_config_uses_mihomo_defaults_and_zero_sentinels() {
         for fields in ["", "  mtu: 0\n  udp-timeout: 0"] {
@@ -4976,6 +6090,54 @@ authentication:
         }
     }
 
+    #[cfg(target_os = "linux")]
+    #[test]
+    fn tun_icmp_options_normalize_and_use_the_existing_reconnect_boundary() {
+        let baseline = Config::parse_yaml(b"tun: {enable: true}").unwrap();
+        assert_eq!(baseline.tun.icmp_timeout, Duration::from_secs(10));
+        assert!(!baseline.tun.disable_icmp_forwarding);
+        for (fields, seconds, disabled, compatible) in [
+            ("icmp-timeout: 0", 10, false, true),
+            ("icmp-timeout: 7", 7, false, false),
+            ("disable-icmp-forwarding: true", 10, true, false),
+        ] {
+            let yaml = format!("tun:\n  enable: true\n  {fields}\n");
+            let config = Config::parse_yaml(yaml.as_bytes()).unwrap();
+            assert_eq!(config.tun.icmp_timeout, Duration::from_secs(seconds));
+            assert_eq!(config.tun.disable_icmp_forwarding, disabled);
+            assert_eq!(
+                live_update::startup_compatible(&baseline, &config),
+                compatible
+            );
+        }
+    }
+
+    #[cfg(target_os = "linux")]
+    #[test]
+    fn tun_icmp_options_reject_negative_and_unrepresentable_timeouts() {
+        for (seconds, reason) in [
+            ("-1", "nonnegative"),
+            ("9223372036854775807", "clock range"),
+            ("9223372036854775808", ""),
+        ] {
+            let yaml = format!("tun:\n  icmp-timeout: {seconds}\n");
+            let error = Config::parse_yaml(yaml.as_bytes()).unwrap_err();
+            if !reason.is_empty() {
+                assert!(error.to_string().contains(reason), "{error}");
+            }
+        }
+    }
+
+    #[cfg(not(target_os = "linux"))]
+    #[test]
+    fn tun_icmp_options_are_unknown_without_the_linux_consumer() {
+        for fields in ["icmp-timeout: 0", "disable-icmp-forwarding: false"] {
+            let yaml = format!("tun:\n  {fields}\n");
+            let error = Config::parse_yaml(yaml.as_bytes()).unwrap_err();
+            assert!(error.to_string().contains("unknown field"), "{error}");
+        }
+    }
+
     #[test]
     fn tun_config_normalizes_config_owned_resources_and_dns_targets() {
         let yaml = current_yaml(
@@ -5009,14 +6171,9 @@ authentication:
             "dns-hijack: [name.example:53]",
             "dns-hijack: null",
             "framing: rawIp",
-            "auto-route: false",
             "auto-redirect: false",
-            "auto-detect-interface: false",
             "stack: mips",
             "inet4-address: [198.18.0.1/30]",
-            "inet6-address: ['fd00::1/126']",
-            "route-address: [0.0.0.0/1]",
-            "strict-route: false",
             "gso: false",
         ] {
             let yaml = current_yaml(&format!("tun:\n  enable: true\n  {fields}"));
@@ -5086,18 +6243,57 @@ authentication:
     }
 
     #[test]
-    fn current_config_requires_listener_rules_and_nonempty_proxies() {
+    fn dns_ipv6_timeout_uses_milliseconds_and_zero_retains_the_default() {
+        for (field, milliseconds) in [
+            ("", 100),
+            ("  ipv6-timeout: 0\n", 100),
+            ("  ipv6-timeout: 37\n", 37),
+        ] {
+            let config = Config::parse_yaml(
+                format!("mixed-port: 1080\ndns:\n  ipv6: true\n{field}").as_bytes(),
+            )
+            .unwrap();
+            assert_eq!(config.dns.ipv6_timeout, Duration::from_millis(milliseconds));
+        }
+        assert!(Config::parse_yaml(b"mixed-port: 1080\ndns:\n  ipv6-timeout: -1\n").is_err());
+    }
+
+    #[test]
+    fn dns_cache_max_size_uses_entries_and_zero_retains_the_default() {
+        for (field, entries) in [
+            ("", 4096),
+            ("  cache-max-size: 0\n", 4096),
+            ("  cache-max-size: 2\n", 2),
+            ("  cache-max-size: 8192\n", 8192),
+        ] {
+            let config =
+                Config::parse_yaml(format!("mixed-port: 1080\ndns:\n{field}").as_bytes()).unwrap();
+            assert_eq!(config.dns.cache_max_size, entries);
+        }
+        assert!(Config::parse_yaml(b"mixed-port: 1080\ndns:\n  cache-max-size: -1\n").is_err());
+    }
+
+    #[test]
+    fn dns_cache_algorithm_activates_arc_only_for_the_exact_name() {
+        for (field, algorithm) in [
+            ("", DnsCacheAlgorithm::Lru),
+            ("  cache-algorithm: lru\n", DnsCacheAlgorithm::Lru),
+            ("  cache-algorithm: arc\n", DnsCacheAlgorithm::Arc),
+            ("  cache-algorithm: ARC\n", DnsCacheAlgorithm::Lru),
+            ("  cache-algorithm: other\n", DnsCacheAlgorithm::Lru),
+        ] {
+            let config =
+                Config::parse_yaml(format!("mixed-port: 1080\ndns:\n{field}").as_bytes()).unwrap();
+            assert_eq!(config.dns.cache_algorithm, algorithm);
+        }
+    }
+
+    #[test]
+    fn current_config_requires_valid_references() {
         for yaml in [
-            current_yaml("mixed-port: 0\nauthentication:\n  - measure:secret"),
-            current_yaml("tun:\n  enable: false"),
             current_yaml("tun:\n  enable: true\n  mtu: 1279"),
             current_yaml(
                 "mixed-port: 1080
-authentication:
-  - measure:secret\nrules: []",
-            ),
-            current_yaml(
-                "mixed-port: 1080
 authentication:
   - measure:secret\ntypo: true",
             ),
@@ -5144,8 +6340,8 @@ authentication:
         let config = Config::parse_yaml(yaml.as_bytes()).unwrap();
         assert_eq!(config.proxies.len(), 2);
         assert_eq!(
-            config.default_route_target,
-            RouteTargetId::Proxy(ProxyId::new(1).unwrap())
+            config.rules.last().unwrap().action,
+            RuleAction::Route(RouteTargetId::Proxy(ProxyId::new(1).unwrap()))
         );
         let ProxyProtocol::Socks5(socks5) = &config.proxies[1].protocol else {
             panic!("expected SOCKS5 proxy");
@@ -5264,12 +6460,6 @@ authentication:
                 "    server: socks.example.com",
                 "    streamSettings: {}\n    server: socks.example.com",
             ),
-            two_proxy_yaml(
-                "mixed-port: 1080
-authentication:
-  - measure:secret",
-            )
-            .replace("    type: socks5", "    type: socks5\n    tls: true"),
         ] {
             assert!(Config::parse_yaml(yaml.as_bytes()).is_err(), "{yaml}");
         }
@@ -5290,12 +6480,27 @@ authentication:
         let config = Config::parse_yaml(yaml.as_bytes()).unwrap();
         let first = ProxyId::new(0).unwrap();
         let second = ProxyId::new(1).unwrap();
-        assert_eq!(config.default_route_target, RouteTargetId::Proxy(second));
+        assert_eq!(
+            config.rules.last().unwrap().action,
+            RuleAction::Route(RouteTargetId::Proxy(second))
+        );
         assert_eq!(
             config.proxies[0].dialer_proxy,
             Some(RouteTargetId::Proxy(second))
         );
         assert_eq!(config.proxies[1].dialer_proxy, None);
+        let direct = Config::parse_yaml(
+            yaml.replace("dialer-proxy: socks-hop", "dialer-proxy: DIRECT")
+                .as_bytes(),
+        )
+        .unwrap();
+        assert_eq!(direct.proxies[0].dialer_proxy, None);
+        let default = Config::parse_yaml(
+            yaml.replace("dialer-proxy: socks-hop", "dialer-proxy: \"\"")
+                .as_bytes(),
+        )
+        .unwrap();
+        assert_eq!(default.proxies[0].dialer_proxy, None);
         assert_eq!(
             config.rules[0].action,
             RuleAction::Route(RouteTargetId::Proxy(first))
@@ -5350,7 +6555,7 @@ rules:
         let main = ProxyGroupId::new(0).unwrap();
         let backup = ProxyGroupId::new(1).unwrap();
 
-        assert_eq!(config.proxy_groups.len(), 2);
+        assert_eq!(config.proxy_groups.len(), 3);
         assert_eq!(config.proxy_groups[0].name, "主线路");
         assert_eq!(config.proxy_groups[0].initial_member, 1);
         assert_eq!(
@@ -5382,7 +6587,10 @@ rules:
                 .collect::<Vec<_>>(),
             ["proxy", "proxy", "DIRECT"]
         );
-        assert_eq!(config.default_route_target, RouteTargetId::Group(main));
+        assert_eq!(
+            config.rules.last().unwrap().action,
+            RuleAction::Route(RouteTargetId::Group(main))
+        );
         assert_eq!(
             config.rules[0].action,
             RuleAction::Route(RouteTargetId::Group(backup))
@@ -5399,29 +6607,14 @@ rules:
             "mixed-port: 1080\nauthentication:\n  - measure:secret\nrules:\n  - MATCH,主线路";
         for groups in [
             r#"  - name: 主线路
-    type: url-test
-    proxies: [proxy]"#,
-            r#"  - name: 主线路
     type: select
     proxies: []"#,
             r#"  - name: 主线路
     type: select
-    proxies: [proxy]
-    default-selected: missing"#,
-            r#"  - name: 主线路
-    type: select
     proxies: [missing]"#,
             r#"  - name: 主线路
     type: select
     proxies: [RULES]"#,
-            r#"  - name: 主线路
-    type: select
-    proxies: [proxy]
-    url: https://example.com"#,
-            r#"  - name: 主线路
-    type: select
-    proxies: [proxy]
-    default-selected: null"#,
         ] {
             let yaml = with_proxy_groups(groups, fields);
             assert!(Config::parse_yaml(yaml.as_bytes()).is_err(), "{yaml}");
@@ -5501,8 +6694,8 @@ rules:
         assert!(Config::parse_yaml(controller.as_bytes()).is_ok());
 
         let missing_secret = controller.replace("secret: token\n", "");
-        let error = Config::parse_yaml(missing_secret.as_bytes()).unwrap_err();
-        assert!(error.to_string().contains("secret is required"), "{error}");
+        let config = Config::parse_yaml(missing_secret.as_bytes()).unwrap();
+        assert!(config.external_controller.unwrap().secret.is_none());
     }
 
     #[test]
@@ -5530,8 +6723,8 @@ proxies:
 
         assert_eq!(config.proxies.len(), 4);
         assert_eq!(
-            config.default_route_target,
-            RouteTargetId::Proxy(ProxyId::from_index(3))
+            config.rules.last().unwrap().action,
+            RuleAction::Route(RouteTargetId::Proxy(ProxyId::from_index(3)))
         );
         assert_eq!(
             config
@@ -5572,8 +6765,8 @@ proxies:
         let config = Config::parse_yaml(yaml.as_bytes()).unwrap();
         assert_eq!(config.proxies.len(), 300);
         assert_eq!(
-            config.default_route_target,
-            RouteTargetId::Proxy(ProxyId::from_index(299))
+            config.rules.last().unwrap().action,
+            RuleAction::Route(RouteTargetId::Proxy(ProxyId::from_index(299)))
         );
         assert_eq!(
             config.proxies[299].dialer_proxy,
@@ -5601,32 +6794,28 @@ proxies:
         for tag in [
             "DIRECT",
             "REJECT",
-            "RULES",
-            "edge,one",
-            "edge#one",
-            "edge/one",
-            "edge?one",
-            "edge&one",
-            "edge=one",
-            "edge%one",
-            "edge\\one",
-            ".",
-            "..",
-            " edge",
-            "edge ",
+            "REJECT-DROP",
+            "COMPATIBLE",
+            "PASS",
+            "PASS-RULE",
         ] {
             let yaml = CURRENT_TLS.replace("name: proxy", &format!("name: '{tag}'"));
-            assert!(Config::parse_yaml(yaml.as_bytes()).is_err(), "{yaml}");
+            assert!(Config::parse_yaml(yaml.as_bytes()).is_err());
         }
-        for tag in ["PROXY", "-edge", "节点", "♻️ 自动选择", "+"] {
+        for tag in [
+            "RULES", "edge,one", "edge#one", "edge/one", "edge?one", "edge%one", ".", "..",
+            " edge", "edge ",
+        ] {
             let yaml = CURRENT_TLS
                 .replace("name: proxy", &format!("name: '{tag}'"))
-                .replace("MATCH,proxy", &format!("MATCH,{tag}"));
-            assert!(Config::parse_yaml(yaml.as_bytes()).is_ok(), "{yaml}");
+                .replace("MATCH,proxy", "MATCH,DIRECT");
+            assert!(Config::parse_yaml(yaml.as_bytes()).is_ok(), "{tag}");
         }
-        let long_tag = "a".repeat(65);
-        let yaml = CURRENT_TLS.replace("name: proxy", &format!("name: {long_tag}"));
-        assert!(Config::parse_yaml(yaml.as_bytes()).is_err());
+        let tag = "a".repeat(256);
+        let yaml = CURRENT_TLS
+            .replace("name: proxy", &format!("name: '{tag}'"))
+            .replace("MATCH,proxy", &format!("MATCH,{tag}"));
+        assert!(Config::parse_yaml(yaml.as_bytes()).is_ok());
 
         let duplicate = two_proxy_yaml(
             "mixed-port: 1080
@@ -5648,7 +6837,7 @@ authentication:
         );
         assert!(Config::parse_yaml(unknown.as_bytes()).is_err());
 
-        for invalid_reference in ["''", "null", "'bad#name'"] {
+        for invalid_reference in ["null", "'bad#name'"] {
             let yaml = two_proxy_yaml(
                 "mixed-port: 1080
 authentication:
@@ -5748,49 +6937,102 @@ authentication:
     }
 
     #[test]
-    fn current_config_validates_dns_schema_and_fixed_ip_nameservers() {
-        let valid = current_yaml(
-            r#"mixed-port: 1080
-authentication:
-  - measure:secret
-dns:
-  enable: true
-  nameserver: [udp://1.1.1.1:53]"#,
+    fn current_config_validates_dns_upstreams_and_roles() {
+        let config = Config::parse_yaml(b"mixed-port: 1080\ndns: {enable: true}\n").unwrap();
+        assert!(!config.dns.ipv6);
+        assert_eq!(config.dns.nameservers[0].transport, DnsTransport::Https);
+        assert_eq!(
+            config.dns.nameservers[1].address,
+            DnsAddress::Ip("223.5.5.5".parse().unwrap())
+        );
+        for dns in [
+            "{enable: true, nameserver: []}",
+            "{default-nameserver: [dns.example]}",
+            "{nameserver: ['tls://1.1.1.1:0']}",
+            "{respect-rules: true}",
+        ] {
+            assert!(
+                Config::parse_yaml(format!("mixed-port: 1080\ndns: {dns}\n").as_bytes()).is_err()
+            );
+        }
+        let config = Config::parse_yaml(b"mixed-port: 1080\ndns: {enable: false, nameserver: ['udp://dns.example', 'https://dns.example/query'], enhanced-mode: redir-host}\n").unwrap();
+        assert!(!config.dns.enable);
+    }
+
+    #[test]
+    fn dns_source_aliases_preserve_mihomo_roles_and_bootstrap_rules() {
+        for alias in ["system", "system://", "dhcp://system"] {
+            let yaml = format!(
+                "mixed-port: 1080\ndns:\n  enable: true\n  default-nameserver: ['{alias}']\n  nameserver: ['{alias}#unknown']\n  fallback: ['{alias}']\n  proxy-server-nameserver: ['{alias}']\n  direct-nameserver: ['{alias}']\n  nameserver-policy: {{example.com: '{alias}'}}\n"
+            );
+            let config = Config::parse_yaml(yaml.as_bytes()).unwrap();
+            for server in config
+                .dns
+                .default_nameservers
+                .iter()
+                .chain(&config.dns.nameservers)
+                .chain(&config.dns.fallback.nameservers)
+                .chain(&config.dns.proxy_nameservers)
+                .chain(&config.dns.direct_nameservers)
+                .chain(config.dns.nameserver_policies[0].nameservers.iter())
+            {
+                assert_eq!(server.address, DnsAddress::Source(DnsSource::System));
+                assert_eq!(server.route, DnsRoute::Direct);
+            }
+        }
+        let parsed = Config::parse_yaml(
+            b"mixed-port: 1080\ndns: {nameserver: ['dhcp://physical0#unknown']}\n",
+        )
+        .unwrap();
+        assert_eq!(
+            parsed.dns.nameservers[0].address,
+            DnsAddress::Source(DnsSource::Dhcp("physical0".into()))
         );
-        let config = Config::parse_yaml(valid.as_bytes()).unwrap();
-        let dns = &config.dns;
-        assert!(dns.ipv6);
-        assert_eq!(dns.nameservers[0].route, DnsRoute::Direct);
+        for invalid in ["dhcp://", "dhcp://physical0/", "system://physical0"] {
+            let yaml = format!("mixed-port: 1080\ndns: {{nameserver: ['{invalid}']}}\n");
+            assert!(Config::parse_yaml(yaml.as_bytes()).is_err());
+        }
+        assert!(
+            Config::parse_yaml(
+                b"mixed-port: 1080\ndns: {default-nameserver: ['dhcp://physical0']}\n"
+            )
+            .is_err()
+        );
+    }
 
-        for fields in [
-            "mixed-port: 1080
-authentication:
-  - measure:secret\ndns:\n  nameserver: []",
-            "mixed-port: 1080
-authentication:
-  - measure:secret\ndns:\n  enable: true\n  nameserver: []",
-            "mixed-port: 1080
-authentication:
-  - measure:secret\ndns:\n  enable: false\n  nameserver: [1.1.1.1]",
-            "mixed-port: 1080
-authentication:
-  - measure:secret\ndns:\n  enable: true\n  enhanced-mode: fake-ip\n  nameserver: [1.1.1.1]",
-            "mixed-port: 1080
-authentication:
-  - measure:secret\ndns:\n  enable: true\n  nameserver: [udp://dns.example:53]",
-            "mixed-port: 1080
-authentication:
-  - measure:secret\ndns:\n  enable: true\n  nameserver: [https://1.1.1.1/dns-query]",
-            "mixed-port: 1080
-authentication:
-  - measure:secret\ndns:\n  enable: true\n  nameserver: [tcp://1.1.1.1:0]",
-            "mixed-port: 1080
-authentication:
-  - measure:secret\ndns:\n  enable: true\n  nameserver: [1.1.1.1, 8.8.8.8, 9.9.9.9, 4.4.4.4, 208.67.222.222]",
+    #[test]
+    fn dns_rcode_nameserver_uses_the_mihomo_names_and_existing_policy_schema() {
+        for (name, rcode) in [
+            ("success", 0),
+            ("format_error", 1),
+            ("server_failure", 2),
+            ("name_error", 3),
+            ("not_implemented", 4),
+            ("refused", 5),
         ] {
-            let yaml = current_yaml(fields);
-            assert!(Config::parse_yaml(yaml.as_bytes()).is_err(), "{yaml}");
+            let yaml = format!(
+                "mixed-port: 1080\ndns:\n  enable: true\n  nameserver: [rcode://{name}]\n  nameserver-policy:\n    example.com: rcode://{name}\n"
+            );
+            let config = Config::parse_yaml(yaml.as_bytes()).unwrap();
+            assert_eq!(
+                config.dns.nameservers[0].transport,
+                DnsTransport::Rcode(rcode)
+            );
+            assert_eq!(
+                config.dns.nameserver_policies[0].nameservers[0].transport,
+                DnsTransport::Rcode(rcode)
+            );
         }
+        for endpoint in ["rcode://NXDOMAIN", "rcode://6", "rcode://success:53"] {
+            let yaml = format!("mixed-port: 1080\ndns:\n  nameserver: [{endpoint}]\n");
+            assert!(Config::parse_yaml(yaml.as_bytes()).is_err());
+        }
+        assert!(
+            Config::parse_yaml(
+                b"mixed-port: 1080\ndns:\n  default-nameserver: [rcode://success]\n"
+            )
+            .is_err()
+        );
     }
 
     #[test]
@@ -5827,7 +7069,12 @@ dns:
 authentication:
   - measure:secret\ndns:\n  enable: true\n  nameserver: [udp://1.1.1.1:53#PROXY]",
         );
-        assert!(Config::parse_yaml(yaml.as_bytes()).is_err());
+        let config = Config::parse_yaml(yaml.as_bytes()).unwrap();
+        assert_eq!(config.dns.nameservers[0].route, DnsRoute::Direct);
+        assert_eq!(
+            config.dns.nameservers[0].options.interface.as_deref(),
+            Some("PROXY")
+        );
 
         let yaml = current_yaml(
             "mixed-port: 1080
@@ -5841,6 +7088,7 @@ authentication:
             config.dns.nameservers[0].route,
             DnsRoute::Route(RouteTargetId::Proxy(ProxyId::new(0).unwrap()))
         );
+        assert!(config.dns.nameservers[0].options.interface.is_none());
 
         let yaml = two_proxy_yaml(
             "mixed-port: 1080
@@ -5863,6 +7111,39 @@ authentication:
         );
     }
 
+    #[test]
+    fn accepts_builtin_final_actions_without_static_proxies() {
+        for proxies in ["", "proxies: []\n"] {
+            for (target, action) in [
+                ("DIRECT", RuleAction::Direct),
+                ("REJECT", RuleAction::Reject),
+            ] {
+                let yaml = format!("mixed-port: 1080\n{proxies}rules: ['MATCH,{target}']\n");
+                let config = Config::parse_yaml(yaml.as_bytes()).unwrap();
+                assert!(config.proxies.is_empty());
+                assert_eq!(config.rules.last().unwrap().action, action);
+                assert_eq!(config.rules[0].action, action);
+            }
+        }
+        let config = Config::parse_yaml(b"mixed-port: 1080\nproxy-groups:\n  - name: local\n    type: select\n    proxies: [DIRECT, REJECT]\nrules: ['MATCH,local']\n").unwrap();
+        assert!(config.proxies.is_empty());
+        assert_eq!(
+            config.proxy_groups[0].members[0].target,
+            ProxyGroupMemberTarget::Direct
+        );
+    }
+
+    #[test]
+    fn rejects_deprecated_fallback_filter_geosite() {
+        for enable in [false, true] {
+            let yaml = format!(
+                "rules: ['MATCH,DIRECT']\ndns:\n  enable: {enable}\n  fallback-filter:\n    geosite: []\n"
+            );
+            let error = Config::parse_yaml(yaml.as_bytes()).unwrap_err();
+            assert!(error.to_string().contains("geosite"), "{error}");
+        }
+    }
+
     #[test]
     fn current_config_parses_ordered_geosite_nameserver_policies() {
         let yaml = current_yaml(
@@ -5883,20 +7164,23 @@ dns:
         let dns = config.dns;
         assert_eq!(
             dns.nameservers[0].route,
-            DnsRoute::Route(config.default_route_target)
+            DnsRoute::Route(RouteTargetId::Proxy(ProxyId::new(0).unwrap()))
         );
         assert_eq!(dns.nameserver_policies.len(), 2);
-        assert_eq!(&*dns.nameserver_policies[0].geosite_codes, ["apple", "cn"]);
+        assert_eq!(dns.nameserver_policies[0].geosite_codes(), ["apple", "cn"]);
         assert_eq!(
             dns.nameserver_policies[0].nameservers.as_ref(),
             [DnsNameserver {
+                path: None,
+                http_auth: None,
+                options: Default::default(),
                 transport: DnsTransport::Tcp,
                 address: "223.5.5.5".parse().unwrap(),
                 port: 53,
                 route: DnsRoute::Direct,
             }]
         );
-        assert_eq!(&*dns.nameserver_policies[1].geosite_codes, ["private"]);
+        assert_eq!(dns.nameserver_policies[1].geosite_codes(), ["private"]);
         assert_eq!(
             dns.nameserver_policies[1]
                 .nameservers
@@ -5939,7 +7223,7 @@ rules:
         assert_eq!(config.rules[2].kind, RuleKind::GeoIp("!cn".to_owned()));
         assert!(config.rules[2].no_resolve);
         assert_eq!(
-            &*config.dns.nameserver_policies[0].geosite_codes,
+            config.dns.nameserver_policies[0].geosite_codes(),
             ["google@ads@cn", "!google@ads"]
         );
     }
@@ -5947,15 +7231,19 @@ rules:
     #[test]
     fn current_config_strictly_validates_nameserver_policy_schema_and_limits() {
         for policy in [
-            r#"    "geosite:cn": "tcp://223.5.5.5""#,
-            r#"    "geoip:cn": ["tcp://223.5.5.5"]"#,
-            r#"    "GEOSITE:cn": ["tcp://223.5.5.5"]"#,
+            r#"    "rule-set:cn": ["tcp://223.5.5.5"]"#,
+            r#"    "example.com": null"#,
+            r#"    "example.com": {server: 1.1.1.1}"#,
+            r#"    "example.com": [false]"#,
+            r#"    "foo..example": "1.1.1.1""#,
+            r#"    "foo.*bar.example": "1.1.1.1""#,
+            r#"    "foo.+.example": "1.1.1.1""#,
+            r#"    "example.com.": "1.1.1.1""#,
+            r#"    "example.com,": "1.1.1.1""#,
             r#"    "geosite:": ["tcp://223.5.5.5"]"#,
             r#"    "geosite:cn,": ["tcp://223.5.5.5"]"#,
             r#"    "geosite:cn, apple": ["tcp://223.5.5.5"]"#,
             r#"    "geosite:cn": []"#,
-            r#"    "geosite:cn": [1.1.1.1, 8.8.8.8, 9.9.9.9, 4.4.4.4, 223.5.5.5]"#,
-            r#"    "geosite:cn": ["tcp://dns.example"]"#,
         ] {
             let yaml = current_yaml(&format!(
                 "mixed-port: 1080
@@ -5976,7 +7264,14 @@ dns:
     "geosite:CN": ["tcp://223.5.5.5"]
     "geosite:cn": ["tcp://8.8.8.8"]"#,
         );
-        assert!(Config::parse_yaml(duplicate.as_bytes()).is_err());
+        assert_eq!(
+            Config::parse_yaml(duplicate.as_bytes())
+                .unwrap()
+                .dns
+                .nameserver_policies
+                .len(),
+            2
+        );
 
         let many_codes = (0..=16)
             .map(|index| format!("code{index}"))
@@ -5992,7 +7287,7 @@ authentication:
                 .unwrap()
                 .dns
                 .nameserver_policies[0]
-                .geosite_codes
+                .geosite_codes()
                 .len(),
             17
         );
@@ -6024,7 +7319,7 @@ dns:
   nameserver-policy:
     "geosite:cn": ["tcp://223.5.5.5"]"#,
         );
-        assert!(Config::parse_yaml(disabled.as_bytes()).is_err());
+        assert!(Config::parse_yaml(disabled.as_bytes()).is_ok());
 
         let missing_main = current_yaml(
             r#"mixed-port: 1080
@@ -6035,18 +7330,14 @@ dns:
   nameserver-policy:
     "geosite:cn": ["tcp://223.5.5.5"]"#,
         );
-        assert!(Config::parse_yaml(missing_main.as_bytes()).is_err());
+        assert!(Config::parse_yaml(missing_main.as_bytes()).is_ok());
     }
 
     #[test]
     fn current_config_strictly_rejects_invalid_dns_route_fragments() {
         for nameserver in [
-            "udp://1.1.1.1:53#",
-            "udp://1.1.1.1:53#direct",
-            "udp://1.1.1.1:53#unknown",
-            "udp://1.1.1.1:53#DIRECT&RULES",
-            "udp://1.1.1.1:53#h3=true",
-            "udp://1.1.1.1:53#DIRECT#RULES",
+            "udp://1.1.1.1:53#bad%00interface",
+            "udp://1.1.1.1:53#unknown-option=true",
         ] {
             let yaml = current_yaml(&format!(
                 "mixed-port: 1080
@@ -6074,12 +7365,6 @@ authentication:
 authentication:
   - measure:secret\ndns:\n  enable: true\n  enhanced-mode: normal\n  nameserver: [1.1.1.1]",
             "mixed-port: 1080
-authentication:
-  - measure:secret\ndns:\n  enable: true\n  enhanced-mode: redir-host\n  nameserver: [1.1.1.1]",
-            "mixed-port: 1080
-authentication:
-  - measure:secret\ndns:\n  enable: true\n  respect-rules: false\n  nameserver: [1.1.1.1]",
-            "mixed-port: 1080
 authentication:
   - measure:secret\ndns:\n  enable: true\n  respect-rules: true\n  nameserver: [1.1.1.1]",
             "mixed-port: 1080
@@ -6101,15 +7386,10 @@ authentication:
             "  - GEOIP,CN@ads,DIRECT\n  - MATCH,proxy",
             "  - GEOSITE,!,DIRECT\n  - MATCH,proxy",
             "  - GEOSITE,@ads,DIRECT\n  - MATCH,proxy",
-            "  - IP-CIDR,2001:db8::/32,DIRECT\n  - MATCH,proxy",
-            "  - IP-CIDR6,192.0.2.0/24,DIRECT\n  - MATCH,proxy",
             "  - IP-CIDR,192.0.2.0/33,DIRECT\n  - MATCH,proxy",
-            "  - DST-PORT,0,REJECT\n  - MATCH,proxy",
-            "  - DST-PORT,100-10,REJECT\n  - MATCH,proxy",
             "  - NETWORK,ICMP,REJECT\n  - MATCH,proxy",
             "  - MATCH,PROXY\n  - DOMAIN,example.com,DIRECT",
             "  - MATCH,PROXY\n  - MATCH,DIRECT",
-            "  - DOMAIN,example.com,DIRECT",
         ] {
             let yaml = current_yaml(&format!(
                 "mixed-port: 1080
@@ -6124,7 +7404,7 @@ authentication:
 authentication:
   - measure:secret\nrules: []",
         );
-        assert!(Config::parse_yaml(explicit_empty.as_bytes()).is_err());
+        assert!(Config::parse_yaml(explicit_empty.as_bytes()).is_ok());
 
         let non_ascii_whitespace = current_yaml(
             "mixed-port: 1080
@@ -6163,7 +7443,33 @@ authentication:
 authentication:
   - measure:secret\nrules:\n{many_rules}  - MATCH,proxy"
         ));
-        let error = Config::parse_yaml(yaml.as_bytes()).unwrap_err();
-        assert!(error.to_string().contains("cumulative limit"), "{error}");
+        assert!(Config::parse_yaml(yaml.as_bytes()).is_ok());
+    }
+}
+
+/// Shared physical connection policy. TCP settings keep Mihomo's top-level
+/// names; IP4P is separately gated by experimental.dialer-ip4p-convert.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub struct ConnectionSettings {
+    pub dialer_ip4p_convert: bool,
+    pub quic: QuicSocketSettings,
+    pub tcp_concurrent: bool,
+    pub keep_alive_idle: i32,
+    pub keep_alive_interval: i32,
+    pub disable_keep_alive: bool,
+}
+
+/// Per-session capabilities of an unchanged physical QUIC UDP path.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct QuicSocketSettings {
+    pub disable_gso: bool,
+    pub disable_ecn: bool,
+}
+impl Default for QuicSocketSettings {
+    fn default() -> Self {
+        Self {
+            disable_gso: false,
+            disable_ecn: true,
+        }
     }
 }
diff --git a/src/config/name_regex.rs b/src/config/name_regex.rs
new file mode 100644
index 0000000..d4ae6b9
--- /dev/null
+++ b/src/config/name_regex.rs
@@ -0,0 +1,375 @@
+//! Bounded expressions for provider/group node names only.
+use super::{Result, VoleError};
+use std::time::{Duration, Instant};
+use tokio_util::sync::CancellationToken;
+
+const PATTERN_BYTES: usize = 4096;
+const NAME_BYTES: usize = 4096;
+const OUTPUT_BYTES: usize = 64 * 1024;
+const BACKTRACKS: usize = 10_000;
+
+fn error(message: &'static str) -> VoleError {
+    VoleError::InvalidConfig(message.into())
+}
+pub(super) struct Budget<'a> {
+    cancel: Option<&'a CancellationToken>,
+    elapsed: Duration,
+    remaining: usize,
+}
+impl<'a> Budget<'a> {
+    pub fn new(cancel: Option<&'a CancellationToken>) -> Self {
+        Self {
+            cancel,
+            elapsed: Duration::ZERO,
+            remaining: 10_000,
+        }
+    }
+    pub fn check(&self) -> Result<()> {
+        if self.cancel.is_some_and(CancellationToken::is_cancelled) {
+            return Err(error("provider expression cancelled"));
+        }
+        Ok(())
+    }
+    fn account(&mut self, elapsed: Duration) -> Result<()> {
+        self.elapsed = self.elapsed.saturating_add(elapsed);
+        if self.elapsed >= Duration::from_millis(100) {
+            return Err(error("provider expression execution budget exceeded"));
+        }
+        self.check()
+    }
+    fn spend(&mut self, name: &str) -> Result<()> {
+        self.check()?;
+        if name.len() > NAME_BYTES
+            || self.remaining == 0
+            || self.elapsed >= Duration::from_millis(100)
+        {
+            return Err(error("provider expression execution budget exceeded"));
+        }
+        self.remaining -= 1;
+        Ok(())
+    }
+}
+
+pub(super) struct NameRegex {
+    engine: Engine,
+    numbers: Option<Box<[usize]>>,
+}
+
+enum Engine {
+    Fast(regex::Regex),
+    Complex(Box<fancy_regex::Regex>),
+}
+impl NameRegex {
+    pub fn new(pattern: &str) -> Result<Self> {
+        if pattern.len() > PATTERN_BYTES {
+            return Err(error("provider expression compilation budget exceeded"));
+        }
+        let translated = super::domain_regex::common_dialect(pattern)
+            .map_err(|_| error("invalid or unsupported provider/group expression syntax"))?;
+        let (translated, numbers) = super::domain_regex::capture_dialect(&translated)
+            .map_err(|_| error("invalid or unsupported provider/group capture syntax"))?;
+        let capture_count = numbers.len();
+        let numbers = (!numbers
+            .iter()
+            .enumerate()
+            .all(|(index, &number)| index == number))
+        .then(|| numbers.into_boxed_slice());
+        let pattern = translated.as_str();
+        if let Ok(regex) = regex::Regex::new(pattern) {
+            if regex.captures_len() != capture_count {
+                return Err(error("unsupported provider/group capture layout"));
+            }
+            return Ok(Self {
+                engine: Engine::Fast(regex),
+                numbers,
+            });
+        }
+        let tree = fancy_regex::Expr::parse_tree(pattern)
+            .map_err(|_| error("invalid provider/group expression"))?;
+        let mut pending = vec![(&tree.expr, 0)];
+        let mut count = 0;
+        while let Some((expr, depth)) = pending.pop() {
+            count += 1;
+            if count > 512 || depth > 32 {
+                return Err(error("provider expression compilation budget exceeded"));
+            }
+            use fancy_regex::Expr;
+            match expr {
+                Expr::Repeat { lo, hi, .. } if *lo > 4096 || (*hi != usize::MAX && *hi > 4096) => {
+                    return Err(error("provider expression compilation budget exceeded"));
+                }
+                Expr::Empty
+                | Expr::Any { .. }
+                | Expr::Assertion(_)
+                | Expr::Literal { .. }
+                | Expr::Concat(_)
+                | Expr::Alt(_)
+                | Expr::Group(_)
+                | Expr::LookAround(..)
+                | Expr::Repeat { .. }
+                | Expr::Delegate { .. }
+                | Expr::Backref { .. }
+                | Expr::AtomicGroup(_) => {}
+                _ => return Err(error("unsupported provider expression syntax")),
+            }
+            pending.extend(expr.children_iter().map(|child| (child, depth + 1)));
+        }
+        let regex = fancy_regex::RegexBuilder::new(pattern)
+            .backtrack_limit(BACKTRACKS)
+            .seek(false)
+            .delegate_size_limit(512 * 1024)
+            .delegate_dfa_size_limit(512 * 1024)
+            .build()
+            .map_err(|_| error("invalid provider/group expression"))?;
+        if regex.captures_len() != capture_count {
+            return Err(error("unsupported provider/group capture layout"));
+        }
+        Ok(Self {
+            engine: Engine::Complex(Box::new(regex)),
+            numbers,
+        })
+    }
+    fn group_index(&self, index: usize) -> usize {
+        self.numbers
+            .as_ref()
+            .map_or(index, |numbers| numbers[index])
+    }
+    pub fn is_match(&self, name: &str, budget: &mut Budget<'_>) -> Result<bool> {
+        budget.check()?;
+        match &self.engine {
+            Engine::Fast(regex) => Ok(regex.is_match(name)),
+            Engine::Complex(regex) => {
+                budget.spend(name)?;
+                let started = Instant::now();
+                let result = regex
+                    .is_match(name)
+                    .map_err(|_| error("provider expression execution budget exceeded"));
+                budget.account(started.elapsed())?;
+                result
+            }
+        }
+    }
+    pub fn replace(&self, name: &str, target: &str, budget: &mut Budget<'_>) -> Result<String> {
+        budget.check()?;
+        let started = Instant::now();
+        let result = self.replace_inner(name, target, budget);
+        budget.account(started.elapsed())?;
+        result
+    }
+    fn replace_inner(&self, name: &str, target: &str, budget: &mut Budget<'_>) -> Result<String> {
+        let mut output = String::new();
+        let mut end = 0;
+        match &self.engine {
+            Engine::Fast(regex) => {
+                for captures in regex.captures_iter(name) {
+                    budget.spend(name)?;
+                    let matched = captures.get(0).expect("whole match");
+                    append(&mut output, &name[end..matched.start()])?;
+                    expand(
+                        &mut output,
+                        target,
+                        name,
+                        matched.start(),
+                        matched.end(),
+                        captures.len(),
+                        |i| captures.get(self.group_index(i)).map(|m| m.as_str()),
+                        |key| {
+                            regex
+                                .capture_names()
+                                .any(|n| n == Some(key))
+                                .then(|| captures.name(key).map(|m| m.as_str()).unwrap_or(""))
+                        },
+                    )?;
+                    end = matched.end();
+                }
+            }
+            Engine::Complex(regex) => {
+                budget.spend(name)?;
+                for captures in regex.captures_iter(name) {
+                    budget.spend(name)?;
+                    let captures = captures
+                        .map_err(|_| error("provider expression execution budget exceeded"))?;
+                    let matched = captures.get(0).expect("whole match");
+                    append(&mut output, &name[end..matched.start()])?;
+                    expand(
+                        &mut output,
+                        target,
+                        name,
+                        matched.start(),
+                        matched.end(),
+                        captures.len(),
+                        |i| captures.get(self.group_index(i)).map(|m| m.as_str()),
+                        |key| {
+                            regex
+                                .capture_names()
+                                .any(|n| n == Some(key))
+                                .then(|| captures.name(key).map(|m| m.as_str()).unwrap_or(""))
+                        },
+                    )?;
+                    end = matched.end();
+                }
+            }
+        }
+        append(&mut output, &name[end..])?;
+        Ok(output)
+    }
+}
+fn append(output: &mut String, value: &str) -> Result<()> {
+    if output
+        .len()
+        .checked_add(value.len())
+        .is_none_or(|n| n > OUTPUT_BYTES)
+    {
+        return Err(error("provider name replacement output budget exceeded"));
+    }
+    output.push_str(value);
+    Ok(())
+}
+// The reference uses .NET replacement syntax: numeric captures stop at a non-digit.
+#[allow(clippy::too_many_arguments)]
+fn expand<'a>(
+    output: &mut String,
+    target: &str,
+    input: &'a str,
+    start: usize,
+    end: usize,
+    count: usize,
+    group: impl Fn(usize) -> Option<&'a str>,
+    named: impl Fn(&str) -> Option<&'a str>,
+) -> Result<()> {
+    let mut rest = target;
+    while let Some(index) = rest.find('$') {
+        append(output, &rest[..index])?;
+        rest = &rest[index..];
+        let next = rest.as_bytes().get(1).copied();
+        let (consumed, value) = match next {
+            Some(b'$') => (2, Some("$")),
+            Some(b'&') => (2, group(0)),
+            Some(b'`') => (2, Some(&input[..start])),
+            Some(b'\'') => (2, Some(&input[end..])),
+            Some(b'_') => (2, Some(input)),
+            Some(b'+') => (2, (1..count).rev().find_map(&group).or(Some(""))),
+            Some(b'{') => {
+                if let Some(close) = rest.find('}') {
+                    let key = &rest[2..close];
+                    let value = key
+                        .parse::<usize>()
+                        .ok()
+                        .filter(|i| *i < count)
+                        .map(|i| group(i).unwrap_or(""))
+                        .or_else(|| named(key));
+                    (close + 1, value)
+                } else {
+                    (1, None)
+                }
+            }
+            Some(b'0'..=b'9') => {
+                let length = 1 + rest[1..].bytes().take_while(u8::is_ascii_digit).count();
+                let value = rest[1..length]
+                    .parse::<usize>()
+                    .ok()
+                    .filter(|i| *i < count)
+                    .map(|i| group(i).unwrap_or(""));
+                (length, value)
+            }
+            _ => (1, None),
+        };
+        append(output, value.unwrap_or(&rest[..consumed]))?;
+        rest = &rest[consumed..];
+    }
+    append(output, rest)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn name_expressions_support_real_subscription_patterns() {
+        let mut budget = Budget::new(None);
+        let exclude = NameRegex::new(r"^(?!.*(流量|到期)).*(香港|HK)").unwrap();
+        assert!(exclude.is_match("香港 HK-01", &mut budget).unwrap());
+        assert!(!exclude.is_match("香港 剩余流量", &mut budget).unwrap());
+        let repeated = NameRegex::new(r"^(HK|SG)-\1$").unwrap();
+        assert!(repeated.is_match("HK-HK", &mut budget).unwrap());
+        assert!(!repeated.is_match("HK-SG", &mut budget).unwrap());
+        let rename = NameRegex::new(r"(?<=HK-)(\d+)").unwrap();
+        assert_eq!(
+            rename.replace("HK-01", "$1x", &mut budget).unwrap(),
+            "HK-01x"
+        );
+        let fast = NameRegex::new(r"(?<area>HK)-(\d+)").unwrap();
+        assert_eq!(
+            fast.replace("HK-01", "${area}:$1x:$$:$&", &mut budget)
+                .unwrap(),
+            "HK:01x:$:HK-01"
+        );
+    }
+    #[test]
+    fn name_expressions_accept_reference_named_capture_and_comment_spelling() {
+        let mut budget = Budget::new(None);
+        let repeated = NameRegex::new(r"^(?'region'HK|SG)-\k'region'$").unwrap();
+        assert!(repeated.is_match("HK-HK", &mut budget).unwrap());
+        assert!(!repeated.is_match("HK-SG", &mut budget).unwrap());
+        assert_eq!(
+            repeated.replace("SG-SG", "${region}", &mut budget).unwrap(),
+            "SG"
+        );
+        let comment =
+            NameRegex::new(r"^(?#subscription category)(?'region'HK)-(?<node>\d+)$").unwrap();
+        assert_eq!(
+            comment
+                .replace("HK-01", "${node}:${region}", &mut budget)
+                .unwrap(),
+            "01:HK"
+        );
+    }
+
+    #[test]
+    fn dotnet_mixed_capture_numbers_apply_to_matching_and_replacement() {
+        let mut budget = Budget::new(None);
+        let simple = NameRegex::new(r"^(?<area>HK)-(\d+)$").unwrap();
+        assert_eq!(
+            simple
+                .replace("HK-01", "$1:${2}:${area}:$+", &mut budget)
+                .unwrap(),
+            "01:HK:HK:HK"
+        );
+        for pattern in [
+            r"^(?<area>HK|SG)-(\d+)-\1-\2$",
+            r"^(?'area'HK|SG)-(\d+)-\k'1'-\k'2'$",
+            "(?x)^(?<area>HK|SG) # (ignored capture)\n - (\\d+) - \\1 - \\2$",
+            r"^(?<area>HK|SG)-(\d+)-\k<1>-\k<area>$",
+        ] {
+            let regex = NameRegex::new(pattern).unwrap();
+            assert!(regex.is_match("HK-01-01-HK", &mut budget).unwrap());
+            assert!(!regex.is_match("HK-01-HK-01", &mut budget).unwrap());
+            assert_eq!(
+                regex
+                    .replace("SG-02-02-SG", "$1:${2}:${area}:$+", &mut budget)
+                    .unwrap(),
+                "02:SG:SG:SG"
+            );
+        }
+        let escaped = NameRegex::new(r"^\((?<area>HK)\)-(\d+)-\1-\2$").unwrap();
+        assert!(escaped.is_match("(HK)-01-01-HK", &mut budget).unwrap());
+    }
+
+    #[test]
+    fn name_expressions_fail_on_budget_and_cancellation() {
+        let regex = NameRegex::new(r"(?i)(a|b|ab)*(?>c)").unwrap();
+        assert!(
+            regex
+                .is_match(&"ab".repeat(40), &mut Budget::new(None))
+                .is_err()
+        );
+        let cancel = CancellationToken::new();
+        cancel.cancel();
+        assert!(
+            NameRegex::new("HK")
+                .unwrap()
+                .is_match("HK", &mut Budget::new(Some(&cancel)))
+                .is_err()
+        );
+        assert!(NameRegex::new(r"(?=a)a{1000000}").is_err());
+    }
+}
diff --git a/src/config/override_expr.rs b/src/config/override_expr.rs
new file mode 100644
index 0000000..f910807
--- /dev/null
+++ b/src/config/override_expr.rs
@@ -0,0 +1,2886 @@
+//! Native, bounded provider transformations; no external interpreter is invoked.
+//! Independently designed against the public finite-yq behavior contract.
+use super::{Result, VoleError};
+use serde_yaml_ng::{Mapping, Number, Value};
+use std::{
+    cmp::Ordering,
+    collections::BTreeMap,
+    time::{Duration, Instant},
+};
+use tokio_util::sync::CancellationToken;
+
+const SOURCE_LIMIT: usize = 16 * 1024;
+const NODE_LIMIT: usize = 4096;
+const COMPILE_NODES: usize = 64 * 1024;
+const COMPILE_BYTES: usize = 512 * 1024;
+const PARSE_DEPTH: usize = 32;
+const VALUE_DEPTH: usize = 64;
+const BYTE_LIMIT: usize = 32 * 1024 * 1024;
+const STEP_LIMIT: usize = 200_000;
+fn error(message: &'static str) -> VoleError {
+    VoleError::InvalidConfig(message.into())
+}
+
+pub(super) struct Budget<'a> {
+    cancel: Option<&'a CancellationToken>,
+    started: Instant,
+    steps: usize,
+    bytes: usize,
+    regexes: BTreeMap<String, regex::Regex>,
+}
+impl<'a> Budget<'a> {
+    pub fn new(cancel: Option<&'a CancellationToken>) -> Self {
+        Self {
+            cancel,
+            started: Instant::now(),
+            steps: 0,
+            bytes: 0,
+            regexes: BTreeMap::new(),
+        }
+    }
+    fn tick(&mut self, amount: usize) -> Result<()> {
+        if self.cancel.is_some_and(CancellationToken::is_cancelled) {
+            return Err(error("provider override expression cancelled"));
+        }
+        self.steps = self
+            .steps
+            .checked_add(amount)
+            .ok_or_else(|| error("provider override execution budget exceeded"))?;
+        if self.steps > STEP_LIMIT || self.started.elapsed() > Duration::from_millis(100) {
+            return Err(error("provider override execution budget exceeded"));
+        }
+        Ok(())
+    }
+    fn reserve(&mut self, bytes: usize) -> Result<()> {
+        self.tick(1)?;
+        self.bytes = self
+            .bytes
+            .checked_add(bytes)
+            .ok_or_else(|| error("provider override output budget exceeded"))?;
+        if self.bytes > BYTE_LIMIT {
+            return Err(error("provider override output budget exceeded"));
+        }
+        Ok(())
+    }
+    fn clone_value(&mut self, value: &Value) -> Result<Value> {
+        let bytes = self.measure(value, 0)?;
+        self.reserve(bytes)?;
+        Ok(value.clone())
+    }
+    fn measure(&mut self, value: &Value, depth: usize) -> Result<usize> {
+        self.tick(1)?;
+        if depth > VALUE_DEPTH {
+            return Err(error("provider override value depth exceeded"));
+        }
+        let mut bytes = std::mem::size_of::<Value>();
+        match value {
+            Value::String(text) => bytes = bytes.saturating_add(text.len()),
+            Value::Sequence(values) => {
+                for value in values {
+                    bytes = bytes.saturating_add(self.measure(value, depth + 1)?);
+                }
+            }
+            Value::Mapping(map) => {
+                for (key, value) in map {
+                    bytes = bytes
+                        .saturating_add(self.measure(key, depth + 1)?)
+                        .saturating_add(self.measure(value, depth + 1)?);
+                }
+            }
+            Value::Tagged(_) => return Err(error("provider override does not support YAML tags")),
+            _ => {}
+        }
+        if bytes > BYTE_LIMIT {
+            return Err(error("provider override output budget exceeded"));
+        }
+        Ok(bytes)
+    }
+    fn regex(&mut self, pattern: &str) -> Result<regex::Regex> {
+        self.tick(1)?;
+        if pattern.len() > 4096 {
+            return Err(error("provider override regex compilation budget exceeded"));
+        }
+        if let Some(regex) = self.regexes.get(pattern) {
+            return Ok(regex.clone());
+        }
+        if self.regexes.len() >= 32 {
+            return Err(error("provider override regex compilation budget exceeded"));
+        }
+        self.reserve(pattern.len().saturating_add(512 * 1024))?;
+        let regex = compile_regex(pattern)?;
+        self.regexes.insert(pattern.into(), regex.clone());
+        Ok(regex)
+    }
+}
+
+fn compile_regex(pattern: &str) -> Result<regex::Regex> {
+    if pattern.len() > 4096 {
+        return Err(error("provider override regex compilation budget exceeded"));
+    }
+    // RE2's Perl shorthand classes are ASCII. Keep Unicode literal/range matching
+    // while expanding those classes before using Rust's bounded linear engine.
+    let mut adapted = String::new();
+    let mut characters = pattern.chars().peekable();
+    while let Some(character) = characters.next() {
+        if character != '\\' {
+            adapted.push(character);
+            continue;
+        }
+        match characters.next() {
+            Some('d') => adapted.push_str("[0-9]"),
+            Some('D') => adapted.push_str("[^0-9]"),
+            Some('w') => adapted.push_str("[A-Za-z0-9_]"),
+            Some('W') => adapted.push_str("[^A-Za-z0-9_]"),
+            Some('s') => adapted.push_str(r"[\t\n\f\r ]"),
+            Some('S') => adapted.push_str(r"[^\t\n\f\r ]"),
+            Some('b') => adapted.push_str(r"(?-u:\b)"),
+            Some('B') => adapted.push_str(r"(?-u:\B)"),
+            Some('Q') => {
+                let mut quoted = String::new();
+                while let Some(character) = characters.next() {
+                    if character == '\\' && characters.peek() == Some(&'E') {
+                        characters.next();
+                        break;
+                    }
+                    quoted.push(character);
+                }
+                adapted.push_str(&regex::escape(&quoted));
+            }
+            Some(character) => {
+                adapted.push('\\');
+                adapted.push(character);
+            }
+            None => adapted.push('\\'),
+        }
+    }
+    regex::RegexBuilder::new(&adapted)
+        .octal(true)
+        .size_limit(512 * 1024)
+        .dfa_size_limit(512 * 1024)
+        .build()
+        .map_err(|_| error("invalid provider override regular expression"))
+}
+
+#[derive(Clone)]
+pub(super) struct Expr {
+    root: Node,
+    regexes: BTreeMap<String, regex::Regex>,
+}
+impl PartialEq for Expr {
+    fn eq(&self, other: &Self) -> bool {
+        self.root == other.root
+    }
+}
+impl Eq for Expr {}
+impl std::fmt::Debug for Expr {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ProviderExpr").finish_non_exhaustive()
+    }
+}
+impl Expr {
+    #[cfg(test)]
+    pub fn parse(source: &str) -> Result<Self> {
+        Self::parse_with_budget(source, &mut CompileBudget::default())
+    }
+    pub fn parse_with_budget(source: &str, limits: &mut CompileBudget) -> Result<Self> {
+        limits.check()?;
+        let initial_nodes = limits.nodes;
+        let initial_tokens = limits.tokens;
+        let root = parse(source, limits, 0)?;
+        if limits.nodes.saturating_sub(initial_nodes) > NODE_LIMIT
+            || limits.tokens.saturating_sub(initial_tokens) > NODE_LIMIT
+        {
+            return Err(error("provider override compilation budget exceeded"));
+        }
+        validate(&root, 0)?;
+        let mut regexes = BTreeMap::new();
+        compile_literal_regexes(&root, &mut regexes, limits)?;
+        Ok(Self { root, regexes })
+    }
+    pub fn apply(&self, mapping: &mut Value, budget: &mut Budget<'_>) -> Result<()> {
+        if !mapping.is_mapping() {
+            return Err(error("provider override input must be a mapping"));
+        }
+        for (pattern, regex) in &self.regexes {
+            budget.tick(1)?;
+            if !budget.regexes.contains_key(pattern) {
+                if budget.regexes.len() >= 32 {
+                    return Err(error("provider override regex compilation budget exceeded"));
+                }
+                budget.reserve(pattern.len().saturating_add(512 * 1024))?;
+                budget.regexes.insert(pattern.clone(), regex.clone());
+            }
+        }
+        let input = budget.clone_value(mapping)?;
+        let mut result = evaluate(&self.root, vec![input], budget, 0)?;
+        if result.len() != 1 || !result[0].is_mapping() {
+            return Err(error("provider override must produce exactly one mapping"));
+        }
+        budget.measure(&result[0], 0)?;
+        *mapping = result.pop().expect("one result");
+        Ok(())
+    }
+}
+#[derive(Clone, PartialEq, Eq)]
+enum Segment {
+    Key(String),
+    Index(i64),
+    Each,
+}
+#[derive(Clone, PartialEq, Eq)]
+enum Part {
+    Text(String),
+    Expression(Node),
+}
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum Op {
+    Add,
+    Sub,
+    Mul,
+    Div,
+    Mod,
+    Eq,
+    Ne,
+    Lt,
+    Le,
+    Gt,
+    Ge,
+    And,
+    Or,
+    Default,
+}
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum Update {
+    Assign,
+    Replace,
+    Add,
+    Sub,
+    Mul,
+}
+#[derive(Clone, PartialEq, Eq)]
+enum Node {
+    Literal(Value),
+    Path(Vec<Segment>),
+    String(Vec<Part>),
+    Array(Box<Node>),
+    Object(Vec<(String, Node)>),
+    Binary(Op, Box<Node>, Box<Node>),
+    Neg(Box<Node>),
+    Pipe(Box<Node>, Box<Node>),
+    Union(Box<Node>, Box<Node>),
+    Call(String, Vec<Node>),
+    Update(Update, Box<Node>, Box<Node>),
+    Delete(Vec<Node>),
+    Group(Box<Node>),
+}
+#[derive(Clone, PartialEq, Eq)]
+enum Token {
+    Dot,
+    Word(String),
+    String(String),
+    Number(String),
+    Symbol(&'static str),
+    End,
+}
+pub(super) struct CompileBudget {
+    tokens: usize,
+    nodes: usize,
+    bytes: usize,
+    started: Instant,
+    regexes: BTreeMap<String, regex::Regex>,
+}
+impl Default for CompileBudget {
+    fn default() -> Self {
+        Self {
+            tokens: 0,
+            nodes: 0,
+            bytes: 0,
+            started: Instant::now(),
+            regexes: BTreeMap::new(),
+        }
+    }
+}
+impl CompileBudget {
+    fn check(&self) -> Result<()> {
+        if self.started.elapsed() > Duration::from_secs(1)
+            || self.tokens > COMPILE_NODES
+            || self.nodes > COMPILE_NODES
+        {
+            return Err(error("provider override compilation budget exceeded"));
+        }
+        Ok(())
+    }
+}
+fn lex(source: &str, limits: &mut CompileBudget) -> Result<Vec<Token>> {
+    limits.bytes = limits.bytes.saturating_add(source.len());
+    limits.check()?;
+    if source.len() > SOURCE_LIMIT || limits.bytes > COMPILE_BYTES {
+        return Err(error("provider override compilation budget exceeded"));
+    }
+    let bytes = source.as_bytes();
+    let mut cursor = 0;
+    let mut tokens = Vec::new();
+    while cursor < bytes.len() {
+        let start = cursor;
+        let ch = source[cursor..].chars().next().expect("valid character");
+        if ch.is_whitespace() {
+            cursor += ch.len_utf8();
+            continue;
+        }
+        if ch == '#' {
+            break;
+        }
+        let token = if ch == '"' {
+            cursor += 1;
+            let content = cursor;
+            let mut escaped = false;
+            while cursor < bytes.len() {
+                let byte = bytes[cursor];
+                if !escaped && byte == b'"' {
+                    break;
+                }
+                escaped = !escaped && byte == b'\\';
+                cursor += 1;
+            }
+            if cursor == bytes.len() {
+                return Err(error("invalid provider override string"));
+            }
+            let text = source[content..cursor].to_owned();
+            cursor += 1;
+            Token::String(text)
+        } else if ch.is_ascii_digit() {
+            cursor += 1;
+            while cursor < bytes.len() {
+                let byte = bytes[cursor];
+                if byte.is_ascii_alphanumeric()
+                    || byte == b'.'
+                    || ((byte == b'+' || byte == b'-') && matches!(bytes[cursor - 1], b'e' | b'E'))
+                {
+                    cursor += 1;
+                } else {
+                    break;
+                }
+            }
+            Token::Number(source[start..cursor].into())
+        } else if ch.is_alphabetic() || ch == '_' {
+            cursor += ch.len_utf8();
+            while cursor < bytes.len() {
+                let ch = source[cursor..].chars().next().expect("valid character");
+                if ch.is_alphanumeric() || matches!(ch, '_' | '-') {
+                    cursor += ch.len_utf8();
+                } else {
+                    break;
+                }
+            }
+            Token::Word(source[start..cursor].into())
+        } else {
+            let mut matched = None;
+            for symbol in [
+                "|=", "+=", "-=", "*=", "//", "==", "!=", "<=", ">=", "(", ")", "[", "]", "{", "}",
+                ",", ";", ":", "|", "=", "+", "-", "*", "/", "%", "<", ">", "~",
+            ] {
+                if source[cursor..].starts_with(symbol) {
+                    matched = Some(symbol);
+                    break;
+                }
+            }
+            if ch == '.' {
+                cursor += 1;
+                Token::Dot
+            } else if let Some(symbol) = matched {
+                cursor += symbol.len();
+                Token::Symbol(symbol)
+            } else {
+                return Err(error("unsupported provider override syntax"));
+            }
+        };
+        limits.tokens += 1;
+        limits.check()?;
+        if tokens.len() >= NODE_LIMIT {
+            return Err(error("provider override compilation budget exceeded"));
+        }
+        tokens.push(token);
+    }
+    tokens.push(Token::End);
+    Ok(tokens)
+}
+struct Parser<'a> {
+    tokens: Vec<Token>,
+    cursor: usize,
+    limits: &'a mut CompileBudget,
+}
+fn parse(source: &str, limits: &mut CompileBudget, depth: usize) -> Result<Node> {
+    if depth > PARSE_DEPTH {
+        return Err(error("provider override expression depth exceeded"));
+    }
+    let tokens = lex(source, limits)?;
+    if tokens.len() == 1 {
+        limits.nodes += 1;
+        limits.check()?;
+        return Ok(Node::Path(Vec::new()));
+    }
+    let mut parser = Parser {
+        tokens,
+        cursor: 0,
+        limits,
+    };
+    let node = parser.expression(0, depth + 1)?;
+    if parser.peek() != &Token::End {
+        return Err(error("invalid provider override expression"));
+    }
+    Ok(node)
+}
+impl Parser<'_> {
+    fn peek(&self) -> &Token {
+        &self.tokens[self.cursor]
+    }
+    fn next(&mut self) -> Token {
+        let result = self.tokens[self.cursor].clone();
+        self.cursor += 1;
+        result
+    }
+    fn symbol(&mut self, symbol: &'static str) -> bool {
+        if self.peek() == &Token::Symbol(symbol) {
+            self.cursor += 1;
+            true
+        } else {
+            false
+        }
+    }
+    fn expect(&mut self, symbol: &'static str) -> Result<()> {
+        if self.symbol(symbol) {
+            Ok(())
+        } else {
+            Err(error("invalid provider override expression"))
+        }
+    }
+    fn account(&mut self, node: Node) -> Result<Node> {
+        self.limits.nodes += 1;
+        if self.limits.nodes > COMPILE_NODES {
+            return Err(error("provider override compilation budget exceeded"));
+        }
+        Ok(node)
+    }
+    fn expression(&mut self, minimum: u8, depth: usize) -> Result<Node> {
+        if depth > PARSE_DEPTH {
+            return Err(error("provider override expression depth exceeded"));
+        }
+        let mut node = self.primary(depth + 1)?;
+        loop {
+            let (precedence, kind) = match self.peek() {
+                Token::Symbol(",") => (1, 0),
+                Token::Symbol("|") => (2, 1),
+                Token::Symbol("=" | "|=" | "+=" | "-=" | "*=") => (3, 2),
+                Token::Word(word) if word == "or" => (4, 3),
+                Token::Word(word) if word == "and" => (5, 3),
+                Token::Symbol("//") => (6, 3),
+                Token::Symbol("==" | "!=" | "<" | "<=" | ">" | ">=") => (7, 3),
+                Token::Symbol("+" | "-") => (8, 3),
+                Token::Symbol("*" | "/" | "%") => (9, 3),
+                _ => break,
+            };
+            if precedence < minimum {
+                break;
+            }
+            if matches!(node, Node::Update(..))
+                && matches!(self.peek(), Token::Word(word) if word == "and" || word == "or")
+            {
+                return Err(error(
+                    "provider override boolean assignment values require parentheses",
+                ));
+            }
+            let operator = self.next();
+            let right = self.expression(if kind == 2 { 6 } else { precedence + 1 }, depth + 1)?;
+            node = self.account(match kind {
+                0 => Node::Union(Box::new(node), Box::new(right)),
+                1 => Node::Pipe(Box::new(node), Box::new(right)),
+                2 => Node::Update(
+                    match operator {
+                        Token::Symbol("=") => Update::Assign,
+                        Token::Symbol("|=") => Update::Replace,
+                        Token::Symbol("+=") => Update::Add,
+                        Token::Symbol("-=") => Update::Sub,
+                        _ => Update::Mul,
+                    },
+                    Box::new(node),
+                    Box::new(right),
+                ),
+                _ => Node::Binary(
+                    match operator {
+                        Token::Word(word) if word == "and" => Op::And,
+                        Token::Word(_) => Op::Or,
+                        Token::Symbol("//") => Op::Default,
+                        Token::Symbol("+") => Op::Add,
+                        Token::Symbol("-") => Op::Sub,
+                        Token::Symbol("*") => Op::Mul,
+                        Token::Symbol("/") => Op::Div,
+                        Token::Symbol("%") => Op::Mod,
+                        Token::Symbol("==") => Op::Eq,
+                        Token::Symbol("!=") => Op::Ne,
+                        Token::Symbol("<") => Op::Lt,
+                        Token::Symbol("<=") => Op::Le,
+                        Token::Symbol(">") => Op::Gt,
+                        _ => Op::Ge,
+                    },
+                    Box::new(node),
+                    Box::new(right),
+                ),
+            })?;
+        }
+        Ok(node)
+    }
+    fn primary(&mut self, depth: usize) -> Result<Node> {
+        let node = match self.next() {
+            Token::Dot => {
+                let mut segments = Vec::new();
+                if matches!(self.peek(), Token::Word(_) | Token::String(_)) {
+                    segments.push(self.field()?);
+                }
+                loop {
+                    if self.peek() == &Token::Dot {
+                        self.next();
+                        segments.push(self.field()?);
+                    } else if self.symbol("[") {
+                        if self.symbol("]") {
+                            segments.push(Segment::Each);
+                            continue;
+                        }
+                        let segment = match self.next() {
+                            Token::String(raw) => Segment::Key(decode_string(&raw)?),
+                            Token::Number(number) => Segment::Index(
+                                number
+                                    .parse()
+                                    .map_err(|_| error("invalid provider override index"))?,
+                            ),
+                            Token::Symbol("-") => match self.next() {
+                                Token::Number(number) => Segment::Index(
+                                    number
+                                        .parse::<i64>()
+                                        .ok()
+                                        .and_then(i64::checked_neg)
+                                        .ok_or_else(|| error("invalid provider override index"))?,
+                                ),
+                                _ => return Err(error("invalid provider override index")),
+                            },
+                            _ => return Err(error("unsupported provider override path")),
+                        };
+                        self.expect("]")?;
+                        segments.push(segment);
+                    } else {
+                        break;
+                    }
+                }
+                if segments.len() > PARSE_DEPTH {
+                    return Err(error("provider override path depth exceeded"));
+                }
+                Node::Path(segments)
+            }
+            Token::Number(number) => Node::Literal(number_value(&number, false)?),
+            Token::String(raw) => Node::String(interpolation(&raw, self.limits, depth + 1)?),
+            Token::Symbol("~") => Node::Literal(Value::Null),
+            Token::Symbol("-") => match self.peek() {
+                Token::Number(number) if !number.starts_with("0x") && !number.starts_with("0X") => {
+                    let number = format!("-{number}");
+                    self.next();
+                    Node::Literal(number_value(&number, false)?)
+                }
+                _ => Node::Neg(Box::new(self.expression(10, depth + 1)?)),
+            },
+            Token::Symbol("(") => {
+                let node = self.expression(0, depth + 1)?;
+                self.expect(")")?;
+                Node::Group(Box::new(node))
+            }
+            Token::Symbol("[") => {
+                if self.symbol("]") {
+                    Node::Literal(Value::Sequence(Vec::new()))
+                } else {
+                    let node = self.expression(0, depth + 1)?;
+                    self.expect("]")?;
+                    Node::Array(Box::new(node))
+                }
+            }
+            Token::Symbol("{") => {
+                let mut entries = Vec::new();
+                if !self.symbol("}") {
+                    loop {
+                        let Token::String(raw) = self.next() else {
+                            return Err(error(
+                                "provider override mapping keys must be quoted strings",
+                            ));
+                        };
+                        let key = decode_string(&raw)?;
+                        self.expect(":")?;
+                        entries.push((key, self.expression(2, depth + 1)?));
+                        if self.symbol("}") {
+                            break;
+                        }
+                        self.expect(",")?;
+                    }
+                }
+                Node::Object(entries)
+            }
+            Token::Word(name) => match name.as_str() {
+                "null" => Node::Literal(Value::Null),
+                "true" => Node::Literal(Value::Bool(true)),
+                "false" => Node::Literal(Value::Bool(false)),
+                _ => {
+                    if ![
+                        "length",
+                        "keys",
+                        "has",
+                        "contains",
+                        "select",
+                        "reverse",
+                        "sort",
+                        "unique",
+                        "flatten",
+                        "any",
+                        "all",
+                        "map",
+                        "map_values",
+                        "filter",
+                        "to_entries",
+                        "from_entries",
+                        "with_entries",
+                        "any_c",
+                        "all_c",
+                        "test",
+                        "sub",
+                        "split",
+                        "join",
+                        "upcase",
+                        "downcase",
+                        "trim",
+                        "tostring",
+                        "tonumber",
+                        "type",
+                        "not",
+                        "del",
+                    ]
+                    .contains(&name.as_str())
+                    {
+                        return Err(error("unsupported provider override function"));
+                    }
+                    let mut arguments = Vec::new();
+                    if self.symbol("(") && !self.symbol(")") {
+                        loop {
+                            let collecting = [
+                                "map",
+                                "map_values",
+                                "filter",
+                                "with_entries",
+                                "any_c",
+                                "all_c",
+                            ]
+                            .contains(&name.as_str());
+                            arguments
+                                .push(self.expression(if collecting { 0 } else { 2 }, depth + 1)?);
+                            if self.symbol(")") {
+                                break;
+                            }
+                            if !self.symbol(",") {
+                                self.expect(";")?;
+                            }
+                        }
+                    }
+                    if name == "del" {
+                        Node::Delete(arguments)
+                    } else {
+                        Node::Call(name, arguments)
+                    }
+                }
+            },
+            _ => return Err(error("invalid provider override value")),
+        };
+        self.account(node)
+    }
+    fn field(&mut self) -> Result<Segment> {
+        match self.next() {
+            Token::Word(name) => Ok(Segment::Key(name)),
+            Token::String(raw) => Ok(Segment::Key(decode_string(&raw)?)),
+            _ => Err(error("invalid provider override field")),
+        }
+    }
+}
+fn decode_string(raw: &str) -> Result<String> {
+    let mut output = String::new();
+    let mut chars = raw.chars();
+    while let Some(ch) = chars.next() {
+        if ch == '\\' {
+            match chars.next() {
+                Some('n') => output.push('\n'),
+                Some('"') => output.push('"'),
+                Some('\\') => output.push('\\'),
+                Some(other) => {
+                    output.push('\\');
+                    output.push(other);
+                }
+                None => return Err(error("invalid provider override string")),
+            }
+        } else {
+            output.push(ch);
+        }
+    }
+    Ok(output)
+}
+fn interpolation(raw: &str, limits: &mut CompileBudget, depth: usize) -> Result<Vec<Part>> {
+    let mut parts = Vec::new();
+    let mut plain = String::new();
+    let mut cursor = 0;
+    while cursor < raw.len() {
+        if raw[cursor..].starts_with("\\\\") {
+            plain.push_str("\\\\");
+            cursor += 2;
+            continue;
+        }
+        if raw[cursor..].starts_with("\\(") {
+            if !plain.is_empty() {
+                parts.push(Part::Text(decode_string(&plain)?));
+                plain.clear();
+            }
+            cursor += 2;
+            let start = cursor;
+            let mut nested = 1;
+            let mut quoted = false;
+            let mut escaped = false;
+            while cursor < raw.len() {
+                let byte = raw.as_bytes()[cursor];
+                if !escaped && byte == b'"' {
+                    quoted = !quoted;
+                }
+                if !quoted && !escaped {
+                    if byte == b'(' {
+                        nested += 1;
+                    } else if byte == b')' {
+                        nested -= 1;
+                        if nested == 0 {
+                            break;
+                        }
+                    }
+                }
+                escaped = !escaped && byte == b'\\';
+                cursor += 1;
+            }
+            if nested != 0 {
+                return Err(error("invalid provider override interpolation"));
+            }
+            let expression = raw[start..cursor].replace("\\\"", "\"");
+            parts.push(Part::Expression(parse(&expression, limits, depth + 1)?));
+            cursor += 1;
+        } else {
+            let ch = raw[cursor..].chars().next().expect("valid character");
+            plain.push(ch);
+            cursor += ch.len_utf8();
+        }
+    }
+    if !plain.is_empty() {
+        parts.push(Part::Text(decode_string(&plain)?));
+    }
+    Ok(parts)
+}
+fn number_value(text: &str, conversion: bool) -> Result<Value> {
+    let integer = if let Some(digits) = text.strip_prefix("0x").or_else(|| text.strip_prefix("0X"))
+    {
+        i64::from_str_radix(digits, 16).ok()
+    } else if conversion && let Some(digits) = text.strip_prefix("0o") {
+        i64::from_str_radix(digits, 8).ok()
+    } else {
+        text.parse::<i64>().ok()
+    };
+    if let Some(integer) = integer {
+        return Ok(Value::Number(integer.into()));
+    }
+    if !conversion && !text.contains(['.', 'e', 'E']) {
+        return Err(error("invalid provider override integer"));
+    }
+    if text.starts_with("0b")
+        || text.starts_with("0B")
+        || text.starts_with("0o")
+        || text.starts_with("0O")
+        || text.starts_with("0x")
+        || text.starts_with("0X")
+    {
+        return Err(error("invalid provider override number"));
+    }
+    let number = text
+        .parse::<f64>()
+        .map_err(|_| error("invalid provider override number"))?;
+    if !number.is_finite()
+        && !(conversion
+            && matches!(
+                text,
+                "NaN"
+                    | "nan"
+                    | "Inf"
+                    | "inf"
+                    | "+Inf"
+                    | "+inf"
+                    | "-Inf"
+                    | "-inf"
+                    | "Infinity"
+                    | "infinity"
+                    | "+Infinity"
+                    | "+infinity"
+                    | "-Infinity"
+                    | "-infinity"
+            ))
+    {
+        return Err(error("provider override number overflow"));
+    }
+    Ok(Value::Number(Number::from(number)))
+}
+
+fn validate(node: &Node, depth: usize) -> Result<()> {
+    if depth > PARSE_DEPTH {
+        return Err(error("provider override expression depth exceeded"));
+    }
+    match node {
+        Node::Update(_, target, value) => {
+            validate_target(target)?;
+            validate(target, depth + 1)?;
+            validate(value, depth + 1)?;
+        }
+        Node::Delete(paths) => {
+            if paths.is_empty() {
+                return Err(error("invalid provider override deletion"));
+            }
+            for path in paths {
+                validate_target(path)?;
+                if matches!(path, Node::Path(path) if path.is_empty()) {
+                    return Err(error("provider override cannot delete the root"));
+                }
+                validate(path, depth + 1)?;
+            }
+        }
+        Node::Call(name, arguments) => {
+            let expected = match name.as_str() {
+                "has" | "contains" | "select" | "split" | "join" => 1..=1,
+                "map" | "map_values" | "filter" | "with_entries" | "any_c" | "all_c" => {
+                    1..=usize::MAX
+                }
+                "sub" => 2..=2,
+                "test" => 1..=2,
+                "flatten" => 0..=1,
+                _ => 0..=0,
+            };
+            if !expected.contains(&arguments.len()) {
+                return Err(error("invalid provider override function arguments"));
+            }
+            for argument in arguments {
+                validate(argument, depth + 1)?;
+            }
+        }
+        Node::Pipe(a, b) | Node::Union(a, b) | Node::Binary(_, a, b) => {
+            validate(a, depth + 1)?;
+            validate(b, depth + 1)?;
+        }
+        Node::Array(node) | Node::Neg(node) | Node::Group(node) => validate(node, depth + 1)?,
+        Node::Object(entries) => {
+            for (_, node) in entries {
+                validate(node, depth + 1)?;
+            }
+        }
+        Node::String(parts) => {
+            for part in parts {
+                if let Part::Expression(node) = part {
+                    validate(node, depth + 1)?;
+                }
+            }
+        }
+        _ => {}
+    }
+    Ok(())
+}
+fn validate_target(node: &Node) -> Result<()> {
+    match node {
+        Node::Path(_) => Ok(()),
+        Node::Group(node) => validate_target(node),
+        Node::Pipe(a, b) | Node::Union(a, b) => {
+            validate_target(a)?;
+            validate_target(b)
+        }
+        Node::Call(name, arguments) if name == "select" && arguments.len() == 1 => Ok(()),
+        _ => Err(error("invalid provider override update target")),
+    }
+}
+fn compile_literal_regexes(
+    node: &Node,
+    output: &mut BTreeMap<String, regex::Regex>,
+    limits: &mut CompileBudget,
+) -> Result<()> {
+    limits.check()?;
+    match node {
+        Node::Call(name, arguments) => {
+            if matches!(name.as_str(), "test" | "sub")
+                && let Some(Node::String(parts)) = arguments.first()
+                && parts.iter().all(|part| matches!(part, Part::Text(_)))
+            {
+                let pattern = parts
+                    .iter()
+                    .filter_map(|part| {
+                        if let Part::Text(text) = part {
+                            Some(text.as_str())
+                        } else {
+                            None
+                        }
+                    })
+                    .collect::<String>();
+                if pattern.len() > 4096 || output.len() >= 32 {
+                    return Err(error("provider override regex compilation budget exceeded"));
+                }
+                let regex = if let Some(regex) = limits.regexes.get(&pattern) {
+                    regex.clone()
+                } else {
+                    if limits.regexes.len() >= 32 {
+                        return Err(error("provider override regex compilation budget exceeded"));
+                    }
+                    let regex = compile_regex(&pattern)?;
+                    limits.regexes.insert(pattern.clone(), regex.clone());
+                    regex
+                };
+                output.insert(pattern, regex);
+            }
+            for node in arguments {
+                compile_literal_regexes(node, output, limits)?;
+            }
+        }
+        Node::Pipe(a, b) | Node::Union(a, b) | Node::Binary(_, a, b) | Node::Update(_, a, b) => {
+            compile_literal_regexes(a, output, limits)?;
+            compile_literal_regexes(b, output, limits)?;
+        }
+        Node::Array(node) | Node::Neg(node) | Node::Group(node) => {
+            compile_literal_regexes(node, output, limits)?
+        }
+        Node::Delete(nodes) => {
+            for node in nodes {
+                compile_literal_regexes(node, output, limits)?;
+            }
+        }
+        Node::Object(entries) => {
+            for (_, node) in entries {
+                compile_literal_regexes(node, output, limits)?;
+            }
+        }
+        Node::String(parts) => {
+            for part in parts {
+                if let Part::Expression(node) = part {
+                    compile_literal_regexes(node, output, limits)?;
+                }
+            }
+        }
+        _ => {}
+    }
+    Ok(())
+}
+
+fn evaluate(
+    node: &Node,
+    inputs: Vec<Value>,
+    budget: &mut Budget<'_>,
+    depth: usize,
+) -> Result<Vec<Value>> {
+    budget.tick(1)?;
+    if depth > PARSE_DEPTH {
+        return Err(error("provider override evaluation depth exceeded"));
+    }
+    match node {
+        Node::Pipe(left, right) => {
+            let values = evaluate(left, inputs, budget, depth + 1)?;
+            evaluate(right, values, budget, depth + 1)
+        }
+        Node::Union(left, right) => {
+            let copies = inputs
+                .iter()
+                .map(|value| budget.clone_value(value))
+                .collect::<Result<Vec<_>>>()?;
+            let mut values = evaluate(left, copies, budget, depth + 1)?;
+            let other = evaluate(right, inputs, budget, depth + 1)?;
+            budget.reserve(other.len().saturating_mul(std::mem::size_of::<Value>()))?;
+            values.extend(other);
+            Ok(values)
+        }
+        Node::Group(node) => evaluate(node, inputs, budget, depth + 1),
+        _ => {
+            let mut output = Vec::new();
+            for input in inputs {
+                budget.tick(1)?;
+                let values = single(node, &input, budget, depth + 1)?;
+                budget.reserve(values.len().saturating_mul(std::mem::size_of::<Value>()))?;
+                output.extend(values);
+            }
+            Ok(output)
+        }
+    }
+}
+fn one(node: &Node, input: &Value, budget: &mut Budget<'_>, depth: usize) -> Result<Option<Value>> {
+    let input = budget.clone_value(input)?;
+    let mut values = evaluate(node, vec![input], budget, depth + 1)?;
+    if values.len() > 1 {
+        return Err(error(
+            "provider override value must collect multiple results",
+        ));
+    }
+    Ok(values.pop())
+}
+fn single(node: &Node, input: &Value, budget: &mut Budget<'_>, depth: usize) -> Result<Vec<Value>> {
+    budget.tick(1)?;
+    match node {
+        Node::Literal(value) => Ok(vec![budget.clone_value(value)?]),
+        Node::Path(path) => lookup(input, path, budget, 0),
+        Node::String(parts) => {
+            let mut output = String::new();
+            for part in parts {
+                let text = match part {
+                    Part::Text(text) => {
+                        budget.reserve(text.len())?;
+                        text.clone()
+                    }
+                    Part::Expression(node) => {
+                        let input = budget.clone_value(input)?;
+                        let result = evaluate(node, vec![input], budget, depth + 1)?;
+                        result
+                            .first()
+                            .map(|value| text(value, budget))
+                            .transpose()?
+                            .unwrap_or_default()
+                    }
+                };
+                append(&mut output, &text, budget)?;
+            }
+            Ok(vec![Value::String(output)])
+        }
+        Node::Array(node) => {
+            let input = budget.clone_value(input)?;
+            let values = evaluate(node, vec![input], budget, depth + 1)?;
+            Ok(vec![Value::Sequence(values)])
+        }
+        Node::Object(entries) => {
+            let mut map = Mapping::new();
+            for (key, node) in entries {
+                let copy = budget.clone_value(input)?;
+                let mut values = evaluate(node, vec![copy], budget, depth + 1)?;
+                if let Some(value) = values.pop() {
+                    budget.reserve(key.len() + std::mem::size_of::<Value>() * 2)?;
+                    map.insert(Value::String(key.clone()), value);
+                }
+            }
+            Ok(vec![Value::Mapping(map)])
+        }
+        Node::Neg(node) => {
+            let Some(value) = one(node, input, budget, depth)? else {
+                return Ok(vec![]);
+            };
+            if let Some(integer) = value.as_i64() {
+                Ok(vec![Value::Number(integer.wrapping_neg().into())])
+            } else {
+                Ok(vec![Value::Number(Number::from(-numeric(&value)?))])
+            }
+        }
+        Node::Binary(operator, left, right) => {
+            let copy = budget.clone_value(input)?;
+            let left = evaluate(left, vec![copy], budget, depth + 1)?;
+            if *operator == Op::Default {
+                let mut output = Vec::new();
+                if left.is_empty() {
+                    let copy = budget.clone_value(input)?;
+                    return evaluate(right, vec![copy], budget, depth + 1);
+                }
+                for value in left {
+                    if truthy(&value) {
+                        output.push(value);
+                    } else {
+                        let copy = budget.clone_value(input)?;
+                        output.extend(evaluate(right, vec![copy], budget, depth + 1)?);
+                    }
+                }
+                return Ok(output);
+            }
+            let copy = budget.clone_value(input)?;
+            let right = evaluate(right, vec![copy], budget, depth + 1)?;
+            let count = left
+                .len()
+                .checked_mul(right.len())
+                .ok_or_else(|| error("provider override output budget exceeded"))?;
+            budget.reserve(count.saturating_mul(std::mem::size_of::<Value>()))?;
+            let mut output = Vec::with_capacity(count);
+            for a in &left {
+                for b in &right {
+                    output.push(binary(*operator, a, b, budget, 0)?);
+                }
+            }
+            Ok(output)
+        }
+        Node::Call(name, arguments) => call(name, arguments, input, budget, depth),
+        Node::Update(operation, target, value) => {
+            let paths = select_paths(target, input, vec![vec![]], budget, depth + 1)?;
+            let mut output = budget.clone_value(input)?;
+            for path in paths {
+                let old = get_path(input, &path).unwrap_or(&Value::Null);
+                let context = if *operation == Update::Replace {
+                    old
+                } else {
+                    input
+                };
+                let Some(right) = one(value, context, budget, depth)? else {
+                    continue;
+                };
+                let replacement = match operation {
+                    Update::Assign | Update::Replace => right,
+                    Update::Add => binary(Op::Add, old, &right, budget, 0)?,
+                    Update::Sub => binary(Op::Sub, old, &right, budget, 0)?,
+                    Update::Mul => binary(Op::Mul, old, &right, budget, 0)?,
+                };
+                set_path(&mut output, &path, replacement, budget, 0)?;
+            }
+            Ok(vec![output])
+        }
+        Node::Delete(targets) => {
+            let mut paths = Vec::new();
+            for target in targets {
+                paths.extend(select_paths(
+                    target,
+                    input,
+                    vec![vec![]],
+                    budget,
+                    depth + 1,
+                )?);
+            }
+            if paths.iter().any(Vec::is_empty) {
+                return Err(error("provider override cannot delete the root"));
+            }
+            // Long paths first; equal-depth array indexes descend, preserving original selectors.
+            paths.sort_by(|a, b| b.len().cmp(&a.len()).then_with(|| b.cmp(a)));
+            paths.dedup();
+            let mut output = budget.clone_value(input)?;
+            for path in paths {
+                delete_path(&mut output, &path, budget)?;
+            }
+            Ok(vec![output])
+        }
+        Node::Pipe(_, _) | Node::Union(_, _) | Node::Group(_) => {
+            let input = budget.clone_value(input)?;
+            evaluate(node, vec![input], budget, depth + 1)
+        }
+    }
+}
+fn full_case_map(input: &str, upper: bool, budget: &mut Budget<'_>) -> Result<String> {
+    if upper {
+        bounded_case_output(input.chars().flat_map(char::to_uppercase), budget)
+    } else {
+        bounded_case_output(input.chars().flat_map(char::to_lowercase), budget)
+    }
+}
+fn bounded_case_output(
+    mut chars: impl Iterator<Item = char>,
+    budget: &mut Budget<'_>,
+) -> Result<String> {
+    let mut output = String::new();
+    budget.reserve(0)?;
+    loop {
+        let mut batch = ['\0'; 128];
+        let mut count = 0;
+        let mut bytes = 0;
+        for (index, character) in chars.by_ref().take(batch.len()).enumerate() {
+            batch[index] = character;
+            count = index + 1;
+            bytes += character.len_utf8();
+        }
+        if count == 0 {
+            break;
+        }
+        budget.reserve(bytes)?;
+        for character in &batch[..count] {
+            output.push(*character);
+        }
+    }
+    Ok(output)
+}
+fn append(output: &mut String, text: &str, budget: &mut Budget<'_>) -> Result<()> {
+    budget.reserve(text.len())?;
+    output.push_str(text);
+    Ok(())
+}
+fn lookup(
+    value: &Value,
+    path: &[Segment],
+    budget: &mut Budget<'_>,
+    depth: usize,
+) -> Result<Vec<Value>> {
+    budget.tick(1)?;
+    if depth > VALUE_DEPTH {
+        return Err(error("provider override value depth exceeded"));
+    }
+    let Some((segment, rest)) = path.split_first() else {
+        return Ok(vec![budget.clone_value(value)?]);
+    };
+    match segment {
+        Segment::Key(key) => lookup(
+            value
+                .as_mapping()
+                .and_then(|map| map.get(key.as_str()))
+                .unwrap_or(&Value::Null),
+            rest,
+            budget,
+            depth + 1,
+        ),
+        Segment::Index(index) => lookup(
+            value
+                .as_sequence()
+                .and_then(|array| {
+                    normalized_index(*index, array.len()).and_then(|index| array.get(index))
+                })
+                .unwrap_or(&Value::Null),
+            rest,
+            budget,
+            depth + 1,
+        ),
+        Segment::Each => {
+            let mut output = Vec::new();
+            if !value.is_sequence() && !value.is_mapping() {
+                return Ok(output);
+            }
+            for (_, value) in members(value, budget)? {
+                output.extend(lookup(value, rest, budget, depth + 1)?);
+            }
+            Ok(output)
+        }
+    }
+}
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
+enum Key {
+    Field(String),
+    Index(usize),
+}
+fn normalized_index(index: i64, length: usize) -> Option<usize> {
+    if index < 0 {
+        usize::try_from(i64::try_from(length).ok()?.checked_add(index)?).ok()
+    } else {
+        usize::try_from(index).ok()
+    }
+}
+fn members<'a>(value: &'a Value, budget: &mut Budget<'_>) -> Result<Vec<(Key, &'a Value)>> {
+    let length = match value {
+        Value::Sequence(values) => values.len(),
+        Value::Mapping(values) => values.len(),
+        _ => 0,
+    };
+    budget.tick(length.saturating_mul(1 + length.checked_ilog2().unwrap_or(0) as usize))?;
+    budget.reserve(length.saturating_mul(std::mem::size_of::<(Key, &Value)>()))?;
+    if let Value::Mapping(map) = value {
+        for key in map.keys() {
+            if let Some(key) = key.as_str() {
+                budget.reserve(key.len())?;
+            }
+        }
+    }
+    match value {
+        Value::Sequence(values) => Ok(values
+            .iter()
+            .enumerate()
+            .map(|(index, value)| (Key::Index(index), value))
+            .collect()),
+        Value::Mapping(map) => {
+            let mut values = map
+                .iter()
+                .map(|(key, value)| {
+                    key.as_str()
+                        .map(|key| (Key::Field(key.into()), value))
+                        .ok_or_else(|| error("provider override requires string mapping keys"))
+                })
+                .collect::<Result<Vec<_>>>()?;
+            values.sort_by(|(a, _), (b, _)| a.cmp(b));
+            Ok(values)
+        }
+        _ => Err(error(
+            "provider override collection function requires an array or mapping",
+        )),
+    }
+}
+fn get_path<'a>(value: &'a Value, path: &[Key]) -> Option<&'a Value> {
+    let mut current = value;
+    for key in path {
+        current = match key {
+            Key::Field(key) => current.as_mapping()?.get(key.as_str())?,
+            Key::Index(index) => current.as_sequence()?.get(*index)?,
+        };
+    }
+    Some(current)
+}
+fn select_paths(
+    node: &Node,
+    root: &Value,
+    inputs: Vec<Vec<Key>>,
+    budget: &mut Budget<'_>,
+    depth: usize,
+) -> Result<Vec<Vec<Key>>> {
+    budget.tick(1)?;
+    if depth > PARSE_DEPTH {
+        return Err(error("provider override target depth exceeded"));
+    }
+    match node {
+        Node::Group(node) => select_paths(node, root, inputs, budget, depth + 1),
+        Node::Pipe(left, right) => {
+            let inputs = select_paths(left, root, inputs, budget, depth + 1)?;
+            select_paths(right, root, inputs, budget, depth + 1)
+        }
+        Node::Union(left, right) => {
+            budget.reserve(
+                inputs
+                    .iter()
+                    .map(|path| {
+                        path.len() * std::mem::size_of::<Key>()
+                            + path
+                                .iter()
+                                .map(|key| match key {
+                                    Key::Field(key) => key.len(),
+                                    Key::Index(_) => 0,
+                                })
+                                .sum::<usize>()
+                    })
+                    .sum(),
+            )?;
+            let mut output = select_paths(left, root, inputs.clone(), budget, depth + 1)?;
+            output.extend(select_paths(right, root, inputs, budget, depth + 1)?);
+            Ok(output)
+        }
+        Node::Call(name, args) if name == "select" => {
+            let mut output = Vec::new();
+            for path in inputs {
+                if let Some(value) = one(
+                    &args[0],
+                    get_path(root, &path).unwrap_or(&Value::Null),
+                    budget,
+                    depth,
+                )? && truthy(&value)
+                {
+                    output.push(path);
+                }
+            }
+            Ok(output)
+        }
+        Node::Path(segments) => {
+            let mut paths = inputs;
+            for segment in segments {
+                let mut next = Vec::new();
+                for path in paths {
+                    budget.tick(1)?;
+                    let old = get_path(root, &path).unwrap_or(&Value::Null);
+                    let keys = match segment {
+                        Segment::Key(key) if old.is_null() || old.is_mapping() => {
+                            budget.reserve(key.len() + std::mem::size_of::<Key>())?;
+                            vec![Key::Field(key.clone())]
+                        }
+                        Segment::Index(index) if old.is_null() || old.is_sequence() => {
+                            normalized_index(*index, old.as_sequence().map_or(0, Vec::len))
+                                .map(|index| vec![Key::Index(index)])
+                                .unwrap_or_default()
+                        }
+                        Segment::Each if old.is_sequence() || old.is_mapping() => {
+                            members(old, budget)?
+                                .into_iter()
+                                .map(|(key, _)| key)
+                                .collect()
+                        }
+                        _ => vec![],
+                    };
+                    for key in keys {
+                        budget.reserve((path.len() + 1) * std::mem::size_of::<Key>())?;
+                        for key in &path {
+                            if let Key::Field(key) = key {
+                                budget.reserve(key.len())?;
+                            }
+                        }
+                        let mut selected = path.clone();
+                        selected.push(key);
+                        next.push(selected);
+                    }
+                }
+                paths = next;
+            }
+            Ok(paths)
+        }
+        _ => Err(error("invalid provider override update target")),
+    }
+}
+fn set_path(
+    value: &mut Value,
+    path: &[Key],
+    replacement: Value,
+    budget: &mut Budget<'_>,
+    depth: usize,
+) -> Result<()> {
+    budget.tick(1)?;
+    if depth > VALUE_DEPTH {
+        return Err(error("provider override target depth exceeded"));
+    }
+    let Some((key, rest)) = path.split_first() else {
+        *value = replacement;
+        return Ok(());
+    };
+    match key {
+        Key::Field(key) => {
+            if value.is_null() {
+                *value = Value::Mapping(Mapping::new());
+            }
+            if let Some(map) = value.as_mapping_mut() {
+                if !map.contains_key(key.as_str()) {
+                    budget.reserve(key.len() + 2 * std::mem::size_of::<Value>())?;
+                    map.insert(Value::String(key.clone()), Value::Null);
+                }
+                set_path(
+                    map.get_mut(key.as_str()).expect("inserted entry"),
+                    rest,
+                    replacement,
+                    budget,
+                    depth + 1,
+                )?;
+            }
+        }
+        Key::Index(index) => {
+            if value.is_null() {
+                *value = Value::Sequence(vec![]);
+            }
+            if let Some(array) = value.as_sequence_mut() {
+                if *index >= array.len() {
+                    let length = index
+                        .checked_add(1)
+                        .ok_or_else(|| error("provider override array budget exceeded"))?;
+                    budget.tick(length - array.len())?;
+                    budget.reserve(
+                        (length - array.len())
+                            .checked_mul(std::mem::size_of::<Value>())
+                            .ok_or_else(|| error("provider override array budget exceeded"))?,
+                    )?;
+                    array.resize(length, Value::Null);
+                }
+                set_path(&mut array[*index], rest, replacement, budget, depth + 1)?;
+            }
+        }
+    }
+    Ok(())
+}
+fn delete_path(value: &mut Value, path: &[Key], budget: &mut Budget<'_>) -> Result<()> {
+    budget.tick(1)?;
+    let Some((key, rest)) = path.split_first() else {
+        return Err(error("provider override cannot delete the root"));
+    };
+    match key {
+        Key::Field(key) => {
+            if let Some(map) = value.as_mapping_mut() {
+                if rest.is_empty() {
+                    map.remove(key.as_str());
+                } else if let Some(value) = map.get_mut(key.as_str()) {
+                    delete_path(value, rest, budget)?;
+                }
+            }
+        }
+        Key::Index(index) => {
+            if let Some(array) = value.as_sequence_mut()
+                && *index < array.len()
+            {
+                if rest.is_empty() {
+                    array.remove(*index);
+                } else {
+                    delete_path(&mut array[*index], rest, budget)?;
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+fn truthy(value: &Value) -> bool {
+    !matches!(value, Value::Null | Value::Bool(false))
+}
+fn scalar_text(value: &Value) -> Option<String> {
+    match value {
+        Value::Null => Some("null".into()),
+        Value::Bool(value) => Some(value.to_string()),
+        Value::Number(value) if value.is_f64() => value.as_f64().map(float_text),
+        Value::Number(value) => Some(value.to_string()),
+        Value::String(value) => Some(value.clone()),
+        _ => None,
+    }
+}
+fn float_text(value: f64) -> String {
+    if value.is_nan() {
+        return "NaN".into();
+    }
+    if value.is_infinite() {
+        return if value.is_sign_negative() {
+            "-Inf"
+        } else {
+            "+Inf"
+        }
+        .into();
+    }
+    let scientific = format!("{value:e}");
+    let (mantissa, exponent) = scientific.split_once('e').expect("float exponent");
+    let exponent: i32 = exponent.parse().expect("numeric exponent");
+    if !(-4..6).contains(&exponent) {
+        format!("{mantissa}e{exponent:+03}")
+    } else {
+        value.to_string()
+    }
+}
+fn text(value: &Value, budget: &mut Budget<'_>) -> Result<String> {
+    if let Value::String(value) = value {
+        budget.reserve(value.len())?;
+        return Ok(value.clone());
+    }
+    if let Value::Number(number) = value
+        && number.as_f64().is_some_and(|value| !value.is_finite())
+    {
+        let text = yaml_scalar(value, budget)?;
+        budget.reserve(text.len())?;
+        return Ok(text);
+    }
+    if let Some(text) = scalar_text(value) {
+        budget.reserve(text.len())?;
+        return Ok(text);
+    }
+    budget.measure(value, 0)?;
+    let sorted = sorted_value(value, budget, 0)?;
+    render(&sorted, budget)
+}
+fn render(value: &Value, budget: &mut Budget<'_>) -> Result<String> {
+    let mut output = String::new();
+    render_node(value, 0, false, &mut output, budget, 0)?;
+    if output.ends_with('\n') {
+        output.pop();
+    }
+    Ok(output)
+}
+
+fn render_node(
+    value: &Value,
+    indentation: usize,
+    inline: bool,
+    output: &mut String,
+    budget: &mut Budget<'_>,
+    depth: usize,
+) -> Result<()> {
+    budget.tick(1)?;
+    if depth > VALUE_DEPTH {
+        return Err(error("provider override value depth exceeded"));
+    }
+    let pad = |output: &mut String, budget: &mut Budget<'_>| {
+        for _ in 0..indentation {
+            append(output, " ", budget)?;
+        }
+        Ok::<_, VoleError>(())
+    };
+    match value {
+        Value::Mapping(map) if !map.is_empty() => {
+            let mut fields = members(value, budget)?;
+            fields.sort_by(|(a, _), (b, _)| {
+                let (Key::Field(a), Key::Field(b)) = (a, b) else {
+                    unreachable!()
+                };
+                yaml_key_order(a, b)
+            });
+            for (index, (key, value)) in fields.into_iter().enumerate() {
+                if !inline || index != 0 {
+                    pad(output, budget)?;
+                }
+                let Key::Field(key) = key else { unreachable!() };
+                let rendered = yaml_scalar(&Value::String(key), budget)?;
+                append(output, &rendered, budget)?;
+                append(output, ":", budget)?;
+                if matches!(value, Value::Mapping(map) if !map.is_empty())
+                    || matches!(value, Value::Sequence(items) if !items.is_empty())
+                {
+                    append(output, "\n", budget)?;
+                    render_node(
+                        value,
+                        (indentation / 4 + 1) * 4,
+                        false,
+                        output,
+                        budget,
+                        depth + 1,
+                    )?;
+                } else {
+                    append(output, " ", budget)?;
+                    render_node(value, indentation, true, output, budget, depth + 1)?;
+                }
+            }
+        }
+        Value::Sequence(items) if !items.is_empty() => {
+            for (index, value) in items.iter().enumerate() {
+                if !inline || index != 0 {
+                    pad(output, budget)?;
+                }
+                append(output, "- ", budget)?;
+                render_node(value, indentation + 2, true, output, budget, depth + 1)?;
+            }
+        }
+        Value::String(text)
+            if text.contains('\n')
+                && !text
+                    .chars()
+                    .any(|ch| ch.is_control() && !matches!(ch, '\n' | '\t')) =>
+        {
+            if !inline {
+                pad(output, budget)?;
+            }
+            let suffix = if !text.ends_with('\n') {
+                "-"
+            } else if text.ends_with("\n\n") || text == "\n" {
+                "+"
+            } else {
+                ""
+            };
+            let explicit_indent = text
+                .lines()
+                .find(|line| !line.is_empty())
+                .is_some_and(|line| line.starts_with(' '));
+            append(output, "|", budget)?;
+            if explicit_indent {
+                append(
+                    output,
+                    if indentation.is_multiple_of(4) {
+                        "4"
+                    } else {
+                        "2"
+                    },
+                    budget,
+                )?;
+            }
+            append(output, suffix, budget)?;
+            append(output, "\n", budget)?;
+            for line in text.split_inclusive('\n') {
+                if line != "\n" {
+                    for _ in 0..(indentation / 4 + 1) * 4 {
+                        append(output, " ", budget)?;
+                    }
+                }
+                append(output, line, budget)?;
+                if !line.ends_with('\n') {
+                    append(output, "\n", budget)?;
+                }
+            }
+        }
+        _ => {
+            if !inline {
+                pad(output, budget)?;
+            }
+            let rendered = yaml_scalar(value, budget)?;
+            append(output, &rendered, budget)?;
+            append(output, "\n", budget)?;
+        }
+    }
+    Ok(())
+}
+
+fn yaml_scalar(value: &Value, budget: &mut Budget<'_>) -> Result<String> {
+    if let Value::Number(number) = value {
+        return Ok(if number.is_f64() {
+            let number = number.as_f64().expect("float");
+            if number.is_nan() {
+                ".nan".into()
+            } else if number.is_infinite() {
+                if number.is_sign_negative() {
+                    "-.inf"
+                } else {
+                    ".inf"
+                }
+                .into()
+            } else {
+                float_text(number)
+            }
+        } else {
+            number.to_string()
+        });
+    }
+    if let Value::String(text) = value {
+        budget.reserve(text.len().saturating_mul(6).saturating_add(2))?;
+        let lower = text.to_ascii_lowercase();
+        let ambiguous = text.is_empty()
+            || matches!(
+                lower.as_str(),
+                "y" | "n"
+                    | "yes"
+                    | "no"
+                    | "on"
+                    | "off"
+                    | "true"
+                    | "false"
+                    | "null"
+                    | "~"
+                    | ".inf"
+                    | "+.inf"
+                    | "-.inf"
+                    | ".nan"
+            )
+            || text.parse::<f64>().is_ok()
+            || ["0x", "0X", "0o", "0O", "0b", "0B"].iter().any(|prefix| {
+                text.strip_prefix(['+', '-'])
+                    .unwrap_or(text)
+                    .strip_prefix(prefix)
+                    .is_some_and(|digits| {
+                        !digits.is_empty()
+                            && digits.bytes().all(|byte| match *prefix {
+                                "0x" | "0X" => byte.is_ascii_hexdigit() || byte == b'_',
+                                "0o" | "0O" => matches!(byte, b'0'..=b'7' | b'_'),
+                                _ => matches!(byte, b'0' | b'1' | b'_'),
+                            })
+                    })
+            })
+            || (text.len() >= 10
+                && text.as_bytes()[4] == b'-'
+                && text.as_bytes()[7] == b'-'
+                && text[..4].bytes().all(|byte| byte.is_ascii_digit()))
+            || text
+                .chars()
+                .any(|ch| ch.is_control() || matches!(ch, '\u{a0}' | '\u{2028}' | '\u{2029}'));
+        if ambiguous {
+            let mut output = String::new();
+            append(&mut output, "\"", budget)?;
+            for character in text.chars() {
+                let escaped = match character {
+                    '\0' => Some(r"\0"),
+                    '\u{7}' => Some(r"\a"),
+                    '\u{8}' => Some(r"\b"),
+                    '\t' => Some(r"\t"),
+                    '\n' => Some(r"\n"),
+                    '\u{b}' => Some(r"\v"),
+                    '\u{c}' => Some(r"\f"),
+                    '\r' => Some(r"\r"),
+                    '\u{1b}' => Some(r"\e"),
+                    '\u{85}' => Some(r"\N"),
+                    '\u{a0}' => Some(r"\_"),
+                    '\u{2028}' => Some(r"\L"),
+                    '\u{2029}' => Some(r"\P"),
+                    '"' => Some(r#"\""#),
+                    '\\' => Some(r"\\"),
+                    _ => None,
+                };
+                if let Some(escaped) = escaped {
+                    append(&mut output, escaped, budget)?;
+                } else if character.is_control() {
+                    append(&mut output, &format!("\\x{:02X}", character as u32), budget)?;
+                } else {
+                    let mut encoded = [0; 4];
+                    append(&mut output, character.encode_utf8(&mut encoded), budget)?;
+                }
+            }
+            append(&mut output, "\"", budget)?;
+            return Ok(output);
+        }
+    }
+    let rendered = serde_yaml_ng::to_string(value)
+        .map_err(|_| error("provider override value cannot be rendered"))?;
+    budget.reserve(rendered.len())?;
+    Ok(rendered.trim_end_matches('\n').into())
+}
+
+fn yaml_key_order(left: &str, right: &str) -> Ordering {
+    let (mut left, mut right) = (left.as_bytes(), right.as_bytes());
+    while let (Some(a), Some(b)) = (left.first(), right.first()) {
+        if a.is_ascii_digit() && b.is_ascii_digit() {
+            let left_end = left
+                .iter()
+                .position(|byte| !byte.is_ascii_digit())
+                .unwrap_or(left.len());
+            let right_end = right
+                .iter()
+                .position(|byte| !byte.is_ascii_digit())
+                .unwrap_or(right.len());
+            let (a, b) = (&left[..left_end], &right[..right_end]);
+            let a = &a[a.iter().position(|byte| *byte != b'0').unwrap_or(a.len())..];
+            let b = &b[b.iter().position(|byte| *byte != b'0').unwrap_or(b.len())..];
+            let ordering = a
+                .len()
+                .cmp(&b.len())
+                .then_with(|| a.cmp(b))
+                .then_with(|| left_end.cmp(&right_end));
+            if !ordering.is_eq() {
+                return ordering;
+            }
+            left = &left[left_end..];
+            right = &right[right_end..];
+        } else {
+            let ordering = a.cmp(b);
+            if !ordering.is_eq() {
+                return ordering;
+            }
+            left = &left[1..];
+            right = &right[1..];
+        }
+    }
+    left.len().cmp(&right.len())
+}
+fn sorted_value(value: &Value, budget: &mut Budget<'_>, depth: usize) -> Result<Value> {
+    budget.tick(1)?;
+    if depth > VALUE_DEPTH {
+        return Err(error("provider override value depth exceeded"));
+    }
+    match value {
+        Value::Mapping(_) => {
+            let mut map = Mapping::new();
+            for (key, value) in members(value, budget)? {
+                let Key::Field(key) = key else { unreachable!() };
+                budget.reserve(key.len() + 2 * std::mem::size_of::<Value>())?;
+                map.insert(Value::String(key), sorted_value(value, budget, depth + 1)?);
+            }
+            Ok(Value::Mapping(map))
+        }
+        Value::Sequence(values) => Ok(Value::Sequence(
+            values
+                .iter()
+                .map(|value| sorted_value(value, budget, depth + 1))
+                .collect::<Result<Vec<_>>>()?,
+        )),
+        _ => budget.clone_value(value),
+    }
+}
+fn equality(a: &Value, b: &Value) -> bool {
+    if a.is_null() || b.is_null() {
+        return a.is_null() && b.is_null();
+    }
+    if let (Value::Number(a), Value::Number(b)) = (a, b) {
+        return a.is_f64() == b.is_f64() && a.as_f64() == b.as_f64();
+    }
+    scalar_text(a)
+        .zip(scalar_text(b))
+        .is_some_and(|(a, b)| a == b)
+}
+fn numeric(value: &Value) -> Result<f64> {
+    value
+        .as_f64()
+        .ok_or_else(|| error("provider override operator requires numbers"))
+}
+fn scalar_order(a: &Value, b: &Value) -> Result<Ordering> {
+    match (a, b) {
+        (Value::Number(_), Value::Number(_)) => Ok(numeric(a)?
+            .partial_cmp(&numeric(b)?)
+            .unwrap_or(Ordering::Equal)),
+        (Value::String(a), Value::String(b)) => Ok(a.cmp(b)),
+        _ => Err(error(
+            "provider override ordered comparison requires compatible scalars",
+        )),
+    }
+}
+fn sort_order(a: &Value, b: &Value) -> Ordering {
+    fn rank(value: &Value) -> u8 {
+        match value {
+            Value::Null => 0,
+            Value::Bool(_) => 1,
+            Value::Number(_) => 2,
+            Value::String(_) => 3,
+            _ => 4,
+        }
+    }
+    rank(a).cmp(&rank(b)).then_with(|| match (a, b) {
+        (Value::Bool(a), Value::Bool(b)) => a.cmp(b),
+        (Value::Number(_), Value::Number(_)) => a
+            .as_f64()
+            .unwrap_or(0.0)
+            .partial_cmp(&b.as_f64().unwrap_or(0.0))
+            .unwrap_or(Ordering::Equal),
+        (Value::String(a), Value::String(b)) => a.cmp(b),
+        _ => Ordering::Equal,
+    })
+}
+fn binary(
+    operator: Op,
+    a: &Value,
+    b: &Value,
+    budget: &mut Budget<'_>,
+    depth: usize,
+) -> Result<Value> {
+    budget.tick(1)?;
+    if depth > VALUE_DEPTH {
+        return Err(error("provider override value depth exceeded"));
+    }
+    match operator {
+        Op::Eq => return Ok(Value::Bool(equality(a, b))),
+        Op::Ne => return Ok(Value::Bool(!equality(a, b))),
+        Op::And => return Ok(Value::Bool(truthy(a) && truthy(b))),
+        Op::Or => return Ok(Value::Bool(truthy(a) || truthy(b))),
+        Op::Lt | Op::Le | Op::Gt | Op::Ge => {
+            if !matches!(
+                a,
+                Value::Null | Value::Bool(_) | Value::Number(_) | Value::String(_)
+            ) || !matches!(
+                b,
+                Value::Null | Value::Bool(_) | Value::Number(_) | Value::String(_)
+            ) {
+                return Err(error(
+                    "provider override ordered comparison requires scalars",
+                ));
+            }
+            if a.is_null() || b.is_null() {
+                return Ok(Value::Bool(
+                    a.is_null() && b.is_null() && matches!(operator, Op::Le | Op::Ge),
+                ));
+            }
+            let ordering = scalar_order(a, b)?;
+            return Ok(Value::Bool(match operator {
+                Op::Lt => ordering.is_lt(),
+                Op::Le => !ordering.is_gt(),
+                Op::Gt => ordering.is_gt(),
+                _ => !ordering.is_lt(),
+            }));
+        }
+        _ => {}
+    }
+    if matches!(operator, Op::Add | Op::Sub) && a.is_null() {
+        return budget.clone_value(b);
+    }
+    if operator == Op::Mul && b.is_null() {
+        return budget.clone_value(a);
+    }
+    if operator == Op::Mul && a.is_null() && (b.is_sequence() || b.is_mapping()) {
+        return budget.clone_value(b);
+    }
+    if operator == Op::Add && b.is_null() && (a.is_string() || a.is_sequence()) {
+        return budget.clone_value(a);
+    }
+    if operator == Op::Add && b.is_string() && !a.is_sequence() && !a.is_mapping() {
+        let left = scalar_text(a)
+            .ok_or_else(|| error("provider override string addition requires a scalar"))?;
+        let mut output = String::new();
+        append(&mut output, &left, budget)?;
+        append(&mut output, b.as_str().expect("string"), budget)?;
+        return Ok(Value::String(output));
+    }
+    if operator == Op::Add {
+        match (a, b) {
+            (Value::String(left), _) => {
+                let Some(right) = scalar_text(b) else {
+                    return Err(error("provider override string addition requires a scalar"));
+                };
+                let mut result = String::new();
+                append(&mut result, left, budget)?;
+                append(&mut result, &right, budget)?;
+                return Ok(Value::String(result));
+            }
+            (Value::Sequence(left), Value::Sequence(right)) => {
+                let mut values = left
+                    .iter()
+                    .map(|value| budget.clone_value(value))
+                    .collect::<Result<Vec<_>>>()?;
+                for value in right {
+                    values.push(budget.clone_value(value)?);
+                }
+                return Ok(Value::Sequence(values));
+            }
+            (Value::Sequence(left), _) => {
+                let mut values = left
+                    .iter()
+                    .map(|value| budget.clone_value(value))
+                    .collect::<Result<Vec<_>>>()?;
+                values.push(budget.clone_value(b)?);
+                return Ok(Value::Sequence(values));
+            }
+            (Value::Mapping(left), Value::Mapping(right)) => {
+                let Value::Mapping(mut result) = budget.clone_value(a)? else {
+                    unreachable!()
+                };
+                for (key, value) in right {
+                    result.insert(budget.clone_value(key)?, budget.clone_value(value)?);
+                }
+                let _ = left;
+                return Ok(Value::Mapping(result));
+            }
+            _ => {}
+        }
+    }
+    if operator == Op::Sub
+        && let (Value::Sequence(left), Value::Sequence(right)) = (a, b)
+    {
+        let mut result = Vec::new();
+        for value in left {
+            if !right.iter().any(|other| value == other) {
+                result.push(budget.clone_value(value)?);
+            }
+        }
+        return Ok(Value::Sequence(result));
+    }
+    if operator == Op::Mul {
+        if let (Value::Mapping(_), Value::Mapping(right)) = (a, b) {
+            let Value::Mapping(mut result) = budget.clone_value(a)? else {
+                unreachable!()
+            };
+            for (key, value) in right {
+                let merged = if let Some(old) = result.get(key)
+                    && old.is_mapping()
+                    && value.is_mapping()
+                {
+                    binary(Op::Mul, old, value, budget, depth + 1)?
+                } else {
+                    budget.clone_value(value)?
+                };
+                result.insert(budget.clone_value(key)?, merged);
+            }
+            return Ok(Value::Mapping(result));
+        }
+        if a.is_sequence() && b.is_sequence() {
+            return budget.clone_value(b);
+        }
+        let string_number = match (a, b) {
+            (Value::String(text), Value::Number(number))
+            | (Value::Number(number), Value::String(text)) => Some((text, number)),
+            _ => None,
+        };
+        if let Some((text, number)) = string_number {
+            let count = number
+                .as_i64()
+                .and_then(|number| usize::try_from(number).ok())
+                .ok_or_else(|| {
+                    error("provider override string repetition requires a nonnegative integer")
+                })?;
+            let bytes = text
+                .len()
+                .checked_mul(count)
+                .ok_or_else(|| error("provider override output budget exceeded"))?;
+            budget.reserve(bytes)?;
+            return Ok(Value::String(text.repeat(count)));
+        }
+    }
+    if operator == Op::Div
+        && let (Value::String(text), Value::String(separator)) = (a, b)
+    {
+        return if text.is_empty() {
+            Ok(Value::Sequence(Vec::new()))
+        } else {
+            split(text, separator, budget)
+        };
+    }
+    if !a.is_number() || !b.is_number() {
+        return Err(error(
+            "provider override operator has incompatible operands",
+        ));
+    }
+    if matches!(a, Value::Number(number) if !number.is_f64())
+        && matches!(b, Value::Number(number) if !number.is_f64())
+        && operator != Op::Div
+    {
+        // The reference projects integer operands through float64, saturates
+        // the signed conversion, then performs wrapping integer arithmetic.
+        let integer = |value: &Value| -> Result<i64> { Ok(numeric(value)? as i64) };
+        let (a, b) = (integer(a)?, integer(b)?);
+        let result = match operator {
+            Op::Add => a.wrapping_add(b),
+            Op::Sub => a.wrapping_sub(b),
+            Op::Mul => a.wrapping_mul(b),
+            Op::Mod if b == 0 => return Err(error("provider override cannot modulo integer zero")),
+            Op::Mod if a == i64::MIN && b == -1 => 0,
+            Op::Mod => a % b,
+            _ => return Err(error("invalid provider override operator")),
+        };
+        return Ok(Value::Number(result.into()));
+    }
+    let (a, b) = (numeric(a)?, numeric(b)?);
+    let number = match operator {
+        Op::Add => a + b,
+        Op::Sub => a - b,
+        Op::Mul => a * b,
+        Op::Div => a / b,
+        Op::Mod => a % b,
+        _ => return Err(error("invalid provider override operator")),
+    };
+    Ok(Value::Number(Number::from(number)))
+}
+fn split(text: &str, separator: &str, budget: &mut Budget<'_>) -> Result<Value> {
+    let mut values = Vec::new();
+    if text.is_empty() && separator.is_empty() {
+        return Ok(Value::Sequence(values));
+    }
+    if separator.is_empty() {
+        for ch in text.chars() {
+            budget.reserve(ch.len_utf8() + std::mem::size_of::<Value>())?;
+            values.push(Value::String(ch.to_string()));
+        }
+    } else {
+        for part in text.split(separator) {
+            budget.reserve(part.len() + std::mem::size_of::<Value>())?;
+            values.push(Value::String(part.into()));
+        }
+    }
+    Ok(Value::Sequence(values))
+}
+fn contains(
+    container: &Value,
+    wanted: &Value,
+    budget: &mut Budget<'_>,
+    depth: usize,
+) -> Result<bool> {
+    budget.tick(1)?;
+    if depth > VALUE_DEPTH {
+        return Err(error("provider override value depth exceeded"));
+    }
+    match (container, wanted) {
+        (Value::String(container), Value::String(wanted)) => Ok(container.contains(wanted)),
+        (Value::Mapping(container), Value::Mapping(wanted)) => {
+            for (key, value) in wanted {
+                let Some(other) = container.get(key) else {
+                    return Ok(false);
+                };
+                if !contains(other, value, budget, depth + 1)? {
+                    return Ok(false);
+                }
+            }
+            Ok(true)
+        }
+        (Value::Sequence(container), Value::Sequence(wanted)) => {
+            for value in wanted {
+                let mut found = false;
+                for other in container {
+                    if contains(other, value, budget, depth + 1)? {
+                        found = true;
+                        break;
+                    }
+                }
+                if !found {
+                    return Ok(false);
+                }
+            }
+            Ok(true)
+        }
+        (Value::Sequence(container), wanted) => {
+            for value in container {
+                if contains(value, wanted, budget, depth + 1)? {
+                    return Ok(true);
+                }
+            }
+            Ok(false)
+        }
+        (Value::Number(_), Value::Number(_)) => Ok(equality(container, wanted)),
+        _ => Ok(container == wanted),
+    }
+}
+
+fn transform(
+    args: &[Node],
+    inputs: Vec<Value>,
+    budget: &mut Budget<'_>,
+    depth: usize,
+) -> Result<Vec<Value>> {
+    let mut inputs = Some(inputs);
+    let mut output = Vec::new();
+    for (index, node) in args.iter().enumerate() {
+        let batch = if index + 1 == args.len() {
+            inputs.take().expect("last transform owns inputs")
+        } else {
+            inputs
+                .as_ref()
+                .expect("unconsumed inputs")
+                .iter()
+                .map(|value| budget.clone_value(value))
+                .collect::<Result<Vec<_>>>()?
+        };
+        let values = evaluate(node, batch, budget, depth + 1)?;
+        budget.reserve(values.len().saturating_mul(std::mem::size_of::<Value>()))?;
+        output.extend(values);
+    }
+    Ok(output)
+}
+
+fn call(
+    name: &str,
+    args: &[Node],
+    input: &Value,
+    budget: &mut Budget<'_>,
+    depth: usize,
+) -> Result<Vec<Value>> {
+    budget.tick(1)?;
+    if depth > PARSE_DEPTH {
+        return Err(error("provider override evaluation depth exceeded"));
+    }
+    if name == "select" {
+        return if one(&args[0], input, budget, depth)?.is_some_and(|value| truthy(&value)) {
+            Ok(vec![budget.clone_value(input)?])
+        } else {
+            Ok(vec![])
+        };
+    }
+    if [
+        "map",
+        "map_values",
+        "filter",
+        "any_c",
+        "all_c",
+        "with_entries",
+    ]
+    .contains(&name)
+    {
+        if name == "with_entries" {
+            if !input.is_mapping() {
+                return Err(error("provider override with_entries requires a mapping"));
+            }
+            let entries = entries(input, budget)?;
+            let mut result = Vec::new();
+            for entry in entries {
+                result.extend(transform(args, vec![entry], budget, depth + 1)?);
+            }
+            return Ok(vec![from_entries(&Value::Sequence(result), budget)?]);
+        }
+        if matches!(name, "any_c" | "all_c") && !input.is_sequence() {
+            return Err(error(
+                "provider override conditional query requires an array",
+            ));
+        }
+        let members = members(input, budget)?;
+        if name == "map" {
+            let inputs = members
+                .iter()
+                .map(|(_, value)| budget.clone_value(value))
+                .collect::<Result<Vec<_>>>()?;
+            return Ok(vec![Value::Sequence(transform(
+                args,
+                inputs,
+                budget,
+                depth + 1,
+            )?)]);
+        }
+        if matches!(name, "any_c" | "all_c") {
+            let result = name == "all_c";
+            for (_, value) in members {
+                let value = budget.clone_value(value)?;
+                let outputs = transform(args, vec![value], budget, depth + 1)?;
+                let Some(first) = outputs.first() else {
+                    continue;
+                };
+                let matched = truthy(first);
+                if name == "any_c" && matched || name == "all_c" && !matched {
+                    return Ok(vec![Value::Bool(matched)]);
+                }
+            }
+            return Ok(vec![Value::Bool(result)]);
+        }
+        if name == "filter" {
+            let mut output = Vec::new();
+            for (_, value) in members {
+                let copy = budget.clone_value(value)?;
+                if transform(args, vec![copy], budget, depth + 1)?
+                    .iter()
+                    .any(truthy)
+                {
+                    output.push(budget.clone_value(value)?);
+                }
+            }
+            return Ok(vec![Value::Sequence(output)]);
+        }
+        let mut output = budget.clone_value(input)?;
+        for (key, value) in members {
+            let copy = budget.clone_value(value)?;
+            if let Some(result) = transform(args, vec![copy], budget, depth + 1)?
+                .into_iter()
+                .next()
+            {
+                set_path(&mut output, &[key], result, budget, 0)?;
+            }
+        }
+        return Ok(vec![output]);
+    }
+    let mut arguments = Vec::new();
+    for argument in args {
+        let Some(value) = one(argument, input, budget, depth)? else {
+            return Ok(vec![]);
+        };
+        arguments.push(value);
+    }
+    let output = match name {
+        "length" => Value::Number(
+            match input {
+                Value::Null => 0,
+                Value::Sequence(value) => value.len(),
+                Value::Mapping(value) => value.len(),
+                _ => scalar_text(input)
+                    .ok_or_else(|| error("invalid provider override length input"))?
+                    .len(),
+            }
+            .into(),
+        ),
+        "keys" => Value::Sequence(
+            members(input, budget)?
+                .into_iter()
+                .map(|(key, _)| match key {
+                    Key::Field(key) => Value::String(key),
+                    Key::Index(index) => Value::Number(index.into()),
+                })
+                .collect(),
+        ),
+        "has" => Value::Bool(match input {
+            Value::Mapping(map) => map.contains_key(Value::String(
+                arguments[0]
+                    .as_str()
+                    .ok_or_else(|| error("provider override mapping key must be a string"))?
+                    .into(),
+            )),
+            Value::Sequence(values) => arguments[0]
+                .as_i64()
+                .and_then(|index| normalized_index(index, values.len()))
+                .is_some_and(|index| index < values.len()),
+            _ => false,
+        }),
+        "contains" => {
+            let compatible = match input {
+                Value::Mapping(_) => arguments[0].is_mapping(),
+                Value::Sequence(_) => arguments[0].is_sequence(),
+                Value::String(_) => arguments[0].is_string(),
+                _ => !arguments[0].is_mapping() && !arguments[0].is_sequence(),
+            };
+            if !compatible {
+                return Err(error(
+                    "provider override contains requires compatible value types",
+                ));
+            }
+            Value::Bool(contains(input, &arguments[0], budget, 0)?)
+        }
+        "reverse" => {
+            let Some(values) = input.as_sequence() else {
+                return Err(error("provider override reverse requires an array"));
+            };
+            Value::Sequence(
+                values
+                    .iter()
+                    .rev()
+                    .map(|value| budget.clone_value(value))
+                    .collect::<Result<Vec<_>>>()?,
+            )
+        }
+        "sort" => {
+            let Some(values) = input.as_sequence() else {
+                return Err(error("provider override sort requires an array"));
+            };
+            if values.iter().any(|value| {
+                value.is_sequence() || value.is_mapping() || matches!(value, Value::Tagged(_))
+            }) {
+                return Err(error("provider override sort requires scalar values"));
+            }
+            budget.tick(
+                values
+                    .len()
+                    .saturating_mul(1 + values.len().checked_ilog2().unwrap_or(0) as usize),
+            )?;
+            let mut values = values
+                .iter()
+                .map(|value| budget.clone_value(value))
+                .collect::<Result<Vec<_>>>()?;
+            values.sort_by(sort_order);
+            Value::Sequence(values)
+        }
+        "unique" => {
+            let Some(values) = input.as_sequence() else {
+                return Err(error("provider override unique requires an array"));
+            };
+            let mut seen = std::collections::BTreeSet::new();
+            let mut output = Vec::new();
+            for value in values {
+                let key = if let Some(key) = scalar_text(value) {
+                    budget.reserve(key.len())?;
+                    key
+                } else {
+                    let mut key = text(value, budget)?;
+                    append(&mut key, "\n", budget)?;
+                    key
+                };
+                if seen.insert(key) {
+                    output.push(budget.clone_value(value)?);
+                }
+            }
+            Value::Sequence(output)
+        }
+        "flatten" => {
+            let Some(values) = input.as_sequence() else {
+                return Err(error("provider override flatten requires an array"));
+            };
+            let flatten_depth = if arguments.is_empty() {
+                VALUE_DEPTH
+            } else {
+                arguments[0]
+                    .as_i64()
+                    .and_then(|value| usize::try_from(value).ok())
+                    .ok_or_else(|| {
+                        error("provider override flatten depth must be a nonnegative integer")
+                    })?
+            };
+            let mut output = Vec::new();
+            flatten(values, flatten_depth, &mut output, budget, 0)?;
+            Value::Sequence(output)
+        }
+        "any" | "all" => {
+            let Some(values) = input.as_sequence() else {
+                return Err(error("provider override query requires an array"));
+            };
+            Value::Bool(if name == "any" {
+                values.iter().any(truthy)
+            } else {
+                values.iter().all(truthy)
+            })
+        }
+        "to_entries" => {
+            if input.is_null() {
+                return Ok(vec![]);
+            }
+            Value::Sequence(entries(input, budget)?)
+        }
+        "from_entries" => from_entries(input, budget)?,
+        "test" => {
+            let pattern = arguments[0]
+                .as_str()
+                .ok_or_else(|| error("provider override test pattern must be a string"))?;
+            if arguments
+                .get(1)
+                .is_some_and(|flags| flags.as_str() != Some("g"))
+            {
+                return Err(error("unsupported provider override regex flags"));
+            }
+            let input = input
+                .as_str()
+                .ok_or_else(|| error("provider override test requires a string"))?;
+            let regex = budget.regex(pattern)?;
+            budget.tick(input.len() / 64 + 1)?;
+            Value::Bool(regex.is_match(input))
+        }
+        "sub" => {
+            let pattern = arguments[0]
+                .as_str()
+                .ok_or_else(|| error("provider override replacement pattern must be a string"))?;
+            let target = arguments[1]
+                .as_str()
+                .ok_or_else(|| error("provider override replacement target must be a string"))?;
+            let input = input
+                .as_str()
+                .ok_or_else(|| error("provider override replacement requires a string"))?;
+            let regex = budget.regex(pattern)?;
+            let mut output = String::new();
+            let mut last = 0;
+            for captures in regex.captures_iter(input) {
+                budget.tick(1)?;
+                let matched = captures.get(0).expect("whole regex match");
+                append(&mut output, &input[last..matched.start()], budget)?;
+                expand_replacement(target, &captures, &mut output, budget)?;
+                last = matched.end();
+            }
+            append(&mut output, &input[last..], budget)?;
+            Value::String(output)
+        }
+        "split" => {
+            if input.is_null() {
+                return Ok(vec![]);
+            }
+            let separator = arguments[0]
+                .as_str()
+                .ok_or_else(|| error("provider override separator must be a string"))?;
+            split(
+                input
+                    .as_str()
+                    .ok_or_else(|| error("provider override split requires a string"))?,
+                separator,
+                budget,
+            )?
+        }
+        "join" => {
+            let separator = arguments[0]
+                .as_str()
+                .ok_or_else(|| error("provider override separator must be a string"))?;
+            let values = input
+                .as_sequence()
+                .ok_or_else(|| error("provider override join requires an array"))?;
+            let mut output = String::new();
+            for (index, value) in values.iter().enumerate() {
+                if index != 0 {
+                    append(&mut output, separator, budget)?;
+                }
+                if !value.is_null()
+                    && let Some(value) = scalar_text(value)
+                {
+                    append(&mut output, &value, budget)?;
+                }
+            }
+            Value::String(output)
+        }
+        "upcase" | "downcase" | "trim" => {
+            let value = input
+                .as_str()
+                .ok_or_else(|| error("provider override string transform requires a string"))?;
+            Value::String(match name {
+                "upcase" => full_case_map(value, true, budget)?,
+                "downcase" => full_case_map(value, false, budget)?,
+                _ => {
+                    budget.reserve(value.len().saturating_mul(3))?;
+                    value.trim().to_owned()
+                }
+            })
+        }
+        "tostring" => {
+            if let Value::String(text) = input {
+                budget.reserve(text.len())?;
+                Value::String(text.clone())
+            } else {
+                let sorted = sorted_value(input, budget, 0)?;
+                Value::String(render(&sorted, budget)?)
+            }
+        }
+        "tonumber" => {
+            if input.is_number() {
+                budget.clone_value(input)?
+            } else {
+                number_value(
+                    input.as_str().ok_or_else(|| {
+                        error("provider override tonumber requires a string or number")
+                    })?,
+                    true,
+                )?
+            }
+        }
+        "type" => Value::String(
+            match input {
+                Value::Null => "!!null",
+                Value::Bool(_) => "!!bool",
+                Value::Number(number) if number.is_f64() => "!!float",
+                Value::Number(_) => "!!int",
+                Value::String(_) => "!!str",
+                Value::Sequence(_) => "!!seq",
+                Value::Mapping(_) => "!!map",
+                Value::Tagged(_) => {
+                    return Err(error("provider override does not support YAML tags"));
+                }
+            }
+            .into(),
+        ),
+        "not" => Value::Bool(!truthy(input)),
+        _ => return Err(error("unsupported provider override function")),
+    };
+    budget.measure(&output, 0)?;
+    Ok(vec![output])
+}
+fn entries(input: &Value, budget: &mut Budget<'_>) -> Result<Vec<Value>> {
+    let mut output = Vec::new();
+    for (key, value) in members(input, budget)? {
+        budget.reserve(2 * std::mem::size_of::<Value>())?;
+        let key = match key {
+            Key::Field(key) => Value::String(key),
+            Key::Index(index) => Value::Number(index.into()),
+        };
+        let mut entry = Mapping::new();
+        entry.insert("key".into(), key);
+        entry.insert("value".into(), budget.clone_value(value)?);
+        output.push(Value::Mapping(entry));
+    }
+    Ok(output)
+}
+fn from_entries(input: &Value, budget: &mut Budget<'_>) -> Result<Value> {
+    let array = input
+        .as_sequence()
+        .ok_or_else(|| error("provider override from_entries requires an array"))?;
+    let mut map = Mapping::new();
+    for entry in array {
+        budget.tick(1)?;
+        let entry = entry
+            .as_mapping()
+            .ok_or_else(|| error("provider override entries must be mappings"))?;
+        let key = entry
+            .get("key")
+            .and_then(Value::as_str)
+            .ok_or_else(|| error("provider override entry key must be a string"))?;
+        let value = entry
+            .get("value")
+            .ok_or_else(|| error("provider override entry requires a value"))?;
+        budget.reserve(key.len() + std::mem::size_of::<Value>() * 2)?;
+        map.insert(key.into(), budget.clone_value(value)?);
+    }
+    Ok(Value::Mapping(map))
+}
+fn flatten(
+    values: &[Value],
+    limit: usize,
+    output: &mut Vec<Value>,
+    budget: &mut Budget<'_>,
+    depth: usize,
+) -> Result<()> {
+    budget.tick(1)?;
+    if depth > VALUE_DEPTH {
+        return Err(error("provider override value depth exceeded"));
+    }
+    for value in values {
+        if limit != 0
+            && let Value::Sequence(nested) = value
+        {
+            flatten(nested, limit - 1, output, budget, depth + 1)?;
+        } else {
+            output.push(budget.clone_value(value)?);
+        }
+    }
+    Ok(())
+}
+fn expand_replacement(
+    target: &str,
+    captures: &regex::Captures<'_>,
+    output: &mut String,
+    budget: &mut Budget<'_>,
+) -> Result<()> {
+    let mut cursor = 0;
+    while cursor < target.len() {
+        let rest = &target[cursor..];
+        if let Some(index) = rest.find('$') {
+            append(output, &rest[..index], budget)?;
+            cursor += index + 1;
+            if target[cursor..].starts_with('$') {
+                append(output, "$", budget)?;
+                cursor += 1;
+                continue;
+            }
+            let braced = target[cursor..].starts_with('{');
+            let start = cursor + usize::from(braced);
+            let mut end = start;
+            for character in target[start..].chars() {
+                if !character.is_alphanumeric() && character != '_' {
+                    break;
+                }
+                end += character.len_utf8();
+            }
+            if end == start || (braced && !target[end..].starts_with('}')) {
+                append(output, "$", budget)?;
+                continue;
+            }
+            let key = &target[start..end];
+            let capture = (!key.starts_with('0') || key.len() == 1)
+                .then(|| key.parse::<usize>().ok())
+                .flatten()
+                .and_then(|index| captures.get(index))
+                .or_else(|| captures.name(key));
+            if let Some(capture) = capture {
+                append(output, capture.as_str(), budget)?;
+            }
+            cursor = end + usize::from(braced);
+        } else {
+            append(output, rest, budget)?;
+            break;
+        }
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn run(input: &str, expression: &str) -> Value {
+        let mut value: Value = serde_yaml_ng::from_str(input).unwrap();
+        Expr::parse(expression)
+            .unwrap()
+            .apply(&mut value, &mut Budget::new(None))
+            .unwrap();
+        value
+    }
+    #[test]
+    fn case_transforms_use_standard_full_unicode_mapping() {
+        let result = run(
+            "name: fixture\n",
+            r#".upper = ("straße fi ᾀ ας 𐐨" | upcase) | .lower = ("İΣ ΟΣ ᾈ 𐐀 中" | downcase)"#,
+        );
+        assert_eq!(result["upper"], Value::String("STRASSE FI ἈΙ ΑΣ 𐐀".into()));
+        assert_eq!(result["lower"], Value::String("i\u{307}σ οσ ᾀ 𐐨 中".into()));
+    }
+    #[test]
+    fn full_case_mapping_checks_cancel_and_actual_utf8_output_budget() {
+        let cancel = CancellationToken::new();
+        cancel.cancel();
+        assert!(full_case_map("input", true, &mut Budget::new(Some(&cancel))).is_err());
+        let mut budget = Budget::new(None);
+        budget.bytes = BYTE_LIMIT - 2;
+        // U+023F has a two-byte UTF-8 input and maps to three-byte U+2C7E.
+        assert!(full_case_map("ȿ", true, &mut budget).is_err());
+    }
+    #[test]
+    fn full_case_mapping_charges_bounded_batches() {
+        let input = "a".repeat(16 * 1024);
+        let mut budget = Budget::new(None);
+        assert_eq!(
+            full_case_map(&input, true, &mut budget).unwrap(),
+            "A".repeat(input.len())
+        );
+        assert_eq!(budget.bytes, input.len());
+        assert!(budget.steps < 200);
+    }
+    #[test]
+    fn full_case_expansion_crosses_batch_and_checks_output_budget() {
+        let input = format!("{}ßz", "a".repeat(127));
+        let expected = format!("{}SSZ", "A".repeat(127));
+        let mut budget = Budget::new(None);
+        budget.bytes = BYTE_LIMIT - expected.len();
+        assert_eq!(full_case_map(&input, true, &mut budget).unwrap(), expected);
+        assert_eq!(budget.bytes, BYTE_LIMIT);
+        let mut budget = Budget::new(None);
+        budget.bytes = BYTE_LIMIT - expected.len() + 1;
+        assert!(full_case_map(&input, true, &mut budget).is_err());
+    }
+    #[test]
+    fn signed_minimum_literal_is_parsed_with_its_sign() {
+        let result = run(
+            "name: fixture\n",
+            r#".minimum = -9223372036854775808 | .maximum = 9223372036854775807 | .hex = [-0x10, -0X10] | .large = [9223372036854775807, 9223372036854775807 + 1, -9223372036854775808, ("9223372036854775807" | tonumber)]"#,
+        );
+        assert_eq!(result["minimum"].as_i64(), Some(i64::MIN));
+        assert_eq!(result["maximum"].as_i64(), Some(i64::MAX));
+        assert_eq!(
+            result["hex"],
+            serde_yaml_ng::from_str::<Value>("[-16, -16]").unwrap()
+        );
+        assert_eq!(
+            result["large"],
+            Value::Sequence(vec![
+                Value::Number(i64::MAX.into()),
+                Value::Number(i64::MIN.into()),
+                Value::Number(i64::MIN.into()),
+                Value::Number(i64::MAX.into()),
+            ])
+        );
+        for expression in [
+            ".x = 9223372036854775808",
+            ".x = 18446744073709551615",
+            ".x = -9223372036854775809",
+        ] {
+            assert!(Expr::parse(expression).is_err());
+        }
+    }
+    #[test]
+    fn transforms_preserve_stream_order_and_update_context() {
+        let result = run(
+            "name: ' q '\nitems: [{name: one, port: 7, enabled: true}, {name: two, port: 9, enabled: false}]",
+            r#".name |= (trim | upcase) | .pairs = [.items[] | (.name, .port)] | (.items[] | select(.enabled) | .port) += 2 | .label = "\(.name):\(.items[-1].port)""#,
+        );
+        assert_eq!(result["name"], Value::String("Q".into()));
+        assert_eq!(
+            result["pairs"],
+            serde_yaml_ng::from_str::<Value>("[one, two, 7, 9]").unwrap()
+        );
+        assert_eq!(result["items"][0]["port"], Value::Number(9.into()));
+        assert_eq!(result["label"], Value::String("Q:9".into()));
+    }
+    #[test]
+    fn collection_operations_and_original_index_deletion() {
+        let result = run(
+            "values: [6, 8, 10, 12]\noptions: {c: 3, a: 1}\ngrid: [1, [2, [3]]]",
+            r#"del(.values[0], .values[2]) | .options |= with_entries(.key |= upcase) | .grid |= flatten(1) | .numbers = (.options | map(. + 4)) | .has = (.numbers | any_c(. > 5))"#,
+        );
+        assert_eq!(
+            result["values"],
+            serde_yaml_ng::from_str::<Value>("[8,12]").unwrap()
+        );
+        assert_eq!(result["options"]["A"], Value::Number(1.into()));
+        assert_eq!(
+            result["grid"],
+            serde_yaml_ng::from_str::<Value>("[1,2,[3]]").unwrap()
+        );
+        assert_eq!(
+            result["numbers"],
+            serde_yaml_ng::from_str::<Value>("[5,7]").unwrap()
+        );
+        assert_eq!(result["has"], Value::Bool(true));
+    }
+    #[test]
+    fn collection_predicates_short_circuit_and_preserve_yaml_values() {
+        let result = run(
+            "name: fixture\n",
+            r#".any = (["yes", {}] | any_c(contains("yes"))) | .all = (["no", {}] | all_c(contains("yes"))) | .nested = ([["a"]] | contains(["a"])) | .empty = (("" / ",") | length) | .split = ("" | split(",") | length) | .unique = (["a: b", {"a": "b"}] | unique | length) | .mapped = (["a", "b"] | map(.; upcase)) | .nan = ("NaN" | tonumber | tostring) | .nan_gt = (("NaN" | tonumber) > 1) | .nan_le = (("NaN" | tonumber) <= 1) | .nan_sort = ([("NaN" | tonumber),1] | sort | .[0] | tostring) | .null_gt = null > 1"#,
+        );
+        assert_eq!(result["any"], Value::Bool(true));
+        assert_eq!(result["all"], Value::Bool(false));
+        assert_eq!(result["nested"], Value::Bool(true));
+        assert_eq!(result["empty"], Value::Number(0.into()));
+        assert_eq!(result["nan"], Value::String(".nan".into()));
+        assert_eq!(result["nan_gt"], Value::Bool(false));
+        assert_eq!(result["nan_le"], Value::Bool(true));
+        assert_eq!(result["nan_sort"], Value::String(".nan".into()));
+        assert_eq!(result["null_gt"], Value::Bool(false));
+        assert_eq!(result["split"], Value::Number(1.into()));
+        assert_eq!(result["unique"], Value::Number(2.into()));
+        assert_eq!(
+            result["mapped"],
+            serde_yaml_ng::from_str::<Value>("[a,b,A,B]").unwrap()
+        );
+        for source in [
+            r#".x = ([{"Key": "name", "value": 1}] | from_entries)"#,
+            r#".x = ([{"key": "name"}] | from_entries)"#,
+            ".x = null > []",
+        ] {
+            let mut value: Value = serde_yaml_ng::from_str("name: fixture").unwrap();
+            let original = value.clone();
+            assert!(
+                Expr::parse(source)
+                    .unwrap()
+                    .apply(&mut value, &mut Budget::new(None))
+                    .is_err()
+            );
+            assert_eq!(value, original);
+        }
+    }
+
+    #[test]
+    fn budgets_are_checked_before_growth_and_candidates_are_atomic() {
+        let mut value: Value = serde_yaml_ng::from_str("name: keeper").unwrap();
+        let original = value.clone();
+        let expression =
+            Expr::parse(r#".name = "changed" | .slots[9223372036854775807] = true"#).unwrap();
+        assert!(
+            expression
+                .apply(&mut value, &mut Budget::new(None))
+                .is_err()
+        );
+        assert_eq!(value, original);
+        let cancel = CancellationToken::new();
+        cancel.cancel();
+        assert!(
+            Expr::parse(".udp = true")
+                .unwrap()
+                .apply(&mut value, &mut Budget::new(Some(&cancel)))
+                .is_err()
+        );
+        assert!(Expr::parse("del(.)").is_err());
+        assert!(Expr::parse("env(SECRET)").is_err());
+    }
+    #[test]
+    fn scalars_functions_and_uncollected_streams_have_explicit_behavior() {
+        let result = run(
+            "name: eu-7\nvalues: [2, '2', null, true]\noptions: {x: 4}",
+            r#".name |= sub("eu-", "EU/") | .parts = (.name | split("/")) | .joined = (.parts | join(":")) | .seen = (.joined | test("^EU", "g")) | .count = (.joined | length) | .kind = (.count | type) | .has = (.options | has("x")) | .contained = (.options | contains({"x": 4})) | .distinct = (.values | unique) | .entries = (.options | to_entries | from_entries) | .empty = ([] | sort) | .integer = ("0o21" | tonumber) | .repeat = "z" * 3 | .fallback = false // 9 | .ratio = 7 / 2 | .ok = (.count >= 3 and (.seen | not) == false) | .absent = (select(false)) | .stream = {"gone": select(false), "last": (.values[])}"#,
+        );
+        assert_eq!(result["joined"], Value::String("EU:7".into()));
+        assert_eq!(result["seen"], Value::Bool(true));
+        assert_eq!(result["kind"], Value::String("!!int".into()));
+        assert_eq!(result["entries"], result["options"]);
+        assert_eq!(result["integer"], Value::Number(17.into()));
+        assert_eq!(result["repeat"], Value::String("zzz".into()));
+        assert_eq!(result["ratio"], Value::Number(Number::from(3.5)));
+        assert_eq!(result["ok"], Value::Bool(true));
+        assert!(result.get("absent").is_none());
+        assert!(result["stream"].get("gone").is_none());
+        assert_eq!(result["stream"]["last"], Value::Bool(true));
+        assert!(Expr::parse(".enabled = true and false").is_err());
+        assert!(Expr::parse(r#".name |= test("[")"#).is_err());
+        let mut value: Value = serde_yaml_ng::from_str("values: [1, 2]").unwrap();
+        assert!(
+            Expr::parse(".result = (.values[])")
+                .unwrap()
+                .apply(&mut value, &mut Budget::new(None))
+                .is_err()
+        );
+    }
+
+    #[test]
+    fn scalar_rendering_and_regex_replacements_follow_the_value_contract() {
+        let result = run(
+            "name: eu-8\noptions: {z: [1, 2], a: true}\nnumber: 1000000.0",
+            r#".name |= sub("(?P<area>eu)-([0-9])", "${area}/$2/$$/$02/$2z") | .yaml = (.options | tostring) | .text = "\(.number)" | .ascii = ("１２" | test("\\d")) | .quoted = ("a.b" | test("\\Qa.b\\E")) | .tags = [(1 | type), (1.0 | type), ((1 / 0) | tostring), ((0 / 0) | tostring)] | .collected = [(.options[] | (., type))]"#,
+        );
+        assert_eq!(result["name"], Value::String("eu/8/$//".into()));
+        assert_eq!(
+            result["yaml"],
+            Value::String("a: true\nz:\n    - 1\n    - 2".into())
+        );
+        assert_eq!(result["text"], Value::String("1e+06".into()));
+        assert_eq!(result["ascii"], Value::Bool(false));
+        assert_eq!(result["quoted"], Value::Bool(true));
+        assert_eq!(
+            result["tags"],
+            serde_yaml_ng::from_str::<Value>("['!!int', '!!float', '.inf', '.nan']").unwrap()
+        );
+        assert_eq!(result["collected"].as_sequence().unwrap().len(), 4);
+    }
+}
diff --git a/src/config/process.rs b/src/config/process.rs
new file mode 100644
index 0000000..ee16d4d
--- /dev/null
+++ b/src/config/process.rs
@@ -0,0 +1,228 @@
+//! Process predicates share the routing decision's bounded matcher.
+use super::{DomainRegex, MatchFailure, Result, RuleDecision, invalid};
+use serde::Deserialize;
+
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Deserialize)]
+#[serde(try_from = "String")]
+pub enum FindProcessMode {
+    #[default]
+    Strict,
+    Always,
+    Off,
+}
+impl TryFrom<String> for FindProcessMode {
+    type Error = &'static str;
+    fn try_from(value: String) -> std::result::Result<Self, Self::Error> {
+        match value.to_ascii_lowercase().as_str() {
+            "strict" => Ok(Self::Strict),
+            "always" => Ok(Self::Always),
+            "off" => Ok(Self::Off),
+            _ => Err("find-process-mode requires strict, always or off"),
+        }
+    }
+}
+impl FindProcessMode {
+    pub(crate) fn name(self) -> &'static str {
+        match self {
+            Self::Strict => "strict",
+            Self::Always => "always",
+            Self::Off => "off",
+        }
+    }
+}
+
+pub(crate) const MAX_PROCESS_TEXT: usize = 32 * 1024;
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ProcessField {
+    Name,
+    Path,
+}
+#[derive(Clone, PartialEq, Eq)]
+pub struct ProcessRule {
+    pub field: ProcessField,
+    pub(crate) pattern: String,
+    kind: ProcessMatch,
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum ProcessMatch {
+    Exact,
+    Wildcard,
+    Regex(DomainRegex),
+}
+impl std::fmt::Debug for ProcessRule {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ProcessRule")
+            .field("field", &self.field)
+            .finish_non_exhaustive()
+    }
+}
+impl ProcessRule {
+    pub(crate) fn parse(kind: &str, payload: &str) -> Result<Self> {
+        if payload.is_empty() || payload.len() > MAX_PROCESS_TEXT || payload.contains('\0') {
+            return invalid("invalid process predicate payload");
+        }
+        let field = if kind.starts_with("PROCESS-NAME") {
+            ProcessField::Name
+        } else {
+            ProcessField::Path
+        };
+        let matcher = if kind.ends_with("-REGEX") {
+            ProcessMatch::Regex(DomainRegex::new(payload).map_err(|_| {
+                super::VoleError::InvalidConfig(
+                    "invalid process regex or compilation budget".into(),
+                )
+            })?)
+        } else if kind.ends_with("-WILDCARD") {
+            ProcessMatch::Wildcard
+        } else {
+            ProcessMatch::Exact
+        };
+        Ok(Self {
+            field,
+            pattern: payload.into(),
+            kind: matcher,
+        })
+    }
+    pub(crate) fn description(&self) -> &'static str {
+        match (self.field, &self.kind) {
+            (ProcessField::Name, ProcessMatch::Exact) => "ProcessName",
+            (ProcessField::Path, ProcessMatch::Exact) => "ProcessPath",
+            (ProcessField::Name, ProcessMatch::Wildcard) => "ProcessNameWildcard",
+            (ProcessField::Path, ProcessMatch::Wildcard) => "ProcessPathWildcard",
+            (ProcessField::Name, ProcessMatch::Regex(_)) => "ProcessNameRegex",
+            (ProcessField::Path, ProcessMatch::Regex(_)) => "ProcessPathRegex",
+        }
+    }
+    pub(crate) fn matches(
+        &self,
+        value: &str,
+        decision: &RuleDecision,
+    ) -> std::result::Result<bool, MatchFailure> {
+        if value.is_empty() {
+            return Ok(false);
+        }
+        if value.len() > MAX_PROCESS_TEXT || value.contains('\0') {
+            return Err(MatchFailure::InvalidInput);
+        }
+        match &self.kind {
+            ProcessMatch::Regex(regex) => regex.is_match_process(value, decision),
+            ProcessMatch::Exact => decision.linear(self.pattern.len(), value.len(), || {
+                self.pattern.to_lowercase() == value.to_lowercase()
+            }),
+            ProcessMatch::Wildcard => decision.linear(self.pattern.len(), value.len(), || {
+                wildcard(&self.pattern.to_lowercase(), &value.to_lowercase())
+            }),
+        }
+    }
+}
+// UTF-8 character boundaries matter for '?' in desktop process paths.
+fn wildcard(pattern: &str, value: &str) -> bool {
+    let (mut p, mut v, mut retry) = (0, 0, None);
+    while v < value.len() {
+        let next = pattern[p..].chars().next();
+        match next {
+            Some('*') => {
+                p += 1;
+                retry = Some((p, v));
+            }
+            Some(c) if c == '?' || value[v..].starts_with(c) => {
+                p += c.len_utf8();
+                v += value[v..].chars().next().unwrap().len_utf8();
+            }
+            _ => {
+                if let Some((after_star, consumed)) = retry {
+                    v = consumed + value[consumed..].chars().next().unwrap().len_utf8();
+                    p = after_star;
+                    retry = Some((p, v));
+                } else {
+                    return false;
+                }
+            }
+        }
+    }
+    pattern[p..].chars().all(|c| c == '*')
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct UidRange {
+    pub start: u32,
+    pub end: u32,
+}
+pub(crate) fn uid_ranges(payload: &str) -> Result<Vec<UidRange>> {
+    if !cfg!(any(target_os = "linux", target_os = "android")) {
+        return invalid("UID rules require Linux or Android");
+    }
+    let mut ranges = Vec::new();
+    for item in payload.split('/') {
+        let item = item.trim();
+        let (start, end) = item.split_once('-').unwrap_or((item, item));
+        let (Ok(start), Ok(end)) = (start.trim().parse::<u32>(), end.trim().parse::<u32>()) else {
+            return invalid("invalid UID range");
+        };
+        if ranges.len() >= 28 || start > end {
+            return invalid("invalid UID range");
+        }
+        ranges.push(UidRange { start, end });
+    }
+    Ok(ranges)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn process_predicates_preserve_unicode_and_shared_budget() {
+        for (kind, pattern, value) in [
+            ("PROCESS-NAME", "应用", "应用"),
+            ("PROCESS-PATH", "/Applications/WEB", "/applications/web"),
+            ("PROCESS-NAME-WILDCARD", "应?*", "应用程序"),
+            (
+                "PROCESS-PATH-WILDCARD",
+                "C:\\*\\应用.exe",
+                "c:\\程序\\应用.EXE",
+            ),
+            ("PROCESS-NAME-REGEX", "(?=应用)应用$", "应用"),
+            ("PROCESS-PATH-REGEX", "^/路径/.*$", "/路径/程序"),
+        ] {
+            assert!(
+                ProcessRule::parse(kind, pattern)
+                    .unwrap()
+                    .matches(value, &Default::default())
+                    .unwrap()
+            );
+        }
+        assert!(
+            !ProcessRule::parse("PROCESS-NAME-REGEX", ".*")
+                .unwrap()
+                .matches("", &Default::default())
+                .unwrap()
+        );
+        let decision = RuleDecision::default();
+        let token = tokio_util::sync::CancellationToken::new();
+        token.cancel();
+        decision.set_cancellation(token);
+        assert_eq!(
+            ProcessRule::parse("PROCESS-NAME", "x")
+                .unwrap()
+                .matches("x", &decision),
+            Err(MatchFailure::Cancelled)
+        );
+    }
+    #[test]
+    fn mode_and_platform_uid_boundaries_are_explicit() {
+        assert_eq!(
+            super::super::Config::parse_yaml(b"find-process-mode: ALWAYS")
+                .unwrap()
+                .find_process_mode,
+            FindProcessMode::Always
+        );
+        assert!(super::super::Config::parse_yaml(b"find-process-mode: true").is_err());
+        assert!(super::super::Config::parse_yaml(b"find-process-mode: enabled").is_err());
+        assert_eq!(
+            uid_ranges("1001-1003/4294967295").is_ok(),
+            cfg!(any(target_os = "linux", target_os = "android"))
+        );
+        assert!(uid_ranges("4294967296").is_err());
+        assert!(uid_ranges("1003-1001").is_err());
+    }
+}
diff --git a/src/config/providers.rs b/src/config/providers.rs
new file mode 100644
index 0000000..90be294
--- /dev/null
+++ b/src/config/providers.rs
@@ -0,0 +1,1374 @@
+//! Provider declarations and deterministic materialization of one resource generation.
+use super::name_regex::{Budget, NameRegex};
+use super::*;
+use serde::Deserialize;
+use serde_yaml_ng::{Mapping, Value};
+use std::{
+    collections::{BTreeMap, HashMap, HashSet},
+    sync::Arc,
+};
+
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum ProviderType {
+    Http,
+    File,
+    Inline,
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum RuleBehavior {
+    Domain,
+    Ipcidr,
+    Classical,
+}
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum RuleFormat {
+    #[default]
+    Yaml,
+    Text,
+    Mrs,
+}
+
+#[derive(Clone, PartialEq, Eq, Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "kebab-case")]
+pub struct ProviderSpec {
+    #[serde(skip)]
+    pub(crate) age_identities: Option<crate::resource::age_provider::Identities>,
+    #[serde(skip)]
+    pub(super) compiled_override_exprs: Arc<[super::override_expr::Expr]>,
+    #[serde(rename = "type")]
+    pub kind: ProviderType,
+    #[serde(default)]
+    pub url: String,
+    #[serde(default)]
+    pub path: String,
+    #[serde(default)]
+    pub path_in_bundle: String,
+    #[serde(default)]
+    pub interval: u64,
+    #[serde(default)]
+    pub proxy: String,
+    #[serde(default)]
+    pub dialer_proxy: String,
+    #[serde(default)]
+    pub header: BTreeMap<String, Vec<String>>,
+    #[serde(default)]
+    pub size_limit: u64,
+    #[serde(default)]
+    pub payload: Vec<Value>,
+    #[serde(default)]
+    pub health_check: HealthCheckConfig,
+    pub behavior: Option<RuleBehavior>,
+    #[serde(default)]
+    pub format: RuleFormat,
+    #[serde(default)]
+    pub filter: String,
+    #[serde(default)]
+    pub exclude_filter: String,
+    #[serde(default)]
+    pub exclude_type: String,
+    #[serde(default, rename = "override")]
+    pub overrides: BTreeMap<String, Value>,
+}
+impl std::fmt::Debug for ProviderSpec {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ProviderSpec")
+            .field("kind", &self.kind)
+            .field("behavior", &self.behavior)
+            .finish_non_exhaustive()
+    }
+}
+impl ProviderSpec {
+    fn validate(&self, is_rule: bool) -> Result<()> {
+        if is_rule != self.behavior.is_some() {
+            return invalid(
+                "rule providers require behavior; proxy providers do not accept behavior",
+            );
+        }
+        if self.behavior == Some(RuleBehavior::Classical) && self.format == RuleFormat::Mrs {
+            return invalid("classical providers do not support mrs");
+        }
+        if !is_rule && !self.path_in_bundle.is_empty() {
+            return invalid("path-in-bundle is only supported by rule providers");
+        }
+        if is_rule
+            && self.kind != ProviderType::Inline
+            && !self.path_in_bundle.is_empty()
+            && !crate::resource::bundle::valid_member(&self.path_in_bundle)
+        {
+            return invalid("invalid rule provider bundle member");
+        }
+        if !is_rule && self.format != RuleFormat::Yaml {
+            return invalid("proxy providers use YAML");
+        }
+        if is_rule
+            && (!self.filter.is_empty()
+                || !self.exclude_filter.is_empty()
+                || !self.exclude_type.is_empty()
+                || !self.dialer_proxy.is_empty()
+                || !self.overrides.is_empty())
+        {
+            return invalid("rule providers do not accept proxy filters or overrides");
+        }
+        if !self.dialer_proxy.is_empty() {
+            validate_route_target_name(&self.dialer_proxy, "provider dialer-proxy")?;
+        }
+        match self.kind {
+            ProviderType::Http => {
+                let options = crate::resource::http::HttpOptions {
+                    allow_http: true,
+                    allow_ip: true,
+                    ..Default::default()
+                };
+                crate::resource::http::parse_url(&self.url, &options).map_err(|_| {
+                    VoleError::InvalidConfig(
+                        "provider requires a valid absolute HTTP(S) URL".into(),
+                    )
+                })?;
+            }
+            ProviderType::File if self.path.is_empty() => {
+                return invalid("file provider requires path");
+            }
+            _ => {}
+        }
+        self.health_check.validate()?;
+        if is_rule && self.health_check != HealthCheckConfig::default() {
+            return invalid("rule providers do not support health-check");
+        }
+        Filter::new(&self.filter, &self.exclude_filter, &self.exclude_type)?;
+        for key in self.overrides.keys() {
+            if ![
+                "ip-version",
+                "tfo",
+                "mptcp",
+                "interface-name",
+                "routing-mark",
+                "udp",
+                "udp-over-tcp",
+                "up",
+                "down",
+                "dialer-proxy",
+                "skip-cert-verify",
+                "name-cert-verify",
+                "additional-prefix",
+                "additional-suffix",
+                "proxy-name",
+                "override-expr",
+            ]
+            .contains(&key.as_str())
+            {
+                return invalid(format!("unsupported provider override `{key}`"));
+            }
+        }
+        validate_overrides(&self.overrides)?;
+        // Validate request metadata even when the initial content comes from cache.
+        crate::resource::http::validate_options(&crate::resource::http::HttpOptions {
+            headers: self.headers(),
+            ..Default::default()
+        })
+        .map_err(|_| VoleError::InvalidConfig("invalid provider header".into()))?;
+        Ok(())
+    }
+    pub(crate) fn headers(&self) -> Vec<(String, String)> {
+        self.header
+            .iter()
+            .flat_map(|(name, values)| {
+                values
+                    .iter()
+                    .map(move |value| (name.clone(), value.clone()))
+            })
+            .collect()
+    }
+}
+
+#[derive(Clone, PartialEq, Eq)]
+pub struct ProviderTemplate {
+    pub(crate) resource_paths: Arc<crate::resource::paths::ProviderPaths>,
+    pub(crate) http_policy: Option<Arc<crate::http_processing::Policy>>,
+    pub(super) base: Value,
+    pub(super) identity_directory: Option<std::path::PathBuf>,
+    pub proxies: Vec<(String, ProviderSpec)>,
+    pub rules: Vec<(String, ProviderSpec)>,
+}
+impl std::fmt::Debug for ProviderTemplate {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ProviderTemplate")
+            .field("proxies", &self.proxies.len())
+            .field("rules", &self.rules.len())
+            .finish_non_exhaustive()
+    }
+}
+#[derive(Clone, PartialEq, Eq)]
+pub enum ProviderContent {
+    Proxies(Vec<Value>),
+    Rules(Arc<RuleCollection>),
+}
+impl std::fmt::Debug for ProviderContent {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Proxies(nodes) => f
+                .debug_struct("Proxies")
+                .field("count", &nodes.len())
+                .finish(),
+            Self::Rules(rules) => f
+                .debug_struct("Rules")
+                .field("count", &rules.len())
+                .finish(),
+        }
+    }
+}
+pub type ProviderContents = BTreeMap<String, ProviderContent>;
+
+impl ProviderTemplate {
+    /// Concrete foreground defaults must survive provider re-materialization.
+    /// This does not expose arbitrary overrides or write back the source document.
+    #[cfg(any(feature = "invoke", test))]
+    pub(crate) fn override_controller(
+        &mut self,
+        http: Option<std::net::SocketAddr>,
+        tls: Option<std::net::SocketAddr>,
+        unix: Option<&str>,
+        mark: Option<u32>,
+        secret: Option<&str>,
+    ) {
+        use zeroize::Zeroize as _;
+        let base = self.base.as_mapping_mut().expect("validated mapping");
+        for (key, value) in [
+            ("external-controller", http.map(|value| value.to_string())),
+            (
+                "external-controller-tls",
+                tls.map(|value| value.to_string()),
+            ),
+            ("external-controller-unix", unix.map(str::to_owned)),
+            ("secret", secret.map(str::to_owned)),
+        ] {
+            if let Some(value) = value
+                && let Some(Value::String(mut old)) = base.insert(key.into(), Value::String(value))
+            {
+                old.zeroize();
+            }
+        }
+        if let Some(mark) = mark {
+            base.insert(
+                "external-controller-routing-mark".into(),
+                Value::Number(mark.into()),
+            );
+        }
+    }
+    #[cfg(any(feature = "invoke", test))]
+    pub(crate) fn controller_secret(&self) -> Option<&str> {
+        self.base
+            .get("secret")
+            .and_then(Value::as_str)
+            .filter(|value| !value.is_empty())
+    }
+    #[cfg(any(feature = "invoke", test))]
+    pub(crate) fn controller_routing_mark(&self) -> u32 {
+        self.base
+            .get("external-controller-routing-mark")
+            .and_then(Value::as_i64)
+            .and_then(|value| super::normalize_controller_mark(value).ok())
+            .unwrap_or_default()
+    }
+    #[cfg(any(feature = "invoke", test))]
+    pub(crate) fn controller_cors(&self) -> super::ControllerCors {
+        self.base
+            .get("external-controller-cors")
+            .map_or_else(Default::default, |value| {
+                serde_yaml_ng::from_value(value.clone()).expect("validated Controller CORS")
+            })
+    }
+    pub(crate) fn request_user_agent(&self) -> String {
+        self.base
+            .get("global-ua")
+            .and_then(Value::as_str)
+            .map_or_else(super::default_global_ua, str::to_owned)
+    }
+    pub(super) fn extract(mut base: Value) -> Result<Self> {
+        let map = base
+            .as_mapping_mut()
+            .ok_or_else(|| VoleError::InvalidConfig("configuration must be a mapping".into()))?;
+        let mut expression_compilation = super::override_expr::CompileBudget::default();
+        let mut take = |key: &str, is_rule| -> Result<Vec<(String, ProviderSpec)>> {
+            let Some(value) = map.remove(key) else {
+                return Ok(Vec::new());
+            };
+            let Value::Mapping(entries) = value else {
+                return invalid("providers must be a mapping");
+            };
+            entries
+                .into_iter()
+                .map(|(name, mut spec)| {
+                    let name = name
+                        .as_str()
+                        .filter(|name| !name.is_empty())
+                        .ok_or_else(|| {
+                            VoleError::InvalidConfig(
+                                "provider name must be a nonempty string".into(),
+                            )
+                        })?
+                        .to_owned();
+                    let age = spec
+                        .as_mapping_mut()
+                        .and_then(|map| map.remove("age-secret-key"));
+                    if is_rule && age.is_some() {
+                        if let Some(Value::String(secret)) = age {
+                            let _ = zeroize::Zeroizing::new(secret);
+                        }
+                        return invalid("rule providers do not accept age-secret-key");
+                    }
+                    let identities = age
+                        .map(crate::resource::age_provider::Identities::from_value)
+                        .transpose()?
+                        .flatten();
+                    let mut spec: ProviderSpec = serde_yaml_ng::from_value(spec)
+                        .map_err(|error| VoleError::InvalidConfig(error.to_string()))?;
+                    spec.age_identities = identities;
+                    spec.validate(is_rule)?;
+                    if let Some(expressions) = spec
+                        .overrides
+                        .get("override-expr")
+                        .and_then(Value::as_sequence)
+                    {
+                        spec.compiled_override_exprs = expressions
+                            .iter()
+                            .map(|source| {
+                                super::override_expr::Expr::parse_with_budget(
+                                    source.as_str().expect("validated expression string"),
+                                    &mut expression_compilation,
+                                )
+                            })
+                            .collect::<Result<Vec<_>>>()?
+                            .into();
+                    }
+                    Ok((name, spec))
+                })
+                .collect()
+        };
+        let proxies = take("proxy-providers", false)?;
+        let rules = take("rule-providers", true)?;
+        Ok(Self {
+            resource_paths: Arc::new(crate::resource::paths::ProviderPaths::default()),
+            http_policy: None,
+            base,
+            identity_directory: None,
+            proxies,
+            rules,
+        })
+    }
+    pub(crate) fn key(is_rule: bool, name: &str) -> String {
+        format!("{}/{name}", if is_rule { "rules" } else { "proxies" })
+    }
+    #[cfg(test)]
+    pub(crate) fn parse_content(
+        &self,
+        spec: &ProviderSpec,
+        bytes: &[u8],
+    ) -> Result<ProviderContent> {
+        self.parse_content_with_control(
+            spec,
+            bytes,
+            &crate::resource::age_provider::DecodeControl::new(
+                None,
+                std::time::Instant::now() + crate::resource::http::DEFAULT_DOWNLOAD_TIMEOUT,
+            ),
+        )
+    }
+    pub(crate) fn parse_content_with_control(
+        &self,
+        spec: &ProviderSpec,
+        bytes: &[u8],
+        control: &crate::resource::age_provider::DecodeControl<'_>,
+    ) -> Result<ProviderContent> {
+        control.check()?;
+        if let Some(behavior) = spec.behavior {
+            return RuleCollection::parse(bytes, behavior, spec.format)
+                .map(|data| ProviderContent::Rules(Arc::new(data)));
+        }
+        #[derive(Deserialize)]
+        struct Payload {
+            proxies: Vec<Value>,
+        }
+        let decoded = crate::resource::age_provider::decode(
+            bytes,
+            spec.age_identities.as_ref(),
+            control,
+            MAX_CONFIG_BYTES,
+        )?;
+        let proxies = yaml::parse(decoded.as_ref())
+            .and_then(|raw| {
+                serde_yaml_ng::from_value::<Payload>(raw)
+                    .map(|payload| payload.proxies)
+                    .map_err(|_| VoleError::InvalidConfig("invalid proxy provider YAML".into()))
+            })
+            .or_else(|_| crate::resource::provider_input::parse(decoded.as_ref(), control))?;
+        control.check()?;
+        Ok(ProviderContent::Proxies(proxies))
+    }
+    fn bundled(&self, spec: &ProviderSpec) -> Result<ProviderContent> {
+        if let Some(behavior) = spec.behavior {
+            let items = spec
+                .payload
+                .iter()
+                .map(|v| {
+                    v.as_str().map(str::to_owned).ok_or_else(|| {
+                        VoleError::InvalidConfig(
+                            "rule provider payload must contain strings".into(),
+                        )
+                    })
+                })
+                .collect::<Result<Vec<_>>>()?;
+            Ok(ProviderContent::Rules(Arc::new(
+                RuleCollection::from_payload(items, behavior)?,
+            )))
+        } else {
+            Ok(ProviderContent::Proxies(spec.payload.clone()))
+        }
+    }
+    pub fn materialize(self: &Arc<Self>, contents: &ProviderContents) -> Result<Config> {
+        self.materialize_with_cancel(contents, None)
+    }
+    pub(crate) fn materialize_with_cancel(
+        self: &Arc<Self>,
+        contents: &ProviderContents,
+        cancellation: Option<&tokio_util::sync::CancellationToken>,
+    ) -> Result<Config> {
+        let mut budget = Budget::new(cancellation);
+        let mut expression_budget = super::override_expr::Budget::new(cancellation);
+        let has_expressions = self
+            .proxies
+            .iter()
+            .any(|(_, spec)| !spec.compiled_override_exprs.is_empty());
+        budget.check()?;
+        let mut value = self.base.clone();
+        let base = value.as_mapping_mut().expect("validated mapping");
+        let mut proxies: Vec<Value> = base
+            .get("proxies")
+            .map(|v| serde_yaml_ng::from_value(v.clone()))
+            .transpose()
+            .map_err(|error| VoleError::InvalidConfig(error.to_string()))?
+            .unwrap_or_default();
+        let static_names = proxies.iter().map(node_name).collect::<Result<Vec<_>>>()?;
+        let mut providers = HashMap::new();
+        for (name, spec) in &self.proxies {
+            let fallback = self.bundled(spec)?;
+            let ProviderContent::Proxies(nodes) =
+                contents.get(&Self::key(false, name)).unwrap_or(&fallback)
+            else {
+                return invalid("provider content kind mismatch");
+            };
+            let filter = Filter::new(&spec.filter, &spec.exclude_filter, &spec.exclude_type)?;
+            let nodes = filter.select(nodes.clone(), &mut budget)?;
+            let mut names = Vec::new();
+            for mut node in nodes {
+                if !spec.dialer_proxy.is_empty() {
+                    node.as_mapping_mut()
+                        .ok_or_else(|| {
+                            VoleError::InvalidConfig("provider node must be a mapping".into())
+                        })?
+                        .insert("dialer-proxy".into(), spec.dialer_proxy.clone().into());
+                }
+                apply_overrides(&mut node, &spec.overrides, &mut budget)?;
+                for expression in spec.compiled_override_exprs.iter() {
+                    expression.apply(&mut node, &mut expression_budget)?;
+                }
+                names.push(node_name(&node)?);
+                proxies.push(node);
+            }
+            providers.insert(name.clone(), names);
+        }
+        let types = proxies
+            .iter()
+            .map(|node| {
+                Ok((
+                    node_name(node)?,
+                    node.get("type")
+                        .and_then(Value::as_str)
+                        .unwrap_or_default()
+                        .to_owned(),
+                ))
+            })
+            .collect::<Result<HashMap<_, _>>>()?;
+        let group_values = base
+            .get_mut("proxy-groups")
+            .and_then(Value::as_sequence_mut);
+        if let Some(groups) = group_values {
+            for group in groups {
+                let map = group.as_mapping_mut().ok_or_else(|| {
+                    VoleError::InvalidConfig("proxy group must be a mapping".into())
+                })?;
+                let declared: Vec<String> = take_or(map, "proxies", Vec::new())?;
+                let mut used: Vec<String> = take_or(map, "use", Vec::new())?;
+                let all = take_or(map, "include-all", false)?;
+                let all_proxies = take_or(map, "include-all-proxies", false)? || all;
+                let all_providers = take_or(map, "include-all-providers", false)? || all;
+                let fallback: String = take_or(map, "empty-fallback", "COMPATIBLE".to_owned())?;
+                let filter = Filter::new(
+                    &take_or(map, "filter", String::new())?,
+                    &take_or(map, "exclude-filter", String::new())?,
+                    &take_or(map, "exclude-type", String::new())?,
+                )?;
+                if all_providers {
+                    used = self.proxies.iter().map(|(name, _)| name.clone()).collect();
+                }
+                if map
+                    .get("url")
+                    .and_then(Value::as_str)
+                    .is_none_or(str::is_empty)
+                    && let Some(url) = used
+                        .iter()
+                        .filter_map(|name| self.proxies.iter().find(|(n, _)| n == name))
+                        .map(|(_, spec)| &spec.health_check.url)
+                        .find(|url| !url.is_empty())
+                {
+                    map.insert("url".into(), url.clone().into());
+                }
+                let dynamic = !used.is_empty() || all_proxies || all_providers;
+                if declared.is_empty() && !dynamic {
+                    return invalid("proxy group requires proxies or use");
+                }
+                let mut names = declared;
+                if all_proxies {
+                    for name in &static_names {
+                        if filter.includes(name, &mut budget)? {
+                            names.push(name.clone());
+                        }
+                    }
+                }
+                let mut dynamic_names = Vec::new();
+                for provider in &used {
+                    let members = providers.get(provider).ok_or_else(|| {
+                        VoleError::InvalidConfig(format!("unknown proxy provider `{provider}`"))
+                    })?;
+                    for name in members {
+                        if filter.includes(name, &mut budget)? {
+                            dynamic_names.push(name.clone());
+                        }
+                    }
+                }
+                filter.sort_matches(&mut dynamic_names, &mut budget)?;
+                names.extend(dynamic_names);
+                let mut selected = Vec::with_capacity(names.len());
+                for name in names {
+                    if !filter.excludes(
+                        &name,
+                        types.get(&name).map(String::as_str).unwrap_or("Selector"),
+                        &mut budget,
+                    )? {
+                        selected.push(name);
+                    }
+                }
+                let mut names = selected;
+                if names.is_empty() {
+                    names.push(fallback.clone());
+                }
+                if let Some(default) = map.get("default-selected").and_then(Value::as_str)
+                    && dynamic
+                    && !names.iter().any(|name| name == default)
+                {
+                    map.remove("default-selected");
+                }
+                map.insert(
+                    "proxies".into(),
+                    serde_yaml_ng::to_value(names).expect("string sequence"),
+                );
+                // An empty fallback cannot itself be a group, avoiding hidden dependency cycles.
+                if fallback != "COMPATIBLE"
+                    && fallback != "DIRECT"
+                    && fallback != "REJECT"
+                    && fallback != "REJECT-DROP"
+                    && !types.contains_key(&fallback)
+                {
+                    return invalid("empty-fallback must be a proxy node or built-in target");
+                }
+            }
+        }
+        let mut identities =
+            super::identity_files::IdentityFiles::new(self.identity_directory.as_deref());
+        for node in &mut proxies {
+            budget.check()?;
+            identities.inline_node(node)?;
+        }
+        base.insert("proxies".into(), Value::Sequence(proxies));
+        let raw: RawVoleConfig = serde_yaml_ng::from_value(value).map_err(|error| {
+            if has_expressions {
+                VoleError::InvalidConfig("invalid provider override candidate schema".into())
+            } else {
+                VoleError::InvalidConfig(error.to_string())
+            }
+        })?;
+        let mut config = raw.normalize().map_err(|error| {
+            if has_expressions {
+                VoleError::InvalidConfig("invalid provider override candidate graph".into())
+            } else {
+                error
+            }
+        })?;
+        identities.attach(&mut config.proxies);
+        let mut sets = HashMap::new();
+        for (name, spec) in &self.rules {
+            let fallback = self.bundled(spec)?;
+            let ProviderContent::Rules(rules) =
+                contents.get(&Self::key(true, name)).unwrap_or(&fallback)
+            else {
+                return invalid("provider content kind mismatch");
+            };
+            sets.insert(name.clone(), rules.clone());
+        }
+        bind_rules(&mut config.rules, &sets)?;
+        for sub in &mut config.sub_rules {
+            bind_rules(&mut sub.rules, &sets)?;
+        }
+        bind_rules(&mut config.sniffer.skip_src_address, &sets)?;
+        bind_rules(&mut config.sniffer.skip_dst_address, &sets)?;
+        for rule in config
+            .sniffer
+            .skip_src_address
+            .iter()
+            .chain(&config.sniffer.skip_dst_address)
+        {
+            if let RuleKind::RuleSet {
+                content: Some(set), ..
+            } = &rule.kind
+                && set.behavior() == RuleBehavior::Domain
+            {
+                return invalid(
+                    "sniffer address filter requires an ipcidr or classical rule provider",
+                );
+            }
+        }
+        for selector in config
+            .sniffer
+            .force_domain
+            .iter_mut()
+            .chain(&mut config.sniffer.skip_domain)
+        {
+            bind_domain_selector(selector, &sets)?;
+        }
+        bind_rules(&mut config.dns.fake_ip.rules, &sets)?;
+        for rule in &config.dns.fake_ip.rules {
+            if let RuleKind::RuleSet {
+                content: Some(set), ..
+            } = &rule.kind
+                && set.behavior() == RuleBehavior::Ipcidr
+            {
+                return invalid("fake-IP filter requires a domain or classical rule provider");
+            }
+        }
+        for selector in &mut config.dns.fake_ip.filter {
+            bind_domain_selector(selector, &sets)?;
+        }
+        for policy in config
+            .dns
+            .nameserver_policies
+            .iter_mut()
+            .chain(&mut config.dns.proxy_policies)
+        {
+            bind_domain_selector(&mut policy.selector, &sets)?;
+        }
+        config.provider_members = providers;
+        config.providers = Some(self.clone());
+        Ok(config)
+    }
+}
+fn bind_domain_selector(
+    selector: &mut DnsPolicySelector,
+    sets: &HashMap<String, Arc<RuleCollection>>,
+) -> Result<()> {
+    if let DnsPolicySelector::RuleSets { names, sets: bound } = selector {
+        for name in names.iter() {
+            let set = sets.get(name).ok_or_else(|| {
+                VoleError::InvalidConfig(format!("unknown rule provider `{name}`"))
+            })?;
+            if set.behavior() == RuleBehavior::Ipcidr {
+                return invalid("domain selector requires a domain or classical rule provider");
+            }
+            bound.push(set.clone());
+        }
+    }
+    Ok(())
+}
+fn bind_rules(rules: &mut [RuleSpec], sets: &HashMap<String, Arc<RuleCollection>>) -> Result<()> {
+    for rule in rules {
+        match &mut rule.kind {
+            RuleKind::RuleSet { name, content, .. } => {
+                *content = Some(
+                    sets.get(name)
+                        .ok_or_else(|| {
+                            VoleError::InvalidConfig(format!("unknown rule provider `{name}`"))
+                        })?
+                        .clone(),
+                )
+            }
+            RuleKind::And(children) | RuleKind::Or(children) => bind_rules(children, sets)?,
+            RuleKind::Not(child)
+            | RuleKind::Flow {
+                predicate: child, ..
+            }
+            | RuleKind::SubRule {
+                predicate: child, ..
+            } => bind_rules(std::slice::from_mut(child), sets)?,
+            _ => {}
+        }
+    }
+    Ok(())
+}
+fn take_or<T: serde::de::DeserializeOwned>(map: &mut Mapping, key: &str, default: T) -> Result<T> {
+    map.remove(key)
+        .map(|v| {
+            serde_yaml_ng::from_value(v)
+                .map_err(|error| VoleError::InvalidConfig(error.to_string()))
+        })
+        .unwrap_or(Ok(default))
+}
+fn node_name(value: &Value) -> Result<String> {
+    value
+        .get("name")
+        .and_then(Value::as_str)
+        .filter(|v| !v.is_empty())
+        .map(str::to_owned)
+        .ok_or_else(|| VoleError::InvalidConfig("provider node requires name".into()))
+}
+
+struct Filter {
+    include: Vec<NameRegex>,
+    exclude: Vec<NameRegex>,
+    types: Vec<String>,
+}
+impl Filter {
+    fn new(include: &str, exclude: &str, types: &str) -> Result<Self> {
+        let compile = |s: &str| -> Result<Vec<NameRegex>> {
+            if s.is_empty() {
+                return Ok(Vec::new());
+            }
+            s.split('`').map(NameRegex::new).collect()
+        };
+        Ok(Self {
+            include: compile(include)?,
+            exclude: compile(exclude)?,
+            types: types
+                .split('|')
+                .filter(|s| !s.is_empty())
+                .map(str::to_owned)
+                .collect(),
+        })
+    }
+    fn match_index(&self, name: &str, budget: &mut Budget<'_>) -> Result<Option<usize>> {
+        if self.include.is_empty() {
+            return Ok(Some(0));
+        }
+        for (index, regex) in self.include.iter().enumerate() {
+            if regex.is_match(name, budget)? {
+                return Ok(Some(index));
+            }
+        }
+        Ok(None)
+    }
+    fn includes(&self, name: &str, budget: &mut Budget<'_>) -> Result<bool> {
+        Ok(self.match_index(name, budget)?.is_some())
+    }
+    fn excludes(&self, name: &str, kind: &str, budget: &mut Budget<'_>) -> Result<bool> {
+        for regex in &self.exclude {
+            if regex.is_match(name, budget)? {
+                return Ok(true);
+            }
+        }
+        Ok(self
+            .types
+            .iter()
+            .any(|ty| ty.eq_ignore_ascii_case(protocol_type(kind))))
+    }
+    fn sort_matches(&self, names: &mut Vec<String>, budget: &mut Budget<'_>) -> Result<()> {
+        if self.include.len() > 1 {
+            let mut keyed = names
+                .drain(..)
+                .map(|name| Ok((self.match_index(&name, budget)?.unwrap_or(usize::MAX), name)))
+                .collect::<Result<Vec<_>>>()?;
+            keyed.sort_by_key(|(index, _)| *index);
+            let mut seen = HashSet::new();
+            names.extend(
+                keyed
+                    .into_iter()
+                    .map(|(_, name)| name)
+                    .filter(|name| seen.insert(name.clone())),
+            );
+        }
+        Ok(())
+    }
+    fn select(&self, nodes: Vec<Value>, budget: &mut Budget<'_>) -> Result<Vec<Value>> {
+        let mut result = Vec::new();
+        for node in nodes {
+            budget.check()?;
+            let name = node_name(&node)?;
+            let kind = node.get("type").and_then(Value::as_str).unwrap_or_default();
+            if !self.excludes(&name, kind, budget)?
+                && let Some(index) = self.match_index(&name, budget)?
+            {
+                result.push((index, node));
+            }
+        }
+        if self.include.len() > 1 {
+            result.sort_by_key(|(index, _)| *index);
+        }
+        Ok(result.into_iter().map(|(_, node)| node).collect())
+    }
+}
+fn protocol_type(kind: &str) -> &str {
+    match kind {
+        "ss" => "Shadowsocks",
+        "socks5" => "Socks5",
+        "http" => "Http",
+        other => other,
+    }
+}
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct Replacement {
+    pattern: String,
+    target: String,
+}
+fn validate_overrides(overrides: &BTreeMap<String, Value>) -> Result<()> {
+    for (key, value) in overrides {
+        let valid = match key.as_str() {
+            "routing-mark" => value
+                .as_i64()
+                .is_some_and(|mark| EgressOptions::normalize(String::new(), mark).is_ok()),
+            "tfo" | "mptcp" | "udp" | "udp-over-tcp" | "skip-cert-verify" => value.is_bool(),
+            "override-expr" => value
+                .as_sequence()
+                .is_some_and(|values| values.iter().all(Value::is_string)),
+            "proxy-name" => {
+                let replacements: Vec<Replacement> = serde_yaml_ng::from_value(value.clone())
+                    .map_err(|_| {
+                        VoleError::InvalidConfig("invalid provider name replacements".into())
+                    })?;
+                for replacement in replacements {
+                    NameRegex::new(&replacement.pattern)?;
+                }
+                true
+            }
+            _ => value.is_string(),
+        };
+        if !valid {
+            return invalid(format!("invalid provider override `{key}`"));
+        }
+    }
+    Ok(())
+}
+fn apply_overrides(
+    node: &mut Value,
+    overrides: &BTreeMap<String, Value>,
+    budget: &mut Budget<'_>,
+) -> Result<()> {
+    let original_name = node_name(node)?;
+    let map = node
+        .as_mapping_mut()
+        .ok_or_else(|| VoleError::InvalidConfig("provider node must be a mapping".into()))?;
+    let mut name = original_name;
+    for (key, value) in overrides {
+        if [
+            "additional-prefix",
+            "additional-suffix",
+            "proxy-name",
+            "override-expr",
+        ]
+        .contains(&key.as_str())
+        {
+            continue;
+        }
+        let kind = map.get("type").and_then(Value::as_str).unwrap_or_default();
+        let applicable = match key.as_str() {
+            "udp" => kind != "http",
+            "up" | "down" => kind == "hysteria2",
+            "udp-over-tcp" => kind == "ss",
+            "skip-cert-verify" | "name-cert-verify" => match kind {
+                "hysteria2" | "tuic" | "trusttunnel" | "masque" => true,
+                "trojan" | "anytls" => {
+                    !map.contains_key("reality-opts") && !map.contains_key("jls-opts")
+                }
+                "http" | "socks5" => map.get("tls").and_then(Value::as_bool) == Some(true),
+                "vmess" | "vless" => {
+                    map.get("tls").and_then(Value::as_bool) == Some(true)
+                        && !map.contains_key("reality-opts")
+                        && !map.contains_key("jls-opts")
+                }
+                _ => false,
+            },
+            _ => true,
+        };
+        if applicable {
+            map.insert(Value::String(key.clone()), value.clone());
+        }
+    }
+    if let Some(replacements) = overrides.get("proxy-name") {
+        let replacements: Vec<Replacement> = serde_yaml_ng::from_value(replacements.clone())
+            .map_err(|error| VoleError::InvalidConfig(error.to_string()))?;
+        for replacement in replacements {
+            let regex = NameRegex::new(&replacement.pattern)?;
+            name = regex.replace(&name, &replacement.target, budget)?;
+        }
+    }
+    let text = |key| -> Result<&str> {
+        overrides
+            .get(key)
+            .map(|v| {
+                v.as_str().ok_or_else(|| {
+                    VoleError::InvalidConfig("provider name affix must be a string".into())
+                })
+            })
+            .unwrap_or(Ok(""))
+    };
+    map.insert(
+        "name".into(),
+        format!(
+            "{}{}{}",
+            text("additional-prefix")?,
+            name,
+            text("additional-suffix")?
+        )
+        .into(),
+    );
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn age_provider_identities_are_validated_before_content_read() {
+        let key = include_str!("../../tests/fixtures/provider-age/x25519.key").trim_end();
+        let yaml =
+            format!("proxy-providers:\n  nodes: {{type: inline, age-secret-key: '{key}'}}\n");
+        let template = ProviderTemplate::extract(serde_yaml_ng::from_str(&yaml).unwrap()).unwrap();
+        let spec = &template.proxies[0].1;
+        assert!(spec.age_identities.is_some());
+        for bytes in [
+            include_bytes!("../../tests/fixtures/provider-age/x25519.age").as_slice(),
+            include_bytes!("../../tests/fixtures/provider-age/provider.yaml").as_slice(),
+        ] {
+            let ProviderContent::Proxies(nodes) = template.parse_content(spec, bytes).unwrap()
+            else {
+                panic!("proxy provider content");
+            };
+            assert_eq!(nodes[0]["name"].as_str(), Some("age-node"));
+        }
+        for value in ["null", "''"] {
+            let yaml =
+                format!("proxy-providers:\n  nodes: {{type: inline, age-secret-key: {value}}}\n");
+            ProviderTemplate::extract(serde_yaml_ng::from_str(&yaml).unwrap()).unwrap();
+        }
+        for yaml in [
+            "proxy-providers:\n  nodes: {type: inline, age-secret-key: invalid-private-fixture}\n",
+            "rule-providers:\n  nodes: {type: inline, behavior: domain, age-secret-key: null}\n",
+        ] {
+            let error =
+                ProviderTemplate::extract(serde_yaml_ng::from_str(yaml).unwrap()).unwrap_err();
+            assert!(!error.to_string().contains("invalid-private-fixture"));
+        }
+    }
+    #[test]
+    fn override_expr_materializes_after_filters_and_structured_names() {
+        let yaml = br#"
+mixed-port: 1080
+proxy-providers:
+  nodes:
+    type: inline
+    filter: '^keep'
+    override:
+      udp: true
+      proxy-name: [{pattern: '^keep-', target: ''}]
+      additional-prefix: 'PRE-'
+      additional-suffix: '-END'
+      override-expr:
+        - '.name = ([.name, (.udp | tostring)] | join("/"))'
+        - '.name |= (split("-") | map(downcase) | join("_"))'
+        - '.port += ([1, [2, 3]] | flatten | length)'
+    payload:
+      - {name: keep-east, type: socks5, server: 192.0.2.1, port: 1080}
+      - {name: omit-west, type: socks5, server: 192.0.2.1, port: 1080}
+proxy-groups: [{name: choice, type: select, use: [nodes]}]
+"#;
+        let config = Config::parse_yaml(yaml).unwrap();
+        assert_eq!(config.proxies.len(), 1);
+        assert_eq!(config.proxies[0].tag, "pre_east_end/true");
+        assert_eq!(config.proxy_groups[0].members[0].name, "pre_east_end/true");
+        let template = config.providers.as_ref().unwrap();
+        let expressions = &template.proxies[0].1.compiled_override_exprs;
+        assert_eq!(expressions.len(), 3);
+        let cloned = template.proxies[0].1.clone();
+        assert!(Arc::ptr_eq(expressions, &cloned.compiled_override_exprs));
+        let cancelled = tokio_util::sync::CancellationToken::new();
+        cancelled.cancel();
+        assert!(
+            template
+                .materialize_with_cancel(&ProviderContents::new(), Some(&cancelled))
+                .is_err()
+        );
+
+        for expression in [
+            ".port = .password",
+            ".dialer-proxy = .name",
+            ".type = .password",
+        ] {
+            let source = format!(
+                "proxy-providers:\n  nodes:\n    type: inline\n    override:\n      override-expr: ['{expression}']\n    payload: [{{name: original, type: socks5, server: 192.0.2.1, port: 1080, username: account, password: private-node-value}}]\n"
+            );
+            let error = Config::parse_yaml(source.as_bytes())
+                .unwrap_err()
+                .to_string();
+            assert!(!error.contains("private-node-value"));
+            assert!(!error.contains(expression));
+        }
+        assert!(Config::parse_yaml(b"proxy-providers: {nodes: {type: inline, payload: [], override: {override-expr: ['.port = (']}}}").is_err());
+    }
+
+    #[test]
+    fn static_members_filtered_to_empty_use_the_declared_fallback() {
+        for (fallback, expected) in [
+            ("", "COMPATIBLE"),
+            (", empty-fallback: DIRECT", "DIRECT"),
+            (", empty-fallback: edge", "edge"),
+        ] {
+            let yaml = format!(
+                "mixed-port: 1080\nproxies: [{{name: edge, type: socks5, server: 192.0.2.1, port: 1080}}]\nproxy-groups: [{{name: filtered, type: select, proxies: [edge], exclude-filter: '^edge'{fallback}}}]\nrules: ['MATCH,filtered']\n"
+            );
+            let config = Config::parse_yaml(yaml.as_bytes()).unwrap();
+            assert_eq!(config.proxy_groups[0].members.len(), 1);
+            assert_eq!(config.proxy_groups[0].members[0].name, expected);
+            assert!(
+                Config::parse_yaml(yaml.replace("proxies: [edge]", "proxies: []").as_bytes())
+                    .is_err()
+            );
+        }
+    }
+
+    #[test]
+    fn provider_and_group_name_expressions_materialize_real_templates() {
+        let config = Config::parse_yaml(
+            r#"
+mixed-port: 1080
+proxy-providers:
+  nodes:
+    type: inline
+    filter: '^(?!.*(流量|到期)).*(HK|SG)'
+    exclude-filter: '(?<=HK-)99$'
+    override:
+      proxy-name:
+        - {pattern: '(?<=HK-)(\d+)', target: '${1}x'}
+    payload:
+      - {name: HK-01, type: socks5, server: 192.0.2.1, port: 1080}
+      - {name: HK-99, type: socks5, server: 192.0.2.1, port: 1080}
+      - {name: SG-SG, type: socks5, server: 192.0.2.1, port: 1080}
+      - {name: SG-SG到期, type: socks5, server: 192.0.2.1, port: 1080}
+proxy-groups:
+  - {name: choose, type: select, use: [nodes], filter: '^(SG)-\1$`HK', exclude-filter: '(?<=HK-)02'}
+"#
+            .as_bytes(),
+        )
+        .unwrap();
+        assert_eq!(
+            config
+                .proxies
+                .iter()
+                .map(|p| p.tag.as_str())
+                .collect::<Vec<_>>(),
+            ["HK-01x", "SG-SG"]
+        );
+        assert_eq!(
+            config.proxy_groups[0]
+                .members
+                .iter()
+                .map(|m| m.name.as_str())
+                .collect::<Vec<_>>(),
+            ["SG-SG", "HK-01x"]
+        );
+        let template = config.providers.unwrap();
+        let cancelled = tokio_util::sync::CancellationToken::new();
+        cancelled.cancel();
+        assert!(
+            template
+                .materialize_with_cancel(&ProviderContents::new(), Some(&cancelled))
+                .is_err()
+        );
+    }
+
+    #[test]
+    fn provider_tfo_override_preserves_false_and_materializes_exact_node_policy() {
+        for enabled in [false, true] {
+            let yaml = format!(
+                r#"proxy-providers:
+  nodes:
+    type: inline
+    override: {{tfo: {enabled}}}
+    payload:
+      - {{name: local, type: direct, tfo: true}}
+      - {{name: remote, type: socks5, server: 192.0.2.1, port: 1080}}
+"#,
+            );
+            let config = Config::parse_yaml(yaml.as_bytes()).unwrap();
+            assert!(config.proxies.iter().all(|node| node.tfo == enabled));
+            let fresh = config
+                .providers
+                .as_ref()
+                .unwrap()
+                .materialize(&ProviderContents::new())
+                .unwrap();
+            assert_eq!(config.proxies, fresh.proxies);
+        }
+    }
+
+    #[test]
+    fn provider_mptcp_override_survives_rematerialization_with_explicit_false() {
+        for enabled in [false, true] {
+            let yaml = format!(
+                r#"proxy-providers:
+  nodes:
+    type: inline
+    override: {{mptcp: {enabled}}}
+    payload:
+      - {{name: local, type: direct, mptcp: true}}
+      - {{name: remote, type: socks5, server: 192.0.2.1, port: 1080}}
+"#,
+            );
+            let config = Config::parse_yaml(yaml.as_bytes()).unwrap();
+            assert!(config.proxies.iter().all(|node| node.mptcp == enabled));
+            let fresh = config
+                .providers
+                .as_ref()
+                .unwrap()
+                .materialize(&ProviderContents::new())
+                .unwrap();
+            assert_eq!(config.proxies, fresh.proxies);
+        }
+        for value in ["null", "'true'", "1"] {
+            let yaml = format!(
+                "proxy-providers: {{nodes: {{type: inline, override: {{mptcp: {value}}}, payload: []}}}}"
+            );
+            assert!(Config::parse_yaml(yaml.as_bytes()).is_err());
+        }
+    }
+
+    #[test]
+    fn provider_dialer_and_certificate_overrides_materialize_in_reference_order() {
+        for (kind, source) in [
+            ("inline", ""),
+            ("file", "path: nodes.yaml"),
+            ("http", "url: https://subscription.invalid/nodes.yaml"),
+        ] {
+            for (provider, override_dialer, expected) in [
+                ("", "", "node-path"),
+                ("provider-path", "", "provider-path"),
+                ("provider-path", "override-path", "override-path"),
+            ] {
+                let yaml = format!(
+                    r#"
+mixed-port: 1080
+proxy-providers:
+  remote:
+    type: {kind}
+    {source}
+    proxy: node-path
+    dialer-proxy: '{provider}'
+    override:
+      name-cert-verify: verified.invalid
+      skip-cert-verify: true
+      {override_entry}
+    payload:
+      - {{name: edge, type: socks5, tls: true, server: cover.invalid, port: 443, dialer-proxy: node-path}}
+      - {{name: plain-socks, type: socks5, server: 192.0.2.1, port: 1080}}
+      - {{name: plain-http, type: http, server: 192.0.2.2, port: 8080}}
+      - {{name: plain-vmess, type: vmess, server: 192.0.2.3, port: 1080, uuid: 00000000-0000-4000-8000-000000000001}}
+      - {{name: plain-vless, type: vless, server: 192.0.2.4, port: 1080, uuid: 00000000-0000-4000-8000-000000000001}}
+proxy-groups:
+  - {{name: node-path, type: select, proxies: [DIRECT]}}
+  - {{name: provider-path, type: select, proxies: [DIRECT]}}
+  - {{name: override-path, type: select, proxies: [DIRECT]}}
+"#,
+                    override_entry = if override_dialer.is_empty() {
+                        String::new()
+                    } else {
+                        format!("dialer-proxy: {override_dialer}")
+                    },
+                );
+                let config = Config::parse_yaml(yaml.as_bytes()).unwrap();
+                let group = config
+                    .proxy_groups
+                    .iter()
+                    .position(|group| group.name == expected)
+                    .unwrap();
+                assert_eq!(
+                    config.proxies[0].dialer_proxy,
+                    Some(RouteTargetId::Group(ProxyGroupId::from_index(group)))
+                );
+                let ProxyProtocol::Socks5(node) = &config.proxies[0].protocol else {
+                    panic!("SOCKS provider node")
+                };
+                let certificate = &node.tls.as_ref().unwrap().certificate;
+                assert_eq!(
+                    certificate.verification_name.as_deref(),
+                    Some("verified.invalid")
+                );
+                assert!(certificate.skip_cert_verify);
+                assert_eq!(node.address, "cover.invalid");
+                assert_eq!(
+                    config.providers.as_ref().unwrap().proxies[0].1.proxy,
+                    "node-path"
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn quic_provider_certificate_name_override_uses_existing_certificate_policy() {
+        for (kind, credentials) in [
+            ("hysteria2", "password: fixture"),
+            (
+                "tuic",
+                "uuid: 00000000-0000-4000-8000-000000000001, password: fixture",
+            ),
+        ] {
+            let config = Config::parse_yaml(format!(
+                "mixed-port: 1080\nproxy-providers:\n  nodes:\n    type: inline\n    override: {{name-cert-verify: verified.invalid}}\n    payload:\n      - {{name: edge, type: {kind}, server: cover.invalid, port: 443, {credentials}}}\n"
+            ).as_bytes()).unwrap();
+            let tls = match &config.proxies[0].protocol {
+                ProxyProtocol::Hysteria2(node) => &node.tls,
+                ProxyProtocol::Tuic(node) => &node.tls,
+                _ => unreachable!(),
+            };
+            assert_eq!(
+                tls.certificate.verification_name.as_deref(),
+                Some("verified.invalid")
+            );
+            assert_eq!(tls.server_name, "cover.invalid");
+        }
+    }
+
+    #[test]
+    fn subrule_provider_candidate_rebinds_without_replacing_old_snapshot() {
+        use crate::{
+            routing::{EmptyGeoMatcher, RoutingContext, RuleEvaluation, RuleMatch, RuleSet},
+            session::Destination,
+        };
+        let mut config = Config::parse_yaml(
+            br#"
+mixed-port: 1080
+rule-providers:
+  domains: {type: inline, behavior: classical, payload: ['DOMAIN,old.example','GEOSITE,cn']}
+rules: ['SUB-RULE,(NETWORK,TCP),child', 'MATCH,DIRECT']
+sub-rules:
+  child: ['RULE-SET,domains,REJECT']
+  unused: ['GEOSITE,us,DIRECT']
+"#,
+        )
+        .unwrap();
+        let template = config.providers.clone().unwrap();
+        let requirements = crate::geodata::GeoRequirements::for_config(&config).unwrap();
+        assert_eq!(requirements.total_codes(), 2);
+        let RuleKind::RuleSet {
+            content: Some(set), ..
+        } = &config
+            .sub_rules
+            .iter()
+            .find(|program| program.name == "child")
+            .unwrap()
+            .rules[0]
+            .kind
+        else {
+            panic!("unbound child provider");
+        };
+        let old_set = Arc::downgrade(set);
+        let old = RuleSet::compile_config(&mut config).unwrap();
+        drop(config);
+        let mut contents = ProviderContents::new();
+        contents.insert(
+            ProviderTemplate::key(true, "domains"),
+            template
+                .parse_content(
+                    &template.rules[0].1,
+                    b"payload: ['DOMAIN,new.example','GEOSITE,cn']\n",
+                )
+                .unwrap(),
+        );
+        let mut candidate = template.materialize(&contents).unwrap();
+        let new = RuleSet::compile_config(&mut candidate).unwrap();
+        let action = |rules: &RuleSet, host| {
+            let context =
+                RoutingContext::new(Network::Tcp, &Destination::domain(host, 443).unwrap())
+                    .unwrap();
+            rules.evaluate_with_geo(&context, &EmptyGeoMatcher)
+        };
+        let rejected = RuleEvaluation::Matched(RuleMatch {
+            action: RuleAction::Reject,
+            rule_index: 0,
+        });
+        assert_eq!(action(&old, "old.example"), rejected);
+        assert_eq!(action(&new, "new.example"), rejected);
+        assert_eq!(
+            action(&new, "old.example"),
+            RuleEvaluation::Matched(RuleMatch {
+                action: RuleAction::Direct,
+                rule_index: 1
+            })
+        );
+        assert!(old_set.upgrade().is_some());
+        drop(old);
+        assert!(old_set.upgrade().is_none());
+    }
+
+    #[test]
+    fn inline_provider_groups_and_rule_policies_share_materialized_content() {
+        let config = Config::parse_yaml(
+            br#"
+mixed-port: 1080
+proxy-providers:
+  nodes:
+    type: inline
+    filter: '^keep'
+    override: {udp: true, skip-cert-verify: true, additional-prefix: 'P-'}
+    payload:
+      - {name: keep-one, type: socks5, server: 192.0.2.1, port: 1080}
+      - {name: discard, type: socks5, server: 192.0.2.2, port: 1080}
+proxy-groups:
+  - {name: choose, type: select, use: [nodes], hidden: true, icon: icon, disable-udp: true}
+  - {name: empty, type: select, use: [nodes], filter: absent}
+rule-providers:
+  domains: {type: inline, behavior: domain, payload: ['+.example.com']}
+  custom: {type: inline, behavior: classical, payload: ['DOMAIN,internal.example']}
+dns:
+  enable: true
+  nameserver: [1.1.1.1]
+  nameserver-policy: {'rule-set:domains,custom': [8.8.8.8]}
+rules: ['RULE-SET,domains,choose', 'RULE-SET,custom,DIRECT,no-resolve']
+"#,
+        )
+        .unwrap();
+        assert_eq!(config.proxies.len(), 1);
+        assert_eq!(config.proxies[0].tag, "P-keep-one");
+        assert!(config.proxies[0].udp);
+        assert!(config.proxy_groups[0].disable_udp);
+        assert!(config.proxy_groups[0].hidden);
+        assert_eq!(config.proxy_groups[1].members[0].name, "COMPATIBLE");
+        let RuleKind::RuleSet {
+            content: Some(set), ..
+        } = &config.rules[0].kind
+        else {
+            panic!("unbound set")
+        };
+        assert!(
+            set.matches_domain(
+                "sub.example.com",
+                &crate::routing::EmptyGeoMatcher,
+                &Default::default()
+            )
+            .unwrap()
+        );
+        let DnsPolicySelector::RuleSets { sets, .. } = &config.dns.nameserver_policies[0].selector
+        else {
+            panic!("unbound policy")
+        };
+        assert!(Arc::ptr_eq(set, &sets[0]));
+    }
+}
diff --git a/src/config/quic.rs b/src/config/quic.rs
new file mode 100644
index 0000000..f6b201b
--- /dev/null
+++ b/src/config/quic.rs
@@ -0,0 +1,32 @@
+use super::invalid;
+use crate::Result;
+
+/// Sizes of receive credit. Neither value eagerly allocates a receive buffer.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct QuicReceiveWindow {
+    pub initial: u64,
+    pub maximum: u64,
+}
+
+impl QuicReceiveWindow {
+    pub(super) fn normalize(initial: u64, maximum: u64, default: Self) -> Result<Self> {
+        let initial = if initial == 0 {
+            default.initial
+        } else {
+            initial
+        };
+        let maximum = if maximum == 0 {
+            default.maximum
+        } else {
+            maximum
+        };
+        if initial > (1_u64 << 62) - 1 {
+            return invalid("QUIC receive credit exceeds its wire representation");
+        }
+        // The reference clamps max values to QUIC VarInt without shrinking initial.
+        Ok(Self {
+            initial,
+            maximum: maximum.min((1_u64 << 62) - 1),
+        })
+    }
+}
diff --git a/src/config/rule_provider.rs b/src/config/rule_provider.rs
new file mode 100644
index 0000000..141dc5b
--- /dev/null
+++ b/src/config/rule_provider.rs
@@ -0,0 +1,756 @@
+//! Immutable provider rule data. MRSv1 is decoded as an interoperable file format.
+use super::{
+    providers::{RuleBehavior, RuleFormat},
+    *,
+};
+use crate::routing::{GeoMatcher, RoutingContext};
+mod domain_set;
+use domain_set::DomainSet;
+use serde::Deserialize;
+use std::{
+    io::Read,
+    net::{IpAddr, Ipv4Addr, Ipv6Addr},
+    sync::Arc,
+};
+
+const MAX_RESOURCE_BYTES: usize = 64 * 1024 * 1024;
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RuleCollection {
+    behavior: RuleBehavior,
+    domains: Arc<DomainSet>,
+    ranges: Vec<(IpAddr, IpAddr)>,
+    pub(crate) classical: Vec<RuleSpec>,
+    count: usize,
+}
+impl RuleCollection {
+    pub fn behavior(&self) -> RuleBehavior {
+        self.behavior
+    }
+    pub fn len(&self) -> usize {
+        self.count
+    }
+    pub fn is_empty(&self) -> bool {
+        self.count == 0
+    }
+    pub(crate) fn uses_ip(&self) -> bool {
+        self.behavior == RuleBehavior::Ipcidr
+            || self
+                .classical
+                .iter()
+                .any(crate::routing::uses_destination_ip)
+    }
+    pub(crate) fn uses_domain(&self) -> bool {
+        self.behavior != RuleBehavior::Ipcidr
+    }
+    pub fn parse(bytes: &[u8], behavior: RuleBehavior, format: RuleFormat) -> Result<Self> {
+        if bytes.len() > MAX_RESOURCE_BYTES {
+            return invalid("rule provider exceeds parser byte limit");
+        }
+        if format == RuleFormat::Mrs {
+            return parse_mrs(bytes, behavior);
+        }
+        let values = match format {
+            RuleFormat::Yaml => {
+                #[derive(Deserialize)]
+                struct Payload {
+                    payload: Vec<String>,
+                }
+                let payload: Payload = serde_yaml_ng::from_value(yaml::parse(bytes)?)
+                    .map_err(|_| VoleError::InvalidConfig("invalid rule provider YAML".into()))?;
+                payload.payload
+            }
+            RuleFormat::Text => std::str::from_utf8(bytes)
+                .map_err(|_| VoleError::InvalidConfig("rule provider text requires UTF-8".into()))?
+                .lines()
+                .map(str::trim)
+                .filter(|s| !s.is_empty() && !s.starts_with('#'))
+                .map(str::to_owned)
+                .collect(),
+            RuleFormat::Mrs => unreachable!(),
+        };
+        Self::from_payload(values, behavior)
+    }
+    pub fn from_payload(values: Vec<String>, behavior: RuleBehavior) -> Result<Self> {
+        let mut data = Self {
+            behavior,
+            domains: Arc::new(DomainSet::default()),
+            ranges: Vec::new(),
+            classical: Vec::new(),
+            count: values.len(),
+        };
+        let mut domains = Vec::new();
+        for value in values {
+            match behavior {
+                RuleBehavior::Domain => {
+                    let selector = normalize_dns_policy_selector(&value)?;
+                    let DnsPolicySelector::Domains(patterns) = selector else {
+                        return invalid("domain provider requires domain patterns");
+                    };
+                    if value.contains('/') || patterns.len() != 1 {
+                        return invalid("invalid rule provider domain");
+                    }
+                    domains.extend(patterns.into_vec());
+                }
+                RuleBehavior::Ipcidr => {
+                    let cidr = parse_ip_cidr(&value, value.contains(':'))?;
+                    let (start, width) = match cidr.network {
+                        IpAddr::V4(ip) => (u128::from(u32::from(ip)), 32u8),
+                        IpAddr::V6(ip) => (u128::from(ip), 128u8),
+                    };
+                    let host_bits = width - cidr.prefix_len;
+                    let mask = if host_bits == 128 {
+                        u128::MAX
+                    } else {
+                        (1u128 << host_bits) - 1
+                    };
+                    let a = start & !mask;
+                    let b = a | mask;
+                    data.ranges.push(if width == 32 {
+                        (
+                            Ipv4Addr::from(a as u32).into(),
+                            Ipv4Addr::from(b as u32).into(),
+                        )
+                    } else {
+                        (Ipv6Addr::from(a).into(), Ipv6Addr::from(b).into())
+                    });
+                }
+                RuleBehavior::Classical => {
+                    let kind = value
+                        .split(',')
+                        .next()
+                        .unwrap_or_default()
+                        .trim()
+                        .to_ascii_uppercase();
+                    if ["MATCH", "RULE-SET", "SUB-RULE"].contains(&kind.as_str()) {
+                        return invalid("unsupported classical provider rule");
+                    }
+                    data.classical.push(rules::parse_predicate(&value)?);
+                }
+            }
+        }
+        data.domains = Arc::new(DomainSet::from_patterns(domains)?);
+        // Reuse normal compilation to validate classical matcher semantics.
+        crate::routing::RuleSet::compile(data.classical.clone())
+            .map_err(|_| VoleError::InvalidConfig("invalid classical provider rules".into()))?;
+        data.merge_ranges();
+        Ok(data)
+    }
+    fn merge_ranges(&mut self) {
+        self.ranges.sort_unstable();
+        let mut merged: Vec<(IpAddr, IpAddr)> = Vec::new();
+        for (start, end) in self.ranges.drain(..) {
+            if let Some(last) = merged.last_mut()
+                && start.is_ipv4() == last.0.is_ipv4()
+                && start <= last.1
+            {
+                last.1 = last.1.max(end);
+                continue;
+            }
+            merged.push((start, end));
+        }
+        self.ranges = merged;
+    }
+    pub(crate) fn matches(
+        &self,
+        context: &RoutingContext,
+        geo: &dyn GeoMatcher,
+        no_resolve: bool,
+        source: bool,
+    ) -> std::result::Result<bool, crate::routing::PredicateFailure> {
+        match self.behavior {
+            RuleBehavior::Domain => Ok(context
+                .domain()
+                .is_some_and(|name| self.domains.contains(name))),
+            RuleBehavior::Ipcidr => {
+                let ip = if source {
+                    context.source_ip()
+                } else {
+                    context.effective_ip()
+                };
+                let Some(ip) = ip else {
+                    return if !source && !no_resolve && context.should_request_ip_resolution() {
+                        Err(crate::routing::PredicateFailure::NeedsIpResolution)
+                    } else {
+                        Ok(false)
+                    };
+                };
+                let index = self.ranges.partition_point(|(start, _)| *start <= ip);
+                Ok(index > 0
+                    && self.ranges[index - 1].0.is_ipv4() == ip.is_ipv4()
+                    && ip <= self.ranges[index - 1].1)
+            }
+            RuleBehavior::Classical => {
+                let mut context = context.clone();
+                if source {
+                    context.swap_source_destination();
+                }
+                if no_resolve {
+                    context.disable_ip_resolution();
+                }
+                for rule in &self.classical {
+                    if crate::routing::matches_rule(rule, &context, geo)? {
+                        return Ok(true);
+                    }
+                }
+                Ok(false)
+            }
+        }
+    }
+    pub(crate) fn matches_ip(
+        &self,
+        address: std::net::IpAddr,
+        geo: &dyn GeoMatcher,
+        decision: &super::RuleDecision,
+    ) -> std::result::Result<bool, super::MatchFailure> {
+        decision.visit()?;
+        let destination = crate::session::Destination::Ip(std::net::SocketAddr::new(address, 1));
+        let context = RoutingContext::selector(&destination)
+            .expect("literal address")
+            .with_decision(decision);
+        self.matches_selector(&context, geo)
+    }
+    pub(crate) fn matches_domain(
+        &self,
+        domain: &str,
+        geo: &dyn GeoMatcher,
+        decision: &super::RuleDecision,
+    ) -> std::result::Result<bool, super::MatchFailure> {
+        decision.visit()?;
+        let Ok(destination) = crate::session::Destination::domain(domain, 53) else {
+            return Ok(false);
+        };
+        let Ok(context) = RoutingContext::selector(&destination) else {
+            return Ok(false);
+        };
+        let context = context.with_decision(decision);
+        self.matches_selector(&context, geo)
+    }
+    fn matches_selector(
+        &self,
+        context: &RoutingContext,
+        geo: &dyn GeoMatcher,
+    ) -> std::result::Result<bool, super::MatchFailure> {
+        use crate::routing::PredicateFailure;
+        if self.behavior == RuleBehavior::Classical {
+            for rule in &self.classical {
+                match crate::routing::matches_rule(rule, context, geo) {
+                    Ok(true) => return Ok(true),
+                    Ok(false)
+                    | Err(
+                        PredicateFailure::NeedsIpResolution | PredicateFailure::NeedsProcessLookup,
+                    ) => {}
+                    Err(PredicateFailure::Evaluation(failure)) => return Err(failure),
+                }
+            }
+            Ok(false)
+        } else {
+            match self.matches(context, geo, true, false) {
+                Ok(matched) => Ok(matched),
+                Err(PredicateFailure::NeedsIpResolution | PredicateFailure::NeedsProcessLookup) => {
+                    Ok(false)
+                }
+                Err(PredicateFailure::Evaluation(failure)) => Err(failure),
+            }
+        }
+    }
+}
+
+fn corrupt() -> VoleError {
+    VoleError::InvalidConfig("invalid MRSv1 rule provider".into())
+}
+struct MrsReader<R> {
+    input: R,
+    remaining: usize,
+}
+impl<R: Read> MrsReader<R> {
+    fn read<const N: usize>(&mut self) -> Result<[u8; N]> {
+        let mut bytes = [0; N];
+        self.read_exact(&mut bytes)?;
+        Ok(bytes)
+    }
+    fn read_exact(&mut self, bytes: &mut [u8]) -> Result<()> {
+        if bytes.len() > self.remaining {
+            return Err(corrupt());
+        }
+        self.input.read_exact(bytes).map_err(|_| corrupt())?;
+        self.remaining -= bytes.len();
+        Ok(())
+    }
+    fn length(&mut self, unit: usize) -> Result<usize> {
+        let n = usize::try_from(i64::from_be_bytes(self.read()?)).map_err(|_| corrupt())?;
+        if n > self.remaining / unit {
+            return Err(corrupt());
+        }
+        Ok(n)
+    }
+    fn words(&mut self) -> Result<Vec<u64>> {
+        let count = self.length(8)?;
+        let mut words = Vec::new();
+        self.chunks(count * 8, |bytes| {
+            words.extend(
+                bytes
+                    .as_chunks::<8>()
+                    .0
+                    .iter()
+                    .copied()
+                    .map(u64::from_be_bytes),
+            );
+        })?;
+        Ok(words)
+    }
+    fn bytes(&mut self, count: usize) -> Result<Vec<u8>> {
+        let mut bytes = Vec::new();
+        self.chunks(count, |block| bytes.extend_from_slice(block))?;
+        Ok(bytes)
+    }
+    // Length declarations are untrusted. Grow output only after each complete
+    // block is available, so a short truncated stream cannot reserve its whole
+    // declared array before EOF is discovered. The block size is divisible by
+    // eight for the word-array decoder.
+    fn chunks(&mut self, mut bytes: usize, mut consume: impl FnMut(&[u8])) -> Result<()> {
+        if bytes > self.remaining {
+            return Err(corrupt());
+        }
+        let mut block = [0_u8; 8192];
+        while bytes != 0 {
+            let len = bytes.min(block.len());
+            self.read_exact(&mut block[..len])?;
+            consume(&block[..len]);
+            bytes -= len;
+        }
+        Ok(())
+    }
+    fn skip(&mut self, mut bytes: usize) -> Result<()> {
+        let mut block = [0_u8; 8192];
+        while bytes != 0 {
+            let len = bytes.min(block.len());
+            self.read_exact(&mut block[..len])?;
+            bytes -= len;
+        }
+        Ok(())
+    }
+    fn finish(mut self) -> Result<()> {
+        if self.input.read(&mut [0]).map_err(|_| corrupt())? != 0 {
+            return Err(corrupt());
+        }
+        Ok(())
+    }
+}
+fn parse_mrs(bytes: &[u8], behavior: RuleBehavior) -> Result<RuleCollection> {
+    let decoder = zstd::stream::read::Decoder::new(bytes).map_err(|_| corrupt())?;
+    let mut input = MrsReader {
+        input: decoder,
+        remaining: MAX_RESOURCE_BYTES,
+    };
+    if input.read::<4>()? != *b"MRS\x01" {
+        return Err(corrupt());
+    }
+    let expected = match behavior {
+        RuleBehavior::Domain => 0,
+        RuleBehavior::Ipcidr => 1,
+        RuleBehavior::Classical => return Err(corrupt()),
+    };
+    if input.read::<1>()?[0] != expected {
+        return Err(corrupt());
+    }
+    let count = usize::try_from(i64::from_be_bytes(input.read()?)).map_err(|_| corrupt())?;
+    let extra = input.length(1)?;
+    input.skip(extra)?;
+    if input.read::<1>()? != [1] {
+        return Err(corrupt());
+    }
+    let mut data = RuleCollection::from_payload(Vec::new(), behavior)?;
+    data.count = count;
+    if behavior == RuleBehavior::Ipcidr {
+        let n = input.length(32)?;
+        for _ in 0..n {
+            let convert = |bytes| {
+                let ip = Ipv6Addr::from(bytes);
+                ip.to_ipv4_mapped()
+                    .map(IpAddr::V4)
+                    .unwrap_or(IpAddr::V6(ip))
+            };
+            let start = convert(input.read::<16>()?);
+            let end = convert(input.read::<16>()?);
+            if start.is_ipv4() != end.is_ipv4() || start > end {
+                return Err(corrupt());
+            }
+            data.ranges.push((start, end));
+        }
+        data.merge_ranges();
+    } else {
+        let leaves = input.words()?;
+        let bitmap = input.words()?;
+        let n = input.length(1)?;
+        let labels = input.bytes(n)?;
+        data.domains = Arc::new(DomainSet::from_mrs(leaves, bitmap, labels)?);
+    }
+    input.finish()?;
+    Ok(data)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn domain_provider_keeps_normalization_input_count_and_generation_snapshots() {
+        let first = Arc::new(
+            RuleCollection::from_payload(
+                vec![
+                    "API.Example.COM".into(),
+                    ".example.com".into(),
+                    "API.EXAMPLE.COM".into(),
+                    "é.test".into(),
+                ],
+                RuleBehavior::Domain,
+            )
+            .unwrap(),
+        );
+        let existing = Arc::clone(&first);
+        let next = Arc::new(
+            RuleCollection::from_payload(vec!["next.test".into()], RuleBehavior::Domain).unwrap(),
+        );
+        assert_eq!(first.len(), 4);
+        let matches = |set: &RuleCollection, domain| {
+            set.matches_domain(
+                domain,
+                &crate::routing::EmptyGeoMatcher,
+                &Default::default(),
+            )
+            .unwrap()
+        };
+        assert!(matches(&existing, "api.example.com"));
+        assert!(matches(&existing, "www.example.com"));
+        assert!(!matches(&existing, "example.com"));
+        // Preserve current selector normalization: Unicode patterns are lower
+        // cased, while query destinations are independently normalized to IDNA.
+        assert!(!matches(&existing, "é.test"));
+        assert!(!matches(&existing, "xn--9ca.test"));
+        assert!(!matches(&existing, "next.test"));
+        assert!(matches(&next, "next.test"));
+        for invalid in ["foo/bar", "one.test,two.test", "foo*bar.test", "geosite:cn"] {
+            assert!(
+                RuleCollection::from_payload(vec![invalid.into()], RuleBehavior::Domain).is_err()
+            );
+        }
+    }
+
+    #[test]
+    fn mrs_stream_reader_keeps_cumulative_limit_and_rejects_trailing_or_truncated_data() {
+        let mut reader = MrsReader {
+            input: &b"abcdefgh"[..],
+            remaining: 7,
+        };
+        assert_eq!(reader.read::<4>().unwrap(), *b"abcd");
+        assert!(reader.read::<4>().is_err());
+        reader.skip(3).unwrap();
+        assert!(reader.finish().is_err());
+        let mut reader = MrsReader {
+            input: &b"abc"[..],
+            remaining: 3,
+        };
+        assert_eq!(reader.read::<3>().unwrap(), *b"abc");
+        reader.finish().unwrap();
+
+        let mut bytes = b"MRS\x01".to_vec();
+        bytes.push(0);
+        bytes.extend(97_i64.to_be_bytes());
+        bytes.extend(0_i64.to_be_bytes());
+        bytes.push(1);
+        // A single exact 'a' domain. Header count remains the writer's input
+        // count, which need not equal the number of unique stored terminals.
+        bytes.extend(1_i64.to_be_bytes());
+        bytes.extend(2_u64.to_be_bytes());
+        bytes.extend(1_i64.to_be_bytes());
+        bytes.extend(6_u64.to_be_bytes());
+        bytes.extend(1_i64.to_be_bytes());
+        bytes.push(b'a');
+        let compressed = zstd::encode_all(bytes.as_slice(), 1).unwrap();
+        let set =
+            RuleCollection::parse(&compressed, RuleBehavior::Domain, RuleFormat::Mrs).unwrap();
+        assert_eq!(set.len(), 97);
+        for cut in [0, 4, 13, bytes.len() - 1] {
+            let truncated = zstd::encode_all(&bytes[..cut], 1).unwrap();
+            assert!(
+                RuleCollection::parse(&truncated, RuleBehavior::Domain, RuleFormat::Mrs).is_err()
+            );
+        }
+        bytes.push(0);
+        let trailing = zstd::encode_all(bytes.as_slice(), 1).unwrap();
+        assert!(RuleCollection::parse(&trailing, RuleBehavior::Domain, RuleFormat::Mrs).is_err());
+    }
+
+    #[test]
+    fn mrs_truncated_large_arrays_only_retain_successfully_read_blocks() {
+        let actual = vec![0_u8; 8200];
+        let mut reader = MrsReader {
+            input: actual.as_slice(),
+            remaining: MAX_RESOURCE_BYTES,
+        };
+        let mut retained = Vec::new();
+        assert!(
+            reader
+                .chunks(MAX_RESOURCE_BYTES - 8, |block| {
+                    retained.extend_from_slice(block)
+                })
+                .is_err()
+        );
+        assert_eq!(retained.len(), 8192);
+        assert!(retained.capacity() <= actual.len());
+        assert_eq!(reader.remaining, MAX_RESOURCE_BYTES - retained.len());
+
+        let mut header = b"MRS\x01".to_vec();
+        header.push(0);
+        header.extend(1_i64.to_be_bytes());
+        header.extend(0_i64.to_be_bytes());
+        header.push(1);
+        let mut missing_words = header.clone();
+        missing_words.extend(((MAX_RESOURCE_BYTES / 8 - 16) as i64).to_be_bytes());
+        let compressed = zstd::encode_all(missing_words.as_slice(), 1).unwrap();
+        assert!(RuleCollection::parse(&compressed, RuleBehavior::Domain, RuleFormat::Mrs).is_err());
+        // Valid one-word arrays followed by a large label declaration and EOF.
+        for word in [2_u64, 6_u64] {
+            header.extend(1_i64.to_be_bytes());
+            header.extend(word.to_be_bytes());
+        }
+        header.extend(((MAX_RESOURCE_BYTES - 128) as i64).to_be_bytes());
+        let compressed = zstd::encode_all(header.as_slice(), 1).unwrap();
+        assert!(RuleCollection::parse(&compressed, RuleBehavior::Domain, RuleFormat::Mrs).is_err());
+    }
+
+    #[test]
+    fn classical_selectors_keep_complete_logical_domain_and_ip_predicates() {
+        let geo = crate::routing::EmptyGeoMatcher;
+        for (payload, matched, unmatched) in [
+            (
+                "AND,((DOMAIN-SUFFIX,example),(DOMAIN-KEYWORD,api))",
+                "api.example",
+                "www.example",
+            ),
+            (
+                "OR,((DOMAIN,api.example),(AND,((DOMAIN-SUFFIX,example),(NOT,((DOMAIN,skip.example))))))",
+                "www.example",
+                "skip.example",
+            ),
+            ("NOT,((DOMAIN,skip.example))", "api.example", "skip.example"),
+        ] {
+            let set = RuleCollection::from_payload(vec![payload.into()], RuleBehavior::Classical)
+                .unwrap();
+            assert_eq!(
+                set.matches_domain(matched, &geo, &Default::default()),
+                Ok(true)
+            );
+            assert_eq!(
+                set.matches_domain(unmatched, &geo, &Default::default()),
+                Ok(false)
+            );
+        }
+        for (payload, matched, unmatched) in [
+            (
+                "AND,((IP-CIDR,192.0.2.0/24),(NOT,((IP-CIDR,192.0.2.7/32))))",
+                "192.0.2.1",
+                "192.0.2.7",
+            ),
+            (
+                "OR,((IP-CIDR,192.0.2.0/24),(IP-SUFFIX,198.51.100.1/8))",
+                "198.51.100.1",
+                "198.51.100.2",
+            ),
+            ("NOT,((IP-CIDR,192.0.2.0/24))", "198.51.100.1", "192.0.2.1"),
+            (
+                "AND,((IP-CIDR6,2001:db8::/32),(NOT,((IP-SUFFIX,::7/8))))",
+                "2001:db8::1",
+                "2001:db8::7",
+            ),
+            (
+                "OR,((IP-CIDR6,2001:db8::/32),(IP-SUFFIX,::1/8))",
+                "2001:db9::1",
+                "2001:db9::2",
+            ),
+            (
+                "NOT,((IP-CIDR6,2001:db8::/32))",
+                "2001:db9::1",
+                "2001:db8::1",
+            ),
+        ] {
+            let set = RuleCollection::from_payload(vec![payload.into()], RuleBehavior::Classical)
+                .unwrap();
+            assert_eq!(
+                set.matches_ip(matched.parse().unwrap(), &geo, &Default::default()),
+                Ok(true)
+            );
+            assert_eq!(
+                set.matches_ip(unmatched.parse().unwrap(), &geo, &Default::default()),
+                Ok(false)
+            );
+        }
+        // Reference selectors evaluate the complete expression using their
+        // zero metadata; a missing source predicate is false and NOT is true.
+        for payload in [
+            "AND,((DOMAIN,api.example),(NETWORK,TCP))",
+            "OR,((DOMAIN,api.example),(DST-PORT,53))",
+            "NOT,((SRC-IP-CIDR,192.0.2.0/24))",
+        ] {
+            let set = RuleCollection::from_payload(vec![payload.into()], RuleBehavior::Classical)
+                .unwrap();
+            assert_eq!(
+                set.matches_domain("api.example", &geo, &Default::default()),
+                Ok(true)
+            );
+        }
+        for payload in [
+            "AND,((IP-CIDR,192.0.2.0/24),(NETWORK,TCP))",
+            "OR,((IP-CIDR,192.0.2.0/24),(DOMAIN,api.example))",
+            "NOT,((SRC-IP-CIDR,198.51.100.0/24))",
+        ] {
+            let set = RuleCollection::from_payload(vec![payload.into()], RuleBehavior::Classical)
+                .unwrap();
+            assert_eq!(
+                set.matches_ip("192.0.2.1".parse().unwrap(), &geo, &Default::default()),
+                Ok(true)
+            );
+        }
+    }
+
+    #[test]
+    fn classical_selector_uses_zero_metadata_without_business_ingress_or_resolution() {
+        let geo = crate::routing::EmptyGeoMatcher;
+        for (payload, expected) in [
+            ("AND,((DOMAIN,api.example),(DST-PORT,0))", true),
+            ("AND,((DOMAIN,api.example),(DST-PORT,53))", false),
+            ("AND,((DOMAIN,api.example),(NETWORK,TCP))", true),
+            ("AND,((DOMAIN,api.example),(NETWORK,UDP))", false),
+            ("AND,((DOMAIN,api.example),(IN-TYPE,HTTP))", true),
+            ("AND,((DOMAIN,api.example),(IN-TYPE,INNER))", false),
+            ("AND,((DOMAIN,api.example),(IN-NAME,DEFAULT-MIXED))", false),
+            ("AND,((DOMAIN,api.example),(IN-NAME,DEFAULT-TUN))", false),
+            ("AND,((DOMAIN,api.example),(IN-PORT,0))", true),
+            ("NOT,((IP-CIDR,192.0.2.0/24))", true),
+            ("NOT,((PROCESS-NAME,synthetic))", true),
+        ] {
+            let set = RuleCollection::from_payload(vec![payload.into()], RuleBehavior::Classical)
+                .unwrap();
+            assert_eq!(
+                set.matches_domain("api.example", &geo, &Default::default()),
+                Ok(expected),
+                "{payload}"
+            );
+        }
+        for (payload, expected) in [
+            ("AND,((IP-CIDR,192.0.2.0/24),(DST-PORT,0))", true),
+            ("AND,((IP-CIDR,192.0.2.0/24),(DST-PORT,1))", false),
+            ("AND,((IP-CIDR,192.0.2.0/24),(SRC-PORT,0))", true),
+            ("AND,((IP-CIDR,192.0.2.0/24),(IN-TYPE,HTTP))", true),
+        ] {
+            let set = RuleCollection::from_payload(vec![payload.into()], RuleBehavior::Classical)
+                .unwrap();
+            assert_eq!(
+                set.matches_ip("192.0.2.1".parse().unwrap(), &geo, &Default::default()),
+                Ok(expected),
+                "{payload}"
+            );
+        }
+    }
+
+    #[test]
+    fn ingress_source_rule_set_swaps_address_ports_but_keeps_host_and_identity() {
+        use crate::session::{InboundKind, InboundMetadata};
+        let destination = crate::session::Destination::domain("host.example", 443).unwrap();
+        let mut context = RoutingContext::new(Network::Tcp, &destination).unwrap();
+        context.set_source("192.0.2.1:1234".parse().unwrap());
+        context.set_inbound(
+            InboundKind::Https,
+            &InboundMetadata {
+                local_port: 1080,
+                user: Some("Alice".into()),
+                ..Default::default()
+            },
+        );
+        let before = context.clone();
+        let geo = crate::routing::EmptyGeoMatcher;
+        let classical = RuleCollection::from_payload(vec![
+            "AND,((IP-CIDR,192.0.2.0/24),(DST-PORT,1234),(SRC-PORT,443),(DOMAIN,host.example),(IN-TYPE,HTTPS),(IN-PORT,1080),(IN-USER,Alice))".into()
+        ], RuleBehavior::Classical).unwrap();
+        assert_eq!(classical.matches(&context, &geo, true, true), Ok(true));
+        assert_eq!(classical.matches(&context, &geo, true, false), Ok(false));
+        // Source port remains available while the domain target has no resolved IP.
+        let source_ip = RuleCollection::from_payload(
+            vec!["SRC-IP-CIDR,203.0.113.0/24".into()],
+            RuleBehavior::Classical,
+        )
+        .unwrap();
+        assert_eq!(source_ip.matches(&context, &geo, true, true), Ok(false));
+        context.pin_ip("203.0.113.1".parse().unwrap());
+        assert_eq!(source_ip.matches(&context, &geo, true, true), Ok(true));
+        context = before.clone();
+        for (behavior, payload) in [
+            (RuleBehavior::Domain, "host.example"),
+            (RuleBehavior::Ipcidr, "192.0.2.0/24"),
+        ] {
+            let set = RuleCollection::from_payload(vec![payload.into()], behavior).unwrap();
+            assert_eq!(set.matches(&context, &geo, true, true), Ok(true));
+        }
+        assert_eq!(context, before);
+    }
+
+    #[test]
+    fn mrs_domain_and_ip_ranges_match_yaml_and_text() {
+        fn header(behavior: u8) -> Vec<u8> {
+            let mut bytes = b"MRS\x01".to_vec();
+            bytes.push(behavior);
+            bytes.extend(1i64.to_be_bytes());
+            bytes.extend(0i64.to_be_bytes());
+            bytes.push(1);
+            bytes
+        }
+        let mut bytes = header(0);
+        let labels = b"tset.cba";
+        bytes.extend(1i64.to_be_bytes());
+        bytes.extend((1u64 << labels.len()).to_be_bytes());
+        bytes.extend(1i64.to_be_bytes());
+        let bitmap =
+            (0..labels.len()).fold(1u64 << (labels.len() * 2), |b, i| b | (1 << (i * 2 + 1)));
+        bytes.extend(bitmap.to_be_bytes());
+        bytes.extend((labels.len() as i64).to_be_bytes());
+        bytes.extend(labels);
+        let compressed = zstd::encode_all(bytes.as_slice(), 1).unwrap();
+        let mrs =
+            RuleCollection::parse(&compressed, RuleBehavior::Domain, RuleFormat::Mrs).unwrap();
+        let yaml = RuleCollection::parse(
+            b"payload: [abc.test]",
+            RuleBehavior::Domain,
+            RuleFormat::Yaml,
+        )
+        .unwrap();
+        for domain in ["abc.test", "no.test", "www.abc.test"] {
+            assert_eq!(
+                mrs.matches_domain(
+                    domain,
+                    &crate::routing::EmptyGeoMatcher,
+                    &Default::default()
+                ),
+                yaml.matches_domain(
+                    domain,
+                    &crate::routing::EmptyGeoMatcher,
+                    &Default::default()
+                )
+            );
+        }
+        let mut bytes = header(1);
+        bytes.extend(1i64.to_be_bytes());
+        for ip in [Ipv4Addr::new(10, 0, 0, 0), Ipv4Addr::new(10, 255, 255, 255)] {
+            bytes.extend(ip.to_ipv6_mapped().octets());
+        }
+        let compressed = zstd::encode_all(bytes.as_slice(), 1).unwrap();
+        let mrs =
+            RuleCollection::parse(&compressed, RuleBehavior::Ipcidr, RuleFormat::Mrs).unwrap();
+        let text = RuleCollection::parse(
+            b"# private\n10.0.0.0/8\n",
+            RuleBehavior::Ipcidr,
+            RuleFormat::Text,
+        )
+        .unwrap();
+        assert_eq!(mrs.ranges, text.ranges);
+        assert!(RuleCollection::parse(&compressed, RuleBehavior::Domain, RuleFormat::Mrs).is_err());
+    }
+}
diff --git a/src/config/rule_provider/domain_set.rs b/src/config/rule_provider/domain_set.rs
new file mode 100644
index 0000000..2eca748
--- /dev/null
+++ b/src/config/rule_provider/domain_set.rs
@@ -0,0 +1,463 @@
+//! Immutable byte-trie representation of the public MRSv1 domain format.
+//!
+//! Each node contributes its child edges as zero bits followed by a one bit
+//! (LOUDS). Edge labels and terminal bits stay contiguous; a sparse directory
+//! records every 32nd node's bit offset. Queries borrow the normalized domain
+//! and never construct a reversed string or a heap-backed traversal stack.
+use super::{Result, corrupt};
+use std::ops::Range;
+
+const DIRECTORY_STRIDE: usize = 32;
+const MAX_MRS_DEPTH: usize = 253;
+
+#[derive(Debug, Default, PartialEq, Eq)]
+pub(super) struct DomainSet {
+    leaves: Box<[u64]>,
+    bitmap: Box<[u64]>,
+    labels: Box<[u8]>,
+    directory: Box<[u32]>,
+    ordered: bool,
+}
+
+impl DomainSet {
+    pub(super) fn from_patterns(patterns: Vec<String>) -> Result<Self> {
+        let mut keys = Vec::with_capacity(patterns.len());
+        for pattern in patterns {
+            if let Some(domain) = pattern.strip_prefix("+.") {
+                let mut suffix = domain.as_bytes().to_vec();
+                suffix.reverse();
+                keys.push(suffix.clone());
+                suffix.push(b'.');
+                keys.push(suffix);
+            } else {
+                let mut key = pattern.into_bytes();
+                key.reverse();
+                keys.push(key);
+            }
+        }
+        keys.sort_unstable();
+        keys.dedup();
+        if keys.is_empty() {
+            return Ok(Self::default());
+        }
+
+        let mut leaves = Vec::new();
+        let mut bitmap = Vec::new();
+        let mut labels = Vec::new();
+        let mut directory = Vec::new();
+        let mut layer = std::iter::once(0..keys.len()).collect::<Vec<_>>();
+        let mut next = Vec::new();
+        let (mut node, mut bit, mut depth) = (0, 0, 0);
+        while !layer.is_empty() {
+            for mut group in layer.drain(..) {
+                if node % DIRECTORY_STRIDE == 0 {
+                    directory.push(u32::try_from(bit).map_err(|_| corrupt())?);
+                }
+                if keys[group.start].len() == depth {
+                    set_bit(&mut leaves, node);
+                    group.start += 1;
+                }
+                while group.start < group.end {
+                    let start = group.start;
+                    let label = keys[start][depth];
+                    group.start += 1;
+                    while group.start < group.end && keys[group.start][depth] == label {
+                        group.start += 1;
+                    }
+                    labels.push(label);
+                    next.push(start..group.start);
+                    bit += 1;
+                }
+                set_bit(&mut bitmap, bit);
+                bit += 1;
+                node += 1;
+            }
+            std::mem::swap(&mut layer, &mut next);
+            depth += 1;
+        }
+        // Nonterminal nodes at the end still need a terminal bitmap slot.
+        leaves.resize(node.div_ceil(64), 0);
+        Ok(Self {
+            leaves: leaves.into_boxed_slice(),
+            bitmap: bitmap.into_boxed_slice(),
+            labels: labels.into_boxed_slice(),
+            directory: directory.into_boxed_slice(),
+            ordered: true,
+        })
+    }
+
+    pub(super) fn from_mrs(
+        mut leaves: Vec<u64>,
+        mut bitmap: Vec<u64>,
+        labels: Vec<u8>,
+    ) -> Result<Self> {
+        let nodes = labels.len().checked_add(1).ok_or_else(corrupt)?;
+        if leaves.len().saturating_mul(64) < nodes {
+            return Err(corrupt());
+        }
+        let mut directory = Vec::with_capacity(nodes.div_ceil(DIRECTORY_STRIDE));
+        let (mut position, mut edge) = (0, 0);
+        let (mut ordered, mut duplicate) = (true, false);
+        for node in 0..nodes {
+            if node % DIRECTORY_STRIDE == 0 {
+                directory.push(u32::try_from(position).map_err(|_| corrupt())?);
+            }
+            let start = edge;
+            while position < bitmap.len().saturating_mul(64) && !bit(&bitmap, position) {
+                edge += 1;
+                // Child IDs are edge + 1; every child follows its parent.
+                if edge <= node || edge >= nodes {
+                    return Err(corrupt());
+                }
+                position += 1;
+            }
+            if position >= bitmap.len().saturating_mul(64) {
+                return Err(corrupt());
+            }
+            ordered &= labels[start..edge].windows(2).all(|pair| pair[0] < pair[1]);
+            let mut seen = [0_u64; 4];
+            for label in &labels[start..edge] {
+                let (word, mask) = (usize::from(*label / 64), 1_u64 << (*label % 64));
+                duplicate |= seen[word] & mask != 0;
+                seen[word] |= mask;
+            }
+            position += 1;
+        }
+        if edge != labels.len() {
+            return Err(corrupt());
+        }
+        // Padding was ignored by the previous decoder; discard it rather than
+        // retaining attacker-controlled extra bitmap words in a generation.
+        leaves.truncate(nodes.div_ceil(64));
+        bitmap.truncate(position.div_ceil(64));
+        let mut set = Self {
+            leaves: leaves.into_boxed_slice(),
+            bitmap: bitmap.into_boxed_slice(),
+            labels: labels.into_boxed_slice(),
+            directory: directory.into_boxed_slice(),
+            ordered,
+        };
+        // Older decoders merged duplicate character branches when constructing
+        // the domain index. Retain that union for noncanonical inputs without
+        // imposing a repeated-branch search cost on every ordinary query.
+        let mut patterns = duplicate.then(Vec::new);
+        set.validate_paths(patterns.as_mut())?;
+        match patterns {
+            Some(patterns) => Self::from_patterns(patterns),
+            None => Ok(set),
+        }
+    }
+
+    // Validate every path once without expanding terminal domains. Previous MRS
+    // decoding removed terminal '+' bytes before interpreting domain patterns;
+    // moving those terminal bits to their ancestor preserves that behavior.
+    fn validate_paths(&mut self, mut patterns: Option<&mut Vec<String>>) -> Result<()> {
+        let mut path = [0_u8; MAX_MRS_DEPTH];
+        let mut frames: [Range<usize>; MAX_MRS_DEPTH + 1] = std::array::from_fn(|_| 0..0);
+        let mut ancestors = [0_usize; MAX_MRS_DEPTH + 1];
+        frames[0] = self.children(0);
+        let mut depth = 0;
+        loop {
+            let Some(edge) = frames[depth].next() else {
+                if depth == 0 {
+                    return Ok(());
+                }
+                depth -= 1;
+                continue;
+            };
+            if depth == MAX_MRS_DEPTH {
+                return Err(corrupt());
+            }
+            path[depth] = self.labels[edge];
+            depth += 1;
+            let node = edge + 1;
+            ancestors[depth] = node;
+            if self.terminal(node) {
+                let key = std::str::from_utf8(&path[..depth]).map_err(|_| corrupt())?;
+                if let Some(patterns) = patterns.as_deref_mut() {
+                    patterns.push(key.trim_end_matches('+').chars().rev().collect());
+                }
+                let mut terminal_depth = depth;
+                while terminal_depth > 0 && path[terminal_depth - 1] == b'+' {
+                    terminal_depth -= 1;
+                }
+                if terminal_depth != depth {
+                    self.leaves[node / 64] &= !(1_u64 << (node % 64));
+                    let terminal = ancestors[terminal_depth];
+                    self.leaves[terminal / 64] |= 1_u64 << (terminal % 64);
+                }
+            }
+            frames[depth] = self.children(node);
+        }
+    }
+
+    pub(super) fn contains(&self, name: &str) -> bool {
+        !name.is_empty()
+            && name.len() <= MAX_MRS_DEPTH
+            && !self.labels.is_empty()
+            && self.matches_label(0, name, false)
+    }
+
+    fn matches_label(&self, node: usize, name: &str, suffix: bool) -> bool {
+        if name.is_empty() {
+            return self.terminal(node);
+        }
+        if suffix && self.terminal(node) {
+            return true;
+        }
+        let (rest, label) = name.rsplit_once('.').unwrap_or(("", name));
+        let mut literal = Some(node);
+        for byte in label.bytes().rev() {
+            literal = literal.and_then(|current| self.child(current, byte));
+            if literal.is_none() {
+                break;
+            }
+        }
+        literal.is_some_and(|end| self.finish_label(end, rest))
+            || self
+                .child(node, b'*')
+                .is_some_and(|end| self.finish_label(end, rest))
+    }
+
+    fn finish_label(&self, node: usize, rest: &str) -> bool {
+        if rest.is_empty() {
+            self.terminal(node)
+        } else {
+            self.child(node, b'.')
+                .is_some_and(|next| self.matches_label(next, rest, true))
+        }
+    }
+
+    fn child(&self, node: usize, label: u8) -> Option<usize> {
+        let children = self.children(node);
+        let labels = &self.labels[children.clone()];
+        let offset = if self.ordered {
+            labels.binary_search(&label).ok()
+        } else {
+            labels.iter().position(|candidate| *candidate == label)
+        };
+        offset.map(|offset| children.start + offset + 1)
+    }
+
+    fn terminal(&self, node: usize) -> bool {
+        bit(&self.leaves, node)
+    }
+
+    fn children(&self, node: usize) -> Range<usize> {
+        let sample = self.directory[node / DIRECTORY_STRIDE] as usize;
+        let offset = node % DIRECTORY_STRIDE;
+        let start = if offset == 0 {
+            sample
+        } else {
+            self.select_one(sample, offset - 1) + 1
+        };
+        let end = self.select_one(start, 0);
+        start - node..end - node
+    }
+
+    fn select_one(&self, start: usize, mut rank: usize) -> usize {
+        let mut index = start / 64;
+        let mut word = self.bitmap[index] & (u64::MAX << (start % 64));
+        loop {
+            let count = word.count_ones() as usize;
+            if rank < count {
+                return index * 64 + nth_one(word, rank);
+            }
+            rank -= count;
+            index += 1;
+            word = self.bitmap[index];
+        }
+    }
+}
+
+fn bit(words: &[u64], offset: usize) -> bool {
+    words
+        .get(offset / 64)
+        .is_some_and(|word| word & (1_u64 << (offset % 64)) != 0)
+}
+
+fn set_bit(words: &mut Vec<u64>, offset: usize) {
+    words.resize(words.len().max(offset / 64 + 1), 0);
+    words[offset / 64] |= 1_u64 << (offset % 64);
+}
+
+fn nth_one(mut word: u64, mut rank: usize) -> usize {
+    if rank == 0 {
+        return word.trailing_zeros() as usize;
+    }
+    let mut offset = 0;
+    for width in [32, 16, 8, 4, 2, 1] {
+        let count = (word & ((1_u64 << width) - 1)).count_ones() as usize;
+        if rank >= count {
+            rank -= count;
+            word >>= width;
+            offset += width;
+        }
+    }
+    offset
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::dns::policy::DomainIndex;
+
+    fn chain(key: &[u8], terminals: &[usize]) -> Result<DomainSet> {
+        let mut leaves = vec![0; (key.len() + 1).div_ceil(64)];
+        for terminal in terminals {
+            set_bit(&mut leaves, *terminal);
+        }
+        let mut bitmap = Vec::new();
+        for index in 0..key.len() {
+            set_bit(&mut bitmap, index * 2 + 1);
+        }
+        set_bit(&mut bitmap, key.len() * 2);
+        DomainSet::from_mrs(leaves, bitmap, key.to_vec())
+    }
+
+    #[test]
+    fn compact_domains_match_existing_label_index_including_overlapping_wildcards() {
+        let mut groups = vec![
+            vec!["example.com"],
+            vec![".example.com"],
+            vec!["+.example.com"],
+            vec!["*.example.com"],
+            vec!["*.a.*.example.com"],
+            vec!["deep.api.example.com", "*.example.com"],
+            vec!["dead.api.example.com", "api.*.com"],
+            vec!["deep.api.example.com", ".example.com"],
+            vec!["*.api.example.com", ".api.example.com", "api.example.com"],
+            vec!["example.com", "example.com", ".example.com"],
+            vec!["xn--xample-9ua.test", "é.test"],
+        ];
+        let generated = ["a", "b", "*"]
+            .into_iter()
+            .flat_map(|a| {
+                ["a", "b", "*"].into_iter().flat_map(move |b| {
+                    [
+                        format!("{a}.{b}"),
+                        format!(".{a}.{b}"),
+                        format!("+.{a}.{b}"),
+                    ]
+                })
+            })
+            .collect::<Vec<_>>();
+        groups.extend(generated.iter().map(|pattern| vec![pattern.as_str()]));
+        let mut queries = vec![
+            "example.com".to_owned(),
+            "api.example.com".to_owned(),
+            "www.api.example.com".to_owned(),
+            "www.a.api.example.com".to_owned(),
+            "deep.api.example.com".to_owned(),
+            "api.other.com".to_owned(),
+            "fooexample.com".to_owned(),
+            "xn--xample-9ua.test".to_owned(),
+            "xn--9ca.test".to_owned(),
+        ];
+        for a in ["a", "b", "c"] {
+            queries.push(a.to_owned());
+            for b in ["a", "b", "c"] {
+                queries.push(format!("{a}.{b}"));
+                for c in ["a", "b", "c"] {
+                    queries.push(format!("{a}.{b}.{c}"));
+                }
+            }
+        }
+        for patterns in groups {
+            let mut old = DomainIndex::new();
+            for pattern in &patterns {
+                old.insert(pattern, 0);
+            }
+            let compact =
+                DomainSet::from_patterns(patterns.iter().map(|s| (*s).into()).collect()).unwrap();
+            for query in &queries {
+                assert_eq!(
+                    compact.contains(query),
+                    old.find(0, query).is_some(),
+                    "patterns {patterns:?}, query {query}"
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn mrs_terminal_markers_keep_exact_suffix_and_whole_label_wildcards() {
+        let suffix = chain(b"tset.+", &[6]).unwrap();
+        assert!(!suffix.contains("test"));
+        assert!(suffix.contains("a.test"));
+        assert!(suffix.contains("a.b.test"));
+        assert!(!suffix.contains("atest"));
+        let both = chain(b"tset.+", &[4, 6]).unwrap();
+        assert!(both.contains("test"));
+        assert!(both.contains("a.test"));
+        let wildcard = chain(b"tset.*", &[6]).unwrap();
+        assert!(!wildcard.contains("test"));
+        assert!(wildcard.contains("a.test"));
+        assert!(!wildcard.contains("a.b.test"));
+        let repeated_marker = chain(b"tset++", &[6]).unwrap();
+        assert!(repeated_marker.contains("test"));
+        assert!(!repeated_marker.contains("a.test"));
+    }
+
+    #[test]
+    fn mrs_retains_noncanonical_edge_order_and_duplicate_branch_union() {
+        let unordered = DomainSet::from_mrs(vec![6], vec![0b11100], b"ba".to_vec()).unwrap();
+        assert!(!unordered.ordered);
+        assert!(unordered.contains("a"));
+        assert!(unordered.contains("b"));
+        assert!(!unordered.contains("c"));
+        // Root has two 'a' children, respectively followed by 'b' and 'c'.
+        let duplicate = DomainSet::from_mrs(vec![24], vec![0b111010100], b"aabc".to_vec()).unwrap();
+        assert!(duplicate.ordered);
+        assert!(duplicate.contains("ba"));
+        assert!(duplicate.contains("ca"));
+        assert!(!duplicate.contains("a"));
+    }
+
+    #[test]
+    fn mrs_validation_bounds_paths_utf8_and_structure_without_enumeration() {
+        assert!(chain(&[b'a'; 253], &[253]).is_ok());
+        assert!(chain(&[b'a'; 254], &[]).is_err());
+        assert!(chain(&[0xff], &[1]).is_err());
+        assert!(chain(&[0xff], &[]).is_ok());
+        assert!(DomainSet::from_mrs(vec![], vec![6], vec![b'a']).is_err());
+        assert!(DomainSet::from_mrs(vec![0], vec![], vec![b'a']).is_err());
+        assert!(DomainSet::from_mrs(vec![0], vec![0], vec![b'a']).is_err());
+        // An empty root cannot own a later node with a back-edge to itself.
+        assert!(DomainSet::from_mrs(vec![0], vec![1], vec![b'a']).is_err());
+        let mut padded = chain(b"a", &[1]).unwrap();
+        let labels = padded.labels.to_vec();
+        let mut leaves = padded.leaves.to_vec();
+        let mut bitmap = padded.bitmap.to_vec();
+        leaves.push(u64::MAX);
+        bitmap.push(u64::MAX);
+        padded = DomainSet::from_mrs(leaves, bitmap, labels).unwrap();
+        assert_eq!(padded.leaves.len(), 1);
+        assert_eq!(padded.bitmap.len(), 1);
+        assert!(padded.contains("a"));
+        assert!(!padded.contains("b"));
+        let root_only = DomainSet::from_mrs(vec![1], vec![1], Vec::new()).unwrap();
+        assert!(!root_only.contains("a"));
+        // The MRS file's depth bound does not add a YAML/Text pattern limit.
+        assert!(DomainSet::from_patterns(vec!["a".repeat(254)]).is_ok());
+    }
+
+    #[test]
+    fn compact_domain_storage_is_linear_in_edges_and_has_no_per_node_allocations() {
+        let patterns = (0..10_000)
+            .map(|index| format!("+.host{index:05}.example"))
+            .collect::<Vec<_>>();
+        let source_bytes = patterns.iter().map(String::len).sum::<usize>();
+        let compact = DomainSet::from_patterns(patterns).unwrap();
+        let stored_bytes = compact.leaves.len() * 8
+            + compact.bitmap.len() * 8
+            + compact.labels.len()
+            + compact.directory.len() * 4;
+        assert!(stored_bytes <= compact.labels.len() * 3 / 2 + 32);
+        assert!(stored_bytes < source_bytes);
+        for query in ["host00000.example", "a.host09999.example"] {
+            assert!(compact.contains(query));
+        }
+        assert!(!compact.contains("host10000.example"));
+    }
+}
diff --git a/src/config/rules.rs b/src/config/rules.rs
new file mode 100644
index 0000000..f10ee1a
--- /dev/null
+++ b/src/config/rules.rs
@@ -0,0 +1,508 @@
+use super::*;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum RuleInboundType {
+    Http,
+    Https,
+    Socks4,
+    Socks5,
+    Shadowsocks,
+    Snell,
+    Vmess,
+    Vless,
+    Redir,
+    Tproxy,
+    Trojan,
+    Tunnel,
+    Tun,
+    Tuic,
+    Hysteria2,
+    Anytls,
+    Mieru,
+    Sudoku,
+    Trusttunnel,
+    Shadowquic,
+    Inner,
+}
+impl RuleInboundType {
+    pub(crate) fn for_inbound(kind: crate::session::InboundKind) -> Self {
+        use crate::session::InboundKind;
+        match kind {
+            InboundKind::Http => Self::Http,
+            InboundKind::Https => Self::Https,
+            InboundKind::Socks5 => Self::Socks5,
+            InboundKind::Tun => Self::Tun,
+            InboundKind::InternalDns
+            | InboundKind::InternalGeoData
+            | InboundKind::InternalMeasure => Self::Inner,
+        }
+    }
+    pub(crate) fn name(self) -> &'static str {
+        match self {
+            Self::Http => "HTTP",
+            Self::Https => "HTTPS",
+            Self::Socks4 => "SOCKS4",
+            Self::Socks5 => "SOCKS5",
+            Self::Shadowsocks => "SHADOWSOCKS",
+            Self::Snell => "SNELL",
+            Self::Vmess => "VMESS",
+            Self::Vless => "VLESS",
+            Self::Redir => "REDIR",
+            Self::Tproxy => "TPROXY",
+            Self::Trojan => "TROJAN",
+            Self::Tunnel => "TUNNEL",
+            Self::Tun => "TUN",
+            Self::Tuic => "TUIC",
+            Self::Hysteria2 => "HYSTERIA2",
+            Self::Anytls => "ANYTLS",
+            Self::Mieru => "MIERU",
+            Self::Sudoku => "SUDOKU",
+            Self::Trusttunnel => "TRUSTTUNNEL",
+            Self::Shadowquic => "SHADOWQUIC",
+            Self::Inner => "INNER",
+        }
+    }
+}
+fn parse_in_types(payload: &str) -> Result<Vec<RuleInboundType>> {
+    let mut types = Vec::new();
+    for value in payload.split('/') {
+        let value = value.trim().to_ascii_uppercase();
+        if value == "SOCKS" {
+            types.extend([RuleInboundType::Socks4, RuleInboundType::Socks5]);
+            continue;
+        }
+        types.push(match value.as_str() {
+            "HTTP" => RuleInboundType::Http,
+            "HTTPS" => RuleInboundType::Https,
+            "SOCKS4" => RuleInboundType::Socks4,
+            "SOCKS5" => RuleInboundType::Socks5,
+            "SHADOWSOCKS" => RuleInboundType::Shadowsocks,
+            "SNELL" => RuleInboundType::Snell,
+            "VMESS" => RuleInboundType::Vmess,
+            "VLESS" => RuleInboundType::Vless,
+            "REDIR" => RuleInboundType::Redir,
+            "TPROXY" => RuleInboundType::Tproxy,
+            "TROJAN" => RuleInboundType::Trojan,
+            "TUNNEL" => RuleInboundType::Tunnel,
+            "TUN" => RuleInboundType::Tun,
+            "TUIC" => RuleInboundType::Tuic,
+            "HYSTERIA2" => RuleInboundType::Hysteria2,
+            "ANYTLS" => RuleInboundType::Anytls,
+            "MIERU" => RuleInboundType::Mieru,
+            "SUDOKU" => RuleInboundType::Sudoku,
+            "TRUSTTUNNEL" => RuleInboundType::Trusttunnel,
+            "SHADOWQUIC" => RuleInboundType::Shadowquic,
+            "INNER" => RuleInboundType::Inner,
+            _ => return invalid("IN-TYPE requires a known Mihomo inbound type"),
+        });
+    }
+    Ok(types)
+}
+fn parse_in_users(payload: &str) -> Result<Vec<String>> {
+    payload
+        .split('/')
+        .map(|value| {
+            let value = value.trim();
+            if value.is_empty() {
+                return invalid("IN-USER requires nonempty users");
+            }
+            Ok(value.to_owned())
+        })
+        .collect()
+}
+
+pub(super) fn parse_rule(input: &str, targets: &RouteTargetsByName) -> Result<RuleSpec> {
+    parse(input, Some(targets), 0)
+}
+
+pub(super) fn parse_program_rule(
+    input: &str,
+    targets: &RouteTargetsByName,
+    sub_rules: &HashMap<String, SubRuleId>,
+) -> Result<RuleSpec> {
+    let (kind, rest) = input
+        .split_once(',')
+        .ok_or_else(|| VoleError::InvalidConfig("rule requires a type and payload".into()))?;
+    if trim_ascii_whitespace(kind).eq_ignore_ascii_case("SUB-RULE") {
+        let (condition, name) = rest.rsplit_once(',').ok_or_else(|| {
+            VoleError::InvalidConfig("SUB-RULE requires a condition and named program".into())
+        })?;
+        let condition = trim_ascii_whitespace(condition)
+            .strip_prefix('(')
+            .and_then(|value| value.strip_suffix(')'))
+            .ok_or_else(|| {
+                VoleError::InvalidConfig("SUB-RULE condition requires parentheses".into())
+            })?;
+        let target = sub_rules
+            .get(trim_ascii_whitespace(name))
+            .copied()
+            .ok_or_else(|| {
+                VoleError::InvalidConfig("SUB-RULE references an unknown program".into())
+            })?;
+        return Ok(RuleSpec {
+            kind: RuleKind::SubRule {
+                predicate: Box::new(parse_predicate(condition)?),
+                target,
+            },
+            action: RuleAction::Direct,
+            no_resolve: false,
+        });
+    }
+    let logical = matches!(
+        trim_ascii_whitespace(kind).to_ascii_uppercase().as_str(),
+        "AND" | "OR" | "NOT" | "DOMAIN-REGEX"
+    );
+    let target_range = if logical {
+        input.rfind(',').map(|start| start + 1..input.len())
+    } else {
+        let start = input.find(',').unwrap() + 1;
+        if trim_ascii_whitespace(kind).eq_ignore_ascii_case("MATCH") {
+            Some(start..input.len())
+        } else {
+            input[start..].find(',').map(|offset| {
+                let start = start + offset + 1;
+                let end = input[start..]
+                    .find(',')
+                    .map_or(input.len(), |offset| start + offset);
+                start..end
+            })
+        }
+    };
+    if let Some(range) = target_range {
+        let control = match trim_ascii_whitespace(&input[range.clone()]) {
+            "PASS" => Some(RuleControl::Pass),
+            "PASS-RULE" => Some(RuleControl::PassRule),
+            _ => None,
+        };
+        if let Some(control) = control {
+            let mut terminal = input.to_owned();
+            terminal.replace_range(range, "DIRECT");
+            let predicate = parse(&terminal, Some(targets), 0)?;
+            return Ok(RuleSpec {
+                kind: RuleKind::Flow {
+                    predicate: Box::new(predicate),
+                    control,
+                },
+                action: RuleAction::Direct,
+                no_resolve: false,
+            });
+        }
+    }
+    parse(input, Some(targets), 0)
+}
+
+pub(crate) fn validate_subrule_calls(
+    main: &[RuleSpec],
+    sub_rules: &[NamedRuleProgram],
+) -> Result<()> {
+    fn visit(
+        id: usize,
+        depth: usize,
+        sub_rules: &[NamedRuleProgram],
+        states: &mut [u8],
+        lengths: &mut [usize],
+    ) -> Result<usize> {
+        if depth > 32 {
+            return invalid("sub-rules exceed 32 call levels");
+        }
+        let Some(program) = sub_rules.get(id) else {
+            return invalid("SUB-RULE references an unknown program");
+        };
+        if states[id] == 1 {
+            return invalid("sub-rules contain a reference cycle");
+        }
+        if states[id] == 2 {
+            return Ok(lengths[id]);
+        }
+        states[id] = 1;
+        let mut length = 1;
+        for rule in &program.rules {
+            if let RuleKind::SubRule { target, .. } = &rule.kind {
+                length =
+                    length.max(1 + visit(target.index(), depth + 1, sub_rules, states, lengths)?);
+            }
+        }
+        if length > 32 {
+            return invalid("sub-rules exceed 32 call levels");
+        }
+        states[id] = 2;
+        lengths[id] = length;
+        Ok(length)
+    }
+    fn pure(rule: &RuleSpec, depth: usize) -> Result<()> {
+        if depth > 32 {
+            return invalid("logical rules exceed 32 nesting levels");
+        }
+        match &rule.kind {
+            RuleKind::Flow { .. } | RuleKind::SubRule { .. } => {
+                invalid("flow controls are not predicates")
+            }
+            RuleKind::And(children) | RuleKind::Or(children) => {
+                for child in children {
+                    pure(child, depth + 1)?;
+                }
+                Ok(())
+            }
+            RuleKind::Not(child) => pure(child, depth + 1),
+            _ => Ok(()),
+        }
+    }
+    let mut names = std::collections::HashSet::new();
+    for program in sub_rules {
+        if program.name.is_empty() || !names.insert(&program.name) {
+            return invalid("sub-rules require unique nonempty names");
+        }
+    }
+    for rule in main
+        .iter()
+        .chain(sub_rules.iter().flat_map(|program| &program.rules))
+    {
+        match &rule.kind {
+            RuleKind::Flow { predicate, .. } | RuleKind::SubRule { predicate, .. } => {
+                pure(predicate, 0)?
+            }
+            _ => pure(rule, 0)?,
+        }
+    }
+    let mut states = vec![0; sub_rules.len()];
+    let mut lengths = vec![0; sub_rules.len()];
+    for id in 0..sub_rules.len() {
+        visit(id, 1, sub_rules, &mut states, &mut lengths)?;
+    }
+    for rule in main {
+        if let RuleKind::SubRule { target, .. } = &rule.kind {
+            visit(target.index(), 1, sub_rules, &mut states, &mut lengths)?;
+        }
+    }
+    Ok(())
+}
+
+pub(super) fn parse_predicate(input: &str) -> Result<RuleSpec> {
+    parse(input, None, 0)
+}
+
+fn parse(input: &str, targets: Option<&RouteTargetsByName>, depth: usize) -> Result<RuleSpec> {
+    if depth > 32 {
+        return invalid("logical rules exceed 32 nesting levels");
+    }
+    let (kind, rest) = input
+        .split_once(',')
+        .ok_or_else(|| VoleError::InvalidConfig("rule requires a type and payload".into()))?;
+    let kind = trim_ascii_whitespace(kind).to_ascii_uppercase();
+    if kind == "MATCH" {
+        let targets = targets.ok_or_else(|| {
+            VoleError::InvalidConfig("MATCH is not supported inside logical rules".into())
+        })?;
+        return Ok(RuleSpec {
+            kind: RuleKind::Match,
+            action: parse_rule_action(
+                trim_ascii_whitespace(rest.split(',').next().unwrap_or_default()),
+                targets,
+            )?,
+            no_resolve: false,
+        });
+    }
+    let (payload, action, no_resolve, source) = if matches!(
+        kind.as_str(),
+        "AND" | "OR" | "NOT" | "DOMAIN-REGEX" | "PROCESS-NAME-REGEX" | "PROCESS-PATH-REGEX"
+    ) {
+        match targets {
+            Some(targets) => {
+                let (payload, action) = rest
+                    .rsplit_once(',')
+                    .ok_or_else(|| VoleError::InvalidConfig("rule requires a target".into()))?;
+                (
+                    trim_ascii_whitespace(payload),
+                    parse_rule_action(trim_ascii_whitespace(action), targets)?,
+                    false,
+                    false,
+                )
+            }
+            None => (
+                trim_ascii_whitespace(rest),
+                RuleAction::Direct,
+                false,
+                false,
+            ),
+        }
+    } else {
+        let mut fields = rest.split(',').map(trim_ascii_whitespace);
+        let payload = fields.next().unwrap_or_default();
+        let action = match targets {
+            Some(targets) => parse_rule_action(fields.next().unwrap_or_default(), targets)?,
+            None => RuleAction::Direct,
+        };
+        let mut no_resolve = false;
+        let mut source = matches!(
+            kind.as_str(),
+            "SRC-GEOIP" | "SRC-IP-CIDR" | "SRC-IP-ASN" | "SRC-IP-SUFFIX"
+        );
+        for option in fields {
+            if option == "no-resolve"
+                && matches!(
+                    kind.as_str(),
+                    "RULE-SET"
+                        | "GEOIP"
+                        | "SRC-GEOIP"
+                        | "IP-CIDR"
+                        | "IP-CIDR6"
+                        | "SRC-IP-CIDR"
+                        | "IP-ASN"
+                        | "SRC-IP-ASN"
+                        | "IP-SUFFIX"
+                        | "SRC-IP-SUFFIX"
+                )
+            {
+                no_resolve = true;
+            } else if option == "src"
+                && matches!(
+                    kind.as_str(),
+                    "RULE-SET" | "GEOIP" | "IP-CIDR" | "IP-CIDR6" | "IP-ASN" | "IP-SUFFIX"
+                )
+            {
+                source = true;
+            } else {
+                return invalid("unsupported rule parameter");
+            }
+        }
+        (payload, action, no_resolve || source, source)
+    };
+    let rule_kind = match kind.as_str() {
+        "RULE-SET" => RuleKind::RuleSet {
+            name: payload.to_owned(),
+            content: None,
+            source,
+        },
+        "DOMAIN" => RuleKind::Domain(normalize_rule_domain(payload, "DOMAIN")?),
+        "DOMAIN-SUFFIX" => RuleKind::DomainSuffix(normalize_rule_domain(payload, "DOMAIN-SUFFIX")?),
+        "DOMAIN-KEYWORD" => RuleKind::DomainKeyword(normalize_rule_keyword(payload)?),
+        "DOMAIN-WILDCARD" => RuleKind::DomainWildcard(payload.to_lowercase()),
+        "DOMAIN-REGEX" => RuleKind::DomainRegex(DomainRegex::new(payload)?),
+        "GEOSITE" => RuleKind::GeoSite(normalize_geo_code(payload, "GEOSITE")?),
+        "GEOIP" | "SRC-GEOIP" => {
+            let code = normalize_geo_code(payload, "GEOIP")?;
+            if source {
+                RuleKind::SrcGeoIp(code)
+            } else {
+                RuleKind::GeoIp(code)
+            }
+        }
+        "IP-ASN" | "SRC-IP-ASN" => {
+            if source {
+                RuleKind::SrcIpAsn(payload.to_owned())
+            } else {
+                RuleKind::IpAsn(payload.to_owned())
+            }
+        }
+        "IP-CIDR" | "IP-CIDR6" | "SRC-IP-CIDR" => {
+            let cidr = parse_ip_cidr(payload, payload.contains(':'))?;
+            if source {
+                RuleKind::SrcIpCidr(cidr)
+            } else {
+                RuleKind::IpCidr(cidr)
+            }
+        }
+        "IP-SUFFIX" | "SRC-IP-SUFFIX" => {
+            let suffix = IpSuffix::parse(payload)?;
+            if source {
+                RuleKind::SrcIpSuffix(suffix)
+            } else {
+                RuleKind::IpSuffix(suffix)
+            }
+        }
+        "DST-PORT" => RuleKind::DstPorts(parse_port_ranges(payload)?),
+        "SRC-PORT" => RuleKind::SrcPorts(parse_port_ranges(payload)?),
+        "NETWORK" => RuleKind::Network(parse_network(payload)?),
+        "IN-TYPE" => RuleKind::InTypes(parse_in_types(payload)?),
+        "IN-NAME" => RuleKind::InNames(
+            payload
+                .split('/')
+                .map(|value| {
+                    let value = value.trim();
+                    if value.is_empty() {
+                        return invalid("IN-NAME requires nonempty names");
+                    }
+                    Ok(value.to_owned())
+                })
+                .collect::<Result<Vec<_>>>()?,
+        ),
+        "IN-USER" => RuleKind::InUsers(parse_in_users(payload)?),
+        "REMATCH-NAME" => RuleKind::RematchNames(
+            payload
+                .split('/')
+                .map(|value| {
+                    let value = value.trim();
+                    if value.is_empty() {
+                        return invalid("REMATCH-NAME requires nonempty names");
+                    }
+                    Ok(value.to_owned())
+                })
+                .collect::<Result<Vec<_>>>()?,
+        ),
+        "PROCESS-NAME"
+        | "PROCESS-PATH"
+        | "PROCESS-NAME-WILDCARD"
+        | "PROCESS-PATH-WILDCARD"
+        | "PROCESS-NAME-REGEX"
+        | "PROCESS-PATH-REGEX" => RuleKind::Process(ProcessRule::parse(&kind, payload)?),
+        "UID" => RuleKind::Uid(super::process::uid_ranges(payload)?),
+        "IN-PORT" => RuleKind::InPorts(parse_port_ranges(payload)?),
+        "AND" | "OR" | "NOT" => {
+            let children = logical_children(payload)?
+                .into_iter()
+                .map(|child| parse(child, None, depth + 1))
+                .collect::<Result<Vec<_>>>()?;
+            match kind.as_str() {
+                "AND" => RuleKind::And(children),
+                "OR" => RuleKind::Or(children),
+                _ if children.len() == 1 => {
+                    RuleKind::Not(Box::new(children.into_iter().next().unwrap()))
+                }
+                _ => return invalid("NOT requires exactly one rule"),
+            }
+        }
+        _ => return invalid(format!("unsupported rule type `{kind}`")),
+    };
+    Ok(RuleSpec {
+        kind: rule_kind,
+        action,
+        no_resolve,
+    })
+}
+
+fn logical_children(payload: &str) -> Result<Vec<&str>> {
+    let inner = payload
+        .strip_prefix('(')
+        .and_then(|value| value.strip_suffix(')'))
+        .ok_or_else(|| {
+            VoleError::InvalidConfig("logical rule payload requires parentheses".into())
+        })?;
+    let mut children = Vec::new();
+    let mut depth = 0_usize;
+    let mut start = 0;
+    for (index, byte) in inner.bytes().enumerate() {
+        match byte {
+            b'(' => {
+                if depth == 0 {
+                    start = index + 1;
+                }
+                depth += 1;
+            }
+            b')' => {
+                depth = depth
+                    .checked_sub(1)
+                    .ok_or_else(|| VoleError::InvalidConfig("unbalanced logical rule".into()))?;
+                if depth == 0 {
+                    children.push(&inner[start..index]);
+                }
+            }
+            b',' | b' ' | b'\t' | b'\r' | b'\n' if depth == 0 => {}
+            _ if depth == 0 => return invalid("logical rule children require parentheses"),
+            _ => {}
+        }
+    }
+    if depth != 0 {
+        return invalid("unbalanced logical rule");
+    }
+    Ok(children)
+}
diff --git a/src/config/scalar.rs b/src/config/scalar.rs
new file mode 100644
index 0000000..b854951
--- /dev/null
+++ b/src/config/scalar.rs
@@ -0,0 +1,109 @@
+//! String-backed numeric fields retain their normalizer's syntax and bounds.
+use serde::{Deserializer, de::Visitor};
+
+pub(super) fn string_or_integer<'de, D: Deserializer<'de>>(
+    deserializer: D,
+) -> Result<String, D::Error> {
+    struct Scalar;
+
+    impl Visitor<'_> for Scalar {
+        type Value = String;
+
+        fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            formatter.write_str("a string or integer")
+        }
+
+        fn visit_str<E: serde::de::Error>(self, value: &str) -> Result<String, E> {
+            Ok(value.to_owned())
+        }
+
+        fn visit_string<E: serde::de::Error>(self, value: String) -> Result<String, E> {
+            Ok(value)
+        }
+
+        fn visit_i64<E: serde::de::Error>(self, value: i64) -> Result<String, E> {
+            Ok(value.to_string())
+        }
+
+        fn visit_u64<E: serde::de::Error>(self, value: u64) -> Result<String, E> {
+            Ok(value.to_string())
+        }
+    }
+
+    deserializer.deserialize_any(Scalar)
+}
+
+pub(super) fn optional_string_or_integer<'de, D: Deserializer<'de>>(
+    deserializer: D,
+) -> Result<Option<String>, D::Error> {
+    string_or_integer(deserializer).map(Some)
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::{Value, json};
+
+    use crate::config::Config;
+
+    fn health_document(status: Value) -> Vec<u8> {
+        serde_json::to_vec(&json!({
+            "mixed-port": 1080,
+            "proxy-groups": [{
+                "name": "pool", "type": "select", "proxies": ["DIRECT"],
+                "expected-status": status
+            }],
+            "proxy-providers": {"local": {
+                "type": "inline", "payload": [],
+                "health-check": {"expected-status": status}
+            }}
+        }))
+        .unwrap()
+    }
+
+    #[test]
+    fn health_status_accepts_integer_and_string_for_groups_and_providers() {
+        for value in [0, 204, 65535] {
+            let numeric = Config::parse_yaml(&health_document(json!(value))).unwrap();
+            let quoted = Config::parse_yaml(&health_document(json!(value.to_string()))).unwrap();
+            assert_eq!(
+                numeric.proxy_groups[0].health,
+                quoted.proxy_groups[0].health
+            );
+            assert_eq!(
+                numeric.providers.as_ref().unwrap().proxies[0]
+                    .1
+                    .health_check,
+                quoted.providers.as_ref().unwrap().proxies[0].1.health_check
+            );
+            assert_eq!(
+                numeric.proxy_groups[0].health.expected_status,
+                value.to_string()
+            );
+        }
+        let ranged = Config::parse_yaml(&health_document(json!("200-299/304"))).unwrap();
+        assert_eq!(ranged.proxy_groups[0].health.expected_status, "200-299/304");
+    }
+
+    #[test]
+    fn health_status_retains_type_and_status_bounds_in_both_locations() {
+        for value in [
+            json!(null),
+            json!(true),
+            json!(204.0),
+            json!(-1),
+            json!(65536),
+        ] {
+            for provider in [false, true] {
+                let mut document: Value =
+                    serde_json::from_slice(&health_document(json!(204))).unwrap();
+                let field = if provider {
+                    &mut document["proxy-providers"]["local"]["health-check"]["expected-status"]
+                } else {
+                    &mut document["proxy-groups"][0]["expected-status"]
+                };
+                *field = value.clone();
+                assert!(Config::parse_yaml(&serde_json::to_vec(&document).unwrap()).is_err());
+            }
+        }
+    }
+}
diff --git a/src/config/security.rs b/src/config/security.rs
new file mode 100644
index 0000000..b12bec1
--- /dev/null
+++ b/src/config/security.rs
@@ -0,0 +1,127 @@
+//! Shared normalized identities for caller-owned TCP transport legs.
+use super::*;
+
+#[derive(Default)]
+pub(super) struct RawSecurityModes {
+    pub reality: Option<RawRealitySettings>,
+    pub jls: Option<jls::RawJls>,
+    pub shadow_tls: Option<RawShadowTlsMode>,
+}
+
+impl RawSecurityModes {
+    pub(super) fn normalize(
+        self,
+        mut tls: TlsConfig,
+        certificate_options: bool,
+    ) -> Result<SecurityConfig> {
+        tls.tls13_only |= tls.ech.is_some();
+        if tls.tls13_only
+            || self.reality.is_some()
+            || self.jls.is_some()
+            || self.shadow_tls.is_some()
+        {
+            validate_tls13_fingerprint(tls.client_fingerprint)?;
+        }
+        if usize::from(self.reality.is_some())
+            + usize::from(self.jls.is_some())
+            + usize::from(self.shadow_tls.is_some())
+            > 1
+        {
+            return invalid("transport security identities are mutually exclusive");
+        }
+        if (self.reality.is_some() || self.jls.is_some()) && certificate_options {
+            return invalid("certificate options cannot be used with this transport identity");
+        }
+        if (self.reality.is_some() || self.jls.is_some() || self.shadow_tls.is_some())
+            && tls.ech.is_some()
+        {
+            return invalid("ECH requires standard TLS");
+        }
+        if let Some(raw) = self.reality {
+            if !cfg!(feature = "stream-security") {
+                return invalid("REALITY is not compiled in");
+            }
+            let mut config = raw.normalize(tls.server_name)?;
+            config.alpn = tls.alpn;
+            config.client_fingerprint = tls.client_fingerprint;
+            config.validate_fingerprint()?;
+            return Ok(SecurityConfig::Reality(config));
+        }
+        if let Some(raw) = self.jls {
+            if !cfg!(feature = "stream-security") {
+                return invalid("JLS is not compiled in");
+            }
+            tls.tls13_only = true;
+            return Ok(SecurityConfig::Jls(raw.normalize(tls)?));
+        }
+        if let Some(raw) = self.shadow_tls {
+            return raw.normalize(tls).map(SecurityConfig::ShadowTls);
+        }
+        Ok(SecurityConfig::Tls(tls))
+    }
+}
+
+/// Generic ShadowTLS options take the cover name/policy from their TLS node.
+/// SS plugins have their own `host` and policy fields and use a separate decoder.
+#[derive(Default, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct RawShadowTlsMode {
+    #[serde(default)]
+    version: u8,
+    #[serde(default)]
+    password: String,
+}
+
+impl std::fmt::Debug for RawShadowTlsMode {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter
+            .debug_struct("RawShadowTlsMode")
+            .finish_non_exhaustive()
+    }
+}
+
+impl RawShadowTlsMode {
+    pub(super) fn is_empty(&self) -> bool {
+        self.version == 0 && self.password.is_empty()
+    }
+
+    pub(super) fn normalize(self, tls: TlsConfig) -> Result<ShadowTlsConfig> {
+        if self.version != 3 {
+            return invalid("ShadowTLS requires explicit version 3");
+        }
+        let config = ShadowTlsConfig {
+            server_name: tls.server_name,
+            password: self.password,
+            alpn: tls.alpn,
+            required_alpn: tls.required_alpn,
+            certificate: tls.certificate,
+            identity: tls.identity,
+            client_fingerprint: tls.client_fingerprint,
+        };
+        config.validate()?;
+        Ok(config)
+    }
+}
+
+pub(super) fn deserialize_shadow_tls<'de, D>(
+    deserializer: D,
+) -> std::result::Result<Option<RawShadowTlsMode>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    deserialize_present_map(deserializer)
+        .map_err(|_| serde::de::Error::custom("invalid ShadowTLS identity object"))
+}
+
+#[cfg(all(
+    test,
+    feature = "stream-security",
+    feature = "shadow-tls-v3",
+    feature = "outbound-vmess",
+    feature = "outbound-vless",
+    feature = "outbound-trojan",
+    feature = "outbound-anytls",
+    feature = "outbound-shadowsocks"
+))]
+#[path = "security_tests.rs"]
+mod tests;
diff --git a/src/config/security_tests.rs b/src/config/security_tests.rs
new file mode 100644
index 0000000..0203dd9
--- /dev/null
+++ b/src/config/security_tests.rs
@@ -0,0 +1,278 @@
+//! Pure configuration and constructor checks; no sockets or resolver calls.
+use crate::config::{Config, ProxyProtocol, SecurityConfig};
+use serde_json::{Value, json};
+
+fn node(protocol: &str) -> Value {
+    let mut node = json!({"name":"edge", "type":protocol, "server":"cover.invalid", "port":443});
+    match protocol {
+        "vmess" | "vless" => {
+            node["uuid"] = json!("00000000-0000-4000-8000-000000000001");
+            node["tls"] = json!(true);
+        }
+        "trojan" | "anytls" => node["password"] = json!("synthetic-proxy-password"),
+        _ => unreachable!(),
+    }
+    node
+}
+
+fn parse(node: Value) -> crate::Result<Config> {
+    Config::parse_yaml(
+        &serde_json::to_vec(&json!({"proxies":[node], "rules":["MATCH,edge"]})).unwrap(),
+    )
+}
+
+fn security(config: &Config) -> &SecurityConfig {
+    match &config.proxies[0].protocol {
+        ProxyProtocol::Vmess(node) => &node.security,
+        ProxyProtocol::Vless(node) => &node.security,
+        ProxyProtocol::Trojan(node) => &node.security,
+        ProxyProtocol::AnyTls(node) => &node.security,
+        _ => unreachable!(),
+    }
+}
+
+fn shadow() -> Value {
+    json!({"version":3, "password":"synthetic-cover-password"})
+}
+
+fn jls() -> Value {
+    json!({"username":"synthetic-jls-user", "password":"synthetic-jls-password"})
+}
+
+fn reality() -> Value {
+    json!({"public-key":"BwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwc", "short-id":"01ab"})
+}
+
+#[test]
+fn common_identities_construct_for_each_supported_tcp_protocol() {
+    let context = crate::security::SecurityContext::new();
+    for protocol in ["vmess", "vless", "trojan", "anytls"] {
+        for (field, identity) in [("shadow-tls-opts", shadow()), ("jls-opts", jls())] {
+            let mut node = node(protocol);
+            node[field] = identity;
+            let config = parse(node).unwrap();
+            let security = security(&config);
+            assert!(matches!(
+                (field, security),
+                ("shadow-tls-opts", SecurityConfig::ShadowTls(_))
+                    | ("jls-opts", SecurityConfig::Jls(_))
+            ));
+            crate::security::SecurityClient::from_security_with_context(
+                security, &context, 0, 8192,
+            )
+            .unwrap();
+            let debug = format!("{config:?}");
+            for secret in [
+                "synthetic-cover-password",
+                "synthetic-jls-user",
+                "synthetic-jls-password",
+            ] {
+                assert!(!debug.contains(secret));
+            }
+        }
+    }
+}
+
+#[test]
+fn reality_is_consumed_only_by_supported_stream_tls_transports() {
+    for (protocol, networks) in [
+        ("vmess", &["tcp", "http", "h2", "grpc"][..]),
+        ("trojan", &["tcp", "grpc"][..]),
+    ] {
+        for network in networks {
+            let mut node = node(protocol);
+            node["network"] = json!(network);
+            node["client-fingerprint"] = json!("chrome");
+            node["reality-opts"] = reality();
+            let config = parse(node).unwrap();
+            assert!(matches!(security(&config), SecurityConfig::Reality(_)));
+            crate::security::SecurityClient::from_security(security(&config)).unwrap();
+        }
+        let mut websocket = node(protocol);
+        websocket["network"] = json!("ws");
+        websocket["client-fingerprint"] = json!("chrome");
+        websocket["reality-opts"] = reality();
+        assert!(parse(websocket).is_err());
+        let mut unnamed = node(protocol);
+        unnamed["reality-opts"] = reality();
+        assert!(parse(unnamed).is_err());
+    }
+}
+
+#[test]
+fn vless_websocket_and_both_upgrade_modes_do_not_admit_reality() {
+    for options in [
+        json!({}),
+        json!({"v2ray-http-upgrade":true}),
+        json!({"v2ray-http-upgrade":true,"v2ray-http-upgrade-fast-open":true}),
+    ] {
+        let mut input = node("vless");
+        input["network"] = json!("ws");
+        input["ws-opts"] = options;
+        input["client-fingerprint"] = json!("chrome");
+        input["reality-opts"] = reality();
+        assert!(parse(input).is_err());
+    }
+}
+
+#[test]
+fn incompatible_identities_and_unconsumed_fields_fail_before_io() {
+    for protocol in ["vmess", "vless", "trojan", "anytls"] {
+        for value in [
+            json!({}),
+            json!({"version":2,"password":"synthetic-cover-password"}),
+            json!({"version":3,"password":""}),
+            json!({"version":3,"password":"synthetic-cover-password", "host":"unused.invalid"}),
+            Value::Null,
+        ] {
+            let mut input = node(protocol);
+            input["shadow-tls-opts"] = value;
+            let error = parse(input).unwrap_err().to_string();
+            assert!(!error.contains("synthetic-cover-password"));
+        }
+        let mut conflict = node(protocol);
+        conflict["shadow-tls-opts"] = shadow();
+        conflict["jls-opts"] = jls();
+        assert!(parse(conflict).is_err());
+        for identity in ["shadow-tls-opts", "jls-opts"] {
+            let mut ech = node(protocol);
+            ech[identity] = if identity == "jls-opts" {
+                jls()
+            } else {
+                shadow()
+            };
+            ech["ech-opts"] = json!({"enable":true});
+            assert!(parse(ech).is_err());
+        }
+        let mut certificate = node(protocol);
+        certificate["jls-opts"] = jls();
+        certificate["skip-cert-verify"] = json!(false);
+        assert!(parse(certificate).is_err());
+    }
+    for protocol in ["vmess", "vless"] {
+        let mut plain = node(protocol);
+        plain["tls"] = json!(false);
+        plain["shadow-tls-opts"] = shadow();
+        assert!(parse(plain).is_err());
+    }
+    let mut vision = node("vless");
+    vision["flow"] = json!("xtls-rprx-vision");
+    vision["shadow-tls-opts"] = shadow();
+    assert!(parse(vision).is_err());
+}
+
+#[test]
+fn xhttp_cover_identities_inherit_replace_and_clear_per_leg() {
+    let mut input = node("vless");
+    input["network"] = json!("xhttp");
+    input["shadow-tls-opts"] = shadow();
+    input["xhttp-opts"] = json!({"mode":"stream-up", "download-settings":{"server":"download.invalid", "alpn":["http/1.1"]}});
+    let config = parse(input.clone()).unwrap();
+    let ProxyProtocol::Vless(node) = &config.proxies[0].protocol else {
+        panic!()
+    };
+    let SecurityConfig::ShadowTls(main) = &node.security else {
+        panic!()
+    };
+    let SecurityConfig::ShadowTls(download) = &node.download().unwrap().security else {
+        panic!()
+    };
+    assert_eq!(main.server_name, "cover.invalid");
+    assert_eq!(download.server_name, "download.invalid");
+    assert_eq!(main.password, download.password);
+    assert_eq!(main.required_alpn.as_deref(), Some(&b"h2"[..]));
+    assert_eq!(download.required_alpn.as_deref(), Some(&b"http/1.1"[..]));
+
+    input["xhttp-opts"]["download-settings"]["shadow-tls-opts"] =
+        json!({"version":3,"password":"different-cover-password"});
+    let replaced = parse(input.clone()).unwrap();
+    let ProxyProtocol::Vless(node) = &replaced.proxies[0].protocol else {
+        panic!()
+    };
+    let SecurityConfig::ShadowTls(download) = &node.download().unwrap().security else {
+        panic!()
+    };
+    assert_eq!(download.password, "different-cover-password");
+
+    input["xhttp-opts"]["download-settings"]["jls-opts"] = jls();
+    assert!(parse(input.clone()).is_err());
+    input["xhttp-opts"]["download-settings"]["shadow-tls-opts"] = json!({});
+    let switched = parse(input.clone()).unwrap();
+    let ProxyProtocol::Vless(node) = &switched.proxies[0].protocol else {
+        panic!()
+    };
+    assert!(matches!(
+        node.download().unwrap().security,
+        SecurityConfig::Jls(_)
+    ));
+    input["xhttp-opts"]["download-settings"]["jls-opts"] = json!({});
+    let cleared = parse(input.clone()).unwrap();
+    let ProxyProtocol::Vless(node) = &cleared.proxies[0].protocol else {
+        panic!()
+    };
+    assert!(matches!(
+        node.download().unwrap().security,
+        SecurityConfig::Tls(_)
+    ));
+    input["alpn"] = json!(["h3"]);
+    assert!(parse(input).is_err());
+}
+
+#[test]
+fn cover_mtls_files_use_the_existing_generation_identity_budget() {
+    let identity = rcgen::generate_simple_self_signed(vec!["client.invalid".into()]).unwrap();
+    let directory = tempfile::tempdir().unwrap();
+    use base64::Engine as _;
+    let pem = |label: &str, bytes: &[u8]| {
+        format!(
+            "-----BEGIN {label}-----\n{}\n-----END {label}-----\n",
+            base64::engine::general_purpose::STANDARD.encode(bytes)
+        )
+    };
+    std::fs::write(
+        directory.path().join("client.crt"),
+        pem("CERTIFICATE", identity.cert.der()),
+    )
+    .unwrap();
+    std::fs::write(
+        directory.path().join("client.key"),
+        pem("PRIVATE KEY", &identity.signing_key.serialize_der()),
+    )
+    .unwrap();
+    for protocol in ["vmess", "vless", "trojan", "anytls", "ss"] {
+        let mut input = if protocol == "ss" {
+            json!({"name":"edge", "type":"ss", "server":"cover.invalid", "port":443,
+                "cipher":"2022-blake3-aes-128-gcm", "password":"BwcHBwcHBwcHBwcHBwcHBw==",
+                "plugin":"shadow-tls", "plugin-opts":{"version":3,"host":"cover.invalid","password":"synthetic-cover-password"}})
+        } else {
+            let mut input = node(protocol);
+            input["shadow-tls-opts"] = shadow();
+            input
+        };
+        let policy = if protocol == "ss" {
+            &mut input["plugin-opts"]
+        } else {
+            &mut input
+        };
+        policy["certificate"] = json!("client.crt");
+        policy["private-key"] = json!("client.key");
+        let yaml = serde_json::to_vec(&json!({"proxies":[input]})).unwrap();
+        let config = Config::parse_yaml_with_directory(&yaml, Some(directory.path())).unwrap();
+        let cover = match &config.proxies[0].protocol {
+            ProxyProtocol::Shadowsocks(node) => match node.plugin.as_ref().unwrap() {
+                crate::config::ShadowsocksPlugin::ShadowTls(config) => config,
+                _ => panic!("expected ShadowTLS"),
+            },
+            _ => {
+                let SecurityConfig::ShadowTls(cover) = security(&config) else {
+                    panic!()
+                };
+                cover
+            }
+        };
+        assert!(cover.identity.is_some());
+        crate::security::ShadowTlsClient::new(&crate::security::SecurityContext::new(), cover)
+            .unwrap();
+        assert!(!format!("{config:?}").contains("PRIVATE KEY"));
+    }
+}
diff --git a/src/config/shadowsocks.rs b/src/config/shadowsocks.rs
index b2a945a..f4f2f5e 100644
--- a/src/config/shadowsocks.rs
+++ b/src/config/shadowsocks.rs
@@ -13,6 +13,8 @@ pub struct ShadowTlsConfig {
     pub server_name: String,
     pub password: String,
     pub alpn: Vec<Vec<u8>>,
+    pub required_alpn: Option<Vec<u8>>,
+    pub identity: Option<super::TlsIdentityPem>,
     pub certificate: super::TlsCertificatePolicy,
     pub client_fingerprint: Option<super::ClientFingerprint>,
 }
@@ -27,7 +29,20 @@ impl std::fmt::Debug for ShadowTlsConfig {
 }
 
 impl ShadowTlsConfig {
+    pub(super) fn tls_config(&self) -> super::TlsConfig {
+        super::TlsConfig {
+            server_name: self.server_name.clone(),
+            client_fingerprint: self.client_fingerprint,
+            alpn: self.alpn.clone(),
+            required_alpn: self.required_alpn.clone(),
+            tls13_only: true,
+            ech: None,
+            certificate: self.certificate.clone(),
+            identity: self.identity.clone(),
+        }
+    }
     pub(crate) fn validate(&self) -> Result<()> {
+        super::validate_tls13_fingerprint(self.client_fingerprint)?;
         if !cfg!(feature = "shadow-tls-v3") {
             return invalid("ShadowTLS v3 is not compiled in");
         }
@@ -46,6 +61,13 @@ impl ShadowTlsConfig {
         {
             return invalid("invalid ShadowTLS ALPN list");
         }
+        if self
+            .required_alpn
+            .as_ref()
+            .is_some_and(|required| !self.alpn.contains(required))
+        {
+            return invalid("ShadowTLS ALPN does not include the selected transport");
+        }
         Ok(())
     }
 }
@@ -61,6 +83,14 @@ pub(super) struct RawShadowTls {
     #[serde(default)]
     skip_cert_verify: bool,
     #[serde(default, deserialize_with = "super::deserialize_present_option")]
+    certificate: Option<String>,
+    #[serde(
+        rename = "private-key",
+        default,
+        deserialize_with = "super::deserialize_present_option"
+    )]
+    private_key: Option<String>,
+    #[serde(default, deserialize_with = "super::deserialize_present_option")]
     fingerprint: Option<String>,
     #[serde(default, deserialize_with = "super::deserialize_present_option")]
     name_cert_verify: Option<String>,
@@ -72,22 +102,12 @@ impl std::fmt::Debug for RawShadowTls {
     }
 }
 
-pub(super) fn deserialize_plugin<'de, D>(
-    deserializer: D,
-) -> std::result::Result<Option<RawShadowTls>, D::Error>
-where
-    D: serde::Deserializer<'de>,
-{
-    super::deserialize_present_map(deserializer)
-        .map_err(|_| serde::de::Error::custom("invalid ShadowTLS plugin policy"))
-}
-
 pub(super) fn plugin(
     name: Option<String>,
     options: Option<RawShadowTls>,
     fingerprint: Option<String>,
 ) -> Result<Option<ShadowTlsConfig>> {
-    let (name, raw) = match (name, options) {
+    let (name, raw) = match (name.filter(|name| !name.is_empty()), options) {
         (None, None) if fingerprint.is_none() => return Ok(None),
         (Some(name), Some(raw)) => (name, raw),
         _ => return invalid("ShadowTLS plugin and plugin-opts must be provided together"),
@@ -98,6 +118,8 @@ pub(super) fn plugin(
     let config = ShadowTlsConfig {
         server_name: raw.host,
         password: raw.password,
+        identity: super::normalize_client_identity(raw.certificate, raw.private_key)?,
+        required_alpn: None,
         alpn: raw
             .alpn
             .unwrap_or_else(|| vec!["h2".into(), "http/1.1".into()])
@@ -105,13 +127,9 @@ pub(super) fn plugin(
             .map(String::into_bytes)
             .collect(),
         certificate: super::TlsCertificatePolicy {
-            verification_name: raw.name_cert_verify,
+            verification_name: super::normalize_verification_name(raw.name_cert_verify)?,
             skip_cert_verify: raw.skip_cert_verify,
-            fingerprint: raw
-                .fingerprint
-                .as_deref()
-                .map(super::vless::parse_pin)
-                .transpose()
+            fingerprint: super::normalize_certificate_fingerprint(raw.fingerprint.as_deref())
                 .map_err(|_| {
                     crate::VoleError::InvalidConfig("invalid ShadowTLS certificate pin".into())
                 })?,
@@ -157,7 +175,7 @@ pub struct ShadowsocksOutboundConfig {
     pub port: u16,
     pub cipher: ShadowsocksCipher,
     pub password: String,
-    pub shadow_tls: Option<ShadowTlsConfig>,
+    pub plugin: Option<super::ShadowsocksPlugin>,
     pub udp_over_tcp: bool,
 }
 
@@ -173,8 +191,8 @@ impl ShadowsocksOutboundConfig {
     pub(crate) fn validate(&self) -> Result<()> {
         validate_host(&self.address, "Shadowsocks server")?;
         validate_port(self.port, "Shadowsocks")?;
-        if let Some(shadow_tls) = &self.shadow_tls {
-            shadow_tls.validate()?;
+        if let Some(plugin) = &self.plugin {
+            plugin.validate()?;
         }
         if !self.cipher.supports_eih() && self.password.contains(':') {
             return invalid("Shadowsocks identity chains require an AES 2022 cipher");
@@ -215,7 +233,7 @@ pub(super) fn normalize(
         port,
         cipher,
         password,
-        shadow_tls: None,
+        plugin: None,
         udp_over_tcp: false,
     };
     config.validate()?;
diff --git a/src/config/shadowsocks_plugin.rs b/src/config/shadowsocks_plugin.rs
new file mode 100644
index 0000000..9674459
--- /dev/null
+++ b/src/config/shadowsocks_plugin.rs
@@ -0,0 +1,306 @@
+//! One strict transport plugin below the official Shadowsocks 2022 codec.
+use super::*;
+use serde::de::DeserializeOwned;
+use serde_yaml_ng::Value;
+use std::collections::BTreeMap;
+
+#[derive(Clone, PartialEq, Eq)]
+pub enum ShadowsocksPlugin {
+    ShadowTls(ShadowTlsConfig),
+    Jls(JlsConfig),
+    Obfs {
+        tls: bool,
+        host: String,
+    },
+    WebSocket {
+        gost: bool,
+        mux: bool,
+        transport: StreamTransport,
+        tls: Option<TlsConfig>,
+    },
+}
+impl std::fmt::Debug for ShadowsocksPlugin {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(match self {
+            Self::ShadowTls(_) => "ShadowTls",
+            Self::Jls(_) => "Jls",
+            Self::Obfs { .. } => "Obfs",
+            Self::WebSocket { .. } => "WebSocket",
+        })
+    }
+}
+impl ShadowsocksPlugin {
+    pub(crate) fn validate(&self) -> Result<()> {
+        match self {
+            Self::ShadowTls(options) => options.validate(),
+            Self::Jls(options) => options.validate(),
+            Self::Obfs { host, .. } => validate_host(host, "Shadowsocks obfs host"),
+            Self::WebSocket {
+                transport: StreamTransport::WebSocket { .. },
+                ..
+            } => Ok(()),
+            Self::WebSocket { .. } => invalid("invalid Shadowsocks WebSocket transport"),
+        }
+    }
+    pub(crate) fn tls_sessions(&self) -> usize {
+        usize::from(matches!(self, Self::WebSocket { tls: Some(_), .. }))
+    }
+}
+
+pub(super) fn deserialize<'de, D>(deserializer: D) -> std::result::Result<Option<Value>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    deserialize_present_map(deserializer)
+        .map_err(|_| serde::de::Error::custom("invalid Shadowsocks plugin options"))
+}
+fn decode<T: DeserializeOwned>(value: Value) -> Result<T> {
+    serde_yaml_ng::from_value(value)
+        .map_err(|_| VoleError::InvalidConfig("invalid Shadowsocks plugin options".into()))
+}
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct Obfs {
+    mode: String,
+    #[serde(default = "default_host")]
+    host: String,
+}
+fn default_host() -> String {
+    "bing.com".into()
+}
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct Jls {
+    host: String,
+    username: String,
+    password: String,
+    #[serde(default, deserialize_with = "deserialize_present_option")]
+    alpn: Option<Vec<String>>,
+}
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "kebab-case")]
+struct WebSocket {
+    mode: String,
+    #[serde(default = "default_host")]
+    host: String,
+    #[serde(default)]
+    path: String,
+    #[serde(default)]
+    headers: BTreeMap<String, String>,
+    #[serde(default)]
+    tls: bool,
+    #[serde(default = "enabled")]
+    mux: bool,
+    #[serde(default)]
+    v2ray_http_upgrade: bool,
+    #[serde(default)]
+    v2ray_http_upgrade_fast_open: bool,
+    #[serde(default, deserialize_with = "deserialize_present_option")]
+    skip_cert_verify: Option<bool>,
+    #[serde(default, deserialize_with = "deserialize_present_option")]
+    name_cert_verify: Option<String>,
+    #[serde(default, deserialize_with = "deserialize_present_option")]
+    fingerprint: Option<String>,
+    #[serde(default, deserialize_with = "deserialize_present_option")]
+    certificate: Option<String>,
+    #[serde(default, deserialize_with = "deserialize_present_option")]
+    private_key: Option<String>,
+    #[serde(default, deserialize_with = "ech::deserialize")]
+    ech_opts: Option<ech::RawEch>,
+}
+fn enabled() -> bool {
+    true
+}
+
+pub(super) fn normalize(
+    name: Option<String>,
+    options: Option<Value>,
+    fingerprint: Option<String>,
+    port: u16,
+) -> Result<Option<ShadowsocksPlugin>> {
+    let (name, options) = match (name.filter(|name| !name.is_empty()), options) {
+        (None, None) if fingerprint.is_none() => return Ok(None),
+        (Some(name), Some(options)) => (name, options),
+        _ => return invalid("Shadowsocks plugin and options must be provided together"),
+    };
+    if fingerprint.is_some() && !matches!(name.as_str(), "shadow-tls" | "jls") {
+        return invalid("Shadowsocks client-fingerprint requires a consuming identity plugin");
+    }
+    let plugin = match name.as_str() {
+        "shadow-tls" => ShadowsocksPlugin::ShadowTls(
+            shadowsocks::plugin(Some(name), Some(decode(options)?), fingerprint)?.unwrap(),
+        ),
+        "jls" => {
+            if !cfg!(feature = "stream-security") {
+                return invalid("JLS is not compiled in");
+            }
+            let raw: Jls = decode(options)?;
+            validate_host(&raw.host, "JLS host")?;
+            let mut tls = TlsConfig::xhttp(raw.host);
+            tls.required_alpn = None;
+            tls.alpn = normalize_alpn(
+                raw.alpn
+                    .unwrap_or_else(|| vec!["h2".into(), "http/1.1".into()]),
+            )?;
+            tls.tls13_only = true;
+            tls.client_fingerprint = parse_client_fingerprint(fingerprint.as_deref())?;
+            ShadowsocksPlugin::Jls(JlsConfig {
+                tls,
+                username: raw.username,
+                password: raw.password,
+            })
+        }
+        "obfs" => {
+            let raw: Obfs = decode(options)?;
+            if !matches!(raw.mode.as_str(), "http" | "tls") {
+                return invalid("invalid Shadowsocks obfs mode");
+            }
+            ShadowsocksPlugin::Obfs {
+                tls: raw.mode == "tls",
+                host: raw.host,
+            }
+        }
+        "v2ray-plugin" | "gost-plugin" => {
+            let raw: WebSocket = decode(options)?;
+            let gost = name == "gost-plugin";
+            if raw.mode != "websocket"
+                || (gost && (raw.v2ray_http_upgrade || raw.v2ray_http_upgrade_fast_open))
+            {
+                return invalid("invalid Shadowsocks WebSocket plugin mode");
+            }
+            if !raw.tls
+                && (raw.skip_cert_verify.is_some()
+                    || raw.name_cert_verify.is_some()
+                    || raw.fingerprint.is_some()
+                    || raw.certificate.is_some()
+                    || raw.private_key.is_some()
+                    || raw.ech_opts.is_some())
+            {
+                return invalid("Shadowsocks plugin TLS options require tls=true");
+            }
+            validate_host(&raw.host, "Shadowsocks plugin host")?;
+            let (transport, server_name) = vmess::normalize_transport(
+                &raw.host,
+                port,
+                raw.tls,
+                "ws",
+                Some(vmess::RawWs {
+                    path: Some(if raw.path.is_empty() {
+                        "/".into()
+                    } else {
+                        raw.path
+                    }),
+                    headers: raw.headers,
+                    http_upgrade: raw.v2ray_http_upgrade,
+                    fast_open: raw.v2ray_http_upgrade_fast_open,
+                    ..Default::default()
+                }),
+                None,
+                None,
+                None,
+                None,
+            )?;
+            let tls = if raw.tls {
+                let ech = raw
+                    .ech_opts
+                    .map(|raw| raw.normalize(false))
+                    .transpose()?
+                    .flatten();
+                Some(TlsConfig {
+                    server_name,
+                    client_fingerprint: None,
+                    alpn: vec![b"http/1.1".to_vec()],
+                    required_alpn: Some(b"http/1.1".to_vec()),
+                    tls13_only: ech.is_some(),
+                    ech,
+                    certificate: TlsCertificatePolicy {
+                        fingerprint: normalize_certificate_fingerprint(raw.fingerprint.as_deref())?,
+                        skip_cert_verify: raw.skip_cert_verify.unwrap_or(false),
+                        verification_name: normalize_verification_name(raw.name_cert_verify)?,
+                    },
+                    identity: normalize_client_identity(raw.certificate, raw.private_key)?,
+                })
+            } else {
+                None
+            };
+            ShadowsocksPlugin::WebSocket {
+                gost,
+                mux: raw.mux,
+                transport,
+                tls,
+            }
+        }
+        _ => return invalid("unsupported Shadowsocks plugin"),
+    };
+    plugin.validate()?;
+    Ok(Some(plugin))
+}
+fn normalize_alpn(values: Vec<String>) -> Result<Vec<Vec<u8>>> {
+    if values.iter().any(|v| v.is_empty() || v.len() > 255)
+        || values.iter().map(|v| v.len() + 1).sum::<usize>() > 65533
+    {
+        return invalid("invalid Shadowsocks plugin ALPN");
+    }
+    Ok(values.into_iter().map(String::into_bytes).collect())
+}
+
+#[cfg(all(test, feature = "outbound-shadowsocks"))]
+mod tests {
+    use super::*;
+    use base64::Engine;
+    use serde_json::json;
+    fn parse(plugin: &str, options: serde_json::Value) -> Result<Config> {
+        Config::parse_yaml(&serde_json::to_vec(&json!({"proxies":[{"name":"edge","type":"ss","server":"proxy.invalid","port":443,"cipher":"2022-blake3-aes-128-gcm","password":base64::engine::general_purpose::STANDARD.encode([7;16]),"udp":true,"plugin":plugin,"plugin-opts":options}],"rules":["MATCH,edge"]})).unwrap())
+    }
+    #[test]
+    fn strict_plugins_construct_their_actual_transport() {
+        for (plugin, options) in [
+            ("obfs", json!({"mode":"http"})),
+            ("obfs", json!({"mode":"tls","host":"cover.invalid"})),
+            (
+                "v2ray-plugin",
+                json!({"mode":"websocket","mux":true,"tls":true,"host":"cover.invalid","headers":{"Host":"identity.invalid"},"v2ray-http-upgrade":true,"v2ray-http-upgrade-fast-open":true}),
+            ),
+            ("gost-plugin", json!({"mode":"websocket","mux":true})),
+            (
+                "jls",
+                json!({"host":"cover.invalid","username":"synthetic-user","password":"synthetic-password"}),
+            ),
+        ] {
+            let config = parse(plugin, options).unwrap();
+            let ProxyProtocol::Shadowsocks(ss) = &config.proxies[0].protocol else {
+                panic!("expected SS")
+            };
+            assert!(!ss.udp_over_tcp);
+            if let Some(ShadowsocksPlugin::WebSocket { tls: Some(tls), .. }) = &ss.plugin {
+                assert_eq!(tls.server_name, "identity.invalid");
+                assert_eq!(tls.required_alpn.as_deref(), Some(b"http/1.1".as_slice()));
+            }
+            let debug = format!("{config:?}");
+            assert!(!debug.contains("synthetic-user"));
+            assert!(!debug.contains("synthetic-password"));
+        }
+    }
+    #[test]
+    fn unused_security_flags_and_unbounded_options_fail_before_io() {
+        for (plugin, options) in [
+            ("obfs", json!({"mode":"http","tls":true})),
+            (
+                "v2ray-plugin",
+                json!({"mode":"websocket","tls":false,"skip-cert-verify":false}),
+            ),
+            (
+                "gost-plugin",
+                json!({"mode":"websocket","v2ray-http-upgrade":true}),
+            ),
+            (
+                "jls",
+                json!({"host":"cover.invalid","username":"synthetic-user","password":"synthetic-password","certificate":"unused"}),
+            ),
+        ] {
+            let error = parse(plugin, options).unwrap_err().to_string();
+            assert!(!error.contains("synthetic-user"));
+            assert!(!error.contains("synthetic-password"));
+        }
+    }
+}
diff --git a/src/config/sing_mux.rs b/src/config/sing_mux.rs
new file mode 100644
index 0000000..94e37ec
--- /dev/null
+++ b/src/config/sing_mux.rs
@@ -0,0 +1,228 @@
+//! Shared node wrapper options; protocol codecs remain independent.
+use super::invalid;
+use crate::Result;
+use serde::Deserialize;
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum SingMuxProtocol {
+    #[default]
+    #[serde(alias = "")]
+    H2Mux,
+    Smux,
+    Yamux,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct SingMuxConfig {
+    pub enabled: bool,
+    pub protocol: SingMuxProtocol,
+    pub max_connections: usize,
+    pub min_streams: usize,
+    pub max_streams: usize,
+    pub padding: bool,
+    pub only_tcp: bool,
+    pub statistic: bool,
+    pub brutal: Option<SingMuxBrutalConfig>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct SingMuxBrutalConfig {
+    pub up: u64,
+    pub down: u64,
+}
+
+#[derive(Debug, Default, Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "kebab-case")]
+struct RawBrutal {
+    #[serde(default)]
+    enabled: bool,
+    #[serde(default)]
+    up: Bandwidth,
+    #[serde(default)]
+    down: Bandwidth,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(untagged)]
+enum Bandwidth {
+    Number(u64),
+    Text(String),
+}
+impl Default for Bandwidth {
+    fn default() -> Self {
+        Self::Number(0)
+    }
+}
+impl Bandwidth {
+    fn bytes_per_second(self) -> Result<u64> {
+        let text = match self {
+            Self::Number(value) => value.to_string(),
+            Self::Text(value) => value,
+        };
+        let text = text.trim();
+        if text.is_empty() {
+            return Ok(0);
+        }
+        let end = text.bytes().take_while(u8::is_ascii_digit).count();
+        let Ok(value) = text[..end].parse::<u64>() else {
+            return invalid("invalid sing-mux Brutal bandwidth");
+        };
+        let (factor, divisor) = match text[end..].trim() {
+            "" | "Mbps" => (1_000_000_u64, 8),
+            "bps" => (1, 8),
+            "Kbps" => (1_000, 8),
+            "Gbps" => (1_000_000_000, 8),
+            "Tbps" => (1_000_000_000_000, 8),
+            "Bps" => (1, 1),
+            "KBps" => (1_000, 1),
+            "MBps" => (1_000_000, 1),
+            "GBps" => (1_000_000_000, 1),
+            "TBps" => (1_000_000_000_000, 1),
+            _ => return invalid("invalid sing-mux Brutal bandwidth unit"),
+        };
+        value
+            .checked_mul(factor)
+            .map(|rate| rate / divisor)
+            .ok_or_else(|| {
+                crate::VoleError::InvalidConfig("sing-mux Brutal bandwidth overflows".into())
+            })
+    }
+}
+
+#[derive(Debug, Default, Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "kebab-case")]
+pub(super) struct RawSingMux {
+    #[serde(default)]
+    enabled: bool,
+    #[serde(default)]
+    protocol: SingMuxProtocol,
+    #[serde(default)]
+    max_connections: isize,
+    #[serde(default)]
+    min_streams: isize,
+    #[serde(default)]
+    max_streams: isize,
+    #[serde(default)]
+    padding: bool,
+    #[serde(default)]
+    only_tcp: bool,
+    #[serde(default)]
+    statistic: bool,
+    #[serde(default)]
+    brutal_opts: RawBrutal,
+}
+impl RawSingMux {
+    pub(super) fn normalize(self) -> Result<Option<SingMuxConfig>> {
+        if !self.enabled {
+            return Ok(None);
+        }
+        if !cfg!(feature = "sing-mux") {
+            return invalid("sing-mux support is not enabled in this build");
+        }
+        // Apply the reference default to literal input, before collapsing
+        // negative counts into disabled threshold conditions.
+        let min_streams = if self.max_connections == 0 && self.max_streams == 0 {
+            8
+        } else {
+            self.min_streams.max(0) as usize
+        };
+        Ok(Some(SingMuxConfig {
+            enabled: true,
+            protocol: self.protocol,
+            max_connections: self.max_connections.max(0) as usize,
+            min_streams,
+            max_streams: self.max_streams.max(0) as usize,
+            padding: self.padding,
+            only_tcp: self.only_tcp,
+            statistic: self.statistic,
+            brutal: if self.brutal_opts.enabled {
+                Some(SingMuxBrutalConfig {
+                    up: self.brutal_opts.up.bytes_per_second()?,
+                    down: self.brutal_opts.down.bytes_per_second()?,
+                })
+            } else {
+                None
+            },
+        }))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[cfg(feature = "sing-mux")]
+    #[test]
+    fn brutal_bandwidth_is_checked_and_uses_bytes_per_second() {
+        for (up, down, expected) in [
+            ("8", "\"125 KBps\"", (1_000_000, 125_000)),
+            ("\"1Gbps\"", "\"2 MBps\"", (125_000_000, 2_000_000)),
+            ("\"\"", "0", (0, 0)),
+            ("\"18446744073709551615 Bps\"", "0", (u64::MAX, 0)),
+        ] {
+            let raw: RawSingMux = serde_yaml_ng::from_str(&format!(
+                "enabled: true\nbrutal-opts: {{enabled: true, up: {up}, down: {down}}}"
+            ))
+            .unwrap();
+            let brutal = raw.normalize().unwrap().unwrap().brutal.unwrap();
+            assert_eq!((brutal.up, brutal.down), expected);
+        }
+        for bandwidth in [
+            "\"18446744073709551615 Mbps\"",
+            "\"18446744073709551616 Bps\"",
+            "\"-1 Mbps\"",
+            "\"1.5 Mbps\"",
+            "\"1 MiBps\"",
+        ] {
+            let raw: RawSingMux = serde_yaml_ng::from_str(&format!(
+                "enabled: true\nbrutal-opts: {{enabled: true, up: {bandwidth}}}"
+            ))
+            .unwrap();
+            assert!(raw.normalize().is_err());
+        }
+    }
+
+    #[cfg(feature = "sing-mux")]
+    #[test]
+    fn normalizes_literal_defaults_before_signed_thresholds() {
+        for (yaml, expected) in [
+            ("enabled: true\nmin-streams: 42", (0, 8, 0)),
+            (
+                "enabled: true\nmax-connections: -1\nmin-streams: -2",
+                (0, 0, 0),
+            ),
+            (
+                "enabled: true\nmax-connections: 2\nmin-streams: 3\nmax-streams: 4",
+                (2, 3, 4),
+            ),
+        ] {
+            let raw: RawSingMux = serde_yaml_ng::from_str(yaml).unwrap();
+            let options = raw.normalize().unwrap().unwrap();
+            assert_eq!(
+                (
+                    options.max_connections,
+                    options.min_streams,
+                    options.max_streams
+                ),
+                expected
+            );
+        }
+    }
+
+    #[cfg(not(feature = "sing-mux"))]
+    #[test]
+    fn disabled_build_rejects_enabled_wrapper_but_allows_disabled_options() {
+        let enabled: RawSingMux = serde_yaml_ng::from_str("enabled: true").unwrap();
+        assert!(
+            enabled
+                .normalize()
+                .unwrap_err()
+                .to_string()
+                .contains("not enabled")
+        );
+        let disabled: RawSingMux =
+            serde_yaml_ng::from_str("enabled: false\nprotocol: yamux").unwrap();
+        assert!(disabled.normalize().unwrap().is_none());
+    }
+}
diff --git a/src/config/sniffer.rs b/src/config/sniffer.rs
new file mode 100644
index 0000000..ffa1bac
--- /dev/null
+++ b/src/config/sniffer.rs
@@ -0,0 +1,37 @@
+use super::*;
+
+pub(super) fn addresses(values: Vec<String>) -> Result<Vec<RuleSpec>> {
+    let mut rules = Vec::new();
+    for value in values {
+        let lower = value.to_ascii_lowercase();
+        if let Some(codes) = lower.strip_prefix("geoip:") {
+            for code in codes.split(',') {
+                rules.push(parse_rule(
+                    &format!("GEOIP,{code},DIRECT,no-resolve"),
+                    &RouteTargetsByName::new(),
+                )?);
+            }
+        } else if lower.starts_with("rule-set:") {
+            for name in value[9..].split(',') {
+                rules.push(parse_rule(
+                    &format!("RULE-SET,{name},DIRECT,no-resolve"),
+                    &RouteTargetsByName::new(),
+                )?);
+            }
+        } else {
+            let cidr = parse_ip_cidr(&value, value.contains(':'))?;
+            rules.push(RuleSpec {
+                kind: RuleKind::IpCidr(cidr),
+                action: RuleAction::Direct,
+                no_resolve: true,
+            });
+        }
+    }
+    Ok(rules)
+}
+pub(super) fn domains(values: Vec<String>) -> Result<Vec<DnsPolicySelector>> {
+    values
+        .iter()
+        .map(|pattern| normalize_dns_policy_selector(pattern))
+        .collect()
+}
diff --git a/src/config/tls_policy_tests.rs b/src/config/tls_policy_tests.rs
new file mode 100644
index 0000000..ebb103f
--- /dev/null
+++ b/src/config/tls_policy_tests.rs
@@ -0,0 +1,369 @@
+use super::*;
+
+fn pem(label: &str, der: &[u8]) -> String {
+    use base64::{Engine as _, engine::general_purpose::STANDARD};
+    format!(
+        "-----BEGIN {label}-----\n{}\n-----END {label}-----\n",
+        STANDARD.encode(der)
+    )
+}
+
+fn node(protocol: &str) -> serde_json::Value {
+    let mut node = serde_json::json!({
+        "name": "edge", "type": protocol, "server": "cover.invalid", "port": 443,
+        "name-cert-verify": "verified.invalid", "fingerprint": "ab".repeat(32),
+    });
+    match protocol {
+        "anytls" | "trojan" | "hysteria2" | "trusttunnel" => {
+            node["password"] = "synthetic-secret".into()
+        }
+        "vmess" | "vless" => {
+            node["uuid"] = "00000000-0000-4000-8000-000000000001".into();
+            node["tls"] = true.into();
+        }
+        "socks5" | "http" => node["tls"] = true.into(),
+        "tuic" => node["uuid"] = "00000000-0000-4000-8000-000000000001".into(),
+        _ => unreachable!(),
+    }
+    node
+}
+
+fn parse(node: serde_json::Value) -> Result<Config> {
+    Config::parse_yaml(
+        serde_yaml_ng::to_string(&serde_json::json!({"mixed-port": 1080, "proxies": [node]}))
+            .unwrap()
+            .as_bytes(),
+    )
+}
+
+fn policy(config: &Config) -> TlsClientPolicy {
+    let security = match &config.proxies[0].protocol {
+        ProxyProtocol::AnyTls(config) => &config.security,
+        ProxyProtocol::Trojan(config) => &config.security,
+        ProxyProtocol::Vmess(config) => &config.security,
+        ProxyProtocol::Socks5(config) => return config.tls.clone().unwrap(),
+        _ => unreachable!(),
+    };
+    let tls = security.as_tls().unwrap();
+    TlsClientPolicy {
+        ech: tls.ech.clone(),
+        client_fingerprint: tls.client_fingerprint,
+        alpn: tls.alpn.clone(),
+        certificate: tls.certificate.clone(),
+        identity: tls.identity.clone(),
+    }
+}
+
+fn client_identity(config: &Config) -> &TlsIdentityPem {
+    let identity = match &config.proxies[0].protocol {
+        ProxyProtocol::AnyTls(config) => &config.security.as_tls().unwrap().identity,
+        ProxyProtocol::Trojan(config) => &config.security.as_tls().unwrap().identity,
+        ProxyProtocol::Vmess(config) => &config.security.as_tls().unwrap().identity,
+        ProxyProtocol::Socks5(config) => &config.tls.as_ref().unwrap().identity,
+        ProxyProtocol::Http(config) => &config.tls.as_ref().unwrap().identity,
+        ProxyProtocol::Hysteria2(config) => &config.tls.identity,
+        ProxyProtocol::Tuic(config) => &config.tls.identity,
+        ProxyProtocol::TrustTunnel(config) => &config.tls.identity,
+        ProxyProtocol::Vless(config) => match &config.security {
+            SecurityConfig::Tls(tls) => &tls.identity,
+            _ => unreachable!(),
+        },
+        _ => unreachable!(),
+    };
+    identity.as_ref().unwrap()
+}
+
+#[test]
+fn common_tls_identity_files_use_the_configuration_directory_and_inline_validation() {
+    let directory = tempfile::tempdir().unwrap();
+    let identity = rcgen::generate_simple_self_signed(vec!["client.invalid".into()]).unwrap();
+    let certificate = pem("CERTIFICATE", identity.cert.der());
+    let private_key = pem("PRIVATE KEY", &identity.signing_key.serialize_der());
+    std::fs::write(directory.path().join("client.crt"), &certificate).unwrap();
+    std::fs::write(directory.path().join("client.key"), &private_key).unwrap();
+
+    for protocol in [
+        "socks5",
+        "anytls",
+        "trojan",
+        "vmess",
+        #[cfg(feature = "outbound-http")]
+        "http",
+        #[cfg(feature = "outbound-vless")]
+        "vless",
+        #[cfg(feature = "outbound-hysteria2")]
+        "hysteria2",
+        #[cfg(feature = "outbound-tuic")]
+        "tuic",
+        #[cfg(feature = "outbound-trusttunnel")]
+        "trusttunnel",
+    ] {
+        let mut node = node(protocol);
+        node["certificate"] = "./client.crt".into();
+        node["private-key"] = "./client.key".into();
+        let yaml = serde_yaml_ng::to_string(&serde_json::json!({
+            "mixed-port": 1080, "proxies": [node],
+        }))
+        .unwrap();
+        let config =
+            Config::parse_yaml_with_directory(yaml.as_bytes(), Some(directory.path())).unwrap();
+        let loaded = client_identity(&config);
+        assert_eq!(loaded.certificate, certificate);
+        assert_eq!(loaded.private_key, private_key);
+        assert!(!format!("{config:?}").contains("PRIVATE KEY"));
+        crate::security::TlsClientIdentity::from_pem(&loaded.certificate, &loaded.private_key)
+            .unwrap();
+    }
+
+    let mut absolute = node("anytls");
+    absolute["certificate"] = directory.path().join("client.crt").to_str().unwrap().into();
+    absolute["private-key"] = directory.path().join("client.key").to_str().unwrap().into();
+    assert_eq!(
+        client_identity(&parse(absolute).unwrap()).certificate,
+        certificate
+    );
+
+    let mut missing = node("anytls");
+    missing["certificate"] = directory
+        .path()
+        .join("missing.crt")
+        .to_str()
+        .unwrap()
+        .into();
+    missing["private-key"] = directory.path().join("client.key").to_str().unwrap().into();
+    let error = parse(missing).unwrap_err().to_string();
+    assert!(!error.contains("missing.crt") && !error.contains("PRIVATE KEY"));
+
+    std::fs::write(directory.path().join("client.crt"), "").unwrap();
+    std::fs::write(directory.path().join("client.key"), "").unwrap();
+    let mut empty_files = node("anytls");
+    empty_files["certificate"] = "client.crt".into();
+    empty_files["private-key"] = "client.key".into();
+    let yaml = serde_json::to_vec(&serde_json::json!({"proxies": [empty_files]})).unwrap();
+    let error = Config::parse_yaml_with_directory(&yaml, Some(directory.path()))
+        .unwrap_err()
+        .to_string();
+    assert!(!error.contains("client.crt") && !error.contains("client.key"));
+}
+
+#[test]
+#[cfg(all(feature = "outbound-http", feature = "outbound-vless"))]
+fn provider_and_xhttp_download_identity_files_share_the_data_directory() {
+    let directory = tempfile::tempdir().unwrap();
+    let identity = rcgen::generate_simple_self_signed(vec!["client.invalid".into()]).unwrap();
+    let certificate = pem("CERTIFICATE", identity.cert.der());
+    std::fs::write(directory.path().join("client.crt"), &certificate).unwrap();
+    std::fs::write(
+        directory.path().join("client.key"),
+        pem("PRIVATE KEY", &identity.signing_key.serialize_der()),
+    )
+    .unwrap();
+    let mut proxy = node("http");
+    proxy["certificate"] = "client.crt".into();
+    proxy["private-key"] = "client.key".into();
+    let yaml = serde_yaml_ng::to_string(&serde_json::json!({
+        "mixed-port": 1080,
+        "proxy-providers": {"local": {"type": "inline", "payload": [proxy]}},
+        "proxy-groups": [{"name": "selected", "type": "select", "use": ["local"]}],
+    }))
+    .unwrap();
+    let config =
+        Config::parse_yaml_with_directory(yaml.as_bytes(), Some(directory.path())).unwrap();
+    assert_eq!(client_identity(&config).certificate, certificate);
+
+    let other = rcgen::generate_simple_self_signed(vec!["download.invalid".into()]).unwrap();
+    let other_certificate = pem("CERTIFICATE", other.cert.der());
+    let other_key = pem("PRIVATE KEY", &other.signing_key.serialize_der());
+    std::fs::write(
+        directory.path().join("download-----BEGIN.crt"),
+        &other_certificate,
+    )
+    .unwrap();
+    std::fs::write(directory.path().join("download.key"), &other_key).unwrap();
+    let mut proxy = node("vless");
+    proxy["network"] = "xhttp".into();
+    proxy["certificate"] = "client.crt".into();
+    proxy["private-key"] = "client.key".into();
+    proxy["xhttp-opts"] = serde_json::json!({"download-settings": {
+        "certificate": "download-----BEGIN.crt", "private-key": "download.key",
+    }});
+    let yaml = serde_json::to_vec(&serde_json::json!({"proxies": [proxy]})).unwrap();
+    let xhttp = Config::parse_yaml_with_directory(&yaml, Some(directory.path())).unwrap();
+    assert_eq!(client_identity(&xhttp).certificate, certificate);
+    let ProxyProtocol::Vless(proxy) = &xhttp.proxies[0].protocol else {
+        unreachable!()
+    };
+    let SecurityConfig::Tls(download) = &proxy.download().unwrap().security else {
+        unreachable!()
+    };
+    assert_eq!(
+        download.identity.as_ref().unwrap().certificate,
+        other_certificate
+    );
+
+    std::fs::write(directory.path().join("client.crt"), &other_certificate).unwrap();
+    std::fs::write(directory.path().join("client.key"), &other_key).unwrap();
+    let next = config
+        .providers
+        .as_ref()
+        .unwrap()
+        .materialize(&providers::ProviderContents::new())
+        .unwrap();
+    assert_eq!(client_identity(&next).certificate, other_certificate);
+    assert_eq!(client_identity(&config).certificate, certificate);
+}
+
+#[test]
+fn common_tls_policy_keeps_verified_identity_separate_from_server_name() {
+    let identity = rcgen::generate_simple_self_signed(vec!["client.invalid".into()]).unwrap();
+    for protocol in ["anytls", "trojan", "vmess", "socks5"] {
+        let mut node = node(protocol);
+        node["certificate"] = pem("CERTIFICATE", identity.cert.der()).into();
+        node["private-key"] = pem("PRIVATE KEY", &identity.signing_key.serialize_der()).into();
+        let config = parse(node).unwrap();
+        let policy = policy(&config);
+        assert_eq!(
+            policy.certificate.verification_name.as_deref(),
+            Some("verified.invalid")
+        );
+        assert_eq!(policy.certificate.fingerprint, Some([0xab; 32]));
+        assert!(
+            crate::security::TlsClientOptions::from_policy(
+                &policy,
+                None,
+                &crate::security::SecurityContext::new()
+            )
+            .unwrap()
+            .identity
+            .is_some()
+        );
+        let debug = format!("{policy:?}");
+        assert!(!debug.contains("PRIVATE KEY") && !debug.contains("verified.invalid"));
+        assert_eq!(
+            config.proxies[0].server_endpoint(),
+            Some(("cover.invalid", 443))
+        );
+    }
+}
+
+#[test]
+fn common_tls_identity_rejects_unpaired_or_mismatched_keys() {
+    let identity = rcgen::generate_simple_self_signed(vec!["client.invalid".into()]).unwrap();
+    let other = rcgen::generate_simple_self_signed(vec!["other.invalid".into()]).unwrap();
+    for protocol in ["anytls", "trojan", "vmess", "socks5"] {
+        let mut node = node(protocol);
+        node["certificate"] = pem("CERTIFICATE", identity.cert.der()).into();
+        assert!(parse(node.clone()).is_err());
+        node["private-key"] = "".into();
+        assert!(parse(node.clone()).is_err());
+        node["private-key"] = pem("PRIVATE KEY", &other.signing_key.serialize_der()).into();
+        let error = parse(node).unwrap_err().to_string();
+        assert!(error.contains("invalid TLS client identity"));
+        assert!(!error.contains("PRIVATE KEY"));
+    }
+}
+
+#[test]
+fn common_tls_empty_overrides_use_defaults_without_a_client_identity() {
+    for protocol in [
+        "anytls",
+        "trojan",
+        "vmess",
+        "socks5",
+        #[cfg(feature = "outbound-http")]
+        "http",
+        #[cfg(feature = "outbound-vless")]
+        "vless",
+        #[cfg(feature = "outbound-hysteria2")]
+        "hysteria2",
+    ] {
+        for identity_fields in [
+            serde_json::json!({"certificate": ""}),
+            serde_json::json!({"private-key": ""}),
+            serde_json::json!({"certificate": "", "private-key": ""}),
+        ] {
+            let mut node = node(protocol);
+            node["fingerprint"] = "".into();
+            node["name-cert-verify"] = "".into();
+            node.as_object_mut()
+                .unwrap()
+                .extend(identity_fields.as_object().unwrap().clone());
+            if matches!(protocol, "vmess" | "vless") {
+                node["servername"] = "".into();
+            } else if protocol != "socks5" {
+                node["sni"] = "".into();
+            }
+            if matches!(protocol, "anytls" | "trojan" | "vmess" | "vless") {
+                node["client-fingerprint"] = "".into();
+            }
+            let config = parse(node).unwrap();
+            let (name, certificate, has_identity, has_profile) = match &config.proxies[0].protocol {
+                ProxyProtocol::AnyTls(node) => (
+                    node.server_name.as_str(),
+                    &node.security.as_tls().unwrap().certificate,
+                    node.security.as_tls().unwrap().identity.is_some(),
+                    node.security.as_tls().unwrap().client_fingerprint.is_some(),
+                ),
+                ProxyProtocol::Trojan(node) => (
+                    node.server_name.as_str(),
+                    &node.security.as_tls().unwrap().certificate,
+                    node.security.as_tls().unwrap().identity.is_some(),
+                    node.security.as_tls().unwrap().client_fingerprint.is_some(),
+                ),
+                ProxyProtocol::Vmess(node) => {
+                    let tls = node.security.as_tls().unwrap();
+                    (
+                        node.server_name.as_str(),
+                        &tls.certificate,
+                        tls.identity.is_some(),
+                        tls.client_fingerprint.is_some(),
+                    )
+                }
+                ProxyProtocol::Socks5(node) => {
+                    let tls = node.tls.as_ref().unwrap();
+                    (
+                        node.address.as_str(),
+                        &tls.certificate,
+                        tls.identity.is_some(),
+                        tls.client_fingerprint.is_some(),
+                    )
+                }
+                ProxyProtocol::Http(node) => {
+                    let tls = node.tls.as_ref().unwrap();
+                    (
+                        tls.server_name.as_str(),
+                        &tls.certificate,
+                        tls.identity.is_some(),
+                        tls.client_fingerprint.is_some(),
+                    )
+                }
+                ProxyProtocol::Vless(node) => {
+                    let SecurityConfig::Tls(tls) = &node.security else {
+                        unreachable!()
+                    };
+                    (
+                        tls.server_name.as_str(),
+                        &tls.certificate,
+                        tls.identity.is_some(),
+                        tls.client_fingerprint.is_some(),
+                    )
+                }
+                ProxyProtocol::Hysteria2(node) => (
+                    node.tls.server_name.as_str(),
+                    &node.tls.certificate,
+                    node.tls.identity.is_some(),
+                    node.tls.client_fingerprint.is_some(),
+                ),
+                _ => unreachable!(),
+            };
+            assert_eq!(name, "cover.invalid", "{protocol}");
+            assert_eq!(certificate.verification_name, None, "{protocol}");
+            assert_eq!(certificate.fingerprint, None, "{protocol}");
+            assert!(!has_identity && !has_profile, "{protocol}");
+            assert_eq!(
+                config.proxies[0].server_endpoint(),
+                Some(("cover.invalid", 443))
+            );
+        }
+    }
+}
diff --git a/src/config/tls_trust.rs b/src/config/tls_trust.rs
new file mode 100644
index 0000000..10b3a7a
--- /dev/null
+++ b/src/config/tls_trust.rs
@@ -0,0 +1,140 @@
+use std::sync::Arc;
+
+use rustls::{
+    RootCertStore,
+    pki_types::{CertificateDer, pem::PemObject},
+};
+use serde::Deserialize;
+
+use crate::{Result, VoleError};
+
+/// Top-level TLS options. Decoded client roots and controller identity remain separate.
+#[derive(Clone, Default, PartialEq, Eq)]
+pub struct TlsTrustConfig {
+    pub(crate) certificates: Arc<[CertificateDer<'static>]>,
+    pub(crate) server: super::ControllerTls,
+}
+
+impl std::fmt::Debug for TlsTrustConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("TlsTrustConfig")
+            .field("certificate_count", &self.certificates.len())
+            .finish()
+    }
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct RawTrust {
+    #[serde(rename = "custom-certifactes", default)]
+    certificates: Vec<String>,
+    #[serde(default)]
+    certificate: Arc<str>,
+    #[serde(rename = "private-key", default)]
+    private_key: Arc<str>,
+    #[serde(rename = "client-auth-type", default)]
+    client_auth_type: Arc<str>,
+    #[serde(rename = "client-auth-cert", default)]
+    client_auth_cert: Arc<str>,
+}
+
+#[cfg(feature = "invoke")]
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct ClientTrust {
+    #[serde(rename = "custom-certifactes", default)]
+    certificates: Vec<String>,
+}
+
+#[cfg(feature = "invoke")]
+pub(super) fn deserialize_client_only<'de, D: serde::Deserializer<'de>>(
+    deserializer: D,
+) -> std::result::Result<TlsTrustConfig, D::Error> {
+    let raw = ClientTrust::deserialize(deserializer)
+        .map_err(|_| serde::de::Error::custom("invalid TLS client trust fields"))?;
+    TlsTrustConfig::parse(raw.certificates)
+        .map_err(|_| serde::de::Error::custom("invalid TLS trust certificate"))
+}
+
+impl<'de> Deserialize<'de> for TlsTrustConfig {
+    fn deserialize<D: serde::Deserializer<'de>>(
+        deserializer: D,
+    ) -> std::result::Result<Self, D::Error> {
+        let raw = RawTrust::deserialize(deserializer)
+            .map_err(|_| serde::de::Error::custom("invalid TLS trust fields"))?;
+        let mut trust = Self::parse(raw.certificates)
+            .map_err(|_| serde::de::Error::custom("invalid TLS trust certificate"))?;
+        trust.server = super::ControllerTls {
+            certificate: raw.certificate,
+            private_key: raw.private_key,
+            client_auth_type: raw.client_auth_type,
+            client_auth_cert: raw.client_auth_cert,
+        };
+        Ok(trust)
+    }
+}
+
+impl TlsTrustConfig {
+    fn parse(values: Vec<String>) -> Result<Self> {
+        let invalid = || VoleError::InvalidConfig("invalid TLS trust certificate".into());
+        let mut certificates = Vec::new();
+        for value in values {
+            if value.is_empty() {
+                return Err(invalid());
+            }
+            let mut parsed = CertificateDer::pem_slice_iter(value.as_bytes())
+                .collect::<std::result::Result<Vec<_>, _>>()
+                .map_err(|_| invalid())?;
+            if parsed.is_empty() {
+                parsed.push(CertificateDer::from(value.into_bytes()));
+            }
+            let mut validator = RootCertStore::empty();
+            for certificate in &parsed {
+                validator.add(certificate.clone()).map_err(|_| invalid())?;
+            }
+            certificates.extend(parsed);
+        }
+        certificates.sort_unstable_by(|a, b| a.as_ref().cmp(b.as_ref()));
+        certificates.dedup_by(|a, b| a.as_ref() == b.as_ref());
+        Ok(Self {
+            certificates: certificates.into(),
+            server: super::ControllerTls::default(),
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn custom_roots_decode_once_and_remain_redacted() {
+        let certificate = rcgen::generate_simple_self_signed(vec!["trust.example".into()])
+            .unwrap()
+            .cert;
+        use base64::{Engine as _, engine::general_purpose::STANDARD};
+        let pem = format!(
+            "-----BEGIN CERTIFICATE-----\n{}\n-----END CERTIFICATE-----\n",
+            STANDARD.encode(certificate.der())
+        );
+        let config = TlsTrustConfig::parse(vec![pem.clone(), pem]).unwrap();
+        assert_eq!(config.certificates.len(), 1);
+        assert!(Arc::ptr_eq(
+            &config.certificates,
+            &config.clone().certificates
+        ));
+        assert!(!format!("{config:?}").contains("CERTIFICATE"));
+    }
+
+    #[test]
+    fn trust_is_strict_certificate_content_not_a_path_or_alias() {
+        for value in [
+            "custom-certificates: []",
+            "custom-certifactes: [./ca.pem]",
+            "custom-certifactes: [null]",
+        ] {
+            assert!(serde_yaml_ng::from_str::<TlsTrustConfig>(value).is_err());
+        }
+        assert!(serde_yaml_ng::from_str::<TlsTrustConfig>("custom-certifactes: []").is_ok());
+    }
+}
diff --git a/src/config/trojan.rs b/src/config/trojan.rs
index bcabaf7..ad5e7d4 100644
--- a/src/config/trojan.rs
+++ b/src/config/trojan.rs
@@ -1,9 +1,9 @@
+use super::grpc::RawGrpc;
 use serde::Deserialize;
 use std::collections::BTreeMap;
 
 use super::{
-    AnyTlsCertificatePolicy, ProxyProtocol, deserialize_present_option, invalid, validate_host,
-    validate_port,
+    GrpcOptions, ProxyProtocol, deserialize_present_option, invalid, validate_host, validate_port,
 };
 use crate::Result;
 
@@ -13,7 +13,7 @@ pub struct TrojanOutboundConfig {
     pub port: u16,
     pub password: String,
     pub server_name: String,
-    pub tls: AnyTlsCertificatePolicy,
+    pub security: super::SecurityConfig,
     pub transport: TrojanTransport,
 }
 
@@ -29,6 +29,7 @@ pub enum TrojanTransport {
     },
     Grpc {
         uri: String,
+        options: GrpcOptions,
     },
 }
 
@@ -166,21 +167,14 @@ struct RawWebSocket {
     early_data_header_name: Option<String>,
 }
 
-#[derive(Deserialize)]
-#[serde(deny_unknown_fields)]
-struct RawGrpc {
-    #[serde(rename = "grpc-service-name")]
-    service: String,
-}
-
-fn uri(scheme: &str, server: &str, port: u16, path: &str) -> Result<String> {
+fn uri(scheme: &str, server: &str, path: &str) -> Result<String> {
     if !path.starts_with('/') || path.contains(['\r', '\n', '#']) {
         return invalid("invalid Trojan transport path");
     }
     let authority = if server.parse::<std::net::Ipv6Addr>().is_ok() {
-        format!("[{server}]:{port}")
+        format!("[{server}]")
     } else {
-        format!("{server}:{port}")
+        server.to_owned()
     };
     let uri = http::Uri::builder()
         .scheme(scheme)
@@ -229,16 +223,58 @@ pub(super) struct RawTrojan {
     sni: Option<String>,
     #[serde(default, deserialize_with = "deserialize_present_option")]
     alpn: Option<Vec<String>>,
-    #[serde(rename = "skip-cert-verify", default)]
-    skip_cert_verify: bool,
+    #[serde(
+        rename = "skip-cert-verify",
+        default,
+        deserialize_with = "deserialize_present_option"
+    )]
+    skip_cert_verify: Option<bool>,
     #[serde(default, deserialize_with = "deserialize_present_option")]
     fingerprint: Option<String>,
+    #[serde(
+        rename = "name-cert-verify",
+        default,
+        deserialize_with = "deserialize_present_option"
+    )]
+    name_cert_verify: Option<String>,
+    #[serde(default, deserialize_with = "deserialize_present_option")]
+    certificate: Option<String>,
+    #[serde(
+        rename = "private-key",
+        default,
+        deserialize_with = "deserialize_present_option"
+    )]
+    private_key: Option<String>,
     #[serde(
         rename = "client-fingerprint",
         default,
         deserialize_with = "deserialize_present_option"
     )]
     client_fingerprint: Option<String>,
+    #[serde(
+        rename = "ech-opts",
+        default,
+        deserialize_with = "super::ech::deserialize"
+    )]
+    ech_opts: Option<super::ech::RawEch>,
+    #[serde(
+        rename = "shadow-tls-opts",
+        default,
+        deserialize_with = "super::security::deserialize_shadow_tls"
+    )]
+    shadow_tls_opts: Option<super::security::RawShadowTlsMode>,
+    #[serde(
+        rename = "jls-opts",
+        default,
+        deserialize_with = "super::jls::deserialize"
+    )]
+    jls_opts: Option<super::jls::RawJls>,
+    #[serde(
+        rename = "reality-opts",
+        default,
+        deserialize_with = "super::deserialize_present_map"
+    )]
+    reality_opts: Option<super::RawRealitySettings>,
     #[serde(
         rename = "dialer-proxy",
         default,
@@ -263,13 +299,28 @@ impl RawTrojan {
         if self.password.is_empty() {
             return invalid("Trojan password must not be empty");
         }
-        let transport = match (self.network.as_deref().unwrap_or("tcp"), self.ws, self.grpc) {
+        let server_name = self
+            .sni
+            .filter(|name| !name.is_empty())
+            .unwrap_or_else(|| self.server.clone());
+        validate_host(&server_name, "Trojan sni")?;
+        let transport = match (
+            self.network
+                .as_deref()
+                .filter(|network| !network.is_empty())
+                .unwrap_or("tcp"),
+            self.ws,
+            self.grpc,
+        ) {
             ("tcp", None, None) => TrojanTransport::Tcp,
             ("ws", ws, None) => {
-                let ws = ws.unwrap_or_default();
-                if ws.max_early_data > 2048
-                    || (ws.max_early_data == 0 && ws.early_data_header_name.is_some())
-                {
+                let mut ws = ws.unwrap_or_default();
+                super::vmess::normalize_ws_early_data(
+                    &mut ws.path,
+                    &mut ws.max_early_data,
+                    &mut ws.early_data_header_name,
+                )?;
+                if ws.max_early_data == 0 && ws.early_data_header_name.is_some() {
                     return invalid("invalid Trojan WebSocket early-data options");
                 }
                 let transport = TrojanTransport::WebSocket {
@@ -280,9 +331,11 @@ impl RawTrojan {
                     )?,
                     uri: uri(
                         "wss",
-                        &self.server,
-                        self.port,
-                        ws.path.as_deref().unwrap_or("/"),
+                        &server_name,
+                        ws.path
+                            .as_deref()
+                            .filter(|path| !path.is_empty())
+                            .unwrap_or("/"),
                     )?,
                     headers: ws.headers,
                     max_early_data: ws.max_early_data,
@@ -296,23 +349,15 @@ impl RawTrojan {
                 }
                 transport
             }
-            ("grpc", None, Some(grpc)) if !grpc.service.is_empty() => {
-                let path = if grpc.service.starts_with('/') {
-                    grpc.service
-                } else {
-                    format!("/{}/Tun", grpc.service)
-                };
-                if path.contains('?') {
-                    return invalid("invalid Trojan gRPC service path");
-                }
+            ("grpc", None, grpc) => {
+                let (path, options) = grpc.unwrap_or_default().normalize()?;
                 TrojanTransport::Grpc {
-                    uri: uri("https", &self.server, self.port, &path)?,
+                    uri: uri("https", &server_name, &path)?,
+                    options,
                 }
             }
             _ => return invalid("Trojan requires tcp, ws with ws-opts, or grpc with grpc-opts"),
         };
-        let server_name = self.sni.unwrap_or_else(|| self.server.clone());
-        validate_host(&server_name, "Trojan sni")?;
         let alpn: Vec<Vec<u8>> = self
             .alpn
             .unwrap_or_else(|| {
@@ -337,22 +382,50 @@ impl RawTrojan {
         {
             return invalid("Trojan ALPN does not include the selected transport");
         }
-        let fingerprint = self
-            .fingerprint
-            .map(|value| {
-                let hex: Vec<u8> = value.trim().bytes().filter(|byte| *byte != b':').collect();
-                if hex.len() != 64 || !hex.iter().all(u8::is_ascii_hexdigit) {
-                    return invalid("Trojan fingerprint must be a SHA-256 certificate digest");
-                }
-                let mut pin = [0; 32];
-                for (byte, pair) in pin.iter_mut().zip(hex.as_chunks::<2>().0) {
-                    *byte = ((pair[0] as char).to_digit(16).unwrap() * 16
-                        + (pair[1] as char).to_digit(16).unwrap())
-                        as u8;
-                }
-                Ok(pin)
-            })
-            .transpose()?;
+        let certificate_options = self.skip_cert_verify.is_some()
+            || self.fingerprint.is_some()
+            || self.name_cert_verify.is_some()
+            || self.certificate.is_some()
+            || self.private_key.is_some();
+        let fingerprint = super::normalize_certificate_fingerprint(self.fingerprint.as_deref())?;
+        let client_fingerprint =
+            super::parse_client_fingerprint(self.client_fingerprint.as_deref())?;
+        let ech = self
+            .ech_opts
+            .map(|raw| raw.normalize(client_fingerprint.is_some()))
+            .transpose()?
+            .flatten();
+        if ech.is_some() && server_name.parse::<std::net::IpAddr>().is_ok() {
+            return invalid("Trojan ECH requires DNS sni");
+        }
+        if self.reality_opts.is_some() && matches!(transport, TrojanTransport::WebSocket { .. }) {
+            return invalid("Trojan REALITY requires a stream TLS transport");
+        }
+        if self.reality_opts.is_some() && client_fingerprint.is_none() {
+            return invalid("Trojan REALITY requires a named client-fingerprint");
+        }
+        let security = super::security::RawSecurityModes {
+            reality: self.reality_opts,
+            jls: self.jls_opts,
+            shadow_tls: self.shadow_tls_opts,
+        }
+        .normalize(
+            super::TlsConfig {
+                server_name: server_name.clone(),
+                required_alpn: transport.required_alpn().map(<[u8]>::to_vec),
+                tls13_only: ech.is_some(),
+                ech,
+                client_fingerprint,
+                alpn,
+                certificate: super::TlsCertificatePolicy {
+                    skip_cert_verify: self.skip_cert_verify.unwrap_or(false),
+                    fingerprint,
+                    verification_name: super::normalize_verification_name(self.name_cert_verify)?,
+                },
+                identity: super::normalize_client_identity(self.certificate, self.private_key)?,
+            },
+            certificate_options,
+        )?;
         Ok((
             self.name,
             self.dialer_proxy,
@@ -363,14 +436,7 @@ impl RawTrojan {
                 password: self.password,
                 server_name,
                 transport,
-                tls: AnyTlsCertificatePolicy {
-                    client_fingerprint: super::parse_client_fingerprint(
-                        self.client_fingerprint.as_deref(),
-                    )?,
-                    alpn,
-                    skip_cert_verify: self.skip_cert_verify,
-                    fingerprint,
-                },
+                security,
             }),
         ))
     }
diff --git a/src/config/trusttunnel.rs b/src/config/trusttunnel.rs
new file mode 100644
index 0000000..88ad83f
--- /dev/null
+++ b/src/config/trusttunnel.rs
@@ -0,0 +1,358 @@
+//! Mihomo TrustTunnel node settings, separate from the shared TLS policy.
+use super::{
+    ProxyProtocol, TlsCertificatePolicy, TlsConfig, deserialize_present_option, invalid,
+    validate_host, validate_port,
+};
+use crate::Result;
+use serde::Deserialize;
+
+#[derive(Clone, PartialEq, Eq)]
+pub struct TrustTunnelOutboundConfig {
+    pub address: String,
+    pub port: u16,
+    pub username: String,
+    pub password: String,
+    pub tls: TlsConfig,
+    pub udp: bool,
+    pub quic: bool,
+    pub health_check: bool,
+    pub pool: TrustTunnelPoolOptions,
+    pub congestion_controller: String,
+}
+
+impl std::fmt::Debug for TrustTunnelOutboundConfig {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter
+            .debug_struct("TrustTunnelOutboundConfig")
+            .field("udp", &self.udp)
+            .field("quic", &self.quic)
+            .field("health_check", &self.health_check)
+            .field("pool", &self.pool)
+            .finish_non_exhaustive()
+    }
+}
+
+/// Pool thresholds retain their signs: negative values disable the matching
+/// positive threshold without opting into the literal all-zero defaults.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct TrustTunnelPoolOptions {
+    pub max_connections: i64,
+    pub min_streams: i64,
+    pub max_streams: i64,
+}
+
+impl Default for TrustTunnelPoolOptions {
+    fn default() -> Self {
+        Self {
+            max_connections: 8,
+            min_streams: 5,
+            max_streams: 0,
+        }
+    }
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "kebab-case")]
+pub(super) struct RawTrustTunnel {
+    name: String,
+    server: String,
+    port: u16,
+    #[serde(default)]
+    username: String,
+    #[serde(default)]
+    password: String,
+    #[serde(default)]
+    udp: bool,
+    #[serde(default)]
+    quic: bool,
+    #[serde(default)]
+    health_check: bool,
+    #[serde(default)]
+    max_connections: i64,
+    #[serde(default)]
+    min_streams: i64,
+    #[serde(default)]
+    max_streams: i64,
+    #[serde(default)]
+    congestion_controller: String,
+    #[serde(default, deserialize_with = "deserialize_present_option")]
+    sni: Option<String>,
+    #[serde(default, deserialize_with = "deserialize_present_option")]
+    alpn: Option<Vec<String>>,
+    #[serde(default, deserialize_with = "super::ech::deserialize")]
+    ech_opts: Option<super::ech::RawEch>,
+    #[serde(default, deserialize_with = "deserialize_present_option")]
+    client_fingerprint: Option<String>,
+    #[serde(default)]
+    skip_cert_verify: bool,
+    #[serde(default, deserialize_with = "deserialize_present_option")]
+    name_cert_verify: Option<String>,
+    #[serde(default, deserialize_with = "deserialize_present_option")]
+    fingerprint: Option<String>,
+    #[serde(default, deserialize_with = "deserialize_present_option")]
+    certificate: Option<String>,
+    #[serde(default, deserialize_with = "deserialize_present_option")]
+    private_key: Option<String>,
+    #[serde(default, deserialize_with = "deserialize_present_option")]
+    dialer_proxy: Option<String>,
+}
+
+impl std::fmt::Debug for RawTrustTunnel {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter
+            .debug_struct("RawTrustTunnel")
+            .finish_non_exhaustive()
+    }
+}
+
+pub(super) fn deserialize<'de, D: serde::Deserializer<'de>>(
+    deserializer: D,
+) -> std::result::Result<RawTrustTunnel, D::Error> {
+    RawTrustTunnel::deserialize(deserializer)
+        .map_err(|_| serde::de::Error::custom("invalid TrustTunnel configuration fields"))
+}
+
+impl RawTrustTunnel {
+    pub(super) fn normalize(self) -> Result<(String, Option<String>, bool, ProxyProtocol)> {
+        if !cfg!(feature = "outbound-trusttunnel") {
+            return invalid("TrustTunnel outbound support is disabled at build time");
+        }
+        validate_host(&self.server, "TrustTunnel server")?;
+        validate_port(self.port, "TrustTunnel")?;
+        let server_name = self
+            .sni
+            .filter(|value| !value.is_empty())
+            .unwrap_or_else(|| self.server.clone());
+        validate_host(&server_name, "TrustTunnel sni")?;
+        let required_alpn = if self.quic { b"h3" } else { b"h2" };
+        let mut alpn: Vec<Vec<u8>> = self
+            .alpn
+            .unwrap_or_default()
+            .into_iter()
+            .map(String::into_bytes)
+            .collect();
+        if alpn.is_empty() {
+            alpn.push(required_alpn.to_vec());
+        }
+        if alpn
+            .iter()
+            .any(|value| value.is_empty() || value.len() > 255)
+            || alpn.iter().map(|value| value.len() + 1).sum::<usize>() > 65_533
+            || !alpn.iter().any(|value| value == required_alpn)
+        {
+            return invalid("TrustTunnel ALPN must include its selected HTTP version");
+        }
+        // Mihomo's QUIC path converts the policy to standard TLS without
+        // applying the TCP ClientHello template or validating its name.
+        let client_fingerprint = if self.quic {
+            None
+        } else {
+            super::parse_client_fingerprint(self.client_fingerprint.as_deref())?
+        };
+        let ech = self
+            .ech_opts
+            .map(|raw| raw.normalize(client_fingerprint.is_some()))
+            .transpose()?
+            .flatten();
+        if ech.is_some() && server_name.parse::<std::net::IpAddr>().is_ok() {
+            return invalid("TrustTunnel ECH requires DNS sni");
+        }
+        let pool = if self.max_connections == 0 && self.min_streams == 0 && self.max_streams == 0 {
+            TrustTunnelPoolOptions::default()
+        } else {
+            TrustTunnelPoolOptions {
+                max_connections: self.max_connections,
+                min_streams: self.min_streams,
+                max_streams: self.max_streams,
+            }
+        };
+        Ok((
+            self.name,
+            self.dialer_proxy,
+            self.udp,
+            ProxyProtocol::TrustTunnel(TrustTunnelOutboundConfig {
+                address: self.server,
+                port: self.port,
+                username: self.username,
+                password: self.password,
+                tls: TlsConfig {
+                    server_name,
+                    alpn,
+                    tls13_only: self.quic || ech.is_some(),
+                    required_alpn: Some(required_alpn.to_vec()),
+                    ech,
+                    client_fingerprint,
+                    certificate: TlsCertificatePolicy {
+                        skip_cert_verify: self.skip_cert_verify,
+                        fingerprint: super::normalize_certificate_fingerprint(
+                            self.fingerprint.as_deref(),
+                        )?,
+                        verification_name: super::normalize_verification_name(
+                            self.name_cert_verify,
+                        )?,
+                    },
+                    identity: super::normalize_client_identity(self.certificate, self.private_key)?,
+                },
+                udp: self.udp,
+                quic: self.quic,
+                health_check: self.health_check,
+                pool,
+                congestion_controller: self.congestion_controller,
+            }),
+        ))
+    }
+}
+
+#[cfg(all(test, feature = "outbound-trusttunnel"))]
+mod tests {
+    use super::*;
+    use crate::config::{Config, IpVersion};
+
+    fn parse(options: &str) -> Result<Config> {
+        Config::parse_yaml(
+            format!(
+                "proxies:\n  - name: edge\n    type: trusttunnel\n    server: cover.invalid\n    port: 443\n{options}"
+            )
+            .as_bytes(),
+        )
+    }
+
+    fn node(config: &Config) -> &TrustTunnelOutboundConfig {
+        let ProxyProtocol::TrustTunnel(node) = &config.proxies[0].protocol else {
+            panic!("expected TrustTunnel node")
+        };
+        node
+    }
+
+    #[test]
+    fn h2_defaults_and_empty_auth_keep_mihomo_semantics() {
+        for options in [
+            "",
+            "    alpn: []\n    sni: ''\n    username: ''\n    password: ''\n",
+        ] {
+            let config = parse(options).unwrap();
+            let node = node(&config);
+            assert_eq!(node.tls.server_name, "cover.invalid");
+            assert_eq!(node.tls.alpn, [b"h2".to_vec()]);
+            assert_eq!(node.tls.required_alpn.as_deref(), Some(b"h2".as_slice()));
+            assert_eq!(node.pool, TrustTunnelPoolOptions::default());
+            assert!(node.username.is_empty() && node.password.is_empty());
+            assert!(!config.proxies[0].udp && !node.udp && !node.quic && !node.health_check);
+        }
+    }
+
+    #[test]
+    fn pool_thresholds_preserve_mixed_fields_and_signs() {
+        let config = parse(
+            "    max-connections: 2\n    min-streams: -3\n    max-streams: 4\n    ip-version: ipv4-prefer\n",
+        )
+        .unwrap();
+        assert_eq!(
+            node(&config).pool,
+            TrustTunnelPoolOptions {
+                max_connections: 2,
+                min_streams: -3,
+                max_streams: 4,
+            }
+        );
+        assert_eq!(config.proxies[0].ip_version, IpVersion::Ipv4Prefer);
+        let config = parse("    max-connections: -1\n").unwrap();
+        assert_eq!(node(&config).pool.max_connections, -1);
+        assert_eq!(node(&config).pool.min_streams, 0);
+    }
+
+    #[test]
+    fn h2_tls_options_do_not_leak_credentials() {
+        let config = parse(
+            "    username: synthetic-user\n    password: synthetic-password\n    sni: cover-name.invalid\n    alpn: [h2, http/1.1]\n    skip-cert-verify: true\n    name-cert-verify: verified.invalid\n    fingerprint: 'abababababababababababababababababababababababababababababababab'\n    congestion-controller: arbitrary-unused-h2-value\n",
+        )
+        .unwrap();
+        let node = node(&config);
+        assert_eq!(node.tls.server_name, "cover-name.invalid");
+        assert_eq!(
+            node.tls.certificate.verification_name.as_deref(),
+            Some("verified.invalid")
+        );
+        assert!(node.tls.certificate.skip_cert_verify);
+        assert_eq!(node.tls.certificate.fingerprint, Some([0xab; 32]));
+        let debug = format!("{config:?}");
+        assert!(!debug.contains("synthetic-user") && !debug.contains("synthetic-password"));
+    }
+
+    #[test]
+    fn h2_requires_its_alpn_and_forwards_udp_and_health_check() {
+        assert!(parse("    alpn: [http/1.1]\n").is_err());
+        let config = parse("    udp: true\n    health-check: true\n").unwrap();
+        assert!(config.proxies[0].udp && node(&config).udp && node(&config).health_check);
+    }
+
+    #[test]
+    fn h3_defaults_force_http3_and_preserve_transport_independent_udp() {
+        for extra in ["", "    alpn: []\n    sni: ''\n"] {
+            let config = parse(&format!("    quic: true\n{extra}")).unwrap();
+            let node = node(&config);
+            assert!(node.quic && node.tls.tls13_only);
+            assert_eq!(node.tls.alpn, [b"h3".to_vec()]);
+            assert_eq!(node.tls.required_alpn.as_deref(), Some(b"h3".as_slice()));
+            assert_eq!(node.tls.server_name, "cover.invalid");
+            assert!(!node.udp && !config.proxies[0].udp);
+            assert!(node.username.is_empty() && node.password.is_empty());
+        }
+        let config =
+            parse("    quic: true\n    udp: true\n    health-check: true\n    alpn: [h3, h2]\n")
+                .unwrap();
+        assert!(config.proxies[0].udp && node(&config).udp && node(&config).health_check);
+        assert_eq!(node(&config).tls.alpn, [b"h3".to_vec(), b"h2".to_vec()]);
+        for options in [
+            "    quic: true\n    alpn: [h2]\n",
+            "    quic: true\n    alpn: ['']\n",
+        ] {
+            assert!(parse(options).is_err());
+        }
+    }
+
+    #[test]
+    fn h3_does_not_consume_tcp_fingerprint_or_add_congestion_restrictions() {
+        for fingerprint in ["chrome", "none", "unknown-http3-noop", ""] {
+            let config = parse(&format!("    quic: true\n    client-fingerprint: '{fingerprint}'\n    congestion-controller: arbitrary-default\n    max-connections: -3\n    min-streams: -4\n")).unwrap();
+            let node = node(&config);
+            assert!(node.tls.client_fingerprint.is_none());
+            assert_eq!(node.congestion_controller, "arbitrary-default");
+            assert_eq!(node.pool.max_connections, -3);
+            assert_eq!(node.pool.min_streams, -4);
+        }
+        assert!(parse("    client-fingerprint: unknown-http3-noop\n").is_err());
+        for value in ["null", "[]", "1"] {
+            assert!(
+                parse(&format!(
+                    "    quic: true\n    client-fingerprint: {value}\n"
+                ))
+                .is_err()
+            );
+        }
+    }
+
+    #[test]
+    fn removed_quic_tuning_fields_are_rejected_in_both_modes() {
+        for quic in [false, true] {
+            for field in ["cwnd: 16", "bbr-profile: standard"] {
+                assert!(parse(&format!("    quic: {quic}\n    {field}\n")).is_err());
+            }
+        }
+    }
+
+    #[test]
+    fn h3_shares_certificate_and_dynamic_ech_policy() {
+        let config = parse("    quic: true\n    sni: cover-name.invalid\n    client-fingerprint: unknown-http3-noop\n    skip-cert-verify: true\n    name-cert-verify: verified.invalid\n    fingerprint: 'abababababababababababababababababababababababababababababababab'\n    ech-opts:\n      enable: true\n      query-server-name: ech-query.invalid\n").unwrap();
+        let node = node(&config);
+        assert_eq!(node.tls.server_name, "cover-name.invalid");
+        assert_eq!(
+            node.tls.certificate.verification_name.as_deref(),
+            Some("verified.invalid")
+        );
+        assert!(node.tls.certificate.skip_cert_verify);
+        assert_eq!(node.tls.certificate.fingerprint, Some([0xab; 32]));
+        assert!(node.tls.ech.is_some());
+        assert!(node.tls.client_fingerprint.is_none());
+    }
+}
diff --git a/src/config/tuic.rs b/src/config/tuic.rs
index 5a37bcc..92f162f 100644
--- a/src/config/tuic.rs
+++ b/src/config/tuic.rs
@@ -32,6 +32,16 @@ pub struct TuicOutboundConfig {
     pub tls: TlsConfig,
     pub congestion: TuicCongestion,
     pub udp_mode: TuicUdpMode,
+    pub ip: Option<String>,
+    pub heartbeat_interval: std::time::Duration,
+    pub stream_window: super::QuicReceiveWindow,
+    pub connection_window: super::QuicReceiveWindow,
+    pub max_open_streams: usize,
+    pub max_udp_relay_packet_size: u16,
+    pub max_datagram_frame_size: u16,
+    pub disable_mtu_discovery: bool,
+    pub udp_over_stream: bool,
+    pub disable_sni: bool,
 }
 
 impl std::fmt::Debug for TuicOutboundConfig {
@@ -49,9 +59,11 @@ pub(super) struct RawTuic {
     server: String,
     port: u16,
     uuid: String,
-    password: String,
     #[serde(default)]
-    udp: bool,
+    password: String,
+    // Accepted for compatibility; Mihomo always advertises UDP for this protocol.
+    #[serde(rename = "udp", default)]
+    _udp: bool,
     #[serde(default, deserialize_with = "super::deserialize_present_option")]
     dialer_proxy: Option<String>,
     #[serde(default, deserialize_with = "super::deserialize_present_option")]
@@ -64,6 +76,32 @@ pub(super) struct RawTuic {
     fingerprint: Option<String>,
     #[serde(default, deserialize_with = "super::deserialize_present_option")]
     name_cert_verify: Option<String>,
+    #[serde(default, deserialize_with = "super::deserialize_present_option")]
+    certificate: Option<String>,
+    #[serde(default, deserialize_with = "super::deserialize_present_option")]
+    private_key: Option<String>,
+    #[serde(default, deserialize_with = "super::deserialize_present_option")]
+    ip: Option<String>,
+    #[serde(default)]
+    heartbeat_interval: i64,
+    #[serde(default)]
+    recv_window_conn: u64,
+    #[serde(default)]
+    recv_window: u64,
+    #[serde(default)]
+    max_open_streams: i64,
+    #[serde(default)]
+    max_udp_relay_packet_size: i64,
+    #[serde(default)]
+    max_datagram_frame_size: i64,
+    #[serde(default)]
+    disable_mtu_discovery: bool,
+    #[serde(default)]
+    disable_sni: bool,
+    #[serde(default)]
+    udp_over_stream: bool,
+    #[serde(default, deserialize_with = "super::deserialize_present_option")]
+    udp_over_stream_version: Option<u8>,
     #[serde(default)]
     congestion_controller: TuicCongestion,
     #[serde(default)]
@@ -91,6 +129,40 @@ impl RawTuic {
         let uuid = super::parse_standard_uuid(&self.uuid).map_err(|_| {
             crate::VoleError::InvalidConfig("TUIC requires a standard hyphenated UUID".into())
         })?;
+        let open_streams = if self.max_open_streams == 0 {
+            100
+        } else {
+            self.max_open_streams
+        };
+        let client_threshold = if open_streams == 100 {
+            90
+        } else {
+            open_streams.max(1)
+        };
+        let max_open_streams = client_threshold.saturating_sub(1) as usize;
+        // The fixed reference computes TUIC v5's overhead with an IPv6 address (29 bytes).
+        let relay = if self.max_udp_relay_packet_size == 0 {
+            1252
+        } else {
+            self.max_udp_relay_packet_size
+        };
+        let frame = if self.max_datagram_frame_size == 0 {
+            relay.checked_add(29).ok_or_else(|| {
+                crate::VoleError::InvalidConfig("TUIC datagram limit overflows".into())
+            })?
+        } else {
+            self.max_datagram_frame_size
+        }
+        .min(1400);
+        if frame < 0 {
+            return invalid("TUIC DATAGRAM frame limit cannot be negative");
+        }
+        if self
+            .udp_over_stream_version
+            .is_some_and(|version| version != 2)
+        {
+            return invalid("TUIC UDP-over-stream only supports version 2");
+        }
         let config = TuicOutboundConfig {
             address: self.server.clone(),
             port: self.port,
@@ -98,8 +170,39 @@ impl RawTuic {
             password: self.password,
             congestion: self.congestion_controller,
             udp_mode: self.udp_relay_mode,
+            ip: self.ip.filter(|value| !value.is_empty()),
+            heartbeat_interval: std::time::Duration::from_millis(if self.heartbeat_interval <= 0 {
+                10000
+            } else {
+                self.heartbeat_interval as u64
+            }),
+            stream_window: super::QuicReceiveWindow::normalize(
+                self.recv_window_conn,
+                self.recv_window_conn,
+                super::QuicReceiveWindow {
+                    initial: 15 * 1024 * 1024 / 10,
+                    maximum: 15 * 1024 * 1024,
+                },
+            )?,
+            connection_window: super::QuicReceiveWindow::normalize(
+                self.recv_window,
+                self.recv_window,
+                super::QuicReceiveWindow {
+                    initial: 2 * 1024 * 1024,
+                    maximum: 64 * 1024 * 1024,
+                },
+            )?,
+            max_open_streams,
+            max_udp_relay_packet_size: frame.saturating_sub(29).max(0) as u16,
+            max_datagram_frame_size: frame as u16,
+            disable_mtu_discovery: self.disable_mtu_discovery,
+            disable_sni: self.disable_sni,
+            udp_over_stream: self.udp_over_stream,
             tls: TlsConfig {
-                server_name: self.sni.unwrap_or(self.server),
+                server_name: self
+                    .sni
+                    .filter(|name| !name.is_empty())
+                    .unwrap_or(self.server),
                 alpn: self
                     .alpn
                     .unwrap_or_else(|| vec!["h3".into()])
@@ -108,20 +211,15 @@ impl RawTuic {
                     .collect(),
                 tls13_only: true,
                 required_alpn: None,
-                identity: None,
+                identity: super::normalize_client_identity(self.certificate, self.private_key)?,
                 ech: None,
                 client_fingerprint: None,
                 certificate: TlsCertificatePolicy {
                     skip_cert_verify: self.skip_cert_verify,
-                    verification_name: self.name_cert_verify,
-                    fingerprint: self
-                        .fingerprint
-                        .as_deref()
-                        .map(super::vless::parse_pin)
-                        .transpose()
-                        .map_err(|_| {
-                            crate::VoleError::InvalidConfig("invalid TUIC certificate pin".into())
-                        })?,
+                    verification_name: super::normalize_verification_name(self.name_cert_verify)?,
+                    fingerprint: super::normalize_certificate_fingerprint(
+                        self.fingerprint.as_deref(),
+                    )?,
                 },
             },
         };
@@ -129,7 +227,7 @@ impl RawTuic {
         Ok((
             self.name,
             self.dialer_proxy,
-            self.udp,
+            true,
             ProxyProtocol::Tuic(config),
         ))
     }
@@ -139,6 +237,9 @@ impl TuicOutboundConfig {
     pub(crate) fn validate(&self) -> Result<()> {
         validate_host(&self.address, "TUIC server")?;
         validate_port(self.port, "TUIC")?;
+        if let Some(ip) = &self.ip {
+            validate_host(ip, "TUIC ip")?;
+        }
         validate_host(&self.tls.server_name, "TUIC sni")?;
         if let Some(name) = &self.tls.certificate.verification_name {
             validate_host(name, "TUIC verification name")?;
@@ -154,12 +255,20 @@ impl TuicOutboundConfig {
         }
         if !self.tls.tls13_only
             || self.tls.ech.is_some()
-            || self.tls.identity.is_some()
             || self.tls.client_fingerprint.is_some()
             || self.tls.required_alpn.is_some()
         {
             return invalid("TUIC requires standard QUIC TLS 1.3");
         }
+        if let Some(identity) = &self.tls.identity {
+            crate::security::TlsClientIdentity::from_pem(
+                &identity.certificate,
+                &identity.private_key,
+            )
+            .map_err(|_| {
+                crate::VoleError::InvalidConfig("invalid TUIC TLS client identity".into())
+            })?;
+        }
         Ok(())
     }
 }
diff --git a/src/config/tun_network.rs b/src/config/tun_network.rs
new file mode 100644
index 0000000..9c4cb71
--- /dev/null
+++ b/src/config/tun_network.rs
@@ -0,0 +1,352 @@
+//! TUN network inputs shared with host adapters; Linux owns native application.
+use super::{IpCidr, PortRange, Result, UidRange, invalid, parse_ip_cidr};
+use serde::Deserialize;
+use std::net::{IpAddr, Ipv6Addr};
+
+pub(crate) const MAX_NETWORK_ITEMS: usize = 256;
+pub const DEFAULT_TUN_TABLE: u32 = 2022;
+pub const DEFAULT_TUN_RULE: u32 = 9000;
+
+/// Network settings do not grant permission to reconfigure a borrowed device.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TunNetworkConfig {
+    pub inet6_address: Vec<TunAddress6>,
+    pub route_address: Vec<IpCidr>,
+    pub route_exclude_address: Vec<IpCidr>,
+    pub table_index: u32,
+    pub rule_index: u32,
+    pub strict_route: bool,
+    pub include_interface: Vec<String>,
+    pub exclude_interface: Vec<String>,
+    pub include_uid: Vec<UidRange>,
+    pub exclude_uid: Vec<UidRange>,
+    pub exclude_src_port: Vec<PortRange>,
+    pub exclude_dst_port: Vec<PortRange>,
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct TunAddress6 {
+    pub address: Ipv6Addr,
+    pub prefix_len: u8,
+}
+impl Default for TunNetworkConfig {
+    fn default() -> Self {
+        Self {
+            inet6_address: vec![TunAddress6 {
+                address: "fdfe:dcba:9876::1".parse().expect("static IPv6"),
+                prefix_len: 126,
+            }],
+            route_address: Vec::new(),
+            route_exclude_address: Vec::new(),
+            table_index: DEFAULT_TUN_TABLE,
+            rule_index: DEFAULT_TUN_RULE,
+            strict_route: false,
+            include_interface: Vec::new(),
+            exclude_interface: Vec::new(),
+            include_uid: Vec::new(),
+            exclude_uid: Vec::new(),
+            exclude_src_port: Vec::new(),
+            exclude_dst_port: Vec::new(),
+        }
+    }
+}
+
+#[derive(Debug, Default, Deserialize)]
+pub(super) struct RawTunNetworkConfig {
+    pub inet6_address: Option<Vec<String>>,
+    pub route_address: Vec<String>,
+    pub route_exclude_address: Vec<String>,
+    pub table_index: u32,
+    pub rule_index: u32,
+    pub strict_route: bool,
+    pub include_interface: Vec<String>,
+    pub exclude_interface: Vec<String>,
+    pub include_uid: Vec<u32>,
+    pub include_uid_range: Vec<String>,
+    pub exclude_uid: Vec<u32>,
+    pub exclude_uid_range: Vec<String>,
+    pub exclude_src_port: Vec<u16>,
+    pub exclude_src_port_range: Vec<String>,
+    pub exclude_dst_port: Vec<u16>,
+    pub exclude_dst_port_range: Vec<String>,
+}
+impl RawTunNetworkConfig {
+    pub(super) fn normalize(self) -> Result<TunNetworkConfig> {
+        let count = self.inet6_address.as_ref().map_or(0, Vec::len)
+            + self.route_address.len()
+            + self.route_exclude_address.len()
+            + self.include_interface.len()
+            + self.exclude_interface.len()
+            + self.include_uid.len()
+            + self.include_uid_range.len()
+            + self.exclude_uid.len()
+            + self.exclude_uid_range.len()
+            + self.exclude_src_port.len()
+            + self.exclude_src_port_range.len()
+            + self.exclude_dst_port.len()
+            + self.exclude_dst_port_range.len();
+        if count > MAX_NETWORK_ITEMS {
+            return invalid("TUN network configuration exceeds its route-object budget");
+        }
+        let table_index = if self.table_index == 0 {
+            DEFAULT_TUN_TABLE
+        } else {
+            self.table_index
+        };
+        let rule_index = if self.rule_index == 0 {
+            DEFAULT_TUN_RULE
+        } else {
+            self.rule_index
+        };
+        if matches!(table_index, 253..=255)
+            || rule_index.checked_add(8).is_none()
+            || (rule_index..=rule_index + 8).any(|priority| matches!(priority, 0 | 32766 | 32767))
+        {
+            return invalid("TUN routing indices overlap reserved system objects");
+        }
+        let inet6_address = self.inet6_address.map_or_else(
+            || Ok(TunNetworkConfig::default().inet6_address),
+            |values| {
+                values
+                    .iter()
+                    .map(|value| {
+                        let (ip, prefix) = value.split_once('/').ok_or_else(|| {
+                            super::VoleError::InvalidConfig(
+                                "tun.inet6-address requires IPv6 prefixes".into(),
+                            )
+                        })?;
+                        let address: Ipv6Addr = ip.parse().map_err(|_| {
+                            super::VoleError::InvalidConfig(
+                                "tun.inet6-address requires IPv6 prefixes".into(),
+                            )
+                        })?;
+                        let prefix_len: u8 = prefix.parse().map_err(|_| {
+                            super::VoleError::InvalidConfig(
+                                "invalid tun.inet6-address prefix".into(),
+                            )
+                        })?;
+                        if prefix_len > 128
+                            || address.is_unspecified()
+                            || address.is_multicast()
+                            || address.is_loopback()
+                        {
+                            return invalid("tun.inet6-address requires unicast IPv6 prefixes");
+                        }
+                        Ok(TunAddress6 {
+                            address,
+                            prefix_len,
+                        })
+                    })
+                    .collect::<Result<Vec<_>>>()
+            },
+        )?;
+        let routes = |values: Vec<String>| {
+            values
+                .iter()
+                .map(|value| {
+                    let ipv6 = value
+                        .split_once('/')
+                        .is_some_and(|(ip, _)| ip.parse::<IpAddr>().is_ok_and(|ip| ip.is_ipv6()));
+                    parse_ip_cidr(value, ipv6).map_err(|_| {
+                        super::VoleError::InvalidConfig("TUN routes require IPv4/IPv6 CIDRs".into())
+                    })
+                })
+                .collect::<Result<Vec<_>>>()
+        };
+        Ok(TunNetworkConfig {
+            inet6_address,
+            route_address: routes(self.route_address)?,
+            route_exclude_address: routes(self.route_exclude_address)?,
+            table_index,
+            rule_index,
+            strict_route: self.strict_route,
+            include_interface: interface_names(self.include_interface)?,
+            exclude_interface: interface_names(self.exclude_interface)?,
+            include_uid: uid_ranges(self.include_uid, self.include_uid_range)?,
+            exclude_uid: uid_ranges(self.exclude_uid, self.exclude_uid_range)?,
+            exclude_src_port: port_ranges(self.exclude_src_port, self.exclude_src_port_range)?,
+            exclude_dst_port: port_ranges(self.exclude_dst_port, self.exclude_dst_port_range)?,
+        })
+    }
+}
+fn interface_names(mut names: Vec<String>) -> Result<Vec<String>> {
+    // Linux IFNAMSIZ includes NUL. Retain names rather than ifindices: an
+    // absent interface is a dormant RPDB selector and can appear later.
+    if names.iter().any(|name| {
+        name.is_empty()
+            || name.len() >= 16
+            || matches!(name.as_str(), "." | "..")
+            || name
+                .bytes()
+                .any(|byte| byte == 0 || byte == b'/' || byte == b':' || byte.is_ascii_whitespace())
+    }) {
+        return invalid("TUN input interfaces require valid Linux interface names");
+    }
+    names.sort_unstable();
+    names.dedup();
+    Ok(names)
+}
+
+fn number(text: &str) -> Option<u32> {
+    if text.is_empty() || text.trim() != text || text.starts_with('-') {
+        return None;
+    }
+    let (radix, digits) =
+        if let Some(value) = text.strip_prefix("0x").or_else(|| text.strip_prefix("0X")) {
+            (16, value)
+        } else if let Some(value) = text.strip_prefix("0o").or_else(|| text.strip_prefix("0O")) {
+            (8, value)
+        } else if let Some(value) = text.strip_prefix("0b").or_else(|| text.strip_prefix("0B")) {
+            (2, value)
+        } else if text.starts_with('0') && text.len() > 1 {
+            (8, &text[1..])
+        } else {
+            (10, text)
+        };
+    u32::from_str_radix(digits, radix).ok()
+}
+fn range(text: &str, maximum: u32) -> Result<(u32, u32)> {
+    let pair = text
+        .split_once(':')
+        .and_then(|(first, last)| Some((number(first)?, number(last)?)));
+    match pair {
+        Some((first, last)) if first <= last && last <= maximum => Ok((first, last)),
+        _ => invalid("TUN ranges require ordered start:end values"),
+    }
+}
+fn uid_ranges(values: Vec<u32>, ranges: Vec<String>) -> Result<Vec<UidRange>> {
+    let mut result: Vec<_> = values
+        .into_iter()
+        .map(|id| UidRange { start: id, end: id })
+        .collect();
+    for text in ranges {
+        let (start, end) = range(&text, u32::MAX)?;
+        result.push(UidRange { start, end });
+    }
+    Ok(result)
+}
+fn port_ranges(values: Vec<u16>, ranges: Vec<String>) -> Result<Vec<PortRange>> {
+    let mut result: Vec<_> = values
+        .into_iter()
+        .map(|port| PortRange {
+            start: port,
+            end: port,
+        })
+        .collect();
+    for text in ranges {
+        let (start, end) = range(&text, u32::from(u16::MAX))?;
+        result.push(PortRange {
+            start: start as u16,
+            end: end as u16,
+        });
+    }
+    Ok(super::merge_port_ranges(result))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn tun_network_fields_keep_host_addresses_and_real_mihomo_range_syntax() {
+        let value = super::super::Config::parse_yaml(
+            br#"
+ipv6: true
+tun:
+  inet6-address: ["fd23::17/64"]
+  route-address: ["203.0.113.17/24", "2001:db8:5::7/48"]
+  route-exclude-address: ["203.0.113.64/26"]
+  iproute2-table-index: 2500
+  iproute2-rule-index: 8500
+  strict-route: true
+  include-uid: [1001]
+  include-uid-range: ["0x1000:0x1003"]
+  exclude-uid-range: ["1002:1003"]
+  exclude-src-port: [12345]
+  exclude-dst-port-range: ["0x35:0x36"]
+rules: ["MATCH,DIRECT"]
+"#,
+        )
+        .unwrap()
+        .tun
+        .network;
+        assert_eq!(
+            value.inet6_address[0].address,
+            "fd23::17".parse::<Ipv6Addr>().unwrap()
+        );
+        assert_eq!(
+            value.route_address[0].network,
+            "203.0.113.0".parse::<IpAddr>().unwrap()
+        );
+        assert_eq!((value.table_index, value.rule_index), (2500, 8500));
+        assert_eq!(
+            value.include_uid[1],
+            UidRange {
+                start: 4096,
+                end: 4099
+            }
+        );
+        assert_eq!(
+            value.exclude_dst_port,
+            vec![PortRange { start: 53, end: 54 }]
+        );
+        assert!(value.strict_route);
+    }
+    #[test]
+    fn tun_network_rejects_unbounded_or_reserved_objects_before_acquisition() {
+        for network in [
+            "iproute2-table-index: 254",
+            "iproute2-rule-index: 32765",
+            "iproute2-rule-index: 4294967295",
+            "include-uid-range: ['1002:1001']",
+            "exclude-dst-port-range: ['0:65536']",
+            "inet6-address: ['192.0.2.1/24']",
+        ] {
+            let yaml = format!("tun: {{{network}}}\nrules: ['MATCH,DIRECT']\n");
+            assert!(super::super::Config::parse_yaml(yaml.as_bytes()).is_err());
+        }
+        assert!(
+            RawTunNetworkConfig {
+                route_address: vec!["0.0.0.0/0".into(); MAX_NETWORK_ITEMS + 1],
+                ..Default::default()
+            }
+            .normalize()
+            .is_err()
+        );
+        let empty = RawTunNetworkConfig {
+            inet6_address: Some(Vec::new()),
+            ..Default::default()
+        }
+        .normalize()
+        .unwrap();
+        assert!(empty.inet6_address.is_empty());
+    }
+    #[test]
+    fn tun_input_interfaces_are_bounded_names_without_interface_discovery() {
+        let config = super::super::Config::parse_yaml(
+            br#"tun: {include-interface: [lo, absent-veth, lo], exclude-interface: [other-veth]}
+rules: ['MATCH,DIRECT']"#,
+        )
+        .unwrap();
+        assert_eq!(config.tun.network.include_interface, ["absent-veth", "lo"]);
+        for name in [
+            "",
+            ".",
+            "..",
+            "with/slash",
+            "bad:name",
+            "bad name",
+            "1234567890123456",
+            "bad\0name",
+        ] {
+            assert!(interface_names(vec![name.into()]).is_err());
+        }
+        assert!(
+            RawTunNetworkConfig {
+                include_interface: vec!["lo".into(); MAX_NETWORK_ITEMS + 1],
+                ..Default::default()
+            }
+            .normalize()
+            .is_err()
+        );
+        assert!(super::super::Config::parse_yaml(b"tun: {iproute2-rule-index: 32760}").is_err());
+    }
+}
diff --git a/src/config/vless.rs b/src/config/vless.rs
index 3b4293e..e15d43e 100644
--- a/src/config/vless.rs
+++ b/src/config/vless.rs
@@ -1,65 +1,13 @@
 //! VLESS public normalization. Transport options share the common stream adapters;
 //! security and VLESS-specific behavior remain independent of VMess.
-use super::vmess::{RawGrpc, RawH2, RawHttp, RawWs};
+use super::grpc::RawGrpc;
+use super::vmess::{RawH2, RawHttp, RawWs};
 use super::*;
 
 #[derive(Clone, Debug, Default, PartialEq, Eq)]
 pub struct VlessStreamOptions {
     pub http_upgrade: bool,
     pub fast_open: bool,
-    pub grpc: GrpcOptions,
-    pub sing_mux: Option<SingMuxConfig>,
-}
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Deserialize)]
-#[serde(rename_all = "lowercase")]
-pub enum SingMuxProtocol {
-    #[default]
-    H2Mux,
-    Smux,
-    Yamux,
-}
-
-#[derive(Clone, Debug, Default, PartialEq, Eq, Deserialize)]
-#[serde(deny_unknown_fields, rename_all = "kebab-case")]
-pub struct SingMuxConfig {
-    #[serde(default)]
-    pub enabled: bool,
-    #[serde(default)]
-    pub protocol: SingMuxProtocol,
-    #[serde(default)]
-    pub max_connections: u32,
-    #[serde(default)]
-    pub min_streams: u32,
-    #[serde(default)]
-    pub max_streams: u32,
-    #[serde(default)]
-    pub padding: bool,
-    #[serde(default)]
-    pub only_tcp: bool,
-}
-#[derive(Clone, PartialEq, Eq)]
-pub struct GrpcOptions {
-    pub user_agent: String,
-    pub ping_interval: u64,
-    pub max_connections: usize,
-    pub min_streams: usize,
-    pub max_streams: usize,
-}
-impl std::fmt::Debug for GrpcOptions {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("GrpcOptions").finish_non_exhaustive()
-    }
-}
-impl Default for GrpcOptions {
-    fn default() -> Self {
-        Self {
-            user_agent: "grpc-go/1.36.0".into(),
-            ping_interval: 0,
-            max_connections: 1,
-            min_streams: 0,
-            max_streams: 0,
-        }
-    }
 }
 #[derive(Deserialize)]
 #[serde(deny_unknown_fields)]
@@ -81,27 +29,6 @@ struct RawVlessWs {
     #[serde(rename = "v2ray-http-upgrade-fast-open", default)]
     fast_open: bool,
 }
-#[derive(Deserialize)]
-#[serde(deny_unknown_fields)]
-struct RawVlessGrpc {
-    #[serde(rename = "grpc-service-name")]
-    service: String,
-    #[serde(
-        rename = "grpc-user-agent",
-        default,
-        deserialize_with = "deserialize_present_option"
-    )]
-    user_agent: Option<String>,
-    #[serde(rename = "ping-interval", default)]
-    ping_interval: u64,
-    #[serde(rename = "max-connections", default)]
-    max_connections: usize,
-    #[serde(rename = "min-streams", default)]
-    min_streams: usize,
-    #[serde(rename = "max-streams", default)]
-    max_streams: usize,
-}
-
 #[derive(Deserialize)]
 #[serde(deny_unknown_fields)]
 pub(super) struct RawVless {
@@ -120,7 +47,7 @@ pub(super) struct RawVless {
     #[serde(default)]
     encryption: String,
     #[serde(default)]
-    flow: String,
+    flow: Option<String>,
     #[serde(default, deserialize_with = "deserialize_present_option")]
     servername: Option<String>,
     #[serde(default, deserialize_with = "deserialize_present_option")]
@@ -143,6 +70,12 @@ pub(super) struct RawVless {
         deserialize_with = "super::jls::deserialize"
     )]
     jls_opts: Option<super::jls::RawJls>,
+    #[serde(
+        rename = "shadow-tls-opts",
+        default,
+        deserialize_with = "super::security::deserialize_shadow_tls"
+    )]
+    shadow_tls_opts: Option<super::security::RawShadowTlsMode>,
     #[serde(
         rename = "ech-opts",
         default,
@@ -156,9 +89,6 @@ pub(super) struct RawVless {
     )]
     xhttp_opts: Option<RawXHttpSettings>,
 
-    #[serde(default, deserialize_with = "deserialize_present_map")]
-    smux: Option<SingMuxConfig>,
-
     #[serde(
         rename = "ws-opts",
         default,
@@ -170,7 +100,7 @@ pub(super) struct RawVless {
         default,
         deserialize_with = "deserialize_present_option"
     )]
-    grpc: Option<RawVlessGrpc>,
+    grpc: Option<RawGrpc>,
     #[serde(
         rename = "http-opts",
         default,
@@ -226,7 +156,12 @@ impl RawVless {
         }
         validate_host(&self.server, "VLESS server")?;
         validate_port(self.port, "VLESS")?;
-        let id = parse_standard_uuid(&self.uuid)?;
+        let id = parse_client_uuid(&self.uuid);
+        // Mihomo treats `none` as XUDP, including before Vision validation.
+        let packet_encoding = match self.packet_encoding {
+            VlessPacketEncoding::Raw => VlessPacketEncoding::Xudp,
+            encoding => encoding,
+        };
         let encryption = if matches!(self.encryption.as_str(), "" | "none") {
             VlessEncryption::None
         } else {
@@ -236,37 +171,36 @@ impl RawVless {
             })?;
             VlessEncryption::MlKem768X25519Plus(self.encryption)
         };
-        let network = self.network.as_deref().unwrap_or("tcp");
-        let vision = self.flow == "xtls-rprx-vision";
+        let network = self
+            .network
+            .as_deref()
+            .filter(|network| !network.is_empty())
+            .unwrap_or("tcp");
+        let flow = self.flow.unwrap_or_default();
+        let vision = flow == "xtls-rprx-vision";
+        if self.shadow_tls_opts.is_some() && vision {
+            return invalid("ShadowTLS cannot be combined with Vision");
+        }
         if self.jls_opts.is_some() && (vision || self.reality_opts.is_some()) {
             return invalid("JLS cannot be combined with REALITY or Vision");
         }
-        if (!self.flow.is_empty() && !vision)
+        if (!flow.is_empty() && !vision)
             || (vision
                 && (network != "tcp"
                     || (!self.tls && matches!(&encryption, VlessEncryption::None))
-                    || self.packet_encoding != VlessPacketEncoding::Xudp))
+                    || packet_encoding != VlessPacketEncoding::Xudp))
         {
             return invalid("VLESS Vision requires TCP, TLS or Encryption, and XUDP");
         }
         let mut stream_options = VlessStreamOptions::default();
-        if let Some(mut mux) = self.smux {
-            if (mux.max_connections > 0 && mux.max_streams > 0)
-                || [mux.max_connections, mux.min_streams, mux.max_streams]
-                    .iter()
-                    .any(|value| *value > i32::MAX as u32)
-                || (mux.enabled && vision)
-            {
-                return invalid("invalid VLESS sing-mux options");
-            }
-            if mux.max_connections == 0 && mux.max_streams == 0 {
-                mux.min_streams = 8;
-            }
-            stream_options.sing_mux = mux.enabled.then_some(mux);
-        }
         let ws = self
             .ws
-            .map(|ws| {
+            .map(|mut ws| {
+                vmess::normalize_ws_early_data(
+                    &mut ws.path,
+                    &mut ws.max_early_data,
+                    &mut ws.early_data_header_name,
+                )?;
                 if (ws.fast_open && !ws.http_upgrade)
                     || (ws.http_upgrade
                         && ws.early_data_header_name.as_ref().is_some_and(|name| {
@@ -289,38 +223,7 @@ impl RawVless {
                 })
             })
             .transpose()?;
-        let grpc = self
-            .grpc
-            .map(|grpc| {
-                let user_agent = grpc.user_agent.unwrap_or_else(|| "grpc-go/1.36.0".into());
-                if user_agent.len() > 8192
-                    || user_agent.parse::<http::HeaderValue>().is_err()
-                    || (grpc.max_connections > 0 && grpc.max_streams > 0)
-                    || std::time::Instant::now()
-                        .checked_add(std::time::Duration::from_secs(grpc.ping_interval))
-                        .is_none()
-                {
-                    return invalid("invalid VLESS gRPC options");
-                }
-                stream_options.grpc = GrpcOptions {
-                    user_agent,
-                    ping_interval: grpc.ping_interval,
-                    max_connections: if grpc.max_connections == 0
-                        && grpc.min_streams == 0
-                        && grpc.max_streams == 0
-                    {
-                        1
-                    } else {
-                        grpc.max_connections
-                    },
-                    min_streams: grpc.min_streams,
-                    max_streams: grpc.max_streams,
-                };
-                Ok(RawGrpc {
-                    service: grpc.service,
-                })
-            })
-            .transpose()?;
+        let grpc = self.grpc;
         if (network != "xhttp" && self.xhttp_opts.is_some())
             || (network == "xhttp"
                 && (ws.is_some() || grpc.is_some() || self.http.is_some() || self.h2.is_some()))
@@ -339,8 +242,12 @@ impl RawVless {
                 grpc,
                 self.http,
                 self.h2,
+                self.servername.as_deref().filter(|name| !name.is_empty()),
             )?
         };
+        if self.reality_opts.is_some() && matches!(stream, StreamTransport::WebSocket { .. }) {
+            return invalid("VLESS REALITY requires a stream TLS transport");
+        }
         let standard_options = self.skip_cert_verify.is_some()
             || self.fingerprint.is_some()
             || self.name_cert_verify.is_some()
@@ -351,6 +258,7 @@ impl RawVless {
                 || (network != "xhttp" && self.alpn.is_some())
                 || self.reality_opts.is_some()
                 || self.jls_opts.is_some()
+                || self.shadow_tls_opts.is_some()
                 || self.ech_opts.is_some()
                 || self.client_fingerprint.is_some()
                 || standard_options)
@@ -363,12 +271,18 @@ impl RawVless {
         if self.jls_opts.is_some() && standard_options {
             return invalid("standard certificate options cannot be used with JLS");
         }
+        let client_fingerprint = parse_client_fingerprint(self.client_fingerprint.as_deref())?;
         let ech = self
             .ech_opts
-            .map(super::ech::RawEch::normalize)
+            .map(|raw| raw.normalize(client_fingerprint.is_some()))
             .transpose()?
             .flatten();
-        if ech.is_some() && (self.reality_opts.is_some() || self.jls_opts.is_some() || vision) {
+        if ech.is_some()
+            && (self.reality_opts.is_some()
+                || self.jls_opts.is_some()
+                || self.shadow_tls_opts.is_some()
+                || vision)
+        {
             return invalid("ECH requires standard TLS without REALITY, JLS or Vision");
         }
         let xhttp_version = if network == "xhttp" {
@@ -381,7 +295,6 @@ impl RawVless {
         } else {
             stream.required_alpn()
         };
-        let client_fingerprint = parse_client_fingerprint(self.client_fingerprint.as_deref())?;
         if network == "xhttp"
             && xhttp_version == super::XHttpVersion::Http3
             && client_fingerprint.is_some()
@@ -401,65 +314,44 @@ impl RawVless {
         {
             return invalid("invalid VLESS ALPN");
         }
-        let explicit_name = self.servername.is_some();
-        let server_name = self.servername.unwrap_or(fallback_name);
+        let servername = self.servername.filter(|name| !name.is_empty());
+        let explicit_name = servername.is_some();
+        let server_name = servername.unwrap_or(fallback_name);
         validate_host(&server_name, "VLESS servername")?;
         if ech.is_some() && server_name.parse::<std::net::IpAddr>().is_ok() {
             return invalid("ECH requires a DNS servername");
         }
-        if let Some(name) = &self.name_cert_verify {
-            validate_host(name, "VLESS certificate verification name")?;
-        }
-        let identity = match (self.certificate, self.private_key) {
-            (None, None) => None,
-            (Some(certificate), Some(private_key)) => {
-                validate_client_identity(&certificate, &private_key)?;
-                Some(TlsIdentityPem {
-                    certificate,
-                    private_key,
-                })
+        let verification_name = normalize_verification_name(self.name_cert_verify)?;
+        let identity = normalize_client_identity(self.certificate, self.private_key)?;
+        let security = if self.tls {
+            super::security::RawSecurityModes {
+                reality: self.reality_opts,
+                jls: self.jls_opts,
+                shadow_tls: self.shadow_tls_opts,
             }
-            _ => return invalid("VLESS certificate and private-key must be provided together"),
-        };
-        let security = match (self.reality_opts, self.jls_opts) {
-            (Some(raw), None) => {
-                let mut config = raw.normalize(server_name)?;
-                config.alpn = alpn;
-                config.client_fingerprint = client_fingerprint;
-                config.validate_fingerprint()?;
-                SecurityConfig::Reality(config)
-            }
-            (None, Some(raw)) => SecurityConfig::Jls(raw.normalize(TlsConfig {
-                ech: None,
-                client_fingerprint,
-                server_name,
-                alpn,
-                tls13_only: true,
-                required_alpn: default_alpn.map(<[u8]>::to_vec),
-                certificate: Default::default(),
-                identity: None,
-            })?),
-            (None, None) if self.tls => SecurityConfig::Tls(TlsConfig {
-                tls13_only: ech.is_some()
-                    || network == "xhttp"
-                    || (vision && matches!(&encryption, VlessEncryption::None)),
-                ech,
-                client_fingerprint,
-                server_name,
-                alpn,
-                required_alpn: default_alpn.map(<[u8]>::to_vec),
-                certificate: TlsCertificatePolicy {
-                    verification_name: self.name_cert_verify,
-                    skip_cert_verify: self.skip_cert_verify.unwrap_or(false),
-                    fingerprint: self
-                        .fingerprint
-                        .map(|value| parse_pin(&value))
-                        .transpose()?,
+            .normalize(
+                TlsConfig {
+                    tls13_only: ech.is_some()
+                        || network == "xhttp"
+                        || (vision && matches!(&encryption, VlessEncryption::None)),
+                    ech,
+                    client_fingerprint,
+                    server_name,
+                    alpn,
+                    required_alpn: default_alpn.map(<[u8]>::to_vec),
+                    certificate: TlsCertificatePolicy {
+                        verification_name,
+                        skip_cert_verify: self.skip_cert_verify.unwrap_or(false),
+                        fingerprint: normalize_certificate_fingerprint(
+                            self.fingerprint.as_deref(),
+                        )?,
+                    },
+                    identity,
                 },
-                identity,
-            }),
-            (None, None) => SecurityConfig::None,
-            (Some(_), Some(_)) => return invalid("JLS and REALITY are mutually exclusive"),
+                standard_options,
+            )?
+        } else {
+            SecurityConfig::None
         };
         let transport = if network == "xhttp" {
             VlessTransport::Xhttp(Box::new(self.xhttp_opts.unwrap_or_default().normalize(
@@ -486,10 +378,10 @@ impl RawVless {
                 port: self.port,
                 id,
                 encryption,
-                flow: self.flow,
+                flow,
                 security,
                 transport,
-                packet_encoding: self.packet_encoding,
+                packet_encoding,
                 stream_options,
             }),
         ))
@@ -514,7 +406,7 @@ pub(super) fn parse_pin(value: &str) -> Result<[u8; 32]> {
         .filter(|byte| *byte != b':')
         .collect::<Vec<_>>();
     if hex.len() != 64 || hex.iter().any(|byte| !byte.is_ascii_hexdigit()) {
-        return invalid("VLESS fingerprint must be a SHA-256 certificate digest");
+        return invalid("fingerprint must be a SHA-256 certificate digest");
     }
     let mut pin = [0; 32];
     for (index, pair) in hex.as_chunks::<2>().0.iter().enumerate() {
diff --git a/src/config/vmess.rs b/src/config/vmess.rs
index 01508e7..d483ba6 100644
--- a/src/config/vmess.rs
+++ b/src/config/vmess.rs
@@ -1,6 +1,7 @@
+use super::grpc::RawGrpc;
 use super::{
-    ProxyProtocol, deserialize_present_option, invalid, parse_standard_uuid, validate_host,
-    validate_port,
+    GrpcOptions, ProxyProtocol, deserialize_present_option, invalid, parse_client_uuid,
+    validate_host, validate_port,
 };
 use crate::Result;
 use serde::Deserialize;
@@ -29,6 +30,7 @@ pub enum StreamTransport {
     },
     Grpc {
         uri: String,
+        options: GrpcOptions,
     },
     Http {
         method: String,
@@ -139,11 +141,84 @@ pub(super) struct RawWs {
     )]
     pub(super) early_data_header_name: Option<String>,
 }
-#[derive(Deserialize)]
-#[serde(deny_unknown_fields)]
-pub(super) struct RawGrpc {
-    #[serde(rename = "grpc-service-name")]
-    pub(super) service: String,
+
+pub(super) fn normalize_ws_early_data(
+    path: &mut Option<String>,
+    maximum: &mut u16,
+    header: &mut Option<String>,
+) -> Result<()> {
+    let effective = path.as_deref().unwrap_or("/").split('#').next().unwrap();
+    if effective.len() > 16 * 1024 - 256 {
+        return invalid("WebSocket path exceeds HTTP head budget");
+    }
+    if let Some((base, _)) = path.as_deref().and_then(|path| path.split_once('#')) {
+        *path = Some(base.to_owned());
+    }
+    let Some((base, query)) = path.as_deref().and_then(|path| path.split_once('?')) else {
+        return Ok(());
+    };
+    let Some((_, value)) =
+        url::form_urlencoded::parse(query.as_bytes()).find(|(key, _)| key == "ed")
+    else {
+        return Ok(());
+    };
+    let Ok(value) = value.parse::<i64>() else {
+        return Ok(());
+    };
+    *maximum = if value <= 0 {
+        0
+    } else {
+        u16::try_from(value).map_err(|_| {
+            crate::VoleError::InvalidConfig("WebSocket early-data limit is out of range".into())
+        })?
+    };
+    *header = (*maximum > 0).then(|| "Sec-WebSocket-Protocol".to_owned());
+    let mut pairs = BTreeMap::<String, Vec<String>>::new();
+    for (key, value) in url::form_urlencoded::parse(query.as_bytes()).filter(|(key, _)| key != "ed")
+    {
+        pairs
+            .entry(key.into_owned())
+            .or_default()
+            .push(value.into_owned());
+    }
+    let mut query = url::form_urlencoded::Serializer::new(String::new());
+    for (key, values) in pairs {
+        for value in values {
+            query.append_pair(&key, &value);
+        }
+    }
+    let query = query.finish();
+    *path = Some(if query.is_empty() {
+        base.to_owned()
+    } else {
+        format!("{base}?{query}")
+    });
+    Ok(())
+}
+
+#[cfg(test)]
+mod websocket_query_tests {
+    use super::*;
+
+    #[test]
+    fn ed_query_overrides_explicit_options_and_removes_only_ed() {
+        let mut path = Some("/transport?z=last&ed=4096&x=a%20b&ed=5".to_owned());
+        let mut maximum = 12;
+        let mut header = Some("X-Explicit".to_owned());
+        normalize_ws_early_data(&mut path, &mut maximum, &mut header).unwrap();
+        assert_eq!(path.as_deref(), Some("/transport?x=a+b&z=last"));
+        assert_eq!(maximum, 4096);
+        assert_eq!(header.as_deref(), Some("Sec-WebSocket-Protocol"));
+        path = Some("/transport?ed=0".to_owned());
+        normalize_ws_early_data(&mut path, &mut maximum, &mut header).unwrap();
+        assert_eq!(path.as_deref(), Some("/transport"));
+        assert_eq!(maximum, 0);
+        assert!(header.is_none());
+        path = Some("/transport?ed=4096&token=x#local".to_owned());
+        normalize_ws_early_data(&mut path, &mut maximum, &mut header).unwrap();
+        assert_eq!(path.as_deref(), Some("/transport?token=x"));
+        assert_eq!(maximum, 4096);
+    }
 }
 #[derive(Default, Deserialize)]
 #[serde(deny_unknown_fields)]
@@ -155,9 +230,10 @@ pub(super) struct RawHttp {
     #[serde(default)]
     headers: BTreeMap<String, Vec<String>>,
 }
-#[derive(Deserialize)]
+#[derive(Default, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub(super) struct RawH2 {
+    #[serde(default)]
     host: Vec<String>,
     #[serde(default, deserialize_with = "deserialize_present_option")]
     path: Option<String>,
@@ -194,19 +270,51 @@ fn authority_host(value: &str) -> Result<String> {
     Ok(host.to_owned())
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize, Default)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
 pub enum VmessCipher {
     #[default]
-    #[serde(rename = "auto")]
     Auto,
-    #[serde(rename = "aes-128-gcm")]
     Aes128Gcm,
-    #[serde(rename = "chacha20-poly1305")]
     Chacha20Poly1305,
-    #[serde(rename = "none", alias = "zero")]
     None,
 }
 
+impl<'de> Deserialize<'de> for VmessCipher {
+    fn deserialize<D: serde::Deserializer<'de>>(
+        deserializer: D,
+    ) -> std::result::Result<Self, D::Error> {
+        let value = String::deserialize(deserializer)?;
+        match value.to_ascii_lowercase().as_str() {
+            "auto" => Ok(Self::Auto),
+            "aes-128-gcm" => Ok(Self::Aes128Gcm),
+            "chacha20-poly1305" => Ok(Self::Chacha20Poly1305),
+            "none" | "zero" => Ok(Self::None),
+            _ => Err(serde::de::Error::custom("unsupported VMess cipher")),
+        }
+    }
+}
+
+#[cfg(test)]
+mod cipher_compatibility_tests {
+    use super::*;
+
+    #[test]
+    fn cipher_names_are_case_insensitive_without_legacy_ciphers() {
+        for (input, expected) in [
+            ("AUTO", VmessCipher::Auto),
+            ("AES-128-GCM", VmessCipher::Aes128Gcm),
+            ("ChaCha20-Poly1305", VmessCipher::Chacha20Poly1305),
+            ("ZERO", VmessCipher::None),
+        ] {
+            assert_eq!(
+                serde_json::from_value::<VmessCipher>(input.into()).unwrap(),
+                expected
+            );
+        }
+        assert!(serde_json::from_value::<VmessCipher>("aes-128-cfb".into()).is_err());
+    }
+}
+
 #[derive(Clone, PartialEq, Eq)]
 pub struct VmessOutboundConfig {
     pub address: String,
@@ -217,7 +325,7 @@ pub struct VmessOutboundConfig {
     pub authenticated_length: bool,
     pub packet_encoding: VmessPacketEncoding,
     pub server_name: String,
-    pub tls: Option<super::AnyTlsCertificatePolicy>,
+    pub security: super::SecurityConfig,
     pub transport: StreamTransport,
 }
 impl std::fmt::Debug for VmessOutboundConfig {
@@ -256,12 +364,50 @@ pub(super) struct RawVmess {
     skip_cert_verify: Option<bool>,
     #[serde(default, deserialize_with = "deserialize_present_option")]
     fingerprint: Option<String>,
+    #[serde(
+        rename = "name-cert-verify",
+        default,
+        deserialize_with = "deserialize_present_option"
+    )]
+    name_cert_verify: Option<String>,
+    #[serde(default, deserialize_with = "deserialize_present_option")]
+    certificate: Option<String>,
+    #[serde(
+        rename = "private-key",
+        default,
+        deserialize_with = "deserialize_present_option"
+    )]
+    private_key: Option<String>,
     #[serde(
         rename = "client-fingerprint",
         default,
         deserialize_with = "deserialize_present_option"
     )]
     client_fingerprint: Option<String>,
+    #[serde(
+        rename = "ech-opts",
+        default,
+        deserialize_with = "super::ech::deserialize"
+    )]
+    ech_opts: Option<super::ech::RawEch>,
+    #[serde(
+        rename = "shadow-tls-opts",
+        default,
+        deserialize_with = "super::security::deserialize_shadow_tls"
+    )]
+    shadow_tls_opts: Option<super::security::RawShadowTlsMode>,
+    #[serde(
+        rename = "jls-opts",
+        default,
+        deserialize_with = "super::jls::deserialize"
+    )]
+    jls_opts: Option<super::jls::RawJls>,
+    #[serde(
+        rename = "reality-opts",
+        default,
+        deserialize_with = "super::deserialize_present_map"
+    )]
+    reality_opts: Option<super::RawRealitySettings>,
     #[serde(rename = "global-padding", default)]
     global_padding: bool,
     #[serde(rename = "authenticated-length", default)]
@@ -322,23 +468,43 @@ impl RawVmess {
                 || self.alpn.is_some()
                 || self.skip_cert_verify.is_some()
                 || self.fingerprint.is_some()
-                || self.client_fingerprint.is_some())
+                || self.name_cert_verify.is_some()
+                || self.certificate.is_some()
+                || self.private_key.is_some()
+                || self.shadow_tls_opts.is_some()
+                || self.jls_opts.is_some()
+                || self.reality_opts.is_some()
+                || (self.client_fingerprint.is_some() || self.ech_opts.is_some()))
         {
             return invalid("VMess TLS options require tls=true");
         }
+        let network = self
+            .network
+            .as_deref()
+            .filter(|value| !value.is_empty())
+            .unwrap_or("tcp");
         let (transport, fallback_name) = normalize_transport(
             &self.server,
             self.port,
             self.tls,
-            self.network.as_deref().unwrap_or("tcp"),
+            network,
             self.ws,
             self.grpc,
             self.http,
             self.h2,
+            self.servername.as_deref().filter(|name| !name.is_empty()),
         )?;
-        let server_name = self.servername.unwrap_or(fallback_name);
+        let server_name = self
+            .servername
+            .filter(|name| !name.is_empty())
+            .unwrap_or(fallback_name);
         validate_host(&server_name, "VMess servername")?;
-        let tls = if self.tls {
+        let certificate_options = self.skip_cert_verify.is_some()
+            || self.fingerprint.is_some()
+            || self.name_cert_verify.is_some()
+            || self.certificate.is_some()
+            || self.private_key.is_some();
+        let security = if self.tls {
             let alpn: Vec<Vec<u8>> = self
                 .alpn
                 .unwrap_or_else(|| {
@@ -358,32 +524,51 @@ impl RawVmess {
             {
                 return invalid("invalid VMess ALPN");
             }
-            let fingerprint = self
-                .fingerprint
-                .map(|value| {
-                    let hex: Vec<_> = value.trim().bytes().filter(|b| *b != b':').collect();
-                    if hex.len() != 64 || !hex.iter().all(u8::is_ascii_hexdigit) {
-                        return invalid("invalid VMess certificate fingerprint");
-                    }
-                    let mut pin = [0; 32];
-                    for (byte, pair) in pin.iter_mut().zip(hex.as_chunks::<2>().0) {
-                        *byte = ((pair[0] as char).to_digit(16).unwrap() * 16
-                            + (pair[1] as char).to_digit(16).unwrap())
-                            as u8;
-                    }
-                    Ok(pin)
-                })
-                .transpose()?;
-            Some(super::AnyTlsCertificatePolicy {
-                client_fingerprint: super::parse_client_fingerprint(
-                    self.client_fingerprint.as_deref(),
-                )?,
-                alpn,
-                fingerprint,
-                skip_cert_verify: self.skip_cert_verify.unwrap_or(false),
-            })
+            let fingerprint =
+                super::normalize_certificate_fingerprint(self.fingerprint.as_deref())?;
+            let client_fingerprint =
+                super::parse_client_fingerprint(self.client_fingerprint.as_deref())?;
+            let ech = self
+                .ech_opts
+                .map(|raw| raw.normalize(client_fingerprint.is_some()))
+                .transpose()?
+                .flatten();
+            if ech.is_some() && server_name.parse::<std::net::IpAddr>().is_ok() {
+                return invalid("VMess ECH requires DNS servername");
+            }
+            if self.reality_opts.is_some() && matches!(transport, StreamTransport::WebSocket { .. })
+            {
+                return invalid("VMess REALITY requires a stream TLS transport");
+            }
+            if self.reality_opts.is_some() && client_fingerprint.is_none() {
+                return invalid("VMess REALITY requires a named client-fingerprint");
+            }
+            super::security::RawSecurityModes {
+                reality: self.reality_opts,
+                jls: self.jls_opts,
+                shadow_tls: self.shadow_tls_opts,
+            }
+            .normalize(
+                super::TlsConfig {
+                    server_name: server_name.clone(),
+                    required_alpn: transport.required_alpn().map(<[u8]>::to_vec),
+                    tls13_only: ech.is_some(),
+                    ech,
+                    client_fingerprint,
+                    alpn,
+                    certificate: super::TlsCertificatePolicy {
+                        fingerprint,
+                        skip_cert_verify: self.skip_cert_verify.unwrap_or(false),
+                        verification_name: super::normalize_verification_name(
+                            self.name_cert_verify,
+                        )?,
+                    },
+                    identity: super::normalize_client_identity(self.certificate, self.private_key)?,
+                },
+                certificate_options,
+            )?
         } else {
-            None
+            super::SecurityConfig::None
         };
         Ok((
             self.name,
@@ -392,13 +577,13 @@ impl RawVmess {
             ProxyProtocol::Vmess(VmessOutboundConfig {
                 address: self.server,
                 port: self.port,
-                id: parse_standard_uuid(&self.uuid)?,
+                id: parse_client_uuid(&self.uuid),
                 cipher: self.cipher,
                 global_padding: self.global_padding,
                 authenticated_length: self.authenticated_length,
                 packet_encoding: self.packet_encoding,
                 server_name,
-                tls,
+                security,
                 transport,
             }),
         ))
@@ -415,6 +600,7 @@ pub(super) fn normalize_transport(
     grpc: Option<RawGrpc>,
     http: Option<RawHttp>,
     h2: Option<RawH2>,
+    grpc_authority: Option<&str>,
 ) -> Result<(StreamTransport, String)> {
     let authority = if server.parse::<std::net::Ipv6Addr>().is_ok() {
         format!("[{}]:{}", server, port)
@@ -426,10 +612,13 @@ pub(super) fn normalize_transport(
     let transport = match (network, ws, grpc, http, h2) {
         ("tcp", None, None, None, None) => StreamTransport::Tcp,
         ("ws", ws, None, None, None) => {
-            let ws = ws.unwrap_or_default();
-            if ws.max_early_data > 2048
-                || (ws.max_early_data == 0 && ws.early_data_header_name.is_some())
-            {
+            let mut ws = ws.unwrap_or_default();
+            normalize_ws_early_data(
+                &mut ws.path,
+                &mut ws.max_early_data,
+                &mut ws.early_data_header_name,
+            )?;
+            if ws.max_early_data == 0 && ws.early_data_header_name.is_some() {
                 return invalid("invalid VMess early-data options");
             }
             for (key, value) in &ws.headers {
@@ -446,7 +635,10 @@ pub(super) fn normalize_transport(
                 uri: uri(
                     if tls { "wss" } else { "ws" },
                     &authority,
-                    ws.path.as_deref().unwrap_or("/"),
+                    ws.path
+                        .as_deref()
+                        .filter(|path| !path.is_empty())
+                        .unwrap_or("/"),
                 )?,
                 headers: ws.headers,
                 max_early_data: ws.max_early_data,
@@ -460,17 +652,22 @@ pub(super) fn normalize_transport(
             }
             transport
         }
-        ("grpc", None, Some(grpc), None, None) if !grpc.service.is_empty() => {
-            let path = if grpc.service.starts_with('/') {
-                grpc.service
-            } else {
-                format!("/{}/Tun", grpc.service)
-            };
-            if path.contains('?') {
-                return invalid("invalid VMess gRPC path");
-            }
+        ("grpc", None, grpc, None, None) => {
+            let (path, options) = grpc.unwrap_or_default().normalize()?;
+            let grpc_authority = grpc_authority.map(|name| {
+                if name.parse::<std::net::Ipv6Addr>().is_ok() {
+                    format!("[{name}]")
+                } else {
+                    name.to_owned()
+                }
+            });
             StreamTransport::Grpc {
-                uri: uri(scheme, &authority, &path)?,
+                uri: uri(
+                    scheme,
+                    grpc_authority.as_deref().unwrap_or(&authority),
+                    &path,
+                )?,
+                options,
             }
         }
         ("http", None, None, http, None) => {
@@ -478,7 +675,10 @@ pub(super) fn normalize_transport(
             if http.path.is_empty() {
                 http.path.push("/".into());
             }
-            let method = http.method.unwrap_or_else(|| "GET".into());
+            let method = http
+                .method
+                .filter(|method| !method.is_empty())
+                .unwrap_or_else(|| "GET".into());
             if method.parse::<http::Method>().is_err() || http.headers.values().any(Vec::is_empty) {
                 return invalid("invalid HTTP transport options");
             }
@@ -499,7 +699,7 @@ pub(super) fn normalize_transport(
                 .path
                 .iter()
                 .map(|path| {
-                    if !path.starts_with('/') || path.contains(['\r', '\n']) {
+                    if (!path.is_empty() && !path.starts_with('/')) || path.contains(['\r', '\n']) {
                         return invalid("invalid HTTP transport path");
                     }
                     let mut url =
@@ -530,11 +730,22 @@ pub(super) fn normalize_transport(
                 headers: http.headers,
             }
         }
-        ("h2", None, None, None, Some(h2)) if !h2.host.is_empty() => {
+        ("h2", None, None, None, h2) => {
+            let mut h2 = h2.unwrap_or_default();
+            if h2.host.is_empty() {
+                h2.host.push("www.example.com".into());
+            }
             let mut uris = Vec::new();
             for host in h2.host {
                 authority_host(&host)?;
-                uris.push(uri(scheme, &host, h2.path.as_deref().unwrap_or("/"))?);
+                uris.push(uri(
+                    scheme,
+                    &host,
+                    h2.path
+                        .as_deref()
+                        .filter(|path| !path.is_empty())
+                        .unwrap_or("/"),
+                )?);
             }
             StreamTransport::H2 { uris }
         }
diff --git a/src/config/wireguard.rs b/src/config/wireguard.rs
new file mode 100644
index 0000000..f05ebad
--- /dev/null
+++ b/src/config/wireguard.rs
@@ -0,0 +1,555 @@
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
+
+use base64::{Engine as _, engine::general_purpose::STANDARD};
+use serde::{Deserialize, de::Visitor};
+use zeroize::Zeroizing;
+
+use super::{DnsNameserver, IpCidr, ProxyProtocol, invalid, validate_host, validate_port};
+use crate::Result;
+
+#[derive(Clone, PartialEq, Eq)]
+pub struct WireGuardKey(Zeroizing<[u8; 32]>);
+impl std::fmt::Debug for WireGuardKey {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("WireGuardKey { .. }")
+    }
+}
+impl WireGuardKey {
+    fn parse(value: String) -> Result<Self> {
+        let value = Zeroizing::new(value);
+        let bytes = Zeroizing::new(STANDARD.decode(value.as_bytes()).map_err(|_| {
+            crate::VoleError::InvalidConfig("WireGuard requires a 32-byte base64 key".into())
+        })?);
+        let bytes: [u8; 32] = bytes.as_slice().try_into().map_err(|_| {
+            crate::VoleError::InvalidConfig("WireGuard requires a 32-byte base64 key".into())
+        })?;
+        Ok(Self(Zeroizing::new(bytes)))
+    }
+    #[cfg(feature = "outbound-wireguard")]
+    pub(crate) fn bytes(&self) -> [u8; 32] {
+        *self.0
+    }
+}
+#[derive(Clone, PartialEq, Eq)]
+pub struct WireGuardPeerConfig {
+    pub address: String,
+    pub port: u16,
+    pub public_key: WireGuardKey,
+    pub pre_shared_key: Option<WireGuardKey>,
+    pub reserved: [u8; 3],
+    pub allowed_ips: Vec<IpCidr>,
+}
+impl std::fmt::Debug for WireGuardPeerConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("WireGuardPeerConfig")
+            .finish_non_exhaustive()
+    }
+}
+#[derive(Clone, PartialEq, Eq)]
+pub struct WireGuardOutboundConfig {
+    /// Representative first endpoint for the existing graph/measurement visitor.
+    pub address: String,
+    pub port: u16,
+    pub ipv4: Option<Ipv4Addr>,
+    pub ipv6: Option<Ipv6Addr>,
+    pub private_key: WireGuardKey,
+    pub mtu: u16,
+    pub persistent_keepalive: u16,
+    pub peers: Vec<WireGuardPeerConfig>,
+    pub routes: Vec<(IpCidr, usize)>,
+    /// Active node resolver; absent when the switch is false or DNS list empty.
+    pub dns: Vec<DnsNameserver>,
+    pub refresh_server_ip_interval: i64,
+}
+impl std::fmt::Debug for WireGuardOutboundConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("WireGuardOutboundConfig")
+            .field("mtu", &self.mtu)
+            .finish_non_exhaustive()
+    }
+}
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "kebab-case")]
+struct RawPeer {
+    server: String,
+    port: u16,
+    public_key: String,
+    #[serde(default)]
+    pre_shared_key: String,
+    #[serde(default, deserialize_with = "deserialize_reserved")]
+    reserved: Vec<u8>,
+    #[serde(default)]
+    allowed_ips: Vec<String>,
+}
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "kebab-case")]
+pub(super) struct RawWireGuard {
+    name: String,
+    #[serde(default)]
+    server: String,
+    #[serde(default)]
+    port: u16,
+    #[serde(default)]
+    ip: String,
+    #[serde(default)]
+    ipv6: String,
+    private_key: String,
+    #[serde(default)]
+    public_key: String,
+    #[serde(default)]
+    pre_shared_key: String,
+    #[serde(default, deserialize_with = "deserialize_reserved")]
+    reserved: Vec<u8>,
+    #[serde(default)]
+    allowed_ips: Vec<String>,
+    #[serde(default)]
+    peers: Vec<RawPeer>,
+    #[serde(default)]
+    mtu: u16,
+    #[serde(default)]
+    persistent_keepalive: u16,
+    #[serde(default)]
+    remote_dns_resolve: bool,
+    #[serde(default)]
+    dns: Vec<String>,
+    #[serde(default)]
+    refresh_server_ip_interval: i64,
+    #[serde(default)]
+    udp: bool,
+    #[serde(default, deserialize_with = "super::deserialize_present_option")]
+    dialer_proxy: Option<String>,
+}
+impl std::fmt::Debug for RawWireGuard {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("RawWireGuard").finish_non_exhaustive()
+    }
+}
+pub(super) fn deserialize<'de, D: serde::Deserializer<'de>>(
+    d: D,
+) -> std::result::Result<RawWireGuard, D::Error> {
+    RawWireGuard::deserialize(d)
+        .map_err(|_| serde::de::Error::custom("invalid WireGuard configuration fields"))
+}
+
+fn deserialize_reserved<'de, D: serde::Deserializer<'de>>(
+    deserializer: D,
+) -> std::result::Result<Vec<u8>, D::Error> {
+    struct Reserved;
+
+    impl<'de> Visitor<'de> for Reserved {
+        type Value = Vec<u8>;
+
+        fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            formatter.write_str("three bytes as a byte array or standard Base64")
+        }
+
+        fn visit_str<E: serde::de::Error>(self, value: &str) -> std::result::Result<Vec<u8>, E> {
+            let error = || E::custom("WireGuard reserved requires three bytes");
+            let mut encoded = [0; 4];
+            let mut length = 0;
+            // Go's standard Base64 decoder ignores CR and LF.
+            for byte in value.bytes().filter(|byte| !matches!(*byte, b'\r' | b'\n')) {
+                if length == encoded.len() {
+                    return Err(error());
+                }
+                encoded[length] = byte;
+                length += 1;
+            }
+            if length == 0 {
+                return Ok(Vec::new());
+            }
+            let mut decoded = [0; 3];
+            if STANDARD
+                .decode_slice(&encoded[..length], &mut decoded)
+                .map_err(|_| error())?
+                != decoded.len()
+            {
+                return Err(error());
+            }
+            Ok(decoded.to_vec())
+        }
+
+        fn visit_seq<A: serde::de::SeqAccess<'de>>(
+            self,
+            mut sequence: A,
+        ) -> std::result::Result<Vec<u8>, A::Error> {
+            let mut bytes = Vec::with_capacity(3);
+            while let Some(byte) = sequence.next_element::<u8>()? {
+                if bytes.len() == 3 {
+                    return Err(serde::de::Error::custom(
+                        "WireGuard reserved requires three bytes",
+                    ));
+                }
+                bytes.push(byte);
+            }
+            if !bytes.is_empty() && bytes.len() != 3 {
+                return Err(serde::de::Error::custom(
+                    "WireGuard reserved requires three bytes",
+                ));
+            }
+            Ok(bytes)
+        }
+    }
+
+    deserializer.deserialize_any(Reserved)
+}
+
+fn reserved(value: Vec<u8>, default: [u8; 3]) -> Result<[u8; 3]> {
+    if value.is_empty() {
+        Ok(default)
+    } else {
+        value.try_into().map_err(|_| {
+            crate::VoleError::InvalidConfig("WireGuard reserved requires three bytes".into())
+        })
+    }
+}
+fn supported_node_dns(nameserver: &DnsNameserver) -> bool {
+    matches!(
+        nameserver.address,
+        super::DnsAddress::Ip(_) | super::DnsAddress::Domain(_)
+    ) && matches!(
+        nameserver.transport,
+        super::DnsTransport::Udp
+            | super::DnsTransport::Tcp
+            | super::DnsTransport::Tls
+            | super::DnsTransport::Http
+            | super::DnsTransport::Https
+            | super::DnsTransport::Quic
+            | super::DnsTransport::Rcode(_)
+    )
+}
+
+impl RawPeer {
+    fn normalize(self, default: [u8; 3]) -> Result<WireGuardPeerConfig> {
+        validate_host(&self.server, "WireGuard server")?;
+        validate_port(self.port, "WireGuard")?;
+        if self.allowed_ips.is_empty() {
+            return invalid("WireGuard peer requires allowed-ips");
+        }
+        let ips = self
+            .allowed_ips
+            .iter()
+            .map(|v| {
+                super::parse_ip_cidr(
+                    v,
+                    v.split_once('/')
+                        .and_then(|(ip, _)| ip.parse::<IpAddr>().ok())
+                        .is_some_and(|ip| ip.is_ipv6()),
+                )
+                .map_err(|_| {
+                    crate::VoleError::InvalidConfig("invalid WireGuard allowed prefix".into())
+                })
+            })
+            .collect::<Result<Vec<_>>>()?;
+        Ok(WireGuardPeerConfig {
+            address: self.server,
+            port: self.port,
+            public_key: WireGuardKey::parse(self.public_key)?,
+            pre_shared_key: (!self.pre_shared_key.is_empty())
+                .then(|| WireGuardKey::parse(self.pre_shared_key))
+                .transpose()?,
+            reserved: reserved(self.reserved, default)?,
+            allowed_ips: ips,
+        })
+    }
+}
+impl RawWireGuard {
+    pub(super) fn normalize(self) -> Result<(String, Option<String>, bool, ProxyProtocol)> {
+        if !cfg!(feature = "outbound-wireguard") {
+            return invalid("WireGuard support is disabled at build time");
+        }
+        let mut ipv4 = None;
+        let mut ipv6 = None;
+        for value in [&self.ip, &self.ipv6].into_iter().filter(|s| !s.is_empty()) {
+            let (address, prefix) = value
+                .split_once('/')
+                .map_or((value.as_str(), None), |(a, p)| (a, Some(p)));
+            let ip = address.parse::<IpAddr>().map_err(|_| {
+                crate::VoleError::InvalidConfig("invalid WireGuard local address".into())
+            })?;
+            if let Some(prefix) = prefix {
+                let p = prefix.parse::<u8>().map_err(|_| {
+                    crate::VoleError::InvalidConfig("invalid WireGuard local prefix".into())
+                })?;
+                if p > if ip.is_ipv4() { 32 } else { 128 } {
+                    return invalid("invalid WireGuard local prefix");
+                }
+            }
+            match ip {
+                IpAddr::V4(ip) if ipv4.is_none() => ipv4 = Some(ip),
+                IpAddr::V6(ip) if ipv6.is_none() => ipv6 = Some(ip),
+                _ => return invalid("WireGuard requires at most one local address per family"),
+            }
+        }
+        let global = reserved(self.reserved, [0; 3])?;
+        let mut peers = Vec::<WireGuardPeerConfig>::new();
+        let mut routes = Vec::new();
+        if self.peers.is_empty() {
+            // Fixed reference ignores top-level allowed-ips in single-peer mode.
+            let _ = self.allowed_ips;
+            let mut allowed_ips = Vec::new();
+            if ipv4.is_some() {
+                allowed_ips.push("0.0.0.0/0".into());
+            }
+            if ipv6.is_some() {
+                allowed_ips.push("::/0".into());
+            }
+            peers.push(
+                RawPeer {
+                    server: self.server,
+                    port: self.port,
+                    public_key: self.public_key,
+                    pre_shared_key: self.pre_shared_key,
+                    reserved: Vec::new(),
+                    allowed_ips,
+                }
+                .normalize(global)?,
+            );
+            routes.extend(peers[0].allowed_ips.iter().map(|cidr| (*cidr, 0)));
+        } else {
+            for raw in self.peers {
+                let peer = raw.normalize(global)?;
+                // WireGuard's device identifies peers by key. Repeated declarations
+                // update that peer rather than inventing a second crypto identity.
+                if let Some(index) = peers
+                    .iter()
+                    .position(|old| old.public_key == peer.public_key)
+                {
+                    routes.extend(peer.allowed_ips.iter().map(|cidr| (*cidr, index)));
+                    let old = &mut peers[index];
+                    old.address = peer.address;
+                    old.port = peer.port;
+                    old.reserved = peer.reserved;
+                    if peer.pre_shared_key.is_some() {
+                        old.pre_shared_key = peer.pre_shared_key;
+                    }
+                    old.allowed_ips.extend(peer.allowed_ips);
+                } else {
+                    routes.extend(peer.allowed_ips.iter().map(|cidr| (*cidr, peers.len())));
+                    peers.push(peer);
+                }
+            }
+        }
+        let dns = if self.remote_dns_resolve && !self.dns.is_empty() {
+            self.dns
+                .iter()
+                .map(|v| {
+                    // The reference replaces every parsed DNS route with this
+                    // WireGuard adapter; a named fragment cannot select an
+                    // external group or bypass the node's raw-IP data plane.
+                    let nameserver = super::dns::parse_node_dns_nameserver(v)?;
+                    if !supported_node_dns(&nameserver) {
+                        return invalid(
+                            "WireGuard node DNS requires an explicit network or RCODE upstream",
+                        );
+                    }
+                    Ok(nameserver)
+                })
+                .collect::<Result<Vec<_>>>()?
+        } else {
+            Vec::new()
+        };
+        let config = WireGuardOutboundConfig {
+            address: peers[0].address.clone(),
+            port: peers[0].port,
+            ipv4,
+            ipv6,
+            private_key: WireGuardKey::parse(self.private_key)?,
+            mtu: if self.mtu == 0 { 1408 } else { self.mtu },
+            persistent_keepalive: self.persistent_keepalive,
+            peers,
+            routes,
+            dns,
+            refresh_server_ip_interval: self.refresh_server_ip_interval,
+        };
+        config.validate()?;
+        Ok((
+            self.name,
+            self.dialer_proxy,
+            self.udp,
+            ProxyProtocol::WireGuard(config),
+        ))
+    }
+}
+impl WireGuardOutboundConfig {
+    pub(crate) fn validate(&self) -> Result<()> {
+        if self.peers.is_empty() {
+            return invalid("WireGuard requires a peer");
+        }
+        if self
+            .dns
+            .iter()
+            .any(|nameserver| !supported_node_dns(nameserver))
+        {
+            return invalid("WireGuard node DNS requires an explicit network or RCODE upstream");
+        }
+        for peer in &self.peers {
+            validate_host(&peer.address, "WireGuard server")?;
+            validate_port(peer.port, "WireGuard")?;
+            if peer.allowed_ips.is_empty() {
+                return invalid("WireGuard peer requires allowed-ips");
+            }
+        }
+        if self.routes.iter().any(|(prefix, index)| {
+            *index >= self.peers.len()
+                || prefix.prefix_len > if prefix.network.is_ipv4() { 32 } else { 128 }
+        }) {
+            return invalid("invalid WireGuard peer route");
+        }
+        if self.ipv4.is_none() && self.ipv6.is_none() {
+            return invalid("WireGuard requires a local address");
+        }
+        if self
+            .ipv4
+            .is_some_and(|ip| ip.is_unspecified() || ip.is_multicast() || ip.is_broadcast())
+            || self
+                .ipv6
+                .is_some_and(|ip| ip.is_unspecified() || ip.is_multicast())
+        {
+            return invalid("WireGuard requires unicast local addresses");
+        }
+        if !(1280..=65503).contains(&self.mtu) {
+            return invalid("WireGuard MTU must be between 1280 and 65503");
+        }
+        Ok(())
+    }
+}
+
+#[cfg(all(test, feature = "outbound-wireguard"))]
+mod tests {
+    use serde_json::{Value, json};
+
+    use super::*;
+    use crate::config::Config;
+
+    fn document(global: Value, peer: Option<Value>) -> Vec<u8> {
+        let mut node = json!({
+            "name": "wg", "type": "wireguard", "server": "192.0.2.1", "port": 51820,
+            "ip": "10.0.0.2", "private-key": STANDARD.encode([1; 32]),
+            "public-key": STANDARD.encode([2; 32]), "reserved": global
+        });
+        if let Some(reserved) = peer {
+            node["peers"] = json!([{
+                "server": "192.0.2.1", "port": 51820, "public-key": STANDARD.encode([2; 32]),
+                "allowed-ips": ["0.0.0.0/0"], "reserved": reserved
+            }]);
+        }
+        serde_json::to_vec(&json!({"mixed-port": 1080, "proxies": [node]})).unwrap()
+    }
+
+    #[test]
+    fn reserved_base64_and_bytes_match_and_empty_peer_inherits() {
+        for peer in [None, Some(json!([])), Some(json!([0, 1, 255]))] {
+            let base64_peer = peer.as_ref().map(|value| {
+                if value.as_array().unwrap().is_empty() {
+                    json!("")
+                } else {
+                    json!("AAH/")
+                }
+            });
+            let bytes = Config::parse_yaml(&document(json!([83, 128, 39]), peer)).unwrap();
+            let encoded = Config::parse_yaml(&document(json!("U4An"), base64_peer)).unwrap();
+            assert_eq!(bytes.proxies[0].protocol, encoded.proxies[0].protocol);
+        }
+        let inherited = Config::parse_yaml(&document(json!("U4An"), Some(json!("")))).unwrap();
+        let ProxyProtocol::WireGuard(config) = &inherited.proxies[0].protocol else {
+            panic!("expected WireGuard");
+        };
+        assert_eq!(config.peers[0].reserved, [83, 128, 39]);
+        let zeros = Config::parse_yaml(&document(json!("U4An"), Some(json!("AAAA")))).unwrap();
+        let ProxyProtocol::WireGuard(config) = &zeros.proxies[0].protocol else {
+            panic!("expected WireGuard");
+        };
+        assert_eq!(config.peers[0].reserved, [0; 3]);
+        let default = Config::parse_yaml(&document(json!(""), None)).unwrap();
+        let bytes = Config::parse_yaml(&document(json!([]), None)).unwrap();
+        assert_eq!(default.proxies[0].protocol, bytes.proxies[0].protocol);
+        assert!(Config::parse_yaml(&document(json!("U4\r\nAn"), None)).is_ok());
+    }
+
+    #[test]
+    fn reserved_rejects_invalid_base64_lengths_and_byte_values_at_both_levels() {
+        for value in [
+            json!("AA=="),
+            json!("AAE="),
+            json!("AAECAw=="),
+            json!("%%%"),
+            json!("____"),
+            json!([1]),
+            json!([1, 2, 3, 4]),
+            json!([0, 1, 256]),
+            json!([-1, 1, 2]),
+            json!([0, 1, 2.0]),
+            json!(null),
+            json!(true),
+            json!(42),
+        ] {
+            assert!(Config::parse_yaml(&document(value.clone(), None)).is_err());
+            assert!(Config::parse_yaml(&document(json!([0, 0, 0]), Some(value))).is_err());
+        }
+    }
+
+    #[test]
+    fn private_dns_preserves_keyed_fragments_and_ignores_route_tokens() {
+        let mut document: Value = serde_json::from_slice(&document(json!([]), None)).unwrap();
+        let node = &mut document["proxies"][0];
+        node["remote-dns-resolve"] = json!(true);
+        let tls = "tls://192.0.2.53#undeclared%2526route%26ecs=2001:db8::7/57%26ecs-override=true%26disable-ipv4=true%26disable-qtype-16=true%26skip-cert-verify=true%26name-cert-verify=dns.example%26disable-reuse=true";
+        node["dns"] = json!([
+            tls,
+            "https://dns.example/dns-query#RULES&h3=true%2526disable-ipv6=true"
+        ]);
+        let parsed = Config::parse_yaml(&serde_json::to_vec(&document).unwrap()).unwrap();
+        let ProxyProtocol::WireGuard(config) = &parsed.proxies[0].protocol else {
+            panic!("expected WireGuard");
+        };
+        assert!(
+            config
+                .dns
+                .iter()
+                .all(|server| server.route == super::super::DnsRoute::Direct)
+        );
+        let options = &config.dns[0].options;
+        assert_eq!(options.ecs.unwrap().prefix_len, 57);
+        assert!(options.ecs_override);
+        assert_eq!(&*options.disabled_types, &[1, 16]);
+        assert!(options.skip_cert_verify);
+        assert_eq!(options.verification_name.as_deref(), Some("dns.example"));
+        assert!(options.disable_reuse);
+        // A second percent decode would introduce another keyed parameter and
+        // accidentally force H3. The value after one decode is not "true".
+        assert!(!config.dns[1].options.force_h3);
+        assert!(config.dns[1].options.disabled_types.is_empty());
+        assert!(
+            config
+                .dns
+                .iter()
+                .all(|server| server.options.interface.is_none())
+        );
+
+        document["proxies"][0]["dns"] = json!(["https://dns.example#undeclared&h3=true"]);
+        let parsed = Config::parse_yaml(&serde_json::to_vec(&document).unwrap());
+        if cfg!(feature = "dns-quic") {
+            let parsed = parsed.unwrap();
+            let ProxyProtocol::WireGuard(config) = &parsed.proxies[0].protocol else {
+                panic!("expected WireGuard")
+            };
+            assert!(config.dns[0].options.force_h3);
+        } else {
+            assert!(parsed.is_err());
+        }
+
+        // Ordinary DNS uses an undeclared name as a physical interface, while
+        // private DNS retains its fixed adapter and validates keyed options.
+        document["proxies"][0]["dns"] = json!([tls]);
+        document["dns"] = json!({"nameserver": ["tls://192.0.2.53#undeclared"]});
+        let ordinary = Config::parse_yaml(&serde_json::to_vec(&document).unwrap()).unwrap();
+        assert_eq!(
+            ordinary.dns.nameservers[0].options.interface.as_deref(),
+            Some("undeclared")
+        );
+        document["dns"] = json!({});
+        document["proxies"][0]["dns"] = json!(["tls://192.0.2.53#undeclared&ecs=not-an-ip"]);
+        assert!(Config::parse_yaml(&serde_json::to_vec(&document).unwrap()).is_err());
+    }
+}
diff --git a/src/config/xhttp.rs b/src/config/xhttp.rs
index 244f387..35b03c6 100644
--- a/src/config/xhttp.rs
+++ b/src/config/xhttp.rs
@@ -53,6 +53,8 @@ pub struct XHttpRequestOptions {
     pub(crate) data: DataPlacement,
     pub(crate) post_bytes: IntegerRange,
     pub(crate) post_interval_ms: IntegerRange,
+    // Preserve explicit intervals; only the internal default may flush a full batch early.
+    pub(crate) post_interval_explicit: bool,
 }
 
 impl Default for XHttpRequestOptions {
@@ -69,7 +71,8 @@ impl Default for XHttpRequestOptions {
                 min: 1_000_000,
                 max: 1_000_000,
             },
-            post_interval_ms: IntegerRange { min: 30, max: 30 },
+            post_interval_ms: IntegerRange { min: 10, max: 10 },
+            post_interval_explicit: false,
         }
     }
 }
@@ -90,38 +93,41 @@ impl XHttpRequestOptions {
             return invalid("XHTTP generated content type conflicts with custom headers");
         }
         if mode != super::XHttpMode::PacketUp
-            && (raw.seq_key.is_some() || raw.seq_placement.is_some())
+            && (nonempty(raw.seq_key.as_deref()).is_some()
+                || nonempty(raw.seq_placement.as_deref()).is_some())
         {
             return invalid("XHTTP sequence overrides require packet-up");
         }
         let data = DataPlacement::normalize(raw)?;
         if mode != super::XHttpMode::PacketUp
             && (data != DataPlacement::Body
-                || raw.sc_max_each_post_bytes.is_some()
-                || raw.sc_min_posts_interval_ms.is_some())
+                || range_value(raw.sc_max_each_post_bytes.as_deref()).is_some()
+                || range_value(raw.sc_min_posts_interval_ms.as_deref()).is_some())
         {
             return invalid("XHTTP packet upload fields require packet-up");
         }
-        let post_bytes = IntegerRange::parse(
-            raw.sc_max_each_post_bytes.as_deref().unwrap_or("1000000"),
+        let post_bytes = IntegerRange::parse_with_default(
+            raw.sc_max_each_post_bytes.as_deref(),
+            "1000000",
             1,
             crate::limits::XHTTP_POST_BYTES,
         )?;
-        let post_interval_ms = IntegerRange::parse(
-            raw.sc_min_posts_interval_ms.as_deref().unwrap_or("30"),
+        let post_interval_ms = IntegerRange::parse_with_default(
+            raw.sc_min_posts_interval_ms.as_deref(),
+            "10",
             0,
             60_000,
         )?;
         if post_interval_ms.max == 0 {
             return invalid("XHTTP post interval must have a positive maximum");
         }
-        let uplink_method = match raw.uplink_http_method.as_deref().unwrap_or("POST") {
-            "POST" => http::Method::POST,
-            "PUT" => http::Method::PUT,
-            "PATCH" => http::Method::PATCH,
-            "DELETE" => http::Method::DELETE,
-            _ => return invalid("unsupported XHTTP uplink method"),
-        };
+        let uplink_method = nonempty(raw.uplink_http_method.as_deref())
+            .unwrap_or("POST")
+            .parse::<http::Method>()
+            .map_err(|_| crate::VoleError::InvalidConfig("invalid XHTTP uplink method".into()))?;
+        if matches!(uplink_method, http::Method::GET | http::Method::OPTIONS) {
+            return invalid("XHTTP download and preflight methods cannot carry upload data");
+        }
         let options = Self {
             no_grpc_header: raw.no_grpc_header,
             padding: XHttpPadding::normalize(raw, headers)?,
@@ -145,6 +151,7 @@ impl XHttpRequestOptions {
             data,
             post_bytes,
             post_interval_ms,
+            post_interval_explicit: range_value(raw.sc_min_posts_interval_ms.as_deref()).is_some(),
         };
         options.validate_headers(headers, &raw.path)?;
         Ok(options)
@@ -252,9 +259,11 @@ pub(crate) enum DataPlacement {
 
 impl DataPlacement {
     fn normalize(raw: &super::RawXHttpSettings) -> Result<Self> {
-        let placement = raw.uplink_data_placement.as_deref().unwrap_or("body");
+        let placement = nonempty(raw.uplink_data_placement.as_deref()).unwrap_or("body");
         if matches!(placement, "body" | "auto") {
-            if raw.uplink_data_key.is_some() || raw.uplink_chunk_size.is_some() {
+            if nonempty(raw.uplink_data_key.as_deref()).is_some()
+                || range_value(raw.uplink_chunk_size.as_deref()).is_some()
+            {
                 return invalid(
                     "XHTTP body upload does not use payload keys or header chunk sizes",
                 );
@@ -269,7 +278,7 @@ impl DataPlacement {
         };
         validate_key(key)?;
         let mut size =
-            IntegerRange::parse(raw.uplink_chunk_size.as_deref().unwrap_or("0"), 0, 8192)?;
+            IntegerRange::parse_with_default(raw.uplink_chunk_size.as_deref(), "0", 0, 8192)?;
         if size.max == 0 {
             size = if placement == "cookie" {
                 IntegerRange {
@@ -283,9 +292,8 @@ impl DataPlacement {
                 }
             };
         }
-        if size.min < 64 {
-            return invalid("XHTTP explicit header/cookie chunk size must be at least 64");
-        }
+        size.min = size.min.max(64);
+        size.max = size.max.max(size.min);
         Ok(Self::Chunks {
             key: key.clone(),
             cookie: placement == "cookie",
@@ -309,6 +317,8 @@ impl MetaPlacement {
         header_default: &str,
         other_default: &str,
     ) -> Result<Self> {
+        let placement = nonempty(placement);
+        let key = nonempty(key);
         match placement.unwrap_or("path") {
             "path" if key.is_none() => Ok(Self::Path),
             "query" | "cookie" => {
@@ -348,6 +358,7 @@ pub(crate) enum SessionId {
 
 impl SessionId {
     fn normalize(table: &str, length: Option<&str>) -> Result<Self> {
+        let length = range_value(length);
         if table.is_empty() || table == "uuid" {
             if length.is_some() {
                 return invalid("XHTTP session-length requires a character table");
@@ -377,7 +388,7 @@ impl SessionId {
                 bytes.push(byte);
             }
         }
-        let length = IntegerRange::parse(length.unwrap_or("16-32"), 1, 128)?;
+        let length = IntegerRange::parse_with_default(length, "16-32", 1, 128)?;
         let mut possibilities = 0u64;
         for n in length.min..=length.max {
             possibilities =
@@ -447,7 +458,7 @@ pub(super) struct RawReuseConfig {
 impl RawReuseConfig {
     pub(super) fn normalize(self, version: XHttpVersion) -> Result<XHttpReuseConfig> {
         let range = |value: Option<String>| {
-            IntegerRange::parse(value.as_deref().unwrap_or("0"), 0, i32::MAX as usize)
+            IntegerRange::parse_with_default(value.as_deref(), "0", 0, i32::MAX as usize)
         };
         if version == XHttpVersion::Http1 && self.h_keep_alive_period != 0 {
             return invalid("XHTTP HTTP/1 does not support a keepalive period override");
@@ -464,12 +475,23 @@ impl RawReuseConfig {
 }
 
 impl IntegerRange {
+    fn parse_with_default(
+        value: Option<&str>,
+        fallback: &str,
+        minimum: usize,
+        maximum: usize,
+    ) -> Result<Self> {
+        Self::parse(range_value(value).unwrap_or(fallback), minimum, maximum)
+    }
+
     pub(super) fn parse(value: &str, minimum: usize, maximum: usize) -> Result<Self> {
+        let value = value.trim();
         let (left, right) = value.split_once('-').unwrap_or((value, value));
-        if [left, right]
-            .iter()
-            .any(|part| part.is_empty() || !part.bytes().all(|b| b.is_ascii_digit()))
-        {
+        let (left, right) = (left.trim(), right.trim());
+        if [left, right].iter().any(|part| {
+            let decimal = part.strip_prefix('+').unwrap_or(part);
+            decimal.is_empty() || !decimal.bytes().all(|b| b.is_ascii_digit())
+        }) {
             return invalid("XHTTP range must be decimal N or N-M");
         }
         let (Ok(min), Ok(max)) = (left.parse::<usize>(), right.parse::<usize>()) else {
@@ -486,6 +508,14 @@ impl IntegerRange {
     }
 }
 
+fn nonempty(value: Option<&str>) -> Option<&str> {
+    value.filter(|value| !value.is_empty())
+}
+
+fn range_value(value: Option<&str>) -> Option<&str> {
+    value.filter(|value| !value.trim().is_empty())
+}
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub(crate) enum PaddingPlacement {
     QueryInHeader,
@@ -520,26 +550,22 @@ impl Default for XHttpPadding {
 
 impl XHttpPadding {
     pub(super) fn normalize(raw: &super::RawXHttpSettings, headers: &XHttpHeaders) -> Result<Self> {
-        let mut padding = Self::default();
-        if let Some(bytes) = &raw.x_padding_bytes {
-            padding.bytes = IntegerRange::parse(bytes, 1, MAX_PADDING_BYTES)?;
-        }
+        let mut padding = Self {
+            bytes: IntegerRange::parse_with_default(
+                raw.x_padding_bytes.as_deref(),
+                "100-1000",
+                1,
+                MAX_PADDING_BYTES,
+            )?,
+            ..Self::default()
+        };
         if !raw.x_padding_obfs_mode {
-            if raw
-                .x_padding_key
-                .as_deref()
-                .is_some_and(|value| value != "x_padding")
-                || raw
-                    .x_padding_header
-                    .as_deref()
+            if nonempty(raw.x_padding_key.as_deref()).is_some_and(|value| value != "x_padding")
+                || nonempty(raw.x_padding_header.as_deref())
                     .is_some_and(|value| !value.eq_ignore_ascii_case("referer"))
-                || raw
-                    .x_padding_placement
-                    .as_deref()
+                || nonempty(raw.x_padding_placement.as_deref())
                     .is_some_and(|value| value != "queryInHeader")
-                || raw
-                    .x_padding_method
-                    .as_deref()
+                || nonempty(raw.x_padding_method.as_deref())
                     .is_some_and(|value| value != "repeat-x")
             {
                 return invalid(
@@ -555,7 +581,7 @@ impl XHttpPadding {
             Some("cookie") => PaddingPlacement::Cookie,
             _ => return invalid("XHTTP obfuscated padding requires a supported placement"),
         };
-        padding.tokenish = match raw.x_padding_method.as_deref().unwrap_or("repeat-x") {
+        padding.tokenish = match nonempty(raw.x_padding_method.as_deref()).unwrap_or("repeat-x") {
             "repeat-x" => false,
             "tokenish" => true,
             _ => return invalid("unsupported XHTTP padding method"),
@@ -666,3 +692,30 @@ pub(super) fn reserved_header(name: &HeaderName) -> bool {
             | "referer"
     )
 }
+
+#[cfg(test)]
+mod request_compatibility_tests {
+    use super::*;
+
+    #[test]
+    fn custom_upload_method_and_small_chunks_keep_bounded_request_options() {
+        let raw = serde_json::from_value(serde_json::json!({
+            "uplink-http-method":"PROPFIND",
+            "uplink-data-placement":"header",
+            "uplink-data-key":"X-Payload",
+            "uplink-chunk-size":1
+        }))
+        .unwrap();
+        let options = XHttpRequestOptions::normalize(
+            &raw,
+            &XHttpHeaders::default(),
+            super::super::XHttpMode::PacketUp,
+        )
+        .unwrap();
+        assert_eq!(options.uplink_method.as_str(), "PROPFIND");
+        let DataPlacement::Chunks { size, .. } = options.data else {
+            panic!("chunks")
+        };
+        assert_eq!((size.min, size.max), (64, 64));
+    }
+}
diff --git a/src/config/yaml.rs b/src/config/yaml.rs
new file mode 100644
index 0000000..83e526b
--- /dev/null
+++ b/src/config/yaml.rs
@@ -0,0 +1,161 @@
+use std::fmt;
+
+use serde::de::{self, DeserializeSeed, MapAccess, SeqAccess, Visitor};
+use serde_yaml_ng::{Mapping, Value};
+
+use crate::{Result, VoleError};
+
+use super::MAX_CONFIG_BYTES;
+
+/// Charge aliases while they are expanded, before allocating their values.
+/// An input-size limit alone does not bound the materialized YAML tree.
+pub(crate) fn parse(input: &[u8]) -> Result<Value> {
+    parse_with_budget(input, &mut (MAX_CONFIG_BYTES * 4))
+}
+
+pub(crate) fn parse_with_budget(input: &[u8], budget: &mut usize) -> Result<Value> {
+    if input.len() > MAX_CONFIG_BYTES {
+        return Err(VoleError::InvalidConfig(format!(
+            "configuration exceeds the {MAX_CONFIG_BYTES}-byte limit"
+        )));
+    }
+    let mut documents = serde_yaml_ng::Deserializer::from_slice(input);
+    let document = documents.next().ok_or_else(|| {
+        VoleError::InvalidConfig("configuration must contain one YAML document".into())
+    })?;
+    let mut value = BoundedValue { budget, depth: 0 }
+        .deserialize(document)
+        .map_err(|error| VoleError::InvalidConfig(error.to_string()))?;
+    if documents.next().is_some() {
+        return Err(VoleError::InvalidConfig(
+            "configuration must contain one YAML document".into(),
+        ));
+    }
+    merge(&mut value)?;
+    Ok(value)
+}
+
+struct BoundedValue<'a> {
+    budget: &'a mut usize,
+    depth: usize,
+}
+
+impl BoundedValue<'_> {
+    fn charge<E: de::Error>(&mut self, bytes: usize) -> std::result::Result<(), E> {
+        *self.budget = self
+            .budget
+            .checked_sub(bytes)
+            .ok_or_else(|| E::custom("expanded YAML exceeds the configuration memory limit"))?;
+        Ok(())
+    }
+}
+
+impl<'de> DeserializeSeed<'de> for BoundedValue<'_> {
+    type Value = Value;
+
+    fn deserialize<D: de::Deserializer<'de>>(
+        mut self,
+        deserializer: D,
+    ) -> std::result::Result<Value, D::Error> {
+        if self.depth > 64 {
+            return Err(de::Error::custom("YAML nesting exceeds 64 levels"));
+        }
+        self.charge::<D::Error>(64)?;
+        deserializer.deserialize_any(self)
+    }
+}
+
+impl<'de> Visitor<'de> for BoundedValue<'_> {
+    type Value = Value;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("YAML data without custom tags")
+    }
+
+    fn visit_unit<E: de::Error>(self) -> std::result::Result<Value, E> {
+        Ok(Value::Null)
+    }
+    fn visit_none<E: de::Error>(self) -> std::result::Result<Value, E> {
+        Ok(Value::Null)
+    }
+    fn visit_bool<E: de::Error>(self, value: bool) -> std::result::Result<Value, E> {
+        Ok(Value::Bool(value))
+    }
+    fn visit_i64<E: de::Error>(self, value: i64) -> std::result::Result<Value, E> {
+        Ok(Value::Number(value.into()))
+    }
+    fn visit_u64<E: de::Error>(self, value: u64) -> std::result::Result<Value, E> {
+        Ok(Value::Number(value.into()))
+    }
+    fn visit_f64<E: de::Error>(self, value: f64) -> std::result::Result<Value, E> {
+        Ok(Value::Number(value.into()))
+    }
+    fn visit_str<E: de::Error>(mut self, value: &str) -> std::result::Result<Value, E> {
+        self.charge::<E>(value.len())?;
+        Ok(Value::String(value.to_owned()))
+    }
+    fn visit_string<E: de::Error>(mut self, value: String) -> std::result::Result<Value, E> {
+        self.charge::<E>(value.len())?;
+        Ok(Value::String(value))
+    }
+    fn visit_seq<A: SeqAccess<'de>>(self, mut sequence: A) -> std::result::Result<Value, A::Error> {
+        let mut values = Vec::new();
+        while let Some(value) = sequence.next_element_seed(BoundedValue {
+            budget: self.budget,
+            depth: self.depth + 1,
+        })? {
+            values.push(value);
+        }
+        Ok(Value::Sequence(values))
+    }
+    fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> std::result::Result<Value, A::Error> {
+        let mut values = Mapping::new();
+        while let Some(key) = map.next_key_seed(BoundedValue {
+            budget: self.budget,
+            depth: self.depth + 1,
+        })? {
+            if !matches!(key, Value::String(_)) {
+                return Err(de::Error::custom("YAML map keys must be strings"));
+            }
+            let value = map.next_value_seed(BoundedValue {
+                budget: self.budget,
+                depth: self.depth + 1,
+            })?;
+            if values.insert(key, value).is_some() {
+                return Err(de::Error::custom("duplicate YAML map key"));
+            }
+        }
+        Ok(Value::Mapping(values))
+    }
+}
+
+fn merge(value: &mut Value) -> Result<()> {
+    match value {
+        Value::Sequence(values) => {
+            for value in values {
+                merge(value)?;
+            }
+        }
+        Value::Mapping(mapping) => {
+            for value in mapping.values_mut() {
+                merge(value)?;
+            }
+            if let Some(source) = mapping.remove("<<") {
+                let sources = match source {
+                    Value::Sequence(values) => values,
+                    source => vec![source],
+                };
+                for source in sources {
+                    let Value::Mapping(source) = source else {
+                        return Err(VoleError::InvalidConfig("YAML merge requires maps".into()));
+                    };
+                    for (key, value) in source {
+                        mapping.entry(key).or_insert(value);
+                    }
+                }
+            }
+        }
+        _ => {}
+    }
+    Ok(())
+}
diff --git a/src/connections.rs b/src/connections.rs
new file mode 100644
index 0000000..2ac3707
--- /dev/null
+++ b/src/connections.rs
@@ -0,0 +1,649 @@
+//! Running-session connection ownership and opt-in Controller snapshots.
+use crate::dispatch::{BoxStream, DispatchError};
+use serde::{
+    Serialize, Serializer,
+    ser::{SerializeSeq, SerializeStruct},
+};
+use std::{
+    collections::{BTreeMap, VecDeque},
+    future::Future,
+    io,
+    net::{IpAddr, SocketAddr},
+    pin::Pin,
+    sync::{
+        Arc, Mutex, Weak,
+        atomic::{AtomicBool, AtomicU64, Ordering},
+    },
+    task::{Context, Poll},
+};
+use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+use tokio_util::sync::CancellationToken;
+
+/// Only owned presentation data is retained, never its resource generation.
+pub(crate) struct ConnectionInfo {
+    pub metadata: ConnectionMetadata,
+    pub chains: Vec<Arc<str>>,
+    pub provider_chains: Vec<Arc<str>>,
+    pub rule: &'static str,
+    pub rule_payload: Arc<str>,
+    pub dns_path: Vec<&'static str>,
+}
+pub(crate) struct ConnectionMetadata {
+    pub network: &'static str,
+    pub inbound_type: &'static str,
+    pub source: SocketAddr,
+    pub destination_ip: Option<IpAddr>,
+    pub destination_port: u16,
+    pub host: Arc<str>,
+    pub dns_mode: &'static str,
+    pub sniff_host: Arc<str>,
+    pub(crate) process: crate::process::Identity,
+    // Retains immutable original facts for current-flow consumers; no config.
+    pub(crate) original: Option<Arc<crate::session::InboundSnapshot>>,
+}
+impl Serialize for ConnectionMetadata {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        let mut state = serializer.serialize_struct("ConnectionMetadata", 12)?;
+        state.serialize_field("network", self.network)?;
+        state.serialize_field("type", self.inbound_type)?;
+        state.serialize_field("sourceIP", &self.source.ip())?;
+        state.serialize_field("sourcePort", &Port(self.source.port()))?;
+        let destination_ip = self.destination_ip.or_else(|| {
+            self.original
+                .as_ref()
+                .and_then(|origin| match &origin.destination {
+                    crate::session::Destination::Ip(address) => Some(address.ip()),
+                    _ => None,
+                })
+        });
+        state.serialize_field("destinationIP", &destination_ip)?;
+        state.serialize_field("destinationPort", &Port(self.destination_port))?;
+        state.serialize_field("host", self.host.as_ref())?;
+        state.serialize_field("dnsMode", self.dns_mode)?;
+        state.serialize_field("sniffHost", self.sniff_host.as_ref())?;
+        state.serialize_field("uid", &self.process.uid.unwrap_or(0))?;
+        state.serialize_field("process", self.process.name.as_deref().unwrap_or_default())?;
+        state.serialize_field(
+            "processPath",
+            self.process.path.as_deref().unwrap_or_default(),
+        )?;
+        state.end()
+    }
+}
+struct Port(u16);
+impl Serialize for Port {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        serializer.collect_str(&self.0)
+    }
+}
+struct Details {
+    metadata: ConnectionMetadata,
+    chains: Box<[Arc<str>]>,
+    provider_chains: Box<[Arc<str>]>,
+    rule: &'static str,
+    rule_payload: Arc<str>,
+}
+impl Details {
+    fn serialize_fields<S: SerializeStruct>(
+        &self,
+        state: &mut S,
+        dns_path: &[&'static str],
+    ) -> Result<(), S::Error> {
+        state.serialize_field("metadata", &self.metadata)?;
+        state.serialize_field("chains", &SharedSlice(&self.chains))?;
+        state.serialize_field("providerChains", &SharedSlice(&self.provider_chains))?;
+        state.serialize_field("rule", self.rule)?;
+        state.serialize_field("rulePayload", self.rule_payload.as_ref())?;
+        state.serialize_field("dnsPath", dns_path)
+    }
+}
+#[derive(Default)]
+struct SessionCounters {
+    upload: AtomicU64,
+    download: AtomicU64,
+}
+#[derive(Default)]
+pub(crate) struct Registry {
+    entries: Mutex<BTreeMap<uuid::Uuid, Arc<Entry>>>,
+    failures: Mutex<VecDeque<Arc<Failure>>>,
+    totals: Arc<SessionCounters>,
+    closed: AtomicBool,
+}
+struct Entry {
+    id: uuid::Uuid,
+    details: Arc<Details>,
+    dns_path: Mutex<Arc<[&'static str]>>,
+    start: Timestamp,
+    upload: AtomicU64,
+    download: AtomicU64,
+    cancel: CancellationToken,
+}
+struct ConnectionSnapshot {
+    id: uuid::Uuid,
+    details: Arc<Details>,
+    dns_path: Arc<[&'static str]>,
+    start: Timestamp,
+    upload: u64,
+    download: u64,
+}
+impl ConnectionSnapshot {
+    fn capture(entry: &Entry) -> Self {
+        Self {
+            id: entry.id,
+            details: entry.details.clone(),
+            dns_path: entry.dns_path.lock().unwrap().clone(),
+            start: entry.start,
+            upload: entry.upload.load(Ordering::Relaxed),
+            download: entry.download.load(Ordering::Relaxed),
+        }
+    }
+}
+impl Serialize for ConnectionSnapshot {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        let mut state = serializer.serialize_struct("Connection", 10)?;
+        self.details.serialize_fields(&mut state, &self.dns_path)?;
+        state.serialize_field("id", &self.id)?;
+        state.serialize_field("start", &self.start)?;
+        state.serialize_field("upload", &self.upload)?;
+        state.serialize_field("download", &self.download)?;
+        state.end()
+    }
+}
+struct Failure {
+    id: uuid::Uuid,
+    details: Arc<Details>,
+    dns_path: Arc<[&'static str]>,
+    time: Timestamp,
+    error: &'static str,
+}
+impl Serialize for Failure {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        let mut state = serializer.serialize_struct("ConnectionFailure", 9)?;
+        self.details.serialize_fields(&mut state, &self.dns_path)?;
+        state.serialize_field("id", &self.id)?;
+        state.serialize_field("time", &self.time)?;
+        state.serialize_field("error", self.error)?;
+        state.end()
+    }
+}
+/// The query freezes values outside the registry lock and shares immutable text.
+/// It can outlive removal without extending transport/cancellation ownership.
+pub(crate) struct Snapshot {
+    connections: Vec<ConnectionSnapshot>,
+    failures: Vec<Arc<Failure>>,
+    memory: Option<u64>,
+    upload: u64,
+    download: u64,
+}
+impl Serialize for Snapshot {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        let mut state = serializer.serialize_struct("Connections", 5)?;
+        state.serialize_field("uploadTotal", &self.upload)?;
+        state.serialize_field("downloadTotal", &self.download)?;
+        state.serialize_field("connections", &self.connections)?;
+        state.serialize_field("memory", &self.memory)?;
+        state.serialize_field("errors", &SharedSlice(&self.failures))?;
+        state.end()
+    }
+}
+struct SharedSlice<'a, T: ?Sized>(&'a [Arc<T>]);
+impl<T: Serialize + ?Sized> Serialize for SharedSlice<'_, T> {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        let mut sequence = serializer.serialize_seq(Some(self.0.len()))?;
+        for item in self.0 {
+            sequence.serialize_element(item.as_ref())?;
+        }
+        sequence.end()
+    }
+}
+pub(crate) struct Connection {
+    entry: Arc<Entry>,
+    totals: Arc<SessionCounters>,
+    registry: Weak<Registry>,
+    business_totals: bool,
+}
+impl Registry {
+    pub fn open(self: &Arc<Self>, info: ConnectionInfo) -> Connection {
+        self.open_counted(info, true)
+    }
+    #[cfg(feature = "sing-mux")]
+    pub(crate) fn open_inner(self: &Arc<Self>, info: ConnectionInfo) -> Connection {
+        self.open_counted(info, false)
+    }
+    fn open_counted(self: &Arc<Self>, info: ConnectionInfo, business_totals: bool) -> Connection {
+        let entry = Arc::new(Entry {
+            id: uuid::Builder::from_random_bytes(rand::random()).into_uuid(),
+            details: Arc::new(Details {
+                metadata: info.metadata,
+                chains: info.chains.into_boxed_slice(),
+                provider_chains: info.provider_chains.into_boxed_slice(),
+                rule: info.rule,
+                rule_payload: info.rule_payload,
+            }),
+            dns_path: Mutex::new(info.dns_path.into()),
+            start: Timestamp::now(),
+            upload: AtomicU64::new(0),
+            download: AtomicU64::new(0),
+            cancel: CancellationToken::new(),
+        });
+        let mut entries = self.entries.lock().unwrap();
+        if self.closed.load(Ordering::Acquire) {
+            entry.cancel.cancel();
+        } else {
+            entries.insert(entry.id, entry.clone());
+        }
+        Connection {
+            entry,
+            totals: self.totals.clone(),
+            registry: Arc::downgrade(self),
+            business_totals,
+        }
+    }
+    pub(crate) fn totals(&self) -> (u64, u64) {
+        (
+            self.totals.upload.load(Ordering::Relaxed),
+            self.totals.download.load(Ordering::Relaxed),
+        )
+    }
+    pub(crate) fn snapshot_bounded(&self, limit: usize) -> Option<Snapshot> {
+        let entries = {
+            let entries = self.entries.lock().unwrap();
+            if entries.len() > limit {
+                return None;
+            }
+            entries.values().cloned().collect::<Vec<_>>()
+        };
+        Some(self.capture(entries))
+    }
+    pub fn snapshot(&self) -> Snapshot {
+        let entries = self
+            .entries
+            .lock()
+            .unwrap()
+            .values()
+            .cloned()
+            .collect::<Vec<_>>();
+        self.capture(entries)
+    }
+    fn capture(&self, entries: Vec<Arc<Entry>>) -> Snapshot {
+        let connections = entries
+            .into_iter()
+            .map(|entry| ConnectionSnapshot::capture(&entry))
+            .collect();
+        let failures = self.failures.lock().unwrap().iter().cloned().collect();
+        Snapshot {
+            connections,
+            failures,
+            memory: crate::memory::resident_bytes(),
+            upload: self.totals.upload.load(Ordering::Relaxed),
+            download: self.totals.download.load(Ordering::Relaxed),
+        }
+    }
+    pub fn close(&self, id: &str) {
+        let Ok(parsed) = uuid::Uuid::parse_str(id) else {
+            return;
+        };
+        // Preserve exact canonical IDs: noncanonical spellings remain unknown.
+        if parsed
+            .hyphenated()
+            .encode_lower(&mut uuid::Uuid::encode_buffer())
+            != id
+        {
+            return;
+        }
+        let entry = self.entries.lock().unwrap().remove(&parsed);
+        if let Some(entry) = entry {
+            entry.cancel.cancel();
+        }
+    }
+    pub fn close_all(&self) {
+        let entries = std::mem::take(&mut *self.entries.lock().unwrap());
+        for entry in entries.into_values() {
+            entry.cancel.cancel();
+        }
+    }
+    pub fn shutdown(&self) {
+        self.closed.store(true, Ordering::Release);
+        self.close_all();
+    }
+}
+impl Connection {
+    pub fn dns_path(&self, path: Vec<&'static str>) {
+        *self.entry.dns_path.lock().unwrap() = path.into();
+    }
+    pub fn token(&self) -> CancellationToken {
+        self.entry.cancel.clone()
+    }
+    pub fn cancelled(&self) -> bool {
+        self.entry.cancel.is_cancelled()
+    }
+    pub fn upload(&self, bytes: usize) {
+        if bytes == 0 {
+            return;
+        }
+        saturating_add(&self.entry.upload, bytes);
+        if self.business_totals {
+            saturating_add(&self.totals.upload, bytes);
+        }
+    }
+    pub fn download(&self, bytes: usize) {
+        if bytes == 0 {
+            return;
+        }
+        saturating_add(&self.entry.download, bytes);
+        if self.business_totals {
+            saturating_add(&self.totals.download, bytes);
+        }
+    }
+    pub fn failed(&self, error: &DispatchError) {
+        let Some(registry) = self.registry.upgrade() else {
+            return;
+        };
+        let kind = match error {
+            DispatchError::NotAllowed => "not_allowed",
+            DispatchError::TimedOut => "timed_out",
+            DispatchError::HostUnreachable => "host_unreachable",
+            DispatchError::NetworkUnreachable => "network_unreachable",
+            _ => "outbound_failed",
+        };
+        let failure = Arc::new(Failure {
+            id: self.entry.id,
+            details: self.entry.details.clone(),
+            dns_path: self.entry.dns_path.lock().unwrap().clone(),
+            time: Timestamp::now(),
+            error: kind,
+        });
+        let mut failures = registry.failures.lock().unwrap();
+        if failures.len() == 32 {
+            failures.pop_front();
+        }
+        failures.push_back(failure);
+    }
+    pub fn stream(self, inner: BoxStream) -> BoxStream {
+        let cancelled = Box::pin(self.token().cancelled_owned());
+        Box::new(TrackedStream {
+            connection: self,
+            inner: Some(inner),
+            cancelled,
+        })
+    }
+}
+impl Drop for Connection {
+    fn drop(&mut self) {
+        if let Some(registry) = self.registry.upgrade() {
+            registry.entries.lock().unwrap().remove(&self.entry.id);
+        }
+    }
+}
+fn saturating_add(counter: &AtomicU64, bytes: usize) {
+    let mut old = counter.load(Ordering::Relaxed);
+    while let Err(value) = counter.compare_exchange_weak(
+        old,
+        old.saturating_add(bytes as u64),
+        Ordering::Relaxed,
+        Ordering::Relaxed,
+    ) {
+        old = value;
+    }
+}
+#[derive(Clone, Copy)]
+struct Timestamp(i128);
+impl Timestamp {
+    fn now() -> Self {
+        Self(time::OffsetDateTime::now_utc().unix_timestamp_nanos())
+    }
+    fn format(&self) -> String {
+        time::OffsetDateTime::from_unix_timestamp_nanos(self.0)
+            .expect("recorded UTC date")
+            .format(&time::format_description::well_known::Rfc3339)
+            .expect("recorded UTC date")
+    }
+}
+impl Serialize for Timestamp {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        serializer.serialize_str(&self.format())
+    }
+}
+struct TrackedStream {
+    connection: Connection,
+    inner: Option<BoxStream>,
+    cancelled: Pin<Box<tokio_util::sync::WaitForCancellationFutureOwned>>,
+}
+impl TrackedStream {
+    fn closed(&mut self, cx: &mut Context<'_>) -> bool {
+        if self.cancelled.as_mut().poll(cx).is_ready() {
+            self.inner.take();
+        }
+        self.inner.is_none()
+    }
+}
+fn closed_error() -> io::Error {
+    io::Error::new(io::ErrorKind::ConnectionAborted, "connection closed")
+}
+impl AsyncRead for TrackedStream {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buffer: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        if self.closed(cx) {
+            return Poll::Ready(Err(closed_error()));
+        }
+        let before = buffer.filled().len();
+        let result = Pin::new(self.inner.as_mut().expect("open stream")).poll_read(cx, buffer);
+        self.connection.download(buffer.filled().len() - before);
+        result
+    }
+}
+impl AsyncWrite for TrackedStream {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        bytes: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        if self.closed(cx) {
+            return Poll::Ready(Err(closed_error()));
+        }
+        let result = Pin::new(self.inner.as_mut().expect("open stream")).poll_write(cx, bytes);
+        if let Poll::Ready(Ok(n)) = &result {
+            self.connection.upload(*n);
+        }
+        result
+    }
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        if self.closed(cx) {
+            return Poll::Ready(Err(closed_error()));
+        }
+        Pin::new(self.inner.as_mut().expect("open stream")).poll_flush(cx)
+    }
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        if self.closed(cx) {
+            return Poll::Ready(Ok(()));
+        }
+        Pin::new(self.inner.as_mut().expect("open stream")).poll_shutdown(cx)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::{Value, json};
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+    fn info() -> ConnectionInfo {
+        ConnectionInfo {
+            metadata: ConnectionMetadata {
+                network: "tcp",
+                inbound_type: "Socks5",
+                source: "127.0.0.1:1234".parse().unwrap(),
+                destination_ip: Some("198.51.100.1".parse().unwrap()),
+                destination_port: 443,
+                host: "example.com".into(),
+                dns_mode: "normal",
+                sniff_host: "".into(),
+                process: Default::default(),
+                original: None,
+            },
+            chains: vec!["edge".into(), "auto".into()],
+            provider_chains: vec!["nodes".into()],
+            rule: "DomainSuffix",
+            rule_payload: "example.com".into(),
+            dns_path: vec!["cache"],
+        }
+    }
+    fn view(registry: &Registry) -> Value {
+        serde_json::to_value(registry.snapshot()).unwrap()
+    }
+    #[tokio::test]
+    async fn connection_query_counts_and_close_wakes_blocked_io() {
+        let registry = Arc::new(Registry::default());
+        let connection = registry.open(info());
+        let id = connection.entry.id.to_string();
+        let (client, mut peer) = tokio::io::duplex(32);
+        let mut stream = connection.stream(Box::new(client));
+        stream.write_all(b"sent").await.unwrap();
+        peer.write_all(b"ok").await.unwrap();
+        assert_eq!(stream.read_u16().await.unwrap(), u16::from_be_bytes(*b"ok"));
+        let snapshot = view(&registry);
+        assert_eq!(snapshot["connections"][0]["upload"], 4);
+        assert_eq!(snapshot["connections"][0]["download"], 2);
+        assert_eq!(
+            snapshot["connections"][0]["chains"],
+            json!(["edge", "auto"])
+        );
+        assert_eq!(snapshot["connections"][0]["metadata"]["sourcePort"], "1234");
+        assert_eq!(
+            snapshot["connections"][0]["metadata"]["destinationPort"],
+            "443"
+        );
+        let waiting = tokio::spawn(async move { stream.read_u8().await });
+        tokio::task::yield_now().await;
+        registry.close(&id);
+        assert_eq!(
+            waiting.await.unwrap().unwrap_err().kind(),
+            io::ErrorKind::ConnectionAborted
+        );
+        assert!(
+            view(&registry)["connections"]
+                .as_array()
+                .unwrap()
+                .is_empty()
+        );
+        assert_eq!(view(&registry)["uploadTotal"], 4);
+        registry.shutdown();
+        assert!(registry.open(info()).cancelled());
+    }
+
+    #[test]
+    fn query_snapshot_freezes_counters_and_dns_path_before_later_io() {
+        let registry = Arc::new(Registry::default());
+        let connection = registry.open(info());
+        connection.upload(3);
+        connection.download(5);
+        let snapshot = registry.snapshot();
+        let before = serde_json::to_value(&snapshot).unwrap();
+        connection.upload(7);
+        connection.download(11);
+        connection.dns_path(vec!["fallback"]);
+        connection.failed(&DispatchError::TimedOut);
+        let after = serde_json::to_value(&snapshot).unwrap();
+        assert_eq!(after, before, "query data must not change after capture");
+        assert_eq!(after["connections"][0]["upload"], 3);
+        assert_eq!(after["connections"][0]["download"], 5);
+        assert_eq!(after["connections"][0]["dnsPath"], json!(["cache"]));
+        assert_eq!(after["uploadTotal"], 3);
+        assert!(after["errors"].as_array().unwrap().is_empty());
+        assert_eq!(view(&registry)["uploadTotal"], 10);
+        assert_eq!(view(&registry)["downloadTotal"], 16);
+    }
+
+    #[test]
+    fn snapshot_shares_metadata_without_holding_registry_or_live_connection() {
+        let registry = Arc::new(Registry::default());
+        let connection = registry.open(info());
+        let details = Arc::downgrade(&connection.entry.details);
+        let entry = Arc::downgrade(&connection.entry);
+        let snapshot = registry.snapshot();
+        assert!(Arc::ptr_eq(
+            &snapshot.connections[0].details,
+            &connection.entry.details
+        ));
+        registry.close_all();
+        assert!(connection.cancelled());
+        drop(connection);
+        assert!(
+            entry.upgrade().is_none(),
+            "a query must release the I/O cancellation owner"
+        );
+        assert!(
+            view(&registry)["connections"]
+                .as_array()
+                .unwrap()
+                .is_empty()
+        );
+        let weak_registry = Arc::downgrade(&registry);
+        drop(registry);
+        assert!(weak_registry.upgrade().is_none());
+        assert_eq!(
+            serde_json::to_value(&snapshot).unwrap()["connections"][0]["chains"],
+            json!(["edge", "auto"])
+        );
+        drop(snapshot);
+        assert!(details.upgrade().is_none());
+    }
+
+    #[test]
+    fn exact_counters_saturate_and_outlive_registry_without_io_weak_upgrade() {
+        let registry = Arc::new(Registry::default());
+        let connection = registry.open(info());
+        connection.upload(0);
+        connection.download(0);
+        assert_eq!(view(&registry)["uploadTotal"], 0);
+        std::thread::scope(|scope| {
+            for _ in 0..6 {
+                scope.spawn(|| {
+                    for _ in 0..1_000 {
+                        connection.upload(1);
+                        connection.download(2);
+                    }
+                });
+            }
+        });
+        assert_eq!(view(&registry)["uploadTotal"], 6_000);
+        assert_eq!(view(&registry)["downloadTotal"], 12_000);
+        assert_eq!(connection.entry.upload.load(Ordering::Relaxed), 6_000);
+        assert_eq!(connection.entry.download.load(Ordering::Relaxed), 12_000);
+        connection
+            .entry
+            .upload
+            .store(u64::MAX - 1, Ordering::Relaxed);
+        registry
+            .totals
+            .upload
+            .store(u64::MAX - 1, Ordering::Relaxed);
+        connection.upload(4);
+        assert_eq!(connection.entry.upload.load(Ordering::Relaxed), u64::MAX);
+        assert_eq!(view(&registry)["uploadTotal"], u64::MAX);
+        let totals = registry.totals.clone();
+        drop(registry);
+        connection.download(7);
+        assert_eq!(totals.download.load(Ordering::Relaxed), 12_007);
+    }
+
+    #[test]
+    fn failure_history_is_bounded_and_keeps_its_dns_path_after_connection_updates() {
+        let registry = Arc::new(Registry::default());
+        let connection = registry.open(info());
+        for _ in 0..33 {
+            connection.failed(&DispatchError::TimedOut);
+        }
+        connection.dns_path(vec!["fallback"]);
+        let snapshot = view(&registry);
+        assert_eq!(snapshot["errors"].as_array().unwrap().len(), 32);
+        assert_eq!(snapshot["errors"][0]["error"], "timed_out");
+        assert_eq!(snapshot["errors"][0]["dnsPath"], json!(["cache"]));
+        assert_eq!(snapshot["connections"][0]["dnsPath"], json!(["fallback"]));
+        assert!(snapshot["errors"][0].get("start").is_none());
+        assert!(snapshot["errors"][0].get("upload").is_none());
+    }
+}
diff --git a/src/controller.rs b/src/controller.rs
index b3070ef..3e6dd7c 100644
--- a/src/controller.rs
+++ b/src/controller.rs
@@ -1,16 +1,31 @@
 use std::{io, net::SocketAddr, sync::Arc, time::Duration};
 
+#[cfg(any(feature = "invoke", test))]
+mod configs;
+mod cors;
+mod dns;
+mod rules;
+mod tls;
+mod transport;
+#[cfg(target_os = "linux")]
+mod unix;
+mod websocket;
+use transport::{ControllerIo, H1Io};
+
+#[cfg(test)]
+#[path = "controller/tests_secure.rs"]
+mod secure_tests;
+
 use serde::{Deserialize, Serialize};
-use tokio::{
-    io::{AsyncReadExt, AsyncWriteExt},
-    net::{TcpListener, TcpStream},
-    task::JoinSet,
-    time::timeout,
-};
+use socket2::{Domain, Protocol, Socket, Type};
+use tokio::{io::AsyncReadExt, net::TcpListener, task::JoinSet, time::timeout};
 use tokio_util::sync::CancellationToken;
 
+#[cfg(test)]
+use tokio::{io::AsyncWriteExt, net::TcpStream};
+
 use crate::{
-    config::{ExternalControllerConfig, MAX_CONTROLLER_SECRET_BYTES, validate_route_target_name},
+    config::{ExternalControllerConfig, validate_route_target_name},
     routing::{ProxyGroupError, ProxyGroupState, ProxyGroups},
     traffic::TunTrafficStats,
 };
@@ -20,102 +35,276 @@ const CONTROLLER_BODY_TIMEOUT: Duration = Duration::from_secs(5);
 const MAX_CONTROLLER_CONNECTIONS: usize = 8;
 const MAX_CONTROLLER_BODY_BYTES: usize = 1024;
 
-pub(crate) struct RuntimeController {
-    listener: TcpListener,
+#[derive(Clone)]
+struct RequestContext {
     secret: Option<Arc<str>>,
     traffic: Option<Arc<TunTrafficStats>>,
     proxy_groups: Arc<ProxyGroups>,
+    resources: Option<Arc<dyn crate::resource::control::RuntimeResources>>,
+    cors: Arc<cors::Policy>,
+    requests: tokio_util::task::TaskTracker,
+    subscriptions: Arc<tokio::sync::Semaphore>,
+    logs: Option<Arc<crate::logging::RuntimeLog>>,
+}
+
+#[cfg(any(target_os = "linux", test))]
+impl RequestContext {
+    fn for_local_transport(&self) -> Self {
+        Self {
+            secret: None,
+            ..self.clone()
+        }
+    }
+}
+
+enum AcceptedController {
+    Http(tokio::net::TcpStream),
+    Tls(tokio::net::TcpStream),
+    #[cfg(target_os = "linux")]
+    Unix(tokio::net::UnixStream),
+}
+
+pub(crate) struct RuntimeController {
+    #[cfg(target_os = "linux")]
+    unix_listener: Option<unix::Listener>,
+    listener: Option<TcpListener>,
+    tls_listener: Option<TcpListener>,
+    tls: Option<Arc<tls::ServerTls>>,
+    routing_mark: u32,
+    context: RequestContext,
 }
 
 impl std::fmt::Debug for RuntimeController {
     fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         formatter
             .debug_struct("RuntimeController")
-            .field("local_addr", &self.listener.local_addr().ok())
-            .field("authenticated", &self.secret.is_some())
-            .field("has_traffic", &self.traffic.is_some())
+            .field("authenticated", &self.context.secret.is_some())
+            .field("https", &self.tls.is_some())
             .finish_non_exhaustive()
     }
 }
 
 impl RuntimeController {
+    #[cfg(test)]
     pub(crate) async fn bind(
         config: &ExternalControllerConfig,
         traffic: Option<Arc<TunTrafficStats>>,
         proxy_groups: Arc<ProxyGroups>,
     ) -> io::Result<Self> {
+        Self::bind_at(config, traffic, proxy_groups, std::path::Path::new(".")).await
+    }
+
+    pub(crate) async fn bind_at(
+        config: &ExternalControllerConfig,
+        traffic: Option<Arc<TunTrafficStats>>,
+        proxy_groups: Arc<ProxyGroups>,
+        root: &std::path::Path,
+    ) -> io::Result<Self> {
+        #[cfg(not(target_os = "linux"))]
+        if config.unix_path.is_some() {
+            return Err(io::Error::new(
+                io::ErrorKind::Unsupported,
+                "external-controller-unix requires Linux",
+            ));
+        }
+        #[cfg(target_os = "linux")]
+        let unix_listener = config
+            .unix_path
+            .as_deref()
+            .map(|path| unix::Listener::bind(path, root))
+            .transpose()?;
+        let listener = config
+            .http_enabled
+            .then(|| bind_controller(config))
+            .transpose()?;
+        let (tls_listener, tls) = if let Some(listen) = config.tls_listen {
+            let tls_options = config.server_tls.clone();
+            let root = root.to_owned();
+            let tls =
+                tokio::task::spawn_blocking(move || tls::ServerTls::load(&tls_options, &root))
+                    .await
+                    .map_err(io::Error::other)??;
+            let listener = bind_controller(&ExternalControllerConfig {
+                listen,
+                routing_mark: config.routing_mark,
+                ..ExternalControllerConfig::default()
+            })?;
+            (Some(listener), Some(Arc::new(tls)))
+        } else {
+            (None, None)
+        };
         Ok(Self {
-            listener: TcpListener::bind(config.listen).await?,
-            secret: config.secret.as_deref().map(Arc::from),
-            traffic,
-            proxy_groups,
+            #[cfg(target_os = "linux")]
+            unix_listener,
+            listener,
+            tls_listener,
+            tls,
+            routing_mark: config.routing_mark,
+            context: RequestContext {
+                secret: config.secret.as_deref().map(Arc::from),
+                traffic,
+                proxy_groups,
+                resources: None,
+                cors: Arc::new(cors::Policy::new(&config.cors)),
+                requests: tokio_util::task::TaskTracker::new(),
+                subscriptions: Arc::new(tokio::sync::Semaphore::new(websocket::MAX_SUBSCRIPTIONS)),
+                logs: crate::logging::current(),
+            },
         })
     }
 
+    pub(crate) fn with_resources(
+        mut self,
+        resources: Option<Arc<dyn crate::resource::control::RuntimeResources>>,
+    ) -> Self {
+        self.context.resources = resources;
+        self
+    }
+
     #[cfg(test)]
     pub(crate) fn local_addr(&self) -> io::Result<SocketAddr> {
-        self.listener.local_addr()
+        self.listener
+            .as_ref()
+            .or(self.tls_listener.as_ref())
+            .expect("controller listener")
+            .local_addr()
+    }
+
+    async fn accept(&self) -> io::Result<AcceptedController> {
+        let network = async {
+            tokio::select! {
+                accepted = async { self.listener.as_ref().unwrap().accept().await }, if self.listener.is_some() => {
+                    accepted.and_then(|(stream, _)| mark_accepted_tcp(stream, self.routing_mark)).map(AcceptedController::Http)
+                }
+                accepted = async { self.tls_listener.as_ref().unwrap().accept().await }, if self.tls_listener.is_some() => {
+                    accepted.and_then(|(stream, _)| mark_accepted_tcp(stream, self.routing_mark)).map(AcceptedController::Tls)
+                }
+                else => std::future::pending().await,
+            }
+        };
+        #[cfg(target_os = "linux")]
+        if let Some(listener) = &self.unix_listener {
+            return tokio::select! {
+                result = network => result,
+                result = listener.accept() => result.map(AcceptedController::Unix),
+            };
+        }
+        network.await
     }
 
     pub(crate) async fn serve(self, cancellation: CancellationToken) -> io::Result<()> {
+        let watcher = self
+            .tls
+            .as_ref()
+            .filter(|tls| tls.watches_files())
+            .map(|tls| {
+                let tls = tls.clone();
+                let child = cancellation.clone();
+                tokio::spawn(crate::resources::observation::task(tls.watch(child)))
+            });
         let mut tasks = JoinSet::new();
-        loop {
-            tokio::select! {
-                biased;
-                () = cancellation.cancelled() => break,
+        let result = loop {
+            tokio::select! { biased;
+                () = cancellation.cancelled() => break Ok(()),
                 joined = tasks.join_next(), if !tasks.is_empty() => {
-                    if let Some(Err(error)) = joined {
-                        tracing::warn!(
-                            cancelled = error.is_cancelled(),
-                            panicked = error.is_panic(),
-                            "controller connection task failed"
-                        );
-                    }
+                    if let Some(Err(error)) = joined { break Err(io::Error::other(error)); }
                 }
-                accepted = self.listener.accept(), if tasks.len() < MAX_CONTROLLER_CONNECTIONS => {
-                    let (stream, peer) = accepted?;
-                    let secret = self.secret.clone();
-                    let traffic = self.traffic.clone();
-                    let proxy_groups = self.proxy_groups.clone();
-                    let child = cancellation.clone();
+                accepted = self.accept(), if tasks.len() < MAX_CONTROLLER_CONNECTIONS => {
+                    let accepted = match accepted { Ok(value) => value, Err(error) => break Err(error) };
+                    let context = self.context.clone(); let child = cancellation.clone();
+                    let tls = self.tls.clone();
                     tasks.spawn(crate::resources::observation::task(async move {
-                        if let Err(error) = handle_connection(
-                            stream,
-                            peer,
-                            secret,
-                            traffic,
-                            proxy_groups,
-                            child,
-                        )
-                        .await
-                        {
-                            tracing::debug!(
-                                error_kind = ?error.kind(),
-                                "controller request failed"
-                            );
+                        match accepted {
+                            AcceptedController::Http(stream) => { let _ = handle_connection(H1Io(stream), context, child).await; }
+                            AcceptedController::Tls(stream) => { let _ = transport::serve_tls(stream, tls.expect("TLS listener owns TLS config"), context, child).await; }
+                            #[cfg(target_os = "linux")]
+                            AcceptedController::Unix(stream) => { let _ = handle_connection(H1Io(stream), context.for_local_transport(), child).await; }
                         }
                     }));
                 }
             }
-        }
+        };
+        cancellation.cancel();
         tasks.abort_all();
         while tasks.join_next().await.is_some() {}
-        Ok(())
+        self.context.requests.close();
+        self.context.requests.wait().await;
+        if let Some(watcher) = watcher {
+            watcher.await.map_err(io::Error::other)?;
+        }
+        result
     }
 }
 
-async fn handle_connection(
-    mut stream: TcpStream,
-    peer: SocketAddr,
-    secret: Option<Arc<str>>,
-    traffic: Option<Arc<TunTrafficStats>>,
-    proxy_groups: Arc<ProxyGroups>,
-    cancellation: CancellationToken,
-) -> io::Result<()> {
-    if !peer.ip().is_loopback() {
-        return write_error(&mut stream, 403, "Forbidden", &[]).await;
+fn bind_controller(config: &ExternalControllerConfig) -> io::Result<TcpListener> {
+    let listen = if config.listen.ip().is_unspecified() {
+        SocketAddr::from(([0u16; 8], config.listen.port()))
+    } else {
+        config.listen
+    };
+    match bind_controller_tcp(listen, config.routing_mark) {
+        Err(error)
+            if config.listen.ip().is_unspecified()
+                && crate::inbound::listen::address_family_unavailable(&error) =>
+        {
+            bind_controller_tcp(
+                SocketAddr::from(([0, 0, 0, 0], config.listen.port())),
+                config.routing_mark,
+            )
+        }
+        result => result,
+    }
+}
+
+fn bind_controller_tcp(address: SocketAddr, routing_mark: u32) -> io::Result<TcpListener> {
+    let socket = Socket::new(
+        Domain::for_address(address),
+        Type::STREAM,
+        Some(Protocol::TCP),
+    )?;
+    if address.is_ipv6() {
+        // Go's tcp listener allows IPv4-mapped peers on an IPv6 wildcard.
+        socket.set_only_v6(false)?;
+    }
+    #[cfg(unix)]
+    socket.set_reuse_address(true)?;
+    socket.set_nonblocking(true)?;
+    set_controller_mark(&socket, routing_mark)?;
+    socket.bind(&address.into())?;
+    socket.listen(128)?;
+    TcpListener::from_std(socket.into())
+}
+
+fn set_controller_mark(socket: &Socket, mark: u32) -> io::Result<()> {
+    if mark == 0 {
+        return Ok(());
+    }
+    #[cfg(target_os = "linux")]
+    {
+        socket.set_mark(mark)
+    }
+    #[cfg(not(target_os = "linux"))]
+    {
+        let _ = socket;
+        Err(io::Error::new(
+            io::ErrorKind::Unsupported,
+            "external-controller-routing-mark requires Linux",
+        ))
     }
+}
+fn mark_accepted_tcp(
+    stream: tokio::net::TcpStream,
+    mark: u32,
+) -> io::Result<tokio::net::TcpStream> {
+    set_controller_mark(&socket2::SockRef::from(&stream), mark)?;
+    Ok(stream)
+}
 
+async fn handle_connection<S: ControllerIo>(
+    mut stream: S,
+    context: RequestContext,
+    cancellation: CancellationToken,
+) -> io::Result<()> {
     let request = tokio::select! {
         biased;
         () = cancellation.cancelled() => return Ok(()),
@@ -141,6 +330,32 @@ async fn handle_connection(
         },
     };
 
+    handle_request(stream, request, context, cancellation).await
+}
+
+async fn handle_request<S: ControllerIo>(
+    stream: S,
+    request: crate::inbound::http::RequestHead,
+    context: RequestContext,
+    cancellation: CancellationToken,
+) -> io::Result<()> {
+    let subscription = websocket::requested(&request).then(|| context.clone());
+    let RequestContext {
+        secret,
+        traffic,
+        proxy_groups,
+        resources,
+        cors,
+        ..
+    } = context;
+    let outcome = cors.evaluate(&request.method, &request.headers);
+    let mut stream = transport::CorsIo::new(stream, outcome.headers);
+    if outcome.preflight {
+        return write_response(&mut stream, 200, &[], &[]).await;
+    }
+    if let Some(context) = subscription {
+        return websocket::handle(&mut stream, request, context, cancellation).await;
+    }
     if !authorized(&request.headers, secret.as_deref()) {
         return write_error(
             &mut stream,
@@ -151,10 +366,169 @@ async fn handle_connection(
         .await;
     }
 
+    if request.target == "/version" {
+        if request.method != "GET" {
+            return write_error(&mut stream, 405, "Method not allowed", &[("Allow", "GET")]).await;
+        }
+        return write_json(
+            &mut stream,
+            200,
+            &serde_json::json!({"meta":false,"version":env!("CARGO_PKG_VERSION")}),
+            &[],
+        )
+        .await;
+    }
+    if request.target == "/memory" {
+        if request.method != "GET" {
+            return write_error(&mut stream, 405, "Method not allowed", &[("Allow", "GET")]).await;
+        }
+        let value = serde_json::json!({"inuse":crate::memory::resident_bytes(),"oslimit":null});
+        return write_json(&mut stream, 200, &value, &[]).await;
+    }
+    let route_path = request
+        .target
+        .split_once('?')
+        .map_or(request.target.as_str(), |(path, _)| path);
+    let probe_route = route_path.strip_suffix("/delay").and_then(|base| {
+        base.strip_prefix("/proxies/")
+            .map(|name| (false, name))
+            .or_else(|| base.strip_prefix("/group/").map(|name| (true, name)))
+    });
+    if let Some((group, raw_name)) = probe_route {
+        if request.method != "GET" {
+            return write_error(&mut stream, 405, "Method not allowed", &[("Allow", "GET")]).await;
+        }
+        return delay_query(
+            &mut stream,
+            group,
+            raw_name,
+            &request.target,
+            resources.as_deref(),
+            &cancellation,
+        )
+        .await;
+    }
+    if let Some(raw_name) = route_path
+        .strip_prefix("/providers/proxies/")
+        .and_then(|tail| tail.strip_suffix("/healthcheck"))
+    {
+        if request.method != "GET" {
+            return write_error(&mut stream, 405, "Method not allowed", &[("Allow", "GET")]).await;
+        }
+        let Ok(name) = decode_group_name(raw_name) else {
+            return write_error(&mut stream, 400, "Bad request", &[]).await;
+        };
+        let Some(resources) = resources.as_deref() else {
+            return write_error(&mut stream, 404, "Resource not found", &[]).await;
+        };
+        let result = tokio::select! { biased;
+            () = cancellation.cancelled() => return Ok(()),
+            result = resources.provider_healthcheck(&name, &cancellation) => result,
+        };
+        return match result {
+            Ok(()) => write_response(&mut stream, 204, &[], &[]).await,
+            Err(error) => probe_error(&mut stream, error).await,
+        };
+    }
+
+    if request.target == "/dns/query" || request.target.starts_with("/dns/query?") {
+        if request.method != "GET" {
+            return write_error(&mut stream, 405, "Method not allowed", &[("Allow", "GET")]).await;
+        }
+        return dns::query(
+            &mut stream,
+            &request.target,
+            resources.as_deref(),
+            cancellation,
+        )
+        .await;
+    }
+
     if request.target.contains(['?', '#']) {
         return write_error(&mut stream, 400, "Bad request", &[]).await;
     }
 
+    #[cfg(any(feature = "invoke", test))]
+    if matches!(
+        request.target.as_str(),
+        "/cache/fakeip/flush" | "/configs/geo"
+    ) {
+        return configs::maintenance(&mut stream, request, resources.as_deref(), cancellation)
+            .await;
+    }
+
+    if request.target == "/rules/disable" {
+        return rules::disable(&mut stream, request, resources.as_deref(), cancellation).await;
+    }
+
+    if request.target == "/cache/dns/flush" {
+        if request.method != "POST" {
+            return write_error(&mut stream, 405, "Method not allowed", &[("Allow", "POST")]).await;
+        }
+        if let Some(snapshot) = resources.as_ref().and_then(|resources| resources.dns()) {
+            tokio::select! {
+                biased;
+                () = cancellation.cancelled() => return Ok(()),
+                () = snapshot.dns.flush_cache() => {}
+            }
+        }
+        return write_response(&mut stream, 204, &[], &[]).await;
+    }
+
+    #[cfg(any(feature = "invoke", test))]
+    if request.target == "/configs" && matches!(request.method.as_str(), "PATCH" | "PUT") {
+        return configs::apply(&mut stream, request, resources.as_deref(), cancellation).await;
+    }
+    if matches!(request.target.as_str(), "/configs" | "/rules") {
+        if request.method != "GET" {
+            return write_error(&mut stream, 405, "Method not allowed", &[("Allow", "GET")]).await;
+        }
+        let Some(resources) = &resources else {
+            return write_error(&mut stream, 404, "Resource not found", &[]).await;
+        };
+        let value = if request.target == "/configs" {
+            resources.configs()
+        } else {
+            resources.rules()
+        };
+        return write_json(&mut stream, 200, &value, &[]).await;
+    }
+    if request.target == "/connections" || request.target.starts_with("/connections/") {
+        let Some(resources) = &resources else {
+            return write_error(&mut stream, 404, "Resource not found", &[]).await;
+        };
+        let registry = resources.connections();
+        if request.method == "GET" && request.target == "/connections" {
+            let snapshot = registry.snapshot();
+            return write_json(&mut stream, 200, &snapshot, &[]).await;
+        }
+        if request.method == "DELETE" {
+            if let Some(raw_id) = request.target.strip_prefix("/connections/") {
+                let Ok(id) = decode_group_name(raw_id) else {
+                    return write_error(&mut stream, 400, "Bad request", &[]).await;
+                };
+                registry.close(&id);
+            } else {
+                registry.close_all();
+            }
+            return write_response(&mut stream, 204, &[], &[]).await;
+        }
+        return write_error(
+            &mut stream,
+            405,
+            "Method not allowed",
+            &[(
+                "Allow",
+                if request.target == "/connections" {
+                    "GET, DELETE"
+                } else {
+                    "DELETE"
+                },
+            )],
+        )
+        .await;
+    }
+
     if request.target == "/traffic" {
         if request.method != "GET" {
             return write_error(&mut stream, 405, "Method not allowed", &[("Allow", "GET")]).await;
@@ -165,6 +539,75 @@ async fn handle_connection(
         };
     }
 
+    if let Some(tail) = request.target.strip_prefix("/providers/") {
+        let (kind, raw_name) = tail
+            .split_once('/')
+            .map_or((tail, None), |(kind, name)| (kind, Some(name)));
+        let rules = match kind {
+            "rules" => true,
+            "proxies" => false,
+            _ => return write_error(&mut stream, 404, "Resource not found", &[]).await,
+        };
+        let name = match raw_name {
+            Some(raw) => match decode_group_name(raw) {
+                Ok(name) => Some(name),
+                Err(()) => return write_error(&mut stream, 400, "Bad request", &[]).await,
+            },
+            None => None,
+        };
+        let state = resources.as_ref().map_or_else(
+            || serde_json::json!({"providers":{}}),
+            |resources| resources.providers(rules),
+        );
+        if request.method == "GET" {
+            if let Some(name) = name {
+                return match state["providers"].get(&name) {
+                    Some(value) => write_json(&mut stream, 200, value, &[]).await,
+                    None => write_error(&mut stream, 404, "Resource not found", &[]).await,
+                };
+            }
+            return write_json(&mut stream, 200, &state, &[]).await;
+        }
+        if request.method == "PUT"
+            && let (Some(resources), Some(name)) = (&resources, name)
+        {
+            if state["providers"].get(&name).is_none() {
+                return write_error(&mut stream, 404, "Resource not found", &[]).await;
+            }
+            let result = tokio::select! { biased; ()=cancellation.cancelled()=>return Ok(()), result=resources.refresh(rules,&name)=>result };
+            return match result {
+                Ok(()) => write_response(&mut stream, 204, &[], &[]).await,
+                Err(_) => write_error(&mut stream, 503, "Provider update failed", &[]).await,
+            };
+        }
+        return write_error(
+            &mut stream,
+            405,
+            "Method not allowed",
+            &[("Allow", "GET, PUT")],
+        )
+        .await;
+    }
+    let proxy_groups = resources
+        .as_ref()
+        .map_or(proxy_groups, |resources| resources.groups());
+
+    if request.target == "/proxies" {
+        if request.method != "GET" {
+            return write_error(&mut stream, 405, "Method not allowed", &[("Allow", "GET")]).await;
+        }
+        let mut health = resources.as_ref().map_or_else(
+            || serde_json::json!({"proxies":{}}),
+            |resources| resources.health(),
+        );
+        for state in proxy_groups.list_states() {
+            let name = state.name.clone();
+            health["proxies"][name] =
+                serde_json::to_value(GroupResponse::from(state)).expect("group status");
+        }
+        return write_json(&mut stream, 200, &health, &[]).await;
+    }
+
     if request.target == "/group" {
         if request.method != "GET" {
             return write_error(&mut stream, 405, "Method not allowed", &[("Allow", "GET")]).await;
@@ -190,7 +633,9 @@ async fn handle_connection(
             Err(ProxyGroupError::UnknownGroup) => {
                 write_error(&mut stream, 404, "Resource not found", &[]).await
             }
-            Err(ProxyGroupError::UnknownMember) => unreachable!("state does not select a member"),
+            Err(ProxyGroupError::UnknownMember | ProxyGroupError::NotSelectable) => {
+                unreachable!("state does not select a member")
+            }
         };
     }
 
@@ -202,8 +647,40 @@ async fn handle_connection(
         return match request.method.as_str() {
             "GET" => match proxy_groups.state(&name) {
                 Ok(state) => write_json(&mut stream, 200, &GroupResponse::from(state), &[]).await,
-                Err(_) => write_error(&mut stream, 404, "Resource not found", &[]).await,
+                Err(_) => {
+                    let health = resources.as_ref().map(|resources| resources.health());
+                    match health
+                        .as_ref()
+                        .and_then(|state| state["proxies"].get(&name))
+                    {
+                        Some(node) => write_json(&mut stream, 200, node, &[]).await,
+                        None => write_error(&mut stream, 404, "Resource not found", &[]).await,
+                    }
+                }
             },
+            "DELETE" => {
+                let result = resources.as_ref().map_or_else(
+                    || proxy_groups.clear_fixed(&name),
+                    |resources| resources.clear_fixed(&name),
+                );
+                match result {
+                    Ok(()) => write_response(&mut stream, 204, &[], &[]).await,
+                    Err(ProxyGroupError::UnknownGroup) => {
+                        if resources
+                            .as_ref()
+                            .is_some_and(|r| r.health()["proxies"].get(&name).is_some())
+                        {
+                            write_error(&mut stream, 400, "Proxy is not an automatic group", &[])
+                                .await
+                        } else {
+                            write_error(&mut stream, 404, "Resource not found", &[]).await
+                        }
+                    }
+                    Err(_) => {
+                        write_error(&mut stream, 400, "Proxy is not an automatic group", &[]).await
+                    }
+                }
+            }
             "PUT" => {
                 handle_select(
                     &mut stream,
@@ -211,6 +688,7 @@ async fn handle_connection(
                     request.buffered,
                     &name,
                     &proxy_groups,
+                    resources.as_deref(),
                     cancellation,
                 )
                 .await
@@ -220,7 +698,7 @@ async fn handle_connection(
                     &mut stream,
                     405,
                     "Method not allowed",
-                    &[("Allow", "GET, PUT")],
+                    &[("Allow", "GET, PUT, DELETE")],
                 )
                 .await
             }
@@ -230,16 +708,98 @@ async fn handle_connection(
     write_error(&mut stream, 404, "Resource not found", &[]).await
 }
 
-async fn handle_select(
-    stream: &mut TcpStream,
+fn parse_delay(target: &str, group: bool) -> Result<crate::resource::control::DelayRequest, ()> {
+    if target.contains('#') {
+        return Err(());
+    }
+    let (_, raw) = target.split_once('?').ok_or(())?;
+    let mut values = std::collections::BTreeMap::new();
+    for (key, value) in url::form_urlencoded::parse(raw.as_bytes()) {
+        values.entry(key).or_insert(value);
+    }
+    let url = values.get("url").ok_or(())?.to_string();
+    crate::resource::probe::Target::parse(&url).map_err(|_| ())?;
+    let raw_timeout = values.get("timeout").ok_or(())?;
+    let millis = if group {
+        raw_timeout.parse::<i32>().map(i64::from)
+    } else {
+        raw_timeout.parse::<i16>().map(i64::from)
+    }
+    .map_err(|_| ())?;
+    let expected =
+        crate::config::status_ranges(values.get("expected").map_or("", |value| value.as_ref()))
+            .map_err(|_| ())?;
+    Ok(crate::resource::control::DelayRequest {
+        url,
+        timeout: Duration::from_millis(millis.max(0) as u64),
+        expected,
+    })
+}
+
+async fn probe_error<S: ControllerIo>(
+    stream: &mut S,
+    error: crate::resource::control::ProbeError,
+) -> io::Result<()> {
+    use crate::resource::control::ProbeError;
+    match error {
+        ProbeError::NotFound => write_error(stream, 404, "Resource not found", &[]).await,
+        ProbeError::Timeout => write_error(stream, 504, "Delay test timed out", &[]).await,
+        ProbeError::Failed => write_error(stream, 503, "Delay test failed", &[]).await,
+        ProbeError::Stopped => Ok(()),
+    }
+}
+
+async fn delay_query<S: ControllerIo>(
+    stream: &mut S,
+    group: bool,
+    raw_name: &str,
+    target: &str,
+    resources: Option<&dyn crate::resource::control::RuntimeResources>,
+    cancellation: &CancellationToken,
+) -> io::Result<()> {
+    let (Ok(name), Ok(request)) = (decode_group_name(raw_name), parse_delay(target, group)) else {
+        return write_error(stream, 400, "Bad request", &[]).await;
+    };
+    let Some(resources) = resources else {
+        return write_error(stream, 404, "Resource not found", &[]).await;
+    };
+    let operation = async {
+        if group {
+            resources
+                .group_delay(&name, &request, cancellation)
+                .await
+                .map(|value| serde_json::json!(value))
+        } else {
+            let delay = resources.node_delay(&name, &request, cancellation).await?;
+            if delay == 0 {
+                Err(crate::resource::control::ProbeError::Failed)
+            } else {
+                Ok(serde_json::json!({"delay":delay}))
+            }
+        }
+    };
+    let result = tokio::select! { biased;
+        () = cancellation.cancelled() => return Ok(()),
+        result = operation => result,
+    };
+    match result {
+        Ok(value) => write_json(stream, 200, &value, &[]).await,
+        Err(error) => probe_error(stream, error).await,
+    }
+}
+
+/// Small authenticated management writes share the existing 1 KiB envelope.
+/// None means a rejection response was written or the read was cancelled.
+async fn read_small_json_body<S: ControllerIo>(
+    stream: &mut S,
     headers: &[(String, String)],
     mut body: Vec<u8>,
-    group: &str,
-    proxy_groups: &ProxyGroups,
     cancellation: CancellationToken,
-) -> io::Result<()> {
+) -> io::Result<Option<Vec<u8>>> {
     if header_values(headers, "transfer-encoding").next().is_some() {
-        return write_error(stream, 400, "Body invalid", &[]).await;
+        return write_error(stream, 400, "Body invalid", &[])
+            .await
+            .map(|()| None);
     }
 
     let mut content_types = header_values(headers, "content-type");
@@ -248,27 +808,39 @@ async fn handle_select(
         .is_some_and(|value| value.eq_ignore_ascii_case("application/json"))
         && content_types.next().is_none();
     if !valid_content_type {
-        return write_error(stream, 415, "Unsupported media type", &[]).await;
+        return write_error(stream, 415, "Unsupported media type", &[])
+            .await
+            .map(|()| None);
     }
 
     let mut content_lengths = header_values(headers, "content-length");
     let Some(content_length) = content_lengths.next() else {
-        return write_error(stream, 411, "Length required", &[]).await;
+        return write_error(stream, 411, "Length required", &[])
+            .await
+            .map(|()| None);
     };
     if content_lengths.next().is_some()
         || content_length.is_empty()
         || !content_length.bytes().all(|byte| byte.is_ascii_digit())
     {
-        return write_error(stream, 400, "Body invalid", &[]).await;
+        return write_error(stream, 400, "Body invalid", &[])
+            .await
+            .map(|()| None);
     }
     let Ok(content_length) = content_length.parse::<usize>() else {
-        return write_error(stream, 400, "Body invalid", &[]).await;
+        return write_error(stream, 400, "Body invalid", &[])
+            .await
+            .map(|()| None);
     };
     if content_length > MAX_CONTROLLER_BODY_BYTES {
-        return write_error(stream, 413, "Payload too large", &[]).await;
+        return write_error(stream, 413, "Payload too large", &[])
+            .await
+            .map(|()| None);
     }
     if body.len() > content_length {
-        return write_error(stream, 400, "Body invalid", &[]).await;
+        return write_error(stream, 400, "Body invalid", &[])
+            .await
+            .map(|()| None);
     }
 
     let buffered = body.len();
@@ -276,7 +848,7 @@ async fn handle_select(
     if buffered != content_length {
         let read = tokio::select! {
             biased;
-            () = cancellation.cancelled() => return Ok(()),
+            () = cancellation.cancelled() => return Ok(None),
             result = timeout(
                 CONTROLLER_BODY_TIMEOUT,
                 stream.read_exact(&mut body[buffered..]),
@@ -298,16 +870,35 @@ async fn handle_select(
         }
     }
 
+    Ok(Some(body))
+}
+
+async fn handle_select<S: ControllerIo>(
+    stream: &mut S,
+    headers: &[(String, String)],
+    body: Vec<u8>,
+    group: &str,
+    proxy_groups: &ProxyGroups,
+    resources: Option<&dyn crate::resource::control::RuntimeResources>,
+    cancellation: CancellationToken,
+) -> io::Result<()> {
+    let Some(body) = read_small_json_body(stream, headers, body, cancellation).await? else {
+        return Ok(());
+    };
+
     let request = match serde_json::from_slice::<SelectRequest>(&body) {
         Ok(request) => request,
         Err(_) => return write_error(stream, 400, "Body invalid", &[]).await,
     };
-    match proxy_groups.select(group, &request.name) {
+    match resources.map_or_else(
+        || proxy_groups.select(group, &request.name),
+        |resources| resources.select(group, &request.name),
+    ) {
         Ok(()) => write_response(stream, 204, &[], b"").await,
         Err(ProxyGroupError::UnknownGroup) => {
             write_error(stream, 404, "Resource not found", &[]).await
         }
-        Err(ProxyGroupError::UnknownMember) => {
+        Err(ProxyGroupError::UnknownMember | ProxyGroupError::NotSelectable) => {
             write_error(
                 stream,
                 400,
@@ -346,8 +937,12 @@ fn authorized(headers: &[(String, String)], secret: Option<&str>) -> bool {
 }
 
 fn controller_token_eq(candidate: &[u8], secret: &[u8]) -> bool {
+    let limit = crate::inbound::DEFAULT_HEADER_LIMIT;
+    if candidate.len() > limit || secret.len() > limit {
+        return false;
+    }
     let mut difference = candidate.len() ^ secret.len();
-    for index in 0..MAX_CONTROLLER_SECRET_BYTES {
+    for index in 0..limit {
         let candidate = candidate.get(index).copied().unwrap_or_default();
         let secret = secret.get(index).copied().unwrap_or_default();
         difference |= usize::from(candidate ^ secret);
@@ -412,22 +1007,30 @@ struct GroupResponse {
     #[serde(rename = "type")]
     kind: &'static str,
     all: Vec<String>,
+    #[serde(skip_serializing_if = "String::is_empty")]
     now: String,
+    hidden: bool,
+    icon: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    fixed: Option<String>,
 }
 
 impl From<ProxyGroupState> for GroupResponse {
     fn from(state: ProxyGroupState) -> Self {
         Self {
             name: state.name,
-            kind: "Selector",
+            kind: state.kind.controller_type(),
             all: state.all,
             now: state.now,
+            hidden: state.hidden,
+            icon: state.icon,
+            fixed: state.fixed,
         }
     }
 }
 
-async fn write_json<T: Serialize>(
-    stream: &mut TcpStream,
+async fn write_json<T: Serialize, S: ControllerIo>(
+    stream: &mut S,
     status: u16,
     value: &T,
     headers: &[(&str, &str)],
@@ -439,8 +1042,8 @@ async fn write_json<T: Serialize>(
     write_response(stream, status, &response_headers, &body).await
 }
 
-async fn write_error(
-    stream: &mut TcpStream,
+async fn write_error<S: ControllerIo>(
+    stream: &mut S,
     status: u16,
     message: &'static str,
     headers: &[(&str, &str)],
@@ -452,41 +1055,13 @@ async fn write_error(
     write_json(stream, status, &ErrorResponse { message }, headers).await
 }
 
-async fn write_response(
-    stream: &mut TcpStream,
+async fn write_response<S: ControllerIo>(
+    stream: &mut S,
     status: u16,
     headers: &[(&str, &str)],
     body: &[u8],
 ) -> io::Result<()> {
-    let reason = match status {
-        200 => "OK",
-        204 => "No Content",
-        400 => "Bad Request",
-        401 => "Unauthorized",
-        403 => "Forbidden",
-        404 => "Not Found",
-        405 => "Method Not Allowed",
-        408 => "Request Timeout",
-        411 => "Length Required",
-        413 => "Payload Too Large",
-        415 => "Unsupported Media Type",
-        500 => "Internal Server Error",
-        _ => "Error",
-    };
-    let mut response = format!(
-        "HTTP/1.1 {status} {reason}\r\nContent-Length: {}\r\nConnection: close\r\nCache-Control: no-store\r\n",
-        body.len()
-    );
-    for (name, value) in headers {
-        response.push_str(name);
-        response.push_str(": ");
-        response.push_str(value);
-        response.push_str("\r\n");
-    }
-    response.push_str("\r\n");
-    stream.write_all(response.as_bytes()).await?;
-    stream.write_all(body).await?;
-    stream.shutdown().await
+    stream.respond(status, headers, body).await
 }
 
 #[cfg(test)]
@@ -520,10 +1095,19 @@ mod tests {
         }
     }
 
-    fn test_groups() -> Arc<ProxyGroups> {
+    pub(super) fn test_groups() -> Arc<ProxyGroups> {
         let dispatcher: Arc<dyn Dispatcher> = Arc::new(UnusedDispatcher);
         ProxyGroups::new(
             &[SelectProxyGroupConfig {
+                kind: crate::config::GroupKind::Select,
+                strategy: crate::config::BalanceStrategy::default(),
+                hash_key: crate::config::BalanceHashKey::default(),
+                health: crate::config::HealthCheckConfig::default(),
+                tolerance: 0,
+                max_failed_times: 5,
+                disable_udp: false,
+                hidden: false,
+                icon: String::new(),
                 name: "主线路".to_owned(),
                 members: vec![
                     ProxyGroupMemberConfig {
@@ -559,6 +1143,192 @@ mod tests {
         response.split_once("\r\n\r\n").unwrap().1
     }
 
+    fn small_body_headers(length: usize) -> Vec<(String, String)> {
+        vec![
+            ("Content-Type".into(), "application/json".into()),
+            ("Content-Length".into(), length.to_string()),
+        ]
+    }
+
+    async fn small_select_memory(
+        headers: Vec<(String, String)>,
+        prefix: Vec<u8>,
+        tail: &[u8],
+        close_write: bool,
+        cancellation: CancellationToken,
+    ) -> (io::Result<()>, String, Arc<ProxyGroups>) {
+        let groups = test_groups();
+        let selected = groups.clone();
+        let (mut client, server) = tokio::io::duplex(4096);
+        let serve = tokio::spawn(async move {
+            let mut stream = H1Io(server);
+            handle_select(
+                &mut stream,
+                &headers,
+                prefix,
+                "主线路",
+                &selected,
+                None,
+                cancellation,
+            )
+            .await
+        });
+        client.write_all(tail).await.unwrap();
+        if close_write {
+            client.shutdown().await.unwrap();
+        }
+        let result = serve.await.unwrap();
+        let mut response = Vec::new();
+        client.read_to_end(&mut response).await.unwrap();
+        (result, String::from_utf8(response).unwrap(), groups)
+    }
+
+    #[tokio::test]
+    async fn small_json_body_keeps_group_selection_and_header_budget() {
+        let mut body = br#"{"name":"node-b"}"#.to_vec();
+        body.resize(MAX_CONTROLLER_BODY_BYTES, b' ');
+        let (result, response, groups) = small_select_memory(
+            small_body_headers(body.len()),
+            body[..5].to_vec(),
+            &body[5..],
+            false,
+            CancellationToken::new(),
+        )
+        .await;
+        result.unwrap();
+        assert!(response.starts_with("HTTP/1.1 204"));
+        assert_eq!(groups.state("主线路").unwrap().now, "node-b");
+
+        for (status, headers) in [
+            (400, {
+                let mut headers = small_body_headers(body.len());
+                headers.push(("Transfer-Encoding".into(), "chunked".into()));
+                headers
+            }),
+            (415, {
+                let mut headers = small_body_headers(body.len());
+                headers[0].1 = "application/json; charset=utf-8".into();
+                headers
+            }),
+            (
+                411,
+                vec![("Content-Type".into(), "application/json".into())],
+            ),
+            (400, {
+                let mut headers = small_body_headers(body.len());
+                headers.push(("Content-Length".into(), body.len().to_string()));
+                headers
+            }),
+            (413, small_body_headers(MAX_CONTROLLER_BODY_BYTES + 1)),
+            (400, small_body_headers(body.len() - 1)),
+        ] {
+            let (result, response, groups) =
+                small_select_memory(headers, body.to_vec(), &[], false, CancellationToken::new())
+                    .await;
+            result.unwrap();
+            assert!(response.starts_with(&format!("HTTP/1.1 {status}")));
+            assert_eq!(groups.state("主线路").unwrap().now, "node-a");
+        }
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn small_json_body_keeps_group_eof_timeout_and_cancel_semantics() {
+        for (close_write, kind, status) in [
+            (true, io::ErrorKind::UnexpectedEof, 400),
+            (false, io::ErrorKind::TimedOut, 408),
+        ] {
+            let (result, response, groups) = small_select_memory(
+                small_body_headers(17),
+                b"{".to_vec(),
+                &[],
+                close_write,
+                CancellationToken::new(),
+            )
+            .await;
+            assert_eq!(result.unwrap_err().kind(), kind);
+            assert!(response.starts_with(&format!("HTTP/1.1 {status}")));
+            assert_eq!(groups.state("主线路").unwrap().now, "node-a");
+        }
+        let cancellation = CancellationToken::new();
+        cancellation.cancel();
+        let (result, response, groups) = small_select_memory(
+            small_body_headers(17),
+            b"{".to_vec(),
+            &[],
+            false,
+            cancellation,
+        )
+        .await;
+        result.unwrap();
+        assert!(response.is_empty());
+        assert_eq!(groups.state("主线路").unwrap().now, "node-a");
+    }
+
+    #[tokio::test]
+    async fn local_context_shares_limits_and_bypasses_only_local_rest_and_websocket_auth() {
+        let network = RequestContext {
+            secret: Some(Arc::from("network-token")),
+            traffic: None,
+            proxy_groups: test_groups(),
+            resources: None,
+            cors: Arc::new(cors::Policy::new(&Default::default())),
+            requests: tokio_util::task::TaskTracker::new(),
+            subscriptions: Arc::new(tokio::sync::Semaphore::new(websocket::MAX_SUBSCRIPTIONS)),
+            logs: None,
+        };
+        let local = network.for_local_transport();
+        assert!(network.secret.is_some());
+        assert!(local.secret.is_none());
+        assert!(Arc::ptr_eq(&network.proxy_groups, &local.proxy_groups));
+        assert!(Arc::ptr_eq(&network.subscriptions, &local.subscriptions));
+        let websocket = "GET /memory?token=wrong HTTP/1.1\r\nHost: controller\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n\r\n";
+        for (context, request, status) in [
+            (network.clone(), "GET /version HTTP/1.1\r\n\r\n", 401),
+            (local.clone(), "GET /version HTTP/1.1\r\n\r\n", 200),
+            (network.clone(), websocket, 401),
+            (local.clone(), websocket, 101),
+        ] {
+            let (mut client, stream) = tokio::io::duplex(4096);
+            let cancel = CancellationToken::new();
+            let child = cancel.clone();
+            let task = tokio::spawn(handle_connection(H1Io(stream), context, child));
+            client.write_all(request.as_bytes()).await.unwrap();
+            let mut head = Vec::new();
+            while !head.ends_with(b"\r\n\r\n") {
+                assert!(head.len() < 2048);
+                head.push(client.read_u8().await.unwrap());
+            }
+            assert!(
+                head.starts_with(format!("HTTP/1.1 {status}").as_bytes()),
+                "unexpected response status: {}",
+                String::from_utf8_lossy(&head).lines().next().unwrap_or("")
+            );
+            cancel.cancel();
+            task.await.unwrap().unwrap();
+        }
+        assert_eq!(
+            network.subscriptions.available_permits(),
+            websocket::MAX_SUBSCRIPTIONS
+        );
+    }
+
+    #[test]
+    fn delay_query_preserves_reference_timeout_width_and_expected_ranges() {
+        let base = "/proxies/edge/delay?url=http%3A%2F%2Fexample.test%2F&timeout=30000&expected=200-204%2F302";
+        let request = parse_delay(base, false).unwrap();
+        assert_eq!(request.timeout, Duration::from_secs(30));
+        assert_eq!(request.expected, [(200, 204), (302, 302)]);
+        assert!(parse_delay(&base.replace("30000", "40000"), false).is_err());
+        assert!(parse_delay(&base.replace("30000", "40000"), true).is_ok());
+        assert_eq!(
+            parse_delay(&base.replace("30000", "-1"), false)
+                .unwrap()
+                .timeout,
+            Duration::ZERO
+        );
+        assert!(parse_delay("/proxies/edge/delay?timeout=1", false).is_err());
+    }
+
     #[test]
     fn bearer_auth_is_strict_and_duplicate_safe() {
         let valid = vec![("Authorization".to_owned(), "Bearer token".to_owned())];
@@ -578,8 +1348,16 @@ mod tests {
         ));
         assert!(!controller_token_eq(b"toke", b"token"));
         assert!(!controller_token_eq(b"token-longer", b"token"));
-        let longest = vec![b'x'; MAX_CONTROLLER_SECRET_BYTES];
-        assert!(controller_token_eq(&longest, &longest));
+        let long_secret = "x".repeat(512);
+        assert!(authorized(
+            &[("Authorization".to_owned(), format!("Bearer {long_secret}"))],
+            Some(&long_secret),
+        ));
+        let mut different = long_secret.as_bytes().to_vec();
+        *different.last_mut().unwrap() = b'y';
+        assert!(!controller_token_eq(&different, long_secret.as_bytes()));
+        let oversized = vec![b'x'; crate::inbound::DEFAULT_HEADER_LIMIT + 1];
+        assert!(!controller_token_eq(&oversized, &oversized));
     }
 
     #[test]
@@ -589,12 +1367,12 @@ mod tests {
             "主线路"
         );
         assert_eq!(decode_group_name("a+b").unwrap(), "a+b");
-        assert!(decode_group_name("%252F").is_err());
-        assert!(decode_group_name("%2F").is_err());
+        assert_eq!(decode_group_name("%252F").unwrap(), "%2F");
+        assert_eq!(decode_group_name("%2F").unwrap(), "/");
         assert!(decode_group_name("%GG").is_err());
         assert!(decode_group_name("%A").is_err());
         assert!(decode_group_name("%FF").is_err());
-        assert!(decode_group_name("..").is_err());
+        assert_eq!(decode_group_name("..").unwrap(), "..");
     }
 
     #[tokio::test]
@@ -604,6 +1382,7 @@ mod tests {
             &ExternalControllerConfig {
                 listen: "127.0.0.1:0".parse().unwrap(),
                 secret: Some("secret".to_owned()),
+                ..ExternalControllerConfig::default()
             },
             None,
             groups.clone(),
@@ -663,6 +1442,7 @@ mod tests {
             &ExternalControllerConfig {
                 listen: "127.0.0.1:0".parse().unwrap(),
                 secret: Some("secret".to_owned()),
+                ..ExternalControllerConfig::default()
             },
             None,
             groups.clone(),
diff --git a/src/controller/configs.rs b/src/controller/configs.rs
new file mode 100644
index 0000000..4f6d6cc
--- /dev/null
+++ b/src/controller/configs.rs
@@ -0,0 +1,272 @@
+//! Thin Controller adapter; candidate ownership lives in the shared worker.
+use super::*;
+use crate::resource::config_apply::{ApplyError, ConfigApplyHandle, ConfigPatch, ConfigUpdate};
+use serde::Deserialize;
+
+const MAX_CONFIG_BODY: usize = 8 * 1024 * 1024;
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct InlineConfig {
+    payload: String,
+}
+
+pub(super) async fn apply<S: ControllerIo>(
+    stream: &mut S,
+    request: crate::inbound::http::RequestHead,
+    resources: Option<&dyn crate::resource::control::RuntimeResources>,
+    cancellation: CancellationToken,
+) -> io::Result<()> {
+    let Some(handle) = resources.and_then(|resources| resources.config_apply()) else {
+        return write_error(stream, 404, "Resource not found", &[]).await;
+    };
+    apply_with_handle(stream, request, handle, cancellation).await
+}
+
+pub(super) async fn maintenance<S: ControllerIo>(
+    stream: &mut S,
+    request: crate::inbound::http::RequestHead,
+    resources: Option<&dyn crate::resource::control::RuntimeResources>,
+    cancellation: CancellationToken,
+) -> io::Result<()> {
+    if request.method != "POST" {
+        return write_error(stream, 405, "Method not allowed", &[("Allow", "POST")]).await;
+    }
+    let mut lengths = header_values(&request.headers, "content-length");
+    if lengths.next().is_some_and(|length| length != "0")
+        || lengths.next().is_some()
+        || header_values(&request.headers, "transfer-encoding")
+            .next()
+            .is_some()
+        || !request.buffered.is_empty()
+    {
+        return write_error(stream, 400, "Body invalid", &[]).await;
+    }
+    let Some(handle) = resources.and_then(|resources| resources.config_apply()) else {
+        return write_error(stream, 404, "Resource not found", &[]).await;
+    };
+    let admission = match handle.try_admit() {
+        Ok(value) => value,
+        Err(error) => return apply_error(stream, error).await,
+    };
+    let update = if request.target == "/configs/geo" {
+        ConfigUpdate::RefreshGeoData
+    } else {
+        ConfigUpdate::FlushFakeIp
+    };
+    let pending = match admission.submit(update) {
+        Ok(value) => value,
+        Err(error) => return apply_error(stream, error).await,
+    };
+    let result = tokio::select! {biased;
+        ()=cancellation.cancelled()=>return Ok(()),
+        result=pending.wait()=>result,
+    };
+    match result {
+        Ok(()) => write_response(stream, 204, &[], &[]).await,
+        Err(error) => apply_error(stream, error).await,
+    }
+}
+
+async fn apply_with_handle<S: ControllerIo>(
+    stream: &mut S,
+    request: crate::inbound::http::RequestHead,
+    handle: ConfigApplyHandle,
+    cancellation: CancellationToken,
+) -> io::Result<()> {
+    if !matches!(request.method.as_str(), "PATCH" | "PUT") {
+        return write_error(
+            stream,
+            405,
+            "Method not allowed",
+            &[("Allow", "GET, PATCH, PUT")],
+        )
+        .await;
+    }
+    // Admission precedes extending the header reader's bounded prefix into a
+    // full body, JSON allocation, parsing, or any worker preparation.
+    let admission = match handle.try_admit() {
+        Ok(value) => value,
+        Err(error) => return apply_error(stream, error).await,
+    };
+    if header_values(&request.headers, "transfer-encoding")
+        .next()
+        .is_some()
+    {
+        return write_error(stream, 400, "Body invalid", &[]).await;
+    }
+    let mut types = header_values(&request.headers, "content-type");
+    if !types
+        .next()
+        .is_some_and(|value| value.eq_ignore_ascii_case("application/json"))
+        || types.next().is_some()
+    {
+        return write_error(stream, 415, "Unsupported media type", &[]).await;
+    }
+    let mut lengths = header_values(&request.headers, "content-length");
+    let Some(length) = lengths.next() else {
+        return write_error(stream, 411, "Length required", &[]).await;
+    };
+    if lengths.next().is_some()
+        || length.is_empty()
+        || !length.bytes().all(|byte| byte.is_ascii_digit())
+    {
+        return write_error(stream, 400, "Body invalid", &[]).await;
+    }
+    let Ok(length) = length.parse::<usize>() else {
+        return write_error(stream, 400, "Body invalid", &[]).await;
+    };
+    let limit = if request.method == "PUT" {
+        MAX_CONFIG_BODY
+    } else {
+        MAX_CONTROLLER_BODY_BYTES
+    };
+    if length > limit {
+        return write_error(stream, 413, "Payload too large", &[]).await;
+    }
+    let mut body = request.buffered;
+    if body.len() > length {
+        return write_error(stream, 400, "Body invalid", &[]).await;
+    }
+    let buffered = body.len();
+    body.resize(length, 0);
+    if buffered < length {
+        let result = tokio::select! { biased;
+            ()=cancellation.cancelled()=>return Ok(()),
+            result=timeout(CONTROLLER_BODY_TIMEOUT,stream.read_exact(&mut body[buffered..]))=>result,
+        };
+        match result {
+            Ok(Ok(_)) => {}
+            Ok(Err(_)) => return write_error(stream, 400, "Body invalid", &[]).await,
+            Err(_) => return write_error(stream, 408, "Timeout", &[]).await,
+        }
+    }
+    let update = if request.method == "PUT" {
+        match serde_json::from_slice::<InlineConfig>(&body) {
+            Ok(config) if !config.payload.is_empty() => ConfigUpdate::Replace(config.payload),
+            _ => return write_error(stream, 400, "Body invalid", &[]).await,
+        }
+    } else {
+        match serde_json::from_slice::<ConfigPatch>(&body) {
+            Ok(patch) => ConfigUpdate::Patch(patch),
+            Err(_) => return write_error(stream, 400, "Body invalid", &[]).await,
+        }
+    };
+    drop(body);
+    let pending = match admission.submit(update) {
+        Ok(value) => value,
+        Err(error) => return apply_error(stream, error).await,
+    };
+    // Cancellation/timeout of this wait cancels the candidate. A normal HTTP
+    // request half-close is not interpreted as candidate cancellation.
+    let result = tokio::select! {biased;
+        ()=cancellation.cancelled()=>return Ok(()),
+        result=pending.wait()=>result,
+    };
+    match result {
+        Ok(()) => write_response(stream, 204, &[], &[]).await,
+        Err(error) => apply_error(stream, error).await,
+    }
+}
+
+pub(super) async fn apply_error<S: ControllerIo>(
+    stream: &mut S,
+    error: ApplyError,
+) -> io::Result<()> {
+    let status = match error {
+        ApplyError::InvalidConfig => 400,
+        ApplyError::RestartRequired => 409,
+        ApplyError::TimedOut => 504,
+        ApplyError::Busy | ApplyError::Stopped | ApplyError::PreparationFailed => 503,
+    };
+    write_error(stream, status, error.message(), &[]).await
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tokio::io::AsyncReadExt;
+    fn request(body: &str) -> crate::inbound::http::RequestHead {
+        crate::inbound::http::RequestHead {
+            method: "PUT".into(),
+            target: "/configs".into(),
+            version: "HTTP/1.1".into(),
+            headers: vec![
+                ("content-type".into(), "application/json".into()),
+                ("content-length".into(), body.len().to_string()),
+            ],
+            buffered: body.as_bytes().to_vec(),
+        }
+    }
+    async fn run(body: &str, expected: Option<&str>, completion: Result<(), ApplyError>) -> String {
+        let cancellation = CancellationToken::new();
+        let (handle, mut receiver) = ConfigApplyHandle::channel(cancellation.clone());
+        let (mut client, server) = tokio::io::duplex(4096);
+        let request = request(body);
+        let expected = expected.map(str::to_owned);
+        let worker = tokio::spawn(async move {
+            if let Some(expected) = expected {
+                let mut task = receiver.recv().await.unwrap();
+                assert!(
+                    matches!(task.take_update(),ConfigUpdate::Replace(value) if value==expected)
+                );
+                task.complete(completion);
+            }
+        });
+        let controller = tokio::spawn(async move {
+            apply_with_handle(&mut H1Io(server), request, handle, cancellation)
+                .await
+                .unwrap();
+        });
+        let mut result = String::new();
+        client.read_to_string(&mut result).await.unwrap();
+        controller.await.unwrap();
+        worker.await.unwrap();
+        result
+    }
+    #[tokio::test]
+    async fn inline_update_is_shared_and_candidate_failure_has_a_fixed_response() {
+        assert!(
+            run(
+                r#"{"payload":"rules: [MATCH,DIRECT]"}"#,
+                Some("rules: [MATCH,DIRECT]"),
+                Ok(())
+            )
+            .await
+            .starts_with("HTTP/1.1 204")
+        );
+        let failure = run(
+            r#"{"payload":"private credentials"}"#,
+            Some("private credentials"),
+            Err(ApplyError::PreparationFailed),
+        )
+        .await;
+        assert!(failure.starts_with("HTTP/1.1 503"));
+        assert!(!failure.contains("private credentials"));
+        assert!(
+            run(r#"{"path":"/private/file"}"#, None, Ok(()))
+                .await
+                .starts_with("HTTP/1.1 400")
+        );
+    }
+    #[tokio::test]
+    async fn busy_admission_rejects_before_waiting_for_the_declared_body() {
+        let cancel = CancellationToken::new();
+        let (handle, _receiver) = ConfigApplyHandle::channel(cancel.clone());
+        let _occupied = handle.try_admit().unwrap();
+        let (mut client, server) = tokio::io::duplex(1024);
+        let mut request = request("");
+        request.headers[1].1 = MAX_CONFIG_BODY.to_string();
+        let task = tokio::spawn(async move {
+            apply_with_handle(&mut H1Io(server), request, handle, cancel)
+                .await
+                .unwrap()
+        });
+        let mut result = String::new();
+        timeout(Duration::from_secs(1), client.read_to_string(&mut result))
+            .await
+            .unwrap()
+            .unwrap();
+        task.await.unwrap();
+        assert!(result.starts_with("HTTP/1.1 503"));
+    }
+}
diff --git a/src/controller/cors.rs b/src/controller/cors.rs
new file mode 100644
index 0000000..b36f59a
--- /dev/null
+++ b/src/controller/cors.rs
@@ -0,0 +1,113 @@
+use crate::config::ControllerCors;
+
+#[derive(Clone)]
+pub(super) struct Policy {
+    all: bool,
+    origins: Vec<String>,
+    private_network: bool,
+}
+
+pub(super) struct Outcome {
+    pub preflight: bool,
+    pub headers: Vec<(String, String)>,
+}
+
+impl Policy {
+    pub fn new(config: &ControllerCors) -> Self {
+        Self {
+            all: config.allow_origins.is_empty() || config.allow_origins.iter().any(|o| o == "*"),
+            origins: config
+                .allow_origins
+                .iter()
+                .map(|o| o.to_lowercase())
+                .collect(),
+            private_network: config.allow_private_network,
+        }
+    }
+
+    pub fn evaluate(&self, method: &str, headers: &[(String, String)]) -> Outcome {
+        let first = |name| super::header_values(headers, name).next();
+        let origin = first("origin");
+        let requested_method = first("access-control-request-method").unwrap_or("");
+        let preflight = method == "OPTIONS" && origin.is_some() && !requested_method.is_empty();
+        let mut outcome = Outcome {
+            preflight,
+            headers: vec![("Vary".into(), "Origin".into())],
+        };
+        if preflight {
+            outcome.headers.extend([
+                ("Vary".into(), "Access-Control-Request-Method".into()),
+                ("Vary".into(), "Access-Control-Request-Headers".into()),
+            ]);
+        }
+        let Some(origin) = origin else { return outcome };
+        let normalized = origin.to_lowercase();
+        let allowed = self.all
+            || self.origins.iter().any(|pattern| {
+                pattern.split_once('*').map_or_else(
+                    || pattern == &normalized,
+                    |(prefix, suffix)| {
+                        normalized.len() >= prefix.len() + suffix.len()
+                            && normalized.starts_with(prefix)
+                            && normalized.ends_with(suffix)
+                    },
+                )
+            });
+        let requested_headers: Vec<String> = first("access-control-request-headers")
+            .unwrap_or("")
+            .split(',')
+            .map(str::trim)
+            .filter(|h| !h.is_empty())
+            .map(|h| {
+                h.split('-')
+                    .map(|part| {
+                        let mut bytes = part.to_ascii_lowercase().into_bytes();
+                        if let Some(first) = bytes.first_mut() {
+                            first.make_ascii_uppercase();
+                        }
+                        String::from_utf8(bytes).expect("ASCII header name")
+                    })
+                    .collect::<Vec<_>>()
+                    .join("-")
+            })
+            .collect();
+        let allowed_headers = requested_headers
+            .iter()
+            .all(|h| matches!(h.as_str(), "Content-Type" | "Authorization" | "Origin"));
+        let relevant_method = if preflight { requested_method } else { method };
+        let allowed_method = matches!(
+            relevant_method.to_ascii_uppercase().as_str(),
+            "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS"
+        );
+        if !allowed || !allowed_method || (preflight && !allowed_headers) {
+            return outcome;
+        }
+        outcome.headers.push((
+            "Access-Control-Allow-Origin".into(),
+            if self.all { "*".into() } else { origin.into() },
+        ));
+        if preflight {
+            outcome.headers.push((
+                "Access-Control-Allow-Methods".into(),
+                requested_method.to_ascii_uppercase(),
+            ));
+            if !requested_headers.is_empty() {
+                outcome.headers.push((
+                    "Access-Control-Allow-Headers".into(),
+                    requested_headers.join(", "),
+                ));
+            }
+            if self.private_network
+                && first("access-control-request-private-network") == Some("true")
+            {
+                outcome
+                    .headers
+                    .push(("Access-Control-Allow-Private-Network".into(), "true".into()));
+            }
+            outcome
+                .headers
+                .push(("Access-Control-Max-Age".into(), "300".into()));
+        }
+        outcome
+    }
+}
diff --git a/src/controller/dns.rs b/src/controller/dns.rs
new file mode 100644
index 0000000..bfe09f0
--- /dev/null
+++ b/src/controller/dns.rs
@@ -0,0 +1,476 @@
+//! On-demand DNS diagnostics over the existing raw upstream resolver.
+use std::{fmt, io};
+
+use domain::{
+    base::{Message, ParsedName, Question, Record, RecordData, name::ToName},
+    rdata::AllRecordData,
+};
+use serde::{
+    Serialize, Serializer,
+    ser::{Error as _, SerializeMap, SerializeSeq},
+};
+use tokio_util::sync::CancellationToken;
+
+use super::{ControllerIo, write_error, write_response};
+
+const MAX_JSON_BYTES: usize = 256 * 1024;
+
+pub(super) async fn query<S: ControllerIo>(
+    stream: &mut S,
+    target: &str,
+    resources: Option<&dyn crate::resource::control::RuntimeResources>,
+    cancellation: CancellationToken,
+) -> io::Result<()> {
+    let Some(snapshot) = resources
+        .and_then(|resources| resources.dns())
+        .filter(|snapshot| snapshot.dns.is_enabled())
+    else {
+        return write_error(stream, 500, "DNS is disabled", &[]).await;
+    };
+    let Ok(query) = question(target) else {
+        return write_error(stream, 400, "Bad request", &[]).await;
+    };
+    let (result, path) = tokio::select! {
+        biased;
+        () = cancellation.cancelled() => return Ok(()),
+        result = crate::dns::trace::capture(snapshot.dns.query_upstream(&query)) => result,
+    };
+    let Ok(wire) = result else {
+        return write_error(stream, 500, "DNS query failed", &[]).await;
+    };
+    let Ok(body) = response(&wire, &path) else {
+        return write_error(stream, 500, "DNS response invalid", &[]).await;
+    };
+    // Keep the selected resource generation alive until output is complete.
+    write_response(stream, 200, &[("Content-Type", "application/json")], &body).await
+}
+
+fn question(target: &str) -> Result<Vec<u8>, ()> {
+    if target.contains('#') {
+        return Err(());
+    }
+    let mut name = None;
+    let mut kind = None;
+    for (key, value) in
+        url::form_urlencoded::parse(target.split_once('?').map_or("", |(_, q)| q).as_bytes())
+    {
+        match key.as_ref() {
+            "name" if name.is_none() => name = Some(value),
+            "type" if kind.is_none() => kind = Some(value),
+            _ => return Err(()),
+        }
+    }
+    let kind = query_type(kind.as_deref().unwrap_or_default()).ok_or(())?;
+    crate::dns::build_wire_query(1, name.as_deref().unwrap_or_default(), kind).map_err(|_| ())
+}
+
+/// Mihomo's Controller uses the case-sensitive miekg/dns v1.1.63 StringToType table.
+/// Keep wire qtypes separate from the address-only business resolver model.
+fn query_type(name: &str) -> Option<u16> {
+    Some(match name {
+        "" | "A" => 1,
+        "AAAA" => 28,
+        "NS" => 2,
+        "MD" => 3,
+        "MF" => 4,
+        "CNAME" => 5,
+        "SOA" => 6,
+        "MB" => 7,
+        "MG" => 8,
+        "MR" => 9,
+        "NULL" => 10,
+        "PTR" => 12,
+        "HINFO" => 13,
+        "MINFO" => 14,
+        "MX" => 15,
+        "TXT" => 16,
+        "RP" => 17,
+        "AFSDB" => 18,
+        "X25" => 19,
+        "ISDN" => 20,
+        "RT" => 21,
+        "NSAP-PTR" => 23,
+        "SIG" => 24,
+        "KEY" => 25,
+        "PX" => 26,
+        "GPOS" => 27,
+        "LOC" => 29,
+        "NXT" => 30,
+        "EID" => 31,
+        "NIMLOC" => 32,
+        "SRV" => 33,
+        "ATMA" => 34,
+        "NAPTR" => 35,
+        "KX" => 36,
+        "CERT" => 37,
+        "DNAME" => 39,
+        "OPT" => 41,
+        "APL" => 42,
+        "DS" => 43,
+        "SSHFP" => 44,
+        "IPSECKEY" => 45,
+        "RRSIG" => 46,
+        "NSEC" => 47,
+        "DNSKEY" => 48,
+        "DHCID" => 49,
+        "NSEC3" => 50,
+        "NSEC3PARAM" => 51,
+        "TLSA" => 52,
+        "SMIMEA" => 53,
+        "HIP" => 55,
+        "NINFO" => 56,
+        "RKEY" => 57,
+        "TALINK" => 58,
+        "CDS" => 59,
+        "CDNSKEY" => 60,
+        "OPENPGPKEY" => 61,
+        "CSYNC" => 62,
+        "ZONEMD" => 63,
+        "SVCB" => 64,
+        "HTTPS" => 65,
+        "SPF" => 99,
+        "UINFO" => 100,
+        "UID" => 101,
+        "GID" => 102,
+        "UNSPEC" => 103,
+        "NID" => 104,
+        "L32" => 105,
+        "L64" => 106,
+        "LP" => 107,
+        "EUI48" => 108,
+        "EUI64" => 109,
+        "NXNAME" => 128,
+        "TKEY" => 249,
+        "TSIG" => 250,
+        "IXFR" => 251,
+        "AXFR" => 252,
+        "MAILB" => 253,
+        "MAILA" => 254,
+        "ANY" => 255,
+        "URI" => 256,
+        "CAA" => 257,
+        "AVC" => 258,
+        "AMTRELAY" => 260,
+        "TA" => 32768,
+        "DLV" => 32769,
+        "None" => 0,
+        "Reserved" => 65535,
+        _ => return None,
+    })
+}
+
+fn response(wire: &[u8], path: &[&'static str]) -> Result<Vec<u8>, ()> {
+    if !(12..=crate::dns::MAX_MESSAGE_SIZE).contains(&wire.len())
+        || wire[2] & 0xfa != 0x80 // QR, opcode 0, and no truncated response.
+        || wire[3] & 0x40 != 0
+        || wire[4..6] != [0, 1]
+    {
+        return Err(());
+    }
+    let message = Message::from_octets(wire).map_err(|_| ())?;
+    let question = message.sole_question().map_err(|_| ())?;
+    if question.qclass().to_int() != 1 {
+        return Err(());
+    }
+    let mut body = BoundedJson(Vec::new());
+    serde_json::to_writer(&mut body, &Response { wire, path }).map_err(|_| ())?;
+    Ok(body.0)
+}
+
+struct Response<'a> {
+    wire: &'a [u8],
+    path: &'a [&'static str],
+}
+impl Serialize for Response<'_> {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        let message = Message::from_octets(self.wire).map_err(S::Error::custom)?;
+        let question = message.sole_question().map_err(S::Error::custom)?;
+        let mut map = serializer.serialize_map(None)?;
+        map.serialize_entry("Status", &message.opt_rcode().to_int())?;
+        map.serialize_entry("Question", &[QuestionView(&question)])?;
+        map.serialize_entry(
+            "Answer",
+            &Section {
+                wire: self.wire,
+                kind: 0,
+            },
+        )?;
+        for (key, kind, count) in [
+            ("Authority", 1, message.header_counts().nscount()),
+            ("Additional", 2, message.header_counts().arcount()),
+        ] {
+            if count != 0 {
+                map.serialize_entry(
+                    key,
+                    &Section {
+                        wire: self.wire,
+                        kind,
+                    },
+                )?;
+            }
+        }
+        // Even empty sections must be scanned to reject trailing wire bytes.
+        if message.header_counts().arcount() == 0 {
+            let mut additional = message.additional().map_err(S::Error::custom)?;
+            for record in additional.by_ref() {
+                record.map_err(S::Error::custom)?;
+            }
+            if additional.pos() != self.wire.len() {
+                return Err(S::Error::custom("trailing DNS data"));
+            }
+        }
+        map.serialize_entry("TC", &(self.wire[2] & 2 != 0))?;
+        map.serialize_entry("RD", &(self.wire[2] & 1 != 0))?;
+        map.serialize_entry("RA", &(self.wire[3] & 0x80 != 0))?;
+        map.serialize_entry("AD", &(self.wire[3] & 0x20 != 0))?;
+        map.serialize_entry("CD", &(self.wire[3] & 0x10 != 0))?;
+        map.serialize_entry("QueryPath", self.path)?;
+        map.end()
+    }
+}
+
+struct QuestionView<'a, N>(&'a Question<N>);
+impl<N: ToName> Serialize for QuestionView<'_, N> {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        let mut map = serializer.serialize_map(Some(3))?;
+        map.serialize_entry("Name", &DisplayValue(self.0.qname().fmt_with_dot()))?;
+        map.serialize_entry("Qtype", &self.0.qtype().to_int())?;
+        map.serialize_entry("Qclass", &self.0.qclass().to_int())?;
+        map.end()
+    }
+}
+
+struct Section<'a> {
+    wire: &'a [u8],
+    kind: u8,
+}
+impl Serialize for Section<'_> {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        let message = Message::from_octets(self.wire).map_err(S::Error::custom)?;
+        let mut section = match self.kind {
+            0 => message.answer(),
+            1 => message.authority(),
+            _ => message.additional(),
+        }
+        .map_err(S::Error::custom)?;
+        let mut records = serializer.serialize_seq(None)?;
+        for record in section.by_ref() {
+            let record = record
+                .map_err(S::Error::custom)?
+                .into_any_record::<AllRecordData<_, ParsedName<_>>>()
+                .map_err(S::Error::custom)?;
+            records.serialize_element(&RecordView(&record))?;
+        }
+        if self.kind == 2 && section.pos() != self.wire.len() {
+            return Err(S::Error::custom("trailing DNS data"));
+        }
+        records.end()
+    }
+}
+
+struct RecordView<'a, N, D>(&'a Record<N, D>);
+impl<N: ToName, D: RecordData + fmt::Display> Serialize for RecordView<'_, N, D> {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        let mut map = serializer.serialize_map(Some(4))?;
+        map.serialize_entry("name", &DisplayValue(self.0.owner().fmt_with_dot()))?;
+        map.serialize_entry("type", &self.0.rtype().to_int())?;
+        map.serialize_entry("TTL", &self.0.ttl().as_secs())?;
+        map.serialize_entry("data", &DisplayValue(self.0.data()))?;
+        map.end()
+    }
+}
+
+struct DisplayValue<T>(T);
+impl<T: fmt::Display> Serialize for DisplayValue<T> {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        // serde_json streams Display through its escaping writer, without an
+        // intermediate unbounded name/RDATA String or generic record tree.
+        serializer.collect_str(&self.0)
+    }
+}
+
+struct BoundedJson(Vec<u8>);
+impl io::Write for BoundedJson {
+    fn write(&mut self, bytes: &[u8]) -> io::Result<usize> {
+        let needed = self
+            .0
+            .len()
+            .checked_add(bytes.len())
+            .filter(|size| *size <= MAX_JSON_BYTES)
+            .ok_or_else(|| io::Error::other("DNS diagnostic output exceeded budget"))?;
+        if needed > self.0.capacity() {
+            let capacity = self
+                .0
+                .capacity()
+                .saturating_mul(2)
+                .max(512)
+                .max(needed)
+                .min(MAX_JSON_BYTES);
+            self.0
+                .try_reserve_exact(capacity - self.0.len())
+                .map_err(io::Error::other)?;
+        }
+        self.0.extend_from_slice(bytes);
+        Ok(bytes.len())
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::{Value, json};
+
+    fn packet(kind: u16) -> Vec<u8> {
+        let mut wire = crate::dns::build_wire_query(1, "example.com", kind).unwrap();
+        wire[2..4].copy_from_slice(&0x8180_u16.to_be_bytes());
+        wire
+    }
+    fn rr(wire: &mut Vec<u8>, kind: u16, ttl: u32, data: &[u8]) {
+        wire.extend_from_slice(&[0xc0, 0x0c]);
+        wire.extend_from_slice(&kind.to_be_bytes());
+        wire.extend_from_slice(&1_u16.to_be_bytes());
+        wire.extend_from_slice(&ttl.to_be_bytes());
+        wire.extend_from_slice(&(data.len() as u16).to_be_bytes());
+        wire.extend_from_slice(data);
+    }
+    fn displayed(wire: &[u8]) -> Value {
+        serde_json::from_slice(&response(wire, &["upstream"]).unwrap()).unwrap()
+    }
+
+    #[test]
+    fn query_types_keep_mihomo_names_case_and_strict_parameters() {
+        for (name, kind) in [
+            ("", 1),
+            ("AAAA", 28),
+            ("TXT", 16),
+            ("HTTPS", 65),
+            ("NSAP-PTR", 23),
+            ("NXNAME", 128),
+            ("ANY", 255),
+            ("None", 0),
+            ("Reserved", 65535),
+        ] {
+            let wire = question(&format!("/dns/query?name=Example.com&type={name}")).unwrap();
+            assert_eq!(
+                crate::dns::classify_query(&wire)
+                    .unwrap()
+                    .question
+                    .query_type,
+                kind
+            );
+        }
+        assert!(question("/dns/query?name=example.com").is_ok());
+        for target in [
+            "/dns/query?name=example.com&type=txt",
+            "/dns/query?name=example.com&type=TYPE65400",
+            "/dns/query?name=example.com&type=WKS",
+            "/dns/query?name=example.com&type=RESINFO",
+            "/dns/query?name=example.com&type=1",
+            "/dns/query?name=example.com&type=A&type=AAAA",
+            "/dns/query?name=example.com&extra=x",
+            "/dns/query?name=example.com#secret",
+        ] {
+            assert!(question(target).is_err(), "{target}");
+        }
+    }
+
+    #[test]
+    fn raw_records_preserve_sections_ttl_and_address_response_shape() {
+        let mut wire = packet(16);
+        wire[6..12].copy_from_slice(&[0, 1, 0, 1, 0, 1]);
+        rr(&mut wire, 16, 17, b"\x03txt");
+        let mut soa = b"\x02ns\x07example\x03com\0\x0ahostmaster\x07example\x03com\0".to_vec();
+        for value in [42_u32, 60, 30, 120, 15] {
+            soa.extend_from_slice(&value.to_be_bytes());
+        }
+        rr(&mut wire, 6, 123, &soa);
+        rr(&mut wire, 1, 9, &[192, 0, 2, 7]);
+        let value = displayed(&wire);
+        assert_eq!(value["Status"], 0);
+        assert_eq!(
+            value["Question"],
+            json!([{"Name":"example.com.", "Qtype":16, "Qclass":1}])
+        );
+        assert_eq!(
+            value["Answer"],
+            json!([{"name":"example.com.", "type":16, "TTL":17, "data":"\"txt\""}])
+        );
+        assert_eq!(value["Authority"][0]["type"], 6);
+        assert_eq!(value["Authority"][0]["TTL"], 123);
+        assert_eq!(
+            value["Authority"][0]["data"],
+            "ns.example.com. hostmaster.example.com. 42 60 30 120 15"
+        );
+        assert_eq!(
+            value["Additional"],
+            json!([{"name":"example.com.", "type":1, "TTL":9, "data":"192.0.2.7"}])
+        );
+        assert_eq!(value["QueryPath"], json!(["upstream"]));
+        assert_eq!(value["RD"], true);
+        assert_eq!(value["RA"], true);
+
+        let mut address = packet(1);
+        address[6..8].copy_from_slice(&1_u16.to_be_bytes());
+        rr(&mut address, 1, 27, &[192, 0, 2, 8]);
+        let value = displayed(&address);
+        assert_eq!(
+            value["Answer"],
+            json!([{"name":"example.com.", "type":1, "TTL":27, "data":"192.0.2.8"}])
+        );
+        assert!(value.get("Authority").is_none());
+        assert!(value.get("Additional").is_none());
+    }
+
+    #[test]
+    fn unknown_data_and_malformed_wire_keep_their_actual_status() {
+        let mut unknown = packet(255);
+        unknown[6..8].copy_from_slice(&1_u16.to_be_bytes());
+        rr(&mut unknown, 65400, 2, &[1, 2, 3]);
+        assert_eq!(displayed(&unknown)["Answer"][0]["data"], "\\# 3 01 02 03");
+        for invalid in [
+            {
+                let mut wire = unknown.clone();
+                wire.push(0);
+                wire
+            },
+            {
+                let mut wire = unknown.clone();
+                wire[2] |= 2;
+                wire
+            },
+            {
+                let mut wire = unknown.clone();
+                wire.pop();
+                wire
+            },
+            {
+                let mut wire = packet(1);
+                wire[6..8].copy_from_slice(&1_u16.to_be_bytes());
+                rr(&mut wire, 1, 2, &[1, 2, 3]);
+                wire
+            },
+        ] {
+            assert!(response(&invalid, &[]).is_err());
+        }
+    }
+
+    #[test]
+    fn escaping_stops_before_diagnostic_output_growth() {
+        struct Escaped;
+        impl fmt::Display for Escaped {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                for _ in 0..MAX_JSON_BYTES {
+                    f.write_str("\"\\")?;
+                }
+                Ok(())
+            }
+        }
+        let mut writer = BoundedJson(Vec::new());
+        assert!(serde_json::to_writer(&mut writer, &DisplayValue(Escaped)).is_err());
+        assert!(writer.0.len() <= MAX_JSON_BYTES);
+        assert!(writer.0.capacity() <= MAX_JSON_BYTES);
+    }
+}
diff --git a/src/controller/rules.rs b/src/controller/rules.rs
new file mode 100644
index 0000000..df74c2f
--- /dev/null
+++ b/src/controller/rules.rs
@@ -0,0 +1,115 @@
+//! Thin, bounded Controller adapter for temporary current-program switches.
+use std::{fmt, io};
+
+use serde::{
+    Deserialize, Deserializer,
+    de::{self, MapAccess, Visitor},
+};
+use tokio_util::sync::CancellationToken;
+
+use super::{ControllerIo, read_small_json_body, write_error, write_response};
+use crate::resource::control::{RuleUpdateError, RuntimeResources};
+
+pub(super) async fn disable<S: ControllerIo>(
+    stream: &mut S,
+    request: crate::inbound::http::RequestHead,
+    resources: Option<&dyn RuntimeResources>,
+    cancellation: CancellationToken,
+) -> io::Result<()> {
+    if request.method != "PATCH" {
+        return write_error(stream, 405, "Method not allowed", &[("Allow", "PATCH")]).await;
+    }
+    let Some(resources) = resources else {
+        return write_error(stream, 404, "Resource not found", &[]).await;
+    };
+    let Some(body) = read_small_json_body(
+        stream,
+        &request.headers,
+        request.buffered,
+        cancellation.clone(),
+    )
+    .await?
+    else {
+        return Ok(());
+    };
+    let Ok(RulePatch(changes)) = serde_json::from_slice::<RulePatch>(&body) else {
+        return write_error(stream, 400, "Body invalid", &[]).await;
+    };
+    if cancellation.is_cancelled() {
+        return Ok(());
+    }
+    match resources.disable_rules(&changes) {
+        Ok(()) => write_response(stream, 204, &[], &[]).await,
+        Err(RuleUpdateError::NotFound) => write_error(stream, 404, "Resource not found", &[]).await,
+        Err(RuleUpdateError::InvalidIndex) => {
+            write_error(stream, 400, "Rule index invalid", &[]).await
+        }
+    }
+}
+
+#[derive(Debug)]
+struct RulePatch(Vec<(usize, bool)>);
+impl<'de> Deserialize<'de> for RulePatch {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        struct PatchVisitor;
+        impl<'de> Visitor<'de> for PatchVisitor {
+            type Value = RulePatch;
+            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+                formatter.write_str("a rule-index to disabled-bool object")
+            }
+            fn visit_map<M: MapAccess<'de>>(self, mut object: M) -> Result<Self::Value, M::Error> {
+                let mut changes = Vec::new();
+                while let Some(key) = object.next_key::<String>()? {
+                    if key.is_empty() || !key.bytes().all(|byte| byte.is_ascii_digit()) {
+                        return Err(de::Error::custom("rule index invalid"));
+                    }
+                    let index = key
+                        .parse::<usize>()
+                        .map_err(|_| de::Error::custom("rule index invalid"))?;
+                    if changes.iter().any(|(old, _)| *old == index) {
+                        return Err(de::Error::custom("duplicate rule index"));
+                    }
+                    changes.push((index, object.next_value::<bool>()?));
+                }
+                Ok(RulePatch(changes))
+            }
+        }
+        deserializer.deserialize_map(PatchVisitor)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn patch_is_one_strict_object_with_unique_unsigned_indexes_and_bool_values() {
+        assert!(
+            serde_json::from_str::<RulePatch>("{}")
+                .unwrap()
+                .0
+                .is_empty()
+        );
+        assert_eq!(
+            serde_json::from_str::<RulePatch>(r#"{"0":true,"12":false}"#)
+                .unwrap()
+                .0,
+            [(0, true), (12, false)]
+        );
+        for body in [
+            r#"{"0":true,"0":false}"#,
+            r#"{"0":true,"00":false}"#,
+            r#"{"-1":true}"#,
+            r#"{"1.0":true}"#,
+            r#"{"0":null}"#,
+            r#"{"0":"true"}"#,
+            r#"{"0":1}"#,
+            r#"{"9999999999999999999999999999999999999999":true}"#,
+            "[]",
+            "null",
+            "{} {}",
+        ] {
+            assert!(serde_json::from_str::<RulePatch>(body).is_err(), "{body}");
+        }
+    }
+}
diff --git a/src/controller/tests_secure.rs b/src/controller/tests_secure.rs
new file mode 100644
index 0000000..a528ad7
--- /dev/null
+++ b/src/controller/tests_secure.rs
@@ -0,0 +1,221 @@
+use super::*;
+use crate::config::{ControllerCors, ControllerTls};
+use bytes::Bytes;
+
+fn context() -> RequestContext {
+    RequestContext {
+        secret: Some("token".into()),
+        traffic: None,
+        proxy_groups: tests::test_groups(),
+        resources: None,
+        cors: Arc::new(cors::Policy::new(&ControllerCors {
+            allow_origins: vec!["https://*.example".into()],
+            allow_private_network: true,
+        })),
+        requests: tokio_util::task::TaskTracker::new(),
+        subscriptions: Arc::new(tokio::sync::Semaphore::new(websocket::MAX_SUBSCRIPTIONS)),
+        logs: None,
+    }
+}
+
+async fn h1(request: &str, context: RequestContext) -> String {
+    let (mut client, server) = tokio::io::duplex(64 * 1024);
+    let serve = tokio::spawn(handle_connection(
+        H1Io(server),
+        context,
+        CancellationToken::new(),
+    ));
+    client.write_all(request.as_bytes()).await.unwrap();
+    let mut response = Vec::new();
+    client.read_to_end(&mut response).await.unwrap();
+    serve.await.unwrap().unwrap();
+    String::from_utf8(response).unwrap()
+}
+
+#[tokio::test]
+async fn controller_secure_http_cors_keeps_bearer_and_preflight_boundaries() {
+    let context = context();
+    let response = h1("OPTIONS /group HTTP/1.1\r\nHost: local\r\nOrigin: https://UI.example\r\nAccess-Control-Request-Method: PUT\r\nAccess-Control-Request-Headers: authorization, content-type\r\nAccess-Control-Request-Private-Network: true\r\n\r\n", context.clone()).await;
+    assert!(response.starts_with("HTTP/1.1 200"));
+    assert!(response.contains("Access-Control-Allow-Origin: https://UI.example\r\n"));
+    assert!(response.contains("Access-Control-Allow-Headers: Authorization, Content-Type\r\n"));
+    assert!(response.contains("Access-Control-Allow-Private-Network: true\r\n"));
+    assert!(response.contains("Access-Control-Max-Age: 300\r\n"));
+    assert_eq!(response.matches("Vary:").count(), 3);
+    assert!(!response.contains("Allow-Credentials"));
+    let response = h1(
+        "GET /group HTTP/1.1\r\nHost: local\r\nOrigin: https://ui.example\r\n\r\n",
+        context.clone(),
+    )
+    .await;
+    assert!(response.starts_with("HTTP/1.1 401"));
+    assert!(response.contains("Access-Control-Allow-Origin: https://ui.example"));
+    let response = h1("OPTIONS /group HTTP/1.1\r\nHost: local\r\nOrigin: https://other.invalid\r\nAccess-Control-Request-Method: PUT\r\n\r\n", context.clone()).await;
+    assert!(response.starts_with("HTTP/1.1 200"));
+    assert!(!response.contains("Access-Control-Allow-Origin"));
+    let response = h1("GET /group HTTP/1.1\r\nHost: local\r\nAuthorization: Bearer token\r\nOrigin: https://ui.example\r\n\r\n", context).await;
+    assert!(response.starts_with("HTTP/1.1 200"));
+    let body: serde_json::Value =
+        serde_json::from_str(response.split_once("\r\n\r\n").unwrap().1).unwrap();
+    assert_eq!(body["proxies"][0]["now"], "node-a");
+}
+
+fn tls() -> (Arc<tls::ServerTls>, Arc<rustls::ClientConfig>) {
+    let material = rcgen::generate_simple_self_signed(vec!["controller.example".into()]).unwrap();
+    use base64::Engine as _;
+    let pem = |label, bytes| {
+        format!(
+            "-----BEGIN {label}-----\n{}\n-----END {label}-----\n",
+            base64::engine::general_purpose::STANDARD.encode(bytes)
+        )
+    };
+    let options = ControllerTls {
+        certificate: pem("CERTIFICATE", material.cert.der().as_ref()).into(),
+        private_key: pem("PRIVATE KEY", &material.signing_key.serialize_der()).into(),
+        ..Default::default()
+    };
+    let server = Arc::new(tls::ServerTls::load(&options, std::path::Path::new(".")).unwrap());
+    let mut roots = rustls::RootCertStore::empty();
+    roots.add(material.cert.der().clone()).unwrap();
+    let client = rustls::ClientConfig::builder_with_provider(Arc::new(
+        rustls::crypto::ring::default_provider(),
+    ))
+    .with_safe_default_protocol_versions()
+    .unwrap()
+    .with_root_certificates(roots)
+    .with_no_client_auth();
+    (server, Arc::new(client))
+}
+
+#[tokio::test]
+async fn controller_secure_https_h1_and_real_h2_share_routes_and_stop_children() {
+    let (tls, client_config) = tls();
+    for alpn in [b"http/1.1".as_slice(), b"h2".as_slice()] {
+        let context = context();
+        let tracker = context.requests.clone();
+        let cancel = CancellationToken::new();
+        let (client, server) = tokio::io::duplex(64 * 1024);
+        let serve = tokio::spawn(transport::serve_tls(
+            server,
+            tls.clone(),
+            context,
+            cancel.clone(),
+        ));
+        let mut config = client_config.as_ref().clone();
+        config.alpn_protocols = vec![alpn.to_vec()];
+        config.resumption = rustls::client::Resumption::disabled();
+        let mut client = tokio_rustls::TlsConnector::from(Arc::new(config))
+            .connect("controller.example".try_into().unwrap(), client)
+            .await
+            .unwrap();
+        assert_eq!(client.get_ref().1.alpn_protocol(), Some(alpn));
+        if alpn == b"http/1.1" {
+            client
+                .write_all(
+                    b"GET /group HTTP/1.1\r\nHost: local\r\nAuthorization: Bearer token\r\n\r\n",
+                )
+                .await
+                .unwrap();
+            let mut response = Vec::new();
+            client.read_to_end(&mut response).await.unwrap();
+            assert!(response.starts_with(b"HTTP/1.1 200"));
+        } else {
+            let (mut sender, driver) = h2::client::handshake(client).await.unwrap();
+            let driver = tokio::spawn(driver);
+            let request = |method, path, body| {
+                let mut request = http::Request::builder()
+                    .method(method)
+                    .uri(path)
+                    .header("authorization", "Bearer token")
+                    .header("origin", "https://ui.example");
+                if body {
+                    request = request
+                        .header("content-type", "application/json")
+                        .header("content-length", "17");
+                }
+                request.body(()).unwrap()
+            };
+            let (aborted, mut upload) = sender
+                .send_request(
+                    request("PUT", "/proxies/%E4%B8%BB%E7%BA%BF%E8%B7%AF", true),
+                    false,
+                )
+                .unwrap();
+            while tracker.len() == 0 {
+                tokio::task::yield_now().await;
+            }
+            let (query, _) = sender
+                .send_request(request("GET", "/group", false), true)
+                .unwrap();
+            let response = query.await.unwrap();
+            assert_eq!(response.status(), 200);
+            assert_eq!(
+                response.headers()["access-control-allow-origin"],
+                "https://ui.example"
+            );
+            let mut body = response.into_body();
+            let mut json = Vec::new();
+            while let Some(bytes) = body.data().await {
+                let bytes = bytes.unwrap();
+                body.flow_control().release_capacity(bytes.len()).unwrap();
+                json.extend_from_slice(&bytes);
+            }
+            assert_eq!(
+                serde_json::from_slice::<serde_json::Value>(&json).unwrap()["proxies"][0]["now"],
+                "node-a"
+            );
+            upload.send_reset(h2::Reason::CANCEL);
+            assert!(aborted.await.is_err());
+            while tracker.len() != 0 {
+                tokio::task::yield_now().await;
+            }
+            let (selected, mut upload) = sender
+                .send_request(
+                    request("PUT", "/proxies/%E4%B8%BB%E7%BA%BF%E8%B7%AF", true),
+                    false,
+                )
+                .unwrap();
+            upload
+                .send_data(Bytes::from_static(b"{\"name\":\"node-b\"}"), true)
+                .unwrap();
+            assert_eq!(selected.await.unwrap().status(), 204);
+            let (query, _) = sender
+                .send_request(request("GET", "/group", false), true)
+                .unwrap();
+            let mut body = query.await.unwrap().into_body();
+            let mut json = Vec::new();
+            while let Some(bytes) = body.data().await {
+                let bytes = bytes.unwrap();
+                body.flow_control().release_capacity(bytes.len()).unwrap();
+                json.extend_from_slice(&bytes);
+            }
+            assert_eq!(
+                serde_json::from_slice::<serde_json::Value>(&json).unwrap()["proxies"][0]["now"],
+                "node-b"
+            );
+            let (waiting, _body) = sender
+                .send_request(
+                    request("PUT", "/proxies/%E4%B8%BB%E7%BA%BF%E8%B7%AF", true),
+                    false,
+                )
+                .unwrap();
+            while tracker.len() == 0 {
+                tokio::task::yield_now().await;
+            }
+            cancel.cancel();
+            serve.await.unwrap().unwrap();
+            tracker.close();
+            tokio::time::timeout(Duration::from_secs(2), tracker.wait())
+                .await
+                .unwrap();
+            assert_eq!(tracker.len(), 0);
+            assert!(waiting.await.is_err());
+            drop(sender);
+            let _ = driver.await.unwrap();
+            continue;
+        }
+        cancel.cancel();
+        serve.await.unwrap().unwrap();
+        assert_eq!(tracker.len(), 0);
+    }
+}
diff --git a/src/controller/tls.rs b/src/controller/tls.rs
new file mode 100644
index 0000000..14d566e
--- /dev/null
+++ b/src/controller/tls.rs
@@ -0,0 +1,306 @@
+use std::{
+    fs::OpenOptions,
+    io::{self, Read},
+    path::{Path, PathBuf},
+    sync::{Arc, RwLock},
+    time::{Duration, SystemTime},
+};
+
+use rsa::pkcs8::EncodePrivateKey;
+use rustls::{
+    pki_types::{CertificateDer, PrivateKeyDer, PrivatePkcs8KeyDer, UnixTime, pem::PemObject},
+    server::{
+        ClientHello, ResolvesServerCert, WebPkiClientVerifier,
+        danger::{ClientCertVerified, ClientCertVerifier},
+    },
+    sign::CertifiedKey,
+};
+use tokio_util::sync::CancellationToken;
+
+use crate::config::ControllerTls;
+
+#[cfg(test)]
+#[path = "tls_tests.rs"]
+mod tests;
+
+struct Resolver(RwLock<Arc<CertifiedKey>>);
+impl std::fmt::Debug for Resolver {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ControllerCertificateResolver")
+            .finish_non_exhaustive()
+    }
+}
+impl ResolvesServerCert for Resolver {
+    fn resolve(&self, _hello: ClientHello<'_>) -> Option<Arc<CertifiedKey>> {
+        Some(self.0.read().unwrap().clone())
+    }
+}
+
+pub(super) struct ServerTls {
+    pub config: Arc<rustls::ServerConfig>,
+    resolver: Arc<Resolver>,
+    files: Option<(PathBuf, PathBuf)>,
+}
+
+fn invalid() -> io::Error {
+    io::Error::new(
+        io::ErrorKind::InvalidInput,
+        "invalid controller TLS material",
+    )
+}
+
+fn pair(certificate: &[u8], private_key: &[u8]) -> io::Result<Arc<CertifiedKey>> {
+    if certificate.len().saturating_add(private_key.len()) > crate::config::MAX_CONFIG_BYTES {
+        return Err(invalid());
+    }
+    let certs = CertificateDer::pem_slice_iter(certificate)
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(|_| invalid())?;
+    let mut keys = PrivateKeyDer::pem_slice_iter(private_key);
+    let key = keys.next().ok_or_else(invalid)?.map_err(|_| invalid())?;
+    if keys.next().is_some() || certs.is_empty() {
+        return Err(invalid());
+    }
+    CertifiedKey::from_der(certs, key, &rustls::crypto::ring::default_provider())
+        .map(Arc::new)
+        .map_err(|_| invalid())
+}
+
+fn read_regular(path: &Path, remaining: &mut usize) -> io::Result<Vec<u8>> {
+    let mut options = OpenOptions::new();
+    options.read(true);
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::OpenOptionsExt;
+        options.custom_flags(libc::O_NONBLOCK);
+    }
+    let file = options.open(path).map_err(|_| invalid())?;
+    if !file.metadata().map_err(|_| invalid())?.is_file() {
+        return Err(invalid());
+    }
+    let mut data = Vec::new();
+    file.take(*remaining as u64 + 1)
+        .read_to_end(&mut data)
+        .map_err(|_| invalid())?;
+    if data.len() > *remaining {
+        return Err(invalid());
+    }
+    *remaining -= data.len();
+    Ok(data)
+}
+
+fn read_pair(files: &(PathBuf, PathBuf)) -> io::Result<Arc<CertifiedKey>> {
+    let mut remaining = crate::config::MAX_CONFIG_BYTES;
+    let certificate = read_regular(&files.0, &mut remaining)?;
+    let key = read_regular(&files.1, &mut remaining)?;
+    pair(&certificate, &key)
+}
+
+struct OsRandom;
+impl rsa::rand_core::CryptoRng for OsRandom {}
+impl rsa::rand_core::RngCore for OsRandom {
+    fn next_u32(&mut self) -> u32 {
+        rand::random()
+    }
+    fn next_u64(&mut self) -> u64 {
+        rand::random()
+    }
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        rand::fill(dest);
+    }
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rsa::rand_core::Error> {
+        self.fill_bytes(dest);
+        Ok(())
+    }
+}
+
+fn generated_pair() -> io::Result<Arc<CertifiedKey>> {
+    let key = rsa::RsaPrivateKey::new(&mut OsRandom, 2048).map_err(|_| invalid())?;
+    let der = key.to_pkcs8_der().map_err(|_| invalid())?;
+    let key_der = PrivateKeyDer::Pkcs8(PrivatePkcs8KeyDer::from(der.as_bytes()));
+    let key_pair = rcgen::KeyPair::from_der_and_sign_algo(&key_der, &rcgen::PKCS_RSA_SHA256)
+        .map_err(|_| invalid())?;
+    let mut params = rcgen::CertificateParams::default();
+    let now = SystemTime::now();
+    let year = Duration::from_secs(365 * 24 * 3600);
+    params.not_before = (now - year).into();
+    params.not_after = (now + year).into();
+    params.distinguished_name = rcgen::DistinguishedName::new();
+    params.serial_number = Some(1u64.into());
+    let certificate = params.self_signed(&key_pair).map_err(|_| invalid())?;
+    CertifiedKey::from_der(
+        vec![certificate.der().clone()],
+        key_der.clone_key(),
+        &rustls::crypto::ring::default_provider(),
+    )
+    .map(Arc::new)
+    .map_err(|_| invalid())
+}
+
+#[derive(Debug)]
+struct ProofVerifier {
+    mandatory: bool,
+}
+impl ClientCertVerifier for ProofVerifier {
+    fn client_auth_mandatory(&self) -> bool {
+        self.mandatory
+    }
+    fn root_hint_subjects(&self) -> &[rustls::DistinguishedName] {
+        &[]
+    }
+    fn verify_client_cert(
+        &self,
+        end_entity: &CertificateDer<'_>,
+        _intermediates: &[CertificateDer<'_>],
+        _now: UnixTime,
+    ) -> Result<ClientCertVerified, rustls::Error> {
+        rustls::server::ParsedCertificate::try_from(end_entity)?;
+        Ok(ClientCertVerified::assertion())
+    }
+    fn verify_tls12_signature(
+        &self,
+        message: &[u8],
+        cert: &CertificateDer<'_>,
+        dss: &rustls::DigitallySignedStruct,
+    ) -> Result<rustls::client::danger::HandshakeSignatureValid, rustls::Error> {
+        rustls::crypto::verify_tls12_signature(
+            message,
+            cert,
+            dss,
+            &rustls::crypto::ring::default_provider().signature_verification_algorithms,
+        )
+    }
+    fn verify_tls13_signature(
+        &self,
+        message: &[u8],
+        cert: &CertificateDer<'_>,
+        dss: &rustls::DigitallySignedStruct,
+    ) -> Result<rustls::client::danger::HandshakeSignatureValid, rustls::Error> {
+        rustls::crypto::verify_tls13_signature(
+            message,
+            cert,
+            dss,
+            &rustls::crypto::ring::default_provider().signature_verification_algorithms,
+        )
+    }
+    fn supported_verify_schemes(&self) -> Vec<rustls::SignatureScheme> {
+        rustls::crypto::ring::default_provider()
+            .signature_verification_algorithms
+            .supported_schemes()
+    }
+}
+
+fn verifier(options: &ControllerTls, root: &Path) -> io::Result<Arc<dyn ClientCertVerifier>> {
+    let mut mode = options.client_auth_type.as_ref();
+    if !matches!(
+        mode,
+        "request" | "require-any" | "verify-if-given" | "require-and-verify"
+    ) {
+        mode = if options.client_auth_cert.is_empty() {
+            ""
+        } else {
+            "require-and-verify"
+        };
+    }
+    match mode {
+        "request" | "require-any" => Ok(Arc::new(ProofVerifier {
+            mandatory: mode == "require-any",
+        })),
+        "verify-if-given" | "require-and-verify" => {
+            let inline = CertificateDer::pem_slice_iter(options.client_auth_cert.as_bytes())
+                .collect::<Result<Vec<_>, _>>();
+            let certs = match inline {
+                Ok(certs) if !certs.is_empty() => certs,
+                _ => {
+                    let path = crate::resource::cache::resource_path(
+                        root,
+                        &options.client_auth_cert,
+                        false,
+                    )
+                    .map_err(|_| invalid())?;
+                    let mut remaining = crate::config::MAX_CONFIG_BYTES;
+                    let bytes = read_regular(&path, &mut remaining)?;
+                    CertificateDer::pem_slice_iter(&bytes)
+                        .collect::<Result<Vec<_>, _>>()
+                        .map_err(|_| invalid())?
+                }
+            };
+            let mut roots = rustls::RootCertStore::empty();
+            for certificate in certs {
+                roots.add(certificate).map_err(|_| invalid())?;
+            }
+            let mut builder = WebPkiClientVerifier::builder_with_provider(
+                Arc::new(roots),
+                Arc::new(rustls::crypto::ring::default_provider()),
+            );
+            if mode == "verify-if-given" {
+                builder = builder.allow_unauthenticated();
+            }
+            builder.build().map_err(|_| invalid())
+        }
+        _ => Ok(Arc::new(rustls::server::NoClientAuth)),
+    }
+}
+
+impl ServerTls {
+    pub fn load(options: &ControllerTls, root: &Path) -> io::Result<Self> {
+        let (key, files) = if options.certificate.is_empty() && options.private_key.is_empty() {
+            (generated_pair()?, None)
+        } else if let Ok(key) = pair(
+            options.certificate.as_bytes(),
+            options.private_key.as_bytes(),
+        ) {
+            (key, None)
+        } else {
+            let files = (
+                crate::resource::cache::resource_path(root, &options.certificate, false)
+                    .map_err(|_| invalid())?,
+                crate::resource::cache::resource_path(root, &options.private_key, false)
+                    .map_err(|_| invalid())?,
+            );
+            (read_pair(&files)?, Some(files))
+        };
+        let resolver = Arc::new(Resolver(RwLock::new(key)));
+        let mut config = rustls::ServerConfig::builder_with_provider(Arc::new(
+            rustls::crypto::ring::default_provider(),
+        ))
+        .with_safe_default_protocol_versions()
+        .map_err(|_| invalid())?
+        .with_client_cert_verifier(verifier(options, root)?)
+        .with_cert_resolver(resolver.clone());
+        config.alpn_protocols = vec![b"h2".to_vec(), b"http/1.1".to_vec()];
+        Ok(Self {
+            config: Arc::new(config),
+            resolver,
+            files,
+        })
+    }
+
+    pub fn watches_files(&self) -> bool {
+        self.files.is_some()
+    }
+
+    pub async fn watch(self: Arc<Self>, cancellation: CancellationToken) {
+        let Some(files) = self.files.clone() else {
+            return;
+        };
+        let mut interval = tokio::time::interval(Duration::from_secs(1));
+        interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
+        loop {
+            tokio::select! { biased; () = cancellation.cancelled() => break, _ = interval.tick() => {} }
+            let files = files.clone();
+            // Await every blocking read, including during cancellation. Stop
+            // cannot return while a certificate candidate is still running.
+            let candidate = tokio::task::spawn_blocking(move || read_pair(&files)).await;
+            if cancellation.is_cancelled() {
+                break;
+            }
+            if let Ok(Ok(candidate)) = candidate {
+                let mut current = self.resolver.0.write().unwrap();
+                if current.cert != candidate.cert {
+                    *current = candidate;
+                }
+            }
+        }
+    }
+}
diff --git a/src/controller/tls_tests.rs b/src/controller/tls_tests.rs
new file mode 100644
index 0000000..1f89e4a
--- /dev/null
+++ b/src/controller/tls_tests.rs
@@ -0,0 +1,248 @@
+use super::*;
+use base64::Engine as _;
+use rcgen::{
+    BasicConstraints, CertificateParams, CertifiedIssuer, ExtendedKeyUsagePurpose, IsCa, KeyPair,
+    KeyUsagePurpose,
+};
+use rustls::sign::{Signer, SigningKey, SingleCertAndKey};
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+fn pem(label: &str, bytes: &[u8]) -> String {
+    format!(
+        "-----BEGIN {label}-----\n{}\n-----END {label}-----\n",
+        base64::engine::general_purpose::STANDARD.encode(bytes)
+    )
+}
+fn material() -> (ControllerTls, CertificateDer<'static>) {
+    let key = rcgen::generate_simple_self_signed(vec!["controller.example".into()]).unwrap();
+    (
+        ControllerTls {
+            certificate: pem("CERTIFICATE", key.cert.der()).into(),
+            private_key: pem("PRIVATE KEY", &key.signing_key.serialize_der()).into(),
+            ..Default::default()
+        },
+        key.cert.der().clone(),
+    )
+}
+fn authority() -> CertifiedIssuer<'static, KeyPair> {
+    let mut params = CertificateParams::default();
+    params.is_ca = IsCa::Ca(BasicConstraints::Unconstrained);
+    params.key_usages = vec![
+        KeyUsagePurpose::KeyCertSign,
+        KeyUsagePurpose::DigitalSignature,
+    ];
+    CertifiedIssuer::self_signed(params, KeyPair::generate().unwrap()).unwrap()
+}
+fn identity(issuer: &CertifiedIssuer<'_, KeyPair>) -> CertifiedKey {
+    let key = KeyPair::generate().unwrap();
+    let mut params = CertificateParams::new(vec!["client.example".into()]).unwrap();
+    params.extended_key_usages = vec![ExtendedKeyUsagePurpose::ClientAuth];
+    let cert = params.signed_by(&key, issuer).unwrap();
+    CertifiedKey::from_der(
+        vec![cert.der().clone()],
+        PrivateKeyDer::Pkcs8(key.serialize_der().into()),
+        &rustls::crypto::ring::default_provider(),
+    )
+    .unwrap()
+}
+#[derive(Debug)]
+struct WrongProof(Arc<dyn SigningKey>);
+#[derive(Debug)]
+struct WrongSignature(Box<dyn Signer>);
+impl SigningKey for WrongProof {
+    fn choose_scheme(&self, offered: &[rustls::SignatureScheme]) -> Option<Box<dyn Signer>> {
+        self.0
+            .choose_scheme(offered)
+            .map(|signer| Box::new(WrongSignature(signer)) as Box<dyn Signer>)
+    }
+    fn algorithm(&self) -> rustls::SignatureAlgorithm {
+        self.0.algorithm()
+    }
+}
+impl Signer for WrongSignature {
+    fn sign(&self, message: &[u8]) -> Result<Vec<u8>, rustls::Error> {
+        let mut signature = self.0.sign(message)?;
+        signature[0] ^= 1;
+        Ok(signature)
+    }
+    fn scheme(&self) -> rustls::SignatureScheme {
+        self.0.scheme()
+    }
+}
+
+async fn handshake(
+    server: Arc<rustls::ServerConfig>,
+    trust: &CertificateDer<'static>,
+    identity: Option<CertifiedKey>,
+    version: &'static rustls::SupportedProtocolVersion,
+) -> (bool, bool) {
+    let mut roots = rustls::RootCertStore::empty();
+    roots.add(trust.clone()).unwrap();
+    let builder = rustls::ClientConfig::builder_with_provider(Arc::new(
+        rustls::crypto::ring::default_provider(),
+    ))
+    .with_protocol_versions(&[version])
+    .unwrap()
+    .with_root_certificates(roots);
+    let mut client = if let Some(key) = identity {
+        builder.with_client_cert_resolver(Arc::new(SingleCertAndKey::from(key)))
+    } else {
+        builder.with_no_client_auth()
+    };
+    client.resumption = rustls::client::Resumption::disabled();
+    let (client_io, server_io) = tokio::io::duplex(64 * 1024);
+    let client = async {
+        let mut stream = tokio_rustls::TlsConnector::from(Arc::new(client))
+            .connect("controller.example".try_into().unwrap(), client_io)
+            .await?;
+        let byte = stream.read_u8().await?;
+        assert_eq!(byte, 42);
+        Ok::<_, io::Error>(())
+    };
+    let server = async {
+        let mut stream = tokio_rustls::TlsAcceptor::from(server)
+            .accept(server_io)
+            .await?;
+        let presented = stream.get_ref().1.peer_certificates().is_some();
+        stream.write_all(&[42]).await?;
+        stream.shutdown().await?;
+        Ok::<_, io::Error>(presented)
+    };
+    let (client, server) = tokio::time::timeout(Duration::from_secs(3), async {
+        tokio::join!(client, server)
+    })
+    .await
+    .unwrap();
+    (client.is_ok() && server.is_ok(), server.unwrap_or(false))
+}
+
+#[tokio::test]
+async fn controller_secure_tls_auth_modes_preserve_real_proof_and_ca_verification() {
+    let (base, certificate) = material();
+    let known = authority();
+    let unknown = authority();
+    for (mode, ca, expected) in [
+        ("", false, [true, true, true]),
+        ("unknown-mode", false, [true, true, true]),
+        ("request", false, [true, true, true]),
+        ("require-any", false, [false, true, true]),
+        ("verify-if-given", true, [true, true, false]),
+        ("require-and-verify", true, [false, true, false]),
+        ("", true, [false, true, false]),
+        ("request", true, [true, true, true]),
+    ] {
+        let mut options = base.clone();
+        options.client_auth_type = mode.into();
+        if ca {
+            options.client_auth_cert = pem("CERTIFICATE", known.der()).into();
+        }
+        let tls = ServerTls::load(&options, Path::new(".")).unwrap();
+        for version in [&rustls::version::TLS12, &rustls::version::TLS13] {
+            for (identity, accepted) in [
+                (None, expected[0]),
+                (Some(identity(&known)), expected[1]),
+                (Some(identity(&unknown)), expected[2]),
+            ] {
+                assert_eq!(
+                    handshake(tls.config.clone(), &certificate, identity, version)
+                        .await
+                        .0,
+                    accepted,
+                    "{mode}, {ca}, {version:?}"
+                );
+            }
+            if matches!(mode, "request" | "require-any") {
+                let mut wrong = identity(&unknown);
+                wrong.key = Arc::new(WrongProof(wrong.key));
+                assert!(
+                    !handshake(tls.config.clone(), &certificate, Some(wrong), version)
+                        .await
+                        .0
+                );
+            }
+        }
+    }
+}
+
+#[tokio::test]
+async fn controller_secure_tls_generates_random_rsa2048_with_matching_signing_key() {
+    use rsa::{pkcs8::DecodePublicKey as _, traits::PublicKeyParts as _};
+    let tls =
+        tokio::task::spawn_blocking(|| ServerTls::load(&ControllerTls::default(), Path::new(".")))
+            .await
+            .unwrap()
+            .unwrap();
+    assert!(!tls.watches_files());
+    let key = tls.resolver.0.read().unwrap().clone();
+    key.keys_match().unwrap();
+    assert_eq!(key.key.algorithm(), rustls::SignatureAlgorithm::RSA);
+    let certificate = rustls::server::ParsedCertificate::try_from(&key.cert[0]).unwrap();
+    let public_key =
+        rsa::RsaPublicKey::from_public_key_der(certificate.subject_public_key_info().as_ref())
+            .unwrap();
+    assert_eq!(public_key.n().bits(), 2048);
+    let signer = key
+        .key
+        .choose_scheme(&[rustls::SignatureScheme::RSA_PSS_SHA256])
+        .unwrap();
+    assert_eq!(signer.sign(b"controller fixture").unwrap().len(), 256);
+}
+
+#[tokio::test]
+async fn controller_secure_tls_file_candidates_keep_old_pair_and_stop_watcher() {
+    let root = tempfile::tempdir().unwrap();
+    let (first, first_certificate) = material();
+    let (second, second_certificate) = material();
+    let certificate_path = root.path().join("controller.pem");
+    let key_path = root.path().join("controller.key");
+    let ca = authority();
+    let ca_path = root.path().join("clients.pem");
+    std::fs::write(&ca_path, pem("CERTIFICATE", ca.der())).unwrap();
+    std::fs::write(&certificate_path, first.certificate.as_bytes()).unwrap();
+    std::fs::write(&key_path, first.private_key.as_bytes()).unwrap();
+    let tls = Arc::new(
+        ServerTls::load(
+            &ControllerTls {
+                certificate: "controller.pem".into(),
+                private_key: "controller.key".into(),
+                client_auth_type: "require-and-verify".into(),
+                client_auth_cert: "clients.pem".into(),
+                ..Default::default()
+            },
+            root.path(),
+        )
+        .unwrap(),
+    );
+    assert!(tls.watches_files());
+    let cancel = CancellationToken::new();
+    let watcher = tokio::spawn(tls.clone().watch(cancel.clone()));
+    std::fs::write(&ca_path, b"CA files are not reloaded during this session").unwrap();
+    std::fs::write(&certificate_path, b"invalid certificate candidate").unwrap();
+    tokio::time::sleep(Duration::from_millis(1100)).await;
+    assert_eq!(tls.resolver.0.read().unwrap().cert[0], first_certificate);
+    std::fs::write(&certificate_path, second.certificate.as_bytes()).unwrap();
+    std::fs::write(&key_path, second.private_key.as_bytes()).unwrap();
+    tokio::time::timeout(Duration::from_secs(3), async {
+        while tls.resolver.0.read().unwrap().cert[0] != second_certificate {
+            tokio::time::sleep(Duration::from_millis(10)).await;
+        }
+    })
+    .await
+    .unwrap();
+    assert!(
+        handshake(
+            tls.config.clone(),
+            &second_certificate,
+            Some(identity(&ca)),
+            &rustls::version::TLS13
+        )
+        .await
+        .0
+    );
+    cancel.cancel();
+    tokio::time::timeout(Duration::from_secs(2), watcher)
+        .await
+        .unwrap()
+        .unwrap();
+    assert!(!Arc::new(ServerTls::load(&first, root.path()).unwrap()).watches_files());
+}
diff --git a/src/controller/transport.rs b/src/controller/transport.rs
new file mode 100644
index 0000000..17b181d
--- /dev/null
+++ b/src/controller/transport.rs
@@ -0,0 +1,268 @@
+use std::{
+    future::Future,
+    io,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use bytes::Bytes;
+use tokio::io::{AsyncRead, AsyncWrite, AsyncWriteExt, ReadBuf};
+use tokio::task::JoinSet;
+use tokio_util::sync::CancellationToken;
+
+use super::{CONTROLLER_BODY_TIMEOUT, CONTROLLER_HEADER_TIMEOUT, RequestContext};
+
+pub(super) trait ControllerIo: AsyncRead + Unpin + Send {
+    fn websocket_io(&mut self) -> Option<&mut (dyn super::websocket::WebSocketIo + '_)> {
+        None
+    }
+    fn websocket_headers(&self) -> Vec<(String, String)> {
+        Vec::new()
+    }
+    fn respond(
+        &mut self,
+        status: u16,
+        headers: &[(&str, &str)],
+        body: &[u8],
+    ) -> impl Future<Output = io::Result<()>> + Send;
+}
+
+pub(super) struct H1Io<T>(pub T);
+impl<T: AsyncRead + Unpin> AsyncRead for H1Io<T> {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.0).poll_read(cx, buf)
+    }
+}
+impl<T: AsyncRead + AsyncWrite + Unpin + Send> ControllerIo for H1Io<T> {
+    fn websocket_io(&mut self) -> Option<&mut (dyn super::websocket::WebSocketIo + '_)> {
+        Some(&mut self.0)
+    }
+
+    async fn respond(
+        &mut self,
+        status: u16,
+        headers: &[(&str, &str)],
+        body: &[u8],
+    ) -> io::Result<()> {
+        let reason = http::StatusCode::from_u16(status)
+            .ok()
+            .and_then(|s| s.canonical_reason())
+            .unwrap_or("Error");
+        let mut head = format!(
+            "HTTP/1.1 {status} {reason}\r\nContent-Length: {}\r\nConnection: close\r\nCache-Control: no-store\r\n",
+            body.len()
+        );
+        for (name, value) in headers {
+            head.push_str(name);
+            head.push_str(": ");
+            head.push_str(value);
+            head.push_str("\r\n");
+        }
+        head.push_str("\r\n");
+        tokio::time::timeout(CONTROLLER_BODY_TIMEOUT, async {
+            self.0.write_all(head.as_bytes()).await?;
+            self.0.write_all(body).await?;
+            self.0.shutdown().await
+        })
+        .await
+        .map_err(|_| io::Error::new(io::ErrorKind::TimedOut, "controller response timed out"))?
+    }
+}
+
+pub(super) struct CorsIo<T> {
+    inner: T,
+    headers: Vec<(String, String)>,
+}
+impl<T> CorsIo<T> {
+    pub fn new(inner: T, headers: Vec<(String, String)>) -> Self {
+        Self { inner, headers }
+    }
+}
+impl<T: AsyncRead + Unpin> AsyncRead for CorsIo<T> {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.inner).poll_read(cx, buf)
+    }
+}
+impl<T: ControllerIo> ControllerIo for CorsIo<T> {
+    fn websocket_io(&mut self) -> Option<&mut (dyn super::websocket::WebSocketIo + '_)> {
+        self.inner.websocket_io()
+    }
+    fn websocket_headers(&self) -> Vec<(String, String)> {
+        let mut headers = self.inner.websocket_headers();
+        headers.extend(self.headers.clone());
+        headers
+    }
+
+    async fn respond(
+        &mut self,
+        status: u16,
+        headers: &[(&str, &str)],
+        body: &[u8],
+    ) -> io::Result<()> {
+        let mut all = Vec::with_capacity(headers.len() + self.headers.len());
+        all.extend_from_slice(headers);
+        all.extend(self.headers.iter().map(|(k, v)| (k.as_str(), v.as_str())));
+        self.inner.respond(status, &all, body).await
+    }
+}
+
+struct H2Io {
+    body: h2::RecvStream,
+    buffered: Bytes,
+    response: h2::server::SendResponse<Bytes>,
+}
+impl AsyncRead for H2Io {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        target: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        if target.remaining() == 0 {
+            return Poll::Ready(Ok(()));
+        }
+        loop {
+            if !self.buffered.is_empty() {
+                let count = target.remaining().min(self.buffered.len());
+                target.put_slice(&self.buffered.split_to(count));
+                return Poll::Ready(
+                    self.body
+                        .flow_control()
+                        .release_capacity(count)
+                        .map_err(io::Error::other),
+                );
+            }
+            match self.body.poll_data(cx) {
+                Poll::Pending => return Poll::Pending,
+                Poll::Ready(None) => return Poll::Ready(Ok(())),
+                Poll::Ready(Some(Err(error))) => return Poll::Ready(Err(io::Error::other(error))),
+                Poll::Ready(Some(Ok(data))) => self.buffered = data,
+            }
+        }
+    }
+}
+impl ControllerIo for H2Io {
+    async fn respond(
+        &mut self,
+        status: u16,
+        headers: &[(&str, &str)],
+        body: &[u8],
+    ) -> io::Result<()> {
+        let mut head = http::Response::builder()
+            .status(status)
+            .header("cache-control", "no-store")
+            .header("content-length", body.len());
+        for (name, value) in headers {
+            head = head.header(*name, *value);
+        }
+        let mut send = self
+            .response
+            .send_response(head.body(()).map_err(io::Error::other)?, body.is_empty())
+            .map_err(io::Error::other)?;
+        tokio::time::timeout(CONTROLLER_BODY_TIMEOUT, async {
+            let mut position = 0;
+            while position < body.len() {
+                send.reserve_capacity((body.len() - position).min(16 * 1024));
+                let capacity = std::future::poll_fn(|cx| send.poll_capacity(cx))
+                    .await
+                    .ok_or_else(|| {
+                        io::Error::new(io::ErrorKind::BrokenPipe, "controller stream closed")
+                    })?
+                    .map_err(io::Error::other)?;
+                let count = capacity.min(body.len() - position).min(16 * 1024);
+                if count == 0 {
+                    continue;
+                }
+                let end = position + count;
+                send.send_data(
+                    Bytes::copy_from_slice(&body[position..end]),
+                    end == body.len(),
+                )
+                .map_err(io::Error::other)?;
+                position = end;
+            }
+            Ok(())
+        })
+        .await
+        .map_err(|_| io::Error::new(io::ErrorKind::TimedOut, "controller response timed out"))?
+    }
+}
+
+pub(super) async fn serve_tls<T: AsyncRead + AsyncWrite + Unpin + Send + 'static>(
+    stream: T,
+    tls: std::sync::Arc<super::tls::ServerTls>,
+    context: RequestContext,
+    cancellation: CancellationToken,
+) -> io::Result<()> {
+    let stream = tokio::select! { biased;
+        () = cancellation.cancelled() => return Ok(()),
+        result = tokio::time::timeout(CONTROLLER_HEADER_TIMEOUT, tokio_rustls::TlsAcceptor::from(tls.config.clone()).accept(stream)) => result
+            .map_err(|_| io::Error::new(io::ErrorKind::TimedOut, "controller TLS handshake timed out"))??,
+    };
+    if stream.get_ref().1.alpn_protocol() == Some(b"h2") {
+        serve_h2(stream, context, cancellation).await
+    } else {
+        super::handle_connection(H1Io(stream), context, cancellation).await
+    }
+}
+
+pub(super) async fn serve_h2<T: AsyncRead + AsyncWrite + Unpin + Send + 'static>(
+    stream: T,
+    context: RequestContext,
+    cancellation: CancellationToken,
+) -> io::Result<()> {
+    let mut builder = h2::server::Builder::new();
+    builder
+        .max_concurrent_streams(8)
+        .initial_window_size(1024)
+        .initial_connection_window_size(8 * 1024)
+        .max_header_list_size(crate::inbound::DEFAULT_HEADER_LIMIT as u32)
+        .max_send_buffer_size(16 * 1024);
+    let mut connection = tokio::select! { biased;
+        () = cancellation.cancelled() => return Ok(()),
+        result = tokio::time::timeout(CONTROLLER_HEADER_TIMEOUT, builder.handshake::<_, Bytes>(stream)) => result
+            .map_err(|_| io::Error::new(io::ErrorKind::TimedOut, "controller H2 handshake timed out"))?.map_err(io::Error::other)?,
+    };
+    let mut tasks = JoinSet::new();
+    let result = loop {
+        tokio::select! { biased;
+            () = cancellation.cancelled() => break Ok(()),
+            joined = tasks.join_next(), if !tasks.is_empty() => {
+                if let Some(Err(error)) = joined { break Err(io::Error::other(error)); }
+            }
+            accepted = connection.accept() => {
+                let Some(accepted) = accepted else { break Ok(()); };
+                let (request, mut response) = match accepted { Ok(value) => value, Err(error) => break Err(io::Error::other(error)) };
+                if tasks.len() >= 8 { response.send_reset(h2::Reason::REFUSED_STREAM); continue; }
+                let target = request.uri().path_and_query().map_or("/", |value| value.as_str()).to_owned();
+                if target.len() > 8 * 1024 || request.headers().len() > crate::inbound::DEFAULT_HEADER_COUNT_LIMIT {
+                    response.send_reset(h2::Reason::PROTOCOL_ERROR); continue;
+                }
+                let mut headers = Vec::with_capacity(request.headers().len());
+                let mut valid = true;
+                for (name, value) in request.headers() {
+                    match value.to_str() { Ok(value) => headers.push((name.as_str().into(), value.into())), Err(_) => { valid = false; break; } }
+                }
+                if !valid { response.send_reset(h2::Reason::PROTOCOL_ERROR); continue; }
+                let head = crate::inbound::http::RequestHead { method: request.method().as_str().into(), target,
+                    version: "HTTP/2".into(), headers, buffered: Vec::new() };
+                let io = H2Io { body: request.into_body(), buffered: Bytes::new(), response };
+                let context = context.clone(); let child = cancellation.clone();
+                let tracking = context.requests.clone();
+                tasks.spawn(tracking.track_future(crate::resources::observation::task(async move {
+                    let _ = super::handle_request(io, head, context, child).await;
+                })));
+            }
+        }
+    };
+    tasks.abort_all();
+    while tasks.join_next().await.is_some() {}
+    result
+}
diff --git a/src/controller/unix.rs b/src/controller/unix.rs
new file mode 100644
index 0000000..7a739ae
--- /dev/null
+++ b/src/controller/unix.rs
@@ -0,0 +1,195 @@
+//! Linux local Controller listener; path ownership lives through Stop or drop.
+use socket2::{Domain, SockAddr, Socket, Type};
+use std::{
+    io,
+    os::{
+        fd::AsRawFd,
+        unix::fs::{FileTypeExt, MetadataExt, PermissionsExt},
+    },
+    path::{Path, PathBuf},
+};
+
+pub(super) struct Listener {
+    listener: tokio::net::UnixListener,
+    _path: OwnedPath,
+}
+impl Listener {
+    pub(super) fn bind(path: &str, root: &Path) -> io::Result<Self> {
+        let path = root.join(path);
+        // No pre-existing object is ours, including a stale socket or symlink.
+        match std::fs::symlink_metadata(&path) {
+            Ok(_) => {
+                return Err(io::Error::new(
+                    io::ErrorKind::AddrInUse,
+                    "Controller Unix path already exists",
+                ));
+            }
+            Err(error) if error.kind() == io::ErrorKind::NotFound => {}
+            Err(error) => return Err(error),
+        }
+        let socket = new_socket()?;
+        socket.bind(&SockAddr::unix(&path)?)?;
+        let owned = OwnedPath::capture(path)?;
+        owned.prepare_for_listen()?;
+        socket.listen(128)?;
+        let listener = tokio::net::UnixListener::from_std(socket.into())?;
+        Ok(Self {
+            listener,
+            _path: owned,
+        })
+    }
+    pub(super) async fn accept(&self) -> io::Result<tokio::net::UnixStream> {
+        self.listener.accept().await.map(|(stream, _)| stream)
+    }
+}
+fn new_socket() -> io::Result<Socket> {
+    let socket = Socket::new(Domain::UNIX, Type::STREAM, None)?;
+    socket.set_nonblocking(true)?;
+    // Linux bind inherits this inode mode, even if the new path is then moved.
+    if unsafe { libc::fchmod(socket.as_raw_fd(), 0o600) } < 0 {
+        return Err(io::Error::last_os_error());
+    }
+    Ok(socket)
+}
+struct OwnedPath {
+    path: PathBuf,
+    device: u64,
+    inode: u64,
+}
+impl OwnedPath {
+    fn prepare_for_listen(&self) -> io::Result<()> {
+        self.require_current()?;
+        // Restore owner bits that a restrictive process umask may have removed.
+        std::fs::set_permissions(&self.path, std::fs::Permissions::from_mode(0o600))?;
+        self.require_current()
+    }
+
+    fn require_current(&self) -> io::Result<()> {
+        let metadata = std::fs::symlink_metadata(&self.path)?;
+        if !metadata.file_type().is_socket()
+            || metadata.dev() != self.device
+            || metadata.ino() != self.inode
+        {
+            return Err(io::Error::new(
+                io::ErrorKind::AddrInUse,
+                "Controller Unix path changed before listen",
+            ));
+        }
+        Ok(())
+    }
+
+    fn capture(path: PathBuf) -> io::Result<Self> {
+        let metadata = std::fs::symlink_metadata(&path)?;
+        if !metadata.file_type().is_socket() {
+            return Err(io::Error::new(
+                io::ErrorKind::AddrInUse,
+                "Controller Unix path changed during bind",
+            ));
+        }
+        Ok(Self {
+            path,
+            device: metadata.dev(),
+            inode: metadata.ino(),
+        })
+    }
+}
+
+impl Drop for OwnedPath {
+    fn drop(&mut self) {
+        if let Ok(metadata) = std::fs::symlink_metadata(&self.path)
+            && metadata.file_type().is_socket()
+            && metadata.dev() == self.device
+            && metadata.ino() == self.inode
+        {
+            let _ = std::fs::remove_file(&self.path);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    struct Umask(libc::mode_t);
+    impl Umask {
+        fn set(mask: libc::mode_t) -> Self {
+            Self(unsafe { libc::umask(mask) })
+        }
+    }
+    impl Drop for Umask {
+        fn drop(&mut self) {
+            unsafe { libc::umask(self.0) };
+        }
+    }
+
+    #[test]
+    #[ignore = "requires isolated Linux container; run this module with --test-threads=1"]
+    fn socket_is_owner_only_before_path_permissions_are_applied() {
+        let root = tempfile::tempdir().unwrap();
+        let _umask = Umask::set(0);
+        let path = root.path().join("controller.sock");
+        let socket = new_socket().unwrap();
+        socket.bind(&SockAddr::unix(&path).unwrap()).unwrap();
+        let owned = OwnedPath::capture(path.clone()).unwrap();
+        assert_eq!(
+            std::fs::symlink_metadata(&path).unwrap().mode() & 0o777,
+            0o600
+        );
+        owned.prepare_for_listen().unwrap();
+        drop(owned);
+        assert!(!path.exists());
+    }
+
+    #[test]
+    #[ignore = "requires isolated Linux container; run this module with --test-threads=1"]
+    fn moved_socket_stays_private_and_replacement_is_not_prepared_or_removed() {
+        let root = tempfile::tempdir().unwrap();
+        let _umask = Umask::set(0);
+        let path = root.path().join("controller.sock");
+        let moved = root.path().join("moved.sock");
+        let socket = new_socket().unwrap();
+        socket.bind(&SockAddr::unix(&path).unwrap()).unwrap();
+        let owned = OwnedPath::capture(path.clone()).unwrap();
+        std::fs::rename(&path, &moved).unwrap();
+        let _replacement = std::os::unix::net::UnixListener::bind(&path).unwrap();
+        let replacement_inode = std::fs::symlink_metadata(&path).unwrap().ino();
+        let error = owned.prepare_for_listen().unwrap_err();
+        assert_eq!(error.kind(), io::ErrorKind::AddrInUse);
+        assert_eq!(
+            std::fs::symlink_metadata(&moved).unwrap().mode() & 0o777,
+            0o600
+        );
+        assert_eq!(
+            std::fs::symlink_metadata(&path).unwrap().mode() & 0o777,
+            0o777
+        );
+        drop(owned);
+        assert_eq!(
+            std::fs::symlink_metadata(&path).unwrap().ino(),
+            replacement_inode
+        );
+    }
+
+    #[tokio::test]
+    #[ignore = "requires isolated Linux container; run this module with --test-threads=1"]
+    async fn restrictive_umask_preserves_exact_permissions_accept_and_drop_cleanup() {
+        use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+        let root = tempfile::tempdir().unwrap();
+        let _umask = Umask::set(0o777);
+        let path = root.path().join("controller.sock");
+        let listener = Listener::bind("controller.sock", root.path()).unwrap();
+        assert_eq!(
+            std::fs::symlink_metadata(&path).unwrap().mode() & 0o777,
+            0o600
+        );
+        let mut client = tokio::net::UnixStream::connect(&path).await.unwrap();
+        let mut accepted = listener.accept().await.unwrap();
+        client.write_all(b"control").await.unwrap();
+        let mut bytes = [0; 7];
+        accepted.read_exact(&mut bytes).await.unwrap();
+        assert_eq!(&bytes, b"control");
+        drop(listener);
+        assert!(!path.exists());
+    }
+}
diff --git a/src/controller/websocket.rs b/src/controller/websocket.rs
new file mode 100644
index 0000000..1c8077b
--- /dev/null
+++ b/src/controller/websocket.rs
@@ -0,0 +1,640 @@
+//! Bounded subscriptions over the existing Controller routes and lifecycle.
+use super::{
+    CONTROLLER_BODY_TIMEOUT, ControllerIo, RequestContext, authorized, controller_token_eq,
+    header_values, write_error,
+};
+use crate::config::LogLevel;
+use base64::Engine as _;
+use futures_util::{SinkExt, StreamExt};
+use serde::Serialize;
+use std::{io, time::Duration};
+use tokio::io::{AsyncRead, AsyncWrite, AsyncWriteExt};
+use tokio_tungstenite::{
+    WebSocketStream,
+    tungstenite::{
+        Message,
+        handshake::derive_accept_key,
+        protocol::{Role, WebSocketConfig},
+    },
+};
+use tokio_util::sync::CancellationToken;
+
+pub(super) const MAX_SUBSCRIPTIONS: usize = 4;
+const MAX_MESSAGE_BYTES: usize = 256 * 1024;
+const MAX_SNAPSHOT_CONNECTIONS: usize = 512;
+
+pub(super) trait WebSocketIo: AsyncRead + AsyncWrite + Unpin + Send {}
+impl<T: AsyncRead + AsyncWrite + Unpin + Send> WebSocketIo for T {}
+
+pub(super) fn requested(request: &crate::inbound::http::RequestHead) -> bool {
+    header_values(&request.headers, "upgrade").any(|v| v.eq_ignore_ascii_case("websocket"))
+}
+
+#[derive(Clone, Copy)]
+enum Topic {
+    Traffic,
+    Memory,
+    Connections,
+    Logs { level: LogLevel, structured: bool },
+}
+struct Options {
+    topic: Topic,
+    interval: Duration,
+    token: Option<String>,
+}
+impl Options {
+    fn parse(target: &str) -> Result<Self, ()> {
+        if target.len() > 8192 || target.contains('#') {
+            return Err(());
+        }
+        let (path, query) = target.split_once('?').unwrap_or((target, ""));
+        let mut token = None;
+        let mut interval = None;
+        let mut level = None;
+        let mut format = None;
+        for (key, value) in url::form_urlencoded::parse(query.as_bytes()) {
+            match key.as_ref() {
+                "token" if token.is_none() => token = Some(value.into_owned()),
+                "interval" if path == "/connections" && interval.is_none() => {
+                    let value = value.parse::<u64>().map_err(|_| ())?;
+                    if !(100..=60_000).contains(&value) {
+                        return Err(());
+                    }
+                    interval = Some(Duration::from_millis(value));
+                }
+                "level" if path == "/logs" && level.is_none() => {
+                    level = Some(match value.as_ref() {
+                        "debug" => LogLevel::Debug,
+                        "info" => LogLevel::Info,
+                        "warning" => LogLevel::Warning,
+                        "error" => LogLevel::Error,
+                        "silent" => LogLevel::Silent,
+                        _ => return Err(()),
+                    });
+                }
+                "format" if path == "/logs" && format.is_none() => {
+                    format = Some(value.into_owned())
+                }
+                _ => return Err(()),
+            }
+        }
+        let topic = match path {
+            "/traffic" => Topic::Traffic,
+            "/memory" => Topic::Memory,
+            "/connections" => Topic::Connections,
+            "/logs" => Topic::Logs {
+                level: level.unwrap_or(LogLevel::Info),
+                structured: format.as_deref() == Some("structured"),
+            },
+            _ => return Err(()),
+        };
+        Ok(Self {
+            topic,
+            token,
+            interval: interval.unwrap_or(Duration::from_secs(1)),
+        })
+    }
+}
+fn valid_handshake(request: &crate::inbound::http::RequestHead) -> Option<String> {
+    let unique = |name: &'static str| {
+        let mut values = header_values(&request.headers, name);
+        let value = values.next()?;
+        values.next().is_none().then_some(value)
+    };
+    if request.method != "GET"
+        || request.version != "HTTP/1.1"
+        || unique("host").is_none()
+        || unique("upgrade").is_none_or(|v| !v.eq_ignore_ascii_case("websocket"))
+        || unique("sec-websocket-version") != Some("13")
+        || header_values(&request.headers, "transfer-encoding")
+            .next()
+            .is_some()
+    {
+        return None;
+    }
+    let mut length = header_values(&request.headers, "content-length");
+    if length.next().is_some_and(|value| value != "0") || length.next().is_some() {
+        return None;
+    }
+    if !header_values(&request.headers, "connection")
+        .flat_map(|value| value.split(','))
+        .any(|value| value.trim().eq_ignore_ascii_case("upgrade"))
+    {
+        return None;
+    }
+    let key = unique("sec-websocket-key")?;
+    if key.len() != 24
+        || base64::engine::general_purpose::STANDARD
+            .decode(key)
+            .ok()?
+            .len()
+            != 16
+    {
+        return None;
+    }
+    Some(derive_accept_key(key.as_bytes()))
+}
+
+pub(super) async fn handle<S: ControllerIo>(
+    stream: &mut S,
+    request: crate::inbound::http::RequestHead,
+    context: RequestContext,
+    cancel: CancellationToken,
+) -> io::Result<()> {
+    let Ok(options) = Options::parse(&request.target) else {
+        return write_error(stream, 400, "Bad request", &[]).await;
+    };
+    let authenticated = match (context.secret.as_deref(), options.token.as_deref()) {
+        (Some(secret), Some(token)) => controller_token_eq(token.as_bytes(), secret.as_bytes()),
+        _ => authorized(&request.headers, context.secret.as_deref()),
+    };
+    if !authenticated {
+        return write_error(
+            stream,
+            401,
+            "Unauthorized",
+            &[("WWW-Authenticate", "Bearer")],
+        )
+        .await;
+    }
+    let Some(accept) = valid_handshake(&request) else {
+        return write_error(stream, 400, "Bad request", &[]).await;
+    };
+    if stream.websocket_io().is_none() {
+        return write_error(stream, 400, "WebSocket requires HTTP/1.1", &[]).await;
+    }
+    let registry = context
+        .resources
+        .as_ref()
+        .map(|resources| resources.connections());
+    if matches!(options.topic, Topic::Traffic | Topic::Connections) && registry.is_none() {
+        return write_error(stream, 404, "Resource not found", &[]).await;
+    }
+    if matches!(options.topic, Topic::Logs { .. }) && context.logs.is_none() {
+        return write_error(stream, 404, "Resource not found", &[]).await;
+    }
+    let Ok(_permit) = context.subscriptions.try_acquire() else {
+        return write_error(stream, 503, "Subscription limit reached", &[]).await;
+    };
+    let mut head = format!(
+        "HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Accept: {accept}\r\nCache-Control: no-store\r\n"
+    );
+    for (name, value) in stream.websocket_headers() {
+        head.push_str(&name);
+        head.push_str(": ");
+        head.push_str(&value);
+        head.push_str("\r\n");
+    }
+    head.push_str("\r\n");
+    let io = stream.websocket_io().expect("checked HTTP/1.1 transport");
+    tokio::select! { biased;
+        () = cancel.cancelled() => return Ok(()),
+        result = tokio::time::timeout(CONTROLLER_BODY_TIMEOUT, async { io.write_all(head.as_bytes()).await?; io.flush().await }) => result.map_err(|_| timed_out())??,
+    }
+    let config = WebSocketConfig::default()
+        .read_buffer_size(1024)
+        .write_buffer_size(0)
+        .max_write_buffer_size(MAX_MESSAGE_BYTES + 64)
+        .max_message_size(Some(1024))
+        .max_frame_size(Some(1024));
+    let mut websocket =
+        WebSocketStream::from_partially_read(io, request.buffered, Role::Server, Some(config))
+            .await;
+    match options.topic {
+        Topic::Logs { level, structured } => {
+            let mut subscription = context.logs.as_ref().unwrap().subscribe();
+            loop {
+                tokio::select! { biased;
+                    () = cancel.cancelled() => return Ok(()),
+                    incoming = websocket.next() => { if !incoming_message(&mut websocket, incoming, &cancel).await? { return Ok(()); } },
+                    event = subscription.recv() => {
+                        let Some(event) = event else { return Ok(()); };
+                        if event.matches(level) { send_json(&mut websocket,&event.json(structured),&cancel).await?; }
+                    }
+                }
+            }
+        }
+        topic => {
+            let mut tick = tokio::time::interval(options.interval);
+            tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
+            if !matches!(topic, Topic::Connections) {
+                tick.reset();
+            }
+            let mut totals = registry
+                .as_ref()
+                .map_or((0, 0), |registry| registry.totals());
+            let mut last = tokio::time::Instant::now();
+            loop {
+                tokio::select! { biased;
+                    () = cancel.cancelled() => return Ok(()),
+                    incoming = websocket.next() => { if !incoming_message(&mut websocket,incoming,&cancel).await? { return Ok(()); } },
+                    _ = tick.tick() => {
+                        match topic {
+                            Topic::Traffic => {
+                                let current = registry.as_ref().unwrap().totals();
+                                let elapsed = last.elapsed().as_secs_f64().max(0.001);
+                                let value = serde_json::json!({"up":((current.0.saturating_sub(totals.0)) as f64/elapsed) as u64,"down":((current.1.saturating_sub(totals.1)) as f64/elapsed) as u64,"upTotal":current.0,"downTotal":current.1});
+                                totals = current;
+                                last = tokio::time::Instant::now();
+                                send_json(&mut websocket,&value,&cancel).await?;
+                            }
+                            Topic::Memory => send_json(&mut websocket,&serde_json::json!({"inuse":crate::memory::resident_bytes(),"oslimit":null}),&cancel).await?,
+                            Topic::Connections => {
+                                let snapshot = registry.as_ref().unwrap().snapshot_bounded(MAX_SNAPSHOT_CONNECTIONS).ok_or_else(|| io::Error::other("Controller snapshot exceeds its subscription budget"))?;
+                                send_json(&mut websocket,&snapshot,&cancel).await?;
+                            }
+                            Topic::Logs{..} => unreachable!(),
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+fn timed_out() -> io::Error {
+    io::Error::new(
+        io::ErrorKind::TimedOut,
+        "Controller subscription write timed out",
+    )
+}
+async fn send_json<T: Serialize + Sync, S: AsyncRead + AsyncWrite + Unpin>(
+    socket: &mut WebSocketStream<S>,
+    value: &T,
+    cancel: &CancellationToken,
+) -> io::Result<()> {
+    let mut bytes = BoundedJson(Vec::new());
+    serde_json::to_writer(&mut bytes, value)
+        .map_err(|_| io::Error::other("Controller subscription exceeds its message budget"))?;
+    let text = String::from_utf8(bytes.0).expect("JSON is UTF-8");
+    tokio::select! { biased;
+        () = cancel.cancelled() => Ok(()),
+        result = tokio::time::timeout(CONTROLLER_BODY_TIMEOUT,socket.send(Message::Text(text.into()))) => result.map_err(|_| timed_out())?.map_err(|_| io::Error::other("Controller subscription closed")),
+    }
+}
+async fn incoming_message<S: AsyncRead + AsyncWrite + Unpin>(
+    socket: &mut WebSocketStream<S>,
+    message: Option<Result<Message, tokio_tungstenite::tungstenite::Error>>,
+    cancel: &CancellationToken,
+) -> io::Result<bool> {
+    match message {
+        Some(Ok(Message::Pong(_))) => Ok(true),
+        Some(Ok(Message::Ping(_))) => {
+            tokio::select! { biased;
+                () = cancel.cancelled() => Ok(false),
+                result = tokio::time::timeout(CONTROLLER_BODY_TIMEOUT,socket.flush()) => { result.map_err(|_| timed_out())?.map_err(|_| io::Error::other("Controller subscription closed"))?; Ok(true) }
+            }
+        }
+        Some(Ok(Message::Close(_))) => {
+            tokio::select! { biased;
+                () = cancel.cancelled() => {},
+                _ = tokio::time::timeout(CONTROLLER_BODY_TIMEOUT, socket.flush()) => {},
+            }
+            Ok(false)
+        }
+        None => Ok(false),
+        _ => Err(io::Error::other("Invalid Controller subscription frame")),
+    }
+}
+struct BoundedJson(Vec<u8>);
+impl io::Write for BoundedJson {
+    fn write(&mut self, bytes: &[u8]) -> io::Result<usize> {
+        if self
+            .0
+            .len()
+            .checked_add(bytes.len())
+            .is_none_or(|size| size > MAX_MESSAGE_BYTES)
+        {
+            return Err(io::Error::other(
+                "Controller subscription exceeds its message budget",
+            ));
+        }
+        let needed = self.0.len() + bytes.len();
+        if needed > self.0.capacity() {
+            let target = needed
+                .max(self.0.capacity().max(1024).saturating_mul(2))
+                .min(MAX_MESSAGE_BYTES);
+            self.0
+                .try_reserve_exact(target - self.0.len())
+                .map_err(|_| io::Error::other("Controller message allocation failed"))?;
+        }
+        self.0.extend_from_slice(bytes);
+        Ok(bytes.len())
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::connections::Registry;
+    use crate::resource::control::{DnsSnapshot, RuntimeResources};
+    use crate::routing::{ProxyGroupError, ProxyGroups};
+    use std::sync::Arc;
+    use tokio::io::{AsyncReadExt, DuplexStream};
+
+    struct Resources {
+        registry: Arc<Registry>,
+        groups: Arc<ProxyGroups>,
+    }
+    #[async_trait::async_trait]
+    impl RuntimeResources for Resources {
+        fn connections(&self) -> Arc<Registry> {
+            self.registry.clone()
+        }
+        fn configs(&self) -> serde_json::Value {
+            serde_json::Value::Null
+        }
+        fn rules(&self) -> serde_json::Value {
+            serde_json::json!({"rules":[]})
+        }
+        fn groups(&self) -> Arc<ProxyGroups> {
+            self.groups.clone()
+        }
+        fn select(&self, group: &str, member: &str) -> Result<(), ProxyGroupError> {
+            self.groups.select(group, member)
+        }
+        fn clear_fixed(&self, group: &str) -> Result<(), ProxyGroupError> {
+            self.groups.clear_fixed(group)
+        }
+        fn health(&self) -> serde_json::Value {
+            serde_json::json!({"proxies":{}})
+        }
+        fn providers(&self, _: bool) -> serde_json::Value {
+            serde_json::json!({"providers":{}})
+        }
+        fn dns(&self) -> Option<DnsSnapshot> {
+            None
+        }
+        async fn refresh(&self, _: bool, _: &str) -> Result<(), &'static str> {
+            Err("not configured")
+        }
+    }
+    fn context() -> (RequestContext, Arc<Registry>) {
+        let groups = super::super::tests::test_groups();
+        let registry = Arc::new(Registry::default());
+        (
+            RequestContext {
+                secret: Some("token".into()),
+                traffic: None,
+                proxy_groups: groups.clone(),
+                resources: Some(Arc::new(Resources {
+                    registry: registry.clone(),
+                    groups,
+                })),
+                cors: Arc::new(super::super::cors::Policy::new(
+                    &crate::config::ControllerCors::default(),
+                )),
+                requests: tokio_util::task::TaskTracker::new(),
+                subscriptions: Arc::new(tokio::sync::Semaphore::new(MAX_SUBSCRIPTIONS)),
+                logs: Some(Arc::new(crate::logging::RuntimeLog::new(LogLevel::Info))),
+            },
+            registry,
+        )
+    }
+    fn info() -> crate::connections::ConnectionInfo {
+        crate::connections::ConnectionInfo {
+            metadata: crate::connections::ConnectionMetadata {
+                network: "tcp",
+                inbound_type: "Tun",
+                source: "198.18.0.1:1234".parse().unwrap(),
+                destination_ip: Some("198.51.100.1".parse().unwrap()),
+                destination_port: 443,
+                host: "fixture.invalid".into(),
+                dns_mode: "normal",
+                sniff_host: "".into(),
+                process: Default::default(),
+                original: None,
+            },
+            chains: vec!["DIRECT".into()],
+            provider_chains: Vec::new(),
+            rule: "Match",
+            rule_payload: "".into(),
+            dns_path: Vec::new(),
+        }
+    }
+    async fn open(
+        path: &str,
+        context: RequestContext,
+        capacity: usize,
+    ) -> (
+        WebSocketStream<DuplexStream>,
+        tokio::task::JoinHandle<io::Result<()>>,
+        CancellationToken,
+    ) {
+        let (client, server) = tokio::io::duplex(capacity);
+        let cancel = CancellationToken::new();
+        let task = tokio::spawn(super::super::handle_connection(
+            super::super::H1Io(server),
+            context,
+            cancel.clone(),
+        ));
+        let (client, response) =
+            tokio_tungstenite::client_async(format!("ws://controller{path}"), client)
+                .await
+                .unwrap();
+        assert_eq!(response.status(), 101);
+        (client, task, cancel)
+    }
+    async fn json(client: &mut WebSocketStream<DuplexStream>) -> serde_json::Value {
+        let message = client.next().await.unwrap().unwrap();
+        serde_json::from_str(message.to_text().unwrap()).unwrap()
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn controller_websocket_traffic_connections_memory_and_stop_share_runtime_state() {
+        let (context, registry) = context();
+        let (mut traffic, traffic_task, traffic_cancel) =
+            open("/traffic?token=token", context.clone(), 4096).await;
+        tokio::task::yield_now().await;
+        let connection = registry.open(info());
+        connection.upload(101);
+        connection.download(203);
+        let value = json(&mut traffic).await;
+        assert_eq!(value["upTotal"], 101);
+        assert_eq!(value["downTotal"], 203);
+        assert_eq!(value["up"], 101);
+        assert_eq!(value["down"], 203);
+        let (mut connections, connections_task, connections_cancel) = open(
+            "/connections?interval=100&token=token",
+            context.clone(),
+            4096,
+        )
+        .await;
+        let value = json(&mut connections).await;
+        assert_eq!(value["uploadTotal"], 101);
+        assert_eq!(value["connections"][0]["metadata"]["type"], "Tun");
+        let id = value["connections"][0]["id"].as_str().unwrap();
+        registry.close(id);
+        let value = json(&mut connections).await;
+        assert!(value["connections"].as_array().unwrap().is_empty());
+        assert!(connection.cancelled());
+        let (mut memory, memory_task, memory_cancel) =
+            open("/memory?token=token", context.clone(), 4096).await;
+        assert!(json(&mut memory).await.get("inuse").is_some());
+        traffic_cancel.cancel();
+        connections_cancel.cancel();
+        memory_cancel.cancel();
+        traffic_task.await.unwrap().unwrap();
+        connections_task.await.unwrap().unwrap();
+        memory_task.await.unwrap().unwrap();
+        assert_eq!(context.subscriptions.available_permits(), MAX_SUBSCRIPTIONS);
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn controller_websocket_admission_and_slow_consumers_remain_bounded() {
+        let (context, _) = context();
+        let (client, task, _cancel) = open("/memory?token=token", context.clone(), 64).await;
+        let result = tokio::time::timeout(Duration::from_secs(10), task)
+            .await
+            .unwrap()
+            .unwrap();
+        assert_eq!(result.unwrap_err().kind(), io::ErrorKind::TimedOut);
+        assert_eq!(context.subscriptions.available_permits(), MAX_SUBSCRIPTIONS);
+        drop(client);
+        let permit = context
+            .subscriptions
+            .acquire_many(MAX_SUBSCRIPTIONS as u32)
+            .await
+            .unwrap();
+        let (client, server) = tokio::io::duplex(4096);
+        let task = tokio::spawn(super::super::handle_connection(
+            super::super::H1Io(server),
+            context.clone(),
+            CancellationToken::new(),
+        ));
+        let error = tokio_tungstenite::client_async("ws://controller/memory?token=token", client)
+            .await
+            .unwrap_err();
+        match error {
+            tokio_tungstenite::tungstenite::Error::Http(response) => {
+                assert_eq!(response.status(), 503)
+            }
+            _ => panic!("expected HTTP refusal"),
+        }
+        task.await.unwrap().unwrap();
+        drop(permit);
+    }
+
+    #[tokio::test]
+    async fn controller_websocket_query_auth_and_buffered_control_frames_are_preserved() {
+        let (context, _) = context();
+        for path in ["/memory?token=wrong", "/memory?token=token&token=token"] {
+            let (client, server) = tokio::io::duplex(4096);
+            let task = tokio::spawn(super::super::handle_connection(
+                super::super::H1Io(server),
+                context.clone(),
+                CancellationToken::new(),
+            ));
+            let error = tokio_tungstenite::client_async(format!("ws://controller{path}"), client)
+                .await
+                .unwrap_err();
+            match error {
+                tokio_tungstenite::tungstenite::Error::Http(response) => assert_eq!(
+                    response.status(),
+                    if path.contains("wrong") { 401 } else { 400 }
+                ),
+                _ => panic!("expected authentication refusal"),
+            }
+            task.await.unwrap().unwrap();
+        }
+        let (mut client, server) = tokio::io::duplex(4096);
+        let cancel = CancellationToken::new();
+        let task = tokio::spawn(super::super::handle_connection(
+            super::super::H1Io(server),
+            context,
+            cancel.clone(),
+        ));
+        let mut request=b"GET /memory?token=token HTTP/1.1\r\nHost: controller\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n\r\n".to_vec();
+        request.extend_from_slice(&[0x89, 0x83, 1, 2, 3, 4, b'a' ^ 1, b'b' ^ 2, b'c' ^ 3]);
+        client.write_all(&request).await.unwrap();
+        let mut head = Vec::new();
+        while !head.ends_with(b"\r\n\r\n") {
+            head.push(client.read_u8().await.unwrap());
+        }
+        assert!(head.starts_with(b"HTTP/1.1 101"));
+        let mut socket = WebSocketStream::from_raw_socket(client, Role::Client, None).await;
+        let message = tokio::time::timeout(Duration::from_secs(1), socket.next())
+            .await
+            .unwrap()
+            .unwrap()
+            .unwrap();
+        assert_eq!(message, Message::Pong(b"abc".to_vec().into()));
+        cancel.cancel();
+        task.await.unwrap().unwrap();
+    }
+
+    #[test]
+    fn controller_websocket_serialization_limits_before_growing_and_connections_are_not_truncated()
+    {
+        let mut writer = BoundedJson(Vec::new());
+        let value = vec!["x".repeat(1024); 512];
+        assert!(serde_json::to_writer(&mut writer, &value).is_err());
+        assert!(writer.0.len() <= MAX_MESSAGE_BYTES);
+        assert!(writer.0.capacity() <= MAX_MESSAGE_BYTES);
+        let (_, registry) = context();
+        let _connection = registry.open(info());
+        assert!(registry.snapshot_bounded(0).is_none());
+        assert!(registry.snapshot_bounded(1).is_some());
+        assert_eq!(registry.totals(), (0, 0));
+    }
+
+    #[tokio::test]
+    async fn controller_websocket_logs_use_the_session_bus_and_rest_tokens_do_not_authenticate() {
+        let (mut context, _) = context();
+        let filtered = crate::logging::dispatch(LogLevel::Debug);
+        context.logs = tracing::dispatcher::with_default(&filtered, crate::logging::current);
+        let (mut client, task, cancel) = open(
+            "/logs?level=warning&format=structured&token=token",
+            context.clone(),
+            4096,
+        )
+        .await;
+        tokio::task::yield_now().await;
+        tracing::dispatcher::with_default(&filtered, || {
+            tracing::info!(target:"vole::controller",bytes=1,"not requested");
+            tracing::warn!(target:"external::library",bytes=7,secret="synthetic credential","synthetic message");
+        });
+        let value = tokio::time::timeout(Duration::from_secs(1), json(&mut client))
+            .await
+            .unwrap();
+        assert_eq!(value["level"], "warn");
+        assert!(value["message"].as_str().unwrap().contains("bytes=7"));
+        assert!(
+            value["message"]
+                .as_str()
+                .unwrap()
+                .contains("synthetic credential")
+        );
+        assert!(
+            value["message"]
+                .as_str()
+                .unwrap()
+                .contains("synthetic message")
+        );
+        assert!(
+            value["message"]
+                .as_str()
+                .unwrap()
+                .contains("external::library")
+        );
+        cancel.cancel();
+        task.await.unwrap().unwrap();
+
+        let (mut client, server) = tokio::io::duplex(4096);
+        let task = tokio::spawn(super::super::handle_connection(
+            super::super::H1Io(server),
+            context,
+            CancellationToken::new(),
+        ));
+        client
+            .write_all(b"GET /version?token=token HTTP/1.1\r\nHost: controller\r\n\r\n")
+            .await
+            .unwrap();
+        let mut response = Vec::new();
+        client.read_to_end(&mut response).await.unwrap();
+        assert!(response.starts_with(b"HTTP/1.1 401"));
+        task.await.unwrap().unwrap();
+    }
+}
diff --git a/src/dialer.rs b/src/dialer.rs
index 64f7ef0..c58bfd7 100644
--- a/src/dialer.rs
+++ b/src/dialer.rs
@@ -1,3 +1,31 @@
+#[path = "dialer_connections.rs"]
+mod connections;
+#[cfg(all(feature = "tun", target_os = "linux"))]
+#[path = "dialer_ping.rs"]
+mod ping;
+#[cfg(all(feature = "tun", target_os = "linux"))]
+pub(crate) use ping::{PhysicalPing, PingReceipt};
+#[cfg(target_os = "linux")]
+#[path = "dialer_fast_open.rs"]
+mod fast_open;
+#[cfg(target_os = "linux")]
+#[path = "dialer_mptcp.rs"]
+mod mptcp;
+#[cfg(all(target_os = "linux", test, feature = "tun"))]
+#[path = "dialer_mptcp_gate.rs"]
+mod mptcp_gate;
+#[cfg(target_os = "linux")]
+#[path = "dialer_native.rs"]
+mod native;
+#[path = "dialer_server_tcp.rs"]
+mod server_tcp;
+#[cfg(all(target_os = "linux", feature = "sing-mux"))]
+#[path = "dialer_tcp_control.rs"]
+pub(crate) mod tcp_control;
+#[cfg(all(windows, any(feature = "windows-uwp", feature = "windows-wintun")))]
+#[path = "dialer_windows.rs"]
+mod windows_egress;
+pub(crate) use connections::race_connections;
 use std::{
     io,
     net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, ToSocketAddrs as _},
@@ -12,7 +40,7 @@ use std::{
 
 #[cfg(unix)]
 use std::os::fd::AsRawFd;
-#[cfg(all(windows, feature = "windows-uwp"))]
+#[cfg(all(windows, any(feature = "windows-uwp", feature = "windows-wintun")))]
 use std::{
     num::NonZeroU32,
     os::windows::io::{AsRawSocket, RawSocket},
@@ -26,7 +54,7 @@ use tokio::{
     time::timeout,
 };
 use tokio_util::{sync::CancellationToken, task::TaskTracker};
-#[cfg(all(windows, feature = "windows-uwp"))]
+#[cfg(all(windows, any(feature = "windows-uwp", feature = "windows-wintun")))]
 use windows::Win32::Networking::WinSock::{
     IP_UNICAST_IF, IPPROTO_IP, IPPROTO_IPV6, IPV6_UNICAST_IF, SOCKET, SOCKET_ERROR,
     WSAGetLastError, setsockopt,
@@ -37,6 +65,10 @@ use crate::resources::observation::{ObservedIo, ResourceKind, track};
 
 pub type PhysicalStream = ObservedIo<tokio::net::TcpStream>;
 pub type PhysicalDatagram = ObservedIo<UdpSocket>;
+#[derive(Clone, Copy, Debug, Default)]
+pub(crate) struct UdpSocketOptions {
+    pub receive_buffer: Option<usize>,
+}
 
 const MAX_RESOLVED_ADDRESSES: usize = 8;
 
@@ -246,7 +278,9 @@ pub trait SocketProtector: Send + Sync {
     fn protect(&self, socket: i32) -> io::Result<()>;
 }
 
-/// Owns synchronous socket setup independently of the async I/O workers.
+/// Owns synchronous socket setup and its shutdown barrier. Platform/custom
+/// work stays on blocking workers; verified Linux native setup may instead
+/// hold the same owner through a short, typed executor-local operation.
 /// A started syscall cannot be aborted; shutdown must wait for its result to
 /// be delivered or destroyed before releasing any platform callback lease.
 #[derive(Debug)]
@@ -255,6 +289,7 @@ struct SocketInitialization {
     cancellation: CancellationToken,
     tasks: TaskTracker,
     submissions: Arc<Semaphore>,
+    process_submissions: Arc<Semaphore>,
 }
 
 impl Default for SocketInitialization {
@@ -264,6 +299,7 @@ impl Default for SocketInitialization {
             cancellation: CancellationToken::new(),
             tasks: TaskTracker::new(),
             submissions: Arc::new(Semaphore::new(MAX_SOCKET_INITIALIZATIONS)),
+            process_submissions: Arc::new(Semaphore::new(4)),
         }
     }
 }
@@ -350,6 +386,14 @@ fn socket_initialization_cancelled() -> io::Error {
     )
 }
 
+fn new_plain_tcp_socket(ipv6: bool) -> io::Result<TcpSocket> {
+    if ipv6 {
+        TcpSocket::new_v6()
+    } else {
+        TcpSocket::new_v4()
+    }
+}
+
 #[derive(Debug, Clone, Copy)]
 struct SourceBinding {
     ipv4: Option<Ipv4Addr>,
@@ -365,6 +409,18 @@ struct InterfaceBinding {
 
 #[derive(Clone)]
 pub struct Dialer {
+    tfo: bool,
+    mptcp: bool,
+    egress: crate::config::EgressOptions,
+    dns_sources: Arc<crate::dns::source::NetworkSources>,
+    dns_binding: Option<crate::dns::source::DnsBinding>,
+    dns_tun_interface: Option<Arc<str>>,
+    #[cfg(all(windows, feature = "windows-uwp"))]
+    physical_adapter: Option<Arc<str>>,
+    #[cfg(all(target_os = "linux", feature = "tun"))]
+    linux_policy: Option<Arc<crate::platform::linux_network::SocketPolicy>>,
+    ip_version: crate::config::IpVersion,
+    connections: crate::config::ConnectionSettings,
     initialization: Arc<SocketInitialization>,
     protector: Option<Arc<dyn SocketProtector>>,
     source_binding: Option<SourceBinding>,
@@ -378,11 +434,14 @@ impl std::fmt::Debug for Dialer {
     fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let mut debug = formatter.debug_struct("Dialer");
         debug
+            .field("has_dns_binding", &self.dns_binding.is_some())
             .field("has_protector", &self.protector.is_some())
             .field("source_binding", &self.source_binding);
         #[cfg(all(windows, feature = "windows-uwp"))]
         debug.field("interface_binding", &self.interface_binding);
         debug
+            .field("tfo", &self.tfo)
+            .field("mptcp", &self.mptcp)
             .field("ipv6", &self.ipv6)
             .field("connect_timeout", &self.connect_timeout)
             .finish()
@@ -392,6 +451,18 @@ impl std::fmt::Debug for Dialer {
 impl Default for Dialer {
     fn default() -> Self {
         Self {
+            tfo: false,
+            mptcp: false,
+            egress: Default::default(),
+            dns_sources: Arc::new(crate::dns::source::NetworkSources::default()),
+            dns_binding: None,
+            dns_tun_interface: None,
+            #[cfg(all(windows, feature = "windows-uwp"))]
+            physical_adapter: None,
+            #[cfg(all(target_os = "linux", feature = "tun"))]
+            linux_policy: None,
+            ip_version: crate::config::IpVersion::Dual,
+            connections: crate::config::ConnectionSettings::default(),
             initialization: Arc::new(SocketInitialization::default()),
             protector: None,
             source_binding: None,
@@ -404,6 +475,367 @@ impl Default for Dialer {
 }
 
 impl Dialer {
+    /// Only immutable direct egress may donate a private active H2 connection.
+    #[cfg(feature = "outbound-vless")]
+    pub(crate) fn permits_static_h2_reuse(&self) -> bool {
+        if self.protector.is_some()
+            || self.dns_binding.is_some()
+            || self.source_binding.is_some()
+            || self.egress.interface.is_some()
+            || self.mptcp
+            || self.ip_version != crate::config::IpVersion::Dual
+        {
+            return false;
+        }
+        #[cfg(all(windows, feature = "windows-uwp"))]
+        if self.physical_adapter.is_some() || self.interface_binding.is_some() {
+            return false;
+        }
+        #[cfg(all(target_os = "linux", feature = "tun"))]
+        if self
+            .linux_policy
+            .as_ref()
+            .is_some_and(|policy| policy.detects_interface())
+        {
+            return false;
+        }
+        true
+    }
+
+    #[cfg(feature = "outbound-vless")]
+    pub(crate) fn h2_reuse_cancellation(&self) -> CancellationToken {
+        self.initialization.cancellation.clone()
+    }
+
+    pub(crate) fn with_egress(mut self, options: &crate::config::EgressOptions) -> Self {
+        self.egress = self.egress.overlay(options);
+        self
+    }
+
+    pub(crate) fn validate_egress(&self) -> io::Result<()> {
+        #[cfg(not(target_os = "linux"))]
+        if self.egress.routing_mark != 0 {
+            return Err(io::Error::new(
+                io::ErrorKind::Unsupported,
+                "routing-mark requires Linux",
+            ));
+        }
+        #[cfg(not(any(
+            target_os = "linux",
+            target_os = "macos",
+            target_os = "ios",
+            target_os = "tvos",
+            all(windows, any(feature = "windows-uwp", feature = "windows-wintun"))
+        )))]
+        if self.egress.interface.is_some() {
+            return Err(io::Error::new(
+                io::ErrorKind::Unsupported,
+                "interface-name binding is unavailable on this target",
+            ));
+        }
+        Ok(())
+    }
+    pub(crate) fn with_dns_sources(
+        mut self,
+        sources: Arc<crate::dns::source::NetworkSources>,
+    ) -> Self {
+        self.dns_sources = sources;
+        self
+    }
+    pub(crate) fn dns_sources(&self) -> Arc<crate::dns::source::NetworkSources> {
+        self.dns_sources.clone()
+    }
+    #[cfg(any(target_os = "linux", target_os = "macos"))]
+    pub(crate) fn with_dns_tun_interface(mut self, interface: Option<Arc<str>>) -> Self {
+        self.dns_tun_interface = interface;
+        self
+    }
+    pub(crate) fn dns_tun_interface(&self) -> Option<Arc<str>> {
+        self.dns_tun_interface.clone()
+    }
+    pub(crate) fn for_dns_source(
+        &self,
+        binding: crate::dns::source::DnsBinding,
+        endpoint: SocketAddr,
+    ) -> io::Result<Self> {
+        #[cfg(all(windows, feature = "windows-uwp"))]
+        if self.physical_adapter.as_deref() != Some(binding.interface.as_ref())
+            || self.interface_binding.is_none()
+        {
+            return Err(io::Error::new(
+                io::ErrorKind::PermissionDenied,
+                "DNS source is outside the physical network binding",
+            ));
+        }
+        #[cfg(all(windows, feature = "windows-uwp"))]
+        if let SocketAddr::V6(endpoint) = endpoint
+            && endpoint.scope_id() != 0
+            && self
+                .interface_binding
+                .and_then(|binding| binding.ipv6.map(|(_, index)| index.get()))
+                != Some(endpoint.scope_id())
+        {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "DNS source scope does not match its binding",
+            ));
+        }
+        let _ = endpoint;
+        #[cfg(any(target_os = "android", all(windows, not(feature = "windows-uwp"))))]
+        let _ = binding;
+        #[cfg(any(target_os = "android", all(windows, not(feature = "windows-uwp"))))]
+        return Err(io::Error::new(
+            io::ErrorKind::Unsupported,
+            "exact physical DNS interface binding is unavailable",
+        ));
+        #[cfg(not(any(target_os = "android", all(windows, not(feature = "windows-uwp")))))]
+        {
+            let mut dialer = self.clone();
+            dialer.dns_binding = Some(binding);
+            Ok(dialer)
+        }
+    }
+    #[cfg(all(windows, feature = "windows-uwp"))]
+    pub(crate) fn with_physical_adapter(mut self, adapter: Arc<str>) -> Self {
+        self.physical_adapter = Some(adapter);
+        self
+    }
+    #[cfg(all(windows, feature = "windows-uwp"))]
+    pub(crate) fn physical_dns_adapter(&self) -> Option<Arc<str>> {
+        self.physical_adapter.clone()
+    }
+    #[cfg(any(target_os = "linux", all(windows, feature = "windows-uwp")))]
+    pub(crate) async fn run_dns_discovery<T, F>(&self, operation: F) -> io::Result<T>
+    where
+        T: Send + 'static,
+        F: FnOnce(&dyn Fn() -> io::Result<()>) -> io::Result<T> + Send + 'static,
+    {
+        self.initialization.run(operation).await
+    }
+    #[cfg(unix)]
+    fn apply_socket_policy(
+        &self,
+        socket: &impl AsRawFd,
+        destination: SocketAddr,
+    ) -> io::Result<()> {
+        self.validate_egress()?;
+        if destination.ip().is_loopback() && self.dns_binding.is_none() {
+            // Local proxies must remain reachable when a physical default
+            // interface is selected. Keep native TUN's private isolation.
+            #[cfg(all(target_os = "linux", feature = "tun"))]
+            if let Some(policy) = &self.linux_policy {
+                return policy.apply(socket, destination, 0);
+            }
+            return Ok(());
+        }
+        #[cfg(target_os = "linux")]
+        if self.egress.routing_mark != 0 {
+            let value = self.egress.routing_mark;
+            // SAFETY: the live socket and u32 match Linux SO_MARK.
+            if unsafe {
+                libc::setsockopt(
+                    socket.as_raw_fd(),
+                    libc::SOL_SOCKET,
+                    libc::SO_MARK,
+                    (&raw const value).cast(),
+                    std::mem::size_of_val(&value) as libc::socklen_t,
+                )
+            } < 0
+            {
+                return Err(io::Error::last_os_error());
+            }
+        }
+        let binding = self.dns_binding.clone().or_else(|| {
+            self.egress
+                .interface
+                .clone()
+                .map(|interface| crate::dns::source::DnsBinding {
+                    interface,
+                    interface_index: None,
+                })
+        });
+        let Some(binding) = binding else {
+            #[cfg(all(target_os = "linux", feature = "tun"))]
+            if let Some(policy) = &self.linux_policy {
+                return policy.apply(socket, destination, self.egress.routing_mark);
+            }
+            return Ok(());
+        };
+        let name = std::ffi::CString::new(binding.interface.as_ref())
+            .map_err(|_| io::ErrorKind::InvalidInput)?;
+        // SAFETY: `name` is terminated and only inspected by the kernel.
+        let index = unsafe { libc::if_nametoindex(name.as_ptr()) };
+        if index == 0 {
+            return Err(io::Error::new(
+                io::ErrorKind::NotFound,
+                "outbound interface is unavailable",
+            ));
+        }
+        if binding
+            .interface_index
+            .is_some_and(|expected| expected.get() != index)
+        {
+            return Err(io::Error::new(
+                io::ErrorKind::NotFound,
+                "DNS source interface generation changed",
+            ));
+        }
+        if let SocketAddr::V6(address) = destination
+            && address.scope_id() != 0
+            && address.scope_id() != index
+        {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "DNS source scope does not match its interface",
+            ));
+        }
+        #[cfg(all(target_os = "linux", feature = "tun"))]
+        if let Some(policy) = &self.linux_policy {
+            return policy.apply_with_interface(
+                socket,
+                destination,
+                self.egress.routing_mark,
+                Some(binding.interface.as_ref()),
+            );
+        }
+        #[cfg(target_os = "linux")]
+        let status = unsafe {
+            libc::setsockopt(
+                socket.as_raw_fd(),
+                libc::SOL_SOCKET,
+                libc::SO_BINDTODEVICE,
+                name.as_ptr().cast(),
+                name.as_bytes_with_nul().len() as libc::socklen_t,
+            )
+        };
+        #[cfg(any(target_os = "macos", target_os = "ios", target_os = "tvos"))]
+        let status = {
+            let (level, option) = if destination.is_ipv6() {
+                (libc::IPPROTO_IPV6, libc::IPV6_BOUND_IF)
+            } else {
+                (libc::IPPROTO_IP, libc::IP_BOUND_IF)
+            };
+            // SAFETY: the option is a live u32 and socket is initialized here.
+            unsafe {
+                libc::setsockopt(
+                    socket.as_raw_fd(),
+                    level,
+                    option,
+                    (&raw const index).cast(),
+                    std::mem::size_of_val(&index) as libc::socklen_t,
+                )
+            }
+        };
+        #[cfg(not(any(
+            target_os = "linux",
+            target_os = "macos",
+            target_os = "ios",
+            target_os = "tvos"
+        )))]
+        return Err(io::ErrorKind::Unsupported.into());
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "macos",
+            target_os = "ios",
+            target_os = "tvos"
+        ))]
+        if status < 0 {
+            Err(io::Error::last_os_error())
+        } else {
+            Ok(())
+        }
+    }
+    pub(crate) fn with_connections(mut self, settings: crate::config::ConnectionSettings) -> Self {
+        self.connections = settings;
+        self
+    }
+    pub(crate) fn connections(&self) -> crate::config::ConnectionSettings {
+        self.connections
+    }
+    #[cfg(all(target_os = "linux", feature = "tun"))]
+    pub(crate) fn with_linux_policy(
+        mut self,
+        policy: Arc<crate::platform::linux_network::SocketPolicy>,
+    ) -> Self {
+        self.linux_policy = Some(policy);
+        self
+    }
+
+    /// Exact node policy: false does not inherit another node's TFO setting.
+    pub(crate) fn with_tfo(mut self, tfo: bool) -> Self {
+        self.tfo = tfo;
+        self
+    }
+
+    pub(crate) fn with_mptcp(mut self, mptcp: bool) -> Self {
+        self.mptcp = mptcp;
+        self
+    }
+
+    pub(crate) fn with_ip_version(mut self, version: crate::config::IpVersion) -> Self {
+        self.ip_version = version;
+        self
+    }
+    pub(crate) fn ip_version(&self) -> crate::config::IpVersion {
+        self.ip_version
+    }
+    pub(crate) fn ordered_addresses(&self, addresses: &[SocketAddr]) -> Vec<SocketAddr> {
+        let mut addresses = addresses
+            .iter()
+            .copied()
+            .filter(|address| self.ipv6 || address.is_ipv4())
+            .collect();
+        self.ip_version.order(&mut addresses);
+        addresses
+    }
+
+    /// Connected TCP and explicitly opted-in UDP node endpoints use physical
+    /// IP4P addresses before family/source/interface selection. Generic UDP
+    /// ordering and bind_udp_for deliberately retain their original addresses.
+    pub(crate) fn ordered_connected_addresses(&self, addresses: &[SocketAddr]) -> Vec<SocketAddr> {
+        let mut addresses = addresses
+            .iter()
+            .filter_map(|address| self.connected_address(*address).ok())
+            .collect();
+        self.ip_version.order(&mut addresses);
+        addresses
+    }
+    pub(crate) fn ip4p_loopback_restricted(&self) -> bool {
+        #[cfg(all(windows, feature = "windows-uwp"))]
+        {
+            self.interface_binding.is_some()
+        }
+        #[cfg(not(all(windows, feature = "windows-uwp")))]
+        {
+            false
+        }
+    }
+    pub(crate) fn connected_address(&self, original: SocketAddr) -> io::Result<SocketAddr> {
+        let actual = self.connections.convert_ip4p_endpoint(original);
+        preserve_ip4p_loopback(original, actual, !self.ip4p_loopback_restricted())?;
+        self.require_permitted(actual)?;
+        Ok(actual)
+    }
+
+    pub(crate) fn validate_connected_endpoint(
+        &self,
+        endpoint: &ResolvedEndpoint,
+    ) -> io::Result<()> {
+        if !self.connections.dialer_ip4p_convert {
+            return Ok(());
+        }
+        let allow_loopback =
+            endpoint.logical_host.parse::<IpAddr>().is_ok() && !self.ip4p_loopback_restricted();
+        for original in &endpoint.addresses {
+            preserve_ip4p_loopback(
+                *original,
+                self.connections.convert_ip4p_endpoint(*original),
+                allow_loopback,
+            )?;
+        }
+        Ok(())
+    }
+
     /// Start a new owner for a Running Session or private measurement. Policy
     /// is retained, but stopping one graph must not close another session.
     pub(crate) fn with_fresh_initialization(mut self) -> Self {
@@ -418,6 +850,47 @@ impl Dialer {
     pub(crate) async fn shutdown(&self) {
         self.initialization.shutdown().await;
     }
+    pub(crate) async fn process_identity(
+        &self,
+        query: crate::process::Query,
+    ) -> io::Result<crate::process::Identity> {
+        self.inspect_process(move |check| crate::process::lookup(query, check))
+            .await
+    }
+    async fn inspect_process<F>(&self, operation: F) -> io::Result<crate::process::Identity>
+    where
+        F: FnOnce(&dyn Fn() -> io::Result<()>) -> io::Result<crate::process::Identity>
+            + Send
+            + 'static,
+    {
+        // Four ordinary simultaneous lookups wait briefly instead of silently
+        // losing identity due to a single busy scanner. No detached waiter/task.
+        let capacity = self.initialization.process_submissions.clone();
+        let permit = tokio::select! {
+            biased;
+            () = self.initialization.cancellation.cancelled() => return Err(socket_initialization_cancelled()),
+            permit = tokio::time::timeout(crate::process::LOOKUP_TIME, capacity.acquire_owned()) => {
+                match permit { Ok(Ok(permit)) => permit, _ => return Ok(Default::default()) }
+            }
+        };
+        let result = tokio::time::timeout(
+            crate::process::LOOKUP_TIME,
+            self.initialization.run(move |check| {
+                let _permit = permit;
+                operation(check)
+            }),
+        )
+        .await;
+        result
+            .unwrap_or_else(|_| Ok(Default::default()))
+            .or_else(|error| {
+                if error.kind() == io::ErrorKind::Interrupted {
+                    Err(error)
+                } else {
+                    Ok(Default::default())
+                }
+            })
+    }
 
     #[must_use]
     pub(crate) const fn with_ipv6(mut self, ipv6: bool) -> Self {
@@ -469,12 +942,23 @@ impl Dialer {
     }
 
     pub async fn connect(&self, endpoint: &ResolvedEndpoint) -> io::Result<PhysicalStream> {
+        // DNS resolution may precede physical conversion; keep the resolver's
+        // hostname -> loopback denial after decoding too. Literal loopback
+        // nodes retain their existing exemption.
+        self.validate_connected_endpoint(endpoint)?;
+        let addresses = self.ordered_connected_addresses(&endpoint.addresses);
+        if self.connections.tcp_concurrent && !addresses.is_empty() {
+            let preferred = match self.ip_version {
+                crate::config::IpVersion::Ipv4Prefer => Some(false),
+                crate::config::IpVersion::Ipv6Prefer => Some(true),
+                _ => None,
+            };
+            return race_connections(&addresses, preferred, |address| self.connect_one(address))
+                .await;
+        }
         let mut last_error = None;
-        for address in &endpoint.addresses {
-            if !self.ipv6 && address.is_ipv6() {
-                continue;
-            }
-            match self.connect_one(*address).await {
+        for address in addresses {
+            match self.connect_one(address).await {
                 Ok(stream) => return Ok(stream),
                 Err(error) => last_error = Some(error),
             }
@@ -500,35 +984,90 @@ impl Dialer {
     /// Creates a direct UDP socket for one destination and applies the
     /// platform protect or binding policy before exposing it to the caller.
     pub async fn bind_udp_for(&self, destination: SocketAddr) -> io::Result<PhysicalDatagram> {
+        self.bind_udp_for_with_receive_buffer(destination, None)
+            .await
+    }
+
+    pub(crate) async fn bind_udp_for_with_receive_buffer(
+        &self,
+        destination: SocketAddr,
+        receive_buffer_size: Option<usize>,
+    ) -> io::Result<PhysicalDatagram> {
+        self.bind_udp_for_with_options(
+            destination,
+            UdpSocketOptions {
+                receive_buffer: receive_buffer_size,
+            },
+        )
+        .await
+    }
+    pub(crate) async fn bind_udp_for_with_options(
+        &self,
+        destination: SocketAddr,
+        options: UdpSocketOptions,
+    ) -> io::Result<PhysicalDatagram> {
         self.require_permitted(destination)?;
-        let ipv6 = destination.is_ipv6();
+        self.validate_egress()?;
         let bind_address = self
             .source_address_for(destination)?
-            .unwrap_or_else(|| wildcard_address(ipv6));
+            .unwrap_or_else(|| wildcard_address(destination.is_ipv6()));
+        #[cfg(target_os = "linux")]
+        if self.permits_plain_native_socket_setup() {
+            return self
+                .bind_plain_native_udp_socket(destination, bind_address, options)
+                .await;
+        }
         let dialer = self.clone();
         let (socket, guard) = self
             .initialization
             .run(move |check| {
-                let socket = Socket::new(
-                    if ipv6 { Domain::IPV6 } else { Domain::IPV4 },
-                    Type::DGRAM,
-                    Some(Protocol::UDP),
-                )?;
-                let guard = track(ResourceKind::Socket);
-                check()?;
-                #[cfg(all(windows, feature = "windows-uwp"))]
-                dialer.apply_interface_binding(socket.as_raw_socket(), destination)?;
-                socket.bind(&bind_address.into())?;
-                socket.set_nonblocking(true)?;
-                check()?;
-                dialer.protect_socket(&socket)?;
-                check()?;
-                Ok((std::net::UdpSocket::from(socket), guard))
+                dialer.configure_udp_socket(destination, bind_address, options, check)
             })
             .await?;
         Ok(ObservedIo::with_guard(UdpSocket::from_std(socket)?, guard))
     }
 
+    fn configure_udp_socket(
+        &self,
+        destination: SocketAddr,
+        bind_address: SocketAddr,
+        options: UdpSocketOptions,
+        check: &dyn Fn() -> io::Result<()>,
+    ) -> io::Result<(std::net::UdpSocket, crate::resources::observation::Guard)> {
+        let socket = Socket::new(
+            if destination.is_ipv6() {
+                Domain::IPV6
+            } else {
+                Domain::IPV4
+            },
+            Type::DGRAM,
+            Some(Protocol::UDP),
+        )?;
+        let guard = track(ResourceKind::Socket);
+        check()?;
+        #[cfg(all(windows, feature = "windows-uwp"))]
+        self.apply_interface_binding(socket.as_raw_socket(), destination)?;
+        #[cfg(all(windows, any(feature = "windows-uwp", feature = "windows-wintun")))]
+        self.apply_configured_interface(socket.as_raw_socket(), destination)?;
+        socket.bind(&bind_address.into())?;
+        // Buffer sizing is a performance hint. Keep this same
+        // owned socket and its platform policy if the OS refuses it.
+        // socket2 converts usize to c_int, so skip invalid hints.
+        if let Some(size) = options
+            .receive_buffer
+            .filter(|&size| size > 0 && size <= i32::MAX as usize)
+        {
+            let _ = socket.set_recv_buffer_size(size);
+        }
+        socket.set_nonblocking(true)?;
+        check()?;
+        self.protect_socket(&socket)?;
+        #[cfg(unix)]
+        self.apply_socket_policy(&socket, destination)?;
+        check()?;
+        Ok((std::net::UdpSocket::from(socket), guard))
+    }
+
     fn source_address_for(&self, destination: SocketAddr) -> io::Result<Option<SocketAddr>> {
         #[cfg(all(windows, feature = "windows-uwp"))]
         if self.interface_binding.is_some() && destination.ip().is_loopback() {
@@ -614,37 +1153,106 @@ impl Dialer {
         Ok(())
     }
 
+    // Returns explicitly pending single-address I/O and the converted physical
+    // address. Ordinary connect()/address races keep their eager TCP contract.
+    #[cfg(target_os = "linux")]
+    pub(crate) async fn prepare_tcp_fast_open(
+        &self,
+        address: SocketAddr,
+        deadline: tokio::time::Instant,
+    ) -> io::Result<(ObservedIo<fast_open::PendingFastOpen>, SocketAddr)> {
+        let deadline = deadline.min(tokio::time::Instant::now() + self.connect_timeout);
+        let operation = async {
+            let (socket, guard, address) = self.prepare_tcp_socket(address).await?;
+            let stream = tokio_tfo::TfoStream::connect_with_socket(socket, address).await?;
+            stream.set_nodelay(true)?;
+            let stream = fast_open::PendingFastOpen::new(stream, deadline, &self.initialization)?;
+            Ok((ObservedIo::with_guard(stream, guard), address))
+        };
+        tokio::select! {
+            biased;
+            () = self.initialization.cancellation.cancelled() => Err(socket_initialization_cancelled()),
+            result = tokio::time::timeout_at(deadline, operation) => {
+                result.map_err(|_| io::Error::new(io::ErrorKind::TimedOut, "connect timed out"))?
+            }
+        }
+    }
+
     async fn connect_one(&self, address: SocketAddr) -> io::Result<PhysicalStream> {
-        self.require_permitted(address)?;
+        let (socket, guard, address) = self.prepare_tcp_socket(address).await?;
+        let stream = timeout(self.connect_timeout, socket.connect(address))
+            .await
+            .map_err(|_| io::Error::new(io::ErrorKind::TimedOut, "connect timed out"))??;
+        stream.set_nodelay(true)?;
+        Ok(ObservedIo::with_guard(stream, guard))
+    }
+
+    async fn prepare_tcp_socket(
+        &self,
+        address: SocketAddr,
+    ) -> io::Result<(TcpSocket, crate::resources::observation::Guard, SocketAddr)> {
+        #[cfg(target_os = "linux")]
+        if self.permits_plain_native_socket_setup() {
+            return self.prepare_plain_native_tcp_socket(address).await;
+        }
+        #[cfg(target_os = "linux")]
+        let mptcp = self.permits_mptcp();
+        self.prepare_tcp_socket_with(address, move |ipv6| {
+            #[cfg(target_os = "linux")]
+            if mptcp {
+                return mptcp::socket(ipv6);
+            }
+            new_plain_tcp_socket(ipv6)
+        })
+        .await
+    }
+
+    async fn prepare_tcp_socket_with<F>(
+        &self,
+        address: SocketAddr,
+        create: F,
+    ) -> io::Result<(TcpSocket, crate::resources::observation::Guard, SocketAddr)>
+    where
+        F: FnOnce(bool) -> io::Result<TcpSocket> + Send + 'static,
+    {
+        let address = self.connected_address(address)?;
+        self.validate_egress()?;
         let ipv6 = address.is_ipv6();
         let source_address = self.source_address_for(address)?;
         let dialer = self.clone();
         let (socket, guard) = self
             .initialization
             .run(move |check| {
-                let socket = if ipv6 {
-                    TcpSocket::new_v6()?
-                } else {
-                    TcpSocket::new_v4()?
-                };
-                let guard = track(ResourceKind::Socket);
-                check()?;
-                dialer.protect_socket(&socket)?;
-                check()?;
-                #[cfg(all(windows, feature = "windows-uwp"))]
-                dialer.apply_interface_binding(socket.as_raw_socket(), address)?;
-                if let Some(source_address) = source_address {
-                    socket.bind(source_address)?;
-                }
-                check()?;
-                Ok((socket, guard))
+                let socket = create(ipv6)?;
+                dialer.configure_tcp_socket(socket, address, source_address, check)
             })
             .await?;
-        let stream = timeout(self.connect_timeout, socket.connect(address))
-            .await
-            .map_err(|_| io::Error::new(io::ErrorKind::TimedOut, "connect timed out"))??;
-        stream.set_nodelay(true)?;
-        Ok(ObservedIo::with_guard(stream, guard))
+        Ok((socket, guard, address))
+    }
+
+    fn configure_tcp_socket(
+        &self,
+        socket: TcpSocket,
+        address: SocketAddr,
+        source_address: Option<SocketAddr>,
+        check: &dyn Fn() -> io::Result<()>,
+    ) -> io::Result<(TcpSocket, crate::resources::observation::Guard)> {
+        let guard = track(ResourceKind::Socket);
+        check()?;
+        self.connections.apply(&socket2::SockRef::from(&socket))?;
+        self.protect_socket(&socket)?;
+        #[cfg(unix)]
+        self.apply_socket_policy(&socket, address)?;
+        check()?;
+        #[cfg(all(windows, feature = "windows-uwp"))]
+        self.apply_interface_binding(socket.as_raw_socket(), address)?;
+        #[cfg(all(windows, any(feature = "windows-uwp", feature = "windows-wintun")))]
+        self.apply_configured_interface(socket.as_raw_socket(), address)?;
+        if let Some(source_address) = source_address {
+            socket.bind(source_address)?;
+        }
+        check()?;
+        Ok((socket, guard))
     }
 
     #[cfg(unix)]
@@ -667,16 +1275,33 @@ impl Dialer {
     }
 
     fn require_permitted(&self, address: SocketAddr) -> io::Result<()> {
-        if !self.ipv6 && address.is_ipv6() {
+        if (!self.ipv6 && address.is_ipv6()) || !self.ip_version.permits(address.ip()) {
             return Err(io::Error::new(
                 io::ErrorKind::PermissionDenied,
-                "IPv6 is disabled",
+                "address family is disabled",
             ));
         }
         Ok(())
     }
 }
 
+/// Conversion cannot grant a loopback exemption forbidden by the original
+/// logical/source policy. This runs before any physical socket acquisition.
+pub(crate) fn preserve_ip4p_loopback(
+    original: SocketAddr,
+    actual: SocketAddr,
+    allow: bool,
+) -> io::Result<()> {
+    if !allow && actual.ip().is_loopback() && !original.ip().is_loopback() {
+        Err(io::Error::new(
+            io::ErrorKind::PermissionDenied,
+            "IP4P endpoint violates loopback policy",
+        ))
+    } else {
+        Ok(())
+    }
+}
+
 fn wildcard_address(ipv6: bool) -> SocketAddr {
     if ipv6 {
         SocketAddr::from(([0_u16; 8], 0))
@@ -694,7 +1319,7 @@ fn loopback_address(ipv6: bool) -> SocketAddr {
     }
 }
 
-#[cfg(all(windows, feature = "windows-uwp"))]
+#[cfg(all(windows, any(feature = "windows-uwp", feature = "windows-wintun")))]
 fn interface_option_value(index: NonZeroU32, ipv6: bool) -> [u8; 4] {
     if ipv6 {
         index.get().to_ne_bytes()
@@ -714,6 +1339,33 @@ mod tests {
 
     use tokio::net::TcpListener;
 
+    #[test]
+    fn egress_clones_keep_the_protection_and_stop_owner() {
+        struct UncalledProtector;
+        impl SocketProtector for UncalledProtector {
+            fn protect(&self, _: i32) -> io::Result<()> {
+                unreachable!("memory-only test");
+            }
+        }
+        let initial = Dialer::default().with_protector(Arc::new(UncalledProtector));
+        let node = initial.clone().with_egress(&crate::config::EgressOptions {
+            interface: Some("Ethernet 网络 2".into()),
+            routing_mark: 0,
+        });
+        assert_eq!(node.egress.interface.as_deref(), Some("Ethernet 网络 2"));
+        assert!(Arc::ptr_eq(&initial.initialization, &node.initialization));
+        assert!(Arc::ptr_eq(&initial.dns_sources, &node.dns_sources));
+        assert!(Arc::ptr_eq(
+            initial.protector.as_ref().unwrap(),
+            node.protector.as_ref().unwrap()
+        ));
+        node.begin_shutdown();
+        assert!(*initial.initialization.closed.lock().unwrap());
+        let fresh = node.with_fresh_initialization();
+        assert!(!Arc::ptr_eq(&initial.initialization, &fresh.initialization));
+        assert_eq!(fresh.egress.interface.as_deref(), Some("Ethernet 网络 2"));
+    }
+
     use super::*;
 
     #[cfg(unix)]
@@ -1004,6 +1656,99 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn process_inspection_small_concurrency_preserves_identity_and_joins_stop() {
+        let dialer = Dialer::default();
+        let mut work = tokio::task::JoinSet::new();
+        for uid in 1..=4 {
+            let dialer = dialer.clone();
+            work.spawn(async move {
+                dialer
+                    .inspect_process(move |check| {
+                        check()?;
+                        Ok(crate::process::Identity {
+                            uid: Some(uid),
+                            ..Default::default()
+                        })
+                    })
+                    .await
+                    .unwrap()
+            });
+        }
+        let mut seen = std::collections::BTreeSet::new();
+        while let Some(identity) = work.join_next().await {
+            seen.insert(identity.unwrap().uid.unwrap());
+        }
+        assert_eq!(seen, [1, 2, 3, 4].into_iter().collect());
+        let (entered, entering) = tokio::sync::oneshot::channel();
+        let (release, released) = std::sync::mpsc::channel();
+        let owned = dialer.clone();
+        let caller = tokio::spawn(async move {
+            owned
+                .inspect_process(move |_check| {
+                    let _ = entered.send(());
+                    let _ = released.recv_timeout(Duration::from_secs(2));
+                    Ok(Default::default())
+                })
+                .await
+        });
+        entering.await.unwrap();
+        caller.abort();
+        let _ = caller.await;
+        let mut stopped = Box::pin(dialer.shutdown());
+        assert!(
+            tokio::time::timeout(Duration::from_millis(10), &mut stopped)
+                .await
+                .is_err()
+        );
+        release.send(()).unwrap();
+        tokio::time::timeout(Duration::from_secs(1), stopped)
+            .await
+            .unwrap();
+        assert!(
+            dialer
+                .inspect_process(|_| Ok(Default::default()))
+                .await
+                .is_err()
+        );
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn process_inspection_shared_socket_capacity_has_its_own_deadline() {
+        let dialer = Dialer::default();
+        // Hold capacity directly: no socket/protect callback or OS lookup.
+        let occupied = dialer
+            .initialization
+            .submissions
+            .clone()
+            .acquire_many_owned(MAX_SOCKET_INITIALIZATIONS as u32)
+            .await
+            .unwrap();
+        let called = Arc::new(AtomicUsize::new(0));
+        let calls = called.clone();
+        let result = dialer
+            .inspect_process(move |_| {
+                calls.fetch_add(1, Ordering::Relaxed);
+                Ok(crate::process::Identity {
+                    uid: Some(1001),
+                    ..Default::default()
+                })
+            })
+            .await
+            .unwrap();
+        assert!(result.uid.is_none());
+        assert_eq!(called.load(Ordering::Relaxed), 0);
+        assert_eq!(
+            dialer
+                .initialization
+                .process_submissions
+                .available_permits(),
+            4
+        );
+        drop(occupied);
+        dialer.shutdown().await;
+    }
+
     #[cfg(all(unix, feature = "ffi"))]
     #[test]
     fn socket_initialization_churn_reclaims_completed_work() {
@@ -1040,9 +1785,8 @@ mod tests {
             }
             dialer.shutdown().await;
             assert_eq!(protector.0.load(Ordering::Relaxed), 8192);
-            assert!(probe.snapshot().peak(ResourceKind::Task) <= 64);
+            assert!(probe.snapshot().peak(ResourceKind::Task) <= MAX_SOCKET_INITIALIZATIONS);
             assert!(probe.snapshot().is_idle(), "{:?}", probe.snapshot());
-            println!("socket initialization churn: {:?}", probe.snapshot());
         }));
     }
 
@@ -1120,7 +1864,7 @@ mod tests {
             }
             timeout(Duration::from_secs(3), async {
                 while callers_started.load(Ordering::Acquire) != 4096
-                    || probe.snapshot().current(ResourceKind::Task) < 64
+                    || probe.snapshot().current(ResourceKind::Task) < MAX_SOCKET_INITIALIZATIONS
                     || protector.entered.load(Ordering::Acquire) < 4
                 {
                     tokio::task::yield_now().await;
@@ -1128,18 +1872,13 @@ mod tests {
             })
             .await
             .unwrap();
-            assert!(probe.snapshot().current(ResourceKind::Task) <= 64);
-            assert!(probe.snapshot().peak(ResourceKind::Task) <= 64);
-            println!("socket initialization backlog: {:?}", probe.snapshot());
+            assert!(probe.snapshot().current(ResourceKind::Task) <= MAX_SOCKET_INITIALIZATIONS);
+            assert!(probe.snapshot().peak(ResourceKind::Task) <= MAX_SOCKET_INITIALIZATIONS);
 
             attempts.abort_all();
             while let Some(result) = attempts.join_next().await {
                 assert!(result.unwrap_err().is_cancelled());
             }
-            println!(
-                "socket initialization backlog after caller cancellation: {:?}",
-                probe.snapshot()
-            );
             let mut stopped = Box::pin(dialer.shutdown());
             assert!(
                 timeout(Duration::from_millis(20), &mut stopped)
@@ -1147,13 +1886,8 @@ mod tests {
                     .is_err(),
                 "Stop must not detach a started protect callback"
             );
-            let release_started = std::time::Instant::now();
             protector.release();
             timeout(Duration::from_secs(3), &mut stopped).await.unwrap();
-            println!(
-                "socket initialization release-to-join: {:?}",
-                release_started.elapsed()
-            );
             drop(stopped);
             assert!(probe.snapshot().is_idle(), "{:?}", probe.snapshot());
             assert_eq!(protector.entered.load(Ordering::Acquire), 4);
@@ -1168,7 +1902,6 @@ mod tests {
             drop(fresh.bind_udp_for(destination).await.unwrap());
             fresh.shutdown().await;
             assert!(probe.snapshot().is_idle(), "{:?}", probe.snapshot());
-            println!("socket initialization reclaimed: {:?}", probe.snapshot());
         }));
     }
 
@@ -1269,7 +2002,7 @@ mod tests {
                 }
                 timeout(Duration::from_secs(3), async {
                     while callers_started.load(Ordering::Acquire) != submitted
-                        || probe.snapshot().current(ResourceKind::Task) < 64
+                        || probe.snapshot().current(ResourceKind::Task) < MAX_SOCKET_INITIALIZATIONS
                     {
                         tokio::task::yield_now().await;
                     }
@@ -1277,41 +2010,40 @@ mod tests {
                 .await
                 .unwrap();
                 let before_cancel = probe.snapshot();
-                assert!(before_cancel.current(ResourceKind::Task) <= 64);
-                assert!(before_cancel.peak(ResourceKind::Task) <= 64);
+                assert!(before_cancel.current(ResourceKind::Task) <= MAX_SOCKET_INITIALIZATIONS);
+                assert!(before_cancel.peak(ResourceKind::Task) <= MAX_SOCKET_INITIALIZATIONS);
                 assert_eq!(before_cancel.current(ResourceKind::Socket), 0);
                 assert_eq!(protector.0.load(Ordering::Relaxed), 0);
-                println!(
-                    "socket initialization shared-pool submitted={submitted} before cancel: {before_cancel:?}"
-                );
 
                 // Scope Stop must wake permit waiters without waiting for
                 // unrelated blocking jobs or requiring caller aborts.
                 dialer.begin_shutdown();
                 timeout(Duration::from_secs(3), async {
                     while let Some(result) = attempts.join_next().await {
-                        assert_eq!(result.unwrap().unwrap_err().kind(), io::ErrorKind::Interrupted);
+                        assert_eq!(
+                            result.unwrap().unwrap_err().kind(),
+                            io::ErrorKind::Interrupted
+                        );
                     }
                 })
                 .await
                 .unwrap();
                 let after_cancel = probe.snapshot();
-                assert!(after_cancel.current(ResourceKind::Task) <= 64);
-                assert!(after_cancel.peak(ResourceKind::Task) <= 64);
+                assert!(after_cancel.current(ResourceKind::Task) <= MAX_SOCKET_INITIALIZATIONS);
+                assert!(after_cancel.peak(ResourceKind::Task) <= MAX_SOCKET_INITIALIZATIONS);
                 assert_eq!(after_cancel.current(ResourceKind::Socket), 0);
                 assert_eq!(protector.0.load(Ordering::Relaxed), 0);
-                println!(
-                    "socket initialization shared-pool submitted={submitted} after Stop cancellation: {after_cancel:?}"
-                );
-
-                let release_started = std::time::Instant::now();
                 gate.release();
                 timeout(Duration::from_secs(3), dialer.shutdown())
                     .await
                     .unwrap();
-                let release_to_join = release_started.elapsed();
                 for blocker in blockers {
-                    assert!(timeout(Duration::from_secs(3), blocker).await.unwrap().unwrap());
+                    assert!(
+                        timeout(Duration::from_secs(3), blocker)
+                            .await
+                            .unwrap()
+                            .unwrap()
+                    );
                 }
                 assert!(probe.snapshot().is_idle(), "{:?}", probe.snapshot());
                 assert_eq!(protector.0.load(Ordering::Relaxed), 0);
@@ -1338,11 +2070,50 @@ mod tests {
                 drop(dialer);
                 drop(protector);
                 assert!(protector_lease.upgrade().is_none());
-                println!(
-                    "socket initialization shared-pool submitted={submitted} release-to-join={release_to_join:?} reclaimed: {:?}",
-                    probe.snapshot()
-                );
             }
         });
     }
+    #[test]
+    fn connected_ip4p_conversion_precedes_family_and_source_binding_only_at_opted_in_seams() {
+        let encoded: SocketAddr = "[2001:0::1bb:c000:201]:8443".parse().unwrap();
+        let physical: SocketAddr = "192.0.2.1:443".parse().unwrap();
+        let dialer = Dialer::default()
+            .with_ipv6(false)
+            .with_ip_version(crate::config::IpVersion::Ipv4)
+            .with_connections(crate::config::ConnectionSettings {
+                dialer_ip4p_convert: true,
+                ..Default::default()
+            })
+            .with_source_ip("192.0.2.2".parse().unwrap());
+        assert_eq!(dialer.ordered_connected_addresses(&[encoded]), [physical]);
+        assert_eq!(
+            dialer.source_address_for(physical).unwrap(),
+            Some("192.0.2.2:0".parse().unwrap())
+        );
+        assert!(dialer.require_permitted(physical).is_ok());
+        assert!(dialer.ordered_addresses(&[encoded]).is_empty());
+        assert!(dialer.require_permitted(encoded).is_err());
+        assert!(dialer.source_address_for(encoded).is_err());
+        assert_eq!(
+            Dialer::default().ordered_connected_addresses(&[encoded]),
+            [encoded]
+        );
+    }
+    #[test]
+    fn ip4p_loopback_mapping_cannot_acquire_a_new_literal_exemption() {
+        let original: SocketAddr = "[2001:0::1bb:7f00:1]:8443".parse().unwrap();
+        let actual: SocketAddr = "127.0.0.1:443".parse().unwrap();
+        assert!(preserve_ip4p_loopback(original, actual, false).is_err());
+        assert!(preserve_ip4p_loopback(original, actual, true).is_ok());
+        assert!(preserve_ip4p_loopback(actual, actual, false).is_ok());
+        assert!(preserve_ip4p_loopback(original, "192.0.2.1:443".parse().unwrap(), false).is_ok());
+    }
 }
+
+#[cfg(all(test, target_os = "linux"))]
+#[path = "dialer_native_init_memory_tests.rs"]
+mod native_init_memory_tests;
+
+#[cfg(all(test, target_os = "linux", feature = "tun"))]
+#[path = "dialer_native_init_fd_tests.rs"]
+mod native_init_fd_tests;
diff --git a/src/dialer_connections.rs b/src/dialer_connections.rs
new file mode 100644
index 0000000..0449e28
--- /dev/null
+++ b/src/dialer_connections.rs
@@ -0,0 +1,165 @@
+//! Structured TCP races: dropping the winner's scope cancels every loser.
+use futures_util::{StreamExt, stream::FuturesUnordered};
+use std::{future::Future, net::SocketAddr, time::Duration};
+use tokio::time::{Instant, sleep_until};
+
+pub(crate) async fn race_connections<T, E, F, C>(
+    addresses: &[SocketAddr],
+    prefer_v6: Option<bool>,
+    connect: C,
+) -> Result<T, E>
+where
+    F: Future<Output = Result<T, E>>,
+    C: Fn(SocketAddr) -> F,
+{
+    assert!(!addresses.is_empty());
+    let mut primary = addresses
+        .iter()
+        .filter(|a| prefer_v6.is_none_or(|v6| a.is_ipv6() == v6))
+        .count();
+    let mut attempts = addresses
+        .iter()
+        .map(|&address| {
+            let attempt = connect(address);
+            async move {
+                (
+                    prefer_v6.is_none_or(|v6| address.is_ipv6() == v6),
+                    attempt.await,
+                )
+            }
+        })
+        .collect::<FuturesUnordered<_>>();
+    let deadline = Instant::now() + Duration::from_millis(300);
+    let mut fallback = None;
+    let mut error = None;
+    loop {
+        if primary == 0
+            && let Some(stream) = fallback.take()
+        {
+            return Ok(stream);
+        }
+        tokio::select! {
+            biased;
+            result = attempts.next() => match result {
+                Some((is_primary, result)) => {
+                    if is_primary { primary -= 1; }
+                    match result {
+                        Ok(stream) if is_primary => return Ok(stream),
+                        Ok(stream) => { if fallback.is_none() { fallback = Some(stream); } }
+                        Err(failed) => error = Some(failed),
+                    }
+                }
+                None => return fallback.ok_or_else(|| error.expect("nonempty failed race")),
+            },
+            () = sleep_until(deadline), if fallback.is_some() => return Ok(fallback.take().expect("fallback ready")),
+        }
+    }
+}
+
+impl crate::config::ConnectionSettings {
+    pub(crate) fn apply(self, socket: &socket2::SockRef<'_>) -> std::io::Result<()> {
+        // Apply to accepted mixed connections as well as physical dials:
+        // small proxy writes must not wait on Nagle and delayed ACKs.
+        socket.set_tcp_nodelay(true)?;
+        // Mihomo deliberately disables TCP probes on Android.
+        if self.disable_keep_alive || cfg!(target_os = "android") {
+            return socket.set_keepalive(false);
+        }
+        socket.set_keepalive(true)?;
+        let mut options = socket2::TcpKeepalive::new();
+        if self.keep_alive_idle >= 0 {
+            options = options.with_time(Duration::from_secs(if self.keep_alive_idle == 0 {
+                15
+            } else {
+                self.keep_alive_idle as u64
+            }));
+        }
+        if self.keep_alive_interval >= 0 {
+            options =
+                options.with_interval(Duration::from_secs(if self.keep_alive_interval == 0 {
+                    15
+                } else {
+                    self.keep_alive_interval as u64
+                }));
+        }
+        // Old Windows 10 releases lack TCP_KEEPCNT; retain their OS count.
+        #[cfg(not(windows))]
+        {
+            options = options.with_retries(9);
+        }
+        socket.set_tcp_keepalive(&options)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::{
+        Arc,
+        atomic::{AtomicUsize, Ordering},
+    };
+    #[tokio::test(start_paused = true)]
+    async fn concurrent_dial_cancels_losers_and_honors_family_preference() {
+        struct Guard(Arc<AtomicUsize>);
+        impl Drop for Guard {
+            fn drop(&mut self) {
+                self.0.fetch_add(1, Ordering::Relaxed);
+            }
+        }
+        let closed = Arc::new(AtomicUsize::new(0));
+        let addresses = [
+            "192.0.2.1:443".parse().unwrap(),
+            "[2001:db8::1]:443".parse().unwrap(),
+        ];
+        let start = Instant::now();
+        let result = race_connections(&addresses, Some(true), |a| {
+            let guard = Guard(closed.clone());
+            async move {
+                let _guard = guard;
+                if a.is_ipv6() {
+                    std::future::pending::<()>().await;
+                }
+                Ok::<_, ()>(a)
+            }
+        })
+        .await
+        .unwrap();
+        assert_eq!(result, addresses[0]);
+        assert_eq!(start.elapsed(), Duration::from_millis(300));
+        assert_eq!(closed.load(Ordering::Relaxed), 2);
+        // This creates no peer or listener: inspect only an unconnected socket.
+        let socket = socket2::Socket::new(
+            socket2::Domain::IPV4,
+            socket2::Type::STREAM,
+            Some(socket2::Protocol::TCP),
+        )
+        .unwrap();
+        let options = crate::config::ConnectionSettings {
+            keep_alive_idle: 42,
+            keep_alive_interval: 7,
+            ..Default::default()
+        };
+        options.apply(&socket2::SockRef::from(&socket)).unwrap();
+        assert!(socket.tcp_nodelay().unwrap());
+        assert_eq!(socket.keepalive().unwrap(), !cfg!(target_os = "android"));
+        #[cfg(any(target_os = "linux", target_os = "macos"))]
+        {
+            assert_eq!(
+                socket.tcp_keepalive_time().unwrap(),
+                Duration::from_secs(42)
+            );
+            assert_eq!(
+                socket.tcp_keepalive_interval().unwrap(),
+                Duration::from_secs(7)
+            );
+        }
+        crate::config::ConnectionSettings {
+            disable_keep_alive: true,
+            ..options
+        }
+        .apply(&socket2::SockRef::from(&socket))
+        .unwrap();
+        assert!(socket.tcp_nodelay().unwrap());
+        assert!(!socket.keepalive().unwrap());
+    }
+}
diff --git a/src/dialer_fast_open.rs b/src/dialer_fast_open.rs
new file mode 100644
index 0000000..d9285cd
--- /dev/null
+++ b/src/dialer_fast_open.rs
@@ -0,0 +1,353 @@
+//! Linux TFO adapter over the already protected and bound physical socket.
+//!
+//! The duplicate is the SAME protected/bound socket, not a second connection.
+//! It exists only until the initial connection completes or is cancelled.
+use std::{
+    future::Future,
+    io,
+    net::Shutdown,
+    os::fd::AsRawFd,
+    pin::Pin,
+    sync::{Arc, OnceLock},
+    task::{Context, Poll},
+};
+
+use futures_util::task::AtomicWaker;
+use socket2::SockRef;
+use tokio::{
+    io::{AsyncRead, AsyncWrite, Interest, ReadBuf},
+    net::TcpStream,
+    sync::Notify,
+    time::{Instant, timeout_at},
+};
+use tokio_tfo::TfoStream;
+use tokio_util::sync::CancellationToken;
+
+use super::{SocketInitialization, socket_initialization_cancelled};
+use crate::resources::observation::{ResourceKind, track};
+
+#[derive(Debug)]
+struct Handshake {
+    deadline: Instant,
+    result: OnceLock<io::Result<()>>,
+    activated: Notify,
+    read: AtomicWaker,
+    write: AtomicWaker,
+    cancellation: CancellationToken,
+}
+
+impl Handshake {
+    fn new(deadline: Instant) -> Self {
+        Self {
+            deadline,
+            result: OnceLock::new(),
+            activated: Notify::new(),
+            read: AtomicWaker::new(),
+            write: AtomicWaker::new(),
+            cancellation: CancellationToken::new(),
+        }
+    }
+
+    fn complete(&self, result: io::Result<()>) {
+        if self.result.set(result).is_ok() {
+            self.read.wake();
+            self.write.wake();
+        }
+    }
+
+    fn status(&self) -> Option<io::Result<()>> {
+        if self.result.get().is_none() && Instant::now() >= self.deadline {
+            self.complete(Err(io::Error::new(
+                io::ErrorKind::TimedOut,
+                "connect timed out",
+            )));
+            self.cancellation.cancel();
+        }
+        self.result.get().map(|result| match result {
+            Ok(()) => Ok(()),
+            Err(error) => Err(error.raw_os_error().map_or_else(
+                || io::Error::new(error.kind(), "TCP Fast Open establishment failed"),
+                io::Error::from_raw_os_error,
+            )),
+        })
+    }
+
+    fn poll(&self, cx: &mut Context<'_>, write: bool) -> Poll<io::Result<()>> {
+        if write {
+            self.write.register(cx.waker());
+        } else {
+            self.read.register(cx.waker());
+        }
+        self.status().map_or(Poll::Pending, Poll::Ready)
+    }
+}
+
+/// Explicitly pending until the shared physical handshake owner confirms it.
+/// This must not be used as an eager Happy-Eyeballs winner.
+pub(crate) struct PendingFastOpen {
+    inner: TfoStream,
+    handshake: Arc<Handshake>,
+    activated: bool,
+}
+#[cfg(feature = "sing-mux")]
+impl AsRawFd for PendingFastOpen {
+    fn as_raw_fd(&self) -> std::os::fd::RawFd {
+        self.inner.as_raw_fd()
+    }
+}
+
+impl std::fmt::Debug for PendingFastOpen {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("PendingFastOpen").finish_non_exhaustive()
+    }
+}
+
+impl PendingFastOpen {
+    pub(super) fn new(
+        inner: TfoStream,
+        deadline: Instant,
+        owner: &Arc<SocketInitialization>,
+    ) -> io::Result<Self> {
+        if owner.cancellation.is_cancelled() {
+            return Err(socket_initialization_cancelled());
+        }
+        let handshake = Arc::new(Handshake::new(deadline));
+        // A cold-cookie connect may already have completed before TfoStream is
+        // returned. Do not keep its setup timer attached to established I/O.
+        if connected(&inner)? {
+            handshake.complete(Ok(()));
+        } else {
+            let duplicate = SockRef::from(&inner).try_clone()?;
+            duplicate.set_nonblocking(true)?;
+            let control = TcpStream::from_std(duplicate.into())?;
+            let socket_guard = track(ResourceKind::Socket);
+            let state = Arc::clone(&handshake);
+            let cancellation = owner.cancellation.clone();
+            spawn_owned(owner, async move {
+                let _socket_guard = socket_guard;
+                let operation = async {
+                    state.activated.notified().await;
+                    // A real zero-byte send, rather than a synthetic
+                    // WouldBlock based on TCP_INFO, owns readiness clearing.
+                    // Its cold/warm/pending behavior is a real-kernel PoC gate.
+                    control
+                        .async_io(Interest::WRITABLE, || {
+                            SockRef::from(&control).send(&[]).map(|_| ())
+                        })
+                        .await?;
+                    if !connected(&control)? {
+                        return Err(io::Error::new(
+                            io::ErrorKind::InvalidData,
+                            "TFO readiness confirmation did not establish TCP",
+                        ));
+                    }
+                    Ok(())
+                };
+                let result = tokio::select! {
+                    biased;
+                    () = cancellation.cancelled() => Err(socket_initialization_cancelled()),
+                    () = state.cancellation.cancelled() => Err(socket_initialization_cancelled()),
+                    result = timeout_at(deadline, operation) => result.unwrap_or_else(|_| {
+                        Err(io::Error::new(io::ErrorKind::TimedOut, "connect timed out"))
+                    }),
+                };
+                if result.is_err() {
+                    let _ = SockRef::from(&control).shutdown(Shutdown::Both);
+                }
+                // The duplicate is released before publishing completion and
+                // before the owning task's tracking token can be released.
+                drop(control);
+                state.complete(result);
+            })?;
+        }
+        Ok(Self {
+            inner,
+            handshake,
+            activated: false,
+        })
+    }
+
+    fn check(&self) -> io::Result<()> {
+        self.handshake.status().unwrap_or(Ok(()))
+    }
+
+    fn reject(&self, error: &io::Error) {
+        if self.handshake.result.get().is_none() {
+            self.handshake
+                .complete(Err(error.raw_os_error().map_or_else(
+                    || io::Error::new(error.kind(), "TCP Fast Open establishment failed"),
+                    io::Error::from_raw_os_error,
+                )));
+            self.handshake.cancellation.cancel();
+        }
+    }
+
+    fn activate(&mut self) {
+        if !self.activated {
+            self.activated = true;
+            self.handshake.activated.notify_one();
+        }
+    }
+
+    fn poll_activate(&mut self, cx: &mut Context<'_>, write: bool) -> Poll<io::Result<()>> {
+        self.check()?;
+        if !self.activated && self.handshake.result.get().is_none() {
+            match Pin::new(&mut self.inner).poll_write(cx, &[]) {
+                Poll::Ready(Ok(0)) => self.activate(),
+                Poll::Ready(Ok(_)) => unreachable!("empty write cannot accept bytes"),
+                Poll::Ready(Err(error)) => {
+                    self.reject(&error);
+                    return Poll::Ready(Err(error));
+                }
+                Poll::Pending => return Poll::Pending,
+            }
+        }
+        self.handshake.poll(cx, write)
+    }
+}
+
+impl AsyncRead for PendingFastOpen {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        if buf.remaining() == 0 {
+            return Poll::Ready(Ok(()));
+        }
+        std::task::ready!(self.poll_activate(cx, false))?;
+        Pin::new(&mut self.inner).poll_read(cx, buf)
+    }
+}
+
+impl AsyncWrite for PendingFastOpen {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        if buf.is_empty() {
+            return self.poll_activate(cx, true).map_ok(|()| 0);
+        }
+        self.check()?;
+        let result = Pin::new(&mut self.inner).poll_write(cx, buf);
+        if let Poll::Ready(Err(error)) = &result {
+            self.reject(error);
+        }
+        if matches!(result, Poll::Ready(Ok(_))) {
+            // Report the library's accepted count immediately, without storing
+            // or retrying payload. Only then may the control owner send empty.
+            self.activate();
+        }
+        result
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        std::task::ready!(self.poll_activate(cx, true))?;
+        Pin::new(&mut self.inner).poll_flush(cx)
+    }
+
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        std::task::ready!(self.poll_activate(cx, true))?;
+        Pin::new(&mut self.inner).poll_shutdown(cx)
+    }
+}
+
+impl Drop for PendingFastOpen {
+    fn drop(&mut self) {
+        self.handshake.cancellation.cancel();
+    }
+}
+
+fn spawn_owned(
+    owner: &SocketInitialization,
+    future: impl Future<Output = ()> + Send + 'static,
+) -> io::Result<()> {
+    let token = {
+        let closed = owner
+            .closed
+            .lock()
+            .map_err(|_| io::Error::other("socket initialization lock is poisoned"))?;
+        if *closed {
+            return Err(socket_initialization_cancelled());
+        }
+        owner.tasks.token()
+    };
+    let guard = track(ResourceKind::Task);
+    tokio::spawn(async move {
+        let _token = token;
+        let _guard = guard;
+        future.await;
+    });
+    Ok(())
+}
+
+fn connected(stream: &impl AsRawFd) -> io::Result<bool> {
+    let mut value = std::mem::MaybeUninit::<libc::tcp_info>::zeroed();
+    let mut length = std::mem::size_of::<libc::tcp_info>() as libc::socklen_t;
+    // SAFETY: the owned stream stays live, and the output and length match
+    // Linux's public TCP_INFO ABI. No borrowed descriptor escapes the call.
+    let result = unsafe {
+        libc::getsockopt(
+            stream.as_raw_fd(),
+            libc::IPPROTO_TCP,
+            libc::TCP_INFO,
+            value.as_mut_ptr().cast(),
+            &mut length,
+        )
+    };
+    if result != 0 {
+        return Err(io::Error::last_os_error());
+    }
+    if length == 0 {
+        return Err(io::Error::new(io::ErrorKind::InvalidData, "empty TCP_INFO"));
+    }
+    // SAFETY: zero-initialized output remains fully initialized for a short
+    // response; the kernel has provided at least the first state byte.
+    let state = unsafe { value.assume_init() }.tcpi_state;
+    Ok(matches!(state, 1 | 8)) // Linux TCP_ESTABLISHED / TCP_CLOSE_WAIT.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test(start_paused = true)]
+    async fn pending_setup_expires_but_confirmed_connection_keeps_its_io_lifetime() {
+        let deadline = Instant::now() + std::time::Duration::from_secs(1);
+        let pending = Handshake::new(deadline);
+        let connected = Handshake::new(deadline);
+        connected.complete(Ok(()));
+        tokio::time::advance(std::time::Duration::from_secs(2)).await;
+        assert_eq!(
+            pending.status().unwrap().unwrap_err().kind(),
+            io::ErrorKind::TimedOut
+        );
+        assert!(pending.cancellation.is_cancelled());
+        assert!(connected.status().unwrap().is_ok());
+        assert!(!connected.cancellation.is_cancelled());
+    }
+
+    #[tokio::test]
+    async fn pending_handshake_registration_is_owned_after_submission_returns_and_stop_joins() {
+        let owner = Arc::new(SocketInitialization::default());
+        let cancellation = owner.cancellation.clone();
+        let exited = Arc::new(std::sync::atomic::AtomicBool::new(false));
+        let observed = exited.clone();
+        spawn_owned(&owner, async move {
+            cancellation.cancelled().await;
+            tokio::task::yield_now().await;
+            observed.store(true, std::sync::atomic::Ordering::Release);
+        })
+        .unwrap();
+        assert_eq!(owner.tasks.len(), 1);
+        owner.shutdown().await;
+        assert!(exited.load(std::sync::atomic::Ordering::Acquire));
+        assert!(owner.tasks.is_empty());
+        assert!(spawn_owned(&owner, async {}).is_err());
+    }
+}
+
+#[cfg(all(test, feature = "tun"))]
+#[path = "dialer_fast_open_gate.rs"]
+mod gate;
diff --git a/src/dialer_fast_open_gate.rs b/src/dialer_fast_open_gate.rs
new file mode 100644
index 0000000..21b9205
--- /dev/null
+++ b/src/dialer_fast_open_gate.rs
@@ -0,0 +1,276 @@
+//! Explicitly ignored Linux-container/TUN driver for the private TFO API.
+//! No listener or server is created by this Rust test.
+use std::{
+    fs, io,
+    net::{IpAddr, SocketAddr},
+    path::PathBuf,
+    sync::{
+        Arc, Mutex,
+        atomic::{AtomicUsize, Ordering},
+    },
+    time::Duration,
+};
+
+use async_trait::async_trait;
+use serde::{Deserialize, Serialize};
+use tokio::io::AsyncWriteExt;
+use tokio::time::{Instant, timeout};
+use tokio_util::sync::CancellationToken;
+
+use crate::{
+    ResourceLimits, TunFraming,
+    dialer::{Dialer, SocketProtector},
+    dispatch::{BoxStream, DatagramTransport, DispatchError, Dispatcher},
+    platform::{TunFd, TunIo},
+    session::{DatagramSession, StreamSession},
+    tun_runtime::TunRuntime,
+};
+
+#[derive(Deserialize)]
+struct Spec {
+    #[serde(default = "tfo")]
+    transport: String,
+    #[serde(default)]
+    protect_fail: bool,
+    #[serde(default)]
+    source_ip: Option<IpAddr>,
+    #[serde(default)]
+    interface: String,
+    #[serde(default)]
+    routing_mark: i64,
+    peer: SocketAddr,
+    mode: String,
+    deadline_ms: u64,
+    delay_ms: u64,
+}
+
+fn tfo() -> String {
+    "tfo".into()
+}
+
+#[derive(Default, Serialize)]
+struct Record {
+    phase: &'static str,
+    initially_pending: bool,
+    accepted_prefix_bytes: usize,
+    prepare_ms: u128,
+    tasks_after_prepare: usize,
+    tasks_after_stop: usize,
+    protector_calls: usize,
+    error_kind: Option<String>,
+    stop_joined: bool,
+    mptcp_paths: Vec<(SocketAddr, SocketAddr)>,
+}
+
+struct Protect {
+    calls: AtomicUsize,
+    reject: bool,
+}
+impl SocketProtector for Protect {
+    fn protect(&self, _fd: i32) -> io::Result<()> {
+        self.calls.fetch_add(1, Ordering::Relaxed);
+        if self.reject {
+            return Err(io::ErrorKind::PermissionDenied.into());
+        }
+        Ok(())
+    }
+}
+
+struct Gate {
+    dialer: Dialer,
+    spec: Spec,
+    record: Arc<Mutex<Record>>,
+    root: PathBuf,
+}
+
+impl Gate {
+    fn save(&self) {
+        fs::write(
+            self.root.join("events.json"),
+            serde_json::to_vec(&*self.record.lock().unwrap()).unwrap(),
+        )
+        .unwrap();
+    }
+
+    async fn open(&self) -> io::Result<BoxStream> {
+        let start = Instant::now();
+        let deadline = start + Duration::from_millis(self.spec.deadline_ms);
+        if self.spec.transport == "mptcp" {
+            let stream = self
+                .dialer
+                .connect_mptcp_gate(self.spec.peer, deadline)
+                .await?;
+            loop {
+                let paths = super::super::mptcp_gate::paths(&*stream)?;
+                if self.record.lock().unwrap().mptcp_paths.len() != paths.len() {
+                    self.record.lock().unwrap().mptcp_paths = paths.clone();
+                    self.save();
+                }
+                if paths.len() >= 2 {
+                    self.record.lock().unwrap().mptcp_paths = paths;
+                    break;
+                }
+                if Instant::now() >= deadline {
+                    return Err(io::Error::new(
+                        io::ErrorKind::TimedOut,
+                        "two actual MPTCP subflows were not established",
+                    ));
+                }
+                tokio::time::sleep(Duration::from_millis(10)).await;
+            }
+            self.record.lock().unwrap().phase = "published";
+            self.save();
+            return Ok(Box::new(stream));
+        }
+        let (mut stream, actual_address) = self
+            .dialer
+            .prepare_tcp_fast_open(self.spec.peer, deadline)
+            .await?;
+        assert_eq!(actual_address, self.spec.peer);
+        {
+            let mut record = self.record.lock().unwrap();
+            record.phase = "prepared";
+            record.initially_pending = stream.handshake.result.get().is_none();
+            record.prepare_ms = start.elapsed().as_millis();
+            record.tasks_after_prepare = self.dialer.initialization.tasks.len();
+        }
+        self.save();
+        if self.spec.mode == "dormant-stop" {
+            // Keep the original stream live while Stop revokes its pending
+            // physical connection and joins the separately tracked owner.
+            self.dialer.initialization.cancellation.cancelled().await;
+            return Err(io::ErrorKind::Interrupted.into());
+        }
+        tokio::time::sleep(Duration::from_millis(self.spec.delay_ms)).await;
+        if matches!(
+            self.spec.mode.as_str(),
+            "first-write" | "late-write" | "connecting-stop" | "rejected"
+        ) {
+            let prefix = b"vole-tfo-one-delivery\n";
+            stream.write_all(prefix).await?;
+            self.record.lock().unwrap().accepted_prefix_bytes = prefix.len();
+            self.save();
+            stream.flush().await?;
+        } else if self.spec.mode == "empty-write" {
+            assert_eq!(stream.write(&[]).await?, 0);
+        } else if self.spec.mode == "flush" {
+            stream.flush().await?;
+        } else if !matches!(self.spec.mode.as_str(), "server-first" | "half-close") {
+            return Err(io::ErrorKind::InvalidInput.into());
+        }
+        self.record.lock().unwrap().phase = "published";
+        self.save();
+        Ok(Box::new(stream))
+    }
+}
+
+#[async_trait]
+impl Dispatcher for Gate {
+    async fn connect_tcp(&self, _session: StreamSession) -> Result<BoxStream, DispatchError> {
+        match self.open().await {
+            Ok(stream) => Ok(stream),
+            Err(error) => {
+                self.record.lock().unwrap().error_kind = Some(format!("{:?}", error.kind()));
+                self.save();
+                Err(error.into())
+            }
+        }
+    }
+
+    async fn open_datagram(
+        &self,
+        _session: DatagramSession,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        Err(DispatchError::NotAllowed)
+    }
+}
+
+#[tokio::test]
+#[ignore = "requires an explicitly owned isolated Linux container and real TUN"]
+async fn real_tun_private_tfo_gate() {
+    assert_eq!(std::env::var("VOLE_INTEROP_ISOLATED").as_deref(), Ok("1"));
+    let root = PathBuf::from(std::env::var_os("VOLE_D03_GATE_DIR").expect("gate directory"));
+    let fd: i32 = std::env::var("VOLE_D03_TUN_FD")
+        .expect("borrowed real TUN fd")
+        .parse()
+        .unwrap();
+    let spec: Spec = serde_json::from_slice(&fs::read(root.join("spec.json")).unwrap()).unwrap();
+    assert!((50..=5_000).contains(&spec.deadline_ms));
+    assert!(spec.delay_ms <= 6_000);
+    assert!(matches!(spec.transport.as_str(), "tfo" | "mptcp"));
+    if spec.transport == "tfo" {
+        assert!(spec.peer.ip().is_loopback());
+    }
+    let protected = Arc::new(Protect {
+        calls: AtomicUsize::new(0),
+        reject: spec.protect_fail,
+    });
+    let source = spec
+        .source_ip
+        .or_else(|| (spec.transport == "tfo").then(|| "127.0.0.2".parse().unwrap()));
+    let egress_yaml = serde_json::to_vec(&serde_json::json!({
+        "interface-name": spec.interface.as_str(),
+        "routing-mark": spec.routing_mark,
+    }))
+    .unwrap();
+    let egress = crate::config::Config::parse_yaml(&egress_yaml)
+        .unwrap()
+        .egress;
+    let mut dialer = Dialer::default()
+        .with_protector(protected.clone())
+        .with_egress(&egress);
+    if let Some(source) = source {
+        dialer = dialer.with_source_ip(source);
+    }
+    let record = Arc::new(Mutex::new(Record::default()));
+    let gate = Arc::new(Gate {
+        dialer: dialer.clone(),
+        spec,
+        record: record.clone(),
+        root: root.clone(),
+    });
+    let tun = TunIo::new(TunFd::duplicate(fd).unwrap(), TunFraming::RawIp).unwrap();
+    let runtime = TunRuntime::new(
+        tun,
+        ResourceLimits::default(),
+        gate.clone(),
+        None,
+        false,
+        false,
+        None,
+    )
+    .unwrap();
+    let cancellation = CancellationToken::new();
+    let mut running = tokio::spawn(runtime.run(cancellation.clone()));
+    fs::write(root.join("ready"), b"real-tun-runtime-created").unwrap();
+    let wait = timeout(Duration::from_secs(20), async {
+        loop {
+            tokio::select! {
+                result = &mut running => panic!("TUN driver ended before explicit stop: {result:?}"),
+                () = tokio::time::sleep(Duration::from_millis(10)) => {
+                    if root.join("stop").exists() { break; }
+                }
+            }
+        }
+    }).await;
+    // Stop registration and cancellation use the same owner as regular Dialer.
+    dialer.begin_shutdown();
+    cancellation.cancel();
+    let shutdown = timeout(Duration::from_secs(2), async {
+        dialer.shutdown().await;
+        running.await.unwrap().unwrap();
+    })
+    .await;
+    {
+        let mut result = record.lock().unwrap();
+        result.phase = "stopped";
+        result.tasks_after_stop = dialer.initialization.tasks.len();
+        result.protector_calls = protected.calls.load(Ordering::Relaxed);
+        result.stop_joined = shutdown.is_ok();
+    }
+    gate.save();
+    wait.expect("explicit gate stop was not requested");
+    shutdown.expect("TFO Stop did not join");
+    assert_eq!(record.lock().unwrap().tasks_after_stop, 0);
+    assert_eq!(record.lock().unwrap().protector_calls, 1);
+}
diff --git a/src/dialer_mptcp.rs b/src/dialer_mptcp.rs
new file mode 100644
index 0000000..11f50fa
--- /dev/null
+++ b/src/dialer_mptcp.rs
@@ -0,0 +1,105 @@
+//! Opt-in Linux MPTCP at the same protected socket-creation seam as TCP.
+use super::Dialer;
+use socket2::{Domain, Protocol, Socket, Type};
+use std::io;
+use tokio::net::TcpSocket;
+
+impl Dialer {
+    pub(super) fn permits_mptcp(&self) -> bool {
+        if !self.mptcp
+            || self.protector.is_some()
+            || self.source_binding.is_some()
+            || self.egress.interface.is_some()
+            || self.dns_binding.is_some()
+        {
+            return false;
+        }
+        #[cfg(feature = "tun")]
+        if self
+            .linux_policy
+            .as_ref()
+            .is_some_and(|policy| !policy.permits_mptcp())
+        {
+            return false;
+        }
+        true
+    }
+}
+
+pub(super) fn socket(ipv6: bool) -> io::Result<TcpSocket> {
+    let domain = if ipv6 { Domain::IPV6 } else { Domain::IPV4 };
+    let socket = match Socket::new(domain, Type::STREAM, Some(Protocol::MPTCP)) {
+        Ok(socket) => socket,
+        Err(error) if unavailable(&error) => {
+            // Only creation-time capability errors permit TCP fallback. Policy
+            // and protect run afterwards on the returned socket and fail closed.
+            Socket::new(domain, Type::STREAM, Some(Protocol::TCP))?
+        }
+        Err(error) => return Err(error),
+    };
+    socket.set_nonblocking(true)?;
+    Ok(TcpSocket::from_std_stream(socket.into()))
+}
+
+fn unavailable(error: &io::Error) -> bool {
+    matches!(
+        error.raw_os_error(),
+        Some(libc::EINVAL | libc::EPROTONOSUPPORT | libc::ENOPROTOOPT)
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{config::EgressOptions, dialer::SocketProtector};
+    use std::sync::Arc;
+
+    struct Protector;
+    impl SocketProtector for Protector {
+        fn protect(&self, _: i32) -> io::Result<()> {
+            panic!("offline policy test must not initialize a socket")
+        }
+    }
+
+    #[test]
+    fn kernel_subflows_require_host_owned_paths_without_fd_only_constraints() {
+        assert!(!Dialer::default().permits_mptcp());
+        let dialer = Dialer::default().with_mptcp(true);
+        assert!(dialer.permits_mptcp());
+        assert!(
+            dialer
+                .clone()
+                .with_egress(&EgressOptions {
+                    routing_mark: 42,
+                    ..Default::default()
+                })
+                .permits_mptcp()
+        );
+        assert!(
+            !dialer
+                .clone()
+                .with_egress(&EgressOptions {
+                    interface: Some("eth0".into()),
+                    ..Default::default()
+                })
+                .permits_mptcp()
+        );
+        assert!(
+            !dialer
+                .clone()
+                .with_source_ip("192.0.2.1".parse().unwrap())
+                .permits_mptcp()
+        );
+        assert!(!dialer.with_protector(Arc::new(Protector)).permits_mptcp());
+    }
+
+    #[test]
+    fn capability_fallback_does_not_hide_policy_or_resource_errors() {
+        for errno in [libc::EINVAL, libc::EPROTONOSUPPORT, libc::ENOPROTOOPT] {
+            assert!(unavailable(&io::Error::from_raw_os_error(errno)));
+        }
+        for errno in [libc::EPERM, libc::EACCES, libc::EMFILE, libc::ENOMEM] {
+            assert!(!unavailable(&io::Error::from_raw_os_error(errno)));
+        }
+    }
+}
diff --git a/src/dialer_mptcp_gate.rs b/src/dialer_mptcp_gate.rs
new file mode 100644
index 0000000..ae67ce3
--- /dev/null
+++ b/src/dialer_mptcp_gate.rs
@@ -0,0 +1,228 @@
+//! Gate-only Linux MPTCP API. No configuration field is accepted here.
+use super::{Dialer, PhysicalStream, socket_initialization_cancelled};
+use crate::resources::observation::ObservedIo;
+use socket2::{Domain, Protocol, Socket, Type};
+use std::{
+    io,
+    net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr},
+    os::fd::AsRawFd,
+};
+use tokio::{
+    net::TcpSocket,
+    time::{Instant, timeout_at},
+};
+
+const SOL_MPTCP: libc::c_int = 284;
+const MPTCP_INFO: libc::c_int = 1;
+const MPTCP_TCPINFO: libc::c_int = 2;
+const TCP_INFO_PREFIX: usize = 8;
+const MPTCP_SUBFLOW_ADDRS: libc::c_int = 3;
+const HEADER: usize = 16;
+const ADDRESS_BYTES: usize = 128;
+const PATH_BYTES: usize = ADDRESS_BYTES * 2;
+const MAX_PATHS: usize = 4;
+
+impl Dialer {
+    pub(super) async fn connect_mptcp_gate(
+        &self,
+        address: SocketAddr,
+        deadline: Instant,
+    ) -> io::Result<PhysicalStream> {
+        let deadline = deadline.min(Instant::now() + self.connect_timeout);
+        let operation = async {
+            let (socket, guard, address) = self
+                .prepare_tcp_socket_with(address, |ipv6| {
+                    let socket = Socket::new(
+                        if ipv6 { Domain::IPV6 } else { Domain::IPV4 },
+                        Type::STREAM,
+                        Some(Protocol::MPTCP),
+                    )?;
+                    socket.set_nonblocking(true)?;
+                    Ok(TcpSocket::from_std_stream(socket.into()))
+                })
+                .await?;
+            let stream = socket.connect(address).await?;
+            stream.set_nodelay(true)?;
+            Ok(ObservedIo::with_guard(stream, guard))
+        };
+        tokio::select! {
+            biased;
+            () = self.initialization.cancellation.cancelled() => Err(socket_initialization_cancelled()),
+            result = timeout_at(deadline, operation) => result.map_err(|_| io::Error::from(io::ErrorKind::TimedOut))?,
+        }
+    }
+}
+
+/// Actual kernel-reported subflows, rather than a request bit or TCP fallback.
+pub(super) fn paths(stream: &impl AsRawFd) -> io::Result<Vec<(SocketAddr, SocketAddr)>> {
+    let mut info = [0_u8; 16];
+    option(stream, MPTCP_INFO, &mut info)?;
+    let flags = u32::from_ne_bytes(info[8..12].try_into().unwrap());
+    if flags & 1 != 0 || flags & 2 == 0 {
+        return Err(io::Error::new(
+            io::ErrorKind::Unsupported,
+            "MPTCP peer negotiation fell back to TCP",
+        ));
+    }
+    let before = all_paths(stream)?;
+    let mut wire = [0_u8; HEADER + TCP_INFO_PREFIX * MAX_PATHS];
+    wire[..4].copy_from_slice(&(HEADER as u32).to_ne_bytes());
+    wire[12..16].copy_from_slice(&(TCP_INFO_PREFIX as u32).to_ne_bytes());
+    let length = option(stream, MPTCP_TCPINFO, &mut wire)?;
+    let states = decode_states(&wire[..length])?;
+    // The two public options iterate the same FD's subflow list. A mutation
+    // between reads is a transient sample, not two proven established paths.
+    if before.len() != states.len() || before != all_paths(stream)? {
+        return Ok(Vec::new());
+    }
+    Ok(before
+        .into_iter()
+        .zip(states)
+        .filter_map(|(path, state)| (state == 1).then_some(path))
+        .collect())
+}
+
+fn all_paths(stream: &impl AsRawFd) -> io::Result<Vec<(SocketAddr, SocketAddr)>> {
+    let mut wire = [0_u8; HEADER + PATH_BYTES * MAX_PATHS];
+    wire[..4].copy_from_slice(&(HEADER as u32).to_ne_bytes());
+    wire[12..16].copy_from_slice(&(PATH_BYTES as u32).to_ne_bytes());
+    let length = option(stream, MPTCP_SUBFLOW_ADDRS, &mut wire)?;
+    decode_paths(&wire[..length])
+}
+
+fn decode_states(wire: &[u8]) -> io::Result<Vec<u8>> {
+    if wire.len() < HEADER {
+        return Err(io::ErrorKind::InvalidData.into());
+    }
+    let count = u32::from_ne_bytes(wire[4..8].try_into().unwrap()) as usize;
+    let kernel_size = u32::from_ne_bytes(wire[8..12].try_into().unwrap()) as usize;
+    let user_size = u32::from_ne_bytes(wire[12..16].try_into().unwrap()) as usize;
+    if count > MAX_PATHS
+        || kernel_size < TCP_INFO_PREFIX
+        || user_size != TCP_INFO_PREFIX
+        || wire.len() < HEADER + count * TCP_INFO_PREFIX
+    {
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidData,
+            "MPTCP TCP_INFO output exceeds the gate ABI budget",
+        ));
+    }
+    Ok((0..count)
+        .map(|index| wire[HEADER + index * TCP_INFO_PREFIX])
+        .collect())
+}
+
+fn decode_paths(wire: &[u8]) -> io::Result<Vec<(SocketAddr, SocketAddr)>> {
+    if wire.len() < HEADER {
+        return Err(io::ErrorKind::InvalidData.into());
+    }
+    let count = u32::from_ne_bytes(wire[4..8].try_into().unwrap()) as usize;
+    let kernel_size = u32::from_ne_bytes(wire[8..12].try_into().unwrap()) as usize;
+    let user_size = u32::from_ne_bytes(wire[12..16].try_into().unwrap()) as usize;
+    if count > MAX_PATHS
+        || kernel_size != PATH_BYTES
+        || user_size != PATH_BYTES
+        || wire.len() < HEADER + count * PATH_BYTES
+    {
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidData,
+            "MPTCP subflow output exceeds the gate ABI budget",
+        ));
+    }
+    (0..count)
+        .map(|index| {
+            let at = HEADER + index * PATH_BYTES;
+            Ok((
+                address(&wire[at..at + ADDRESS_BYTES])?,
+                address(&wire[at + ADDRESS_BYTES..at + PATH_BYTES])?,
+            ))
+        })
+        .collect()
+}
+
+fn address(wire: &[u8]) -> io::Result<SocketAddr> {
+    let family = u16::from_ne_bytes(wire[..2].try_into().unwrap()) as libc::c_int;
+    let port = u16::from_be_bytes(wire[2..4].try_into().unwrap());
+    match family {
+        libc::AF_INET => Ok(SocketAddr::new(
+            IpAddr::V4(Ipv4Addr::from(<[u8; 4]>::try_from(&wire[4..8]).unwrap())),
+            port,
+        )),
+        libc::AF_INET6 => Ok(SocketAddr::V6(std::net::SocketAddrV6::new(
+            Ipv6Addr::from(<[u8; 16]>::try_from(&wire[8..24]).unwrap()),
+            port,
+            u32::from_be_bytes(wire[4..8].try_into().unwrap()),
+            u32::from_ne_bytes(wire[24..28].try_into().unwrap()),
+        ))),
+        _ => Err(io::Error::new(
+            io::ErrorKind::InvalidData,
+            "unknown MPTCP subflow family",
+        )),
+    }
+}
+
+fn option(stream: &impl AsRawFd, name: libc::c_int, wire: &mut [u8]) -> io::Result<usize> {
+    let mut length = wire.len() as libc::socklen_t;
+    // SAFETY: the borrowed descriptor remains owned by its live stream; the
+    // bounded initialized output is writable for exactly the supplied length.
+    let result = unsafe {
+        libc::getsockopt(
+            stream.as_raw_fd(),
+            SOL_MPTCP,
+            name,
+            wire.as_mut_ptr().cast(),
+            &mut length,
+        )
+    };
+    if result != 0 {
+        return Err(io::Error::last_os_error());
+    }
+    let length = length as usize;
+    if length < HEADER || length > wire.len() {
+        return Err(io::ErrorKind::InvalidData.into());
+    }
+    Ok(length)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn subflow_states_are_actual_bounded_tcp_info_not_address_count() {
+        let mut wire = [0_u8; HEADER + 2 * TCP_INFO_PREFIX];
+        wire[4..8].copy_from_slice(&2_u32.to_ne_bytes());
+        wire[8..12].copy_from_slice(&256_u32.to_ne_bytes());
+        wire[12..16].copy_from_slice(&(TCP_INFO_PREFIX as u32).to_ne_bytes());
+        wire[HEADER] = 1; // TCP_ESTABLISHED
+        wire[HEADER + TCP_INFO_PREFIX] = 2; // TCP_SYN_SENT is not established
+        assert_eq!(decode_states(&wire).unwrap(), [1, 2]);
+        assert!(decode_states(&wire[..wire.len() - 1]).is_err());
+        wire[4..8].copy_from_slice(&5_u32.to_ne_bytes());
+        assert!(decode_states(&wire).is_err());
+    }
+
+    #[test]
+    fn actual_subflow_abi_counts_paths_without_interpreting_the_request_as_success() {
+        let mut wire = [0_u8; HEADER + 2 * PATH_BYTES];
+        wire[4..8].copy_from_slice(&2_u32.to_ne_bytes());
+        wire[8..12].copy_from_slice(&(PATH_BYTES as u32).to_ne_bytes());
+        wire[12..16].copy_from_slice(&(PATH_BYTES as u32).to_ne_bytes());
+        for index in 0..2 {
+            for (offset, ip, port) in [
+                (0, [10, 77, 0, index as u8 + 1], 50000),
+                (ADDRESS_BYTES, [10, 77, 0, 3], 443),
+            ] {
+                let at = HEADER + index * PATH_BYTES + offset;
+                wire[at..at + 2].copy_from_slice(&(libc::AF_INET as u16).to_ne_bytes());
+                wire[at + 2..at + 4].copy_from_slice(&(port as u16).to_be_bytes());
+                wire[at + 4..at + 8].copy_from_slice(&ip);
+            }
+        }
+        let result = decode_paths(&wire).unwrap();
+        assert_eq!(result.len(), 2);
+        assert_ne!(result[0].0, result[1].0);
+        assert!(decode_paths(&wire[..wire.len() - 1]).is_err());
+        wire[4..8].copy_from_slice(&5_u32.to_ne_bytes());
+        assert!(decode_paths(&wire).is_err());
+    }
+}
diff --git a/src/dialer_native.rs b/src/dialer_native.rs
new file mode 100644
index 0000000..a0b8263
--- /dev/null
+++ b/src/dialer_native.rs
@@ -0,0 +1,107 @@
+//! Linux plain socket setup under the existing initialization owner. No callback
+//! or arbitrary initialization closure is executed by this admission path.
+use super::*;
+
+#[must_use = "keep native socket admission until setup has completed or failed"]
+pub(super) struct NativeSocketAdmission {
+    // Declaration order preserves the blocking path's release order: first
+    // observation, then tracker token, finally capacity for the next job.
+    _observation: crate::resources::observation::Guard,
+    _token: tokio_util::task::task_tracker::TaskTrackerToken,
+    _permit: tokio::sync::OwnedSemaphorePermit,
+    cancellation: CancellationToken,
+}
+
+impl NativeSocketAdmission {
+    pub(super) fn check(&self) -> io::Result<()> {
+        if self.cancellation.is_cancelled() {
+            Err(socket_initialization_cancelled())
+        } else {
+            Ok(())
+        }
+    }
+}
+
+impl SocketInitialization {
+    pub(super) async fn admit_native_socket(&self) -> io::Result<NativeSocketAdmission> {
+        let permit = tokio::select! {
+            biased;
+            () = self.cancellation.cancelled() => return Err(socket_initialization_cancelled()),
+            permit = Arc::clone(&self.submissions).acquire_owned() => {
+                permit.map_err(|_| socket_initialization_cancelled())?
+            }
+        };
+        let token = {
+            let closed = self
+                .closed
+                .lock()
+                .map_err(|_| io::Error::other("socket initialization lock is poisoned"))?;
+            if *closed {
+                return Err(socket_initialization_cancelled());
+            }
+            self.tasks.token()
+        };
+        let admission = NativeSocketAdmission {
+            _observation: track(ResourceKind::Task),
+            _token: token,
+            _permit: permit,
+            cancellation: self.cancellation.clone(),
+        };
+        admission.check()?;
+        Ok(admission)
+    }
+}
+
+impl Dialer {
+    pub(super) fn permits_plain_native_socket_setup(&self) -> bool {
+        if self.tfo
+            || self.mptcp
+            || self.protector.is_some()
+            || self.source_binding.is_some()
+            || self.egress.interface.is_some()
+            || self.dns_binding.is_some()
+        {
+            return false;
+        }
+        #[cfg(feature = "tun")]
+        if self
+            .linux_policy
+            .as_ref()
+            .is_some_and(|policy| policy.detects_interface())
+        {
+            return false;
+        }
+        true
+    }
+
+    pub(super) async fn prepare_plain_native_tcp_socket(
+        &self,
+        address: SocketAddr,
+    ) -> io::Result<(TcpSocket, crate::resources::observation::Guard, SocketAddr)> {
+        let address = self.connected_address(address)?;
+        self.validate_egress()?;
+        let source_address = self.source_address_for(address)?;
+        let admission = self.initialization.admit_native_socket().await?;
+        admission.check()?;
+        let socket = new_plain_tcp_socket(address.is_ipv6())?;
+        let (socket, guard) =
+            self.configure_tcp_socket(socket, address, source_address, &|| admission.check())?;
+        admission.check()?;
+        Ok((socket, guard, address))
+    }
+
+    pub(super) async fn bind_plain_native_udp_socket(
+        &self,
+        destination: SocketAddr,
+        bind_address: SocketAddr,
+        options: UdpSocketOptions,
+    ) -> io::Result<PhysicalDatagram> {
+        let admission = self.initialization.admit_native_socket().await?;
+        admission.check()?;
+        let (socket, guard) =
+            self.configure_udp_socket(destination, bind_address, options, &|| admission.check())?;
+        let socket = UdpSocket::from_std(socket)?;
+        admission.check()?;
+        Ok(ObservedIo::with_guard(socket, guard))
+    }
+}
diff --git a/src/dialer_native_init_fd_tests.rs b/src/dialer_native_init_fd_tests.rs
new file mode 100644
index 0000000..f5a3b5e
--- /dev/null
+++ b/src/dialer_native_init_fd_tests.rs
@@ -0,0 +1,183 @@
+//! Root-only Linux FD prechecks. Require an inherited REAL owned TUN FD;
+//! these are deliberately ignored and are NOT memory tests or TUN data signoff.
+use super::*;
+use crate::resources::observation::ResourceProbe;
+use std::{future::Future, os::fd::AsRawFd, task::Poll};
+
+fn require_owned_real_tun() {
+    assert_eq!(std::env::var("BENCHMARK_ISOLATED").as_deref(), Ok("1"));
+    let fd: i32 = std::env::var("VOLE_NATIVE_INIT_TEST_TUN_FD")
+        .expect("Root must inherit the owned Linux guest's real TUN FD")
+        .parse()
+        .unwrap();
+    assert!(fd > 2);
+    // Read-only UAPI check; never open/configure a TUN or alter owner flags.
+    let mut request: libc::ifreq = unsafe { std::mem::zeroed() };
+    assert_eq!(unsafe { libc::ioctl(fd, libc::TUNGETIFF, &mut request) }, 0);
+    assert_ne!(
+        i32::from(unsafe { request.ifr_ifru.ifru_flags }) & libc::IFF_TUN,
+        0
+    );
+    // This does not independently prove raw-IP framing, routing or business IO;
+    // Root's existing real-TUN environment and later data check own those facts.
+}
+
+struct OccupiedBlockingWorker {
+    release: Option<std::sync::mpsc::Sender<()>>,
+    task: Option<tokio::task::JoinHandle<()>>,
+}
+impl OccupiedBlockingWorker {
+    fn start() -> Self {
+        let (ready, started) = std::sync::mpsc::channel();
+        let (release, held) = std::sync::mpsc::channel();
+        let task = tokio::task::spawn_blocking(move || {
+            let _ = ready.send(());
+            // Sender Drop also releases the fixture on panic; no stuck worker.
+            let _ = held.recv();
+        });
+        started.recv().unwrap();
+        Self {
+            release: Some(release),
+            task: Some(task),
+        }
+    }
+    async fn finish(mut self) {
+        if let Some(release) = self.release.take() {
+            let _ = release.send(());
+        }
+        self.task.take().unwrap().await.unwrap();
+    }
+}
+impl Drop for OccupiedBlockingWorker {
+    fn drop(&mut self) {
+        if let Some(release) = self.release.take() {
+            let _ = release.send(());
+        }
+    }
+}
+
+fn closed_fd(fd: i32) {
+    assert_eq!(unsafe { libc::fcntl(fd, libc::F_GETFD) }, -1);
+    assert_eq!(io::Error::last_os_error().raw_os_error(), Some(libc::EBADF));
+}
+
+#[test]
+#[ignore = "Root-owned Linux real TUN only; actual sockets, not a memory filter"]
+fn plain_native_tcp_udp_do_not_wait_for_the_blocking_worker() {
+    require_owned_real_tun();
+    let runtime = tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .max_blocking_threads(1)
+        .build()
+        .unwrap();
+    let probe = ResourceProbe::default();
+    let (tcp_ready, udp_ready) = runtime.block_on(probe.scope(async {
+        let dialer = Dialer::default();
+        let destination: SocketAddr = "192.0.2.10:443".parse().unwrap();
+        let held = OccupiedBlockingWorker::start();
+        let mut preparing = Box::pin(dialer.prepare_tcp_socket(destination));
+        let first = std::future::poll_fn(|cx| Poll::Ready(preparing.as_mut().poll(cx))).await;
+        let tcp_ready = first.is_ready();
+        // Original blocking source is allowed to finish after releasing its
+        // worker; intended RED occurs only after all cleanup, not at a timeout.
+        held.finish().await;
+        let (socket, guard, address) = match first {
+            Poll::Ready(result) => result.unwrap(),
+            Poll::Pending => preparing.await.unwrap(),
+        };
+        assert_eq!(address, destination);
+        let raw = socket.as_raw_fd();
+        let options = socket2::SockRef::from(&socket);
+        assert!(options.nonblocking().unwrap());
+        assert!(options.tcp_nodelay().unwrap());
+        assert!(options.keepalive().unwrap());
+        drop(options);
+        drop(socket);
+        drop(guard);
+        closed_fd(raw);
+
+        let held = OccupiedBlockingWorker::start();
+        let mut binding = Box::pin(dialer.bind_udp_for(destination));
+        let first = std::future::poll_fn(|cx| Poll::Ready(binding.as_mut().poll(cx))).await;
+        let udp_ready = first.is_ready();
+        held.finish().await;
+        let socket = match first {
+            Poll::Ready(result) => result.unwrap(),
+            Poll::Pending => binding.await.unwrap(),
+        };
+        let raw = socket.as_raw_fd();
+        assert!(socket.local_addr().unwrap().port() > 0);
+        assert!(socket2::SockRef::from(&*socket).nonblocking().unwrap());
+        drop(socket);
+        closed_fd(raw);
+        dialer.shutdown().await;
+        assert!(probe.snapshot().is_idle(), "{:?}", probe.snapshot());
+        (tcp_ready, udp_ready)
+    }));
+    assert!(
+        tcp_ready && udp_ready,
+        "plain native socket setup waited for an unrelated blocking worker"
+    );
+}
+
+#[test]
+#[ignore = "Root-owned Linux real TUN only; actual sockets, not a memory filter"]
+fn custom_factory_and_host_protector_stay_on_the_blocking_worker() {
+    require_owned_real_tun();
+    let runtime = tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .max_blocking_threads(1)
+        .build()
+        .unwrap();
+    let probe = ResourceProbe::default();
+    runtime.block_on(probe.scope(async {
+        let caller = std::thread::current().id();
+        let destination: SocketAddr = "192.0.2.10:443".parse().unwrap();
+        let dialer = Dialer::default();
+        let factory_thread = Arc::new(Mutex::new(None));
+        let record = factory_thread.clone();
+        let held = OccupiedBlockingWorker::start();
+        let mut preparing = Box::pin(dialer.prepare_tcp_socket_with(destination, move |ipv6| {
+            *record.lock().unwrap() = Some(std::thread::current().id());
+            if ipv6 {
+                TcpSocket::new_v6()
+            } else {
+                TcpSocket::new_v4()
+            }
+        }));
+        assert!(
+            std::future::poll_fn(|cx| Poll::Ready(preparing.as_mut().poll(cx)))
+                .await
+                .is_pending()
+        );
+        assert!(factory_thread.lock().unwrap().is_none());
+        held.finish().await;
+        drop(preparing.await.unwrap());
+        assert_ne!(factory_thread.lock().unwrap().unwrap(), caller);
+        dialer.shutdown().await;
+
+        struct Protector(Arc<Mutex<Option<std::thread::ThreadId>>>);
+        impl SocketProtector for Protector {
+            fn protect(&self, _: i32) -> io::Result<()> {
+                *self.0.lock().unwrap() = Some(std::thread::current().id());
+                Ok(())
+            }
+        }
+        let protector_thread = Arc::new(Mutex::new(None));
+        let dialer =
+            Dialer::default().with_protector(Arc::new(Protector(protector_thread.clone())));
+        let held = OccupiedBlockingWorker::start();
+        let mut binding = Box::pin(dialer.bind_udp_for(destination));
+        assert!(
+            std::future::poll_fn(|cx| Poll::Ready(binding.as_mut().poll(cx)))
+                .await
+                .is_pending()
+        );
+        assert!(protector_thread.lock().unwrap().is_none());
+        held.finish().await;
+        drop(binding.await.unwrap());
+        assert_ne!(protector_thread.lock().unwrap().unwrap(), caller);
+        dialer.shutdown().await;
+        assert!(probe.snapshot().is_idle(), "{:?}", probe.snapshot());
+    }));
+}
diff --git a/src/dialer_native_init_memory_tests.rs b/src/dialer_native_init_memory_tests.rs
new file mode 100644
index 0000000..54ac06e
--- /dev/null
+++ b/src/dialer_native_init_memory_tests.rs
@@ -0,0 +1,61 @@
+//! No FD, native syscall, thread, blocking job, listener or network is created.
+use super::*;
+use crate::resources::observation::ResourceProbe;
+use std::{future::Future, task::Poll};
+
+#[test]
+fn typed_admission_bounds_cancelled_waiters_and_waits_for_stop() {
+    let runtime = tokio::runtime::Builder::new_current_thread()
+        .build()
+        .unwrap();
+    let probe = ResourceProbe::default();
+    runtime.block_on(probe.scope(async {
+        let initialization = SocketInitialization::default();
+        let mut admitted = Vec::new();
+        for _ in 0..MAX_SOCKET_INITIALIZATIONS {
+            admitted.push(initialization.admit_native_socket().await.unwrap());
+        }
+        assert_eq!(initialization.tasks.len(), MAX_SOCKET_INITIALIZATIONS);
+        assert_eq!(initialization.submissions.available_permits(), 0);
+
+        let mut caller = Box::pin(initialization.admit_native_socket());
+        assert!(
+            std::future::poll_fn(|cx| Poll::Ready(caller.as_mut().poll(cx)))
+                .await
+                .is_pending()
+        );
+        // Cancel an actual queued admission, not merely a borrowed Pin/wait.
+        drop(caller);
+        assert_eq!(initialization.tasks.len(), MAX_SOCKET_INITIALIZATIONS);
+        assert_eq!(initialization.submissions.available_permits(), 0);
+
+        initialization.begin_shutdown();
+        assert_eq!(
+            admitted[0].check().unwrap_err().kind(),
+            io::ErrorKind::Interrupted
+        );
+        assert!(initialization.admit_native_socket().await.is_err());
+        let mut stop = Box::pin(initialization.shutdown());
+        assert!(
+            std::future::poll_fn(|cx| Poll::Ready(stop.as_mut().poll(cx)))
+                .await
+                .is_pending()
+        );
+        // Cancel/drop each admitted caller: the real tracker must prevent Stop
+        // completion until the last registered guard, not just the last wait.
+        while admitted.len() > 1 {
+            drop(admitted.pop());
+        }
+        assert_eq!(initialization.tasks.len(), 1);
+        assert!(
+            std::future::poll_fn(|cx| Poll::Ready(stop.as_mut().poll(cx)))
+                .await
+                .is_pending()
+        );
+        drop(admitted);
+        stop.await;
+        assert_eq!(initialization.tasks.len(), 0);
+        assert!(initialization.admit_native_socket().await.is_err());
+        assert!(probe.snapshot().is_idle(), "{:?}", probe.snapshot());
+    }));
+}
diff --git a/src/dialer_ping.rs b/src/dialer_ping.rs
new file mode 100644
index 0000000..46d9848
--- /dev/null
+++ b/src/dialer_ping.rs
@@ -0,0 +1,264 @@
+//! Linux ping sockets only. Creation, protection and binding stay in Dialer.
+use super::Dialer;
+use crate::{
+    config::IpCidr,
+    platform::TunIo,
+    resources::observation::{Guard, ResourceKind, track},
+};
+use socket2::{Domain, Protocol, Socket, Type};
+use std::{
+    io,
+    net::{IpAddr, SocketAddr},
+    os::fd::AsRawFd,
+    sync::Arc,
+};
+use tokio::io::unix::AsyncFd;
+
+pub(crate) struct PhysicalPing {
+    socket: AsyncFd<Socket>,
+    _guard: Guard,
+    pub(crate) identifier: u16,
+}
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct PingReceipt {
+    pub(crate) length: usize,
+    pub(crate) peer: IpAddr,
+    pub(crate) local: IpAddr,
+    pub(crate) interface: u32,
+}
+impl Dialer {
+    pub(crate) fn permit_ping_destination(&self, destination: IpAddr) -> io::Result<()> {
+        self.require_permitted(SocketAddr::new(destination, 0))?;
+        self.validate_egress()
+    }
+    // Reuse the same tracked initialization scope as TCP/UDP, including protect
+    // callback cancellation and shutdown's spawn_blocking owner barrier.
+    pub(crate) async fn ping_tun_prefixes(&self, tun: Arc<TunIo>) -> io::Result<Vec<IpCidr>> {
+        self.initialization
+            .run(move |check| {
+                check()?;
+                let prefixes = tun.echo_prefixes()?;
+                check()?;
+                Ok(prefixes)
+            })
+            .await
+    }
+    pub(crate) async fn bind_ping_for(
+        &self,
+        destination: IpAddr,
+        identifier: u16,
+    ) -> io::Result<PhysicalPing> {
+        self.permit_ping_destination(destination)?;
+        if identifier == 0 {
+            return Err(io::ErrorKind::InvalidInput.into());
+        }
+        let endpoint = SocketAddr::new(destination, 0);
+        let mut bind = self
+            .source_address_for(endpoint)?
+            .unwrap_or_else(|| super::wildcard_address(destination.is_ipv6()));
+        // Linux ping sockets use sin_port as the kernel-visible ICMP identifier.
+        bind.set_port(identifier);
+        let dialer = self.clone();
+        let (socket, guard) = self
+            .initialization
+            .run(move |check| {
+                let socket = Socket::new(
+                    if destination.is_ipv6() {
+                        Domain::IPV6
+                    } else {
+                        Domain::IPV4
+                    },
+                    Type::DGRAM,
+                    Some(if destination.is_ipv6() {
+                        Protocol::ICMPV6
+                    } else {
+                        Protocol::ICMPV4
+                    }),
+                )?;
+                let guard = track(ResourceKind::Socket);
+                check()?;
+                if destination.is_ipv6() {
+                    socket.set_only_v6(true)?;
+                }
+                socket.set_nonblocking(true)?;
+                dialer.protect_socket(&socket)?;
+                dialer.apply_socket_policy(&socket, endpoint)?;
+                enable_packet_info(socket.as_raw_fd(), destination.is_ipv6())?;
+                socket.bind(&bind.into())?;
+                if socket.local_addr()?.as_socket().map(|a| a.port()) != Some(identifier) {
+                    return Err(io::Error::other(
+                        "ping socket did not retain its reserved identifier",
+                    ));
+                }
+                check()?;
+                Ok((socket, guard))
+            })
+            .await?;
+        Ok(PhysicalPing {
+            // SAFETY: Socket owns this descriptor and keeps it open and
+            // unchanged until AsyncFd releases the socket.
+            socket: unsafe { AsyncFd::register(socket) }?,
+            _guard: guard,
+            identifier,
+        })
+    }
+}
+fn enable_packet_info(fd: libc::c_int, ipv6: bool) -> io::Result<()> {
+    let enabled: libc::c_int = 1;
+    let (level, option) = if ipv6 {
+        (libc::IPPROTO_IPV6, libc::IPV6_RECVPKTINFO)
+    } else {
+        (libc::IPPROTO_IP, libc::IP_PKTINFO)
+    };
+    // SAFETY: fd is live; enabled has the Linux integer socket-option layout.
+    if unsafe {
+        libc::setsockopt(
+            fd,
+            level,
+            option,
+            (&raw const enabled).cast(),
+            std::mem::size_of_val(&enabled) as libc::socklen_t,
+        )
+    } < 0
+    {
+        return Err(io::Error::last_os_error());
+    }
+    Ok(())
+}
+impl PhysicalPing {
+    pub(crate) async fn send(&self, destination: IpAddr, bytes: &[u8]) -> io::Result<()> {
+        let address = SocketAddr::new(destination, 0).into();
+        loop {
+            let mut ready = self.socket.writable().await?;
+            match ready.try_io(|socket| socket.get_ref().send_to(bytes, &address)) {
+                Ok(Ok(n)) if n == bytes.len() => return Ok(()),
+                Ok(Ok(_)) => return Err(io::Error::other("partial ICMP datagram write")),
+                Ok(Err(e)) => return Err(e),
+                Err(_) => {}
+            }
+        }
+    }
+    pub(crate) async fn recv(&self, bytes: &mut [u8]) -> io::Result<PingReceipt> {
+        loop {
+            let mut ready = self.socket.readable().await?;
+            if let Ok(result) = ready.try_io(|socket| receive(socket.get_ref().as_raw_fd(), bytes))
+            {
+                return result;
+            }
+        }
+    }
+}
+// cmsghdr requires native alignment. This buffer is larger than either pktinfo
+// message, without a per-receive heap allocation or a 64-KiB scratch buffer.
+#[repr(C, align(16))]
+struct Control([u8; 128]);
+fn receive(fd: libc::c_int, bytes: &mut [u8]) -> io::Result<PingReceipt> {
+    let mut peer: libc::sockaddr_storage = unsafe { std::mem::zeroed() };
+    let mut control = Control([0; 128]);
+    let mut iov = libc::iovec {
+        iov_base: bytes.as_mut_ptr().cast(),
+        iov_len: bytes.len(),
+    };
+    let mut msg: libc::msghdr = unsafe { std::mem::zeroed() };
+    msg.msg_name = (&raw mut peer).cast();
+    msg.msg_namelen = std::mem::size_of_val(&peer) as libc::socklen_t;
+    msg.msg_iov = &raw mut iov;
+    msg.msg_iovlen = 1;
+    msg.msg_control = control.0.as_mut_ptr().cast();
+    msg.msg_controllen = control.0.len();
+    // SAFETY: all output buffers have the capacities advertised in msghdr.
+    let length = unsafe { libc::recvmsg(fd, &mut msg, libc::MSG_TRUNC) };
+    if length < 0 {
+        return Err(io::Error::last_os_error());
+    }
+    if length as usize > bytes.len()
+        || msg.msg_controllen > control.0.len()
+        || msg.msg_flags & (libc::MSG_TRUNC | libc::MSG_CTRUNC) != 0
+    {
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidData,
+            "truncated ICMP datagram",
+        ));
+    }
+    let peer = match i32::from(peer.ss_family) {
+        libc::AF_INET if msg.msg_namelen as usize >= std::mem::size_of::<libc::sockaddr_in>() => {
+            let address =
+                unsafe { std::ptr::read_unaligned((&raw const peer).cast::<libc::sockaddr_in>()) };
+            IpAddr::V4(address.sin_addr.s_addr.to_ne_bytes().into())
+        }
+        libc::AF_INET6 if msg.msg_namelen as usize >= std::mem::size_of::<libc::sockaddr_in6>() => {
+            let address =
+                unsafe { std::ptr::read_unaligned((&raw const peer).cast::<libc::sockaddr_in6>()) };
+            IpAddr::V6(address.sin6_addr.s6_addr.into())
+        }
+        _ => {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidData,
+                "ICMP peer address is incomplete",
+            ));
+        }
+    };
+    let mut pktinfo = None;
+    // SAFETY: msg_control is aligned and refers to the kernel's checked length.
+    let mut cmsg = unsafe { libc::CMSG_FIRSTHDR(&msg) };
+    while !cmsg.is_null() {
+        let header = unsafe { &*cmsg };
+        let minimum = unsafe { libc::CMSG_LEN(0) as usize };
+        let base = cmsg as usize - msg.msg_control as usize;
+        if header.cmsg_len < minimum
+            || base
+                .checked_add(header.cmsg_len)
+                .is_none_or(|end| end > msg.msg_controllen)
+        {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidData,
+                "invalid ICMP ancillary header",
+            ));
+        }
+        let data = unsafe { libc::CMSG_DATA(cmsg) };
+        let found = if header.cmsg_level == libc::IPPROTO_IP
+            && header.cmsg_type == libc::IP_PKTINFO
+            && header.cmsg_len
+                == unsafe { libc::CMSG_LEN(std::mem::size_of::<libc::in_pktinfo>() as _) as usize }
+        {
+            let info = unsafe { std::ptr::read_unaligned(data.cast::<libc::in_pktinfo>()) };
+            Some((
+                IpAddr::V4(info.ipi_addr.s_addr.to_ne_bytes().into()),
+                info.ipi_ifindex as u32,
+            ))
+        } else if header.cmsg_level == libc::IPPROTO_IPV6
+            && header.cmsg_type == libc::IPV6_PKTINFO
+            && header.cmsg_len
+                == unsafe { libc::CMSG_LEN(std::mem::size_of::<libc::in6_pktinfo>() as _) as usize }
+        {
+            let info = unsafe { std::ptr::read_unaligned(data.cast::<libc::in6_pktinfo>()) };
+            Some((IpAddr::V6(info.ipi6_addr.s6_addr.into()), info.ipi6_ifindex))
+        } else {
+            None
+        };
+        if let Some(found) = found
+            && pktinfo.replace(found).is_some()
+        {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidData,
+                "ambiguous ICMP packet info",
+            ));
+        }
+        cmsg = unsafe { libc::CMSG_NXTHDR(&msg, cmsg) };
+    }
+    let (local, interface) = pktinfo
+        .filter(|(ip, index)| ip.is_ipv4() == peer.is_ipv4() && *index != 0)
+        .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, "ICMP packet info is missing"))?;
+    if local.is_unspecified() || local.is_multicast() {
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidData,
+            "ICMP packet info is not unicast",
+        ));
+    }
+    Ok(PingReceipt {
+        length: length as usize,
+        peer,
+        local,
+        interface,
+    })
+}
diff --git a/src/dialer_server_tcp.rs b/src/dialer_server_tcp.rs
new file mode 100644
index 0000000..7645be7
--- /dev/null
+++ b/src/dialer_server_tcp.rs
@@ -0,0 +1,143 @@
+//! Explicit node-owned physical TCP I/O. A pending TFO stream is not an eager
+//! connection or address-race winner; its effective address is known at prepare.
+use std::{io, net::SocketAddr};
+
+use tokio::time::Instant;
+
+use super::{Dialer, ResolvedEndpoint};
+use crate::dispatch::BoxStream;
+
+pub(crate) struct ServerTcpConnection {
+    pub io: BoxStream,
+    pub address: SocketAddr,
+    #[cfg(all(target_os = "linux", feature = "sing-mux"))]
+    pub control: Option<super::tcp_control::Control>,
+}
+
+impl Dialer {
+    /// Explicitly configured node endpoints only. Built-in DIRECT and ordinary
+    /// callers retain connect()/connect_address()'s established TCP contract.
+    pub(crate) async fn connect_server_tcp(
+        &self,
+        endpoint: &ResolvedEndpoint,
+        deadline: Instant,
+    ) -> io::Result<ServerTcpConnection> {
+        self.connect_server_tcp_inner(endpoint, deadline, false)
+            .await
+    }
+
+    #[cfg(all(target_os = "linux", feature = "sing-mux"))]
+    pub(crate) async fn connect_server_tcp_controlled(
+        &self,
+        endpoint: &ResolvedEndpoint,
+        deadline: Instant,
+    ) -> io::Result<ServerTcpConnection> {
+        self.connect_server_tcp_inner(endpoint, deadline, true)
+            .await
+    }
+
+    async fn connect_server_tcp_inner(
+        &self,
+        endpoint: &ResolvedEndpoint,
+        deadline: Instant,
+        capture: bool,
+    ) -> io::Result<ServerTcpConnection> {
+        #[cfg(not(all(target_os = "linux", feature = "sing-mux")))]
+        let _ = capture;
+        #[cfg(target_os = "linux")]
+        if let Some(address) = self.single_tfo_address(endpoint)? {
+            let (stream, address) = self.prepare_tcp_fast_open(address, deadline).await?;
+            #[cfg(feature = "sing-mux")]
+            if capture && !self.mptcp {
+                let (io, control) = super::tcp_control::fast_open(stream);
+                return Ok(ServerTcpConnection {
+                    io,
+                    address,
+                    control: Some(control),
+                });
+            }
+            return Ok(ServerTcpConnection {
+                io: Box::new(stream),
+                address,
+                #[cfg(feature = "sing-mux")]
+                control: None,
+            });
+        }
+        // Multiple permitted addresses retain the existing eager serial/race
+        // selection. Other OSes retain their normal controlled TCP adapter.
+        let stream = tokio::time::timeout_at(deadline, self.connect(endpoint))
+            .await
+            .map_err(|_| io::Error::new(io::ErrorKind::TimedOut, "connect timed out"))??;
+        let address = stream.peer_addr()?;
+        #[cfg(all(target_os = "linux", feature = "sing-mux"))]
+        if capture && !self.mptcp {
+            let (io, control) = super::tcp_control::stream(stream);
+            return Ok(ServerTcpConnection {
+                io,
+                address,
+                control: Some(control),
+            });
+        }
+        Ok(ServerTcpConnection {
+            io: Box::new(stream),
+            address,
+            #[cfg(all(target_os = "linux", feature = "sing-mux"))]
+            control: None,
+        })
+    }
+
+    #[cfg(target_os = "linux")]
+    fn single_tfo_address(&self, endpoint: &ResolvedEndpoint) -> io::Result<Option<SocketAddr>> {
+        if !self.tfo {
+            return Ok(None);
+        }
+        self.validate_connected_endpoint(endpoint)?;
+        let addresses = self.ordered_connected_addresses(&endpoint.addresses);
+        Ok(match addresses.as_slice() {
+            [address] => Some(*address),
+            _ => None,
+        })
+    }
+}
+
+#[cfg(all(test, target_os = "linux"))]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn node_tfo_requires_exact_policy_and_one_permitted_physical_address() {
+        let first = "192.0.2.1:443".parse().unwrap();
+        let second = "[2001:db8::2]:443".parse().unwrap();
+        let endpoint = |addresses| ResolvedEndpoint {
+            logical_host: "node.invalid".into(),
+            port: 443,
+            addresses,
+        };
+        let selected = endpoint(vec![first]);
+        let default = Dialer::default();
+        assert_eq!(default.single_tfo_address(&selected).unwrap(), None);
+        let enabled = default.with_tfo(true);
+        assert_eq!(enabled.single_tfo_address(&selected).unwrap(), Some(first));
+        assert_eq!(
+            enabled
+                .single_tfo_address(&endpoint(vec![first, second]))
+                .unwrap(),
+            None,
+        );
+        assert_eq!(
+            enabled
+                .clone()
+                .with_ip_version(crate::config::IpVersion::Ipv4)
+                .single_tfo_address(&endpoint(vec![first, second]))
+                .unwrap(),
+            Some(first),
+        );
+        assert_eq!(
+            enabled
+                .with_tfo(false)
+                .single_tfo_address(&selected)
+                .unwrap(),
+            None,
+        );
+    }
+}
diff --git a/src/dialer_tcp_control.rs b/src/dialer_tcp_control.rs
new file mode 100644
index 0000000..bc36204
--- /dev/null
+++ b/src/dialer_tcp_control.rs
@@ -0,0 +1,224 @@
+//! Opt-in control of one IO-owned TCP socket. A weak capability never owns
+//! the socket, and owner teardown invalidates it before closing the fd.
+use crate::dispatch::BoxStream;
+use std::{
+    io,
+    os::fd::{AsRawFd, BorrowedFd, RawFd},
+    pin::Pin,
+    sync::{Arc, Mutex, Weak},
+    task::{Context, Poll},
+};
+use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+
+#[derive(Clone, Debug)]
+pub(crate) struct Control(Weak<Mutex<Option<RawFd>>>);
+
+#[derive(Clone, Debug, Default)]
+pub(crate) struct Capture(Arc<Mutex<Captured>>);
+#[derive(Debug, Default)]
+enum Captured {
+    #[default]
+    Empty,
+    One(Control),
+    Unavailable,
+}
+impl Capture {
+    pub(crate) fn report(&self, control: Option<Control>) {
+        let mut state = self
+            .0
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
+        *state = match (&*state, control) {
+            (Captured::Empty, Some(control)) => Captured::One(control),
+            _ => Captured::Unavailable,
+        };
+    }
+    pub(crate) fn finish(&self) -> Option<Control> {
+        let mut state = self
+            .0
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
+        match std::mem::replace(&mut *state, Captured::Unavailable) {
+            Captured::One(control) => Some(control),
+            _ => None,
+        }
+    }
+}
+
+struct Owner {
+    io: BoxStream,
+    alive: Arc<Mutex<Option<RawFd>>>,
+}
+impl Drop for Owner {
+    fn drop(&mut self) {
+        // This lock also guards every borrowed syscall. The owned IO remains
+        // live until after the slot is cleared and this Drop returns.
+        self.alive
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner)
+            .take();
+    }
+}
+impl AsyncRead for Owner {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.io).poll_read(cx, buf)
+    }
+}
+impl AsyncWrite for Owner {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        Pin::new(&mut self.io).poll_write(cx, buf)
+    }
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.io).poll_flush(cx)
+    }
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.io).poll_shutdown(cx)
+    }
+}
+
+pub(super) fn stream(io: super::PhysicalStream) -> (BoxStream, Control) {
+    let fd = io.as_raw_fd();
+    owned(Box::new(io), fd)
+}
+pub(super) fn fast_open(
+    io: crate::resources::observation::ObservedIo<super::fast_open::PendingFastOpen>,
+) -> (BoxStream, Control) {
+    let fd = io.as_raw_fd();
+    owned(Box::new(io), fd)
+}
+// Only the two typed constructors above supply real production descriptors.
+fn owned(io: BoxStream, fd: RawFd) -> (BoxStream, Control) {
+    let alive = Arc::new(Mutex::new(Some(fd)));
+    let control = Control(Arc::downgrade(&alive));
+    (Box::new(Owner { io, alive }), control)
+}
+impl Control {
+    fn borrow<T>(&self, apply: impl FnOnce(BorrowedFd<'_>) -> io::Result<T>) -> io::Result<T> {
+        let state = self.0.upgrade().ok_or(io::ErrorKind::NotConnected)?;
+        let state = state
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
+        let fd = state.as_ref().ok_or(io::ErrorKind::NotConnected)?;
+        // SAFETY: owner Drop must acquire this same lock before closing the
+        // socket. The borrowed fd cannot outlive this synchronous closure.
+        apply(unsafe { BorrowedFd::borrow_raw(*fd) })
+    }
+    pub(crate) fn apply_brutal(&self, rate: u64) -> io::Result<()> {
+        // The official module accepts 500 Kbps..1 Tbps. Invalid negotiated
+        // speeds must not switch CC then strand it at its 1 Mbps default.
+        if !(62_500..=125_000_000_000).contains(&rate) {
+            return Err(io::ErrorKind::InvalidInput.into());
+        }
+        self.borrow(|fd| {
+            let old = congestion(fd)?;
+            set(fd, libc::TCP_CONGESTION, b"brutal")?;
+            let mut params = [0; 12];
+            params[..8].copy_from_slice(&rate.to_ne_bytes());
+            params[8..].copy_from_slice(&20_u32.to_ne_bytes());
+            if let Err(error) = set(fd, 23301, &params) {
+                if set(fd, libc::TCP_CONGESTION, &old).is_err() {
+                    // SAFETY: fd remains owned and locked for this operation.
+                    unsafe {
+                        libc::shutdown(fd.as_raw_fd(), libc::SHUT_RDWR);
+                    }
+                }
+                return Err(error);
+            }
+            Ok(())
+        })
+    }
+}
+
+fn congestion(fd: BorrowedFd<'_>) -> io::Result<[u8; 16]> {
+    let mut old = [0_u8; 16];
+    let mut length = old.len() as libc::socklen_t;
+    // SAFETY: output has the advertised writable size and fd is borrowed.
+    if unsafe {
+        libc::getsockopt(
+            fd.as_raw_fd(),
+            libc::IPPROTO_TCP,
+            libc::TCP_CONGESTION,
+            old.as_mut_ptr().cast(),
+            &mut length,
+        )
+    } != 0
+    {
+        return Err(io::Error::last_os_error());
+    }
+    if length == 0 || length as usize > old.len() || !old.contains(&0) {
+        return Err(io::ErrorKind::InvalidData.into());
+    }
+    Ok(old)
+}
+fn set(fd: BorrowedFd<'_>, option: libc::c_int, bytes: &[u8]) -> io::Result<()> {
+    // SAFETY: bytes remains readable for its declared length; fd is borrowed.
+    if unsafe {
+        libc::setsockopt(
+            fd.as_raw_fd(),
+            libc::IPPROTO_TCP,
+            option,
+            bytes.as_ptr().cast(),
+            bytes.len() as libc::socklen_t,
+        )
+    } != 0
+    {
+        return Err(io::Error::last_os_error());
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn capture_rejects_missing_duplicate_and_consumed_owners() {
+        let capture = Capture::default();
+        assert!(capture.finish().is_none());
+        let (io, _) = tokio::io::duplex(1);
+        let (owner, control) = owned(Box::new(io), -1);
+        let capture = Capture::default();
+        capture.report(Some(control.clone()));
+        assert!(capture.finish().is_some());
+        assert!(capture.finish().is_none());
+        let capture = Capture::default();
+        capture.report(Some(control.clone()));
+        capture.report(Some(control.clone()));
+        assert!(capture.finish().is_none());
+        let capture = Capture::default();
+        capture.report(None);
+        capture.report(Some(control.clone()));
+        assert!(capture.finish().is_none());
+        drop(owner);
+        // A later IO owner can be assigned the same synthetic descriptor;
+        // the old weak capability must still fail before any syscall.
+        let (io, _) = tokio::io::duplex(1);
+        let (_replacement, _) = owned(Box::new(io), -1);
+        assert_eq!(
+            control
+                .borrow::<()>(|_| panic!("closed owner exposed descriptor"))
+                .unwrap_err()
+                .kind(),
+            io::ErrorKind::NotConnected
+        );
+    }
+    #[test]
+    fn invalid_rate_does_not_touch_an_owner_or_change_congestion() {
+        let control = Control(Weak::new());
+        assert_eq!(
+            control.apply_brutal(0).unwrap_err().kind(),
+            io::ErrorKind::InvalidInput
+        );
+        assert_eq!(
+            control.apply_brutal(125_000_000_001).unwrap_err().kind(),
+            io::ErrorKind::InvalidInput
+        );
+    }
+}
diff --git a/src/dialer_windows.rs b/src/dialer_windows.rs
new file mode 100644
index 0000000..d0b112b
--- /dev/null
+++ b/src/dialer_windows.rs
@@ -0,0 +1,108 @@
+//! Windows socket binding without changing the Provider's immutable session.
+use super::*;
+use windows::{
+    Win32::{
+        Foundation::NO_ERROR,
+        NetworkManagement::{
+            IpHelper::{
+                ConvertInterfaceAliasToLuid, ConvertInterfaceGuidToLuid,
+                ConvertInterfaceLuidToIndex, ConvertInterfaceNameToLuidW,
+            },
+            Ndis::NET_LUID_LH,
+        },
+    },
+    core::{GUID, PCWSTR},
+};
+
+fn interface_index(name: &str) -> io::Result<NonZeroU32> {
+    let mut luid = NET_LUID_LH::default();
+    let status = if let Ok(guid) = GUID::try_from(name.trim_matches(['{', '}'])) {
+        // SAFETY: both SDK values remain live for the synchronous conversion.
+        unsafe { ConvertInterfaceGuidToLuid(&guid, &mut luid) }
+    } else {
+        let wide: Vec<u16> = name.encode_utf16().chain(Some(0)).collect();
+        // SAFETY: the interface string is NUL terminated and the output is live.
+        let alias = unsafe { ConvertInterfaceAliasToLuid(PCWSTR(wide.as_ptr()), &mut luid) };
+        if alias == NO_ERROR {
+            alias
+        } else {
+            // Also accept the canonical system interface name.
+            unsafe { ConvertInterfaceNameToLuidW(PCWSTR(wide.as_ptr()), &mut luid) }
+        }
+    };
+    if status != NO_ERROR {
+        return Err(io::Error::new(
+            io::ErrorKind::NotFound,
+            "outbound interface is unavailable",
+        ));
+    }
+    let mut index = 0;
+    // SAFETY: luid was initialized by a successful conversion above.
+    if unsafe { ConvertInterfaceLuidToIndex(&luid, &mut index) } != NO_ERROR {
+        return Err(io::Error::new(
+            io::ErrorKind::NotFound,
+            "outbound interface is unavailable",
+        ));
+    }
+    NonZeroU32::new(index).ok_or_else(|| io::ErrorKind::NotFound.into())
+}
+
+impl Dialer {
+    pub(super) fn apply_configured_interface(
+        &self,
+        socket: RawSocket,
+        destination: SocketAddr,
+    ) -> io::Result<()> {
+        if destination.ip().is_loopback() {
+            return Ok(());
+        }
+        let Some(name) = &self.egress.interface else {
+            return Ok(());
+        };
+        #[cfg(feature = "windows-uwp")]
+        if self.dns_binding.is_some() {
+            // for_dns_source already validated the authoritative Provider
+            // adapter; its explicit source binding wins over global defaults.
+            return Ok(());
+        }
+        let index = interface_index(name)?;
+        #[cfg(feature = "windows-uwp")]
+        if let Some(binding) = self.interface_binding {
+            if let Some(adapter) = &self.physical_adapter {
+                if interface_index(adapter)? != index {
+                    return Err(io::Error::new(
+                        io::ErrorKind::PermissionDenied,
+                        "interface-name conflicts with the physical network binding",
+                    ));
+                }
+                return Ok(());
+            }
+            let bound = if destination.is_ipv6() {
+                binding.ipv6.map(|(_, index)| index)
+            } else {
+                binding.ipv4.map(|(_, index)| index)
+            };
+            if bound != Some(index) {
+                return Err(io::Error::new(
+                    io::ErrorKind::PermissionDenied,
+                    "interface-name conflicts with the physical network binding",
+                ));
+            }
+            // apply_interface_binding already set the Provider's source/index.
+            return Ok(());
+        }
+        let ipv6 = destination.is_ipv6();
+        let (level, option) = if ipv6 {
+            (IPPROTO_IPV6.0, IPV6_UNICAST_IF)
+        } else {
+            (IPPROTO_IP.0, IP_UNICAST_IF)
+        };
+        let value = interface_option_value(index, ipv6);
+        let socket = usize::try_from(socket).map_err(|_| io::ErrorKind::InvalidInput)?;
+        // SAFETY: the owned socket is live and the required DWORD is four bytes.
+        if unsafe { setsockopt(SOCKET(socket), level, option, Some(&value)) } == SOCKET_ERROR {
+            return Err(io::Error::from_raw_os_error(unsafe { WSAGetLastError() }.0));
+        }
+        Ok(())
+    }
+}
diff --git a/src/dispatch.rs b/src/dispatch.rs
index a376943..b2c3a74 100644
--- a/src/dispatch.rs
+++ b/src/dispatch.rs
@@ -19,10 +19,16 @@ impl<T> AsyncStream for T where T: AsyncRead + AsyncWrite + Unpin + Send {}
 
 pub type BoxStream = Box<dyn AsyncStream>;
 
+/// One owned send operation; its owner must cancel or complete it before close.
+pub type OwnedDatagramSend =
+    Pin<Box<dyn std::future::Future<Output = Result<(), DispatchError>> + Send + 'static>>;
+
 #[derive(Debug, thiserror::Error)]
 pub enum DispatchError {
     #[error("connection is not allowed")]
     NotAllowed,
+    #[error("rule evaluation failed: {0}")]
+    RuleEvaluation(#[from] crate::config::MatchFailure),
     #[error("network is unreachable")]
     NetworkUnreachable,
     #[error("host is unreachable")]
@@ -40,6 +46,7 @@ impl DispatchError {
     pub const fn diagnostic_code(&self) -> &'static str {
         match self {
             Self::NotAllowed => "not_allowed",
+            Self::RuleEvaluation(_) => "rule_evaluation",
             Self::NetworkUnreachable => "network_unreachable",
             Self::HostUnreachable => "host_unreachable",
             Self::ConnectionRefused => "connection_refused",
@@ -72,6 +79,15 @@ impl From<io::Error> for DispatchError {
 
 #[async_trait]
 pub trait DatagramTransport: Send {
+    /// Whether one source association may share this transport across distinct
+    /// unmodified IP destinations routed to the same concrete dispatcher.
+    /// Replies must retain their source destination, and cancelled sends must
+    /// preserve framing for the next send/receive. Fixed-target codecs and
+    /// ambiguous address restoration must retain independent transports.
+    /// Every implementation must declare this capability explicitly; transparent
+    /// wrappers forward the underlying transport's decision.
+    fn supports_shared_destinations(&self) -> bool;
+
     /// Payload budget for packets sent to and received from this logical peer.
     /// Encapsulating transports subtract their headers from the upstream cap.
     /// The default is the u16 wire ceiling; narrower paths must override it.
@@ -80,6 +96,29 @@ pub trait DatagramTransport: Send {
         DatagramBudget::new(u16::MAX, u16::MAX)
     }
 
+    /// Lease an already-open path without borrowing this transport during IO.
+    /// Unsupported paths return the untouched datagram for ordinary `send`.
+    /// This never binds, resolves, or creates an alternative physical path.
+    /// The caller must drop or complete this lease before closing the transport.
+    fn send_owned(&mut self, datagram: Datagram) -> Result<OwnedDatagramSend, Datagram> {
+        Err(datagram)
+    }
+
+    /// A dedicated QUIC endpoint may initialize this same DIRECT physical
+    /// socket through Dialer and retain a lease until endpoint retirement.
+    /// Codecs, proxy hops and pacers do not forward this capability.
+    #[cfg(all(
+        target_os = "linux",
+        any(feature = "outbound-tuic", feature = "quinn-h3-transport")
+    ))]
+    #[doc(hidden)]
+    async fn lease_quic_socket(
+        &mut self,
+        _peer: std::net::SocketAddr,
+    ) -> Result<Option<crate::transport::quic::PhysicalQuicLease>, DispatchError> {
+        Ok(None)
+    }
+
     async fn send(&mut self, datagram: Datagram) -> Result<(), DispatchError>;
 
     /// Sends the first packet of an authenticated logical connection.
@@ -103,6 +142,21 @@ pub trait DatagramTransport: Send {
     /// when another datagram path becomes ready.
     async fn receive(&mut self) -> Result<Datagram, DispatchError>;
 
+    /// Optional cancellation-safe receive seam for readiness multiplexers.
+    /// The caller owns one reusable scratch buffer; it must never be retained
+    /// across polls. Returned datagrams own only their complete payload.
+    fn supports_poll_receive(&self) -> bool {
+        false
+    }
+
+    fn poll_receive(
+        &mut self,
+        _context: &mut Context<'_>,
+        _scratch: &mut Vec<u8>,
+    ) -> Poll<Result<Datagram, DispatchError>> {
+        Poll::Ready(Err(DispatchError::NotAllowed))
+    }
+
     async fn close(&mut self) -> Result<(), DispatchError> {
         Ok(())
     }
@@ -110,6 +164,25 @@ pub trait DatagramTransport: Send {
 
 #[async_trait]
 pub trait Dispatcher: Send + Sync {
+    #[cfg(feature = "inbound-http")]
+    #[doc(hidden)]
+    fn http_context(&self) -> Option<crate::http_processing::HttpContext> {
+        None
+    }
+
+    /// Configured datagram capability, independent of reachability or health.
+    fn supports_udp(&self) -> bool {
+        true
+    }
+
+    async fn sniff_plan(
+        &self,
+        _source: std::net::SocketAddr,
+        _destination: &crate::session::Destination,
+    ) -> Result<Option<crate::sniffing::Plan>, DispatchError> {
+        Ok(None)
+    }
+
     async fn connect_tcp(&self, session: StreamSession) -> Result<BoxStream, DispatchError>;
 
     async fn open_datagram(
@@ -138,6 +211,18 @@ impl SessionObservedDispatcher {
 
 #[async_trait]
 impl Dispatcher for SessionObservedDispatcher {
+    fn supports_udp(&self) -> bool {
+        self.inner.supports_udp()
+    }
+
+    async fn sniff_plan(
+        &self,
+        source: std::net::SocketAddr,
+        destination: &crate::session::Destination,
+    ) -> Result<Option<crate::sniffing::Plan>, DispatchError> {
+        self.inner.sniff_plan(source, destination).await
+    }
+
     async fn connect_tcp(&self, session: StreamSession) -> Result<BoxStream, DispatchError> {
         let stream = self.inner.connect_tcp(session).await?;
         Ok(Box::new(ObservedStream {
@@ -178,6 +263,18 @@ impl HandshakeObservedDispatcher {
 
 #[async_trait]
 impl Dispatcher for HandshakeObservedDispatcher {
+    fn supports_udp(&self) -> bool {
+        self.inner.supports_udp()
+    }
+
+    async fn sniff_plan(
+        &self,
+        source: std::net::SocketAddr,
+        destination: &crate::session::Destination,
+    ) -> Result<Option<crate::sniffing::Plan>, DispatchError> {
+        self.inner.sniff_plan(source, destination).await
+    }
+
     async fn connect_tcp(&self, session: StreamSession) -> Result<BoxStream, DispatchError> {
         let _activity = self.resource_stats.begin(ResourceActivity::Handshake);
         self.inner.connect_tcp(session).await
@@ -251,10 +348,41 @@ struct ObservedDatagramTransport {
 
 #[async_trait]
 impl DatagramTransport for ObservedDatagramTransport {
+    #[cfg(all(
+        target_os = "linux",
+        any(feature = "outbound-tuic", feature = "quinn-h3-transport")
+    ))]
+    async fn lease_quic_socket(
+        &mut self,
+        peer: std::net::SocketAddr,
+    ) -> Result<Option<crate::transport::quic::PhysicalQuicLease>, DispatchError> {
+        self.inner.lease_quic_socket(peer).await
+    }
+
+    fn supports_shared_destinations(&self) -> bool {
+        self.inner.supports_shared_destinations()
+    }
+
+    fn supports_poll_receive(&self) -> bool {
+        self.inner.supports_poll_receive()
+    }
+
+    fn poll_receive(
+        &mut self,
+        context: &mut Context<'_>,
+        scratch: &mut Vec<u8>,
+    ) -> Poll<Result<Datagram, DispatchError>> {
+        self.inner.poll_receive(context, scratch)
+    }
+
     fn payload_budget(&self, peer: &crate::session::Destination) -> DatagramBudget {
         self.inner.payload_budget(peer)
     }
 
+    fn send_owned(&mut self, datagram: Datagram) -> Result<OwnedDatagramSend, Datagram> {
+        self.inner.send_owned(datagram)
+    }
+
     async fn send(&mut self, datagram: Datagram) -> Result<(), DispatchError> {
         self.inner.send(datagram).await
     }
@@ -318,6 +446,10 @@ mod tests {
 
     #[async_trait]
     impl DatagramTransport for NullDatagrams {
+        fn supports_shared_destinations(&self) -> bool {
+            false
+        }
+
         async fn send(&mut self, _datagram: Datagram) -> Result<(), DispatchError> {
             Ok(())
         }
@@ -352,6 +484,7 @@ mod tests {
 
     fn stream_session(port: u16) -> StreamSession {
         StreamSession {
+            metadata: Default::default(),
             inbound: InboundKind::Tun,
             source: "127.0.0.1:10000".parse().unwrap(),
             destination: Destination::Ip(format!("192.0.2.1:{port}").parse().unwrap()),
@@ -371,6 +504,10 @@ mod tests {
         struct InitialTransport(Arc<AtomicUsize>);
         #[async_trait]
         impl DatagramTransport for InitialTransport {
+            fn supports_shared_destinations(&self) -> bool {
+                false
+            }
+
             async fn send(&mut self, _datagram: Datagram) -> Result<(), DispatchError> {
                 panic!("observer must preserve first-flow metadata");
             }
@@ -409,6 +546,72 @@ mod tests {
         assert_eq!(stats.snapshot().udp_current, 0);
     }
 
+    #[test]
+    fn polled_datagram_observer_forwards_scratch_readiness_and_retains_activity() {
+        struct PolledTransport {
+            scratch_pointer: usize,
+            parent: std::task::Waker,
+            polls: Arc<AtomicUsize>,
+        }
+        #[async_trait]
+        impl DatagramTransport for PolledTransport {
+            fn supports_shared_destinations(&self) -> bool {
+                true
+            }
+            fn supports_poll_receive(&self) -> bool {
+                true
+            }
+            fn poll_receive(
+                &mut self,
+                context: &mut Context<'_>,
+                scratch: &mut Vec<u8>,
+            ) -> Poll<Result<Datagram, DispatchError>> {
+                assert!(context.waker().will_wake(&self.parent));
+                assert_eq!(scratch.as_ptr() as usize, self.scratch_pointer);
+                assert_eq!(scratch.as_slice(), b"supplied");
+                scratch.clear();
+                scratch.extend_from_slice(b"used");
+                self.polls.fetch_add(1, Ordering::Relaxed);
+                Poll::Ready(Ok(Datagram {
+                    remote: Destination::Ip("198.51.100.1:443".parse().unwrap()),
+                    payload: bytes::Bytes::from_static(b"ready"),
+                    sniffed_domain: None,
+                }))
+            }
+            async fn send(&mut self, _datagram: Datagram) -> Result<(), DispatchError> {
+                Ok(())
+            }
+            async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+                panic!("polled observer must not use asynchronous receive")
+            }
+        }
+        let polls = Arc::new(AtomicUsize::new(0));
+        let stats = RuntimeResourceStats::new("polled_observer_test");
+        let parent = futures_util::task::noop_waker();
+        let mut scratch = b"supplied".to_vec();
+        let mut observed = ObservedDatagramTransport {
+            inner: Box::new(PolledTransport {
+                scratch_pointer: scratch.as_ptr() as usize,
+                parent: parent.clone(),
+                polls: polls.clone(),
+            }),
+            _activity: stats.begin(ResourceActivity::UdpAssociation),
+        };
+        assert_eq!(stats.snapshot().udp_current, 1);
+        assert!(observed.supports_poll_receive());
+        assert!(observed.supports_shared_destinations());
+        let mut context = Context::from_waker(&parent);
+        let Poll::Ready(Ok(datagram)) = observed.poll_receive(&mut context, &mut scratch) else {
+            panic!("observer must forward the ready datagram")
+        };
+        assert_eq!(datagram.payload, bytes::Bytes::from_static(b"ready"));
+        assert_eq!(scratch.as_slice(), b"used");
+        assert_eq!(polls.load(Ordering::Relaxed), 1);
+        assert_eq!(stats.snapshot().udp_current, 1);
+        drop(observed);
+        assert_eq!(stats.snapshot().udp_current, 0);
+    }
+
     #[tokio::test]
     async fn session_observation_does_not_reject_former_tcp_or_udp_boundaries() {
         const TCP_SESSIONS: usize = 160;
diff --git a/src/dispatch/datagram.rs b/src/dispatch/datagram.rs
index 760e309..004e8ec 100644
--- a/src/dispatch/datagram.rs
+++ b/src/dispatch/datagram.rs
@@ -93,9 +93,67 @@ struct Bounded {
 
 #[async_trait::async_trait]
 impl DatagramTransport for Bounded {
+    #[cfg(all(
+        target_os = "linux",
+        any(feature = "outbound-tuic", feature = "quinn-h3-transport")
+    ))]
+    async fn lease_quic_socket(
+        &mut self,
+        peer: std::net::SocketAddr,
+    ) -> Result<Option<crate::transport::quic::PhysicalQuicLease>, DispatchError> {
+        if self.closing {
+            return Err(DispatchError::NotAllowed);
+        }
+        self.inner.lease_quic_socket(peer).await
+    }
+
+    fn supports_shared_destinations(&self) -> bool {
+        self.inner.supports_shared_destinations()
+    }
+
+    fn supports_poll_receive(&self) -> bool {
+        self.inner.supports_poll_receive()
+    }
+
+    fn poll_receive(
+        &mut self,
+        context: &mut std::task::Context<'_>,
+        scratch: &mut Vec<u8>,
+    ) -> std::task::Poll<Result<Datagram, DispatchError>> {
+        if self.closing {
+            return std::task::Poll::Ready(Err(DispatchError::NotAllowed));
+        }
+        for _ in 0..crate::limits::IO_POLL_BUDGET {
+            let datagram = match self.inner.poll_receive(context, scratch) {
+                std::task::Poll::Pending => return std::task::Poll::Pending,
+                std::task::Poll::Ready(result) => match result {
+                    Ok(datagram) => datagram,
+                    Err(error) => return std::task::Poll::Ready(Err(error)),
+                },
+            };
+            if datagram.payload.len()
+                <= usize::from(self.payload_budget(&datagram.remote).receive())
+            {
+                return std::task::Poll::Ready(Ok(datagram));
+            }
+        }
+        context.waker().wake_by_ref();
+        std::task::Poll::Pending
+    }
+
     fn payload_budget(&self, peer: &Destination) -> DatagramBudget {
         self.budget.intersect(self.inner.payload_budget(peer))
     }
+    fn send_owned(&mut self, datagram: Datagram) -> Result<super::OwnedDatagramSend, Datagram> {
+        if self.closing
+            || datagram.payload.len()
+                > usize::from(self.payload_budget(&datagram.remote).transmit())
+        {
+            return Err(datagram);
+        }
+        self.inner.send_owned(datagram)
+    }
+
     async fn send(&mut self, datagram: Datagram) -> Result<(), DispatchError> {
         if self.closing {
             return Err(DispatchError::NotAllowed);
@@ -132,3 +190,182 @@ impl DatagramTransport for Bounded {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use bytes::Bytes;
+    use futures_util::task::{ArcWake, waker};
+    use std::{
+        collections::VecDeque,
+        sync::{
+            Arc,
+            atomic::{AtomicUsize, Ordering},
+        },
+        task::{Context, Poll},
+    };
+
+    struct PolledPackets {
+        packets: VecDeque<Datagram>,
+        polls: Arc<AtomicUsize>,
+        closes: Arc<AtomicUsize>,
+    }
+    #[async_trait::async_trait]
+    impl DatagramTransport for PolledPackets {
+        fn supports_shared_destinations(&self) -> bool {
+            true
+        }
+        fn payload_budget(&self, _peer: &Destination) -> DatagramBudget {
+            DatagramBudget::new(2, 3)
+        }
+        fn supports_poll_receive(&self) -> bool {
+            true
+        }
+        fn poll_receive(
+            &mut self,
+            _context: &mut Context<'_>,
+            _scratch: &mut Vec<u8>,
+        ) -> Poll<Result<Datagram, DispatchError>> {
+            self.polls.fetch_add(1, Ordering::Relaxed);
+            match self.packets.pop_front() {
+                Some(datagram) => Poll::Ready(Ok(datagram)),
+                None => Poll::Pending,
+            }
+        }
+        async fn send(&mut self, _datagram: Datagram) -> Result<(), DispatchError> {
+            Ok(())
+        }
+        async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+            panic!("polled test must not use asynchronous receive")
+        }
+        async fn close(&mut self) -> Result<(), DispatchError> {
+            self.closes.fetch_add(1, Ordering::Relaxed);
+            Ok(())
+        }
+    }
+
+    #[derive(Default)]
+    struct WakeCount(AtomicUsize);
+    impl ArcWake for WakeCount {
+        fn wake_by_ref(arc_self: &Arc<Self>) {
+            arc_self.0.fetch_add(1, Ordering::Relaxed);
+        }
+    }
+    fn packet(payload: &'static [u8]) -> Datagram {
+        Datagram {
+            remote: Destination::Ip("198.51.100.1:443".parse().unwrap()),
+            payload: Bytes::from_static(payload),
+            sniffed_domain: None,
+        }
+    }
+
+    struct OwnedPackets(Arc<AtomicUsize>);
+    #[async_trait::async_trait]
+    impl DatagramTransport for OwnedPackets {
+        fn supports_shared_destinations(&self) -> bool {
+            false
+        }
+
+        fn send_owned(&mut self, _: Datagram) -> Result<super::super::OwnedDatagramSend, Datagram> {
+            self.0.fetch_add(1, Ordering::Relaxed);
+            Ok(Box::pin(async { Ok(()) }))
+        }
+        async fn send(&mut self, _: Datagram) -> Result<(), DispatchError> {
+            panic!("bounded owned path must not invoke legacy send")
+        }
+        async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+            std::future::pending().await
+        }
+    }
+    #[tokio::test]
+    async fn polled_datagram_bounded_owned_send_preserves_budget_and_close() {
+        let sends = Arc::new(AtomicUsize::new(0));
+        let mut transport = bounded(
+            Box::new(OwnedPackets(sends.clone())),
+            DatagramBudget::new(3, 3),
+        );
+        let Err(oversized) = transport.send_owned(packet(b"four")) else {
+            panic!("oversized packet reached inner transport")
+        };
+        assert_eq!(oversized.payload, b"four"[..]);
+        assert_eq!(sends.load(Ordering::Relaxed), 0);
+        transport.send_owned(packet(b"ok!")).unwrap().await.unwrap();
+        assert_eq!(sends.load(Ordering::Relaxed), 1);
+        transport.close().await.unwrap();
+        assert!(transport.send_owned(packet(b"ok!")).is_err());
+        assert_eq!(sends.load(Ordering::Relaxed), 1);
+    }
+
+    #[tokio::test]
+    async fn polled_datagram_bounded_filters_complete_packets_and_blocks_after_close() {
+        let polls = Arc::new(AtomicUsize::new(0));
+        let closes = Arc::new(AtomicUsize::new(0));
+        let mut transport = bounded(
+            Box::new(PolledPackets {
+                packets: [packet(b"oversized"), packet(b"four"), packet(b"ok!")].into(),
+                polls: polls.clone(),
+                closes: closes.clone(),
+            }),
+            DatagramBudget::new(10, 4),
+        );
+        assert!(transport.supports_poll_receive());
+        assert!(transport.supports_shared_destinations());
+        assert_eq!(
+            transport.payload_budget(&packet(b"").remote),
+            DatagramBudget::new(2, 3)
+        );
+        let parent = futures_util::task::noop_waker();
+        let mut context = Context::from_waker(&parent);
+        let mut scratch = Vec::new();
+        let Poll::Ready(Ok(datagram)) = transport.poll_receive(&mut context, &mut scratch) else {
+            panic!("valid packet must follow dropped oversized packets")
+        };
+        assert_eq!(datagram.payload, Bytes::from_static(b"ok!"));
+        assert_eq!(polls.load(Ordering::Relaxed), 3);
+        transport.close().await.unwrap();
+        transport.close().await.unwrap();
+        assert_eq!(closes.load(Ordering::Relaxed), 1);
+        assert!(matches!(
+            transport.poll_receive(&mut context, &mut scratch),
+            Poll::Ready(Err(DispatchError::NotAllowed))
+        ));
+        assert_eq!(polls.load(Ordering::Relaxed), 3);
+    }
+
+    #[test]
+    fn polled_datagram_bounded_yields_and_wakes_after_oversized_packet_budget() {
+        let polls = Arc::new(AtomicUsize::new(0));
+        let mut packets = VecDeque::new();
+        for _ in 0..=crate::limits::IO_POLL_BUDGET {
+            packets.push_back(packet(b"four"));
+        }
+        packets.push_back(packet(b"ok!"));
+        let mut transport = bounded(
+            Box::new(PolledPackets {
+                packets,
+                polls: polls.clone(),
+                closes: Arc::default(),
+            }),
+            DatagramBudget::new(10, 4),
+        );
+        let wakes = Arc::new(WakeCount::default());
+        let parent = waker(wakes.clone());
+        let mut context = Context::from_waker(&parent);
+        let mut scratch = Vec::new();
+        assert!(
+            transport
+                .poll_receive(&mut context, &mut scratch)
+                .is_pending()
+        );
+        assert_eq!(polls.load(Ordering::Relaxed), crate::limits::IO_POLL_BUDGET);
+        assert_eq!(wakes.0.load(Ordering::Relaxed), 1);
+        let Poll::Ready(Ok(datagram)) = transport.poll_receive(&mut context, &mut scratch) else {
+            panic!("next poll must consume the remaining oversized packet and valid packet")
+        };
+        assert_eq!(datagram.payload, Bytes::from_static(b"ok!"));
+        assert_eq!(
+            polls.load(Ordering::Relaxed),
+            crate::limits::IO_POLL_BUDGET + 2
+        );
+    }
+}
diff --git a/src/dns/cache.rs b/src/dns/cache.rs
new file mode 100644
index 0000000..d2f8848
--- /dev/null
+++ b/src/dns/cache.rs
@@ -0,0 +1,811 @@
+//! Single-owner hash index and safe slot-linked DNS retention order.
+
+use std::{
+    collections::HashMap,
+    sync::Arc,
+    time::{Duration, Instant},
+};
+
+use super::{
+    CacheLookup, CacheValue, DnsError, MAX_OPAQUE_CACHE_BYTES, MAX_OPAQUE_CACHE_ENTRIES, QueryType,
+    Result, WireQuestion,
+};
+
+#[derive(Debug, PartialEq, Eq, Hash)]
+pub(super) enum Key {
+    Address(String, QueryType),
+    Opaque(WireQuestion, [u8; 32]),
+}
+
+#[derive(Debug)]
+pub(super) enum Value {
+    Address(CacheValue),
+    Opaque {
+        wire: Box<[u8]>,
+        ttl_offsets: Box<[u16]>,
+        accounted_bytes: usize,
+    },
+}
+
+impl Value {
+    fn opaque_bytes(&self) -> Option<usize> {
+        match self {
+            Self::Address(_) => None,
+            Self::Opaque {
+                accounted_bytes, ..
+            } => Some(*accounted_bytes),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(usize)]
+enum List {
+    Recent,
+    Frequent,
+    RecentGhost,
+    FrequentGhost,
+    Lru,
+}
+
+impl List {
+    const fn is_ghost(self) -> bool {
+        matches!(self, Self::RecentGhost | Self::FrequentGhost)
+    }
+}
+
+#[derive(Debug, Default)]
+struct Chain {
+    least: Option<usize>,
+    most: Option<usize>,
+    len: usize,
+}
+
+#[derive(Debug)]
+struct Entry {
+    key: Arc<Key>,
+    value: Option<Value>,
+    expires_at: Instant,
+    stale_eligible: bool,
+    refresh_after: Instant,
+    list: List,
+    previous: Option<usize>,
+    next: Option<usize>,
+    opaque_previous: Option<usize>,
+    opaque_next: Option<usize>,
+}
+
+impl Entry {
+    fn opaque_bytes(&self) -> Option<usize> {
+        match self.value.as_ref() {
+            Some(value) => value.opaque_bytes(),
+            None => self.key.opaque_metadata_bytes(),
+        }
+    }
+
+    fn opaque_chain(&self) -> Option<usize> {
+        self.opaque_bytes()
+            .map(|_| usize::from(self.value.is_none()))
+    }
+}
+
+#[derive(Debug)]
+enum Slot {
+    Occupied(Entry),
+    Vacant(Option<usize>),
+}
+
+/// Metadata retained alongside each opaque payload is part of its byte budget.
+pub(super) const fn opaque_metadata_bytes() -> usize {
+    std::mem::size_of::<Slot>()
+        + std::mem::size_of::<Key>()
+        + std::mem::size_of::<(Arc<Key>, usize)>()
+        + 2 * std::mem::size_of::<usize>() // Arc reference counters
+}
+
+impl Key {
+    fn opaque_metadata_bytes(&self) -> Option<usize> {
+        match self {
+            Self::Address(..) => None,
+            Self::Opaque(question, digest) => {
+                Some(question.name.len() + 4 + digest.len() + opaque_metadata_bytes())
+            }
+        }
+    }
+}
+
+/// Maximum additional age after a positive result's fresh expiry.
+pub(super) const STALE_RETENTION: Duration = Duration::from_secs(3_600);
+
+/// One role's shared result store. Hash/slot storage starts empty. LRU retains
+/// at most c slots; ARC retains at most c payloads and c payload-free ghosts.
+/// Active and ghost opaque chains allow byte-budget eviction without scanning
+/// address results. Ghost key metadata remains charged to the opaque budget.
+#[derive(Debug)]
+pub(super) struct Store {
+    index: HashMap<Arc<Key>, usize>,
+    slots: Vec<Slot>,
+    free: Option<usize>,
+    lists: [Chain; 5],
+    opaque: [Chain; 2],
+    algorithm: crate::config::DnsCacheAlgorithm,
+    recent_target: usize,
+    max_entries: usize,
+    resident_entries: usize,
+    opaque_entries: usize,
+    opaque_bytes: usize,
+}
+
+impl Store {
+    pub(super) fn new(max_entries: usize) -> Self {
+        Self::with_algorithm(max_entries, crate::config::DnsCacheAlgorithm::Lru)
+    }
+
+    pub(super) fn with_algorithm(
+        max_entries: usize,
+        algorithm: crate::config::DnsCacheAlgorithm,
+    ) -> Self {
+        assert!(max_entries != 0, "DNS cache capacity must be non-zero");
+        Self {
+            index: HashMap::new(),
+            slots: Vec::new(),
+            free: None,
+            lists: std::array::from_fn(|_| Chain::default()),
+            opaque: std::array::from_fn(|_| Chain::default()),
+            algorithm,
+            recent_target: 0,
+            max_entries,
+            resident_entries: 0,
+            opaque_entries: 0,
+            opaque_bytes: 0,
+        }
+    }
+
+    pub(super) const fn len(&self) -> usize {
+        self.resident_entries
+    }
+
+    pub(super) const fn opaque_len(&self) -> usize {
+        self.opaque_entries
+    }
+    pub(super) const fn opaque_bytes(&self) -> usize {
+        self.opaque_bytes
+    }
+
+    fn metadata_limit(&self) -> usize {
+        match self.algorithm {
+            crate::config::DnsCacheAlgorithm::Lru => self.max_entries,
+            crate::config::DnsCacheAlgorithm::Arc => self.max_entries.saturating_mul(2),
+        }
+    }
+
+    pub(super) fn clear(&mut self) {
+        *self = Self::with_algorithm(self.max_entries, self.algorithm);
+    }
+
+    #[cfg(test)]
+    pub(super) fn get(&mut self, key: &Key, now: Instant) -> Option<(&Value, Instant)> {
+        self.lookup(key, now, false).into_fresh()
+    }
+
+    /// Stale payloads remain residents in the existing count and byte budgets.
+    /// A lookup never extends either the fresh expiry or the fixed stale age.
+    pub(super) fn lookup(
+        &mut self,
+        key: &Key,
+        now: Instant,
+        allow_stale: bool,
+    ) -> CacheLookup<(&Value, Instant)> {
+        let Some(&slot) = self.index.get(key) else {
+            return CacheLookup::Miss;
+        };
+        let entry = self.entry(slot);
+        let stale = entry.expires_at <= now;
+        if stale
+            && (!allow_stale
+                || !entry.stale_eligible
+                || entry.value.is_none()
+                || now.saturating_duration_since(entry.expires_at) >= STALE_RETENTION)
+        {
+            self.remove(slot);
+            return CacheLookup::Miss;
+        }
+        if entry.value.is_none() {
+            return CacheLookup::Miss;
+        }
+        // Repeated stale access may retain a resident, but does not count as
+        // fresh frequency evidence or resurrect an ARC ghost payload.
+        let list = if stale {
+            entry.list
+        } else {
+            match self.algorithm {
+                crate::config::DnsCacheAlgorithm::Lru => List::Lru,
+                crate::config::DnsCacheAlgorithm::Arc => List::Frequent,
+            }
+        };
+        self.unlink(slot);
+        self.append(slot, list);
+        let entry = self.entry(slot);
+        let hit = (
+            entry.value.as_ref().expect("resident entry has a payload"),
+            entry.expires_at,
+        );
+        if stale {
+            CacheLookup::Stale(hit)
+        } else {
+            CacheLookup::Fresh(hit)
+        }
+    }
+
+    pub(super) fn reserve_refresh(&mut self, key: &Key, now: Instant, backoff: Duration) -> bool {
+        let Some(&slot) = self.index.get(key) else {
+            return false;
+        };
+        let entry = self.entry_mut(slot);
+        if entry.value.is_none()
+            || !entry.stale_eligible
+            || entry.expires_at > now
+            || entry.refresh_after > now
+        {
+            return false;
+        }
+        entry.refresh_after = now.checked_add(backoff).unwrap_or(now);
+        true
+    }
+
+    pub(super) fn finish_refresh(&mut self, key: &Key, now: Instant, backoff: Duration) {
+        if let Some(&slot) = self.index.get(key) {
+            let entry = self.entry_mut(slot);
+            if entry.expires_at <= now {
+                entry.refresh_after = now.checked_add(backoff).unwrap_or(now);
+            }
+        }
+    }
+
+    pub(super) fn insert(
+        &mut self,
+        key: Key,
+        value: Value,
+        expires_at: Instant,
+        now: Instant,
+        stale_eligible: bool,
+    ) -> Result<()> {
+        let mut replaced = self.index.get(&key).copied();
+        if let Some(slot) = replaced
+            && self.entry(slot).expires_at <= now
+        {
+            self.remove(slot);
+            replaced = None;
+        }
+        let previous_list = replaced.map(|slot| self.entry(slot).list);
+        // Make allocation failure leave existing usable payloads untouched.
+        let metadata_limit = self.metadata_limit();
+        if replaced.is_none() && self.index.len() < metadata_limit {
+            self.index
+                .try_reserve(1)
+                .map_err(|_| DnsError::CacheAllocation)?;
+            if self.free.is_none() {
+                super::reserve_entry_slot(&mut self.slots, metadata_limit)?;
+            }
+        }
+        if previous_list == Some(List::RecentGhost) {
+            let step =
+                (self.list_len(List::FrequentGhost) / self.list_len(List::RecentGhost)).max(1);
+            self.recent_target = self
+                .recent_target
+                .saturating_add(step)
+                .min(self.max_entries);
+        } else if previous_list == Some(List::FrequentGhost) {
+            let step =
+                (self.list_len(List::RecentGhost) / self.list_len(List::FrequentGhost)).max(1);
+            self.recent_target = self.recent_target.saturating_sub(step);
+        }
+        if let Some(slot) = replaced {
+            self.remove(slot);
+        }
+        let destination = match self.algorithm {
+            crate::config::DnsCacheAlgorithm::Lru => {
+                if self.len() >= self.max_entries {
+                    self.remove_lru(List::Lru);
+                }
+                List::Lru
+            }
+            crate::config::DnsCacheAlgorithm::Arc => match previous_list {
+                Some(List::Recent | List::Frequent) => List::Frequent,
+                Some(list) if list.is_ghost() => {
+                    if self.len() >= self.max_entries {
+                        self.replace(list == List::FrequentGhost);
+                    }
+                    List::Frequent
+                }
+                _ => {
+                    self.prepare_recent();
+                    List::Recent
+                }
+            },
+        };
+        if let Some(bytes) = value.opaque_bytes() {
+            while self.opaque_entries >= MAX_OPAQUE_CACHE_ENTRIES
+                || self.opaque_bytes.saturating_add(bytes) > MAX_OPAQUE_CACHE_BYTES
+            {
+                // Discard metadata first; a byte-budget eviction is not an ARC
+                // capacity miss and does not change the adaptive target.
+                let candidate = self.opaque[1]
+                    .least
+                    .or(self.opaque[0].least)
+                    .ok_or(DnsError::CacheAllocation)?;
+                self.remove(candidate);
+            }
+        }
+        self.trim_ghosts();
+        let slot = if let Some(slot) = self.free {
+            let Slot::Vacant(next) = self.slots[slot] else {
+                unreachable!("free cache slot must be vacant");
+            };
+            self.free = next;
+            slot
+        } else {
+            self.slots.push(Slot::Vacant(None));
+            self.slots.len() - 1
+        };
+        let key = Arc::new(key);
+        if let Some(bytes) = value.opaque_bytes() {
+            self.opaque_entries += 1;
+            self.opaque_bytes += bytes;
+        }
+        self.resident_entries += 1;
+        self.index.insert(key.clone(), slot);
+        self.slots[slot] = Slot::Occupied(Entry {
+            key,
+            value: Some(value),
+            expires_at,
+            stale_eligible,
+            refresh_after: expires_at,
+            list: destination,
+            previous: None,
+            next: None,
+            opaque_previous: None,
+            opaque_next: None,
+        });
+        self.append(slot, destination);
+        debug_assert!(self.len() <= self.max_entries);
+        debug_assert!(self.index.len() <= metadata_limit);
+        debug_assert!(self.slots.len() <= metadata_limit);
+        debug_assert!(self.opaque_entries <= MAX_OPAQUE_CACHE_ENTRIES);
+        debug_assert!(self.opaque_bytes <= MAX_OPAQUE_CACHE_BYTES);
+        Ok(())
+    }
+
+    fn list_len(&self, list: List) -> usize {
+        self.lists[list as usize].len
+    }
+
+    fn prepare_recent(&mut self) {
+        let recent_and_ghost = self.list_len(List::Recent) + self.list_len(List::RecentGhost);
+        if recent_and_ghost == self.max_entries {
+            if self.list_len(List::Recent) < self.max_entries {
+                self.remove_lru(List::RecentGhost);
+                if self.len() >= self.max_entries {
+                    self.replace(false);
+                }
+            } else {
+                self.remove_lru(List::Recent);
+            }
+        } else if self.index.len() >= self.max_entries {
+            if self.index.len() >= self.metadata_limit() && !self.remove_lru(List::FrequentGhost) {
+                self.remove_lru(List::RecentGhost);
+            }
+            if self.len() >= self.max_entries {
+                self.replace(false);
+            }
+        }
+    }
+
+    fn replace(&mut self, incoming_frequent_ghost: bool) {
+        let recent = self.list_len(List::Recent);
+        let from_recent = recent != 0
+            && (recent > self.recent_target
+                || (incoming_frequent_ghost && recent == self.recent_target));
+        let (from, to) = if from_recent {
+            (List::Recent, List::RecentGhost)
+        } else {
+            (List::Frequent, List::FrequentGhost)
+        };
+        let slot = self.lists[from as usize]
+            .least
+            .expect("full ARC has a replacement entry");
+        self.unlink(slot);
+        let value = self
+            .entry_mut(slot)
+            .value
+            .take()
+            .expect("ARC resident has a payload");
+        self.resident_entries -= 1;
+        if let Some(bytes) = value.opaque_bytes() {
+            self.opaque_entries -= 1;
+            self.opaque_bytes -= bytes
+                - self
+                    .entry(slot)
+                    .key
+                    .opaque_metadata_bytes()
+                    .expect("opaque key metadata");
+        }
+        drop(value);
+        self.append(slot, to);
+    }
+
+    fn trim_ghosts(&mut self) {
+        while self.list_len(List::RecentGhost) + self.list_len(List::FrequentGhost)
+            > self.max_entries
+            || self.index.len() >= self.metadata_limit()
+        {
+            if !self.remove_lru(List::FrequentGhost) && !self.remove_lru(List::RecentGhost) {
+                break;
+            }
+        }
+    }
+
+    fn remove_lru(&mut self, list: List) -> bool {
+        if let Some(slot) = self.lists[list as usize].least {
+            self.remove(slot);
+            true
+        } else {
+            false
+        }
+    }
+
+    fn entry(&self, slot: usize) -> &Entry {
+        match &self.slots[slot] {
+            Slot::Occupied(entry) => entry,
+            Slot::Vacant(_) => unreachable!("linked cache slot must be occupied"),
+        }
+    }
+    fn entry_mut(&mut self, slot: usize) -> &mut Entry {
+        match &mut self.slots[slot] {
+            Slot::Occupied(entry) => entry,
+            Slot::Vacant(_) => unreachable!("linked cache slot must be occupied"),
+        }
+    }
+
+    fn unlink(&mut self, slot: usize) {
+        let entry = self.entry(slot);
+        let list = entry.list as usize;
+        let (previous, next) = (entry.previous, entry.next);
+        let opaque_chain = entry.opaque_chain();
+        let (opaque_previous, opaque_next) = (entry.opaque_previous, entry.opaque_next);
+        if let Some(previous) = previous {
+            self.entry_mut(previous).next = next;
+        } else {
+            self.lists[list].least = next;
+        }
+        if let Some(next) = next {
+            self.entry_mut(next).previous = previous;
+        } else {
+            self.lists[list].most = previous;
+        }
+        self.lists[list].len -= 1;
+        if let Some(chain) = opaque_chain {
+            if let Some(previous) = opaque_previous {
+                self.entry_mut(previous).opaque_next = opaque_next;
+            } else {
+                self.opaque[chain].least = opaque_next;
+            }
+            if let Some(next) = opaque_next {
+                self.entry_mut(next).opaque_previous = opaque_previous;
+            } else {
+                self.opaque[chain].most = opaque_previous;
+            }
+            self.opaque[chain].len -= 1;
+        }
+    }
+
+    fn append(&mut self, slot: usize, list: List) {
+        let previous = self.lists[list as usize].most;
+        let opaque_chain = self.entry(slot).opaque_chain();
+        let entry = self.entry_mut(slot);
+        entry.list = list;
+        entry.previous = previous;
+        entry.next = None;
+        if let Some(previous) = previous {
+            self.entry_mut(previous).next = Some(slot);
+        } else {
+            self.lists[list as usize].least = Some(slot);
+        }
+        self.lists[list as usize].most = Some(slot);
+        self.lists[list as usize].len += 1;
+        if let Some(chain) = opaque_chain {
+            let previous = self.opaque[chain].most;
+            let entry = self.entry_mut(slot);
+            entry.opaque_previous = previous;
+            entry.opaque_next = None;
+            if let Some(previous) = previous {
+                self.entry_mut(previous).opaque_next = Some(slot);
+            } else {
+                self.opaque[chain].least = Some(slot);
+            }
+            self.opaque[chain].most = Some(slot);
+            self.opaque[chain].len += 1;
+        }
+    }
+
+    fn remove(&mut self, slot: usize) {
+        self.unlink(slot);
+        let Slot::Occupied(entry) =
+            std::mem::replace(&mut self.slots[slot], Slot::Vacant(self.free))
+        else {
+            unreachable!("removed cache slot must be occupied");
+        };
+        self.free = Some(slot);
+        self.index.remove(entry.key.as_ref());
+        if entry.value.is_some() {
+            self.resident_entries -= 1;
+        }
+        if let Some(bytes) = entry.opaque_bytes() {
+            if entry.value.is_some() {
+                self.opaque_entries -= 1;
+            }
+            self.opaque_bytes -= bytes;
+        }
+    }
+
+    #[cfg(test)]
+    pub(super) fn allocated_slots(&self) -> usize {
+        self.slots.capacity()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::config::DnsCacheAlgorithm;
+    use std::{net::Ipv4Addr, time::Duration};
+
+    fn address(name: &str) -> Key {
+        Key::Address(name.into(), QueryType::A)
+    }
+
+    fn put(store: &mut Store, name: &str, now: Instant) {
+        store
+            .insert(
+                address(name),
+                Value::Address(CacheValue::Positive(vec![Ipv4Addr::LOCALHOST.into()])),
+                now + Duration::from_secs(60),
+                now,
+                true,
+            )
+            .unwrap();
+    }
+
+    fn opaque_key(name: &str) -> Key {
+        Key::Opaque(
+            WireQuestion {
+                name: name.into(),
+                query_type: 16,
+                query_class: 1,
+            },
+            [0; 32],
+        )
+    }
+
+    fn put_opaque(store: &mut Store, name: &str, now: Instant, ttl: u64) {
+        let key = opaque_key(name);
+        let accounted_bytes = key.opaque_metadata_bytes().unwrap() + 4096 + 2;
+        store
+            .insert(
+                key,
+                Value::Opaque {
+                    wire: vec![0_u8; 4096].into_boxed_slice(),
+                    ttl_offsets: vec![8].into_boxed_slice(),
+                    accounted_bytes,
+                },
+                now + Duration::from_secs(ttl),
+                now,
+                true,
+            )
+            .unwrap();
+    }
+
+    #[test]
+    fn stale_positive_age_is_fixed_and_does_not_turn_ghosts_into_payloads() {
+        let now = Instant::now();
+        for algorithm in [DnsCacheAlgorithm::Lru, DnsCacheAlgorithm::Arc] {
+            let mut store = Store::with_algorithm(2, algorithm);
+            put(&mut store, "a", now);
+            assert!(matches!(
+                store.lookup(&address("a"), now, true),
+                CacheLookup::Fresh(_)
+            ));
+            let expires = now + Duration::from_secs(60);
+            assert!(matches!(
+                store.lookup(&address("a"), expires, true),
+                CacheLookup::Stale(_)
+            ));
+            assert!(matches!(
+                store.lookup(
+                    &address("a"),
+                    expires + STALE_RETENTION - Duration::from_secs(1),
+                    true
+                ),
+                CacheLookup::Stale(_)
+            ));
+            assert!(matches!(
+                store.lookup(&address("a"), expires + STALE_RETENTION, true),
+                CacheLookup::Miss
+            ));
+            assert_eq!(store.len(), 0);
+
+            put(&mut store, "a", now);
+            store.get(&address("a"), now).unwrap();
+            put_opaque(&mut store, "b", now, 60);
+            put(&mut store, "c", now);
+            if algorithm == DnsCacheAlgorithm::Arc {
+                let ghost = store.entry(*store.index.get(&opaque_key("b")).unwrap());
+                assert!(ghost.value.is_none());
+                assert!(matches!(
+                    store.lookup(&opaque_key("b"), now, true),
+                    CacheLookup::Miss
+                ));
+                assert_eq!(store.opaque_len(), 0);
+                assert_eq!(store.recent_target, 0);
+            }
+        }
+    }
+
+    #[test]
+    fn stale_mixed_results_use_the_same_resident_and_opaque_budgets() {
+        let now = Instant::now();
+        let stale = now + Duration::from_secs(61);
+        for algorithm in [DnsCacheAlgorithm::Lru, DnsCacheAlgorithm::Arc] {
+            let mut store = Store::with_algorithm(64, algorithm);
+            for index in 0..64 {
+                put_opaque(&mut store, &format!("wire{index}"), now, 60);
+            }
+            let bytes = store.opaque_bytes();
+            let mut stale_hits = 0;
+            for index in 0..64 {
+                stale_hits += usize::from(matches!(
+                    store.lookup(&opaque_key(&format!("wire{index}")), stale, true),
+                    CacheLookup::Stale(_)
+                ));
+            }
+            assert!(stale_hits > 0);
+            assert_eq!(store.opaque_bytes(), bytes);
+            for index in 0..200 {
+                put_opaque(&mut store, &format!("new{index}"), stale, 60);
+                if index % 4 == 0 {
+                    put(&mut store, &format!("typed{index}"), stale);
+                }
+                assert!(store.len() <= 64);
+                assert!(store.opaque_len() <= MAX_OPAQUE_CACHE_ENTRIES);
+                assert!(store.opaque_bytes() <= MAX_OPAQUE_CACHE_BYTES);
+                assert!(store.index.len() <= store.metadata_limit());
+                assert!(store.slots.len() <= store.metadata_limit());
+            }
+            store.clear();
+            assert_eq!(store.len(), 0);
+            assert_eq!(store.opaque_bytes(), 0);
+            assert_eq!(store.allocated_slots(), 0);
+        }
+    }
+
+    #[test]
+    fn arc_preserves_a_frequent_result_that_lru_evicts_during_a_scan() {
+        let now = Instant::now();
+        for (algorithm, retained) in [
+            (DnsCacheAlgorithm::Lru, false),
+            (DnsCacheAlgorithm::Arc, true),
+        ] {
+            let mut store = Store::with_algorithm(2, algorithm);
+            put(&mut store, "a", now);
+            assert!(store.get(&address("a"), now).is_some());
+            put(&mut store, "b", now);
+            put(&mut store, "c", now);
+            assert_eq!(store.get(&address("a"), now).is_some(), retained);
+            assert_eq!(store.len(), 2);
+        }
+    }
+
+    #[test]
+    fn arc_ghost_hits_adapt_in_both_directions_and_release_wire_payloads() {
+        let now = Instant::now();
+        let mut store = Store::with_algorithm(2, DnsCacheAlgorithm::Arc);
+        put(&mut store, "a", now);
+        store.get(&address("a"), now).unwrap();
+        put_opaque(&mut store, "b", now, 60);
+        put(&mut store, "c", now);
+        let ghost = store.entry(*store.index.get(&opaque_key("b")).unwrap());
+        assert_eq!(ghost.list, List::RecentGhost);
+        assert!(ghost.value.is_none());
+        assert_eq!(store.opaque_entries, 0);
+        assert_eq!(
+            store.opaque_bytes,
+            opaque_key("b").opaque_metadata_bytes().unwrap()
+        );
+        put_opaque(&mut store, "b", now, 60);
+        assert_eq!(store.recent_target, 1);
+        let ghost = store.entry(*store.index.get(&address("a")).unwrap());
+        assert_eq!(ghost.list, List::FrequentGhost);
+        assert!(ghost.value.is_none());
+        put(&mut store, "a", now);
+        assert_eq!(store.recent_target, 0);
+        assert!(store.get(&address("a"), now).is_some());
+        assert!(store.get(&opaque_key("b"), now).is_some());
+        assert_eq!(store.len(), 2);
+    }
+
+    #[test]
+    fn arc_expired_residents_and_ghosts_are_removed_without_learning_a_hit() {
+        let now = Instant::now();
+        let mut store = Store::with_algorithm(2, DnsCacheAlgorithm::Arc);
+        put(&mut store, "a", now);
+        store.get(&address("a"), now).unwrap();
+        put_opaque(&mut store, "b", now, 30);
+        store
+            .insert(
+                address("c"),
+                Value::Address(CacheValue::Negative { rcode: 3 }),
+                now + Duration::from_secs(30),
+                now,
+                false,
+            )
+            .unwrap();
+        let expired = now + Duration::from_secs(31);
+        assert!(store.get(&opaque_key("b"), expired).is_none());
+        assert_eq!(store.opaque_bytes, 0);
+        assert!(store.get(&address("c"), expired).is_none());
+        assert_eq!(store.len(), 1);
+        put_opaque(&mut store, "b", expired, 60);
+        assert_eq!(store.recent_target, 0);
+        assert_eq!(
+            store
+                .entry(*store.index.get(&opaque_key("b")).unwrap())
+                .list,
+            List::Recent
+        );
+    }
+
+    #[test]
+    fn arc_mixed_payloads_keep_resident_ghost_and_opaque_budgets_bounded() {
+        let now = Instant::now();
+        let mut store = Store::with_algorithm(64, DnsCacheAlgorithm::Arc);
+        assert_eq!(store.allocated_slots(), 0);
+        for index in 0..600 {
+            if index % 6 == 0 {
+                put(&mut store, &format!("typed{index}"), now);
+            } else {
+                put_opaque(&mut store, &format!("wire{index}"), now, 60);
+            }
+            if index % 3 == 0 {
+                store.get(&opaque_key(&format!("wire{}", index - index % 6 + 1)), now);
+            }
+            assert!(store.len() <= 64);
+            assert!(store.index.len() <= 128);
+            assert!(store.slots.len() <= 128);
+            assert!(store.list_len(List::RecentGhost) + store.list_len(List::FrequentGhost) <= 64);
+            assert!(store.list_len(List::Recent) + store.list_len(List::RecentGhost) <= 64);
+            assert!(store.recent_target <= 64);
+            assert!(store.opaque_entries <= MAX_OPAQUE_CACHE_ENTRIES);
+            assert!(store.opaque_bytes <= MAX_OPAQUE_CACHE_BYTES);
+            let mut resident = 0;
+            let mut opaque = 0;
+            let mut bytes = 0;
+            for slot in store.index.values() {
+                let entry = store.entry(*slot);
+                assert_eq!(entry.value.is_none(), entry.list.is_ghost());
+                resident += usize::from(entry.value.is_some());
+                if let Some(retained) = entry.opaque_bytes() {
+                    opaque += usize::from(entry.value.is_some());
+                    bytes += retained;
+                }
+            }
+            assert_eq!(store.len(), resident);
+            assert_eq!(store.opaque_entries, opaque);
+            assert_eq!(store.opaque_bytes, bytes);
+        }
+        store.clear();
+        assert_eq!(store.len(), 0);
+        assert_eq!(store.opaque_bytes, 0);
+        assert_eq!(store.allocated_slots(), 0);
+        assert_eq!(store.index.capacity(), 0);
+    }
+}
diff --git a/src/dns/fake_ip.rs b/src/dns/fake_ip.rs
new file mode 100644
index 0000000..1575557
--- /dev/null
+++ b/src/dns/fake_ip.rs
@@ -0,0 +1,494 @@
+//! Separate synthetic address pools; answer TTL does not expire the reverse map.
+use crate::config::Network;
+use crate::config::{
+    DnsPolicySelector, FakeIpConfig, FakeIpFilterMode, FakeIpRange, RuleAction, RuleKind,
+};
+use crate::routing::{GeoMatcher, RoutingContext};
+use crate::session::Destination;
+use redb::{Database, ReadableDatabase, ReadableTable, TableDefinition};
+use std::{
+    collections::HashMap,
+    io,
+    net::IpAddr,
+    path::Path,
+    sync::{Arc, Mutex},
+};
+
+const MEMORY_ENTRIES: usize = 1000;
+const RANGES: TableDefinition<&str, &str> = TableDefinition::new("ranges");
+const OFFSETS: TableDefinition<&str, u128> = TableDefinition::new("offsets");
+fn storage_error(_: impl std::fmt::Display) -> io::Error {
+    io::Error::other("fake-IP storage is unavailable")
+}
+
+pub(crate) struct DomainFilter {
+    index: super::policy::DomainIndex,
+    selectors: Vec<DnsPolicySelector>,
+}
+impl DomainFilter {
+    pub(crate) fn new(selectors: &[DnsPolicySelector]) -> Self {
+        let mut index = super::policy::DomainIndex::new();
+        for selector in selectors {
+            if let DnsPolicySelector::Domains(patterns) = selector {
+                for pattern in patterns {
+                    index.insert(pattern, 0);
+                }
+            }
+        }
+        Self {
+            index,
+            selectors: selectors.to_vec(),
+        }
+    }
+    pub(crate) fn matches(
+        &self,
+        host: &str,
+        geo: &dyn GeoMatcher,
+        decision: &crate::config::RuleDecision,
+    ) -> Result<bool, crate::config::MatchFailure> {
+        decision.visit()?;
+        if self.index.find(0, host).is_some() {
+            return Ok(true);
+        }
+        for selector in &self.selectors {
+            match selector {
+                DnsPolicySelector::GeoSite(codes) => {
+                    for code in codes {
+                        if geo.geosite_available(code)
+                            && geo.matches_geosite_bounded(code, host, decision)?
+                        {
+                            return Ok(true);
+                        }
+                    }
+                }
+                DnsPolicySelector::RuleSets { sets, .. } => {
+                    for set in sets {
+                        if set.matches_domain(host, geo, decision)? {
+                            return Ok(true);
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+        Ok(false)
+    }
+}
+pub(crate) struct Filter {
+    config: FakeIpConfig,
+    domains: DomainFilter,
+}
+impl Filter {
+    pub(crate) fn new(config: &FakeIpConfig) -> Self {
+        Self {
+            config: config.clone(),
+            domains: DomainFilter::new(&config.filter),
+        }
+    }
+    pub(crate) fn skips(
+        &self,
+        host: &str,
+        geo: &dyn GeoMatcher,
+        decision: &crate::config::RuleDecision,
+    ) -> Result<bool, crate::config::MatchFailure> {
+        decision.visit()?;
+        if self.config.mode == FakeIpFilterMode::Rule {
+            let destination = Destination::Domain {
+                host: host.to_owned(),
+                port: 53,
+            };
+            let Ok(context) = RoutingContext::new(Network::Tcp, &destination) else {
+                return Ok(true);
+            };
+            let mut context = context.with_decision(decision);
+            context.disable_ip_resolution();
+            for rule in &self.config.rules {
+                let matched = if let RuleKind::RuleSet {
+                    content: Some(set), ..
+                } = &rule.kind
+                {
+                    set.matches_domain(host, geo, decision)?
+                } else {
+                    match crate::routing::matches_rule(rule, &context, geo) {
+                        Ok(matched) => matched,
+                        Err(
+                            crate::routing::PredicateFailure::NeedsIpResolution
+                            | crate::routing::PredicateFailure::NeedsProcessLookup,
+                        ) => false,
+                        Err(crate::routing::PredicateFailure::Evaluation(failure)) => {
+                            return Err(failure);
+                        }
+                    }
+                };
+                if matched {
+                    return Ok(rule.action == RuleAction::Direct);
+                }
+            }
+            return Ok(false);
+        }
+        let matched = self.domains.matches(host, geo, decision)?;
+        Ok(if self.config.mode == FakeIpFilterMode::Whitelist {
+            !matched
+        } else {
+            matched
+        })
+    }
+}
+
+pub(crate) struct FakePools {
+    v4: Option<Mutex<Pool>>,
+    v6: Option<Mutex<Pool>>,
+}
+impl FakePools {
+    pub(crate) fn open(config: &FakeIpConfig, ipv6: bool, path: Option<&Path>) -> io::Result<Self> {
+        let database = path
+            .map(|path| {
+                let file = std::fs::OpenOptions::new()
+                    .read(true)
+                    .write(true)
+                    .create(true)
+                    .truncate(false)
+                    .open(path)?;
+                #[cfg(unix)]
+                {
+                    use std::os::unix::fs::PermissionsExt;
+                    file.set_permissions(std::fs::Permissions::from_mode(0o600))?;
+                }
+                Database::builder()
+                    .set_cache_size(2 * 1024 * 1024)
+                    .create_file(file)
+                    .map(Arc::new)
+                    .map_err(storage_error)
+            })
+            .transpose()?;
+        Ok(Self {
+            v4: config
+                .range
+                .map(|range| Pool::new(range, database.clone()))
+                .transpose()?
+                .map(Mutex::new),
+            v6: config
+                .range6
+                .filter(|_| ipv6)
+                .map(|range| Pool::new(range, database.clone()))
+                .transpose()?
+                .map(Mutex::new),
+        })
+    }
+
+    pub(crate) fn same_address_families(&self, other: &Self) -> bool {
+        self.v4.is_some() == other.v4.is_some() && self.v6.is_some() == other.v6.is_some()
+    }
+
+    pub(crate) fn has_persistent_store(&self) -> io::Result<bool> {
+        let Some(pool) = self.v4.as_ref().or(self.v6.as_ref()) else {
+            return Ok(false);
+        };
+        Ok(pool.lock().map_err(storage_error)?.database.is_some())
+    }
+
+    /// Forget forward bindings without immediately reusing addresses that may
+    /// still be present in a client's active flow. Reverse maps and cursor keep
+    /// their normal bounded lifetime; database commit precedes memory mutation.
+    pub(crate) fn flush_forward(&self) -> io::Result<()> {
+        let mut v4 = self
+            .v4
+            .as_ref()
+            .map(|pool| pool.lock().map_err(storage_error))
+            .transpose()?;
+        let mut v6 = self
+            .v6
+            .as_ref()
+            .map(|pool| pool.lock().map_err(storage_error))
+            .transpose()?;
+        if let Some(db) = v4
+            .as_ref()
+            .and_then(|p| p.database.as_ref())
+            .or_else(|| v6.as_ref().and_then(|p| p.database.as_ref()))
+        {
+            let tx = db.begin_write().map_err(storage_error)?;
+            for pool in [v4.as_ref(), v6.as_ref()].into_iter().flatten() {
+                tx.delete_table(pool.hosts).map_err(storage_error)?;
+                tx.open_table(pool.hosts).map_err(storage_error)?;
+            }
+            tx.commit().map_err(storage_error)?;
+        }
+        for pool in [v4.as_mut(), v6.as_mut()].into_iter().flatten() {
+            pool.memory.clear();
+        }
+        Ok(())
+    }
+
+    pub(crate) fn lookup(&self, host: &str, ipv6: bool) -> io::Result<Option<IpAddr>> {
+        let pool = if ipv6 { &self.v6 } else { &self.v4 };
+        pool.as_ref()
+            .map(|pool| pool.lock().map_err(storage_error)?.lookup(host))
+            .transpose()
+    }
+    pub(crate) fn recover(&self, address: IpAddr) -> io::Result<Option<String>> {
+        let pool = if address.is_ipv6() {
+            &self.v6
+        } else {
+            &self.v4
+        };
+        let Some(pool) = pool else {
+            return Ok(None);
+        };
+        let mut pool = pool.lock().map_err(storage_error)?;
+        let (base, last) = pool.range.bounds();
+        let value = ip_value(address);
+        if !pool.range.cidr.contains(address) || value == base + 1 || value == last {
+            return Ok(None);
+        }
+        pool.reverse(value)?.map(Some).ok_or_else(|| {
+            io::Error::new(
+                io::ErrorKind::NotFound,
+                "fake-IP mapping is no longer available",
+            )
+        })
+    }
+}
+fn ip_value(address: IpAddr) -> u128 {
+    match address {
+        IpAddr::V4(ip) => u128::from(u32::from(ip)),
+        IpAddr::V6(ip) => u128::from(ip),
+    }
+}
+struct Pool {
+    range: FakeIpRange,
+    next: u128,
+    database: Option<Arc<Database>>,
+    family: &'static str,
+    hosts: TableDefinition<'static, &'static str, u128>,
+    ips: TableDefinition<'static, u128, &'static str>,
+    memory: HashMap<String, (u128, u64)>,
+    reverse: HashMap<u128, String>,
+    clock: u64,
+}
+impl Pool {
+    fn new(range: FakeIpRange, database: Option<Arc<Database>>) -> io::Result<Self> {
+        let ipv6 = range.cidr.network.is_ipv6();
+        let family = if ipv6 { "6" } else { "4" };
+        let hosts = TableDefinition::new(if ipv6 { "host6" } else { "host4" });
+        let ips = TableDefinition::new(if ipv6 { "ip6" } else { "ip4" });
+        let mut next = range.bounds().0 + 3;
+        if let Some(db) = &database {
+            let tx = db.begin_write().map_err(storage_error)?;
+            {
+                let mut ranges = tx.open_table(RANGES).map_err(storage_error)?;
+                let key = format!("{}/{}", range.cidr.network, range.cidr.prefix_len);
+                let same = ranges
+                    .get(family)
+                    .map_err(storage_error)?
+                    .is_some_and(|v| v.value() == key);
+                let mut offsets = tx.open_table(OFFSETS).map_err(storage_error)?;
+                if !same {
+                    tx.delete_table(hosts).map_err(storage_error)?;
+                    tx.delete_table(ips).map_err(storage_error)?;
+                    ranges.insert(family, key.as_str()).map_err(storage_error)?;
+                    offsets.insert(family, next).map_err(storage_error)?;
+                } else if let Some(value) = offsets.get(family).map_err(storage_error)? {
+                    next = value.value();
+                }
+                tx.open_table(hosts).map_err(storage_error)?;
+                tx.open_table(ips).map_err(storage_error)?;
+            }
+            tx.commit().map_err(storage_error)?;
+        }
+        let (base, last) = range.bounds();
+        if next < base + 3 || next >= last {
+            return Err(storage_error("invalid offset"));
+        }
+        Ok(Self {
+            range,
+            next,
+            database,
+            family,
+            hosts,
+            ips,
+            memory: HashMap::new(),
+            reverse: HashMap::new(),
+            clock: 0,
+        })
+    }
+    fn lookup(&mut self, host: &str) -> io::Result<IpAddr> {
+        self.clock = self.clock.wrapping_add(1);
+        let previous = if let Some(db) = &self.database {
+            let tx = db.begin_read().map_err(storage_error)?;
+            let hosts = tx.open_table(self.hosts).map_err(storage_error)?;
+            hosts.get(host).map_err(storage_error)?.map(|v| v.value())
+        } else {
+            self.memory.get_mut(host).map(|entry| {
+                entry.1 = self.clock;
+                entry.0
+            })
+        };
+        if let Some(value) = previous {
+            return Ok(self.range.address(value));
+        }
+        let (base, last) = self.range.bounds();
+        let mut next = self.next + 1;
+        if next >= last {
+            next = base + 4;
+        }
+        if let Some(db) = &self.database {
+            let tx = db.begin_write().map_err(storage_error)?;
+            {
+                let mut hosts = tx.open_table(self.hosts).map_err(storage_error)?;
+                let mut ips = tx.open_table(self.ips).map_err(storage_error)?;
+                let previous = ips
+                    .remove(next)
+                    .map_err(storage_error)?
+                    .map(|v| v.value().to_owned());
+                if let Some(previous) = previous {
+                    let same = hosts
+                        .get(previous.as_str())
+                        .map_err(storage_error)?
+                        .is_some_and(|value| value.value() == next);
+                    if same {
+                        hosts.remove(previous.as_str()).map_err(storage_error)?;
+                    }
+                }
+                hosts.insert(host, next).map_err(storage_error)?;
+                ips.insert(next, host).map_err(storage_error)?;
+                tx.open_table(OFFSETS)
+                    .map_err(storage_error)?
+                    .insert(self.family, next)
+                    .map_err(storage_error)?;
+            }
+            tx.commit().map_err(storage_error)?;
+        } else {
+            if let Some(previous) = self.reverse.remove(&next)
+                && self
+                    .memory
+                    .get(&previous)
+                    .is_some_and(|(address, _)| *address == next)
+            {
+                self.memory.remove(&previous);
+            }
+            if self.reverse.len() >= MEMORY_ENTRIES {
+                // Cleared forward maps may leave reverse-only slots. Reclaim
+                // one before insertion, retaining the original memory bound.
+                let stale = self.reverse.iter().find_map(|(address, host)| {
+                    (!self
+                        .memory
+                        .get(host)
+                        .is_some_and(|(current, _)| current == address))
+                    .then_some(*address)
+                });
+                if let Some(stale) = stale {
+                    self.reverse.remove(&stale);
+                }
+            }
+            if self.memory.len() >= MEMORY_ENTRIES
+                && let Some(old) = self
+                    .memory
+                    .iter()
+                    .min_by_key(|(_, (_, clock))| clock)
+                    .map(|(host, _)| host.clone())
+            {
+                let (address, _) = self.memory.remove(&old).unwrap();
+                self.reverse.remove(&address);
+            }
+            self.memory.insert(host.to_owned(), (next, self.clock));
+            self.reverse.insert(next, host.to_owned());
+        }
+        self.next = next;
+        Ok(self.range.address(next))
+    }
+    fn reverse(&mut self, ip: u128) -> io::Result<Option<String>> {
+        self.clock = self.clock.wrapping_add(1);
+        if let Some(db) = &self.database {
+            let tx = db.begin_read().map_err(storage_error)?;
+            let ips = tx.open_table(self.ips).map_err(storage_error)?;
+            ips.get(ip)
+                .map_err(storage_error)
+                .map(|v| v.map(|v| v.value().to_owned()))
+        } else {
+            let host = self.reverse.get(&ip).cloned();
+            if let Some(entry) = host.as_ref().and_then(|host| self.memory.get_mut(host)) {
+                entry.1 = self.clock;
+            }
+            Ok(host)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn fake_ip_forward_flush_preserves_reverse_and_never_erases_a_newer_binding() {
+        let mut config = crate::config::DnsConfig::default().fake_ip;
+        config.range = FakeIpRange::parse("198.18.0.1/29", false).unwrap();
+        for persist in [false, true] {
+            let root = tempfile::tempdir().unwrap();
+            let path = root.path().join("fake-ip.redb");
+            let pools = FakePools::open(&config, false, persist.then_some(path.as_path())).unwrap();
+            let old = pools.lookup("one.example", false).unwrap().unwrap();
+            pools.flush_forward().unwrap();
+            assert_eq!(pools.recover(old).unwrap().as_deref(), Some("one.example"));
+            let new = pools.lookup("one.example", false).unwrap().unwrap();
+            assert_ne!(old, new);
+            pools.lookup("two.example", false).unwrap();
+            assert_eq!(pools.lookup("three.example", false).unwrap(), Some(old));
+            // Reusing the old reverse slot must keep one's newer binding.
+            assert_eq!(pools.lookup("one.example", false).unwrap(), Some(new));
+            drop(pools);
+            if persist {
+                let pools = FakePools::open(&config, false, Some(&path)).unwrap();
+                assert_eq!(pools.lookup("one.example", false).unwrap(), Some(new));
+            }
+        }
+        config.range = FakeIpRange::parse("198.18.0.1/16", false).unwrap();
+        let pools = FakePools::open(&config, false, None).unwrap();
+        for i in 0..MEMORY_ENTRIES * 3 {
+            if i % 17 == 0 {
+                pools.flush_forward().unwrap();
+            }
+            pools.lookup(&format!("{i}.example"), false).unwrap();
+            let pool = pools.v4.as_ref().unwrap().lock().unwrap();
+            assert!(pool.reverse.len() <= MEMORY_ENTRIES);
+            assert!(pool.memory.len() <= MEMORY_ENTRIES);
+        }
+    }
+
+    #[test]
+    fn fake_ip_persistence_restarts_and_reuses_addresses_transactionally() {
+        let mut config = crate::config::DnsConfig::default().fake_ip;
+        config.range = FakeIpRange::parse("198.18.0.1/29", false).unwrap();
+        let root = tempfile::tempdir().unwrap();
+        let path = root.path().join("fake-ip.redb");
+        let first;
+        {
+            let pools = FakePools::open(&config, false, Some(&path)).unwrap();
+            first = pools.lookup("one.example", false).unwrap().unwrap();
+            assert_eq!(first, "198.18.0.4".parse::<IpAddr>().unwrap());
+            pools.lookup("two.example", false).unwrap();
+        }
+        {
+            let pools = FakePools::open(&config, false, Some(&path)).unwrap();
+            assert_eq!(
+                pools.recover(first).unwrap().as_deref(),
+                Some("one.example")
+            );
+            assert_eq!(pools.lookup("one.example", false).unwrap(), Some(first));
+            assert_eq!(
+                pools.lookup("three.example", false).unwrap(),
+                Some("198.18.0.6".parse().unwrap())
+            );
+            assert_eq!(pools.lookup("four.example", false).unwrap(), Some(first));
+            assert_eq!(
+                pools.recover(first).unwrap().as_deref(),
+                Some("four.example")
+            );
+        }
+        config.range = FakeIpRange::parse("198.19.0.1/29", false).unwrap();
+        let pools = FakePools::open(&config, false, Some(&path)).unwrap();
+        assert_eq!(pools.recover(first).unwrap(), None);
+        assert_eq!(
+            pools.lookup("one.example", false).unwrap(),
+            Some("198.19.0.4".parse().unwrap())
+        );
+    }
+}
diff --git a/src/dns/fallback.rs b/src/dns/fallback.rs
new file mode 100644
index 0000000..f46453d
--- /dev/null
+++ b/src/dns/fallback.rs
@@ -0,0 +1,141 @@
+use crate::{config::DnsFallbackConfig, routing::GeoMatcher};
+use std::{future::Future, net::IpAddr};
+
+pub(crate) struct Filter {
+    config: DnsFallbackConfig,
+    domains: super::fake_ip::DomainFilter,
+}
+impl Filter {
+    pub(crate) fn new(config: &DnsFallbackConfig) -> Self {
+        Self {
+            config: config.clone(),
+            domains: super::fake_ip::DomainFilter::new(&config.domains),
+        }
+    }
+    pub(crate) fn domain(
+        &self,
+        host: &str,
+        geo: &dyn GeoMatcher,
+        decision: &crate::config::RuleDecision,
+    ) -> Result<bool, crate::config::MatchFailure> {
+        self.domains.matches(host, geo, decision)
+    }
+    pub(crate) fn address(&self, address: IpAddr, geo: &dyn GeoMatcher) -> bool {
+        if self.config.ipcidr.iter().any(|cidr| cidr.contains(address)) {
+            return true;
+        }
+        let Some(code) = &self.config.geoip else {
+            return false;
+        };
+        let local = address.is_unspecified()
+            || address.is_loopback()
+            || address.is_multicast()
+            || match address {
+                IpAddr::V4(ip) => ip.is_private() || ip.is_link_local(),
+                IpAddr::V6(ip) => ip.is_unique_local() || ip.is_unicast_link_local(),
+            };
+        !local
+            && (code == "lan" || (geo.geoip_available(code) && !geo.matches_geoip(code, address)))
+    }
+}
+
+// Both futures remain owned by the requesting DNS flight. Returning the primary
+// drops the speculative fallback; cancellation drops both without detached work.
+pub(super) async fn choose<T>(
+    primary: impl Future<Output = T>,
+    fallback: impl Future<Output = T>,
+    lazy: bool,
+    acceptable: impl FnOnce(&T) -> bool,
+) -> T {
+    tokio::pin!(fallback);
+    let mut ready = None;
+    let first = if lazy {
+        primary.await
+    } else {
+        tokio::pin!(primary);
+        tokio::select! {
+            biased;
+            answer = &mut fallback => { ready = Some(answer); primary.await }
+            answer = &mut primary => answer,
+        }
+    };
+    if acceptable(&first) {
+        super::trace::record("primary-answer");
+        first
+    } else if let Some(answer) = ready {
+        super::trace::record("fallback-answer");
+        answer
+    } else {
+        super::trace::record("fallback-answer");
+        fallback.await
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::{
+        Arc,
+        atomic::{AtomicBool, Ordering},
+    };
+    #[tokio::test]
+    async fn fallback_query_scheduling_cancels_speculation_and_defers_lazy_work() {
+        struct Guard(Arc<AtomicBool>);
+        impl Drop for Guard {
+            fn drop(&mut self) {
+                self.0.store(true, Ordering::SeqCst);
+            }
+        }
+        for lazy in [true, false] {
+            let started = Arc::new(AtomicBool::new(false));
+            let dropped = Arc::new(AtomicBool::new(false));
+            let fallback = {
+                let started = started.clone();
+                let dropped = dropped.clone();
+                async move {
+                    started.store(true, Ordering::SeqCst);
+                    let _guard = Guard(dropped);
+                    std::future::pending::<u8>().await
+                }
+            };
+            assert_eq!(choose(async { 1 }, fallback, lazy, |v| *v == 1).await, 1);
+            assert_eq!(started.load(Ordering::SeqCst), !lazy);
+            assert_eq!(dropped.load(Ordering::SeqCst), !lazy);
+        }
+        assert_eq!(choose(async { 0 }, async { 2 }, true, |v| *v == 1).await, 2);
+    }
+    #[test]
+    fn fallback_geoip_preserves_local_addresses_and_uses_shared_matcher() {
+        struct Country;
+        impl GeoMatcher for Country {
+            fn matches_geosite(&self, _: &str, _: &str) -> bool {
+                false
+            }
+            fn geoip_available(&self, code: &str) -> bool {
+                code == "cn"
+            }
+            fn matches_geoip(&self, _: &str, address: IpAddr) -> bool {
+                address == "203.0.113.1".parse::<IpAddr>().unwrap()
+            }
+        }
+        let filter = Filter::new(&DnsFallbackConfig {
+            geoip: Some("cn".into()),
+            ..Default::default()
+        });
+        for address in [
+            "10.1.2.3",
+            "127.0.0.1",
+            "169.254.0.2",
+            "::1",
+            "fc00::1",
+            "203.0.113.1",
+        ] {
+            assert!(!filter.address(address.parse().unwrap(), &Country));
+        }
+        assert!(filter.address("203.0.113.2".parse().unwrap(), &Country));
+        assert!(!filter.address(
+            "203.0.113.2".parse().unwrap(),
+            &crate::routing::EmptyGeoMatcher
+        ));
+    }
+}
diff --git a/src/dns/hosts.rs b/src/dns/hosts.rs
new file mode 100644
index 0000000..7181e28
--- /dev/null
+++ b/src/dns/hosts.rs
@@ -0,0 +1,227 @@
+use super::policy::DomainIndex;
+use crate::config::{HostEntry, HostValue, MAX_CONFIG_BYTES};
+use std::{
+    collections::HashSet,
+    io::{self, Read},
+    net::IpAddr,
+};
+
+pub(crate) struct Hosts {
+    index: DomainIndex,
+    system: std::collections::HashMap<String, HostValue>,
+    values: Vec<HostValue>,
+}
+
+impl Hosts {
+    pub(crate) fn new(entries: &[HostEntry], configured: bool, system: bool) -> Self {
+        let mut hosts = Self {
+            index: DomainIndex::new(),
+            system: std::collections::HashMap::new(),
+            values: Vec::new(),
+        };
+        if system {
+            #[cfg(windows)]
+            let path = std::env::var_os("SystemRoot")
+                .map(std::path::PathBuf::from)
+                .unwrap_or_else(|| "C:\\Windows".into())
+                .join("System32/drivers/etc/hosts");
+            #[cfg(not(windows))]
+            let path = std::path::PathBuf::from("/etc/hosts");
+            if let Ok(file) = std::fs::File::open(path) {
+                let mut text = String::new();
+                if file
+                    .take(MAX_CONFIG_BYTES as u64)
+                    .read_to_string(&mut text)
+                    .is_ok()
+                {
+                    let mut entries = std::collections::BTreeMap::<String, Vec<IpAddr>>::new();
+                    for line in text.lines() {
+                        let mut words = line.split('#').next().unwrap_or("").split_whitespace();
+                        let Some(ip) = words.next().and_then(|word| word.parse::<IpAddr>().ok())
+                        else {
+                            continue;
+                        };
+                        for name in words {
+                            if let Ok(name) = super::canonicalize_name(name) {
+                                entries.entry(name).or_default().push(ip);
+                            }
+                        }
+                    }
+                    for (name, addresses) in entries {
+                        hosts.system.insert(name, HostValue::Addresses(addresses));
+                    }
+                }
+            }
+        }
+        if configured {
+            // PreparedCore has already captured LAN entries. Standalone resolver
+            // constructors capture their own snapshot and fail closed if unavailable.
+            let materialized = entries
+                .iter()
+                .any(|entry| matches!(entry.value, HostValue::Lan))
+                .then(|| {
+                    let mut entries = entries.to_vec();
+                    if materialize_lan(&mut entries).is_err() {
+                        clear_lan_markers(&mut entries);
+                    }
+                    entries
+                });
+            for entry in materialized.as_deref().unwrap_or(entries) {
+                hosts.insert(&entry.pattern, entry.value.clone());
+            }
+        }
+        hosts
+    }
+    fn insert(&mut self, name: &str, value: HostValue) {
+        self.index.insert(name, self.values.len());
+        self.values.push(value);
+    }
+    pub(crate) fn lookup(&self, name: &str) -> io::Result<HostValue> {
+        let mut name = name.to_owned();
+        let mut seen = HashSet::new();
+        while let Some(value) = self
+            .index
+            .find(0, &name)
+            .map(|index| &self.values[index])
+            .or_else(|| self.system.get(&name))
+        {
+            if !seen.insert(name.clone()) || seen.len() > 32 {
+                return Err(io::ErrorKind::InvalidInput.into());
+            }
+            match value {
+                HostValue::Addresses(addresses) => {
+                    return Ok(HostValue::Addresses(addresses.clone()));
+                }
+                HostValue::Alias(alias) => name.clone_from(alias),
+                HostValue::Lan => return Err(io::ErrorKind::InvalidInput.into()),
+            }
+        }
+        Ok(HostValue::Alias(name))
+    }
+}
+
+pub(crate) fn validate(entries: &[HostEntry]) -> io::Result<()> {
+    let mut entries = entries.to_vec();
+    clear_lan_markers(&mut entries);
+    let hosts = Hosts::new(&entries, true, false);
+    for entry in entries {
+        hosts.lookup(&entry.pattern)?;
+    }
+    Ok(())
+}
+
+pub(crate) fn materialize_lan(entries: &mut [HostEntry]) -> io::Result<()> {
+    if !entries
+        .iter()
+        .any(|entry| matches!(entry.value, HostValue::Lan))
+    {
+        return Ok(());
+    }
+    let addresses = getifaddrs::getifaddrs()
+        .map_err(|_| io::Error::other("hosts LAN interface snapshot unavailable"))?
+        .filter_map(|interface| interface.address.ip_addr())
+        .collect::<Vec<_>>();
+    apply_lan_snapshot(entries, &addresses)
+}
+
+fn clear_lan_markers(entries: &mut [HostEntry]) {
+    for entry in entries {
+        if matches!(entry.value, HostValue::Lan) {
+            entry.value = HostValue::Addresses(Vec::new());
+        }
+    }
+}
+
+fn apply_lan_snapshot(entries: &mut [HostEntry], addresses: &[IpAddr]) -> io::Result<()> {
+    if !entries
+        .iter()
+        .any(|entry| matches!(entry.value, HostValue::Lan))
+    {
+        return Ok(());
+    }
+    let addresses = addresses
+        .iter()
+        .copied()
+        .map(|address| match address {
+            IpAddr::V6(address) => address
+                .to_ipv4_mapped()
+                .map(IpAddr::V4)
+                .unwrap_or(IpAddr::V6(address)),
+            address => address,
+        })
+        .filter(|address| {
+            !address.is_loopback()
+                && match address {
+                    IpAddr::V4(address) => !address.is_link_local(),
+                    IpAddr::V6(address) => !address.is_unicast_link_local(),
+                }
+        })
+        .collect::<Vec<_>>();
+    if addresses.is_empty() {
+        return Err(io::Error::new(
+            io::ErrorKind::AddrNotAvailable,
+            "hosts LAN snapshot has no usable interface addresses",
+        ));
+    }
+    for entry in entries {
+        if matches!(entry.value, HostValue::Lan) {
+            entry.value = HostValue::Addresses(addresses.clone());
+        }
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn lan_hosts_use_a_fixed_injected_snapshot_without_interface_access() {
+        let config = crate::config::Config::parse_yaml(
+            b"hosts: {home.lan: lan, alias.lan: home.lan, public.lan: [lan]}\nrules: ['MATCH,DIRECT']",
+        )
+        .unwrap();
+        assert!(matches!(config.dns.hosts[1].value, HostValue::Alias(_)));
+        assert!(
+            config
+                .dns
+                .hosts
+                .iter()
+                .any(|entry| matches!(entry.value, HostValue::Lan))
+        );
+        let mut entries = config.dns.hosts;
+        let addresses = [
+            "127.0.0.1",
+            "::1",
+            "169.254.1.2",
+            "fe80::1",
+            "192.168.1.2",
+            "2001:db8::2",
+            "203.0.113.4",
+        ]
+        .map(|address| address.parse().unwrap());
+        apply_lan_snapshot(&mut entries, &addresses).unwrap();
+        let hosts = Hosts::new(&entries, true, false);
+        let expected = HostValue::Addresses(addresses[4..].to_vec());
+        assert_eq!(hosts.lookup("home.lan").unwrap(), expected);
+        assert_eq!(hosts.lookup("alias.lan").unwrap(), expected);
+        assert_eq!(hosts.lookup("public.lan").unwrap(), expected);
+        apply_lan_snapshot(&mut entries, &["192.168.2.2".parse().unwrap()]).unwrap();
+        assert_eq!(
+            Hosts::new(&entries, true, false)
+                .lookup("home.lan")
+                .unwrap(),
+            expected
+        );
+        let mut empty = vec![HostEntry {
+            pattern: "empty.lan".into(),
+            value: HostValue::Lan,
+        }];
+        assert_eq!(
+            apply_lan_snapshot(&mut empty, &addresses[..4])
+                .unwrap_err()
+                .kind(),
+            io::ErrorKind::AddrNotAvailable
+        );
+    }
+}
diff --git a/src/dns/http2.rs b/src/dns/http2.rs
new file mode 100644
index 0000000..6451be8
--- /dev/null
+++ b/src/dns/http2.rs
@@ -0,0 +1,528 @@
+//! Multiplexed DoH over an authenticated, protected caller-owned stream.
+//! Drivers and the idle reaper belong to one resolver's shutdown barrier.
+
+use super::{MAX_HTTP_HEADER_BYTES, MAX_MESSAGE_SIZE};
+use crate::{config::DnsNameserver, dispatch::BoxStream};
+use bytes::Bytes;
+use std::{
+    collections::HashMap,
+    hash::Hash,
+    io,
+    sync::{
+        Arc, Mutex, Weak,
+        atomic::{AtomicBool, AtomicUsize, Ordering},
+    },
+    time::Duration,
+};
+use tokio::{
+    sync::{Mutex as AsyncMutex, Semaphore},
+    task::JoinHandle,
+    time::Instant,
+};
+use tokio_util::{sync::CancellationToken, task::TaskTracker};
+
+const MAX_STREAMS: usize = 32;
+const MAX_IDLE: usize = 4;
+const IDLE_TIMEOUT: Duration = Duration::from_secs(30);
+
+pub(super) struct Pool<K> {
+    state: Mutex<State<K>>,
+    admission: Mutex<()>,
+    cancel: CancellationToken,
+    tasks: TaskTracker,
+    reaper_running: AtomicBool,
+    max_idle: AtomicUsize,
+}
+
+struct State<K> {
+    connections: Vec<(K, Arc<Connection>)>,
+    initialization: HashMap<K, Weak<AsyncMutex<()>>>,
+}
+
+struct Connection {
+    sender: h2::client::SendRequest<Bytes>,
+    meta: Arc<Metadata>,
+    streams: Arc<Semaphore>,
+    driver: JoinHandle<()>,
+}
+
+struct Metadata {
+    reusable: AtomicBool,
+    active: AtomicUsize,
+    last_used: Mutex<Instant>,
+}
+
+pub(super) struct Lease<K: Clone + Eq + Hash + Send + Sync + 'static> {
+    connection: Arc<Connection>,
+    owner: Weak<Pool<K>>,
+}
+
+impl<K: Clone + Eq + Hash + Send + Sync + 'static> Pool<K> {
+    pub(super) fn new() -> Arc<Self> {
+        Arc::new(Self {
+            state: Mutex::new(State {
+                connections: Vec::new(),
+                initialization: HashMap::new(),
+            }),
+            admission: Mutex::new(()),
+            cancel: CancellationToken::new(),
+            tasks: TaskTracker::new(),
+            reaper_running: AtomicBool::new(false),
+            max_idle: AtomicUsize::new(MAX_IDLE),
+        })
+    }
+
+    pub(super) fn disable_idle(&self) {
+        self.max_idle.store(0, Ordering::Release);
+    }
+
+    pub(super) fn is_closed(&self) -> bool {
+        self.cancel.is_cancelled()
+    }
+
+    pub(super) fn has(&self, key: &K) -> bool {
+        if self.is_closed() {
+            return false;
+        }
+        self.state
+            .lock()
+            .unwrap()
+            .connections
+            .iter()
+            .any(|(candidate, connection)| {
+                candidate == key
+                    && connection.meta.reusable.load(Ordering::Acquire)
+                    && (connection.meta.active.load(Ordering::Acquire) != 0
+                        || Instant::now()
+                            .duration_since(*connection.meta.last_used.lock().unwrap())
+                            < IDLE_TIMEOUT)
+            })
+    }
+
+    pub(super) fn get(self: &Arc<Self>, key: &K) -> Option<Lease<K>> {
+        if self.is_closed() {
+            return None;
+        }
+        let mut state = self.state.lock().unwrap();
+        self.maintain_locked(&mut state);
+        let connection = state
+            .connections
+            .iter()
+            .find(|(candidate, connection)| {
+                candidate == key && connection.meta.reusable.load(Ordering::Acquire)
+            })?
+            .1
+            .clone();
+        connection.meta.active.fetch_add(1, Ordering::AcqRel);
+        Some(Lease {
+            connection,
+            owner: Arc::downgrade(self),
+        })
+    }
+
+    /// Cold builders remain caller-owned. A canceled builder releases its
+    /// per-key gate, so the next waiter can build without orphaned work.
+    pub(super) fn initialization(&self, key: K) -> Arc<AsyncMutex<()>> {
+        let mut state = self.state.lock().unwrap();
+        state
+            .initialization
+            .retain(|_, gate| gate.strong_count() != 0);
+        if let Some(gate) = state.initialization.get(&key).and_then(Weak::upgrade) {
+            return gate;
+        }
+        let gate = Arc::new(AsyncMutex::new(()));
+        state.initialization.insert(key, Arc::downgrade(&gate));
+        gate
+    }
+
+    pub(super) async fn connect(
+        self: &Arc<Self>,
+        key: K,
+        stream: BoxStream,
+        physical: impl Send + 'static,
+    ) -> io::Result<Lease<K>> {
+        let (sender, connection) = h2::client::Builder::new()
+            .enable_push(false)
+            .initial_window_size(MAX_MESSAGE_SIZE as u32)
+            .initial_connection_window_size((MAX_MESSAGE_SIZE * MAX_STREAMS) as u32)
+            .max_header_list_size(MAX_HTTP_HEADER_BYTES as u32)
+            .max_concurrent_reset_streams(MAX_STREAMS * 2)
+            .max_send_buffer_size(MAX_MESSAGE_SIZE)
+            .handshake(stream)
+            .await
+            .map_err(error)?;
+        let meta = Arc::new(Metadata {
+            reusable: AtomicBool::new(true),
+            active: AtomicUsize::new(1),
+            last_used: Mutex::new(Instant::now()),
+        });
+        let finished = meta.clone();
+        let driver = self.spawn(async move {
+            let _physical = physical;
+            let _ = connection.await;
+            finished.reusable.store(false, Ordering::Release);
+        })?;
+        let connection = Arc::new(Connection {
+            sender,
+            meta,
+            streams: Arc::new(Semaphore::new(MAX_STREAMS)),
+            driver,
+        });
+        {
+            // Serialize publication with shutdown, after the handshake.
+            let _admission = self.admission.lock().unwrap();
+            if self.is_closed() {
+                return Err(closed());
+            }
+            self.state
+                .lock()
+                .unwrap()
+                .connections
+                .push((key, connection.clone()));
+        }
+        self.ensure_reaper()?;
+        Ok(Lease {
+            connection,
+            owner: Arc::downgrade(self),
+        })
+    }
+
+    fn spawn(
+        &self,
+        future: impl std::future::Future<Output = ()> + Send + 'static,
+    ) -> io::Result<JoinHandle<()>> {
+        let _admission = self.admission.lock().unwrap();
+        if self.is_closed() {
+            return Err(closed());
+        }
+        let cancel = self.cancel.clone();
+        let observation =
+            crate::resources::observation::track(crate::resources::observation::ResourceKind::Task);
+        Ok(self
+            .tasks
+            .spawn(crate::resources::observation::bind(async move {
+                let _observation = observation;
+                tokio::select! { biased; ()=cancel.cancelled()=>{}, ()=future=>{} }
+            })))
+    }
+
+    fn maintain_locked(&self, state: &mut State<K>) {
+        let now = Instant::now();
+        state.connections.retain(|(_, connection)| {
+            connection.meta.active.load(Ordering::Acquire) != 0
+                || connection.meta.reusable.load(Ordering::Acquire)
+                    && now.duration_since(*connection.meta.last_used.lock().unwrap()) < IDLE_TIMEOUT
+        });
+        while state
+            .connections
+            .iter()
+            .filter(|(_, connection)| connection.meta.active.load(Ordering::Acquire) == 0)
+            .count()
+            > self.max_idle.load(Ordering::Acquire)
+        {
+            let Some(index) = state
+                .connections
+                .iter()
+                .enumerate()
+                .filter(|(_, (_, connection))| connection.meta.active.load(Ordering::Acquire) == 0)
+                .min_by_key(|(_, (_, connection))| *connection.meta.last_used.lock().unwrap())
+                .map(|(index, _)| index)
+            else {
+                break;
+            };
+            state.connections.swap_remove(index);
+        }
+    }
+
+    fn ensure_reaper(self: &Arc<Self>) -> io::Result<()> {
+        if self.reaper_running.swap(true, Ordering::AcqRel) {
+            return Ok(());
+        }
+        let pool = Arc::downgrade(self);
+        self.spawn(async move {
+            loop {
+                tokio::time::sleep(IDLE_TIMEOUT).await;
+                let Some(pool) = pool.upgrade() else {
+                    return;
+                };
+                let mut state = pool.state.lock().unwrap();
+                pool.maintain_locked(&mut state);
+                if state.connections.is_empty() {
+                    pool.reaper_running.store(false, Ordering::Release);
+                    return;
+                }
+            }
+        })?;
+        Ok(())
+    }
+
+    pub(super) fn close(&self) {
+        let _admission = self.admission.lock().unwrap();
+        self.cancel.cancel();
+        self.tasks.close();
+        let mut state = self.state.lock().unwrap();
+        state.initialization.clear();
+        let connections = std::mem::take(&mut state.connections);
+        drop(state);
+        drop(connections);
+    }
+
+    pub(super) async fn shutdown(&self) {
+        self.close();
+        self.tasks.wait().await;
+    }
+
+    #[cfg(test)]
+    pub(super) fn driver_count(&self) -> usize {
+        self.tasks.len()
+    }
+}
+
+impl<K> Drop for Pool<K> {
+    fn drop(&mut self) {
+        self.cancel.cancel();
+        self.tasks.close();
+    }
+}
+
+impl Drop for Connection {
+    fn drop(&mut self) {
+        self.driver.abort();
+    }
+}
+
+struct ResetOnDrop(h2::SendStream<Bytes>, bool);
+impl Drop for ResetOnDrop {
+    fn drop(&mut self) {
+        if !self.1 {
+            self.0.send_reset(h2::Reason::CANCEL);
+        }
+    }
+}
+
+impl<K: Clone + Eq + Hash + Send + Sync + 'static> Lease<K> {
+    pub(super) async fn exchange<R>(
+        &self,
+        server: &DnsNameserver,
+        query: &[u8],
+        validate: impl Fn(&[u8]) -> io::Result<R>,
+    ) -> io::Result<(Vec<u8>, R)> {
+        let result = self.exchange_inner(server, query, validate).await;
+        if result.is_err() {
+            self.connection
+                .meta
+                .reusable
+                .store(false, Ordering::Release);
+        }
+        result
+    }
+
+    async fn exchange_inner<R>(
+        &self,
+        server: &DnsNameserver,
+        query: &[u8],
+        validate: impl Fn(&[u8]) -> io::Result<R>,
+    ) -> io::Result<(Vec<u8>, R)> {
+        let _permit = self
+            .connection
+            .streams
+            .clone()
+            .acquire_owned()
+            .await
+            .map_err(|_| closed())?;
+        let request = super::https::request(server, query)?;
+        let mut sender = self
+            .connection
+            .sender
+            .clone()
+            .ready()
+            .await
+            .map_err(error)?;
+        let (response, stream) = sender.send_request(request, true).map_err(error)?;
+        let mut reset = ResetOnDrop(stream, false);
+        let response = response.await.map_err(error)?;
+        if response.status() != http::StatusCode::OK
+            || !response
+                .headers()
+                .get(http::header::CONTENT_TYPE)
+                .and_then(|value| value.to_str().ok())
+                .is_some_and(|value| {
+                    value.split(';').next().is_some_and(|value| {
+                        value.trim().eq_ignore_ascii_case("application/dns-message")
+                    })
+                })
+        {
+            return Err(io::ErrorKind::InvalidData.into());
+        }
+        let expected = response
+            .headers()
+            .get(http::header::CONTENT_LENGTH)
+            .map(|value| {
+                value
+                    .to_str()
+                    .ok()
+                    .and_then(|value| value.parse::<usize>().ok())
+                    .filter(|length| *length <= MAX_MESSAGE_SIZE)
+                    .ok_or(io::ErrorKind::InvalidData)
+            })
+            .transpose()?;
+        let mut receive = response.into_body();
+        let mut body = Vec::new();
+        while let Some(data) = receive.data().await {
+            let data = data.map_err(error)?;
+            if body.len() + data.len() > MAX_MESSAGE_SIZE {
+                return Err(io::ErrorKind::InvalidData.into());
+            }
+            body.extend_from_slice(&data);
+            receive
+                .flow_control()
+                .release_capacity(data.len())
+                .map_err(error)?;
+        }
+        if expected.is_some_and(|length| body.len() != length) {
+            return Err(io::ErrorKind::InvalidData.into());
+        }
+        if let Some(trailers) = receive.trailers().await.map_err(error)?
+            && trailers
+                .iter()
+                .map(|(name, value)| name.as_str().len() + value.as_bytes().len() + 32)
+                .sum::<usize>()
+                > MAX_HTTP_HEADER_BYTES
+        {
+            return Err(io::ErrorKind::InvalidData.into());
+        }
+        super::https::restore_id(query, &mut body)?;
+        let validated = validate(&body)?;
+        reset.1 = true;
+        Ok((body, validated))
+    }
+}
+
+impl<K: Clone + Eq + Hash + Send + Sync + 'static> Drop for Lease<K> {
+    fn drop(&mut self) {
+        // Use the same lock order as get/maintenance: pool, then timestamp.
+        if let Some(owner) = self.owner.upgrade() {
+            let mut state = owner.state.lock().unwrap();
+            *self.connection.meta.last_used.lock().unwrap() = Instant::now();
+            self.connection.meta.active.fetch_sub(1, Ordering::AcqRel);
+            owner.maintain_locked(&mut state);
+        } else {
+            self.connection.meta.active.fetch_sub(1, Ordering::AcqRel);
+        }
+    }
+}
+
+fn error(error: h2::Error) -> io::Error {
+    io::Error::new(io::ErrorKind::ConnectionAborted, error)
+}
+fn closed() -> io::Error {
+    io::ErrorKind::BrokenPipe.into()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tokio::sync::oneshot;
+
+    struct Physical(Arc<AtomicUsize>);
+    impl Drop for Physical {
+        fn drop(&mut self) {
+            self.0.fetch_sub(1, Ordering::AcqRel);
+        }
+    }
+
+    #[tokio::test]
+    async fn doh_h2_cancel_resets_one_stream_and_stop_joins_inflight_driver() {
+        let config = crate::config::Config::parse_yaml(b"mixed-port: 1080\ndns:\n  enable: true\n  nameserver: ['https://192.0.2.1/dns-query']\n").unwrap();
+        let server = config.dns.nameservers[0].clone();
+        let (client, peer) = tokio::io::duplex(64 * 1024);
+        let (arrived, arrival) = oneshot::channel();
+        let (reset_sent, reset_seen) = oneshot::channel();
+        let (third_sent, third_seen) = oneshot::channel();
+        let peer = tokio::spawn(async move {
+            let mut connection = h2::server::handshake(peer).await.unwrap();
+            let (_, mut first) = connection.accept().await.unwrap().unwrap();
+            arrived.send(()).unwrap();
+            let reason = tokio::select! {
+                reason = futures_util::future::poll_fn(|cx| first.poll_reset(cx)) => reason.unwrap(),
+                request = connection.accept() => panic!("unexpected request before reset: {}", request.is_some()),
+            };
+            assert_eq!(reason, h2::Reason::CANCEL);
+            reset_sent.send(()).unwrap();
+            let (request, mut respond) = connection.accept().await.unwrap().unwrap();
+            use base64::Engine as _;
+            let query = base64::engine::general_purpose::URL_SAFE_NO_PAD
+                .decode(request.uri().query().unwrap().strip_prefix("dns=").unwrap())
+                .unwrap();
+            let query = crate::dns::classify_query(&query).unwrap();
+            let wire = crate::dns::synthesize_empty_response(&query, 0).unwrap();
+            let response = http::Response::builder()
+                .status(200)
+                .header("content-type", "application/dns-message")
+                .body(())
+                .unwrap();
+            respond
+                .send_response(response, false)
+                .unwrap()
+                .send_data(Bytes::from(wire), true)
+                .unwrap();
+            let (_, _held) = connection.accept().await.unwrap().unwrap();
+            third_sent.send(()).unwrap();
+            // The client stops while this response remains pending.
+            while let Some(result) = connection.accept().await {
+                if result.is_err() {
+                    break;
+                }
+            }
+        });
+        let pool = Pool::new();
+        let physical = Arc::new(AtomicUsize::new(1));
+        let first = pool
+            .connect((), Box::new(client), Physical(physical.clone()))
+            .await
+            .unwrap();
+        let query =
+            crate::dns::build_query(0x2345, "first.example", crate::dns::QueryType::A).unwrap();
+        let request_server = server.clone();
+        let first =
+            tokio::spawn(async move { first.exchange(&request_server, &query, |_| Ok(())).await });
+        tokio::time::timeout(Duration::from_secs(3), arrival)
+            .await
+            .unwrap()
+            .unwrap();
+        first.abort();
+        assert!(first.await.unwrap_err().is_cancelled());
+        tokio::time::timeout(Duration::from_secs(3), reset_seen)
+            .await
+            .unwrap()
+            .unwrap();
+        let query =
+            crate::dns::build_query(0x4567, "second.example", crate::dns::QueryType::A).unwrap();
+        let (wire, ()) = pool
+            .get(&())
+            .unwrap()
+            .exchange(&server, &query, |wire| {
+                let classified = crate::dns::classify_query(&query).unwrap();
+                crate::dns::validate_wire_response(&classified, wire)
+                    .map(|_| ())
+                    .map_err(|_| io::Error::from(io::ErrorKind::InvalidData))
+            })
+            .await
+            .unwrap();
+        assert_eq!(&wire[..2], &query[..2]);
+        let held = pool.get(&()).unwrap();
+        let third = tokio::spawn(async move { held.exchange(&server, &query, |_| Ok(())).await });
+        tokio::time::timeout(Duration::from_secs(3), third_seen)
+            .await
+            .unwrap()
+            .unwrap();
+        tokio::time::timeout(Duration::from_secs(3), pool.shutdown())
+            .await
+            .unwrap();
+        assert_eq!(pool.driver_count(), 0);
+        assert_eq!(physical.load(Ordering::Acquire), 0);
+        assert!(pool.get(&()).is_none());
+        assert!(third.await.unwrap().is_err());
+        peer.await.unwrap();
+    }
+}
diff --git a/src/dns/https.rs b/src/dns/https.rs
new file mode 100644
index 0000000..3740b03
--- /dev/null
+++ b/src/dns/https.rs
@@ -0,0 +1,259 @@
+//! Shared DoH GET construction and HTTP/1.1 framing over caller-owned IO.
+use super::{MAX_HTTP_HEADER_BYTES, MAX_MESSAGE_SIZE};
+use crate::{config::DnsNameserver, dispatch::BoxStream};
+use base64::{Engine as _, engine::general_purpose::URL_SAFE_NO_PAD};
+use std::io;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+pub(super) fn request(server: &DnsNameserver, query: &[u8]) -> io::Result<http::Request<()>> {
+    if query.len() < 12 || query.len() > MAX_MESSAGE_SIZE {
+        return Err(io::ErrorKind::InvalidInput.into());
+    }
+    let mut wire = query.to_vec();
+    wire[..2].fill(0);
+    let host = match &server.address {
+        crate::config::DnsAddress::Ip(std::net::IpAddr::V6(ip)) => format!("[{ip}]"),
+        other => other.to_string(),
+    };
+    let authority = format!("{host}:{}", server.port);
+    let target = format!(
+        "{}?dns={}",
+        server.path.as_deref().unwrap_or("/dns-query"),
+        URL_SAFE_NO_PAD.encode(wire)
+    );
+    let size = authority.len()
+        + target.len()
+        + server.http_auth.as_ref().map_or(0, |auth| auth.0.len())
+        // Covers HTTP/1 framing and the HTTP/2 pseudo/header names with
+        // RFC 7540's 32-byte accounting per field.
+        + 512;
+    if size > MAX_HTTP_HEADER_BYTES {
+        return Err(io::ErrorKind::InvalidInput.into());
+    }
+    let uri = http::Uri::builder()
+        .scheme(if server.transport == crate::config::DnsTransport::Http {
+            "http"
+        } else {
+            "https"
+        })
+        .authority(authority)
+        .path_and_query(target)
+        .build()
+        .map_err(|_| io::ErrorKind::InvalidInput)?;
+    let mut builder = http::Request::builder()
+        .method("GET")
+        .uri(uri)
+        .header("accept", "application/dns-message");
+    if let Some(auth) = &server.http_auth {
+        let mut value =
+            http::HeaderValue::from_str(&auth.0).map_err(|_| io::ErrorKind::InvalidInput)?;
+        value.set_sensitive(true);
+        builder = builder.header("authorization", value);
+    }
+    builder
+        .body(())
+        .map_err(|_| io::ErrorKind::InvalidInput.into())
+}
+
+pub(super) fn restore_id(query: &[u8], response: &mut [u8]) -> io::Result<()> {
+    if response.len() < 12 || response[..2] != [0, 0] {
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidData,
+            "DNS response ID is not zero",
+        ));
+    }
+    response[..2].copy_from_slice(&query[..2]);
+    Ok(())
+}
+
+#[cfg(feature = "dns-quic")]
+pub(super) fn validate_headers(
+    status: http::StatusCode,
+    headers: &http::HeaderMap,
+) -> io::Result<Option<usize>> {
+    if status != http::StatusCode::OK
+        || !headers
+            .get(http::header::CONTENT_TYPE)
+            .and_then(|value| value.to_str().ok())
+            .is_some_and(|value| {
+                value.split(';').next().is_some_and(|value| {
+                    value.trim().eq_ignore_ascii_case("application/dns-message")
+                })
+            })
+    {
+        return Err(io::ErrorKind::InvalidData.into());
+    }
+    headers
+        .get(http::header::CONTENT_LENGTH)
+        .map(|value| {
+            value
+                .to_str()
+                .ok()
+                .and_then(|value| value.parse::<usize>().ok())
+                .filter(|length| *length <= MAX_MESSAGE_SIZE)
+                .ok_or_else(|| io::ErrorKind::InvalidData.into())
+        })
+        .transpose()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn doh_get_uses_id_zero_unpadded_dns_and_sensitive_basic() {
+        let config = crate::config::Config::parse_yaml(b"mixed-port: 1080\ndns:\n  enable: true\n  nameserver: ['http://alice:password@[2001:db8::1]:8080/dns%2Fquery?old=value#ecs=192.0.2.1']\n").unwrap();
+        let query =
+            crate::dns::build_query(0x1234, "example.com", crate::dns::QueryType::A).unwrap();
+        let request = request(&config.dns.nameservers[0], &query).unwrap();
+        assert_eq!(request.method(), http::Method::GET);
+        assert_eq!(request.uri().authority().unwrap(), "[2001:db8::1]:8080");
+        assert_eq!(request.uri().path(), "/dns/query");
+        let encoded = request.uri().query().unwrap().strip_prefix("dns=").unwrap();
+        assert!(!encoded.contains('='));
+        let mut decoded = URL_SAFE_NO_PAD.decode(encoded).unwrap();
+        assert_eq!(&decoded[..2], &[0, 0]);
+        assert_eq!(&decoded[2..], &query[2..]);
+        assert_eq!(
+            request.headers()["authorization"],
+            "Basic YWxpY2U6cGFzc3dvcmQ="
+        );
+        assert!(request.headers()["authorization"].is_sensitive());
+        assert_eq!(request.headers()["accept"], "application/dns-message");
+        for name in ["content-type", "content-length", "user-agent"] {
+            assert!(!request.headers().contains_key(name));
+        }
+        restore_id(&query, &mut decoded).unwrap();
+        assert_eq!(decoded, query);
+        assert!(restore_id(&query, &mut decoded).is_err());
+    }
+}
+
+async fn line(stream: &mut BoxStream, remaining: &mut usize) -> io::Result<String> {
+    let mut bytes = Vec::new();
+    loop {
+        *remaining = remaining.checked_sub(1).ok_or(io::ErrorKind::InvalidData)?;
+        let byte = stream.read_u8().await?;
+        bytes.push(byte);
+        if bytes.ends_with(b"\r\n") {
+            bytes.truncate(bytes.len() - 2);
+            break;
+        }
+    }
+    String::from_utf8(bytes).map_err(|_| io::ErrorKind::InvalidData.into())
+}
+
+pub(super) async fn exchange(
+    stream: &mut BoxStream,
+    server: &DnsNameserver,
+    query: &[u8],
+) -> io::Result<(Vec<u8>, bool)> {
+    let request = request(server, query)?;
+    let mut head = format!(
+        "GET {} HTTP/1.1\r\nHost: {}\r\n",
+        request.uri().path_and_query().expect("DoH has a path"),
+        request.uri().authority().expect("DoH has an authority")
+    );
+    for (name, value) in request.headers() {
+        head.push_str(name.as_str());
+        head.push_str(": ");
+        head.push_str(value.to_str().map_err(|_| io::ErrorKind::InvalidInput)?);
+        head.push_str("\r\n");
+    }
+    head.push_str("\r\n");
+    stream.write_all(head.as_bytes()).await?;
+    stream.flush().await?;
+    let mut budget = MAX_HTTP_HEADER_BYTES;
+    let status = line(stream, &mut budget).await?;
+    let mut parts = status.split_ascii_whitespace();
+    let version = parts.next().unwrap_or_default();
+    if !matches!(version, "HTTP/1.0" | "HTTP/1.1") || parts.next() != Some("200") {
+        return Err(io::Error::other("DNS HTTP response status is not 200"));
+    }
+    let mut reusable = version == "HTTP/1.1";
+    let mut length = None;
+    let mut chunked = false;
+    let mut content_type = false;
+    loop {
+        let header = line(stream, &mut budget).await?;
+        if header.is_empty() {
+            break;
+        }
+        let (name, value) = header.split_once(':').ok_or(io::ErrorKind::InvalidData)?;
+        let value = value.trim();
+        match name.to_ascii_lowercase().as_str() {
+            "content-length" => {
+                if length.is_some() {
+                    return Err(io::ErrorKind::InvalidData.into());
+                }
+                length = Some(
+                    value
+                        .parse::<usize>()
+                        .map_err(|_| io::ErrorKind::InvalidData)?,
+                );
+            }
+            "transfer-encoding" => {
+                if chunked || !value.eq_ignore_ascii_case("chunked") {
+                    return Err(io::ErrorKind::InvalidData.into());
+                }
+                chunked = true;
+            }
+            "content-type" => {
+                content_type = value.split(';').next().is_some_and(|value| {
+                    value.trim().eq_ignore_ascii_case("application/dns-message")
+                })
+            }
+            "connection"
+                if value
+                    .split(',')
+                    .any(|value| value.trim().eq_ignore_ascii_case("close")) =>
+            {
+                reusable = false
+            }
+            _ => {}
+        }
+    }
+    if !content_type || (chunked && length.is_some()) {
+        return Err(io::ErrorKind::InvalidData.into());
+    }
+    let mut body = Vec::new();
+    if chunked {
+        loop {
+            let size = line(stream, &mut budget).await?;
+            let size = usize::from_str_radix(size.split(';').next().unwrap_or("").trim(), 16)
+                .map_err(|_| io::ErrorKind::InvalidData)?;
+            if size == 0 {
+                while !line(stream, &mut budget).await?.is_empty() {}
+                break;
+            }
+            let end = body
+                .len()
+                .checked_add(size)
+                .filter(|size| *size <= MAX_MESSAGE_SIZE)
+                .ok_or(io::ErrorKind::InvalidData)?;
+            let start = body.len();
+            body.resize(end, 0);
+            stream.read_exact(&mut body[start..]).await?;
+            if stream.read_u16().await? != 0x0d0a {
+                return Err(io::ErrorKind::InvalidData.into());
+            }
+        }
+    } else if let Some(length) = length {
+        if length > MAX_MESSAGE_SIZE {
+            return Err(io::ErrorKind::InvalidData.into());
+        }
+        body.resize(length, 0);
+        stream.read_exact(&mut body).await?;
+    } else {
+        reusable = false;
+        stream
+            .take(MAX_MESSAGE_SIZE as u64 + 1)
+            .read_to_end(&mut body)
+            .await?;
+        if body.len() > MAX_MESSAGE_SIZE {
+            return Err(io::ErrorKind::InvalidData.into());
+        }
+    }
+    restore_id(query, &mut body)?;
+    Ok((body, reusable))
+}
diff --git a/src/dns/mod.rs b/src/dns/mod.rs
index 132b039..12c804c 100644
--- a/src/dns/mod.rs
+++ b/src/dns/mod.rs
@@ -2,11 +2,25 @@
 //!
 //! This module deliberately contains no network transport. Callers own query
 //! scheduling and cancellation. Every allocation retained by the cache and
-//! redir-host table is bounded by the constants below, while concurrent query
+//! redir-host table is bounded by the configured count and wire/record limits,
+//! while concurrent query
 //! activity is observed rather than rejected by a fixed local admission cap.
 
+mod cache;
+pub(crate) mod fake_ip;
+pub(crate) mod fallback;
+pub(crate) mod hosts;
+mod http2;
+mod https;
+mod options;
+pub(crate) mod policy;
+#[cfg(feature = "dns-quic")]
+mod quic;
+pub(crate) mod trace;
+
 pub mod resolution;
 pub mod runtime;
+pub(crate) mod source;
 
 use std::{
     fmt,
@@ -17,13 +31,15 @@ use std::{
 use sha2::{Digest as _, Sha256};
 
 pub const MAX_MESSAGE_SIZE: usize = 4_096;
+pub(crate) const MAX_HTTP_HEADER_BYTES: usize = 16 * 1024;
 /// Maximum number of resource records scanned across all response sections.
 pub const MAX_RESPONSE_RECORDS: usize = 64;
 /// Maximum number of unique addresses retained in the typed cache and hints.
 pub const MAX_ANSWERS: usize = 16;
 pub const MAX_NAME_LEN: usize = 253;
 pub const MAX_COMPRESSION_JUMPS: usize = 16;
-pub const MAX_CACHE_ENTRIES: usize = 256;
+/// Default result count per DNS role; configuration may choose another count.
+pub const MAX_CACHE_ENTRIES: usize = 4_096;
 pub const MAX_REDIR_HOST_ENTRIES: usize = 256;
 pub const MAX_OPAQUE_RECORDS: usize = 64;
 pub const MAX_OPAQUE_CACHE_ENTRIES: usize = 64;
@@ -157,6 +173,10 @@ pub struct ClassifiedDnsQuery {
     pub kind: DnsQueryKind,
     question_wire: Box<[u8]>,
     semantics_digest: [u8; 32],
+    // Plain address lookups use the small address cache. Client EDNS or
+    // semantic flags require retaining the validated wire response instead.
+    needs_wire_cache: bool,
+    dnssec_context: bool,
 }
 
 impl ClassifiedDnsQuery {
@@ -202,6 +222,7 @@ pub struct ValidatedOpaqueResponse {
     ttl_offsets: Box<[u16]>,
     rcode: u16,
     cache_policy: OpaqueCachePolicy,
+    stale_eligible: bool,
 }
 
 impl ValidatedOpaqueResponse {
@@ -294,6 +315,11 @@ struct ScannedRecord {
 
 /// Builds a recursive A or AAAA query containing exactly one question.
 pub fn build_query(id: u16, name: &str, query_type: QueryType) -> Result<Vec<u8>> {
+    build_wire_query(id, name, query_type as u16)
+}
+
+/// Builds one bounded IN query without narrowing the resource-record type.
+pub(crate) fn build_wire_query(id: u16, name: &str, query_type: u16) -> Result<Vec<u8>> {
     let name = canonicalize_name(name)?;
     let mut message = Vec::with_capacity(DNS_HEADER_LEN + name.len() + 6);
     message.extend_from_slice(&id.to_be_bytes());
@@ -303,12 +329,77 @@ pub fn build_query(id: u16, name: &str, query_type: QueryType) -> Result<Vec<u8>
     message.extend_from_slice(&0_u16.to_be_bytes()); // NSCOUNT
     message.extend_from_slice(&0_u16.to_be_bytes()); // ARCOUNT
     encode_name(&name, &mut message);
-    message.extend_from_slice(&(query_type as u16).to_be_bytes());
+    message.extend_from_slice(&query_type.to_be_bytes());
     message.extend_from_slice(&CLASS_IN.to_be_bytes());
     debug_assert!(message.len() <= MAX_MESSAGE_SIZE);
     Ok(message)
 }
 
+/// HTTPS ECH is the binary key 5 parameter of the first applicable answer in
+/// wire order. Other SVCB fields never change the proxy's dial/SNI/ALPN policy.
+pub(crate) fn https_ech_config(query: &[u8], response: &[u8]) -> Result<Vec<u8>> {
+    let query = classify_query(query)?;
+    let validated = validate_opaque_response(&query, response)?;
+    if validated.rcode != u16::from(RCODE_NOERROR) || response[2] & 0x02 != 0 {
+        return Err(DnsError::InvalidRecord);
+    }
+    let header = parse_wire_question_header(response)?;
+    let mut cursor = header.records_offset;
+    for _ in 0..header.answer_count {
+        let record = scan_record(response, &mut cursor)?;
+        if record.record_type != 65 || record.record_class != CLASS_IN {
+            continue;
+        }
+        let rdata = &response[usize::from(record.data_start)..usize::from(record.data_end)];
+        if let Some(ech) = svcb_ech_parameter(rdata)? {
+            return Ok(ech.to_vec());
+        }
+    }
+    Err(DnsError::InvalidRecord)
+}
+
+fn svcb_ech_parameter(mut data: &[u8]) -> Result<Option<&[u8]>> {
+    // RFC 9460: priority and an uncompressed TargetName. Bound every label and
+    // the full name before examining strictly increasing unique SvcParam keys.
+    data = data.get(2..).ok_or(DnsError::InvalidRecord)?;
+    let mut total = 0usize;
+    loop {
+        let (&length, rest) = data.split_first().ok_or(DnsError::InvalidRecord)?;
+        if length > 63 {
+            return Err(DnsError::InvalidRecord);
+        }
+        total += 1 + usize::from(length);
+        if total > 255 {
+            return Err(DnsError::InvalidRecord);
+        }
+        data = rest
+            .get(usize::from(length)..)
+            .ok_or(DnsError::InvalidRecord)?;
+        if length == 0 {
+            break;
+        }
+    }
+    let mut previous = None;
+    let mut ech = None;
+    while !data.is_empty() {
+        let header = data.get(..4).ok_or(DnsError::InvalidRecord)?;
+        let key = u16::from_be_bytes([header[0], header[1]]);
+        let length = usize::from(u16::from_be_bytes([header[2], header[3]]));
+        if previous.is_some_and(|old| key <= old) {
+            return Err(DnsError::InvalidRecord);
+        }
+        previous = Some(key);
+        let (value, rest) = data[4..]
+            .split_at_checked(length)
+            .ok_or(DnsError::InvalidRecord)?;
+        if key == 5 {
+            ech = Some(value);
+        }
+        data = rest;
+    }
+    Ok(ech)
+}
+
 /// Classifies a bounded single-question IN query without narrowing its qtype.
 /// Query answer and authority sections are rejected. The additional section is
 /// restricted to at most one structurally valid EDNS OPT record.
@@ -328,11 +419,14 @@ pub fn classify_query(message: &[u8]) -> Result<ClassifiedDnsQuery> {
     }
 
     let mut cursor = parsed.records_offset;
+    let mut dnssec_context =
+        parsed.flags & 0x0030 != 0 || dnssec_record_type(parsed.question.query_type);
     for _ in 0..parsed.additional_count {
         let record = scan_record(message, &mut cursor)?;
         if record.record_type != TYPE_OPT || !record.owner.is_empty() {
             return Err(DnsError::InvalidRecord);
         }
+        dnssec_context |= record.ttl & 0x8000 != 0;
         validate_edns_options(
             message,
             usize::from(record.data_start),
@@ -357,6 +451,8 @@ pub fn classify_query(message: &[u8]) -> Result<ClassifiedDnsQuery> {
         kind,
         question_wire,
         semantics_digest,
+        needs_wire_cache: parsed.additional_count != 0 || parsed.flags & !0x0100 != 0,
+        dnssec_context,
     })
 }
 
@@ -398,6 +494,13 @@ pub fn validate_opaque_response(
     if !query.is_opaque() {
         return Err(DnsError::ExpectedOpaqueQuestion);
     }
+    validate_wire_response(query, response)
+}
+
+fn validate_wire_response(
+    query: &ClassifiedDnsQuery,
+    response: &[u8],
+) -> Result<ValidatedOpaqueResponse> {
     let parsed = parse_wire_question_header(response)?;
     if parsed.flags & 0x8000 == 0 {
         return Err(DnsError::NotAResponse);
@@ -428,9 +531,11 @@ pub fn validate_opaque_response(
     let mut seen_opt = false;
     let mut extended_rcode = 0_u8;
     let mut authority_has_soa = false;
+    let mut dnssec_context = query.dnssec_context || parsed.flags & 0x0030 != 0;
     for (section, count) in section_counts.into_iter().enumerate() {
         for _ in 0..count {
             let record = scan_record(response, &mut cursor)?;
+            dnssec_context |= dnssec_record_type(record.record_type);
             if section == 1
                 && record.record_type == 6
                 && record.record_class == query.question.query_class
@@ -443,6 +548,7 @@ pub fn validate_opaque_response(
                 }
                 seen_opt = true;
                 extended_rcode = (record.ttl >> 24) as u8;
+                dnssec_context |= record.ttl & 0x8000 != 0;
                 validate_edns_options(
                     response,
                     usize::from(record.data_start),
@@ -493,9 +599,16 @@ pub fn validate_opaque_response(
         ttl_offsets: ttl_offsets.into_boxed_slice(),
         rcode,
         cache_policy,
+        stale_eligible: matches!(cache_policy, OpaqueCachePolicy::Positive { .. })
+            && !dnssec_context,
     })
 }
 
+// Keep signed-response lifetime policy separate from ordinary positive TTLs.
+const fn dnssec_record_type(record_type: u16) -> bool {
+    matches!(record_type, 43 | 46 | 47 | 48 | 50 | 51 | 59 | 60)
+}
+
 /// Parses and validates a DNS query. Only opcode 0, class IN and A/AAAA are
 /// accepted. Additional records (for example EDNS OPT) are bounded by the
 /// message-size limit and validated structurally.
@@ -935,23 +1048,37 @@ pub enum CacheValue {
     },
 }
 
-#[derive(Debug)]
-struct CacheEntry {
-    name: String,
-    query_type: QueryType,
-    value: CacheValue,
-    expires_at: Instant,
-    sequence: u64,
+/// Internal lookup state; the current public cache getters remain fresh-only.
+#[derive(Debug, PartialEq, Eq)]
+pub(crate) enum CacheLookup<T> {
+    Fresh(T),
+    Stale(T),
+    Miss,
+}
+
+impl<T> CacheLookup<T> {
+    fn into_fresh(self) -> Option<T> {
+        match self {
+            Self::Fresh(value) => Some(value),
+            Self::Stale(_) | Self::Miss => None,
+        }
+    }
+
+    fn map<U>(self, convert: impl FnOnce(T) -> U) -> CacheLookup<U> {
+        match self {
+            Self::Fresh(value) => CacheLookup::Fresh(convert(value)),
+            Self::Stale(value) => CacheLookup::Stale(convert(value)),
+            Self::Miss => CacheLookup::Miss,
+        }
+    }
 }
 
-/// Fixed-capacity, single-owner DNS cache. It can be placed behind the
-/// runtime's existing lock when shared; mutation requires `&mut self` so no
-/// internal task or allocation can grow independently.
+/// Single-owner result cache with a shared count for typed and opaque questions.
+/// Lookups, recency updates and capacity eviction use a hash index and linked
+/// slots; payloads remain bounded by their respective address/wire budgets.
 #[derive(Debug)]
 pub struct DnsCache {
-    entries: Vec<CacheEntry>,
-    max_entries: usize,
-    next_sequence: u64,
+    store: cache::Store,
 }
 
 impl Default for DnsCache {
@@ -968,26 +1095,33 @@ impl DnsCache {
 
     #[must_use]
     pub(crate) fn with_max_entries(max_entries: usize) -> Self {
-        assert!(max_entries != 0, "DNS cache capacity must be non-zero");
         Self {
-            entries: Vec::new(),
-            max_entries,
-            next_sequence: 0,
+            store: cache::Store::new(max_entries),
+        }
+    }
+
+    #[must_use]
+    pub(crate) fn with_algorithm(
+        max_entries: usize,
+        algorithm: crate::config::DnsCacheAlgorithm,
+    ) -> Self {
+        Self {
+            store: cache::Store::with_algorithm(max_entries, algorithm),
         }
     }
 
     #[must_use]
     pub fn len(&self) -> usize {
-        self.entries.len()
+        self.store.len()
     }
 
     #[must_use]
     pub fn is_empty(&self) -> bool {
-        self.entries.is_empty()
+        self.len() == 0
     }
 
     pub fn clear(&mut self) {
-        self.entries.clear();
+        self.store.clear();
     }
 
     pub fn get(&mut self, name: &str, query_type: QueryType, now: Instant) -> Option<CacheValue> {
@@ -995,27 +1129,42 @@ impl DnsCache {
             .map(|(value, _remaining_ttl)| value)
     }
 
-    /// Returns a cached value together with its remaining wire TTL. Keeping
-    /// the remaining TTL prevents a synthesized cache response from extending
-    /// an upstream record beyond this cache entry's own expiry.
+    /// Hits refresh recency without extending the entry's own expiry.
     pub fn get_with_ttl(
         &mut self,
         name: &str,
         query_type: QueryType,
         now: Instant,
     ) -> Option<(CacheValue, u32)> {
-        self.remove_expired(now);
-        let name = canonicalize_name(name).ok()?;
-        self.entries
-            .iter()
-            .find(|entry| entry.name == name && entry.query_type == query_type)
-            .map(|entry| {
-                let remaining_ttl = entry
-                    .expires_at
-                    .saturating_duration_since(now)
-                    .as_secs()
-                    .min(u64::from(u32::MAX)) as u32;
-                (entry.value.clone(), remaining_ttl)
+        self.lookup_with_ttl(name, query_type, now, false)
+            .into_fresh()
+    }
+
+    pub(crate) fn lookup_with_ttl(
+        &mut self,
+        name: &str,
+        query_type: QueryType,
+        now: Instant,
+        allow_stale: bool,
+    ) -> CacheLookup<(CacheValue, u32)> {
+        let Ok(name) = canonicalize_name(name) else {
+            return CacheLookup::Miss;
+        };
+        let key = cache::Key::Address(name, query_type);
+        self.store
+            .lookup(&key, now, allow_stale)
+            .map(|(value, expires_at)| {
+                let cache::Value::Address(value) = value else {
+                    unreachable!("typed cache key has a typed payload");
+                };
+                (
+                    value.clone(),
+                    if expires_at <= now {
+                        1
+                    } else {
+                        remaining_ttl(expires_at, now)
+                    },
+                )
             })
     }
 
@@ -1041,13 +1190,11 @@ impl DnsCache {
         }) {
             return Err(DnsError::AddressFamilyMismatch);
         }
-        let mut retained = Vec::with_capacity(addresses.len());
-        retained.extend_from_slice(addresses);
         self.insert(
             name,
             query_type,
-            CacheValue::Positive(retained),
-            clamp_ttl(ttl),
+            CacheValue::Positive(addresses.to_vec()),
+            ttl,
             now,
         )
     }
@@ -1079,62 +1226,141 @@ impl DnsCache {
         ttl: u32,
         now: Instant,
     ) -> Result<()> {
-        let name = canonicalize_name(name)?;
-        self.remove_expired(now);
-        let expires_at = expiry(now, ttl);
-        let sequence = self.take_sequence();
+        let stale_eligible = matches!(value, CacheValue::Positive(_)) && ttl != 0;
+        self.store.insert(
+            cache::Key::Address(canonicalize_name(name)?, query_type),
+            cache::Value::Address(value),
+            expiry(now, clamp_ttl(ttl)),
+            now,
+            stale_eligible,
+        )
+    }
 
-        if let Some(entry) = self
-            .entries
-            .iter_mut()
-            .find(|entry| entry.name == name && entry.query_type == query_type)
+    fn refresh_key(query: &ClassifiedDnsQuery) -> cache::Key {
+        if let DnsQueryKind::Address(kind) = query.kind
+            && !query.needs_wire_cache
         {
-            *entry = CacheEntry {
-                name,
-                query_type,
-                value,
-                expires_at,
-                sequence,
-            };
-            return Ok(());
+            cache::Key::Address(query.question.name.clone(), kind)
+        } else {
+            cache::Key::Opaque(query.question.clone(), query.semantics_digest)
         }
+    }
 
-        if self.entries.len() >= self.max_entries {
-            let index = eviction_index(&self.entries, |entry| (entry.expires_at, entry.sequence));
-            self.entries.swap_remove(index);
+    pub(crate) fn reserve_refresh(
+        &mut self,
+        query: &ClassifiedDnsQuery,
+        now: Instant,
+        backoff: Duration,
+    ) -> bool {
+        self.store
+            .reserve_refresh(&Self::refresh_key(query), now, backoff)
+    }
+
+    pub(crate) fn finish_refresh(
+        &mut self,
+        query: &ClassifiedDnsQuery,
+        now: Instant,
+        backoff: Duration,
+    ) {
+        self.store
+            .finish_refresh(&Self::refresh_key(query), now, backoff);
+    }
+
+    /// An opaque hit restores the caller's ID/RD and remaining record TTLs.
+    pub(crate) fn get_opaque(
+        &mut self,
+        query: &ClassifiedDnsQuery,
+        now: Instant,
+    ) -> Option<Vec<u8>> {
+        if !query.is_opaque() {
+            return None;
         }
-        reserve_entry_slot(&mut self.entries, self.max_entries)?;
-        self.entries.push(CacheEntry {
-            name,
-            query_type,
-            value,
-            expires_at,
-            sequence,
-        });
-        debug_assert!(self.entries.len() <= self.max_entries);
-        Ok(())
+        self.get_wire(query, now)
     }
 
-    fn remove_expired(&mut self, now: Instant) {
-        self.entries.retain(|entry| entry.expires_at > now);
+    pub(crate) fn get_wire(&mut self, query: &ClassifiedDnsQuery, now: Instant) -> Option<Vec<u8>> {
+        self.lookup_wire(query, now, false).into_fresh()
     }
 
-    fn take_sequence(&mut self) -> u64 {
-        let sequence = self.next_sequence;
-        self.next_sequence = self.next_sequence.wrapping_add(1);
-        sequence
+    pub(crate) fn lookup_wire(
+        &mut self,
+        query: &ClassifiedDnsQuery,
+        now: Instant,
+        allow_stale: bool,
+    ) -> CacheLookup<Vec<u8>> {
+        let key = cache::Key::Opaque(query.question.clone(), query.semantics_digest);
+        self.store
+            .lookup(&key, now, allow_stale)
+            .map(|(value, expires_at)| {
+                let cache::Value::Opaque {
+                    wire, ttl_offsets, ..
+                } = value
+                else {
+                    unreachable!("wire cache key has a wire payload");
+                };
+                let mut wire = wire.to_vec();
+                wire[..2].copy_from_slice(&query.id.to_be_bytes());
+                let mut flags = u16::from_be_bytes([wire[2], wire[3]]);
+                if query.recursion_desired {
+                    flags |= 0x0100;
+                } else {
+                    flags &= !0x0100;
+                }
+                wire[2..4].copy_from_slice(&flags.to_be_bytes());
+                let ttl = if expires_at <= now {
+                    1
+                } else {
+                    remaining_ttl(expires_at, now)
+                }
+                .to_be_bytes();
+                for offset in ttl_offsets {
+                    let offset = usize::from(*offset);
+                    wire[offset..offset + 4].copy_from_slice(&ttl);
+                }
+                wire
+            })
+    }
+
+    /// Opaque payloads share the role's result count while retaining their own
+    /// 64-response, 256 KiB, 4096-byte and 64-record safety boundaries.
+    pub(crate) fn insert_opaque(
+        &mut self,
+        response: &ValidatedOpaqueResponse,
+        now: Instant,
+    ) -> bool {
+        let Some(lifetime_secs) = response.cache_policy.lifetime_secs() else {
+            return false;
+        };
+        let Some(accounted_bytes) = opaque_entry_accounted_bytes(response) else {
+            return false;
+        };
+        if response.wire.len() > MAX_OPAQUE_CACHE_ENTRY_BYTES
+            || accounted_bytes > MAX_OPAQUE_CACHE_BYTES
+            || response.ttl_offsets.len() > MAX_OPAQUE_RECORDS
+        {
+            return false;
+        }
+        self.store
+            .insert(
+                cache::Key::Opaque(response.question.clone(), response.semantics_digest),
+                cache::Value::Opaque {
+                    wire: response.wire.clone(),
+                    ttl_offsets: response.ttl_offsets.clone(),
+                    accounted_bytes,
+                },
+                expiry(now, lifetime_secs),
+                now,
+                response.stale_eligible,
+            )
+            .is_ok()
     }
 }
 
-#[derive(Debug)]
-struct OpaqueCacheEntry {
-    question: WireQuestion,
-    semantics_digest: [u8; 32],
-    wire: Box<[u8]>,
-    ttl_offsets: Box<[u16]>,
-    accounted_bytes: usize,
-    expires_at: Instant,
-    sequence: u64,
+fn remaining_ttl(expires_at: Instant, now: Instant) -> u32 {
+    expires_at
+        .saturating_duration_since(now)
+        .as_secs()
+        .min(u64::from(u32::MAX)) as u32
 }
 
 fn opaque_entry_accounted_bytes(response: &ValidatedOpaqueResponse) -> Option<usize> {
@@ -1149,21 +1375,15 @@ fn opaque_entry_accounted_bytes(response: &ValidatedOpaqueResponse) -> Option<us
                 .ttl_offsets
                 .len()
                 .checked_mul(std::mem::size_of::<u16>())?,
-        )
+        )?
+        .checked_add(cache::opaque_metadata_bytes())
 }
 
-/// Hard-bounded cache for non-A/AAAA response wire payloads.
-///
-/// The cache stores at most [`MAX_OPAQUE_CACHE_ENTRIES`] responses and at most
-/// [`MAX_OPAQUE_CACHE_BYTES`] bytes of response wire, normalized question key,
-/// full-query semantics digest and TTL-offset metadata in total. A hit clones
-/// at most one 4096-byte response, rewrites its transaction ID and reduces
-/// every cacheable RR TTL to the entry's remaining lifetime.
+/// Standalone opaque-only view of the same bounded result store.
+/// Runtime roles use DnsCache directly so all question types share capacity.
 #[derive(Debug)]
 pub struct OpaqueDnsCache {
-    entries: Vec<OpaqueCacheEntry>,
-    retained_bytes: usize,
-    next_sequence: u64,
+    cache: DnsCache,
 }
 
 impl Default for OpaqueDnsCache {
@@ -1176,142 +1396,35 @@ impl OpaqueDnsCache {
     #[must_use]
     pub fn new() -> Self {
         Self {
-            entries: Vec::new(),
-            retained_bytes: 0,
-            next_sequence: 0,
+            cache: DnsCache::with_max_entries(MAX_OPAQUE_CACHE_ENTRIES),
         }
     }
 
     #[must_use]
     pub fn len(&self) -> usize {
-        self.entries.len()
+        self.cache.store.opaque_len()
     }
 
     #[must_use]
     pub fn is_empty(&self) -> bool {
-        self.entries.is_empty()
+        self.len() == 0
     }
 
     #[must_use]
     pub const fn retained_bytes(&self) -> usize {
-        self.retained_bytes
+        self.cache.store.opaque_bytes()
     }
 
     pub fn clear(&mut self) {
-        self.entries.clear();
-        self.retained_bytes = 0;
+        self.cache.clear();
     }
 
-    /// Returns a rewritten wire response for an opaque query, or `None` for an
-    /// address query, cache miss or expired entry.
     pub fn get(&mut self, query: &ClassifiedDnsQuery, now: Instant) -> Option<Vec<u8>> {
-        if !query.is_opaque() {
-            return None;
-        }
-        self.remove_expired(now);
-        let entry = self.entries.iter().find(|entry| {
-            entry.question == query.question && entry.semantics_digest == query.semantics_digest
-        })?;
-        let remaining_ttl = entry
-            .expires_at
-            .saturating_duration_since(now)
-            .as_secs()
-            .min(u64::from(u32::MAX)) as u32;
-        let mut wire = entry.wire.to_vec();
-        wire[..2].copy_from_slice(&query.id.to_be_bytes());
-        let mut flags = u16::from_be_bytes([wire[2], wire[3]]);
-        if query.recursion_desired {
-            flags |= 0x0100;
-        } else {
-            flags &= !0x0100;
-        }
-        wire[2..4].copy_from_slice(&flags.to_be_bytes());
-        let ttl = remaining_ttl.to_be_bytes();
-        for offset in &entry.ttl_offsets {
-            let offset = usize::from(*offset);
-            wire[offset..offset + 4].copy_from_slice(&ttl);
-        }
-        Some(wire)
+        self.cache.get_opaque(query, now)
     }
 
-    /// Inserts a validated response when its cache policy permits it. Returns
-    /// `false` for retryable/error responses and positive responses with a zero
-    /// or absent cacheable TTL.
     pub fn insert(&mut self, response: &ValidatedOpaqueResponse, now: Instant) -> bool {
-        let Some(lifetime_secs) = response.cache_policy.lifetime_secs() else {
-            return false;
-        };
-        let wire_bytes = response.wire.len();
-        let Some(entry_bytes) = opaque_entry_accounted_bytes(response) else {
-            return false;
-        };
-        if wire_bytes > MAX_OPAQUE_CACHE_ENTRY_BYTES
-            || entry_bytes > MAX_OPAQUE_CACHE_BYTES
-            || response.ttl_offsets.len() > MAX_OPAQUE_RECORDS
-        {
-            return false;
-        }
-
-        self.remove_expired(now);
-        if let Some(index) = self.entries.iter().position(|entry| {
-            entry.question == response.question
-                && entry.semantics_digest == response.semantics_digest
-        }) {
-            self.remove_index(index);
-        }
-
-        while !self.entries.is_empty()
-            && (self.entries.len() >= MAX_OPAQUE_CACHE_ENTRIES
-                || self.retained_bytes.saturating_add(entry_bytes) > MAX_OPAQUE_CACHE_BYTES)
-        {
-            let index = eviction_index(&self.entries, |entry| (entry.expires_at, entry.sequence));
-            self.remove_index(index);
-        }
-        if self.entries.len() >= MAX_OPAQUE_CACHE_ENTRIES
-            || self.retained_bytes.saturating_add(entry_bytes) > MAX_OPAQUE_CACHE_BYTES
-        {
-            return false;
-        }
-
-        let sequence = self.take_sequence();
-        if reserve_entry_slot(&mut self.entries, MAX_OPAQUE_CACHE_ENTRIES).is_err() {
-            return false;
-        }
-        self.entries.push(OpaqueCacheEntry {
-            question: response.question.clone(),
-            semantics_digest: response.semantics_digest,
-            wire: response.wire.clone(),
-            ttl_offsets: response.ttl_offsets.clone(),
-            accounted_bytes: entry_bytes,
-            expires_at: expiry(now, lifetime_secs),
-            sequence,
-        });
-        self.retained_bytes += entry_bytes;
-        debug_assert!(self.entries.len() <= MAX_OPAQUE_CACHE_ENTRIES);
-        debug_assert!(self.retained_bytes <= MAX_OPAQUE_CACHE_BYTES);
-        true
-    }
-
-    fn remove_expired(&mut self, now: Instant) {
-        let mut index = 0;
-        while index < self.entries.len() {
-            if self.entries[index].expires_at <= now {
-                self.remove_index(index);
-            } else {
-                index += 1;
-            }
-        }
-    }
-
-    fn remove_index(&mut self, index: usize) {
-        let removed = self.entries.swap_remove(index);
-        self.retained_bytes -= removed.accounted_bytes;
-    }
-
-    fn take_sequence(&mut self) -> u64 {
-        let sequence = self.next_sequence;
-        self.next_sequence = self.next_sequence.wrapping_add(1);
-        sequence
+        self.cache.insert_opaque(response, now)
     }
 }
 
@@ -1731,7 +1844,7 @@ mod tests {
     }
 
     #[test]
-    fn cache_is_fixed_capacity_and_evicts_the_oldest_expiry() {
+    fn cache_is_fixed_capacity_and_evicts_the_least_recent_entry() {
         let now = Instant::now();
         let address = IpAddr::V4(Ipv4Addr::LOCALHOST);
         let mut cache = DnsCache::new();
@@ -1760,7 +1873,7 @@ mod tests {
         let now = Instant::now();
         let address = IpAddr::V4(Ipv4Addr::LOCALHOST);
         let mut cache = DnsCache::with_max_entries(2);
-        assert_eq!(cache.entries.capacity(), 0);
+        assert_eq!(cache.store.allocated_slots(), 0);
 
         for name in ["first.example", "second.example", "third.example"] {
             cache
@@ -1773,6 +1886,88 @@ mod tests {
         assert!(cache.get("third.example", QueryType::A, now).is_some());
     }
 
+    #[test]
+    fn cache_lru_hits_and_replacements_preserve_ttl_and_promote_entries() {
+        let now = Instant::now();
+        let address = IpAddr::V4(Ipv4Addr::LOCALHOST);
+        let mut cache = DnsCache::with_max_entries(2);
+        cache
+            .insert_positive("short.example", QueryType::A, &[address], 30, now)
+            .unwrap();
+        cache
+            .insert_negative("negative.example", QueryType::Aaaa, 3, now)
+            .unwrap();
+        assert_eq!(
+            cache.get_with_ttl(
+                "SHORT.example.",
+                QueryType::A,
+                now + Duration::from_secs(10)
+            ),
+            Some((CacheValue::Positive(vec![address]), 20))
+        );
+        cache
+            .insert_positive("long.example", QueryType::A, &[address], 3600, now)
+            .unwrap();
+        assert_eq!(cache.get("negative.example", QueryType::Aaaa, now), None);
+        // Updating the short entry is also a use, independent of its expiry.
+        cache
+            .insert_negative("short.example", QueryType::A, 0, now)
+            .unwrap();
+        cache
+            .insert_negative("other.example", QueryType::A, 3, now)
+            .unwrap();
+        assert_eq!(cache.get("long.example", QueryType::A, now), None);
+        assert_eq!(
+            cache.get("short.example", QueryType::A, now),
+            Some(CacheValue::Negative { rcode: 0 })
+        );
+        assert_eq!(
+            cache.get("short.example", QueryType::A, now + Duration::from_secs(30)),
+            None
+        );
+        // Freed slots are reused, and clear releases all retained allocation.
+        for index in 0..100 {
+            cache
+                .insert_negative(&format!("cycle{index}.example"), QueryType::A, 3, now)
+                .unwrap();
+        }
+        assert_eq!(cache.len(), 2);
+        assert_eq!(cache.store.allocated_slots(), 2);
+        cache.clear();
+        assert!(cache.is_empty());
+        assert_eq!(cache.store.allocated_slots(), 0);
+    }
+
+    #[test]
+    fn cache_shares_typed_and_opaque_capacity_and_reclaims_opaque_bytes() {
+        let now = Instant::now();
+        let mut cache = DnsCache::with_max_entries(2);
+        let query_wire = wire_query(1, "opaque.example", 16);
+        let query = classify_query(&query_wire).unwrap();
+        let mut response = opaque_response(&query_wire, RCODE_NOERROR, false);
+        set_counts(&mut response, 1, 0, 0);
+        append_wire_record(&mut response, &[0xc0, 0x0c], 16, CLASS_IN, 60, &[]);
+        let response = validate_opaque_response(&query, &response).unwrap();
+        cache
+            .insert_negative("typed.example", QueryType::A, 3, now)
+            .unwrap();
+        assert!(cache.insert_opaque(&response, now));
+        assert!(cache.store.opaque_bytes() > 0);
+        assert!(cache.get("typed.example", QueryType::A, now).is_some());
+        cache
+            .insert_negative("next.example", QueryType::A, 3, now)
+            .unwrap();
+        assert_eq!(cache.get_opaque(&query, now), None);
+        assert_eq!(cache.len(), 2);
+        assert_eq!(cache.store.opaque_bytes(), 0);
+        assert!(cache.insert_opaque(&response, now));
+        assert_eq!(
+            cache.get_opaque(&query, now + Duration::from_secs(60)),
+            None
+        );
+        assert_eq!(cache.store.opaque_bytes(), 0);
+    }
+
     #[test]
     fn cache_rejects_unbounded_or_mismatched_values() {
         let now = Instant::now();
@@ -2075,6 +2270,133 @@ mod tests {
         );
     }
 
+    #[test]
+    fn typed_stale_lookup_keeps_public_getters_fresh_only_and_excludes_negative_or_zero_ttl() {
+        let now = Instant::now();
+        let expired = now + Duration::from_secs(30);
+        let address = "192.0.2.1".parse().unwrap();
+        let mut cache = DnsCache::new();
+        cache
+            .insert_positive("positive.test", QueryType::A, &[address], 30, now)
+            .unwrap();
+        assert_eq!(
+            cache.lookup_with_ttl("positive.test", QueryType::A, expired, true),
+            CacheLookup::Stale((CacheValue::Positive(vec![address]), 1))
+        );
+        assert_eq!(cache.len(), 1);
+        // This stage does not enable stale answers in an existing runtime.
+        assert_eq!(cache.get("positive.test", QueryType::A, expired), None);
+        assert!(cache.is_empty());
+        cache
+            .insert_negative("negative.test", QueryType::A, RCODE_NXDOMAIN, now)
+            .unwrap();
+        cache
+            .insert_positive("zero.test", QueryType::A, &[address], 0, now)
+            .unwrap();
+        for name in ["negative.test", "zero.test"] {
+            assert_eq!(
+                cache.lookup_with_ttl(name, QueryType::A, expired, true),
+                CacheLookup::Miss
+            );
+        }
+        assert!(cache.is_empty());
+    }
+
+    #[test]
+    fn stale_wire_lookup_restores_id_and_limits_record_ttls_without_rewriting_opt() {
+        let now = Instant::now();
+        let query_wire = wire_query(1, "txt.example", 16);
+        let query = classify_query(&query_wire).unwrap();
+        let mut response = opaque_response(&query_wire, RCODE_NOERROR, false);
+        set_counts(&mut response, 1, 1, 1);
+        let answer_ttl =
+            append_wire_record(&mut response, &[0xc0, 0x0c], 16, CLASS_IN, 30, b"\x05value");
+        let authority_ttl = append_wire_record(&mut response, &[0xc0, 0x0c], 2, CLASS_IN, 60, &[0]);
+        let opt_ttl = append_wire_record(&mut response, &[0], TYPE_OPT, 1232, 0, &[]);
+        let validated = validate_opaque_response(&query, &response).unwrap();
+        let mut cache = DnsCache::new();
+        assert!(cache.insert_opaque(&validated, now));
+        let hit_query = classify_query(&wire_query(2, "txt.example", 16)).unwrap();
+        let CacheLookup::Stale(hit) =
+            cache.lookup_wire(&hit_query, now + Duration::from_secs(30), true)
+        else {
+            panic!("validated positive should retain a bounded stale answer");
+        };
+        assert_eq!(read_u16(&hit, 0).unwrap(), 2);
+        assert_eq!(read_u32(&hit, answer_ttl).unwrap(), 1);
+        assert_eq!(read_u32(&hit, authority_ttl).unwrap(), 1);
+        assert_eq!(read_u32(&hit, opt_ttl).unwrap(), 0);
+        assert_eq!(cache.len(), 1);
+        assert!(cache.store.opaque_bytes() <= MAX_OPAQUE_CACHE_BYTES);
+        assert_eq!(
+            cache.get_opaque(&hit_query, now + Duration::from_secs(30)),
+            None
+        );
+        assert_eq!(cache.store.opaque_bytes(), 0);
+    }
+
+    #[test]
+    fn stale_wire_lookup_excludes_dnssec_context_and_negative_answers() {
+        let now = Instant::now();
+        for (name, qtype, query_flags, query_do, response_flags, record_type, response_do, rcode) in [
+            ("plain", 16, 0x0100, false, 0, 16, false, RCODE_NOERROR),
+            ("query-do", 16, 0x0100, true, 0, 16, false, RCODE_NOERROR),
+            ("query-cd", 16, 0x0110, false, 0, 16, false, RCODE_NOERROR),
+            (
+                "answer-ad",
+                16,
+                0x0100,
+                false,
+                0x0020,
+                16,
+                false,
+                RCODE_NOERROR,
+            ),
+            ("answer-do", 16, 0x0100, false, 0, 16, true, RCODE_NOERROR),
+            ("signature", 16, 0x0100, false, 0, 46, false, RCODE_NOERROR),
+            ("dnskey", 48, 0x0100, false, 0, 48, false, RCODE_NOERROR),
+            ("negative", 16, 0x0100, false, 0, 16, false, RCODE_NXDOMAIN),
+        ] {
+            let mut wire = wire_query(1, &format!("{name}.test"), qtype);
+            wire[2..4].copy_from_slice(&u16::to_be_bytes(query_flags));
+            if query_do {
+                wire[10..12].copy_from_slice(&1_u16.to_be_bytes());
+                append_wire_record(&mut wire, &[0], TYPE_OPT, 1232, 0x8000, &[]);
+            }
+            let query = classify_query(&wire).unwrap();
+            let mut response = opaque_response(&wire, rcode, false);
+            let flags = read_u16(&response, 2).unwrap() | response_flags;
+            response[2..4].copy_from_slice(&flags.to_be_bytes());
+            set_counts(&mut response, 1, 0, u16::from(response_do));
+            append_wire_record(
+                &mut response,
+                &[0xc0, 0x0c],
+                record_type,
+                CLASS_IN,
+                30,
+                b"\x05value",
+            );
+            if response_do {
+                append_wire_record(&mut response, &[0], TYPE_OPT, 1232, 0x8000, &[]);
+            }
+            let validated = validate_opaque_response(&query, &response).unwrap();
+            let mut cache = DnsCache::new();
+            assert!(cache.insert_opaque(&validated, now));
+            assert!(
+                matches!(cache.lookup_wire(&query, now, true), CacheLookup::Fresh(_)),
+                "{name}"
+            );
+            assert_eq!(
+                matches!(
+                    cache.lookup_wire(&query, now + Duration::from_secs(30), true),
+                    CacheLookup::Stale(_)
+                ),
+                name == "plain",
+                "{name}"
+            );
+        }
+    }
+
     #[test]
     fn opaque_cache_rewrites_id_and_all_non_opt_ttls() {
         let now = Instant::now();
@@ -2213,7 +2535,7 @@ mod tests {
     }
 
     #[test]
-    fn opaque_cache_is_bounded_and_evicts_earliest_expiry() {
+    fn opaque_cache_is_bounded_and_evicts_the_least_recent_entry() {
         let now = Instant::now();
         let mut cache = OpaqueDnsCache::new();
         for index in 0..MAX_OPAQUE_CACHE_ENTRIES {
@@ -2232,6 +2554,8 @@ mod tests {
             let response = validate_opaque_response(&query, &response).unwrap();
             assert!(cache.insert(&response, now));
         }
+        let first_query = classify_query(&wire_query(0, "host0.example", 16)).unwrap();
+        assert!(cache.get(&first_query, now).is_some());
         let new_wire = wire_query(999, "new.example", 16);
         let new_query = classify_query(&new_wire).unwrap();
         let mut new_response = opaque_response(&new_wire, RCODE_NOERROR, false);
@@ -2242,8 +2566,9 @@ mod tests {
 
         assert_eq!(cache.len(), MAX_OPAQUE_CACHE_ENTRIES);
         assert!(cache.retained_bytes() <= MAX_OPAQUE_CACHE_BYTES);
-        let first_query = classify_query(&wire_query(0, "host0.example", 16)).unwrap();
-        assert_eq!(cache.get(&first_query, now), None);
+        assert!(cache.get(&first_query, now).is_some());
+        let second_query = classify_query(&wire_query(1, "host1.example", 16)).unwrap();
+        assert_eq!(cache.get(&second_query, now), None);
         assert!(cache.get(&new_query, now).is_some());
     }
 
diff --git a/src/dns/options.rs b/src/dns/options.rs
new file mode 100644
index 0000000..8857123
--- /dev/null
+++ b/src/dns/options.rs
@@ -0,0 +1,386 @@
+//! Per-upstream DNS query wrappers, independent of the physical source.
+
+use std::{borrow::Cow, net::IpAddr};
+
+use domain::{
+    base::{Message, MessageBuilder, ParsedName, StaticCompressor},
+    rdata::AllRecordData,
+};
+
+use crate::config::DnsNameserverOptions;
+
+use super::{
+    DnsError, MAX_MESSAGE_SIZE, MAX_RESPONSE_RECORDS, Result, classify_query, decode_name,
+    parse_wire_question_header, read_u16, scan_record,
+};
+
+pub(super) fn question_disabled(options: &DnsNameserverOptions, qtype: u16) -> bool {
+    options.disabled_types.binary_search(&qtype).is_ok()
+}
+
+/// Preserves an existing ECS unless override was explicitly requested. Only
+/// the first ECS is replaced, retaining its scope and all other EDNS options.
+pub(super) fn with_ecs<'a>(
+    query: &'a [u8],
+    options: &DnsNameserverOptions,
+) -> Result<Cow<'a, [u8]>> {
+    let Some(ecs) = options.ecs else {
+        return Ok(Cow::Borrowed(query));
+    };
+    classify_query(query)?;
+    let header = parse_wire_question_header(query)?;
+    let mut data_start = query.len();
+    let mut data_end = query.len();
+    let mut length_offset = None;
+    if header.additional_count != 0 {
+        let mut cursor = header.records_offset;
+        let record = scan_record(query, &mut cursor)?;
+        data_start = usize::from(record.data_start);
+        data_end = usize::from(record.data_end);
+        length_offset = Some(data_start - 2);
+    }
+    let mut replace = None;
+    let mut scope = 0;
+    let mut cursor = data_start;
+    while cursor < data_end {
+        let code = read_u16(query, cursor)?;
+        let end = cursor + 4 + usize::from(read_u16(query, cursor + 2)?);
+        if code == 8 {
+            if !options.ecs_override {
+                return Ok(Cow::Borrowed(query));
+            }
+            if end < cursor + 8 {
+                return Err(DnsError::InvalidRecord);
+            }
+            scope = query[cursor + 7];
+            replace = Some(cursor..end);
+            break;
+        }
+        cursor = end;
+    }
+    let (family, bytes): (u16, Vec<u8>) = match ecs.address {
+        IpAddr::V4(address) => (1, address.octets().to_vec()),
+        IpAddr::V6(address) => (2, address.octets().to_vec()),
+    };
+    if usize::from(ecs.prefix_len) > bytes.len() * 8 {
+        return Err(DnsError::InvalidRecord);
+    }
+    let address_len = usize::from(ecs.prefix_len).div_ceil(8);
+    let mut option = Vec::with_capacity(8 + address_len);
+    option.extend_from_slice(&8_u16.to_be_bytes());
+    option.extend_from_slice(&(4 + address_len as u16).to_be_bytes());
+    option.extend_from_slice(&family.to_be_bytes());
+    option.extend_from_slice(&[ecs.prefix_len, scope]);
+    option.extend_from_slice(&bytes[..address_len]);
+    if ecs.prefix_len % 8 != 0 {
+        *option
+            .last_mut()
+            .expect("a partial prefix has an address byte") &= 0xff << (8 - ecs.prefix_len % 8);
+    }
+    let replaced_len = replace.as_ref().map_or(0, |range| range.len());
+    let extra_record = usize::from(length_offset.is_none()) * 11;
+    let output_len = query.len() - replaced_len + option.len() + extra_record;
+    if output_len > MAX_MESSAGE_SIZE {
+        return Err(DnsError::MessageTooLarge);
+    }
+    let mut output = Vec::with_capacity(output_len);
+    if let Some(range) = replace {
+        output.extend_from_slice(&query[..range.start]);
+        output.extend_from_slice(&option);
+        output.extend_from_slice(&query[range.end..]);
+    } else {
+        output.extend_from_slice(query);
+        if length_offset.is_none() {
+            // Mihomo's new OPT has a zero advertised UDP size and no flags.
+            output.extend_from_slice(&[0, 0, 41, 0, 0, 0, 0, 0, 0, 0, 0]);
+            output[10..12].copy_from_slice(&1_u16.to_be_bytes());
+            length_offset = Some(output.len() - 2);
+        }
+        output.extend_from_slice(&option);
+    }
+    let data_len = data_end - data_start - replaced_len + option.len();
+    let offset = length_offset.expect("ECS always belongs to an OPT record");
+    output[offset..offset + 2].copy_from_slice(&(data_len as u16).to_be_bytes());
+    Ok(Cow::Owned(output))
+}
+
+/// Re-composes every surviving RR so names compressed against a removed RR
+/// cannot retain stale offsets. The official codec understands all RFC 1035
+/// compressible RDATA; RFC 3597 unknown RDATA remains byte-for-byte opaque.
+pub(super) fn filter_response(wire: &[u8], disabled: &[u16]) -> Result<Vec<u8>> {
+    preflight_names(wire)?;
+    let message = Message::from_octets(wire).map_err(|_| DnsError::InvalidRecord)?;
+    let mut builder = MessageBuilder::from_target(StaticCompressor::new(Vec::new()))
+        .map_err(|_| DnsError::MessageTooLarge)?;
+    builder.set_push_limit(MAX_MESSAGE_SIZE);
+    *builder.header_mut() = message.header();
+    let mut builder = builder.question();
+    for question in message.question() {
+        builder
+            .push(question.map_err(|_| DnsError::InvalidRecord)?)
+            .map_err(|_| DnsError::MessageTooLarge)?;
+    }
+    let mut builder = builder.answer();
+    for record in message
+        .answer()
+        .map_err(|_| DnsError::InvalidRecord)?
+        .into_records::<AllRecordData<_, ParsedName<_>>>()
+    {
+        let record = record.map_err(|_| DnsError::InvalidRecord)?;
+        if disabled.binary_search(&record.rtype().to_int()).is_err() {
+            builder
+                .push(record)
+                .map_err(|_| DnsError::MessageTooLarge)?;
+        }
+    }
+    let mut builder = builder.authority();
+    for record in message
+        .authority()
+        .map_err(|_| DnsError::InvalidRecord)?
+        .into_records::<AllRecordData<_, ParsedName<_>>>()
+    {
+        let record = record.map_err(|_| DnsError::InvalidRecord)?;
+        if disabled.binary_search(&record.rtype().to_int()).is_err() {
+            builder
+                .push(record)
+                .map_err(|_| DnsError::MessageTooLarge)?;
+        }
+    }
+    let mut builder = builder.additional();
+    for record in message
+        .additional()
+        .map_err(|_| DnsError::InvalidRecord)?
+        .into_records::<AllRecordData<_, ParsedName<_>>>()
+    {
+        let record = record.map_err(|_| DnsError::InvalidRecord)?;
+        if disabled.binary_search(&record.rtype().to_int()).is_err() {
+            builder
+                .push(record)
+                .map_err(|_| DnsError::MessageTooLarge)?;
+        }
+    }
+    Ok(builder.finish().into_target())
+}
+
+/// Retains Core's smaller name/pointer budget before the borrowed codec
+/// parses name-bearing RDATA. Binary RDATA is never searched for pointers.
+fn preflight_names(wire: &[u8]) -> Result<()> {
+    let header = parse_wire_question_header(wire)?;
+    let count = usize::from(header.answer_count)
+        + usize::from(header.authority_count)
+        + usize::from(header.additional_count);
+    if count > MAX_RESPONSE_RECORDS {
+        return Err(DnsError::TooManyRecords);
+    }
+    let mut cursor = header.records_offset;
+    for _ in 0..count {
+        let record = scan_record(wire, &mut cursor)?;
+        let mut name_cursor = usize::from(record.data_start);
+        let end = usize::from(record.data_end);
+        let (prefix, names, exact) = match record.record_type {
+            2..=5 | 7..=9 | 12 | 39 => (0, 1, true),
+            6 => (0, 2, false),
+            14 | 17 => (0, 2, true),
+            15 => (2, 1, true),
+            33 => (6, 1, true),
+            46 => (18, 1, false),
+            47 | 250 => (0, 1, false),
+            64 | 65 => (2, 1, false),
+            45 if wire.get(name_cursor + 1) == Some(&3) => (3, 1, false),
+            35 => {
+                name_cursor += 4;
+                for _ in 0..3 {
+                    let length =
+                        usize::from(*wire.get(name_cursor).ok_or(DnsError::InvalidRecord)?);
+                    name_cursor += length + 1;
+                    if name_cursor > end {
+                        return Err(DnsError::InvalidRecord);
+                    }
+                }
+                (0, 1, true)
+            }
+            _ => continue,
+        };
+        name_cursor += prefix;
+        for _ in 0..names {
+            if name_cursor >= end {
+                return Err(DnsError::InvalidRecord);
+            }
+            let (_, consumed) = decode_name(wire, name_cursor)?;
+            name_cursor += consumed;
+            if name_cursor > end {
+                return Err(DnsError::InvalidRecord);
+            }
+        }
+        if exact && name_cursor != end || record.record_type == 6 && name_cursor + 20 != end {
+            return Err(DnsError::InvalidRecord);
+        }
+    }
+    if cursor != wire.len() {
+        return Err(DnsError::TrailingData);
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        config::DnsEcs,
+        dns::{QueryType, build_query, validate_opaque_response},
+    };
+
+    fn options(address: &str, prefix_len: u8) -> DnsNameserverOptions {
+        DnsNameserverOptions {
+            ecs: Some(DnsEcs {
+                address: address.parse().unwrap(),
+                prefix_len,
+            }),
+            ..Default::default()
+        }
+    }
+
+    #[test]
+    fn upstream_ecs_masks_prefix_and_preserves_other_options_and_scope() {
+        let query = build_query(7, "ecs.example", QueryType::A).unwrap();
+        let mut ipv4 = with_ecs(&query, &options("192.0.2.255", 25))
+            .unwrap()
+            .into_owned();
+        assert_eq!(
+            &ipv4[ipv4.len() - 12..],
+            &[0, 8, 0, 8, 0, 1, 25, 0, 192, 0, 2, 128]
+        );
+        let header = parse_wire_question_header(&ipv4).unwrap();
+        let mut cursor = header.records_offset;
+        let record = scan_record(&ipv4, &mut cursor).unwrap();
+        assert_eq!(record.record_class, 0);
+        assert_eq!(record.ttl, 0);
+        let start = usize::from(record.data_start);
+        ipv4[start + 7] = 17;
+        // Append a non-ECS EDNS option, keeping its exact bytes.
+        ipv4.extend_from_slice(&[0, 12, 0, 2, 0xc0, 0xff]);
+        ipv4[start - 2..start].copy_from_slice(&18_u16.to_be_bytes());
+        let unchanged = with_ecs(&ipv4, &options("2001:db8::ffff", 57)).unwrap();
+        assert!(matches!(unchanged, Cow::Borrowed(_)));
+        let mut replacement = options("2001:db8::ffff", 57);
+        replacement.ecs_override = true;
+        let output = with_ecs(&ipv4, &replacement).unwrap();
+        classify_query(&output).unwrap();
+        assert_eq!(&output[start..start + 8], &[0, 8, 0, 12, 0, 2, 57, 17]);
+        assert_eq!(
+            &output[start + 8..start + 16],
+            &[0x20, 1, 0x0d, 0xb8, 0, 0, 0, 0]
+        );
+        assert_eq!(&output[output.len() - 6..], &[0, 12, 0, 2, 0xc0, 0xff]);
+    }
+
+    fn rr(wire: &mut Vec<u8>, owner: &[u8], kind: u16, data: &[u8]) {
+        wire.extend_from_slice(owner);
+        wire.extend_from_slice(&kind.to_be_bytes());
+        wire.extend_from_slice(&1_u16.to_be_bytes());
+        wire.extend_from_slice(&60_u32.to_be_bytes());
+        wire.extend_from_slice(&(data.len() as u16).to_be_bytes());
+        wire.extend_from_slice(data);
+    }
+
+    #[test]
+    fn upstream_type_filter_reencodes_removed_compression_targets_in_all_sections() {
+        let mut query = build_query(23, "mail.example", QueryType::A).unwrap();
+        let offset = query.len() - 4;
+        query[offset..offset + 2].copy_from_slice(&15_u16.to_be_bytes());
+        let classified = classify_query(&query).unwrap();
+        let mut wire = query;
+        wire[2] |= 0x80;
+        wire[6..8].copy_from_slice(&2_u16.to_be_bytes());
+        wire[8..10].copy_from_slice(&2_u16.to_be_bytes());
+        wire[10..12].copy_from_slice(&2_u16.to_be_bytes());
+        let target = wire.len() as u16 | 0xc000;
+        rr(&mut wire, b"\x05alias\x07example\0", 16, b"\x03txt");
+        let mut mx = vec![0, 10];
+        mx.extend_from_slice(&target.to_be_bytes());
+        rr(&mut wire, &[0xc0, 12], 15, &mx);
+        let mut soa = Vec::new();
+        soa.extend_from_slice(&target.to_be_bytes());
+        soa.extend_from_slice(&target.to_be_bytes());
+        soa.extend_from_slice(&[0; 20]);
+        rr(&mut wire, &[0xc0, 12], 6, &soa);
+        rr(&mut wire, &[0xc0, 12], 16, b"\x03txt");
+        rr(&mut wire, &[0xc0, 12], 65280, &[0xc0, 0xff, 0, 42]);
+        rr(&mut wire, &[0xc0, 12], 16, b"\x03txt");
+        let filtered = filter_response(&wire, &[16]).unwrap();
+        let header = parse_wire_question_header(&filtered).unwrap();
+        assert_eq!(
+            (
+                header.answer_count,
+                header.authority_count,
+                header.additional_count
+            ),
+            (1, 1, 1)
+        );
+        let mut cursor = header.records_offset;
+        let mx = scan_record(&filtered, &mut cursor).unwrap();
+        assert_eq!(
+            decode_name(&filtered, usize::from(mx.data_start) + 2)
+                .unwrap()
+                .0,
+            "alias.example"
+        );
+        let soa = scan_record(&filtered, &mut cursor).unwrap();
+        assert_eq!(
+            decode_name(&filtered, usize::from(soa.data_start))
+                .unwrap()
+                .0,
+            "alias.example"
+        );
+        let unknown = scan_record(&filtered, &mut cursor).unwrap();
+        assert_eq!(
+            &filtered[usize::from(unknown.data_start)..usize::from(unknown.data_end)],
+            &[0xc0, 0xff, 0, 42]
+        );
+        assert_eq!(
+            validate_opaque_response(&classified, &filtered)
+                .unwrap()
+                .ttl_offsets
+                .len(),
+            3
+        );
+    }
+
+    #[test]
+    fn upstream_type_filter_retains_core_pointer_and_output_budgets() {
+        let query = build_query(3, "budget.example", QueryType::A).unwrap();
+        let mut wire = query;
+        wire[2] |= 0x80;
+        wire[6..8].copy_from_slice(&1_u16.to_be_bytes());
+        let mut chain = 12_u16;
+        // Null binary RDATA supplies a legal place for a deliberately excessive
+        // chain used by the later CNAME, without treating all binary bytes as names.
+        let mut data = vec![];
+        let data_start = wire.len() + 12;
+        for index in 0..17 {
+            data.extend_from_slice(&(chain | 0xc000).to_be_bytes());
+            chain = (data_start + index * 2) as u16;
+        }
+        rr(&mut wire, &[0xc0, 12], 10, &data);
+        wire[6..8].copy_from_slice(&2_u16.to_be_bytes());
+        rr(&mut wire, &[0xc0, 12], 5, &(chain | 0xc000).to_be_bytes());
+        assert_eq!(
+            filter_response(&wire, &[16]),
+            Err(DnsError::TooManyCompressionJumps)
+        );
+        let name = ["a".repeat(63), "b".repeat(63), "c".repeat(63)].join(".");
+        let mut wire = build_query(4, &name, QueryType::A).unwrap();
+        wire[2] |= 0x80;
+        wire[6..8].copy_from_slice(&64_u16.to_be_bytes());
+        for _ in 0..64 {
+            // A legacy compressed DNAME is expanded by the codec as required
+            // for non-RFC1035 RDATA; expansion must still obey our output cap.
+            rr(&mut wire, &[0xc0, 12], 39, &[0xc0, 12]);
+        }
+        assert!(wire.len() < MAX_MESSAGE_SIZE);
+        assert_eq!(
+            filter_response(&wire, &[16]),
+            Err(DnsError::MessageTooLarge)
+        );
+    }
+}
diff --git a/src/dns/policy.rs b/src/dns/policy.rs
new file mode 100644
index 0000000..34c54e5
--- /dev/null
+++ b/src/dns/policy.rs
@@ -0,0 +1,146 @@
+use std::collections::HashMap;
+
+use crate::{
+    config::{DnsNameserverPolicy, DnsPolicySelector},
+    routing::GeoMatcher,
+};
+
+/// Adjacent domain entries form one specificity-ordered lookup. GeoSite
+/// entries separate those lookups and retain their configured ordering.
+#[derive(Debug, Default)]
+pub(super) struct NameserverPolicies(Vec<PolicyStep>);
+
+#[derive(Debug)]
+enum PolicyStep {
+    Domains(DomainIndex),
+    GeoSite(usize),
+    RuleSet(usize),
+}
+
+impl NameserverPolicies {
+    pub(super) fn new(policies: &[DnsNameserverPolicy]) -> Self {
+        let mut steps = Vec::new();
+        for (index, policy) in policies.iter().enumerate() {
+            match &policy.selector {
+                DnsPolicySelector::RuleSets { .. } => steps.push(PolicyStep::RuleSet(index)),
+                DnsPolicySelector::GeoSite(_) => steps.push(PolicyStep::GeoSite(index)),
+                DnsPolicySelector::Domains(patterns) => {
+                    if !matches!(steps.last(), Some(PolicyStep::Domains(_))) {
+                        steps.push(PolicyStep::Domains(DomainIndex::new()));
+                    }
+                    let Some(PolicyStep::Domains(domains)) = steps.last_mut() else {
+                        unreachable!();
+                    };
+                    for pattern in patterns {
+                        domains.insert(pattern, index);
+                    }
+                }
+            }
+        }
+        Self(steps)
+    }
+
+    pub(super) fn select(
+        &self,
+        name: &str,
+        policies: &[DnsNameserverPolicy],
+        geo: &dyn GeoMatcher,
+        decision: &crate::config::RuleDecision,
+    ) -> Result<Option<usize>, crate::config::MatchFailure> {
+        decision.visit()?;
+        for step in &self.0 {
+            match step {
+                PolicyStep::Domains(domains) => {
+                    if let Some(index) = domains.find(0, name) {
+                        return Ok(Some(index));
+                    }
+                }
+                PolicyStep::RuleSet(index) => {
+                    let DnsPolicySelector::RuleSets { sets, .. } = &policies[*index].selector
+                    else {
+                        unreachable!()
+                    };
+                    for set in sets {
+                        if set.matches_domain(name, geo, decision)? {
+                            return Ok(Some(*index));
+                        }
+                    }
+                }
+                PolicyStep::GeoSite(index) => {
+                    for code in policies[*index].geosite_codes() {
+                        if geo.matches_geosite_bounded(code, name, decision)? {
+                            return Ok(Some(*index));
+                        }
+                    }
+                }
+            }
+        }
+        Ok(None)
+    }
+}
+
+#[derive(Debug, Default, PartialEq, Eq)]
+struct DomainNode {
+    labels: HashMap<String, usize>,
+    wildcard: Option<usize>,
+    exact: Option<usize>,
+    suffix: Option<usize>,
+}
+
+/// A flat arena keeps construction and destruction independent of pattern
+/// depth; lookup depth is bounded by the validated DNS question.
+#[derive(Debug, PartialEq, Eq)]
+pub(crate) struct DomainIndex(Vec<DomainNode>);
+
+impl DomainIndex {
+    pub(crate) fn new() -> Self {
+        Self(vec![DomainNode::default()])
+    }
+
+    pub(crate) fn insert(&mut self, pattern: &str, policy: usize) {
+        let (domain, exact, suffix) = if let Some(domain) = pattern.strip_prefix("+.") {
+            (domain, true, true)
+        } else if let Some(domain) = pattern.strip_prefix('.') {
+            (domain, false, true)
+        } else {
+            (pattern, true, false)
+        };
+        let mut current = 0;
+        for label in domain.rsplit('.') {
+            let child = if label == "*" {
+                self.0[current].wildcard
+            } else {
+                self.0[current].labels.get(label).copied()
+            };
+            current = child.unwrap_or_else(|| {
+                let next = self.0.len();
+                self.0.push(DomainNode::default());
+                if label == "*" {
+                    self.0[current].wildcard = Some(next);
+                } else {
+                    self.0[current].labels.insert(label.to_owned(), next);
+                }
+                next
+            });
+        }
+        if exact {
+            self.0[current].exact = Some(policy);
+        }
+        if suffix {
+            self.0[current].suffix = Some(policy);
+        }
+    }
+
+    pub(crate) fn find(&self, current: usize, name: &str) -> Option<usize> {
+        let node = &self.0[current];
+        if name.is_empty() {
+            return node.exact;
+        }
+        let (rest, label) = name.rsplit_once('.').unwrap_or(("", name));
+        node.labels
+            .get(label)
+            .and_then(|child| self.find(*child, rest))
+            .or_else(|| node.wildcard.and_then(|child| self.find(child, rest)))
+            .or(node.suffix)
+    }
+}
diff --git a/src/dns/quic.rs b/src/dns/quic.rs
new file mode 100644
index 0000000..15d932a
--- /dev/null
+++ b/src/dns/quic.rs
@@ -0,0 +1,599 @@
+//! DNS-only QUIC ownership, budgets and per-query streams over protected IO.
+use super::{MAX_HTTP_HEADER_BYTES, MAX_MESSAGE_SIZE};
+use crate::{
+    config::DnsNameserver,
+    dispatch::{DatagramBudget, DatagramTransport},
+    transport::{
+        quic::{self, OwnedRuntime},
+        quinn_h3,
+    },
+};
+use bytes::Buf;
+use std::{
+    collections::HashMap,
+    future::Future,
+    hash::Hash,
+    io,
+    net::SocketAddr,
+    sync::{
+        Arc, Mutex, Weak,
+        atomic::{AtomicBool, AtomicUsize, Ordering},
+    },
+    time::Duration,
+};
+use tokio::{
+    io::AsyncReadExt,
+    sync::{Mutex as AsyncMutex, Semaphore, oneshot},
+    time::Instant,
+};
+use tokio_util::{sync::CancellationToken, task::TaskTracker};
+
+const MAX_STREAMS: usize = 32;
+const MAX_IDLE: usize = 4;
+const IDLE_TIMEOUT: Duration = Duration::from_secs(30);
+
+#[derive(Clone, Copy)]
+pub(super) enum Kind {
+    Doq,
+    H3,
+}
+
+pub(super) struct Raw {
+    pub transport: Box<dyn DatagramTransport>,
+    pub peer: SocketAddr,
+    pub budget: DatagramBudget,
+    pub tls: Arc<rustls::ClientConfig>,
+    pub server_name: String,
+}
+
+enum Protocol {
+    Doq(quinn::Connection),
+    H3(quinn_h3::Client),
+}
+
+struct Connection {
+    protocol: Protocol,
+    metadata: Arc<Metadata>,
+    cancel: CancellationToken,
+    streams: Arc<Semaphore>,
+}
+struct Metadata {
+    healthy: AtomicBool,
+    active: AtomicUsize,
+    used: Mutex<Instant>,
+}
+struct State<K> {
+    connections: Vec<(K, Arc<Connection>)>,
+    initializing: HashMap<K, Weak<AsyncMutex<()>>>,
+}
+
+pub(super) struct Pool<K> {
+    state: Mutex<State<K>>,
+    admission: Mutex<()>,
+    cancel: CancellationToken,
+    tasks: TaskTracker,
+    reaper: AtomicBool,
+    max_idle: AtomicUsize,
+}
+pub(super) struct Lease<K: Clone + Eq + Hash + Send + Sync + 'static> {
+    connection: Arc<Connection>,
+    owner: Weak<Pool<K>>,
+}
+
+/// A probe is already owned by its resolver, including its close exchange.
+/// Dropping a canceled query cancels this child; Stop joins its cleanup task.
+pub(super) struct Pending<K: Clone + Eq + Hash + Send + Sync + 'static> {
+    owner: Arc<Pool<K>>,
+    key: Option<K>,
+    ready: oneshot::Receiver<io::Result<Protocol>>,
+    done: Option<oneshot::Receiver<()>>,
+    protocol: Option<Protocol>,
+    metadata: Arc<Metadata>,
+    cancel: CancellationToken,
+    published: bool,
+}
+
+impl<K: Clone + Eq + Hash + Send + Sync + 'static> Pool<K> {
+    pub(super) fn new() -> Arc<Self> {
+        Arc::new(Self {
+            state: Mutex::new(State {
+                connections: Vec::new(),
+                initializing: HashMap::new(),
+            }),
+            admission: Mutex::new(()),
+            cancel: CancellationToken::new(),
+            tasks: TaskTracker::new(),
+            reaper: AtomicBool::new(false),
+            max_idle: AtomicUsize::new(MAX_IDLE),
+        })
+    }
+    pub(super) fn disable_idle(&self) {
+        self.max_idle.store(0, Ordering::Release);
+    }
+    pub(super) fn has(&self, key: &K) -> bool {
+        !self.cancel.is_cancelled()
+            && self
+                .state
+                .lock()
+                .unwrap()
+                .connections
+                .iter()
+                .any(|(candidate, connection)| candidate == key && live(connection))
+    }
+    pub(super) fn get(self: &Arc<Self>, key: &K) -> Option<Lease<K>> {
+        if self.cancel.is_cancelled() {
+            return None;
+        }
+        let mut state = self.state.lock().unwrap();
+        self.maintain(&mut state);
+        let connection = state
+            .connections
+            .iter()
+            .find(|(candidate, connection)| candidate == key && live(connection))?
+            .1
+            .clone();
+        connection.metadata.active.fetch_add(1, Ordering::AcqRel);
+        Some(Lease {
+            connection,
+            owner: Arc::downgrade(self),
+        })
+    }
+    pub(super) fn initialization(&self, key: K) -> Arc<AsyncMutex<()>> {
+        let mut state = self.state.lock().unwrap();
+        state
+            .initializing
+            .retain(|_, gate| gate.strong_count() != 0);
+        if let Some(gate) = state.initializing.get(&key).and_then(Weak::upgrade) {
+            return gate;
+        }
+        let gate = Arc::new(AsyncMutex::new(()));
+        state.initializing.insert(key, Arc::downgrade(&gate));
+        gate
+    }
+    pub(super) fn start(
+        self: &Arc<Self>,
+        key: K,
+        kind: Kind,
+        open: impl Future<Output = io::Result<Raw>> + Send + 'static,
+    ) -> io::Result<Pending<K>> {
+        let _admission = self.admission.lock().unwrap();
+        if self.cancel.is_cancelled() {
+            return Err(closed());
+        }
+        let cancel = self.cancel.child_token();
+        let metadata = Arc::new(Metadata {
+            healthy: AtomicBool::new(true),
+            active: AtomicUsize::new(0),
+            used: Mutex::new(Instant::now()),
+        });
+        let (ready, response) = oneshot::channel();
+        let (done, completed) = oneshot::channel();
+        let observation =
+            crate::resources::observation::track(crate::resources::observation::ResourceKind::Task);
+        let stop = cancel.clone();
+        let meta = metadata.clone();
+        self.tasks
+            .spawn(crate::resources::observation::bind(async move {
+                let _observation = observation;
+                drive(open, kind, stop, meta, ready).await;
+                let _ = done.send(());
+            }));
+        Ok(Pending {
+            owner: self.clone(),
+            key: Some(key),
+            ready: response,
+            done: Some(completed),
+            protocol: None,
+            metadata,
+            cancel,
+            published: false,
+        })
+    }
+    fn maintain(&self, state: &mut State<K>) {
+        state.connections.retain(|(_, connection)| {
+            connection.metadata.active.load(Ordering::Acquire) != 0 || live(connection)
+        });
+        while state
+            .connections
+            .iter()
+            .filter(|(_, connection)| connection.metadata.active.load(Ordering::Acquire) == 0)
+            .count()
+            > self.max_idle.load(Ordering::Acquire)
+        {
+            let Some(index) = state
+                .connections
+                .iter()
+                .enumerate()
+                .filter(|(_, (_, connection))| {
+                    connection.metadata.active.load(Ordering::Acquire) == 0
+                })
+                .min_by_key(|(_, (_, connection))| *connection.metadata.used.lock().unwrap())
+                .map(|(index, _)| index)
+            else {
+                break;
+            };
+            state.connections.swap_remove(index);
+        }
+    }
+    fn start_reaper(self: &Arc<Self>) {
+        let _admission = self.admission.lock().unwrap();
+        if self.cancel.is_cancelled() || self.reaper.swap(true, Ordering::AcqRel) {
+            return;
+        }
+        let owner = Arc::downgrade(self);
+        let cancel = self.cancel.clone();
+        self.tasks.spawn(crate::resources::observation::task(async move {
+            loop {
+                tokio::select! { biased; ()=cancel.cancelled()=>return, ()=tokio::time::sleep(IDLE_TIMEOUT)=>{} }
+                let Some(owner) = owner.upgrade() else { return; };
+                let mut state = owner.state.lock().unwrap();
+                owner.maintain(&mut state);
+                if state.connections.is_empty() { owner.reaper.store(false, Ordering::Release); return; }
+            }
+        }));
+    }
+    pub(super) fn close(&self) {
+        let _admission = self.admission.lock().unwrap();
+        self.cancel.cancel();
+        self.tasks.close();
+        let mut state = self.state.lock().unwrap();
+        state.initializing.clear();
+        let connections = std::mem::take(&mut state.connections);
+        drop(state);
+        drop(connections);
+    }
+    pub(super) async fn shutdown(&self) {
+        self.close();
+        self.tasks.wait().await;
+    }
+    #[cfg(test)]
+    pub(super) fn task_count(&self) -> usize {
+        self.tasks.len()
+    }
+}
+
+fn live(connection: &Connection) -> bool {
+    connection.metadata.healthy.load(Ordering::Acquire)
+        && match &connection.protocol {
+            Protocol::H3(sender) => sender.can_open_request(),
+            Protocol::Doq(connection) => connection.close_reason().is_none(),
+        }
+        && !connection.cancel.is_cancelled()
+        && (connection.metadata.active.load(Ordering::Acquire) != 0
+            || Instant::now().duration_since(*connection.metadata.used.lock().unwrap())
+                < IDLE_TIMEOUT)
+}
+impl<K> Drop for Pool<K> {
+    fn drop(&mut self) {
+        self.cancel.cancel();
+        self.tasks.close();
+    }
+}
+impl Drop for Connection {
+    fn drop(&mut self) {
+        self.cancel.cancel();
+    }
+}
+
+impl<K: Clone + Eq + Hash + Send + Sync + 'static> Pending<K> {
+    pub(super) async fn wait_ready(&mut self) -> io::Result<()> {
+        self.protocol = Some((&mut self.ready).await.map_err(|_| closed())??);
+        Ok(())
+    }
+    pub(super) fn publish(mut self) -> io::Result<Lease<K>> {
+        let connection = Arc::new(Connection {
+            protocol: self.protocol.take().ok_or_else(closed)?,
+            metadata: self.metadata.clone(),
+            cancel: self.cancel.clone(),
+            streams: Arc::new(Semaphore::new(MAX_STREAMS)),
+        });
+        {
+            let _admission = self.owner.admission.lock().unwrap();
+            if self.owner.cancel.is_cancelled()
+                || !connection.metadata.healthy.load(Ordering::Acquire)
+            {
+                return Err(closed());
+            }
+            connection.metadata.active.store(1, Ordering::Release);
+            self.owner
+                .state
+                .lock()
+                .unwrap()
+                .connections
+                .push((self.key.take().unwrap(), connection.clone()));
+        }
+        self.published = true;
+        self.owner.start_reaper();
+        Ok(Lease {
+            connection,
+            owner: Arc::downgrade(&self.owner),
+        })
+    }
+    pub(super) async fn finish(mut self) -> io::Result<Lease<K>> {
+        self.wait_ready().await?;
+        self.publish()
+    }
+    pub(super) async fn cancel(mut self) {
+        self.cancel.cancel();
+        if let Some(done) = self.done.take() {
+            let _ = done.await;
+        }
+    }
+}
+impl<K: Clone + Eq + Hash + Send + Sync + 'static> Drop for Pending<K> {
+    fn drop(&mut self) {
+        if !self.published {
+            self.cancel.cancel();
+        }
+    }
+}
+
+async fn drive(
+    open: impl Future<Output = io::Result<Raw>>,
+    kind: Kind,
+    stop: CancellationToken,
+    metadata: Arc<Metadata>,
+    ready: oneshot::Sender<io::Result<Protocol>>,
+) {
+    // Keep native IO alive until the bounded close exchange completes; its
+    // cancellation token must not be the resolver's already canceled token.
+    let runtime = Arc::new(OwnedRuntime::new(CancellationToken::new()));
+    let mut upstream = None;
+    let mut endpoint = None;
+    let mut datagram = None;
+    let mut ready = Some(ready);
+    let connected = async {
+        let raw = open.await?;
+        upstream = Some(raw.transport);
+        let mut tls = (*raw.tls).clone();
+        tls.resumption = rustls::client::Resumption::disabled();
+        tls.enable_early_data = false;
+        let crypto = quinn::crypto::rustls::QuicClientConfig::try_from(tls).map_err(failure)?;
+        if raw.peer.port() == 0 || raw.peer.ip().is_unspecified() || raw.peer.ip().is_multicast() {
+            return Err(io::ErrorKind::InvalidInput.into());
+        }
+        // Preserve close ownership when preparation fails before attach can
+        // transfer the transport to its tracked datagram driver.
+        raw.budget
+            .intersect(upstream.as_ref().unwrap().payload_budget(&raw.peer.into()))
+            .quic_payload_limit()?;
+        let (socket, driver) =
+            quic::attach_quinn(upstream.take().unwrap(), raw.peer, raw.budget).await?;
+        datagram = Some(driver);
+        let path = socket.budget();
+        let mtu = path
+            .quic_payload_limit()?
+            .min(crate::dispatch::QUIC_MIN_PAYLOAD_BYTES);
+        let discovery = if matches!(kind, Kind::H3) {
+            let mut discovery = quinn::MtuDiscoveryConfig::default();
+            discovery.upper_bound(path.transmit());
+            Some(discovery)
+        } else {
+            None
+        };
+        let mut limits = quinn::TransportConfig::default();
+        socket.configure_transport(&mut limits);
+        limits
+            .initial_mtu(mtu)
+            .min_mtu(mtu)
+            .mtu_discovery_config(discovery)
+            .max_concurrent_bidi_streams(0_u8.into())
+            .max_concurrent_uni_streams((if matches!(kind, Kind::H3) { 8_u8 } else { 0 }).into())
+            .stream_receive_window(((MAX_MESSAGE_SIZE + 2) as u32).into())
+            .receive_window(((MAX_MESSAGE_SIZE * MAX_STREAMS) as u32).into())
+            .send_window((MAX_MESSAGE_SIZE * MAX_STREAMS) as u64)
+            .datagram_receive_buffer_size(None)
+            .datagram_send_buffer_size(0)
+            .max_idle_timeout(Some(IDLE_TIMEOUT.try_into().map_err(failure)?));
+        let mut client = quinn::ClientConfig::new(Arc::new(crypto));
+        client.transport_config(Arc::new(limits));
+        let mut config = quinn::EndpointConfig::default();
+        config
+            .max_udp_payload_size(path.receive())
+            .map_err(failure)?;
+        let mut peer =
+            quinn::Endpoint::new_with_abstract_socket(config, None, socket, runtime.clone())?;
+        peer.set_default_client_config(client);
+        endpoint = Some(peer);
+        let connection = endpoint
+            .as_ref()
+            .unwrap()
+            .connect(raw.peer, &raw.server_name)
+            .map_err(failure)?
+            .await
+            .map_err(failure)?;
+        let handshake = connection
+            .handshake_data()
+            .ok_or_else(closed)?
+            .downcast::<quinn::crypto::rustls::HandshakeData>()
+            .map_err(|_| closed())?;
+        let alpn: &[u8] = if matches!(kind, Kind::Doq) {
+            b"doq"
+        } else {
+            b"h3"
+        };
+        if handshake.protocol.as_deref() != Some(alpn) {
+            return Err(io::ErrorKind::InvalidData.into());
+        }
+        match kind {
+            Kind::Doq => {
+                ready
+                    .take()
+                    .unwrap()
+                    .send(Ok(Protocol::Doq(connection.clone())))
+                    .map_err(|_| closed())?;
+                connection.closed().await;
+            }
+            Kind::H3 => {
+                let (sender, mut control) =
+                    quinn_h3::attach(connection, MAX_HTTP_HEADER_BYTES as u64)
+                        .await
+                        .map_err(failure)?;
+                // Dropping the last h3 sender closes QUIC. Retain one until the
+                // owner retires; a dropped query only owns its request halves.
+                let keep_sender = sender.clone();
+                ready
+                    .take()
+                    .unwrap()
+                    .send(Ok(Protocol::H3(sender)))
+                    .map_err(|_| closed())?;
+                let _ = control.wait_idle().await;
+                drop(keep_sender);
+            }
+        }
+        Ok::<_, io::Error>(())
+    };
+    let result =
+        tokio::select! { biased; ()=stop.cancelled()=>Err(closed()), result=connected=>result };
+    metadata.healthy.store(false, Ordering::Release);
+    if let Some(endpoint) = endpoint {
+        endpoint.close(0_u8.into(), b"");
+        let _ = tokio::time::timeout(quic::CLOSE_TIMEOUT, endpoint.wait_idle()).await;
+    }
+    runtime.stop().await;
+    if let Some(driver) = datagram {
+        let _ = driver.stop().await;
+    }
+    if let Some(mut upstream) = upstream {
+        let _ = tokio::time::timeout(quic::CLOSE_TIMEOUT, upstream.close()).await;
+    }
+    if let Some(ready) = ready {
+        let _ = ready.send(Err(result.err().unwrap_or_else(closed)));
+    }
+}
+
+struct DoqStream {
+    send: quinn::SendStream,
+    receive: quinn::RecvStream,
+    completed: bool,
+}
+impl Drop for DoqStream {
+    fn drop(&mut self) {
+        if !self.completed {
+            let _ = self.send.reset(3_u8.into());
+            let _ = self.receive.stop(3_u8.into());
+        }
+    }
+}
+
+impl<K: Clone + Eq + Hash + Send + Sync + 'static> Lease<K> {
+    pub(super) async fn exchange<R>(
+        &self,
+        server: &DnsNameserver,
+        query: &[u8],
+        validate: impl Fn(&[u8]) -> io::Result<R>,
+    ) -> io::Result<(Vec<u8>, R)> {
+        let result = self.exchange_inner(server, query, validate).await;
+        if result.is_err() {
+            self.connection
+                .metadata
+                .healthy
+                .store(false, Ordering::Release);
+        }
+        result
+    }
+    async fn exchange_inner<R>(
+        &self,
+        server: &DnsNameserver,
+        query: &[u8],
+        validate: impl Fn(&[u8]) -> io::Result<R>,
+    ) -> io::Result<(Vec<u8>, R)> {
+        if query.len() < 12 || query.len() > MAX_MESSAGE_SIZE {
+            return Err(io::ErrorKind::InvalidInput.into());
+        }
+        let _permit = self
+            .connection
+            .streams
+            .clone()
+            .acquire_owned()
+            .await
+            .map_err(|_| closed())?;
+        match &self.connection.protocol {
+            Protocol::Doq(connection) => {
+                let (send, receive) = connection.open_bi().await.map_err(failure)?;
+                let mut stream = DoqStream {
+                    send,
+                    receive,
+                    completed: false,
+                };
+                let mut wire = Vec::with_capacity(query.len() + 2);
+                wire.extend_from_slice(&(query.len() as u16).to_be_bytes());
+                wire.extend_from_slice(query);
+                wire[2..4].fill(0);
+                stream.send.write_all(&wire).await.map_err(failure)?;
+                stream.send.finish().map_err(failure)?;
+                let length = stream.receive.read_u16().await? as usize;
+                if !(12..=MAX_MESSAGE_SIZE).contains(&length) {
+                    return Err(io::ErrorKind::InvalidData.into());
+                }
+                let mut response = vec![0; length];
+                stream
+                    .receive
+                    .read_exact(&mut response)
+                    .await
+                    .map_err(failure)?;
+                if stream
+                    .receive
+                    .read(&mut [0; 1])
+                    .await
+                    .map_err(failure)?
+                    .is_some()
+                {
+                    return Err(io::ErrorKind::InvalidData.into());
+                }
+                super::https::restore_id(query, &mut response)?;
+                let validated = validate(&response)?;
+                stream.completed = true;
+                Ok((response, validated))
+            }
+            Protocol::H3(sender) => {
+                let mut sender = sender.clone();
+                let mut stream = sender
+                    .send_request(super::https::request(server, query)?)
+                    .await
+                    .map_err(failure)?;
+                stream.finish().await.map_err(failure)?;
+                let headers = stream.recv_response().await.map_err(failure)?;
+                let length = super::https::validate_headers(headers.status(), headers.headers())?;
+                let mut response = Vec::new();
+                while let Some(mut bytes) = stream.recv_data().await.map_err(failure)? {
+                    if response.len() + bytes.remaining() > MAX_MESSAGE_SIZE {
+                        return Err(io::ErrorKind::InvalidData.into());
+                    }
+                    response.extend_from_slice(&bytes.copy_to_bytes(bytes.remaining()));
+                }
+                if length.is_some_and(|length| length != response.len()) {
+                    return Err(io::ErrorKind::InvalidData.into());
+                }
+                let _ = stream.recv_trailers().await.map_err(failure)?;
+                super::https::restore_id(query, &mut response)?;
+                let validated = validate(&response)?;
+                Ok((response, validated))
+            }
+        }
+    }
+}
+impl<K: Clone + Eq + Hash + Send + Sync + 'static> Drop for Lease<K> {
+    fn drop(&mut self) {
+        if let Some(owner) = self.owner.upgrade() {
+            let mut state = owner.state.lock().unwrap();
+            *self.connection.metadata.used.lock().unwrap() = Instant::now();
+            self.connection
+                .metadata
+                .active
+                .fetch_sub(1, Ordering::AcqRel);
+            owner.maintain(&mut state);
+        } else {
+            self.connection
+                .metadata
+                .active
+                .fetch_sub(1, Ordering::AcqRel);
+        }
+    }
+}
+fn failure(_: impl std::fmt::Display) -> io::Error {
+    io::Error::other("DNS QUIC exchange failed")
+}
+fn closed() -> io::Error {
+    io::ErrorKind::ConnectionAborted.into()
+}
diff --git a/src/dns/refresh.rs b/src/dns/refresh.rs
new file mode 100644
index 0000000..d81a849
--- /dev/null
+++ b/src/dns/refresh.rs
@@ -0,0 +1,73 @@
+//! Bounded refresh ownership, separate from foreground DNS query lifetimes.
+use std::{
+    future::Future,
+    sync::{Arc, Mutex},
+};
+use tokio::sync::{OwnedSemaphorePermit, Semaphore};
+use tokio_util::{sync::CancellationToken, task::TaskTracker};
+
+pub(super) const CONCURRENCY: usize = 4;
+pub(super) const BACKOFF: std::time::Duration = std::time::Duration::from_secs(5);
+
+pub(super) struct Owner {
+    pub(super) budget: Arc<Semaphore>,
+    admission: Mutex<bool>,
+    cancel: CancellationToken,
+    tasks: TaskTracker,
+}
+
+impl Owner {
+    pub(super) fn new(budget: Option<Arc<Semaphore>>) -> Arc<Self> {
+        Arc::new(Self {
+            budget: budget.unwrap_or_else(|| Arc::new(Semaphore::new(CONCURRENCY))),
+            admission: Mutex::new(true),
+            cancel: CancellationToken::new(),
+            tasks: TaskTracker::new(),
+        })
+    }
+
+    pub(super) fn reserve(&self) -> Option<OwnedSemaphorePermit> {
+        if self.cancel.is_cancelled() {
+            return None;
+        }
+        self.budget.clone().try_acquire_owned().ok()
+    }
+
+    pub(super) fn spawn<F>(&self, permit: OwnedSemaphorePermit, future: F)
+    where
+        F: Future<Output = ()> + Send + 'static,
+    {
+        let admission = self
+            .admission
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
+        if !*admission {
+            return;
+        }
+        let cancel = self.cancel.clone();
+        self.tasks
+            .spawn(crate::resources::observation::task(async move {
+                let _permit = permit;
+                tokio::select! { biased; () = cancel.cancelled() => {}, () = future => {} }
+            }));
+    }
+
+    pub(super) fn close(&self) {
+        let mut admission = self
+            .admission
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
+        *admission = false;
+        self.cancel.cancel();
+        self.tasks.close();
+    }
+
+    pub(super) fn is_closed(&self) -> bool {
+        self.cancel.is_cancelled()
+    }
+
+    pub(super) async fn shutdown(&self) {
+        self.close();
+        self.tasks.wait().await;
+    }
+}
diff --git a/src/dns/resolution.rs b/src/dns/resolution.rs
index a76e502..ac8cd33 100644
--- a/src/dns/resolution.rs
+++ b/src/dns/resolution.rs
@@ -1,5 +1,5 @@
 //! IP-only protocol boundaries use a runtime-owned resolver, never an implicit
-//! system lookup. Endpoint/ECH bootstrap remains a separate prepare operation.
+//! system lookup. Proxy servers use their separate runtime DNS role.
 
 use super::{canonicalize_name, runtime::RuntimeDns};
 use crate::{dialer::Resolver, dispatch::DispatchError, session::Destination};
@@ -21,6 +21,7 @@ enum Source {
 
 struct State {
     source: OnceLock<Source>,
+    measurement_ech: OnceLock<Weak<RuntimeDns>>,
     ipv6: bool,
     cancel: CancellationToken,
 }
@@ -30,6 +31,9 @@ struct State {
 /// Default contexts permit literal IPs but have no domain resolver.
 #[derive(Clone, Default)]
 pub struct ResolutionContext {
+    ip_version: crate::config::IpVersion,
+    ip4p_convert: bool,
+    ip4p_reject_loopback: bool,
     inner: Option<Arc<State>>,
 }
 
@@ -42,7 +46,14 @@ impl std::fmt::Debug for ResolutionContext {
 #[derive(Clone)]
 struct ActiveResolution {
     deadline: Instant,
-    names: Vec<(usize, String)>,
+    names: Vec<(usize, ResolveRole, u16, String)>,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum ResolveRole {
+    Business,
+    Proxy,
+    Direct,
 }
 
 tokio::task_local! {
@@ -56,10 +67,45 @@ pub(crate) fn inherited_deadline(deadline: Instant) -> Instant {
 }
 
 impl ResolutionContext {
+    pub(crate) fn with_ip_version(mut self, version: crate::config::IpVersion) -> Self {
+        self.ip_version = version;
+        self
+    }
+
+    /// Scoped only to a physical endpoint lookup. Ordinary business/IP-only
+    /// resolution, DNS answers and proxy-chain destinations do not opt in.
+    pub(crate) fn with_physical_dialer(mut self, dialer: &crate::dialer::Dialer) -> Self {
+        self.ip4p_convert = dialer.connections().dialer_ip4p_convert;
+        self.ip4p_reject_loopback = dialer.ip4p_loopback_restricted();
+        self
+    }
+    fn physical_address(
+        &self,
+        original: SocketAddr,
+        literal: bool,
+    ) -> Result<SocketAddr, DispatchError> {
+        let actual = crate::config::ConnectionSettings {
+            dialer_ip4p_convert: self.ip4p_convert,
+            ..Default::default()
+        }
+        .convert_ip4p_endpoint(original);
+        crate::dialer::preserve_ip4p_loopback(
+            original,
+            actual,
+            literal && !self.ip4p_reject_loopback,
+        )
+        .map_err(|_| DispatchError::NotAllowed)?;
+        Ok(actual)
+    }
+
     pub fn runtime(ipv6: bool) -> Self {
         Self {
+            ip_version: crate::config::IpVersion::Dual,
+            ip4p_convert: false,
+            ip4p_reject_loopback: false,
             inner: Some(Arc::new(State {
                 source: OnceLock::new(),
+                measurement_ech: OnceLock::new(),
                 ipv6,
                 cancel: CancellationToken::new(),
             })),
@@ -76,8 +122,8 @@ impl ResolutionContext {
             .map_err(|_| io::ErrorKind::AlreadyExists.into())
     }
 
-    /// Private measurement lifetime: no Running Session, RuntimeDns, listener,
-    /// or system-fallback path is constructed by this context.
+    /// Private measurement lifetime. Address lookup uses only the original
+    /// resolver; raw ECH records use a separately owned weak DNS leaf.
     pub fn measurement(bootstrap: Arc<dyn Resolver>, ipv6: bool) -> Self {
         let context = Self::runtime(ipv6);
         let _ = context
@@ -89,10 +135,92 @@ impl ResolutionContext {
         context
     }
 
+    #[cfg(any(feature = "invoke", test))]
+    pub(crate) fn bind_measurement_ech(&self, dns: &Arc<RuntimeDns>) -> io::Result<()> {
+        self.inner
+            .as_ref()
+            .ok_or(io::ErrorKind::InvalidInput)?
+            .measurement_ech
+            .set(Arc::downgrade(dns))
+            .map_err(|_| io::ErrorKind::AlreadyExists.into())
+    }
+
+    pub(crate) fn resolve_ech<'a>(
+        &'a self,
+        name: &'a str,
+        deadline: Instant,
+    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = io::Result<Vec<u8>>> + Send + 'a>> {
+        // DNS transports can establish a TLS node whose ECH query returns to
+        // this boundary; erase the recursive future without spawning a task.
+        Box::pin(async move {
+            let name =
+                canonicalize_name(name).map_err(|_| io::Error::other("invalid ECH query name"))?;
+            let state = self
+                .inner
+                .as_ref()
+                .ok_or_else(|| io::Error::other("ECH DNS source unavailable"))?;
+            let dns = match state.source.get() {
+                Some(Source::Runtime(dns)) => dns.as_ref().and_then(Weak::upgrade),
+                Some(Source::Measurement(_)) => state.measurement_ech.get().and_then(Weak::upgrade),
+                None => None,
+            }
+            .ok_or_else(|| io::Error::other("ECH DNS source unavailable"))?;
+            let deadline = inherited_deadline(deadline);
+            let key = (
+                Arc::as_ptr(state) as usize,
+                ResolveRole::Proxy,
+                65,
+                name.clone(),
+            );
+            let mut active = ACTIVE.try_with(Clone::clone).unwrap_or(ActiveResolution {
+                deadline,
+                names: Vec::new(),
+            });
+            if deadline <= Instant::now() {
+                return Err(io::ErrorKind::TimedOut.into());
+            }
+            if active.names.contains(&key) || active.names.len() >= MAX_RESOLUTION_DEPTH {
+                return Err(io::Error::other("recursive ECH DNS dependency"));
+            }
+            active.deadline = deadline;
+            active.names.push(key);
+            let _waiter = crate::resources::observation::track(
+                crate::resources::observation::ResourceKind::Waiter,
+            );
+            tokio::select! { biased;
+                () = state.cancel.cancelled() => Err(io::ErrorKind::Interrupted.into()),
+                result = timeout_at(deadline, ACTIVE.scope(active, dns.query_proxy_ech(&name, deadline))) => {
+                    if Instant::now() >= deadline {
+                        Err(io::ErrorKind::TimedOut.into())
+                    } else {
+                        result.map_err(|_| io::Error::from(io::ErrorKind::TimedOut))?
+                    }
+                },
+            }
+        })
+    }
+
     pub fn close(&self) {
         if let Some(inner) = &self.inner {
             inner.cancel.cancel();
         }
+        if let Some(dns) = self.runtime_dns() {
+            dns.begin_shutdown();
+        }
+    }
+
+    pub(crate) fn runtime_dns(&self) -> Option<Arc<RuntimeDns>> {
+        match self.inner.as_ref()?.source.get()? {
+            Source::Runtime(Some(dns)) => dns.upgrade(),
+            _ => None,
+        }
+    }
+
+    pub(crate) async fn shutdown(&self) {
+        self.close();
+        if let Some(dns) = self.runtime_dns() {
+            dns.shutdown().await;
+        }
     }
 
     /// Resolve only when the consuming protocol requires an IP. This does not
@@ -102,91 +230,328 @@ impl ResolutionContext {
         target: &Destination,
         deadline: Instant,
     ) -> Result<SocketAddr, DispatchError> {
-        let deadline = inherited_deadline(deadline);
-        if deadline <= Instant::now() {
-            return Err(DispatchError::TimedOut);
-        }
-        if self
-            .inner
-            .as_ref()
-            .is_some_and(|inner| inner.cancel.is_cancelled())
-        {
-            return Err(DispatchError::NotAllowed);
+        self.resolve_addresses(target, deadline, ResolveRole::Business)
+            .await?
+            .into_iter()
+            .next()
+            .ok_or(DispatchError::HostUnreachable)
+    }
+
+    /// A raw-IP node cannot originate a family without a configured local IP.
+    /// Keep the same business DNS role, policy ordering and absolute deadline.
+    #[cfg(any(feature = "outbound-wireguard", feature = "outbound-masque"))]
+    pub(crate) async fn resolve_local_family(
+        &self,
+        target: &Destination,
+        deadline: Instant,
+        ipv4: bool,
+        ipv6: bool,
+    ) -> Result<SocketAddr, DispatchError> {
+        self.resolve_addresses(target, deadline, ResolveRole::Business)
+            .await?
+            .into_iter()
+            .find(|address| if address.is_ipv4() { ipv4 } else { ipv6 })
+            .ok_or(DispatchError::HostUnreachable)
+    }
+
+    #[cfg(any(feature = "outbound-wireguard", feature = "outbound-masque"))]
+    pub(crate) fn ipv6_allowed(&self) -> bool {
+        self.inner.as_ref().is_none_or(|state| state.ipv6)
+    }
+
+    #[cfg(any(feature = "outbound-wireguard", feature = "outbound-masque"))]
+    pub(crate) async fn resolve_node_local(
+        &self,
+        target: &Destination,
+        deadline: Instant,
+        dns: &RuntimeDns,
+        ipv4: bool,
+        ipv6: bool,
+    ) -> Result<SocketAddr, DispatchError> {
+        self.resolve_addresses_via(target, deadline, ResolveRole::Business, Some(dns))
+            .await?
+            .into_iter()
+            .find(|address| if address.is_ipv4() { ipv4 } else { ipv6 })
+            .ok_or(DispatchError::HostUnreachable)
+    }
+
+    pub async fn resolve_proxy(
+        &self,
+        target: &Destination,
+        deadline: Instant,
+    ) -> Result<crate::dialer::ResolvedEndpoint, DispatchError> {
+        let addresses = self
+            .resolve_addresses(target, deadline, ResolveRole::Proxy)
+            .await?;
+        Ok(Self::endpoint(target, addresses))
+    }
+
+    pub(crate) async fn resolve_direct(
+        &self,
+        target: &Destination,
+        deadline: Instant,
+    ) -> Result<crate::dialer::ResolvedEndpoint, DispatchError> {
+        let addresses = self
+            .resolve_addresses(target, deadline, ResolveRole::Direct)
+            .await?;
+        Ok(Self::endpoint(target, addresses))
+    }
+
+    fn endpoint(
+        target: &Destination,
+        addresses: Vec<SocketAddr>,
+    ) -> crate::dialer::ResolvedEndpoint {
+        crate::dialer::ResolvedEndpoint {
+            logical_host: match target {
+                Destination::Domain { host, .. } => host.clone(),
+                Destination::Ip(address) => address.ip().to_string(),
+            },
+            port: target.port(),
+            addresses,
         }
-        if let Destination::Ip(address) = target {
-            if address.port() == 0
-                || (address.is_ipv6() && self.inner.as_ref().is_some_and(|inner| !inner.ipv6))
+    }
+
+    async fn resolve_addresses(
+        &self,
+        target: &Destination,
+        deadline: Instant,
+        role: ResolveRole,
+    ) -> Result<Vec<SocketAddr>, DispatchError> {
+        self.resolve_addresses_via(target, deadline, role, None)
+            .await
+    }
+
+    fn resolve_addresses_via<'a>(
+        &'a self,
+        target: &'a Destination,
+        deadline: Instant,
+        role: ResolveRole,
+        node_dns: Option<&'a RuntimeDns>,
+    ) -> std::pin::Pin<
+        Box<dyn std::future::Future<Output = Result<Vec<SocketAddr>, DispatchError>> + Send + 'a>,
+    > {
+        // Erase this future at the resolver boundary: DNS transports may resolve
+        // their own endpoints through the same context.
+        Box::pin(async move {
+            let deadline = inherited_deadline(deadline);
+            if deadline <= Instant::now() {
+                return Err(DispatchError::TimedOut);
+            }
+            if self
+                .inner
+                .as_ref()
+                .is_some_and(|inner| inner.cancel.is_cancelled())
             {
-                return Err(DispatchError::HostUnreachable);
+                return Err(DispatchError::NotAllowed);
             }
-            return Ok(*address);
-        }
-        let Destination::Domain { host, port } = target else {
-            unreachable!()
-        };
-        let host = canonicalize_name(host).map_err(|_| DispatchError::HostUnreachable)?;
-        let inner = self.inner.as_ref().ok_or_else(unavailable)?;
-        let source = inner.source.get().ok_or_else(unavailable)?;
-        let key = (Arc::as_ptr(inner) as usize, host.clone());
-        let mut active = ACTIVE.try_with(Clone::clone).unwrap_or(ActiveResolution {
-            deadline,
-            names: Vec::new(),
-        });
-        if active.names.contains(&key) {
-            return Err(DispatchError::Other("recursive DNS dependency".into()));
-        }
-        if active.names.len() >= MAX_RESOLUTION_DEPTH {
-            return Err(DispatchError::Other("DNS dependency depth exceeded".into()));
-        }
-        active.deadline = deadline;
-        active.names.push(key);
-        let _waiter = crate::resources::observation::track(
-            crate::resources::observation::ResourceKind::Waiter,
-        );
-        let lookup = async {
-            let addresses = match source {
-                Source::Runtime(dns) => {
-                    let dns = dns
-                        .as_ref()
-                        .and_then(Weak::upgrade)
-                        .ok_or_else(unavailable)?;
+            if let Destination::Ip(address) = target {
+                let address = self.physical_address(*address, true)?;
+                if !self.ip_version.permits(address.ip())
+                    || address.port() == 0
+                    || (address.is_ipv6() && self.inner.as_ref().is_some_and(|inner| !inner.ipv6))
+                {
+                    return Err(DispatchError::HostUnreachable);
+                }
+                return Ok(vec![address]);
+            }
+            let Destination::Domain { host, port } = target else {
+                unreachable!()
+            };
+            let host = canonicalize_name(host).map_err(|_| DispatchError::HostUnreachable)?;
+            let inner = self.inner.as_ref();
+            let source = inner.and_then(|inner| inner.source.get());
+            if node_dns.is_none() && source.is_none() {
+                return Err(unavailable());
+            }
+            let identity = node_dns.map_or_else(
+                || Arc::as_ptr(inner.unwrap()) as usize,
+                |dns| dns as *const RuntimeDns as usize,
+            );
+            let key = (identity, role, 0, host.clone());
+            let mut active = ACTIVE.try_with(Clone::clone).unwrap_or(ActiveResolution {
+                deadline,
+                names: Vec::new(),
+            });
+            if active.names.contains(&key) {
+                return Err(DispatchError::Other("recursive DNS dependency".into()));
+            }
+            if active.names.len() >= MAX_RESOLUTION_DEPTH {
+                return Err(DispatchError::Other("DNS dependency depth exceeded".into()));
+            }
+            active.deadline = deadline;
+            active.names.push(key);
+            let _waiter = crate::resources::observation::track(
+                crate::resources::observation::ResourceKind::Waiter,
+            );
+            let decision = crate::config::RuleDecision::default();
+            if let Some(inner) = inner {
+                decision.set_cancellation(inner.cancel.clone());
+            }
+            decision.set_deadline(deadline.into_std());
+            let lookup = async {
+                decision.check()?;
+                let addresses = if let Some(dns) = node_dns {
                     dns.resolve(&host)
                         .await
-                        .map_err(|_| DispatchError::HostUnreachable)?
+                        .map_err(runtime_error)?
                         .into_iter()
                         .map(|ip| SocketAddr::new(ip, *port))
                         .collect::<Vec<_>>()
-                }
-                Source::Measurement(bootstrap) => {
-                    let resolved = bootstrap
-                        .resolve(&host, *port)
-                        .await
-                        .map_err(|_| DispatchError::HostUnreachable)?;
-                    if resolved.logical_host != host
-                        || resolved.port != *port
-                        || resolved
-                            .addresses
-                            .iter()
-                            .any(|address| address.port() != *port)
-                    {
-                        return Err(DispatchError::HostUnreachable);
+                } else {
+                    match source.expect("checked resolver source") {
+                        Source::Runtime(dns) => {
+                            let dns = dns
+                                .as_ref()
+                                .and_then(Weak::upgrade)
+                                .ok_or_else(unavailable)?;
+                            match role {
+                                ResolveRole::Business => dns.resolve(&host).await,
+                                ResolveRole::Proxy => dns.resolve_proxy(&host).await,
+                                ResolveRole::Direct => dns.resolve_direct(&host).await,
+                            }
+                            .map_err(runtime_error)?
+                            .into_iter()
+                            .map(|ip| SocketAddr::new(ip, *port))
+                            .collect::<Vec<_>>()
+                        }
+                        Source::Measurement(bootstrap) => {
+                            let resolved = bootstrap
+                                .resolve(&host, *port)
+                                .await
+                                .map_err(|_| DispatchError::HostUnreachable)?;
+                            if resolved.logical_host != host
+                                || resolved.port != *port
+                                || resolved
+                                    .addresses
+                                    .iter()
+                                    .any(|address| address.port() != *port)
+                            {
+                                return Err(DispatchError::HostUnreachable);
+                            }
+                            resolved.addresses
+                        }
                     }
-                    resolved.addresses
+                };
+                let mut addresses: Vec<_> = addresses
+                    .into_iter()
+                    .map(|address| self.physical_address(address, false))
+                    .collect::<Result<_, _>>()?;
+                addresses
+                    .retain(|address| inner.is_none_or(|inner| inner.ipv6) || address.is_ipv4());
+                self.ip_version.order(&mut addresses);
+                if addresses.is_empty() {
+                    Err(DispatchError::HostUnreachable)
+                } else {
+                    Ok(addresses)
                 }
             };
-            addresses
-                .into_iter()
-                .find(|address| inner.ipv6 || address.is_ipv4())
-                .ok_or(DispatchError::HostUnreachable)
-        };
-        tokio::select! {
-            biased;
-            _ = inner.cancel.cancelled() => Err(DispatchError::NotAllowed),
-            result = timeout_at(deadline, ACTIVE.scope(active, lookup)) => result.unwrap_or(Err(DispatchError::TimedOut)),
+            tokio::select! {
+                biased;
+                _ = async { if let Some(inner)=inner { inner.cancel.cancelled().await } else { std::future::pending::<()>().await } } => Err(DispatchError::NotAllowed),
+                result = timeout_at(deadline, decision.scope(ACTIVE.scope(active, lookup))) => result.unwrap_or(Err(DispatchError::TimedOut)),
+            }
+        })
+    }
+}
+
+fn runtime_error(error: super::runtime::RuntimeDnsError) -> DispatchError {
+    match error {
+        super::runtime::RuntimeDnsError::RuleEvaluation(failure) => {
+            DispatchError::RuleEvaluation(failure)
         }
+        _ => DispatchError::HostUnreachable,
     }
 }
 
 fn unavailable() -> DispatchError {
     DispatchError::Other("runtime DNS is unavailable".into())
 }
+
+#[cfg(test)]
+mod ip4p_tests {
+    use super::*;
+    struct Encoded;
+    #[async_trait::async_trait]
+    impl Resolver for Encoded {
+        async fn resolve(
+            &self,
+            host: &str,
+            port: u16,
+        ) -> io::Result<crate::dialer::ResolvedEndpoint> {
+            Ok(crate::dialer::ResolvedEndpoint {
+                logical_host: host.into(),
+                port,
+                addresses: vec![SocketAddr::new(
+                    "2001:0::1bb:c000:201".parse().unwrap(),
+                    port,
+                )],
+            })
+        }
+    }
+    #[tokio::test]
+    async fn scoped_ip4p_keeps_logical_identity_cancellation_and_ordinary_resolution() {
+        let dialer =
+            crate::dialer::Dialer::default().with_connections(crate::config::ConnectionSettings {
+                dialer_ip4p_convert: true,
+                ..Default::default()
+            });
+        let target = Destination::domain("encoded.example", 8443).unwrap();
+        let base = ResolutionContext::measurement(Arc::new(Encoded), true);
+        let deadline = Instant::now() + std::time::Duration::from_secs(1);
+        let normal = base.resolve_proxy(&target, deadline).await.unwrap();
+        assert_eq!(
+            normal.addresses[0],
+            "[2001:0::1bb:c000:201]:8443".parse::<SocketAddr>().unwrap()
+        );
+        let physical = base
+            .clone()
+            .with_ip_version(crate::config::IpVersion::Ipv4)
+            .with_physical_dialer(&dialer)
+            .resolve_proxy(&target, deadline)
+            .await
+            .unwrap();
+        assert_eq!(physical.logical_host, "encoded.example");
+        assert_eq!(physical.port, 8443);
+        assert_eq!(
+            physical.addresses,
+            ["192.0.2.1:443".parse::<SocketAddr>().unwrap()]
+        );
+        assert_eq!(
+            base.resolve_ip(&target, deadline).await.unwrap(),
+            normal.addresses[0]
+        );
+        let limited = ResolutionContext::measurement(Arc::new(Encoded), false)
+            .with_ip_version(crate::config::IpVersion::Ipv4)
+            .with_physical_dialer(&dialer);
+        assert_eq!(
+            limited
+                .resolve_proxy(&target, deadline)
+                .await
+                .unwrap()
+                .addresses,
+            physical.addresses
+        );
+        base.close();
+        assert!(
+            base.with_physical_dialer(&dialer)
+                .resolve_proxy(&target, deadline)
+                .await
+                .is_err()
+        );
+    }
+    #[test]
+    fn physical_ip4p_loopback_checks_keep_original_literal_and_source_boundaries() {
+        let mut context = ResolutionContext::default();
+        context.ip4p_convert = true;
+        let encoded: SocketAddr = "[2001:0::1bb:7f00:1]:8443".parse().unwrap();
+        assert!(context.physical_address(encoded, false).is_err());
+        assert_eq!(
+            context.physical_address(encoded, true).unwrap(),
+            "127.0.0.1:443".parse().unwrap()
+        );
+        context.ip4p_reject_loopback = true; // Same pure predicate as a UWP physical binding.
+        assert!(context.physical_address(encoded, true).is_err());
+        let explicit: SocketAddr = "127.0.0.1:443".parse().unwrap();
+        assert_eq!(context.physical_address(explicit, true).unwrap(), explicit);
+    }
+}
diff --git a/src/dns/runtime.rs b/src/dns/runtime.rs
index 8dd391d..dad711f 100644
--- a/src/dns/runtime.rs
+++ b/src/dns/runtime.rs
@@ -1,18 +1,30 @@
 //! Bounded runtime DNS service with Mihomo-compatible nameserver egress.
 //!
-//! Upstream endpoints are literal IP addresses. Explicit nameserver fragments
-//! select DIRECT, a named route target, or the ordered rules using only that
-//! endpoint as routing context; a DNS question name is never injected into
-//! business routing.
+//! Upstream domains use a separate bootstrap resolver. DNS questions never
+//! become upstream routing targets; fragments select the upstream connection.
+
+#[cfg(test)]
+#[path = "tests_encrypted.rs"]
+mod encrypted_tests;
+#[cfg(all(test, feature = "dns-quic"))]
+#[path = "tests_quic.rs"]
+mod quic_tests;
+
+#[cfg(test)]
+#[path = "tests_ech.rs"]
+mod ech_tests;
+
+#[path = "refresh.rs"]
+mod refresh;
 
 use std::{
-    collections::HashMap,
+    collections::{HashMap, HashSet},
     fmt,
     future::Future,
     io,
     net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr},
     sync::{
-        Arc, Mutex as StdMutex, Weak,
+        Arc, Mutex as StdMutex, OnceLock, Weak,
         atomic::{AtomicBool, AtomicU16, AtomicU64, AtomicUsize, Ordering},
     },
     time::{Duration, Instant},
@@ -21,31 +33,52 @@ use std::{
 use bytes::Bytes;
 use tokio::{
     io::{AsyncReadExt as _, AsyncWriteExt as _},
-    sync::{Mutex, watch},
+    sync::{Mutex, RwLock, Semaphore, watch},
     time::{Instant as TokioInstant, sleep_until, timeout_at},
 };
 use tokio_util::sync::CancellationToken;
 
+use super::policy::NameserverPolicies;
 use super::{
     CacheValue, ClassifiedDnsQuery, DnsCache, DnsError, DnsMessage, DnsQueryKind, MAX_ANSWERS,
-    MAX_CACHE_ENTRIES, MAX_MESSAGE_SIZE, MAX_REDIR_HOST_ENTRIES, MAX_RESPONSE_RECORDS,
-    MIN_TTL_SECS, OpaqueDnsCache, QueryType, RecordData, RedirHostHints, ValidatedOpaqueResponse,
-    WireQuestion, build_query, canonicalize_name, classify_query, parse_query, parse_response,
-    synthesize_servfail_response, validate_opaque_response, validate_response_identity,
+    MAX_MESSAGE_SIZE, MAX_REDIR_HOST_ENTRIES, MAX_RESPONSE_RECORDS, MIN_TTL_SECS, QueryType,
+    RecordData, RedirHostHints, ValidatedOpaqueResponse, WireQuestion, build_query,
+    canonicalize_name, classify_query, parse_query, parse_response, synthesize_servfail_response,
+    validate_opaque_response, validate_response_identity,
 };
 use crate::{
     config::{
-        DnsConfig, DnsNameserver, DnsNameserverPolicy, DnsRoute, DnsTransport, Network,
-        RouteTargetId, RuleAction,
+        DnsAddress, DnsConfig, DnsNameserver, DnsNameserverPolicy, DnsRoute, DnsTransport,
+        HostValue, Network, RouteTargetId, RuleAction,
     },
     dispatch::{BoxStream, DispatchError, Dispatcher},
     resources::{ResourceActivity, ResourceActivityGuard, RuntimeResourceStats},
     routing::{
-        EmptyGeoMatcher, GeoMatcher, ProxyDispatchers, RoutingContext, RuleEvaluation, RuleSet,
+        EmptyGeoMatcher, GeoMatcher, ProgramEvaluation, ProxyDispatchers, RoutingContext, RuleSet,
+        RuleTargetEffect,
     },
     session::{Datagram, DatagramSession, Destination, InboundKind, StreamSession},
 };
 
+fn system_ech_config() -> DnsConfig {
+    let server = DnsNameserver {
+        transport: DnsTransport::Udp,
+        address: DnsAddress::Source(crate::config::DnsSource::System),
+        port: 53,
+        route: DnsRoute::Direct,
+        path: None,
+        http_auth: None,
+        options: Default::default(),
+    };
+    DnsConfig {
+        enable: true,
+        nameservers: vec![server.clone()],
+        default_nameservers: vec![server],
+        cache_max_size: 64,
+        ..Default::default()
+    }
+}
+
 const UPSTREAM_TIMEOUT: Duration = Duration::from_secs(3);
 const QUERY_TIMEOUT: Duration = Duration::from_secs(5);
 const UDP_RETRY_DELAY: Duration = Duration::from_secs(1);
@@ -63,11 +96,17 @@ const RCODE_SERVFAIL: u8 = 2;
 const RCODE_NXDOMAIN: u8 = 3;
 const RCODE_REFUSED: u8 = 5;
 
+fn dot_reuse_disabled(nameserver: &DnsNameserver) -> bool {
+    nameserver.transport == DnsTransport::Tls && nameserver.options.disable_reuse
+}
+
 /// Errors returned by the runtime DNS service.
 #[derive(Debug, Clone, thiserror::Error)]
 pub enum RuntimeDnsError {
     #[error("runtime DNS is disabled")]
     Disabled,
+    #[error("DNS rule evaluation failed: {0}")]
+    RuleEvaluation(#[from] crate::config::MatchFailure),
     #[error("runtime DNS has no nameserver")]
     NoNameserver,
     #[error("invalid DNS query: {0}")]
@@ -87,35 +126,80 @@ pub enum RuntimeDnsError {
 pub struct RuntimeDns {
     enabled: bool,
     ipv6: bool,
+    prefer_h3: bool,
+    ipv6_timeout: Duration,
     nameservers: Box<[DnsNameserver]>,
+    hosts: super::hosts::Hosts,
+    fallback: crate::config::DnsFallbackConfig,
+    fallback_filter: super::fallback::Filter,
+    fake_config: crate::config::FakeIpConfig,
+    fake_filter: super::fake_ip::Filter,
+    fake_pools: Option<Arc<super::fake_ip::FakePools>>,
+    bootstrap: Option<Arc<RuntimeDns>>,
+    node_bootstrap: Option<super::resolution::ResolutionContext>,
+    proxy_resolver: Option<Arc<RuntimeDns>>,
+    direct_resolver: Option<Arc<RuntimeDns>>,
+    ech_system_resolver: Option<Arc<RuntimeDns>>,
     nameserver_policies: Box<[DnsNameserverPolicy]>,
+    policy_index: NameserverPolicies,
     geo_matcher: Arc<dyn GeoMatcher>,
     egress: DnsEgress,
     cache: Mutex<DnsCache>,
-    opaque_cache: Mutex<OpaqueDnsCache>,
+    cache_epoch: Arc<RwLock<u64>>,
+    sources: Arc<super::source::NetworkSources>,
+    source_dialer: Option<crate::dialer::Dialer>,
+    source_exclusions: super::source::SourceExclusions,
     // Hint lookup and insertion are bounded synchronous work. Keep this
     // shared TUN hot path free of asynchronous mutex scheduling.
-    hints: Option<StdMutex<RedirHostHints>>,
+    hints: Option<Arc<StdMutex<RedirHostHints>>>,
+    // Retired policy trees may answer their pinned flows but cannot refill
+    // the active generation's shared address-to-domain mapping.
+    hints_writable: AtomicBool,
     singleflight: Arc<SingleflightRegistry>,
     tcp_pool: Arc<TcpConnectionPool>,
     next_id: AtomicU16,
     resource_stats: RuntimeResourceStats,
+    refresh: OnceLock<RefreshBinding>,
+}
+
+struct RefreshBinding {
+    resolver: Weak<RuntimeDns>,
+    owner: Arc<refresh::Owner>,
+}
+
+impl Drop for RuntimeDns {
+    fn drop(&mut self) {
+        if let Some(binding) = self.refresh.get() {
+            binding.owner.close();
+        }
+    }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 enum DnsEgressKey {
     Single,
     Direct,
+    Reject,
+    RejectDrop,
     Route(RouteTargetId),
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 struct TcpPoolKey {
+    upstream: DnsNameserver,
     endpoint: SocketAddr,
     egress: DnsEgressKey,
+    source_generation: u64,
+    source_binding: Option<super::source::DnsBinding>,
 }
 
 struct TcpConnectionPool {
+    security: crate::security::SecurityContext,
+    http2: Arc<super::http2::Pool<TcpPoolKey>>,
+    #[cfg(feature = "dns-quic")]
+    quic: Arc<super::quic::Pool<TcpPoolKey>>,
+    #[cfg(feature = "dns-quic")]
+    http_tcp_choices: StdMutex<Vec<(TcpPoolKey, TokioInstant)>>,
     state: Mutex<TcpPoolState>,
     max_idle: usize,
     max_idle_per_key: usize,
@@ -137,6 +221,7 @@ struct IdleTcpConnection {
 
 struct PooledTcpConnection {
     stream: BoxStream,
+    negotiated_alpn: Option<Vec<u8>>,
     _slot: TcpPhysicalSlot,
     _observation: crate::resources::observation::Guard,
 }
@@ -201,13 +286,19 @@ struct TcpPoolSnapshot {
 }
 
 impl TcpConnectionPool {
-    fn new() -> Arc<Self> {
+    fn new(security: crate::security::SecurityContext) -> Arc<Self> {
         let max_idle = TCP_POOL_MAX_IDLE;
         let max_idle_per_key = TCP_POOL_MAX_IDLE_PER_KEY;
         let mut stats = TcpPoolStats::default();
         stats.idle_limit = max_idle;
         stats.idle_per_key_limit = max_idle_per_key;
         Arc::new(Self {
+            security,
+            http2: super::http2::Pool::new(),
+            #[cfg(feature = "dns-quic")]
+            quic: super::quic::Pool::new(),
+            #[cfg(feature = "dns-quic")]
+            http_tcp_choices: StdMutex::new(Vec::new()),
             state: Mutex::new(TcpPoolState::default()),
             max_idle,
             max_idle_per_key,
@@ -217,28 +308,45 @@ impl TcpConnectionPool {
         })
     }
 
-    async fn checkout(
+    async fn checkout_for(
         self: &Arc<Self>,
-        key: TcpPoolKey,
-        nameserver: DnsNameserver,
-        egress: &Arc<dyn Dispatcher>,
+        nameserver: &ResolvedNameserver,
+        resolve: impl FnOnce(&TcpPoolState) -> Result<(DnsEgressKey, Arc<dyn Dispatcher>), AttemptError>,
     ) -> Result<TcpLease, AttemptError> {
-        let (connection, expired) = {
+        if self.http2.is_closed() {
+            return Err(io::Error::from(io::ErrorKind::BrokenPipe).into());
+        }
+        let (key, egress, connection, expired) = {
             let mut state = self.state.lock().await;
             let expired = self.take_expired_locked(&mut state, TokioInstant::now());
+            // Resolve and remove an idle connection in one transaction. The
+            // callback commits a group only when this stable route key is absent.
+            let (egress_key, egress) = match resolve(&state) {
+                Ok(route) => route,
+                Err(error) => {
+                    self.record_idle_locked(&state);
+                    return Err(error);
+                }
+            };
+            let key = TcpPoolKey {
+                upstream: nameserver.config.clone(),
+                endpoint: nameserver.endpoint(),
+                egress: egress_key,
+                source_generation: nameserver.source_generation,
+                source_binding: nameserver.source_binding.clone(),
+            };
             let index = state
                 .idle
                 .iter()
                 .enumerate()
-                .filter(|(_, idle)| idle.key == key)
+                .filter(|(_, idle)| !dot_reuse_disabled(&nameserver.config) && idle.key == key)
                 .max_by_key(|(_, idle)| idle.idle_since)
                 .map(|(index, _)| index);
             let connection = index.map(|index| state.idle.swap_remove(index).connection);
             self.record_idle_locked(&state);
-            (connection, expired)
+            (key, egress, connection, expired)
         };
         drop(expired);
-
         if let Some(connection) = connection {
             self.stats.reuse_hits.fetch_add(1, Ordering::Relaxed);
             return Ok(TcpLease {
@@ -249,8 +357,7 @@ impl TcpConnectionPool {
                 stats: Arc::clone(&self.stats),
             });
         }
-
-        let connection = self.open_connection(nameserver, egress).await?;
+        let connection = self.open_connection(nameserver, &egress).await?;
         Ok(TcpLease {
             key,
             connection: Some(connection),
@@ -260,25 +367,90 @@ impl TcpConnectionPool {
         })
     }
 
+    #[cfg(feature = "dns-quic")]
+    fn tcp_selected(&self, key: &TcpPoolKey) -> bool {
+        let mut choices = self.http_tcp_choices.lock().unwrap();
+        let now = TokioInstant::now();
+        choices.retain(|(_, used)| now.duration_since(*used) < TCP_POOL_IDLE_TIMEOUT);
+        if let Some((_, used)) = choices.iter_mut().find(|(candidate, _)| candidate == key) {
+            *used = now;
+            true
+        } else {
+            false
+        }
+    }
+
+    #[cfg(feature = "dns-quic")]
+    fn select_tcp(&self, key: TcpPoolKey) {
+        let mut choices = self.http_tcp_choices.lock().unwrap();
+        choices.retain(|(candidate, _)| *candidate != key);
+        if choices.len() == TCP_POOL_MAX_IDLE {
+            choices.remove(0);
+        }
+        choices.push((key, TokioInstant::now()));
+    }
+
+    #[cfg(feature = "dns-quic")]
+    fn forget_tcp(&self, key: &TcpPoolKey) {
+        self.http_tcp_choices
+            .lock()
+            .unwrap()
+            .retain(|(candidate, _)| candidate != key);
+    }
+
     async fn open_connection(
         &self,
-        nameserver: DnsNameserver,
+        nameserver: &ResolvedNameserver,
         egress: &Arc<dyn Dispatcher>,
     ) -> Result<PooledTcpConnection, AttemptError> {
+        if self.http2.is_closed() {
+            return Err(io::Error::from(io::ErrorKind::BrokenPipe).into());
+        }
         let slot = TcpPhysicalSlot::new(Arc::clone(&self.stats));
         let connecting = TcpConnectingGuard::new(Arc::clone(&self.stats));
         let stream = egress
             .connect_tcp(StreamSession {
+                metadata: Default::default(),
                 inbound: InboundKind::InternalDns,
-                source: internal_source(nameserver.address),
+                source: internal_source(nameserver.endpoint.ip()),
                 destination: Destination::Ip(nameserver.endpoint()),
                 sniffed_domain: None,
             })
             .await?;
+        let (stream, negotiated_alpn) = if matches!(
+            nameserver.transport,
+            DnsTransport::Tls | DnsTransport::Https
+        ) {
+            let options = crate::security::TlsClientOptions {
+                certificate: crate::config::TlsCertificatePolicy {
+                    verification_name: nameserver.options.verification_name.clone(),
+                    skip_cert_verify: nameserver.options.skip_cert_verify,
+                    fingerprint: None,
+                },
+                alpn: if nameserver.transport == DnsTransport::Https {
+                    vec![b"h2".to_vec(), b"http/1.1".to_vec()]
+                } else {
+                    Vec::new()
+                },
+                ..Default::default()
+            };
+            crate::security::StandardTlsClient::with_options(
+                &self.security,
+                nameserver.address.to_string(),
+                options,
+                0,
+                64 * 1024,
+            )?
+            .connect_negotiated(stream)
+            .await?
+        } else {
+            (stream, None)
+        };
         drop(connecting);
         self.stats.physical_opens.fetch_add(1, Ordering::Relaxed);
         Ok(PooledTcpConnection {
             stream,
+            negotiated_alpn,
             _slot: slot,
             _observation: crate::resources::observation::track(
                 crate::resources::observation::ResourceKind::Pool,
@@ -289,7 +461,7 @@ impl TcpConnectionPool {
     async fn replace_stale(
         &self,
         lease: &mut TcpLease,
-        nameserver: DnsNameserver,
+        nameserver: &ResolvedNameserver,
         egress: &Arc<dyn Dispatcher>,
     ) -> Result<(), AttemptError> {
         if lease.connection.take().is_some() {
@@ -308,7 +480,7 @@ impl TcpConnectionPool {
             return;
         };
         lease.busy.take();
-        if self.max_idle == 0 {
+        if self.http2.is_closed() || self.max_idle == 0 || dot_reuse_disabled(&lease.key.upstream) {
             drop(connection);
             return;
         }
@@ -325,7 +497,7 @@ impl TcpConnectionPool {
             .count()
             >= self.max_idle_per_key
         {
-            let Some(index) = oldest_idle_index_for_key(&state.idle, lease.key) else {
+            let Some(index) = oldest_idle_index_for_key(&state.idle, lease.key.clone()) else {
                 break;
             };
             discarded.push(state.idle.swap_remove(index).connection);
@@ -340,7 +512,7 @@ impl TcpConnectionPool {
         }
 
         state.idle.push(IdleTcpConnection {
-            key: lease.key,
+            key: lease.key.clone(),
             connection,
             idle_since: now,
         });
@@ -448,6 +620,9 @@ impl TcpConnectionPool {
 
 impl Drop for TcpConnectionPool {
     fn drop(&mut self) {
+        self.http2.close();
+        #[cfg(feature = "dns-quic")]
+        self.quic.close();
         self.reaper_cancel.cancel();
         let idle = std::mem::take(&mut self.state.get_mut().idle);
         self.stats.current_idle.store(0, Ordering::Release);
@@ -551,13 +726,15 @@ type SharedDnsResult = Result<Arc<[u8]>, RuntimeDnsError>;
 struct SingleflightKey {
     question: WireQuestion,
     semantics_digest: [u8; 32],
+    epoch: u64,
 }
 
-impl From<&ClassifiedDnsQuery> for SingleflightKey {
-    fn from(query: &ClassifiedDnsQuery) -> Self {
+impl SingleflightKey {
+    fn new(query: &ClassifiedDnsQuery, epoch: u64) -> Self {
         Self {
             question: query.question.clone(),
             semantics_digest: query.semantics_digest,
+            epoch,
         }
     }
 }
@@ -625,6 +802,26 @@ impl SingleflightRegistry {
         })
     }
 
+    fn try_lead(self: &Arc<Self>, key: SingleflightKey) -> Option<FlightLeaderGuard> {
+        let mut flights = self
+            .flights
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
+        if flights.contains_key(&key) {
+            return None;
+        }
+        let (updates, _) = watch::channel(FlightUpdate::Pending);
+        let state = Arc::new(FlightState { updates });
+        flights.insert(key.clone(), state.clone());
+        Some(FlightLeaderGuard {
+            registry: self.clone(),
+            key,
+            state,
+            activity: Some(self.resource_stats.begin(ResourceActivity::Singleflight)),
+            completed: false,
+        })
+    }
+
     #[cfg(test)]
     fn len(&self) -> usize {
         self.flights
@@ -698,6 +895,15 @@ async fn wait_for_flight(mut updates: watch::Receiver<FlightUpdate>) -> Option<S
 pub(crate) struct DnsQueryPermit {
     _activity: ResourceActivityGuard,
     deadline: TokioInstant,
+    decision: crate::config::RuleDecision,
+}
+
+impl DnsQueryPermit {
+    #[cfg(feature = "tun")]
+    pub(crate) fn with_cancellation(self, token: tokio_util::sync::CancellationToken) -> Self {
+        self.decision.set_cancellation(token);
+        self
+    }
 }
 
 /// One DNS wire response that can retain its query observation until the caller
@@ -720,7 +926,7 @@ impl DnsWireResponse {
         &self.wire
     }
 
-    fn into_wire(self) -> Vec<u8> {
+    pub(crate) fn into_wire(self) -> Vec<u8> {
         self.wire
     }
 
@@ -739,6 +945,7 @@ enum FailureMode {
     BoundedError,
 }
 
+#[derive(Clone)]
 enum DnsEgress {
     /// Kept for focused unit tests and embedders that deliberately provide one
     /// already-selected dispatcher.
@@ -764,6 +971,399 @@ impl fmt::Debug for RuntimeDns {
 }
 
 impl RuntimeDns {
+    pub(crate) fn network_sources(&self) -> Arc<super::source::NetworkSources> {
+        self.sources.clone()
+    }
+    pub(crate) fn with_network_sources(
+        mut self,
+        dialer: crate::dialer::Dialer,
+        exclusions: super::source::SourceExclusions,
+    ) -> Self {
+        self.sources = dialer.dns_sources();
+        self.source_dialer = Some(dialer);
+        self.source_exclusions = exclusions;
+        self.share_cache_epoch(self.sources.epoch());
+        self
+    }
+    pub(crate) fn with_mapping_from(mut self, previous: Option<&Self>) -> Self {
+        if let Some(previous) = previous {
+            if previous.hints.is_some() {
+                self.hints = previous.hints.clone();
+            }
+            self.sources = previous.sources.clone();
+            self.share_cache_epoch(previous.cache_epoch.clone());
+            if self.fake_config.enabled == previous.fake_config.enabled
+                && self.fake_config.range == previous.fake_config.range
+                && self.fake_config.range6 == previous.fake_config.range6
+                && let Some(previous_pools) = previous.fake_pools.as_ref()
+                && self
+                    .fake_pools
+                    .as_ref()
+                    .is_none_or(|pools| pools.same_address_families(previous_pools))
+            {
+                self.fake_pools = Some(previous_pools.clone());
+            }
+        }
+        self
+    }
+    // Resource replacement consumes a freshly assembled tree. Release the
+    // leaves' shared bootstrap references before mutating that owned node.
+    fn share_cache_epoch(&mut self, epoch: Arc<RwLock<u64>>) {
+        let mut roles = [
+            self.proxy_resolver.take(),
+            self.direct_resolver.take(),
+            self.ech_system_resolver.take(),
+        ];
+        for role in roles.iter_mut().flatten() {
+            Arc::get_mut(role)
+                .expect("fresh DNS role is exclusively owned")
+                .bootstrap = None;
+        }
+        if let Some(bootstrap) = &mut self.bootstrap {
+            let bootstrap =
+                Arc::get_mut(bootstrap).expect("fresh DNS bootstrap is exclusively owned");
+            bootstrap.cache_epoch = epoch.clone();
+            bootstrap.sources = self.sources.clone();
+            bootstrap.source_dialer = self.source_dialer.clone();
+            bootstrap.source_exclusions = self.source_exclusions.clone();
+        }
+        for role in roles.iter_mut().flatten() {
+            let role = Arc::get_mut(role).expect("fresh DNS role is exclusively owned");
+            role.cache_epoch = epoch.clone();
+            role.sources = self.sources.clone();
+            role.source_dialer = self.source_dialer.clone();
+            role.source_exclusions = self.source_exclusions.clone();
+            role.bootstrap = self.bootstrap.clone();
+        }
+        [
+            self.proxy_resolver,
+            self.direct_resolver,
+            self.ech_system_resolver,
+        ] = roles;
+        self.cache_epoch = epoch;
+    }
+
+    /// Bind only after graph/configuration assembly: weak links must not
+    /// invalidate Arc::get_mut used while constructing the resolver roles.
+    pub(crate) fn enable_refresh(self: &Arc<Self>, previous: Option<&Self>) {
+        if self.refresh.get().is_some() {
+            return;
+        }
+        let parent = self
+            .node_bootstrap
+            .as_ref()
+            .and_then(super::resolution::ResolutionContext::runtime_dns);
+        let budget = previous
+            .or(parent.as_deref())
+            .and_then(|dns| dns.refresh.get())
+            .map(|binding| binding.owner.budget.clone());
+        let owner = refresh::Owner::new(budget);
+        let mut pending = vec![self.clone()];
+        let mut seen = HashSet::new();
+        while let Some(resolver) = pending.pop() {
+            if !seen.insert(Arc::as_ptr(&resolver) as usize) {
+                continue;
+            }
+            assert!(
+                resolver
+                    .refresh
+                    .set(RefreshBinding {
+                        resolver: Arc::downgrade(&resolver),
+                        owner: owner.clone(),
+                    })
+                    .is_ok(),
+                "DNS refresh roles must have one owner"
+            );
+            pending.extend(
+                [
+                    resolver.bootstrap.clone(),
+                    resolver.proxy_resolver.clone(),
+                    resolver.direct_resolver.clone(),
+                    resolver.ech_system_resolver.clone(),
+                ]
+                .into_iter()
+                .flatten(),
+            );
+        }
+    }
+
+    fn refresh_stale(
+        &self,
+        query: &[u8],
+        classified: &ClassifiedDnsQuery,
+        epoch: u64,
+        cache: &mut DnsCache,
+    ) {
+        let Some(binding) = self.refresh.get() else {
+            return;
+        };
+        let Some(permit) = binding.owner.reserve() else {
+            return;
+        };
+        if !cache.reserve_refresh(classified, Instant::now(), refresh::BACKOFF) {
+            return;
+        }
+        let Some(leader) = self
+            .singleflight
+            .try_lead(SingleflightKey::new(classified, epoch))
+        else {
+            return;
+        };
+        let resolver = binding.resolver.clone();
+        let query = query.to_vec();
+        let classified = classified.clone();
+        binding.owner.spawn(permit, async move {
+            let Some(resolver) = resolver.upgrade() else {
+                return;
+            };
+            let permit = resolver.begin_query();
+            let exchange = permit.decision.scope(async {
+                match classified.kind {
+                    DnsQueryKind::Address(_) => {
+                        resolver
+                            .exchange_address_leader(&query, &classified, permit.deadline, epoch)
+                            .await
+                    }
+                    DnsQueryKind::Opaque => {
+                        resolver
+                            .exchange_opaque_leader(&query, &classified, permit.deadline, epoch)
+                            .await
+                    }
+                }
+            });
+            let result = timeout_at(permit.deadline, Box::pin(exchange))
+                .await
+                .unwrap_or_else(|_| {
+                    Err(RuntimeDnsError::UpstreamsExhausted {
+                        last_error: "runtime DNS total query deadline expired".into(),
+                    })
+                })
+                .map(Arc::<[u8]>::from);
+            let current = resolver.cache_epoch.read().await;
+            if *current == epoch {
+                resolver.cache.lock().await.finish_refresh(
+                    &classified,
+                    Instant::now(),
+                    refresh::BACKOFF,
+                );
+            }
+            leader.complete(result);
+        });
+    }
+
+    fn stale_hints(&self, response: &DnsMessage) -> Result<(), RuntimeDnsError> {
+        if self.hints_writable.load(Ordering::Acquire)
+            && let Some(hints) = &self.hints
+        {
+            let answers =
+                matching_answer_set(response).map_err(RuntimeDnsError::InvalidResponse)?;
+            let mut hints = hints
+                .lock()
+                .unwrap_or_else(std::sync::PoisonError::into_inner);
+            for address in answers.addresses {
+                hints
+                    .insert(address, &response.question.name, 1, Instant::now())
+                    .map_err(RuntimeDnsError::Cache)?;
+            }
+        }
+        Ok(())
+    }
+
+    /// Clears typed and wire results and redir-host hints for every DNS role.
+    /// Fake-IP mappings, active queries and upstream connections stay live.
+    /// Queries admitted before this boundary cannot refill cleared state.
+    pub async fn flush_cache(&self) {
+        let mut epoch = self.cache_epoch.write().await;
+        // Advance before clearing so cancellation during shutdown cannot
+        // allow an old leader to repopulate a partially cleared tree.
+        *epoch = epoch.wrapping_add(1);
+        self.clear_cache_tree().await;
+    }
+
+    /// Keep active reverse mappings, but start fresh forward assignments.
+    /// Hold the shared epoch until the durable transaction has been joined.
+    pub(crate) async fn flush_fake_ip(&self) -> io::Result<()> {
+        let mut epoch = self.cache_epoch.write().await;
+        *epoch = epoch.wrapping_add(1);
+        self.clear_cache_tree().await;
+        if let Some(pools) = self.fake_pools.clone() {
+            tokio::task::spawn_blocking(move || pools.flush_forward())
+                .await
+                .map_err(|_| io::Error::other("fake-IP maintenance failed"))??;
+        }
+        Ok(())
+    }
+
+    /// Keep this guard until the resource generation has been published. Cache
+    /// admission/refill observes the same boundary as network-source updates.
+    #[cfg(any(feature = "invoke", test))]
+    pub(crate) async fn configuration_publication(&self) -> tokio::sync::RwLockWriteGuard<'_, u64> {
+        let mut epoch = self.cache_epoch.write().await;
+        *epoch = epoch.wrapping_add(1);
+        self.clear_cache_tree().await;
+        epoch
+    }
+
+    /// Called only while the common cache epoch is exclusively held. A pinned
+    /// old tree can start another query after publication; epoch alone would
+    /// not prevent that query from adding an old-policy hint to the shared map.
+    #[cfg(any(feature = "invoke", test))]
+    pub(crate) fn retire_configuration_hints(&self) {
+        let mut pending = vec![self];
+        let mut seen = HashSet::new();
+        while let Some(resolver) = pending.pop() {
+            if !seen.insert(std::ptr::from_ref(resolver) as usize) {
+                continue;
+            }
+            resolver.hints_writable.store(false, Ordering::Release);
+            if let Some(binding) = resolver.refresh.get() {
+                binding.owner.close();
+            }
+            pending.extend(
+                [
+                    resolver.bootstrap.as_deref(),
+                    resolver.proxy_resolver.as_deref(),
+                    resolver.direct_resolver.as_deref(),
+                    resolver.ech_system_resolver.as_deref(),
+                ]
+                .into_iter()
+                .flatten(),
+            );
+        }
+    }
+
+    pub(super) async fn clear_cache_tree(&self) {
+        let mut pending = vec![self];
+        let mut seen = HashSet::new();
+        while let Some(resolver) = pending.pop() {
+            if !seen.insert(std::ptr::from_ref(resolver) as usize) {
+                continue;
+            }
+            resolver.cache.lock().await.clear();
+            if let Some(hints) = &resolver.hints {
+                hints
+                    .lock()
+                    .unwrap_or_else(std::sync::PoisonError::into_inner)
+                    .clear();
+            }
+            pending.extend(
+                [
+                    resolver.bootstrap.as_deref(),
+                    resolver.proxy_resolver.as_deref(),
+                    resolver.direct_resolver.as_deref(),
+                    resolver.ech_system_resolver.as_deref(),
+                ]
+                .into_iter()
+                .flatten(),
+            );
+        }
+    }
+
+    /// Retires multiplexed transports before outbound shutdown begins.
+    pub(crate) fn begin_shutdown(&self) {
+        let mut pending = vec![self];
+        let mut seen = HashSet::new();
+        while let Some(resolver) = pending.pop() {
+            if !seen.insert(std::ptr::from_ref(resolver) as usize) {
+                continue;
+            }
+            if let Some(binding) = resolver.refresh.get() {
+                binding.owner.close();
+            }
+            resolver.tcp_pool.http2.close();
+            #[cfg(feature = "dns-quic")]
+            resolver.tcp_pool.quic.close();
+            #[cfg(feature = "dns-quic")]
+            resolver.tcp_pool.http_tcp_choices.lock().unwrap().clear();
+            resolver.tcp_pool.reaper_cancel.cancel();
+            pending.extend(
+                [
+                    resolver.bootstrap.as_deref(),
+                    resolver.proxy_resolver.as_deref(),
+                    resolver.direct_resolver.as_deref(),
+                    resolver.ech_system_resolver.as_deref(),
+                ]
+                .into_iter()
+                .flatten(),
+            );
+        }
+    }
+
+    pub(crate) async fn shutdown(&self) {
+        self.begin_shutdown();
+        let mut pending = vec![self];
+        let mut seen = HashSet::new();
+        while let Some(resolver) = pending.pop() {
+            if !seen.insert(std::ptr::from_ref(resolver) as usize) {
+                continue;
+            }
+            if let Some(binding) = resolver.refresh.get() {
+                binding.owner.shutdown().await;
+            }
+            resolver.tcp_pool.http2.shutdown().await;
+            #[cfg(feature = "dns-quic")]
+            resolver.tcp_pool.quic.shutdown().await;
+            let idle = {
+                let mut state = resolver.tcp_pool.state.lock().await;
+                let idle = std::mem::take(&mut state.idle);
+                resolver.tcp_pool.record_idle_locked(&state);
+                idle
+            };
+            drop(idle);
+            pending.extend(
+                [
+                    resolver.bootstrap.as_deref(),
+                    resolver.proxy_resolver.as_deref(),
+                    resolver.direct_resolver.as_deref(),
+                    resolver.ech_system_resolver.as_deref(),
+                ]
+                .into_iter()
+                .flatten(),
+            );
+        }
+    }
+
+    pub(crate) fn with_fake_ip_store(mut self, root: Option<&std::path::Path>) -> io::Result<Self> {
+        if self.enabled
+            && self.fake_config.enabled
+            && let Some(root) = root
+        {
+            if self
+                .fake_pools
+                .as_ref()
+                .map(|pools| pools.has_persistent_store())
+                .transpose()?
+                .unwrap_or(false)
+            {
+                return Ok(self);
+            }
+            self.fake_pools = Some(Arc::new(super::fake_ip::FakePools::open(
+                &self.fake_config,
+                self.ipv6,
+                Some(&root.join("fake-ip.redb")),
+            )?));
+        }
+        Ok(self)
+    }
+
+    pub(crate) fn recover_fake_ip(&self, address: IpAddr) -> io::Result<Option<String>> {
+        self.fake_pools
+            .as_ref()
+            .map_or(Ok(None), |pool| pool.recover(address))
+    }
+
+    fn use_fake_ip(&self, host: &str) -> Result<bool, RuntimeDnsError> {
+        if self.fake_pools.is_none() {
+            return Ok(false);
+        }
+        let snapshot = self.geo_matcher.routing_snapshot();
+        Ok(!self.fake_filter.skips(
+            host,
+            snapshot.as_deref().unwrap_or(self.geo_matcher.as_ref()),
+            &crate::config::RuleDecision::default(),
+        )?)
+    }
+
     /// Creates a resolver whose upstream traffic uses one preselected
     /// dispatcher and no GeoData matcher. Production runtimes use
     /// [`Self::new_routed`].
@@ -772,6 +1372,69 @@ impl RuntimeDns {
         Self::new_with_geo_matcher(config, dispatcher, Arc::new(EmptyGeoMatcher))
     }
 
+    /// A raw-IP node's private resolver uses its own data plane, while DNS
+    /// server domains bootstrap through the Core's original proxy DNS role.
+    #[cfg(any(feature = "outbound-wireguard", feature = "outbound-masque"))]
+    pub(crate) fn new_for_node(
+        config: &DnsConfig,
+        dispatcher: Arc<dyn Dispatcher>,
+        bootstrap: super::resolution::ResolutionContext,
+        security: crate::security::SecurityContext,
+    ) -> Self {
+        let mut resolver = Self::assemble_leaf(
+            config,
+            DnsEgress::Single(dispatcher),
+            Arc::new(EmptyGeoMatcher),
+            config.cache_max_size,
+            0,
+            Arc::new(RwLock::new(0)),
+            security,
+        );
+        resolver.node_bootstrap = Some(bootstrap);
+        // No idle background reaper belongs to this private node resolver.
+        // Foreground queries remain caller-owned. The raw-IP engine joins
+        // bounded refresh work and transport drivers through DNS shutdown.
+        let pool = Arc::get_mut(&mut resolver.tcp_pool).expect("fresh node DNS pool");
+        pool.max_idle = 0;
+        pool.max_idle_per_key = 0;
+        pool.http2.disable_idle();
+        #[cfg(feature = "dns-quic")]
+        pool.quic.disable_idle();
+        let stats = Arc::get_mut(&mut pool.stats).expect("fresh node DNS counters");
+        stats.idle_limit = 0;
+        stats.idle_per_key_limit = 0;
+        resolver
+    }
+
+    /// MASQUE keeps special system/DHCP sources physical. Share only an
+    /// already protected runtime source and register the private cache without
+    /// retaining that runtime or a retired resource generation.
+    #[cfg(feature = "outbound-masque")]
+    pub(crate) fn new_for_masque_node(
+        config: &DnsConfig,
+        dispatcher: Arc<dyn Dispatcher>,
+        bootstrap: super::resolution::ResolutionContext,
+        security: crate::security::SecurityContext,
+    ) -> Arc<Self> {
+        let physical = config
+            .nameservers
+            .iter()
+            .any(|nameserver| matches!(nameserver.address, DnsAddress::Source(_)))
+            .then(|| bootstrap.runtime_dns())
+            .flatten();
+        let mut resolver = Self::new_for_node(config, dispatcher, bootstrap, security);
+        if let Some(physical) = physical.filter(|resolver| resolver.source_dialer.is_some()) {
+            resolver.sources = physical.sources.clone();
+            resolver.source_dialer = physical.source_dialer.clone();
+            resolver.source_exclusions = physical.source_exclusions.clone();
+            resolver.share_cache_epoch(physical.cache_epoch.clone());
+        }
+        let resolver = Arc::new(resolver);
+        resolver.enable_refresh(None);
+        resolver.sources.register(&resolver);
+        resolver
+    }
+
     /// Creates a single-egress resolver with an explicit GeoData matcher.
     /// This is useful to embedders that need nameserver-policy without the
     /// built-in DIRECT/proxy dispatcher registry.
@@ -785,8 +1448,9 @@ impl RuntimeDns {
             config,
             DnsEgress::Single(dispatcher),
             geo_matcher,
-            MAX_CACHE_ENTRIES,
+            config.cache_max_size,
             MAX_REDIR_HOST_ENTRIES,
+            crate::security::SecurityContext::new(),
         )
     }
 
@@ -826,7 +1490,7 @@ impl RuntimeDns {
             direct,
             rules,
             geo_matcher,
-            MAX_CACHE_ENTRIES,
+            config.cache_max_size,
             MAX_REDIR_HOST_ENTRIES,
         )
     }
@@ -841,6 +1505,29 @@ impl RuntimeDns {
         geo_matcher: Arc<dyn GeoMatcher>,
         address_cache_entries: usize,
         redir_host_entries: usize,
+    ) -> Self {
+        Self::new_routed_proxies_with_cache_limits_and_security(
+            config,
+            proxies,
+            direct,
+            rules,
+            geo_matcher,
+            address_cache_entries,
+            redir_host_entries,
+            crate::security::SecurityContext::new(),
+        )
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn new_routed_proxies_with_cache_limits_and_security(
+        config: &DnsConfig,
+        proxies: ProxyDispatchers,
+        direct: Arc<dyn Dispatcher>,
+        rules: RuleSet,
+        geo_matcher: Arc<dyn GeoMatcher>,
+        address_cache_entries: usize,
+        redir_host_entries: usize,
+        security: crate::security::SecurityContext,
     ) -> Self {
         debug_assert!(address_cache_entries != 0);
         Self::assemble(
@@ -853,64 +1540,238 @@ impl RuntimeDns {
             geo_matcher,
             address_cache_entries,
             redir_host_entries,
+            security,
         )
     }
 
     fn assemble(
+        config: &DnsConfig,
+        egress: DnsEgress,
+        geo: Arc<dyn GeoMatcher>,
+        cache: usize,
+        hints: usize,
+        security: crate::security::SecurityContext,
+    ) -> Self {
+        let sources = Arc::new(super::source::NetworkSources::default());
+        let cache_epoch = sources.epoch();
+        let mut bootstrap_config = config.clone();
+        bootstrap_config.enable = true;
+        bootstrap_config.fallback = crate::config::DnsFallbackConfig::default();
+        bootstrap_config.nameservers = config.default_nameservers.clone();
+        bootstrap_config.nameserver_policies.clear();
+        let bootstrap = Arc::new(Self::assemble_leaf(
+            &bootstrap_config,
+            egress.clone(),
+            geo.clone(),
+            cache,
+            0,
+            cache_epoch.clone(),
+            security.clone(),
+        ));
+        let mut root = Self::assemble_leaf(
+            config,
+            egress.clone(),
+            geo.clone(),
+            cache,
+            hints,
+            cache_epoch.clone(),
+            security.clone(),
+        );
+        root.bootstrap = Some(bootstrap.clone());
+        if config.enable && config.fake_ip.enabled {
+            root.fake_pools = Some(Arc::new(
+                super::fake_ip::FakePools::open(&config.fake_ip, config.ipv6, None)
+                    .expect("validated fake-IP ranges"),
+            ));
+        }
+        let role = |nameservers: &[DnsNameserver], policies: &[DnsNameserverPolicy]| {
+            let mut role_config = config.clone();
+            role_config.nameservers = nameservers.to_vec();
+            role_config.fallback = crate::config::DnsFallbackConfig::default();
+            role_config.nameserver_policies = policies.to_vec();
+            let mut resolver = Self::assemble_leaf(
+                &role_config,
+                egress.clone(),
+                geo.clone(),
+                cache,
+                0,
+                cache_epoch.clone(),
+                security.clone(),
+            );
+            resolver.bootstrap = Some(bootstrap.clone());
+            Arc::new(resolver)
+        };
+        // A disabled address resolver still needs actual HTTPS records for
+        // dynamic ECH. Use physical system metadata, never the default public
+        // nameservers of an otherwise disabled DNS configuration.
+        if !config.enable {
+            let mut system = Self::assemble_leaf(
+                &system_ech_config(),
+                egress.clone(),
+                Arc::new(EmptyGeoMatcher),
+                64,
+                0,
+                cache_epoch.clone(),
+                security.clone(),
+            );
+            let pool = Arc::get_mut(&mut system.tcp_pool).expect("fresh system ECH pool");
+            pool.max_idle = 0;
+            pool.max_idle_per_key = 0;
+            pool.http2.disable_idle();
+            #[cfg(feature = "dns-quic")]
+            pool.quic.disable_idle();
+            let stats = Arc::get_mut(&mut pool.stats).expect("fresh system ECH counters");
+            stats.idle_limit = 0;
+            stats.idle_per_key_limit = 0;
+            root.ech_system_resolver = Some(Arc::new(system));
+        }
+        if !config.proxy_nameservers.is_empty() {
+            root.proxy_resolver = Some(role(&config.proxy_nameservers, &config.proxy_policies));
+        }
+        if !config.direct_nameservers.is_empty() {
+            root.direct_resolver = Some(role(
+                &config.direct_nameservers,
+                if config.direct_follow_policy {
+                    &config.nameserver_policies
+                } else {
+                    &[]
+                },
+            ));
+        }
+        drop(bootstrap);
+        root.sources = sources;
+        root.share_cache_epoch(cache_epoch);
+        root
+    }
+
+    fn assemble_leaf(
         config: &DnsConfig,
         egress: DnsEgress,
         geo_matcher: Arc<dyn GeoMatcher>,
         address_cache_entries: usize,
         redir_host_entries: usize,
+        cache_epoch: Arc<RwLock<u64>>,
+        security: crate::security::SecurityContext,
     ) -> Self {
         let resource_stats = RuntimeResourceStats::new("runtime_dns");
         Self {
             enabled: config.enable,
             ipv6: config.ipv6,
+            prefer_h3: config.prefer_h3,
+            ipv6_timeout: config.ipv6_timeout,
+            hosts: super::hosts::Hosts::new(
+                &config.hosts,
+                config.use_hosts,
+                config.use_system_hosts,
+            ),
+            fallback: config.fallback.clone(),
+            fallback_filter: super::fallback::Filter::new(&config.fallback),
+            fake_config: config.fake_ip.clone(),
+            fake_filter: super::fake_ip::Filter::new(&config.fake_ip),
+            fake_pools: None,
+            bootstrap: None,
+            node_bootstrap: None,
+            proxy_resolver: None,
+            direct_resolver: None,
+            ech_system_resolver: None,
             nameservers: config.nameservers.clone().into_boxed_slice(),
             nameserver_policies: config.nameserver_policies.clone().into_boxed_slice(),
+            policy_index: NameserverPolicies::new(&config.nameserver_policies),
             geo_matcher,
             egress,
-            cache: Mutex::new(DnsCache::with_max_entries(address_cache_entries)),
-            opaque_cache: Mutex::new(OpaqueDnsCache::new()),
-            hints: (redir_host_entries != 0)
-                .then(|| StdMutex::new(RedirHostHints::with_max_entries(redir_host_entries))),
+            cache: Mutex::new(DnsCache::with_algorithm(
+                address_cache_entries,
+                config.cache_algorithm,
+            )),
+            cache_epoch,
+            sources: Arc::new(super::source::NetworkSources::default()),
+            source_dialer: None,
+            source_exclusions: super::source::SourceExclusions::default(),
+            hints: (redir_host_entries != 0).then(|| {
+                Arc::new(StdMutex::new(RedirHostHints::with_max_entries(
+                    redir_host_entries,
+                )))
+            }),
+            hints_writable: AtomicBool::new(true),
             singleflight: SingleflightRegistry::new(resource_stats.clone()),
-            tcp_pool: TcpConnectionPool::new(),
+            tcp_pool: TcpConnectionPool::new(security),
             next_id: AtomicU16::new(1),
             resource_stats,
+            refresh: OnceLock::new(),
         }
     }
 
-    fn nameservers_for(&self, query: &ClassifiedDnsQuery) -> &[DnsNameserver] {
-        if self.nameserver_policies.is_empty() {
-            return &self.nameservers;
+    fn policy_for(
+        &self,
+        query: &ClassifiedDnsQuery,
+    ) -> Result<Option<&[DnsNameserver]>, RuntimeDnsError> {
+        let snapshot = self.geo_matcher.routing_snapshot();
+        let geo = snapshot.as_deref().unwrap_or(self.geo_matcher.as_ref());
+        Ok(self
+            .policy_index
+            .select(
+                &query.question.name,
+                &self.nameserver_policies,
+                geo,
+                &crate::config::RuleDecision::default(),
+            )?
+            .map(|index| self.nameserver_policies[index].nameservers.as_ref()))
+    }
+
+    fn nameservers_for(
+        &self,
+        query: &ClassifiedDnsQuery,
+    ) -> Result<&[DnsNameserver], RuntimeDnsError> {
+        Ok(self.policy_for(query)?.unwrap_or(&self.nameservers))
+    }
+
+    fn fallback_domain(&self, host: &str) -> Result<bool, RuntimeDnsError> {
+        let snapshot = self.geo_matcher.routing_snapshot();
+        Ok(self.fallback_filter.domain(
+            host,
+            snapshot.as_deref().unwrap_or(self.geo_matcher.as_ref()),
+            &crate::config::RuleDecision::default(),
+        )?)
+    }
+
+    fn accepts_primary(
+        &self,
+        result: &Result<(Vec<u8>, DnsMessage, bool), RuntimeDnsError>,
+    ) -> bool {
+        // Rule evaluation failures are terminal; selecting a fallback would hide them.
+        if matches!(result, Err(RuntimeDnsError::RuleEvaluation(_))) {
+            return true;
         }
+        let Ok((_, response, _)) = result else {
+            return false;
+        };
+        let Ok(answers) = matching_answer_set(response) else {
+            return false;
+        };
         let snapshot = self.geo_matcher.routing_snapshot();
-        let geo_matcher = snapshot.as_deref().unwrap_or(self.geo_matcher.as_ref());
-        for (policy_index, policy) in self.nameserver_policies.iter().enumerate() {
-            if policy
-                .geosite_codes
+        let geo = snapshot.as_deref().unwrap_or(self.geo_matcher.as_ref());
+        !answers.addresses.is_empty()
+            && answers
+                .addresses
                 .iter()
-                .any(|code| geo_matcher.matches_geosite(code, &query.question.name))
-            {
-                tracing::debug!(
-                    policy_index,
-                    query_type = query.question.query_type,
-                    event = "runtime_dns_nameserver_policy_match",
-                    "runtime DNS selected a nameserver policy"
-                );
-                return &policy.nameservers;
-            }
-        }
-        &self.nameservers
+                .all(|ip| !self.fallback_filter.address(*ip, geo))
     }
 
     fn egress_for(
         &self,
-        nameserver: DnsNameserver,
+        nameserver: &ResolvedNameserver,
         network: Network,
-    ) -> Result<(DnsEgressKey, &Arc<dyn Dispatcher>), AttemptError> {
+        reuse: impl Fn(DnsEgressKey) -> bool,
+    ) -> Result<(DnsEgressKey, Arc<dyn Dispatcher>), AttemptError> {
+        use crate::routing::proxy_group::InspectedRuleTarget;
+        if let Some(physical) = &nameserver.physical {
+            return Ok((DnsEgressKey::Direct, physical.clone()));
+        }
+        match nameserver.route {
+            DnsRoute::Reject => return Ok((DnsEgressKey::Reject, self.rejection(false))),
+            DnsRoute::RejectDrop => return Ok((DnsEgressKey::RejectDrop, self.rejection(true))),
+            _ => {}
+        }
         let DnsEgress::Routed {
             proxies,
             direct,
@@ -920,68 +1781,320 @@ impl RuntimeDns {
             let DnsEgress::Single(dispatcher) = &self.egress else {
                 unreachable!()
             };
-            return Ok((DnsEgressKey::Single, dispatcher));
+            return Ok((DnsEgressKey::Single, dispatcher.clone()));
         };
-
-        match nameserver.route {
-            DnsRoute::Direct => Ok((DnsEgressKey::Direct, direct)),
-            DnsRoute::Route(id) => proxies
-                .get_route(id)
-                .map(|dispatcher| (DnsEgressKey::Route(id), dispatcher))
-                .map_err(AttemptError::Dispatch),
-            DnsRoute::Rules => {
-                let destination = Destination::Ip(nameserver.endpoint());
-                let context = RoutingContext::new(network, &destination).map_err(|error| {
-                    AttemptError::Dispatch(DispatchError::Other(format!(
-                        "DNS nameserver routing context is invalid: {error}"
-                    )))
-                })?;
-                match rules.evaluate_with_geo(&context, self.geo_matcher.as_ref()) {
-                    RuleEvaluation::Matched(rule_match) => match rule_match.action {
-                        RuleAction::Route(id) => proxies
-                            .get_route(id)
-                            .map(|dispatcher| (DnsEgressKey::Route(id), dispatcher))
-                            .map_err(AttemptError::Dispatch),
-                        RuleAction::Direct => Ok((DnsEgressKey::Direct, direct)),
+        let destination = match &nameserver.address {
+            DnsAddress::Ip(_) => Destination::Ip(nameserver.endpoint()),
+            DnsAddress::Domain(host) => {
+                Destination::domain(host, nameserver.port).map_err(AttemptError::Io)?
+            }
+            DnsAddress::Source(_) => {
+                return Err(AttemptError::Io(super::source::unavailable()));
+            }
+        };
+        let inspect = |id| {
+            proxies.inspect_rule_target(
+                id,
+                network == Network::Udp,
+                !reuse(DnsEgressKey::Route(id)),
+                Some(internal_source(nameserver.endpoint.ip())),
+                Some(&destination),
+                None,
+            )
+        };
+        match nameserver.route {
+            DnsRoute::Reject | DnsRoute::RejectDrop => {
+                unreachable!("handled before egress selection")
+            }
+            DnsRoute::Direct => Ok((DnsEgressKey::Direct, direct.clone())),
+            DnsRoute::Route(id) => match inspect(id).map_err(AttemptError::Dispatch)? {
+                InspectedRuleTarget::Egress(leaf) => Ok((DnsEgressKey::Route(id), leaf.dispatcher)),
+                InspectedRuleTarget::Control(_)
+                | InspectedRuleTarget::Rematch(_)
+                | InspectedRuleTarget::Unavailable => {
+                    Err(AttemptError::Dispatch(DispatchError::NotAllowed))
+                }
+            },
+            DnsRoute::Rules => {
+                let mut context = RoutingContext::new(network, &destination)
+                    .map_err(|_| AttemptError::Dispatch(DispatchError::HostUnreachable))?;
+                context.pin_ip(nameserver.endpoint.ip());
+                context.set_source(internal_source(nameserver.endpoint.ip()));
+                let snapshot = self.geo_matcher.routing_snapshot();
+                let geo = snapshot.as_deref().unwrap_or(self.geo_matcher.as_ref());
+                let mut selected = None;
+                let mut error = None;
+                let evaluation =
+                    rules.evaluate_program(&mut context, geo, None, None, |action, _| {
+                        let RuleAction::Route(id) = action else {
+                            return RuleTargetEffect::Accept;
+                        };
+                        match inspect(id) {
+                            Ok(InspectedRuleTarget::Rematch(_)) if !rules.filters_udp() => {
+                                error = Some(DispatchError::NotAllowed);
+                                RuleTargetEffect::Accept
+                            }
+                            Ok(InspectedRuleTarget::Rematch(target)) => {
+                                RuleTargetEffect::Rematch(target)
+                            }
+                            Ok(InspectedRuleTarget::Control(_)) if !rules.filters_udp() => {
+                                error = Some(DispatchError::NotAllowed);
+                                RuleTargetEffect::Accept
+                            }
+                            Ok(InspectedRuleTarget::Control(control)) => {
+                                RuleTargetEffect::Control(control)
+                            }
+                            Ok(InspectedRuleTarget::Egress(leaf)) => {
+                                selected = Some((DnsEgressKey::Route(id), leaf.dispatcher));
+                                RuleTargetEffect::Accept
+                            }
+                            Ok(InspectedRuleTarget::Unavailable) if rules.filters_udp() => {
+                                RuleTargetEffect::Skip
+                            }
+                            Ok(InspectedRuleTarget::Unavailable) => {
+                                error = Some(DispatchError::NotAllowed);
+                                RuleTargetEffect::Accept
+                            }
+                            Err(failure) => {
+                                error = Some(failure);
+                                RuleTargetEffect::Accept
+                            }
+                        }
+                    });
+                if let Some(error) = error {
+                    return Err(AttemptError::Dispatch(error));
+                }
+                match evaluation {
+                    ProgramEvaluation::Failed(failure) => {
+                        Err(AttemptError::RuleEvaluation(failure))
+                    }
+                    ProgramEvaluation::Matched(rule_match) => match rule_match.action {
+                        RuleAction::Route(_) => {
+                            Ok(selected.expect("accepted DNS route owns a leaf"))
+                        }
+                        RuleAction::Direct => Ok((DnsEgressKey::Direct, direct.clone())),
                         RuleAction::Reject => {
                             Err(AttemptError::Dispatch(DispatchError::NotAllowed))
                         }
+                        RuleAction::RejectDrop => {
+                            Ok((DnsEgressKey::RejectDrop, self.rejection(true)))
+                        }
                     },
-                    RuleEvaluation::NeedsIpResolution { .. } | RuleEvaluation::NoMatch => {
-                        Err(AttemptError::Dispatch(DispatchError::Other(
-                            "DNS nameserver rules produced no final action".to_owned(),
-                        )))
+                    ProgramEvaluation::NeedsIpResolution(_)
+                    | ProgramEvaluation::NeedsProcessLookup(_) => {
+                        Err(AttemptError::Dispatch(DispatchError::HostUnreachable))
                     }
                 }
             }
         }
     }
 
-    /// Resolves a canonical domain through A followed by AAAA. AAAA is skipped
-    /// completely when `dns.ipv6` is false.
+    fn rejection(&self, drop: bool) -> Arc<dyn Dispatcher> {
+        let reject = if drop {
+            crate::outbound::RejectOutbound::with_drop_cancellation(
+                self.tcp_pool.reaper_cancel.child_token(),
+            )
+        } else {
+            crate::outbound::RejectOutbound::default()
+        };
+        Arc::new(crate::outbound::ConnectorDispatcher::new(Arc::new(reject)))
+    }
+
+    /// Resolves A and AAAA concurrently, retaining IPv4 first and waiting at
+    /// most `dns.ipv6-timeout` for IPv6 after A completes. Dropping this future
+    /// cancels both lookups; no detached query outlives its caller.
     pub async fn resolve(&self, host: &str) -> Result<Vec<IpAddr>, RuntimeDnsError> {
+        let decision = crate::config::RuleDecision::default();
+        decision.check()?;
+        let result = decision.scope(self.resolve_inner(host)).await;
+        decision.check()?;
+        result
+    }
+
+    async fn resolve_inner(&self, host: &str) -> Result<Vec<IpAddr>, RuntimeDnsError> {
+        super::trace::record("resolve");
+        let host = canonicalize_name(host).map_err(RuntimeDnsError::InvalidQuery)?;
+        let host =
+            match self
+                .hosts
+                .lookup(&host)
+                .map_err(|_| RuntimeDnsError::UpstreamsExhausted {
+                    last_error: "hosts alias cycle".into(),
+                })? {
+                HostValue::Addresses(mut addresses) => {
+                    addresses.retain(|ip| self.ipv6 || ip.is_ipv4());
+                    return Ok(addresses);
+                }
+                HostValue::Alias(host) => host,
+                HostValue::Lan => {
+                    return Err(RuntimeDnsError::UpstreamsExhausted {
+                        last_error: "hosts snapshot unavailable".into(),
+                    });
+                }
+            };
         if !self.enabled {
-            return Err(RuntimeDnsError::Disabled);
+            use crate::dialer::Resolver;
+            let endpoint = tokio::time::timeout(
+                QUERY_TIMEOUT,
+                crate::dialer::SystemResolver.resolve(&host, 53),
+            )
+            .await
+            .map_err(|_| RuntimeDnsError::UpstreamsExhausted {
+                last_error: "system resolver timed out".into(),
+            })?
+            .map_err(|_| RuntimeDnsError::UpstreamsExhausted {
+                last_error: "system resolver failed".into(),
+            })?;
+            return Ok(endpoint
+                .addresses
+                .into_iter()
+                .map(|address| address.ip())
+                .filter(|ip| self.ipv6 || ip.is_ipv4())
+                .collect());
         }
-        let host = canonicalize_name(host).map_err(RuntimeDnsError::InvalidQuery)?;
-        let mut addresses = Vec::new();
-
-        match self.resolve_type(&host, QueryType::A).await? {
-            LookupResult::Positive(mut values) => addresses.append(&mut values),
-            LookupResult::NoData => {}
-            LookupResult::NxDomain => return Ok(addresses),
+        let deadline = super::resolution::inherited_deadline(TokioInstant::now() + QUERY_TIMEOUT);
+        let ipv4 = self.resolve_type(&host, QueryType::A, deadline);
+        if !self.ipv6 {
+            return match ipv4.await? {
+                LookupResult::Positive(addresses) => Ok(addresses),
+                LookupResult::NoData | LookupResult::NxDomain => Ok(Vec::new()),
+            };
         }
-
-        if self.ipv6 {
-            match self.resolve_type(&host, QueryType::Aaaa).await? {
-                LookupResult::Positive(mut values) => addresses.append(&mut values),
-                LookupResult::NoData | LookupResult::NxDomain => {}
+        let ipv6 = self.resolve_type(&host, QueryType::Aaaa, deadline);
+        tokio::pin!(ipv4, ipv6);
+        let mut ipv6_result = None;
+        let ipv4_result = tokio::select! {
+            biased;
+            result = &mut ipv4 => result,
+            result = &mut ipv6 => {
+                ipv6_result = Some(result);
+                ipv4.await
             }
+        };
+        if ipv6_result.is_none() {
+            let wait_until = TokioInstant::now()
+                .checked_add(self.ipv6_timeout)
+                .unwrap_or(deadline)
+                .min(deadline);
+            ipv6_result = timeout_at(wait_until, &mut ipv6).await.ok();
+        }
+        if let Err(RuntimeDnsError::RuleEvaluation(failure)) = &ipv4_result {
+            return Err(RuntimeDnsError::RuleEvaluation(*failure));
+        }
+        if let Some(Err(RuntimeDnsError::RuleEvaluation(failure))) = &ipv6_result {
+            return Err(RuntimeDnsError::RuleEvaluation(*failure));
+        }
+        let mut addresses = match ipv4_result {
+            Ok(LookupResult::Positive(addresses)) => addresses,
+            Ok(LookupResult::NoData | LookupResult::NxDomain) => Vec::new(),
+            Err(error) => {
+                return match ipv6_result {
+                    Some(Ok(LookupResult::Positive(addresses))) => Ok(addresses),
+                    _ => Err(error),
+                };
+            }
+        };
+        match ipv6_result {
+            Some(Ok(LookupResult::Positive(mut values))) => addresses.append(&mut values),
+            Some(Err(error)) if addresses.is_empty() => return Err(error),
+            _ => {}
         }
-
         Ok(addresses)
     }
 
+    pub fn is_enabled(&self) -> bool {
+        self.enabled
+    }
+
+    pub async fn resolve_proxy(&self, host: &str) -> Result<Vec<IpAddr>, RuntimeDnsError> {
+        super::trace::record("proxy-role");
+        self.proxy_resolver
+            .as_deref()
+            .unwrap_or(self)
+            .resolve(host)
+            .await
+    }
+    pub async fn resolve_direct(&self, host: &str) -> Result<Vec<IpAddr>, RuntimeDnsError> {
+        super::trace::record("direct-role");
+        self.direct_resolver
+            .as_deref()
+            .unwrap_or(self)
+            .resolve(host)
+            .await
+    }
+    async fn resolve_nameserver(
+        &self,
+        nameserver: &DnsNameserver,
+    ) -> Result<ResolvedNameserver, AttemptError> {
+        let physical = if let Some(interface) = &nameserver.options.interface {
+            if matches!(self.egress, DnsEgress::Single(_)) {
+                return Err(AttemptError::Io(io::Error::new(
+                    io::ErrorKind::Unsupported,
+                    "private DNS cannot select a physical interface",
+                )));
+            }
+            let dialer = self
+                .source_dialer
+                .as_ref()
+                .ok_or_else(|| {
+                    AttemptError::Io(io::Error::new(
+                        io::ErrorKind::Unsupported,
+                        "DNS interface binding is unavailable",
+                    ))
+                })?
+                .clone()
+                .with_egress(&crate::config::EgressOptions {
+                    interface: Some(interface.clone()),
+                    routing_mark: 0,
+                });
+            dialer.validate_egress().map_err(AttemptError::Io)?;
+            Some(Arc::new(crate::outbound::DirectOutbound::new(dialer)) as Arc<dyn Dispatcher>)
+        } else {
+            None
+        };
+        let address = match &nameserver.address {
+            DnsAddress::Ip(ip) => *ip,
+            DnsAddress::Source(_) => return Err(AttemptError::Io(super::source::unavailable())),
+            DnsAddress::Domain(host) => {
+                super::trace::record("bootstrap");
+                if let Some(context) = &self.node_bootstrap {
+                    let destination = Destination::domain(host.clone(), nameserver.port)?;
+                    context
+                        .resolve_proxy(
+                            &destination,
+                            super::resolution::inherited_deadline(
+                                TokioInstant::now() + QUERY_TIMEOUT,
+                            ),
+                        )
+                        .await?
+                        .addresses
+                        .into_iter()
+                        .next()
+                        .ok_or_else(|| io::Error::other("DNS bootstrap returned no address"))?
+                        .ip()
+                } else {
+                    let resolver = self
+                        .bootstrap
+                        .as_ref()
+                        .ok_or_else(|| io::Error::other("DNS bootstrap is unavailable"))?;
+                    Box::pin(resolver.resolve(host))
+                        .await
+                        .map_err(|_| io::Error::other("DNS bootstrap failed"))?
+                        .into_iter()
+                        .next()
+                        .ok_or_else(|| io::Error::other("DNS bootstrap returned no address"))?
+                }
+            }
+        };
+        Ok(ResolvedNameserver {
+            config: nameserver.clone(),
+            endpoint: SocketAddr::new(address, nameserver.port),
+            physical,
+            source_generation: 0,
+            source_binding: None,
+        })
+    }
+
     /// Exchanges one structurally valid single-question IN query. A/AAAA keep
     /// the typed address cache and redir-host behavior; every other qtype uses
     /// the bounded opaque wire cache and never creates a routing hint.
@@ -991,6 +2104,110 @@ impl RuntimeDns {
             .map(DnsWireResponse::into_wire)
     }
 
+    /// Node-role HTTPS query, bypassing fake-IP/hosts address middleware. The
+    /// caller owns cancellation and the original absolute setup deadline.
+    pub(crate) async fn query_proxy_ech(
+        &self,
+        name: &str,
+        deadline: TokioInstant,
+    ) -> io::Result<Vec<u8>> {
+        let resolver = if self.enabled {
+            self.proxy_resolver.as_deref().unwrap_or(self)
+        } else {
+            self.ech_system_resolver.as_deref().unwrap_or(self)
+        };
+        let query = super::build_wire_query(resolver.next_upstream_id(), name, 65)
+            .map_err(|_| io::Error::other("invalid ECH DNS query"))?;
+        let classified =
+            classify_query(&query).map_err(|_| io::Error::other("invalid ECH DNS query"))?;
+        let permit = resolver.begin_query();
+        let deadline = deadline.min(permit.deadline);
+        permit.decision.set_deadline(deadline.into_std());
+        let exchange: std::pin::Pin<
+            Box<dyn Future<Output = Result<Vec<u8>, RuntimeDnsError>> + Send + '_>,
+        > = Box::pin(permit.decision.scope(async {
+            permit.decision.check()?;
+            resolver
+                .exchange_opaque(&query, &classified, deadline, FailureMode::BoundedError)
+                .await
+        }));
+        let response = timeout_at(deadline, exchange)
+            .await
+            .map_err(|_| io::Error::from(io::ErrorKind::TimedOut))?
+            .map_err(|_| io::Error::other("ECH DNS query failed"))?;
+        super::https_ech_config(&query, &response)
+            .map_err(|_| io::Error::other("invalid ECH DNS response"))
+    }
+
+    #[cfg(any(feature = "invoke", test))]
+    pub(crate) fn measurement_ech(
+        dialer: crate::dialer::Dialer,
+        security: crate::security::SecurityContext,
+    ) -> Self {
+        let mut dns = Self::assemble_leaf(
+            &system_ech_config(),
+            DnsEgress::Single(Arc::new(crate::outbound::DirectOutbound::new(
+                dialer.clone(),
+            ))),
+            Arc::new(EmptyGeoMatcher),
+            64,
+            0,
+            dialer.dns_sources().epoch(),
+            security,
+        );
+        let pool = Arc::get_mut(&mut dns.tcp_pool).expect("fresh measurement ECH pool");
+        pool.max_idle = 0;
+        pool.max_idle_per_key = 0;
+        pool.http2.disable_idle();
+        #[cfg(feature = "dns-quic")]
+        pool.quic.disable_idle();
+        let stats = Arc::get_mut(&mut pool.stats).expect("fresh measurement ECH counters");
+        stats.idle_limit = 0;
+        stats.idle_per_key_limit = 0;
+        dns.with_network_sources(dialer, Default::default())
+    }
+
+    /// Controller queries inspect the upstream resolver, as in Mihomo, without
+    /// the DNS listener's hosts, fake-IP or IPv6 response middleware.
+    pub(crate) async fn query_upstream(&self, query: &[u8]) -> Result<Vec<u8>, RuntimeDnsError> {
+        if !self.enabled {
+            return Err(RuntimeDnsError::Disabled);
+        }
+        let classified = classify_query(query).map_err(RuntimeDnsError::InvalidQuery)?;
+        let permit = self.begin_query();
+        // Keep the nested resolver future type bounded at the Controller boundary.
+        let exchange: std::pin::Pin<
+            Box<dyn Future<Output = Result<Vec<u8>, RuntimeDnsError>> + Send + '_>,
+        > = Box::pin(permit.decision.scope(async {
+            permit.decision.check()?;
+            match classified.kind {
+                DnsQueryKind::Address(_) => {
+                    self.exchange_address_upstream(
+                        query,
+                        &classified,
+                        permit.deadline,
+                        FailureMode::BoundedError,
+                    )
+                    .await
+                }
+                DnsQueryKind::Opaque => {
+                    self.exchange_opaque(
+                        query,
+                        &classified,
+                        permit.deadline,
+                        FailureMode::BoundedError,
+                    )
+                    .await
+                }
+            }
+        }));
+        timeout_at(permit.deadline, exchange).await.map_err(|_| {
+            RuntimeDnsError::UpstreamsExhausted {
+                last_error: "runtime DNS total query deadline expired".into(),
+            }
+        })?
+    }
+
     /// Keeps an observed query attached to the returned wire response. TUN TCP
     /// uses this until the framed response write completes.
     pub(crate) async fn exchange_retained(
@@ -1011,9 +2228,13 @@ impl RuntimeDns {
     /// Begins observing a query before the caller creates its task. This is the
     /// entry point used by the TUN DNS fast path.
     pub(crate) fn begin_query(&self) -> DnsQueryPermit {
+        let deadline = TokioInstant::now() + QUERY_TIMEOUT;
+        let decision = crate::config::RuleDecision::default();
+        decision.set_deadline(deadline.into_std());
         DnsQueryPermit {
             _activity: self.resource_stats.begin(ResourceActivity::DnsRequest),
-            deadline: TokioInstant::now() + QUERY_TIMEOUT,
+            deadline,
+            decision,
         }
     }
 
@@ -1050,19 +2271,35 @@ impl RuntimeDns {
         failure_mode: FailureMode,
     ) -> Result<Vec<u8>, RuntimeDnsError> {
         let deadline = permit.deadline;
-        let exchange = async {
+        // Transport variants make this future large. Keep it out of nested
+        // decision/deadline and node-resolution stack frames without spawning
+        // a task or changing caller-owned cancellation.
+        let exchange = Box::pin(async {
+            permit.decision.check()?;
             match classified.kind {
                 DnsQueryKind::Address(_) => {
                     self.exchange_address(query, classified, deadline, failure_mode)
                         .await
                 }
                 DnsQueryKind::Opaque => {
+                    if matches!(failure_mode, FailureMode::WireServfail)
+                        && matches!(classified.question.query_type, 64 | 65)
+                        && self.use_fake_ip(&classified.question.name)?
+                    {
+                        return super::synthesize_empty_response(classified, 0)
+                            .map_err(RuntimeDnsError::InvalidResponse);
+                    }
                     self.exchange_opaque(query, classified, deadline, failure_mode)
                         .await
                 }
             }
-        };
-        match timeout_at(deadline, exchange).await {
+        });
+        match timeout_at(deadline, permit.decision.scope(exchange)).await {
+            Ok(Err(RuntimeDnsError::RuleEvaluation(_)))
+                if matches!(failure_mode, FailureMode::WireServfail) =>
+            {
+                Ok(synthesize_servfail_response(classified))
+            }
             Ok(result) => result,
             Err(_) => {
                 tracing::warn!(
@@ -1080,6 +2317,27 @@ impl RuntimeDns {
         }
     }
 
+    fn synthetic_answer(&self, query: &DnsMessage, host: &str) -> Result<Vec<u8>, RuntimeDnsError> {
+        super::trace::record("fake-ip");
+        match self
+            .fake_pools
+            .as_ref()
+            .expect("enabled fake-IP pool")
+            .lookup(host, query.question.query_type == QueryType::Aaaa)
+        {
+            Ok(address) => {
+                let mut wire = synthesize_response(
+                    query,
+                    &CacheValue::Positive(address.into_iter().collect()),
+                    self.fake_config.ttl,
+                )?;
+                wire[2] |= 0x04;
+                Ok(wire)
+            }
+            Err(_) => synthesize_response(query, &CacheValue::Negative { rcode: 2 }, 0),
+        }
+    }
+
     async fn exchange_address(
         &self,
         query: &[u8],
@@ -1093,21 +2351,96 @@ impl RuntimeDns {
             return synthesize_response(&parsed_query, &CacheValue::Negative { rcode: 0 }, 0);
         }
 
+        let addresses = match self
+            .hosts
+            .lookup(&parsed_query.question.name)
+            .map_err(|_| RuntimeDnsError::UpstreamsExhausted {
+                last_error: "hosts alias cycle".into(),
+            })? {
+            HostValue::Addresses(addresses) => Some(addresses),
+            HostValue::Alias(alias) if alias != parsed_query.question.name => {
+                if matches!(failure_mode, FailureMode::WireServfail) && self.use_fake_ip(&alias)? {
+                    return self.synthetic_answer(&parsed_query, &alias);
+                }
+                Some(Box::pin(self.resolve(&alias)).await?)
+            }
+            _ => None,
+        };
+        if let Some(addresses) = addresses {
+            super::trace::record("hosts");
+            let addresses: Vec<_> = addresses
+                .into_iter()
+                .filter(|ip| match parsed_query.question.query_type {
+                    QueryType::A => ip.is_ipv4(),
+                    QueryType::Aaaa => ip.is_ipv6(),
+                })
+                .collect();
+            return synthesize_response(&parsed_query, &CacheValue::Positive(addresses), 600);
+        }
+
+        if matches!(failure_mode, FailureMode::WireServfail)
+            && self.use_fake_ip(&parsed_query.question.name)?
+        {
+            let _epoch = self.cache_epoch.read().await;
+            return self.synthetic_answer(&parsed_query, &parsed_query.question.name);
+        }
+
+        self.exchange_address_upstream(query, classified, deadline, failure_mode)
+            .await
+    }
+
+    async fn exchange_address_upstream(
+        &self,
+        query: &[u8],
+        classified: &ClassifiedDnsQuery,
+        deadline: TokioInstant,
+        failure_mode: FailureMode,
+    ) -> Result<Vec<u8>, RuntimeDnsError> {
+        let parsed_query = parse_query(query).map_err(RuntimeDnsError::InvalidQuery)?;
+
         loop {
-            let key = SingleflightKey::from(classified);
-            let role = {
+            let (role, epoch) = {
+                let epoch = self.cache_epoch.read().await;
                 // Keep the cache lock through registry selection. A completing
                 // leader populates this cache before removing its registry
                 // entry, so a caller cannot observe a miss and then create a
                 // duplicate flight after that leader has disappeared.
                 let mut cache = self.cache.lock().await;
-                if let Some((cached, remaining_ttl)) = cache.get_with_ttl(
-                    &parsed_query.question.name,
-                    parsed_query.question.query_type,
-                    Instant::now(),
-                ) {
-                    self.resource_stats.dns_cache_hit();
-                    return synthesize_response(&parsed_query, &cached, remaining_ttl);
+                let allow_stale = self
+                    .refresh
+                    .get()
+                    .is_some_and(|binding| !binding.owner.is_closed());
+                let cached = if classified.needs_wire_cache {
+                    cache
+                        .lookup_wire(classified, Instant::now(), allow_stale)
+                        .map(Ok)
+                } else {
+                    cache
+                        .lookup_with_ttl(
+                            &parsed_query.question.name,
+                            parsed_query.question.query_type,
+                            Instant::now(),
+                            allow_stale,
+                        )
+                        .map(|(value, ttl)| synthesize_response(&parsed_query, &value, ttl))
+                };
+                match cached {
+                    super::CacheLookup::Fresh(wire) => {
+                        super::trace::record("cache");
+                        self.resource_stats.dns_cache_hit();
+                        return wire;
+                    }
+                    super::CacheLookup::Stale(wire) => {
+                        let wire = wire?;
+                        let response =
+                            parse_response(&wire).map_err(RuntimeDnsError::InvalidResponse)?;
+                        self.stale_hints(&response)?;
+                        self.refresh_stale(query, classified, *epoch, &mut cache);
+                        super::trace::record("stale-cache");
+                        self.resource_stats.dns_cache_hit();
+                        return Ok(wire);
+                    }
+                    super::CacheLookup::Miss => {}
                 }
                 if self.nameservers.is_empty() {
                     return finish_shared_result(
@@ -1116,18 +2449,23 @@ impl RuntimeDns {
                         failure_mode,
                     );
                 }
-                self.singleflight.join(key)
+                (
+                    self.singleflight
+                        .join(SingleflightKey::new(classified, *epoch)),
+                    *epoch,
+                )
             };
             match role {
                 FlightRole::Leader(leader) => {
                     let result = self
-                        .exchange_address_leader(query, classified, deadline)
+                        .exchange_address_leader(query, classified, deadline, epoch)
                         .await
                         .map(Arc::<[u8]>::from);
                     leader.complete(result.clone());
                     return finish_shared_result(result, classified, failure_mode);
                 }
                 FlightRole::Follower(updates) => {
+                    super::trace::record("shared-query");
                     let Some(result) = wait_for_flight(updates).await else {
                         continue;
                     };
@@ -1142,20 +2480,59 @@ impl RuntimeDns {
         query: &[u8],
         classified: &ClassifiedDnsQuery,
         deadline: TokioInstant,
+        epoch: u64,
     ) -> Result<Vec<u8>, RuntimeDnsError> {
         let upstream_query = rewrite_query_id(query, self.next_upstream_id());
         let upstream_parsed_query =
             parse_query(&upstream_query).map_err(RuntimeDnsError::InvalidQuery)?;
-        let nameservers = self.nameservers_for(classified);
-        let (mut response, parsed_response) = self
-            .exchange_upstreams(
-                nameservers,
-                &upstream_query,
-                &upstream_parsed_query,
-                deadline,
-            )
-            .await?;
-        self.cache_response(&parsed_response).await?;
+        let (mut response, parsed_response, cacheable) =
+            if let Some(policy) = self.policy_for(classified)? {
+                super::trace::record("nameserver-policy");
+                self.exchange_upstreams(policy, &upstream_query, &upstream_parsed_query, deadline)
+                    .await?
+            } else if self.fallback.nameservers.is_empty() {
+                super::trace::record("nameserver");
+                self.exchange_upstreams(
+                    &self.nameservers,
+                    &upstream_query,
+                    &upstream_parsed_query,
+                    deadline,
+                )
+                .await?
+            } else if self.fallback_domain(&classified.question.name)? {
+                super::trace::record("fallback-domain");
+                self.exchange_upstreams(
+                    &self.fallback.nameservers,
+                    &upstream_query,
+                    &upstream_parsed_query,
+                    deadline,
+                )
+                .await?
+            } else {
+                // Reserve the two racing queries only when fallback is used.
+                // Keeping this state inline inflates every ordinary DNS flight.
+                Box::pin(super::fallback::choose(
+                    self.exchange_upstreams(
+                        &self.nameservers,
+                        &upstream_query,
+                        &upstream_parsed_query,
+                        deadline,
+                    ),
+                    self.exchange_upstreams(
+                        &self.fallback.nameservers,
+                        &upstream_query,
+                        &upstream_parsed_query,
+                        deadline,
+                    ),
+                    self.fallback.lazy,
+                    |answer| self.accepts_primary(answer),
+                ))
+                .await?
+            };
+        if cacheable {
+            self.cache_response(&parsed_response, classified, &response, epoch)
+                .await?;
+        }
         restore_response_id(&mut response, 0);
         Ok(response)
     }
@@ -1168,12 +2545,26 @@ impl RuntimeDns {
         failure_mode: FailureMode,
     ) -> Result<Vec<u8>, RuntimeDnsError> {
         loop {
-            let key = SingleflightKey::from(classified);
-            let role = {
-                let mut cache = self.opaque_cache.lock().await;
-                if let Some(response) = cache.get(classified, Instant::now()) {
-                    self.resource_stats.dns_cache_hit();
-                    return Ok(response);
+            let (role, epoch) = {
+                let epoch = self.cache_epoch.read().await;
+                let mut cache = self.cache.lock().await;
+                let allow_stale = self
+                    .refresh
+                    .get()
+                    .is_some_and(|binding| !binding.owner.is_closed());
+                match cache.lookup_wire(classified, Instant::now(), allow_stale) {
+                    super::CacheLookup::Fresh(wire) => {
+                        super::trace::record("cache");
+                        self.resource_stats.dns_cache_hit();
+                        return Ok(wire);
+                    }
+                    super::CacheLookup::Stale(wire) => {
+                        self.refresh_stale(query, classified, *epoch, &mut cache);
+                        super::trace::record("stale-cache");
+                        self.resource_stats.dns_cache_hit();
+                        return Ok(wire);
+                    }
+                    super::CacheLookup::Miss => {}
                 }
                 if self.nameservers.is_empty() {
                     return finish_shared_result(
@@ -1182,18 +2573,23 @@ impl RuntimeDns {
                         failure_mode,
                     );
                 }
-                self.singleflight.join(key)
+                (
+                    self.singleflight
+                        .join(SingleflightKey::new(classified, *epoch)),
+                    *epoch,
+                )
             };
             match role {
                 FlightRole::Leader(leader) => {
                     let result = self
-                        .exchange_opaque_leader(query, classified, deadline)
+                        .exchange_opaque_leader(query, classified, deadline, epoch)
                         .await
                         .map(Arc::<[u8]>::from);
                     leader.complete(result.clone());
                     return finish_shared_result(result, classified, failure_mode);
                 }
                 FlightRole::Follower(updates) => {
+                    super::trace::record("shared-query");
                     let Some(result) = wait_for_flight(updates).await else {
                         continue;
                     };
@@ -1208,18 +2604,24 @@ impl RuntimeDns {
         query: &[u8],
         classified: &ClassifiedDnsQuery,
         deadline: TokioInstant,
+        epoch: u64,
     ) -> Result<Vec<u8>, RuntimeDnsError> {
         let upstream_query = rewrite_query_id(query, self.next_upstream_id());
         let upstream_classified =
             classify_query(&upstream_query).map_err(RuntimeDnsError::InvalidQuery)?;
-        let nameservers = self.nameservers_for(classified);
+        let nameservers = self.nameservers_for(classified)?;
         let response = self
             .exchange_opaque_upstreams(nameservers, &upstream_query, &upstream_classified, deadline)
             .await?;
-        self.opaque_cache
-            .lock()
-            .await
-            .insert(&response, Instant::now());
+        {
+            let current_epoch = self.cache_epoch.read().await;
+            if *current_epoch == epoch {
+                self.cache
+                    .lock()
+                    .await
+                    .insert_opaque(&response, Instant::now());
+            }
+        }
         let mut response = response.into_wire();
         restore_response_id(&mut response, 0);
         Ok(response)
@@ -1242,11 +2644,15 @@ impl RuntimeDns {
         &self,
         host: &str,
         query_type: QueryType,
+        deadline: TokioInstant,
     ) -> Result<LookupResult, RuntimeDnsError> {
         let id = self.next_id.fetch_add(1, Ordering::Relaxed);
         let query = build_query(id, host, query_type).map_err(RuntimeDnsError::InvalidQuery)?;
         let classified = classify_query(&query).map_err(RuntimeDnsError::InvalidQuery)?;
-        let permit = self.begin_query();
+        let permit = DnsQueryPermit {
+            deadline,
+            ..self.begin_query()
+        };
         let response = self
             .exchange_classified_admitted(&query, &classified, &permit, FailureMode::BoundedError)
             .await?;
@@ -1281,17 +2687,24 @@ impl RuntimeDns {
         query: &[u8],
         parsed_query: &DnsMessage,
         deadline: TokioInstant,
-    ) -> Result<(Vec<u8>, DnsMessage), RuntimeDnsError> {
-        exchange_nameservers(
+    ) -> Result<(Vec<u8>, DnsMessage, bool), RuntimeDnsError> {
+        let cacheable = !nameservers
+            .iter()
+            .any(|server| matches!(server.transport, DnsTransport::Rcode(_)));
+        let permits = Semaphore::new(4);
+        let (wire, response) = exchange_nameservers(
             nameservers,
             deadline,
-            |nameserver| self.exchange_nameserver(nameserver, query, parsed_query),
+            |nameserver| {
+                self.exchange_nameserver_limited(nameserver, query, parsed_query, &permits)
+            },
             |(_, response): &(Vec<u8>, DnsMessage)| {
                 matches!(response.rcode, RCODE_SERVFAIL | RCODE_REFUSED)
                     .then_some(u16::from(response.rcode))
             },
         )
-        .await
+        .await?;
+        Ok((wire, response, cacheable))
     }
 
     async fn exchange_opaque_upstreams(
@@ -1301,10 +2714,11 @@ impl RuntimeDns {
         classified: &ClassifiedDnsQuery,
         deadline: TokioInstant,
     ) -> Result<ValidatedOpaqueResponse, RuntimeDnsError> {
+        let permits = Semaphore::new(4);
         exchange_nameservers(
             nameservers,
             deadline,
-            |nameserver| self.exchange_opaque_nameserver(nameserver, query, classified),
+            |nameserver| self.exchange_opaque_nameserver(nameserver, query, classified, &permits),
             |response: &ValidatedOpaqueResponse| {
                 matches!(
                     response.rcode(),
@@ -1317,73 +2731,236 @@ impl RuntimeDns {
         .await
     }
 
+    #[cfg(test)]
     async fn exchange_nameserver(
         &self,
         nameserver: DnsNameserver,
         query: &[u8],
-        parsed_query: &DnsMessage,
+        parsed: &DnsMessage,
     ) -> Result<(Vec<u8>, DnsMessage), AttemptError> {
-        let route_network = match nameserver.transport {
-            DnsTransport::Udp => Network::Udp,
-            DnsTransport::Tcp => Network::Tcp,
-        };
-        let (egress_key, egress) = self.egress_for(nameserver, route_network)?;
-        let egress = Arc::clone(egress);
-        match nameserver.transport {
-            DnsTransport::Udp => {
-                let response = self
-                    .exchange_udp(nameserver, &egress, query, |response| {
-                        udp_response_matches_query(parsed_query, response)
-                    })
-                    .await?;
-                let parsed_response = validate_complete_response(parsed_query, &response)?;
-                Ok((response, parsed_response))
-            }
-            DnsTransport::Tcp => {
-                self.exchange_tcp(nameserver, egress_key, &egress, query, |response| {
-                    validate_complete_response(parsed_query, response)
-                })
-                .await
-            }
-        }
+        self.exchange_nameserver_limited(nameserver, query, parsed, &Semaphore::new(4))
+            .await
+    }
+
+    async fn exchange_nameserver_limited(
+        &self,
+        nameserver: DnsNameserver,
+        query: &[u8],
+        parsed: &DnsMessage,
+        permits: &Semaphore,
+    ) -> Result<(Vec<u8>, DnsMessage), AttemptError> {
+        self.exchange_validated(
+            nameserver,
+            query,
+            |wire| udp_response_matches_query(parsed, wire),
+            |wire| validate_complete_response(parsed, wire),
+            permits,
+        )
+        .await
     }
 
     async fn exchange_opaque_nameserver(
         &self,
         nameserver: DnsNameserver,
         query: &[u8],
-        classified: &ClassifiedDnsQuery,
+        parsed: &ClassifiedDnsQuery,
+        permits: &Semaphore,
     ) -> Result<ValidatedOpaqueResponse, AttemptError> {
-        let route_network = match nameserver.transport {
-            DnsTransport::Udp => Network::Udp,
-            DnsTransport::Tcp => Network::Tcp,
-        };
-        let (egress_key, egress) = self.egress_for(nameserver, route_network)?;
-        let egress = Arc::clone(egress);
-        match nameserver.transport {
-            DnsTransport::Udp => {
-                let response = self
-                    .exchange_udp(nameserver, &egress, query, |response| {
-                        udp_response_matches_classified_query(classified, response)
-                    })
-                    .await?;
-                validate_opaque_response(classified, &response).map_err(AttemptError::from)
+        let local = matches!(nameserver.transport, DnsTransport::Rcode(_));
+        self.exchange_validated(
+            nameserver,
+            query,
+            |wire| udp_response_matches_classified_query(parsed, wire),
+            |wire| validate_opaque_response(parsed, wire).map_err(AttemptError::from),
+            permits,
+        )
+        .await
+        .map(|(_, mut parsed)| {
+            if local {
+                parsed.cache_policy = super::OpaqueCachePolicy::NotCacheable;
             }
-            DnsTransport::Tcp => self
-                .exchange_tcp(nameserver, egress_key, &egress, query, |response| {
-                    validate_opaque_response(classified, response).map_err(|error| match error {
-                        DnsError::ResponseMismatch => AttemptError::ResponseMismatch,
-                        error => AttemptError::InvalidResponse(error),
-                    })
+            parsed
+        })
+    }
+
+    async fn exchange_validated<R, M, V>(
+        &self,
+        nameserver: DnsNameserver,
+        query: &[u8],
+        matches: M,
+        validate: V,
+        permits: &Semaphore,
+    ) -> Result<(Vec<u8>, R), AttemptError>
+    where
+        M: Fn(&[u8]) -> Result<bool, AttemptError>,
+        V: Fn(&[u8]) -> Result<R, AttemptError>,
+    {
+        if nameserver.options.disabled_types.is_empty() {
+            let wrapped = super::options::with_ecs(query, &nameserver.options)?;
+            return self
+                .exchange_raw_validated(nameserver, &wrapped, matches, validate, permits)
+                .await;
+        }
+        let classified = classify_query(query)?;
+        if super::options::question_disabled(&nameserver.options, classified.question.query_type) {
+            let mut response = super::synthesize_empty_response(&classified, RCODE_NOERROR)?;
+            response[2] |= 0x04; // AA, matching Mihomo's disable-type wrapper.
+            let parsed = validate(&response)?;
+            return Ok((response, parsed));
+        }
+        let wrapped = super::options::with_ecs(query, &nameserver.options)?;
+        let disabled = nameserver.options.disabled_types.clone();
+        let (wire, ()) = self
+            .exchange_raw_validated(
+                nameserver,
+                &wrapped,
+                matches,
+                |wire| validate(wire).map(|_| ()),
+                permits,
+            )
+            .await?;
+        let wire = super::options::filter_response(&wire, &disabled)?;
+        let parsed = validate(&wire)?;
+        Ok((wire, parsed))
+    }
+
+    async fn exchange_raw_validated<R, M, V>(
+        &self,
+        nameserver: DnsNameserver,
+        query: &[u8],
+        matches: M,
+        validate: V,
+        permits: &Semaphore,
+    ) -> Result<(Vec<u8>, R), AttemptError>
+    where
+        M: Fn(&[u8]) -> Result<bool, AttemptError>,
+        V: Fn(&[u8]) -> Result<R, AttemptError>,
+    {
+        if let DnsTransport::Rcode(rcode) = nameserver.transport {
+            super::trace::record("rcode");
+            let mut response = query.to_vec();
+            let flags = u16::from_be_bytes([response[2], response[3]]);
+            let flags = (flags | DNS_FLAG_RESPONSE) & !0x000f | u16::from(rcode);
+            response[2..4].copy_from_slice(&flags.to_be_bytes());
+            let parsed = validate(&response)?;
+            return Ok((response, parsed));
+        }
+        if let DnsAddress::Source(source) = &nameserver.address {
+            use futures_util::{StreamExt, stream};
+            let selection = self
+                .sources
+                .select(source, self.source_dialer.as_ref(), &self.source_exclusions)
+                .await?;
+            let mut attempts = stream::iter(selection.endpoints.to_vec())
+                .map(|endpoint| {
+                    let mut config = nameserver.clone();
+                    config.address = DnsAddress::Ip(endpoint.endpoint.ip());
+                    config.route = DnsRoute::Direct;
+                    let physical = self
+                        .source_dialer
+                        .as_ref()
+                        .map(|dialer| {
+                            dialer
+                                .for_dns_source(endpoint.binding.clone(), endpoint.endpoint)
+                                .map(|dialer| {
+                                    Arc::new(crate::outbound::DirectOutbound::new(dialer))
+                                        as Arc<dyn Dispatcher>
+                                })
+                        })
+                        .transpose();
+                    let resolved = ResolvedNameserver {
+                        config,
+                        endpoint: endpoint.endpoint,
+                        physical: None,
+                        source_generation: selection.generation,
+                        source_binding: Some(endpoint.binding.clone()),
+                    };
+                    let matches = &matches;
+                    let validate = &validate;
+                    async move {
+                        let mut resolved = resolved;
+                        resolved.physical = physical?;
+                        let _attempt = permits
+                            .acquire()
+                            .await
+                            .map_err(|_| super::source::unavailable())?;
+                        self.exchange_resolved_validated(resolved, query, matches, validate)
+                            .await
+                    }
                 })
-                .await
-                .map(|(_, response)| response),
+                .buffer_unordered(4);
+            let mut last = None;
+            while let Some(result) = attempts.next().await {
+                match result {
+                    Ok((wire, parsed))
+                        if !matches!(wire[3] & 0x0f, RCODE_SERVFAIL | RCODE_REFUSED) =>
+                    {
+                        return Ok((wire, parsed));
+                    }
+                    Ok(response) => last = Some(Ok(response)),
+                    Err(error) => {
+                        if !matches!(last, Some(Ok(_))) {
+                            last = Some(Err(error));
+                        }
+                    }
+                }
+            }
+            return last.unwrap_or_else(|| Err(super::source::unavailable().into()));
+        }
+        super::trace::record(match nameserver.transport {
+            DnsTransport::Rcode(_) => unreachable!("local response handled above"),
+            DnsTransport::Udp => "udp",
+            DnsTransport::Tcp => "tcp",
+            DnsTransport::Tls => "tls",
+            DnsTransport::Https => "https",
+            DnsTransport::Http => "http",
+            DnsTransport::Quic => "quic",
+        });
+        let server = self.resolve_nameserver(&nameserver).await?;
+        let _attempt = permits
+            .acquire()
+            .await
+            .map_err(|_| super::source::unavailable())?;
+        self.exchange_resolved_validated(server, query, matches, validate)
+            .await
+    }
+
+    async fn exchange_resolved_validated<R, M, V>(
+        &self,
+        mut server: ResolvedNameserver,
+        query: &[u8],
+        matches: M,
+        validate: V,
+    ) -> Result<(Vec<u8>, R), AttemptError>
+    where
+        M: Fn(&[u8]) -> Result<bool, AttemptError>,
+        V: Fn(&[u8]) -> Result<R, AttemptError>,
+    {
+        if server.transport == DnsTransport::Quic {
+            #[cfg(feature = "dns-quic")]
+            return Box::pin(self.exchange_quic(&server, query, validate, super::quic::Kind::Doq))
+                .await;
+            #[cfg(not(feature = "dns-quic"))]
+            return Err(io::Error::from(io::ErrorKind::Unsupported).into());
+        }
+        if server.transport == DnsTransport::Udp {
+            let (_, egress) = self.egress_for(&server, Network::Udp, |_| false)?;
+            let response = self.exchange_udp(&server, &egress, query, matches).await?;
+            if response.get(2).is_some_and(|flags| flags & 0x02 != 0) {
+                server.config.transport = DnsTransport::Tcp;
+            } else {
+                let parsed = validate(&response)?;
+                return Ok((response, parsed));
+            }
         }
+        // TCP/TLS/H3 handshake states are only needed after selecting them.
+        // Keeping them inline would inflate every racing UDP attempt as well.
+        Box::pin(self.exchange_tcp(&server, query, validate)).await
     }
 
     async fn exchange_udp<F>(
         &self,
-        nameserver: DnsNameserver,
+        nameserver: &ResolvedNameserver,
         egress: &Arc<dyn Dispatcher>,
         query: &[u8],
         response_matches: F,
@@ -1395,7 +2972,7 @@ impl RuntimeDns {
         let mut transport = egress
             .open_datagram(DatagramSession::new(
                 InboundKind::InternalDns,
-                internal_source(nameserver.address),
+                internal_source(nameserver.endpoint.ip()),
             ))
             .await?;
         let payload = Bytes::copy_from_slice(query);
@@ -1462,28 +3039,40 @@ impl RuntimeDns {
 
     async fn exchange_tcp<R, F>(
         &self,
-        nameserver: DnsNameserver,
-        egress_key: DnsEgressKey,
-        egress: &Arc<dyn Dispatcher>,
+        nameserver: &ResolvedNameserver,
         query: &[u8],
         validate: F,
     ) -> Result<(Vec<u8>, R), AttemptError>
     where
         F: Fn(&[u8]) -> Result<R, AttemptError>,
     {
-        let key = TcpPoolKey {
-            endpoint: nameserver.endpoint(),
-            egress: egress_key,
-        };
-        let mut lease = self.tcp_pool.checkout(key, nameserver, egress).await?;
+        if nameserver.transport == DnsTransport::Https {
+            return self.exchange_https(nameserver, query, validate).await;
+        }
+        let mut lease = self
+            .tcp_pool
+            .checkout_for(nameserver, |state| {
+                self.egress_for(nameserver, Network::Tcp, |egress| {
+                    !dot_reuse_disabled(&nameserver.config)
+                        && state.idle.iter().any(|idle| {
+                            idle.key.upstream == nameserver.config
+                                && idle.key.endpoint == nameserver.endpoint()
+                                && idle.key.egress == egress
+                                && idle.key.source_generation == nameserver.source_generation
+                                && idle.key.source_binding == nameserver.source_binding
+                        })
+                })
+            })
+            .await?;
         let first_was_reused = lease.reused;
 
-        let mut result = exchange_tcp_validated(
+        let mut result = exchange_stream_validated(
             &mut lease
                 .connection
                 .as_mut()
                 .expect("TCP lease always owns a connection")
                 .stream,
+            nameserver,
             query,
             &validate,
         )
@@ -1493,34 +3082,431 @@ impl RuntimeDns {
                 event = "runtime_dns_tcp_pool_stale_retry",
                 "runtime DNS is rebuilding one stale reused TCP connection"
             );
+            let (key, egress) = self.egress_for(nameserver, Network::Tcp, |_| false)?;
+            lease.key.egress = key;
             self.tcp_pool
-                .replace_stale(&mut lease, nameserver, egress)
+                .replace_stale(&mut lease, nameserver, &egress)
                 .await?;
-            result = exchange_tcp_validated(
+            result = exchange_stream_validated(
                 &mut lease
                     .connection
                     .as_mut()
                     .expect("replacement TCP lease owns a connection")
                     .stream,
+                nameserver,
                 query,
                 &validate,
             )
             .await;
         }
 
-        let (response, validated) = result?;
-        self.tcp_pool.check_in(lease).await;
+        let (response, validated, reusable) = result?;
+        if reusable {
+            self.tcp_pool.check_in(lease).await;
+        }
         Ok((response, validated))
     }
 
-    async fn cache_response(&self, response: &DnsMessage) -> Result<(), RuntimeDnsError> {
-        let now = Instant::now();
+    async fn exchange_https<R, F>(
+        &self,
+        nameserver: &ResolvedNameserver,
+        query: &[u8],
+        validate: F,
+    ) -> Result<(Vec<u8>, R), AttemptError>
+    where
+        F: Fn(&[u8]) -> Result<R, AttemptError>,
+    {
+        #[cfg(feature = "dns-quic")]
+        if nameserver.options.force_h3 {
+            return self
+                .exchange_quic(nameserver, query, validate, super::quic::Kind::H3)
+                .await;
+        }
+        #[cfg(not(feature = "dns-quic"))]
+        if nameserver.options.force_h3 || self.prefer_h3 {
+            return Err(io::Error::from(io::ErrorKind::Unsupported).into());
+        }
+        let resolve = |state: &TcpPoolState| {
+            self.egress_for(nameserver, Network::Tcp, |egress| {
+                let key = TcpPoolKey {
+                    upstream: nameserver.config.clone(),
+                    endpoint: nameserver.endpoint(),
+                    egress,
+                    source_generation: nameserver.source_generation,
+                    source_binding: nameserver.source_binding.clone(),
+                };
+                self.tcp_pool.http2.has(&key) || state.idle.iter().any(|idle| idle.key == key)
+            })
+        };
+        // Only a stale reused HTTP/1 connection gets one retry. Each fresh
+        // handshake branches on actual ALPN, including a changed server choice.
+        for attempt in 0..2 {
+            #[cfg(feature = "dns-quic")]
+            if self.prefer_h3
+                && let Some(lease) = self.cached_quic(nameserver)?
+            {
+                let result = lease
+                    .exchange(&nameserver.config, query, |wire| {
+                        validate(wire)
+                            .map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))
+                    })
+                    .await
+                    .map_err(AttemptError::Io);
+                return result;
+            }
+            let key = {
+                let state = self.tcp_pool.state.lock().await;
+                let (egress, _) = resolve(&state)?;
+                TcpPoolKey {
+                    upstream: nameserver.config.clone(),
+                    endpoint: nameserver.endpoint(),
+                    egress,
+                    source_generation: nameserver.source_generation,
+                    source_binding: nameserver.source_binding.clone(),
+                }
+            };
+            if let Some(lease) = self.tcp_pool.http2.get(&key) {
+                self.tcp_pool
+                    .stats
+                    .reuse_hits
+                    .fetch_add(1, Ordering::Relaxed);
+                let result = lease
+                    .exchange(&nameserver.config, query, |wire| {
+                        validate(wire)
+                            .map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))
+                    })
+                    .await
+                    .map_err(AttemptError::Io);
+                #[cfg(feature = "dns-quic")]
+                if result.is_err() {
+                    self.tcp_pool.forget_tcp(&key);
+                }
+                return result;
+            }
+            let initialization = self.tcp_pool.http2.initialization(key.clone());
+            let gate = initialization.lock().await;
+            #[cfg(feature = "dns-quic")]
+            if self.prefer_h3
+                && let Some(lease) = self.cached_quic(nameserver)?
+            {
+                drop(gate);
+                return lease
+                    .exchange(&nameserver.config, query, |wire| {
+                        validate(wire)
+                            .map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))
+                    })
+                    .await
+                    .map_err(AttemptError::Io);
+            }
+            if let Some(lease) = self.tcp_pool.http2.get(&key) {
+                drop(gate);
+                self.tcp_pool
+                    .stats
+                    .reuse_hits
+                    .fetch_add(1, Ordering::Relaxed);
+                let result = lease
+                    .exchange(&nameserver.config, query, |wire| {
+                        validate(wire)
+                            .map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))
+                    })
+                    .await
+                    .map_err(AttemptError::Io);
+                #[cfg(feature = "dns-quic")]
+                if result.is_err() {
+                    self.tcp_pool.forget_tcp(&key);
+                }
+                return result;
+            }
+            #[cfg(feature = "dns-quic")]
+            let mut lease = if self.prefer_h3 && !self.tcp_pool.tcp_selected(&key) {
+                let mut quic = self.start_quic(nameserver, super::quic::Kind::H3)?;
+                let mut tcp = Box::pin(self.tcp_pool.checkout_for(nameserver, &resolve));
+                tokio::select! {
+                    result = &mut tcp => match result {
+                    Ok(lease) => {
+                        drop(tcp);
+                        quic.cancel().await;
+                        self.tcp_pool.select_tcp(lease.key.clone());
+                        lease
+                    }
+                    Err(_) => {
+                        drop(tcp);
+                        if let Err(error) = quic.wait_ready().await {
+                            quic.cancel().await;
+                            return Err(error.into());
+                        }
+                        let lease = quic.publish()?;
+                        drop(gate);
+                        return lease
+                            .exchange(&nameserver.config, query, |wire| {
+                                validate(wire).map_err(|error| {
+                                    io::Error::new(io::ErrorKind::InvalidData, error)
+                                })
+                            })
+                            .await
+                            .map_err(AttemptError::Io);
+                    }
+                    },
+                    result = quic.wait_ready() => match result {
+                    Ok(()) => {
+                        drop(tcp);
+                        let lease = quic.publish()?;
+                        drop(gate);
+                        return lease
+                            .exchange(&nameserver.config, query, |wire| {
+                                validate(wire).map_err(|error| {
+                                    io::Error::new(io::ErrorKind::InvalidData, error)
+                                })
+                            })
+                            .await
+                            .map_err(AttemptError::Io);
+                    }
+                    Err(_) => {
+                        let tcp = tcp.await;
+                        quic.cancel().await;
+                        let lease = tcp?;
+                        self.tcp_pool.select_tcp(lease.key.clone());
+                        lease
+                    }
+                }
+                }
+            } else {
+                self.tcp_pool.checkout_for(nameserver, &resolve).await?
+            };
+            #[cfg(not(feature = "dns-quic"))]
+            let mut lease = self.tcp_pool.checkout_for(nameserver, &resolve).await?;
+            let alpn = lease
+                .connection
+                .as_ref()
+                .expect("TCP lease owns a connection")
+                .negotiated_alpn
+                .as_deref();
+            if alpn == Some(b"h2") {
+                let connection = lease
+                    .connection
+                    .take()
+                    .expect("TCP lease owns a connection");
+                lease.busy.take();
+                let PooledTcpConnection {
+                    stream,
+                    _slot,
+                    _observation,
+                    ..
+                } = connection;
+                let h2 = self
+                    .tcp_pool
+                    .http2
+                    .connect(lease.key.clone(), stream, (_slot, _observation))
+                    .await?;
+                drop(gate);
+                let result = h2
+                    .exchange(&nameserver.config, query, |wire| {
+                        validate(wire)
+                            .map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))
+                    })
+                    .await
+                    .map_err(AttemptError::Io);
+                #[cfg(feature = "dns-quic")]
+                if result.is_err() {
+                    self.tcp_pool.forget_tcp(&key);
+                }
+                return result;
+            }
+            if alpn.is_some_and(|protocol| protocol != b"http/1.1") {
+                return Err(io::Error::from(io::ErrorKind::InvalidData).into());
+            }
+            drop(gate);
+            let result = exchange_stream_validated(
+                &mut lease
+                    .connection
+                    .as_mut()
+                    .expect("TCP lease owns a connection")
+                    .stream,
+                nameserver,
+                query,
+                &validate,
+            )
+            .await;
+            if attempt == 0 && lease.reused && result.as_ref().is_err_and(stale_reuse_is_retryable)
+            {
+                #[cfg(feature = "dns-quic")]
+                self.tcp_pool.forget_tcp(&key);
+                self.tcp_pool
+                    .stats
+                    .stale_retries
+                    .fetch_add(1, Ordering::Relaxed);
+                drop(lease);
+                continue;
+            }
+            #[cfg(feature = "dns-quic")]
+            if result.is_err() {
+                self.tcp_pool.forget_tcp(&key);
+            }
+            let (response, validated, reusable) = result?;
+            if reusable {
+                self.tcp_pool.check_in(lease).await;
+            }
+            return Ok((response, validated));
+        }
+        unreachable!("stale HTTP/1 reuse retries once")
+    }
+
+    #[cfg(feature = "dns-quic")]
+    fn quic_route(
+        &self,
+        nameserver: &ResolvedNameserver,
+    ) -> Result<(TcpPoolKey, Arc<dyn Dispatcher>), AttemptError> {
+        let (egress, dispatcher) = self.egress_for(nameserver, Network::Udp, |egress| {
+            self.tcp_pool.quic.has(&TcpPoolKey {
+                upstream: nameserver.config.clone(),
+                endpoint: nameserver.endpoint(),
+                egress,
+                source_generation: nameserver.source_generation,
+                source_binding: nameserver.source_binding.clone(),
+            })
+        })?;
+        Ok((
+            TcpPoolKey {
+                upstream: nameserver.config.clone(),
+                endpoint: nameserver.endpoint(),
+                egress,
+                source_generation: nameserver.source_generation,
+                source_binding: nameserver.source_binding.clone(),
+            },
+            dispatcher,
+        ))
+    }
+
+    #[cfg(feature = "dns-quic")]
+    fn cached_quic(
+        &self,
+        nameserver: &ResolvedNameserver,
+    ) -> Result<Option<super::quic::Lease<TcpPoolKey>>, AttemptError> {
+        // UDP-disabled rules must not prevent an otherwise valid H1/H2 path.
+        let Ok((key, _)) = self.quic_route(nameserver) else {
+            return Ok(None);
+        };
+        Ok(self.tcp_pool.quic.get(&key))
+    }
+
+    #[cfg(feature = "dns-quic")]
+    fn start_quic(
+        &self,
+        nameserver: &ResolvedNameserver,
+        kind: super::quic::Kind,
+    ) -> Result<super::quic::Pending<TcpPoolKey>, AttemptError> {
+        let route = self.quic_route(nameserver);
+        let key = route.as_ref().map_or_else(
+            |_| TcpPoolKey {
+                upstream: nameserver.config.clone(),
+                endpoint: nameserver.endpoint(),
+                egress: DnsEgressKey::Single,
+                source_generation: nameserver.source_generation,
+                source_binding: nameserver.source_binding.clone(),
+            },
+            |(key, _)| key.clone(),
+        );
+        let nameserver = nameserver.clone();
+        let security = self.tcp_pool.security.clone();
+        let open = async move {
+            let (_, dispatcher) =
+                route.map_err(|error| io::Error::new(io::ErrorKind::ConnectionAborted, error))?;
+            let alpn = match kind {
+                super::quic::Kind::Doq => b"doq".to_vec(),
+                super::quic::Kind::H3 => b"h3".to_vec(),
+            };
+            let client = crate::security::StandardTlsClient::with_options(
+                &security,
+                nameserver.address.to_string(),
+                crate::security::TlsClientOptions {
+                    certificate: crate::config::TlsCertificatePolicy {
+                        verification_name: nameserver.options.verification_name.clone(),
+                        skip_cert_verify: nameserver.options.skip_cert_verify,
+                        fingerprint: None,
+                    },
+                    alpn: vec![alpn.clone()],
+                    required_alpn: Some(alpn),
+                    versions: crate::security::TlsVersions::Tls13,
+                    ..Default::default()
+                },
+                0,
+                64 * 1024,
+            )?;
+            let (tls, server_name) = client.quic_config()?;
+            let transport = dispatcher
+                .open_datagram(DatagramSession::new(
+                    InboundKind::InternalDns,
+                    internal_source(nameserver.endpoint.ip()),
+                ))
+                .await
+                .map_err(|error| io::Error::new(io::ErrorKind::ConnectionAborted, error))?;
+            let budget = transport.payload_budget(&Destination::Ip(nameserver.endpoint()));
+            Ok(super::quic::Raw {
+                transport,
+                peer: nameserver.endpoint(),
+                budget,
+                tls,
+                server_name,
+            })
+        };
+        self.tcp_pool
+            .quic
+            .start(key, kind, open)
+            .map_err(AttemptError::Io)
+    }
+
+    #[cfg(feature = "dns-quic")]
+    async fn exchange_quic<R>(
+        &self,
+        nameserver: &ResolvedNameserver,
+        query: &[u8],
+        validate: impl Fn(&[u8]) -> Result<R, AttemptError>,
+        kind: super::quic::Kind,
+    ) -> Result<(Vec<u8>, R), AttemptError> {
+        let (key, _) = self.quic_route(nameserver)?;
+        let lease = if let Some(lease) = self.tcp_pool.quic.get(&key) {
+            lease
+        } else {
+            let initialization = self.tcp_pool.quic.initialization(key.clone());
+            let _gate = initialization.lock().await;
+            if let Some(lease) = self.tcp_pool.quic.get(&key) {
+                lease
+            } else {
+                self.start_quic(nameserver, kind)?.finish().await?
+            }
+        };
+        lease
+            .exchange(&nameserver.config, query, |wire| {
+                validate(wire).map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))
+            })
+            .await
+            .map_err(AttemptError::Io)
+    }
+
+    async fn cache_response(
+        &self,
+        response: &DnsMessage,
+        query: &ClassifiedDnsQuery,
+        wire: &[u8],
+        epoch: u64,
+    ) -> Result<(), RuntimeDnsError> {
+        let current_epoch = self.cache_epoch.read().await;
+        if *current_epoch != epoch {
+            return Ok(());
+        }
+        let mut cache = self.cache.lock().await;
+        let now = Instant::now();
+        if query.needs_wire_cache {
+            let mut upstream_query = query.clone();
+            upstream_query.id = response.id;
+            let validated = super::validate_wire_response(&upstream_query, wire)
+                .map_err(RuntimeDnsError::InvalidResponse)?;
+            cache.insert_opaque(&validated, now);
+        }
         let name = &response.question.name;
         let query_type = response.question.query_type;
-        if response.rcode == RCODE_NXDOMAIN {
-            self.cache
-                .lock()
-                .await
+        if response.rcode == RCODE_NXDOMAIN && !query.needs_wire_cache {
+            cache
                 .insert_negative(name, query_type, RCODE_NXDOMAIN, now)
                 .map_err(RuntimeDnsError::Cache)?;
             return Ok(());
@@ -1531,21 +3517,23 @@ impl RuntimeDns {
 
         let answers = matching_answer_set(response).map_err(RuntimeDnsError::InvalidResponse)?;
         if answers.addresses.is_empty() {
-            self.cache
-                .lock()
-                .await
-                .insert_negative(name, query_type, RCODE_NOERROR, now)
-                .map_err(RuntimeDnsError::Cache)?;
+            if !query.needs_wire_cache {
+                cache
+                    .insert_negative(name, query_type, RCODE_NOERROR, now)
+                    .map_err(RuntimeDnsError::Cache)?;
+            }
             return Ok(());
         }
 
         let ttl = answers.ttl.unwrap_or(MIN_TTL_SECS);
-        self.cache
-            .lock()
-            .await
-            .insert_positive(name, query_type, &answers.addresses, ttl, now)
-            .map_err(RuntimeDnsError::Cache)?;
-        if let Some(hints) = &self.hints {
+        if !query.needs_wire_cache {
+            cache
+                .insert_positive(name, query_type, &answers.addresses, ttl, now)
+                .map_err(RuntimeDnsError::Cache)?;
+        }
+        if self.hints_writable.load(Ordering::Acquire)
+            && let Some(hints) = &self.hints
+        {
             let mut hints = hints
                 .lock()
                 .unwrap_or_else(std::sync::PoisonError::into_inner);
@@ -1577,6 +3565,26 @@ async fn exchange_tcp_framed(
     Ok(response)
 }
 
+async fn exchange_stream_validated<R, F>(
+    stream: &mut BoxStream,
+    server: &ResolvedNameserver,
+    query: &[u8],
+    validate: &F,
+) -> Result<(Vec<u8>, R, bool), AttemptError>
+where
+    F: Fn(&[u8]) -> Result<R, AttemptError>,
+{
+    if matches!(server.transport, DnsTransport::Http | DnsTransport::Https) {
+        let (wire, reusable) = super::https::exchange(stream, server, query).await?;
+        let response = validate(&wire)?;
+        Ok((wire, response, reusable))
+    } else {
+        exchange_tcp_validated(stream, query, validate)
+            .await
+            .map(|(wire, response)| (wire, response, true))
+    }
+}
+
 async fn exchange_tcp_validated<R, F>(
     stream: &mut BoxStream,
     query: &[u8],
@@ -1626,75 +3634,96 @@ where
     AttemptFuture: Future<Output = Result<T, AttemptError>>,
     RetryableResponse: Fn(&T) -> Option<u16>,
 {
-    let mut last_error: Box<str> = "no nameserver attempted".into();
-    for (nameserver_index, nameserver) in nameservers.iter().copied().enumerate() {
-        let now = TokioInstant::now();
-        if now >= deadline {
-            tracing::warn!(
-                nameserver_index,
-                event = "runtime_dns_total_deadline",
-                "runtime DNS deadline expired before nameserver attempt"
-            );
-            last_error = "runtime DNS total query deadline expired".into();
-            break;
-        }
-        let attempt_deadline = std::cmp::min(deadline, now + UPSTREAM_TIMEOUT);
-        match timeout_at(attempt_deadline, attempt(nameserver)).await {
-            Err(_) => {
-                tracing::warn!(
-                    nameserver_index,
-                    event = "runtime_dns_attempt_timeout",
-                    "runtime DNS nameserver attempt timed out"
-                );
-                last_error = format!("nameserver {nameserver_index} attempt timed out").into();
+    use futures_util::{StreamExt, stream};
+    if let Some(server) = nameservers
+        .iter()
+        .find(|server| matches!(server.transport, DnsTransport::Rcode(_)))
+    {
+        let result = timeout_at(deadline, Box::pin(attempt(server.clone()))).await;
+        crate::config::RuleDecision::default().check()?;
+        return match result {
+            Ok(Ok(response)) => {
+                crate::config::RuleDecision::default().check()?;
+                Ok(response)
             }
-            Ok(Err(error)) => {
-                tracing::debug!(
-                    nameserver_index,
-                    error_kind = error.category(),
-                    "runtime DNS nameserver attempt failed"
-                );
-                last_error = error.summary(nameserver_index);
+            Ok(Err(AttemptError::RuleEvaluation(failure))) => {
+                Err(RuntimeDnsError::RuleEvaluation(failure))
             }
-            Ok(Ok(response)) => {
-                let Some(rcode) = retryable_response(&response) else {
-                    return Ok(response);
-                };
-                tracing::debug!(
-                    nameserver_index,
-                    rcode,
-                    "runtime DNS nameserver returned a retryable response"
-                );
-                last_error = format!(
-                    "nameserver {nameserver_index} returned retryable response code {rcode}"
+            Ok(Err(error)) => Err(RuntimeDnsError::UpstreamsExhausted {
+                last_error: error.summary(0),
+            }),
+            Err(_) => Err(RuntimeDnsError::UpstreamsExhausted {
+                last_error: "local DNS response timed out".into(),
+            }),
+        };
+    }
+    let mut last_error: Box<str> = "no nameserver attempted".into();
+    let mut attempts = stream::iter(nameservers.iter().cloned().enumerate())
+        .map(|(index, server)| {
+            let future = attempt(server);
+            async move {
+                (
+                    index,
+                    timeout_at(deadline.min(TokioInstant::now() + UPSTREAM_TIMEOUT), future).await,
                 )
-                .into();
             }
-        }
-        if nameserver_index + 1 < nameservers.len() {
-            tracing::debug!(
-                nameserver_index,
-                event = "runtime_dns_nameserver_failover",
-                "runtime DNS is trying the next nameserver"
-            );
+        })
+        .buffer_unordered(4);
+    while let Some((index, result)) = attempts.next().await {
+        crate::config::RuleDecision::default().check()?;
+        match result {
+            Ok(Ok(response)) if retryable_response(&response).is_none() => {
+                crate::config::RuleDecision::default().check()?;
+                return Ok(response);
+            }
+            Ok(Ok(_)) => {
+                last_error = format!("nameserver {index} returned a retryable response").into()
+            }
+            Ok(Err(AttemptError::RuleEvaluation(failure))) => {
+                return Err(RuntimeDnsError::RuleEvaluation(failure));
+            }
+            Ok(Err(error)) => last_error = error.summary(index),
+            Err(_) => last_error = format!("nameserver {index} timed out").into(),
         }
     }
     Err(RuntimeDnsError::UpstreamsExhausted { last_error })
 }
 
+#[derive(Clone)]
+struct ResolvedNameserver {
+    config: DnsNameserver,
+    endpoint: SocketAddr,
+    physical: Option<Arc<dyn Dispatcher>>,
+    source_generation: u64,
+    source_binding: Option<super::source::DnsBinding>,
+}
+impl std::ops::Deref for ResolvedNameserver {
+    type Target = DnsNameserver;
+    fn deref(&self) -> &Self::Target {
+        &self.config
+    }
+}
+impl ResolvedNameserver {
+    fn endpoint(&self) -> SocketAddr {
+        self.endpoint
+    }
+}
+#[cfg(test)]
 impl DnsNameserver {
-    fn endpoint(self) -> SocketAddr {
-        SocketAddr::new(self.address, self.port)
+    fn endpoint(&self) -> SocketAddr {
+        match self.address {
+            DnsAddress::Ip(ip) => SocketAddr::new(ip, self.port),
+            _ => panic!("test requires literal DNS endpoint"),
+        }
     }
 }
-
 impl fmt::Display for DnsNameserver {
     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let transport = match self.transport {
-            DnsTransport::Udp => "udp",
-            DnsTransport::Tcp => "tcp",
-        };
-        write!(formatter, "{transport}://{}", self.endpoint())
+        write!(
+            formatter,
+            "{:?}://{}:{}",
+            self.transport, self.address, self.port
+        )
     }
 }
 
@@ -1707,8 +3736,10 @@ enum LookupResult {
 
 #[derive(Debug, thiserror::Error)]
 enum AttemptError {
+    #[error("DNS rule evaluation failed: {0}")]
+    RuleEvaluation(crate::config::MatchFailure),
     #[error("dispatcher failed: {0}")]
-    Dispatch(#[from] DispatchError),
+    Dispatch(DispatchError),
     #[error("stream I/O failed: {0}")]
     Io(#[from] io::Error),
     #[error("invalid response: {0}")]
@@ -1721,9 +3752,19 @@ enum AttemptError {
     MessageTooLarge,
 }
 
+impl From<DispatchError> for AttemptError {
+    fn from(error: DispatchError) -> Self {
+        match error {
+            DispatchError::RuleEvaluation(failure) => Self::RuleEvaluation(failure),
+            error => Self::Dispatch(error),
+        }
+    }
+}
+
 impl AttemptError {
     fn category(&self) -> &'static str {
         match self {
+            Self::RuleEvaluation(_) => "rule evaluation",
             Self::Dispatch(_) => "dispatcher",
             Self::Io(_) => "I/O",
             Self::InvalidResponse(_) => "invalid response",
@@ -1740,7 +3781,7 @@ impl AttemptError {
 
 fn udp_response_matches_query(query: &DnsMessage, response: &[u8]) -> Result<bool, AttemptError> {
     match validate_response_identity(query, response) {
-        Ok(_) => Ok(true),
+        Ok(_) | Err(DnsError::TruncatedResponse) => Ok(true),
         Err(DnsError::ResponseMismatch | DnsError::NotAResponse | DnsError::UnsupportedOpcode) => {
             Ok(false)
         }
@@ -1757,6 +3798,7 @@ fn udp_response_matches_classified_query(
         Err(DnsError::ResponseMismatch | DnsError::NotAResponse | DnsError::UnsupportedOpcode) => {
             Ok(false)
         }
+        Err(DnsError::TruncatedResponse) => Ok(true),
         Err(error) => Err(AttemptError::InvalidResponse(error)),
     }
 }
@@ -1933,7 +3975,7 @@ mod tests {
         config::{DnsNameserverPolicy, DnsRoute, IpCidr, RuleAction, RuleKind, RuleSpec},
         dialer::Dialer,
         dispatch::{BoxStream, DatagramTransport},
-        dns::{DnsQuestion, DnsRecord},
+        dns::{DnsQuestion, DnsRecord, MAX_CACHE_ENTRIES},
         geodata::{DynamicGeoData, GEOSITE_FILE_NAME, GeoData},
         outbound::DirectOutbound,
         routing::{EmptyGeoMatcher, RuleSet},
@@ -2051,6 +4093,7 @@ mod tests {
         udp_queries: Arc<StdMutex<Vec<u16>>>,
         tcp_queries: Arc<StdMutex<Vec<u16>>>,
         udp_ids: Arc<StdMutex<Vec<u16>>>,
+        udp_payloads: Arc<StdMutex<Vec<Vec<u8>>>>,
         tcp_ids: Arc<StdMutex<Vec<u16>>>,
         udp_destinations: Arc<StdMutex<Vec<Destination>>>,
         tcp_destinations: Arc<StdMutex<Vec<Destination>>>,
@@ -2210,6 +4253,7 @@ mod tests {
                 remote: None,
                 queries: self.udp_queries.clone(),
                 ids: self.udp_ids.clone(),
+                payloads: self.udp_payloads.clone(),
                 destinations: self.udp_destinations.clone(),
                 send_count: 0,
             }))
@@ -2222,14 +4266,23 @@ mod tests {
         remote: Option<Destination>,
         queries: Arc<StdMutex<Vec<u16>>>,
         ids: Arc<StdMutex<Vec<u16>>>,
+        payloads: Arc<StdMutex<Vec<Vec<u8>>>>,
         destinations: Arc<StdMutex<Vec<Destination>>>,
         send_count: usize,
     }
 
     #[async_trait]
     impl DatagramTransport for MockDatagrams {
+        fn supports_shared_destinations(&self) -> bool {
+            false
+        }
+
         async fn send(&mut self, datagram: Datagram) -> Result<(), DispatchError> {
             self.send_count += 1;
+            self.payloads
+                .lock()
+                .unwrap()
+                .push(datagram.payload.to_vec());
             let parsed = classify_query(&datagram.payload)
                 .map_err(|error| DispatchError::Other(error.to_string()))?;
             self.queries
@@ -2315,8 +4368,11 @@ mod tests {
 
     fn nameserver(index: u8, transport: DnsTransport) -> DnsNameserver {
         DnsNameserver {
+            path: None,
+            http_auth: None,
+            options: Default::default(),
             transport,
-            address: IpAddr::V4(Ipv4Addr::new(192, 0, 2, index)),
+            address: IpAddr::V4(Ipv4Addr::new(192, 0, 2, index)).into(),
             port: 53,
             route: crate::config::DnsRoute::Route(crate::config::RouteTargetId::Proxy(
                 crate::config::ProxyId::new(0).unwrap(),
@@ -2326,11 +4382,13 @@ mod tests {
 
     fn dns_policy(codes: &[&str], nameservers: Vec<DnsNameserver>) -> DnsNameserverPolicy {
         DnsNameserverPolicy {
-            geosite_codes: codes
-                .iter()
-                .map(|code| (*code).to_owned())
-                .collect::<Vec<_>>()
-                .into_boxed_slice(),
+            selector: crate::config::DnsPolicySelector::GeoSite(
+                codes
+                    .iter()
+                    .map(|code| (*code).to_owned())
+                    .collect::<Vec<_>>()
+                    .into_boxed_slice(),
+            ),
             nameservers: nameservers.into_boxed_slice(),
         }
     }
@@ -2356,874 +4414,1894 @@ mod tests {
             ipv6,
             nameservers,
             nameserver_policies: Vec::new(),
+            ..DnsConfig::default()
         }
     }
 
-    fn response_for_query(query: &[u8], spec: &ResponseSpec) -> Vec<u8> {
-        classify_query(query).unwrap();
-        let mut response = query.to_vec();
-        let mut flags = DNS_FLAG_RESPONSE
-            | DNS_FLAG_RECURSION_DESIRED
-            | DNS_FLAG_RECURSION_AVAILABLE
-            | u16::from(spec.rcode);
-        if spec.truncated {
-            flags |= 0x0200;
-        }
-        response[2..4].copy_from_slice(&flags.to_be_bytes());
-        let answer_count = spec.answers.len() as u16;
-        response[6..8].copy_from_slice(&answer_count.to_be_bytes());
-        for address in &spec.answers {
-            response.extend_from_slice(&[0xc0, 0x0c]);
-            match address {
-                IpAddr::V4(address) => {
-                    response.extend_from_slice(&(QueryType::A as u16).to_be_bytes());
-                    response.extend_from_slice(&DNS_CLASS_IN.to_be_bytes());
-                    response.extend_from_slice(&60_u32.to_be_bytes());
-                    response.extend_from_slice(&4_u16.to_be_bytes());
-                    response.extend_from_slice(&address.octets());
-                }
-                IpAddr::V6(address) => {
-                    response.extend_from_slice(&(QueryType::Aaaa as u16).to_be_bytes());
-                    response.extend_from_slice(&DNS_CLASS_IN.to_be_bytes());
-                    response.extend_from_slice(&60_u32.to_be_bytes());
-                    response.extend_from_slice(&16_u16.to_be_bytes());
-                    response.extend_from_slice(&address.octets());
-                }
+    async fn stale_seed(resolver: &RuntimeDns, name: &str, address: IpAddr) {
+        resolver
+            .cache
+            .lock()
+            .await
+            .insert_positive(
+                name,
+                QueryType::A,
+                &[address],
+                30,
+                Instant::now() - Duration::from_secs(31),
+            )
+            .unwrap();
+    }
+
+    async fn stale_wait(mut ready: impl FnMut() -> bool) {
+        tokio::time::timeout(Duration::from_secs(1), async {
+            while !ready() {
+                tokio::task::yield_now().await;
             }
-        }
-        response
+        })
+        .await
+        .unwrap();
     }
 
-    fn parsed_response_with_answers(
-        name: &str,
-        query_type: QueryType,
-        answers: Vec<DnsRecord>,
-    ) -> DnsMessage {
-        let answer_count = u16::try_from(answers.len()).unwrap();
-        DnsMessage {
-            id: 1,
-            is_response: true,
-            authoritative: false,
-            recursion_desired: true,
-            recursion_available: true,
-            rcode: RCODE_NOERROR,
-            question: DnsQuestion {
-                name: name.to_owned(),
-                query_type,
-            },
-            answers,
-            answer_count,
+    #[tokio::test]
+    async fn stale_refresh_roles_bind_one_owner_and_new_trees_only_share_budget() {
+        let mut configuration = config(false, vec![nameserver(1, DnsTransport::Udp)]);
+        configuration.proxy_nameservers = configuration.nameservers.clone();
+        configuration.direct_nameservers = configuration.nameservers.clone();
+        let egress = Arc::new(MockDispatcher::default());
+        let old = Arc::new(RuntimeDns::new(&configuration, egress.clone()));
+        old.enable_refresh(None);
+        let current =
+            Arc::new(RuntimeDns::new(&configuration, egress).with_mapping_from(Some(&old)));
+        current.enable_refresh(Some(&old));
+        for root in [&old, &current] {
+            for role in [
+                root.bootstrap.as_ref().unwrap(),
+                root.proxy_resolver.as_ref().unwrap(),
+                root.direct_resolver.as_ref().unwrap(),
+            ] {
+                assert!(Arc::ptr_eq(
+                    &root.refresh.get().unwrap().owner,
+                    &role.refresh.get().unwrap().owner
+                ));
+            }
+        }
+        old.retire_configuration_hints();
+        for role in [
+            &current,
+            current.bootstrap.as_ref().unwrap(),
+            current.proxy_resolver.as_ref().unwrap(),
+            current.direct_resolver.as_ref().unwrap(),
+        ] {
+            assert!(!role.refresh.get().unwrap().owner.is_closed());
         }
+        old.shutdown().await;
+        current.shutdown().await;
     }
 
+    #[cfg(any(feature = "outbound-wireguard", feature = "outbound-masque"))]
     #[tokio::test]
-    async fn udp_exchange_uses_internal_context_and_fixed_ip_endpoint() {
-        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 10));
-        let dispatcher = Arc::new(MockDispatcher::with_replies(
-            vec![MockReply::Response(ResponseSpec::answer(address))],
-            vec![],
+    async fn stale_refresh_private_nodes_share_budget_without_stopping_parent() {
+        let configuration = config(false, vec![nameserver(1, DnsTransport::Udp)]);
+        let egress = Arc::new(MockDispatcher::default());
+        let root = Arc::new(RuntimeDns::new(&configuration, egress.clone()));
+        root.enable_refresh(None);
+        let resolution = super::super::resolution::ResolutionContext::runtime(false);
+        resolution.bind_runtime(Some(&root)).unwrap();
+        let private = Arc::new(RuntimeDns::new_for_node(
+            &configuration,
+            egress.clone(),
+            resolution.clone(),
+            crate::security::SecurityContext::new(),
         ));
-        let resolver = RuntimeDns::new(
-            &config(false, vec![nameserver(1, DnsTransport::Udp)]),
-            dispatcher.clone(),
-        );
-        let query = build_query(42, "example.com", QueryType::A).unwrap();
-        let response = resolver.exchange(&query).await.unwrap();
+        private.enable_refresh(None);
+        assert!(Arc::ptr_eq(
+            &root.refresh.get().unwrap().owner.budget,
+            &private.refresh.get().unwrap().owner.budget
+        ));
+        assert!(!Arc::ptr_eq(
+            &root.refresh.get().unwrap().owner,
+            &private.refresh.get().unwrap().owner
+        ));
+        private.shutdown().await;
+        assert!(!root.refresh.get().unwrap().owner.is_closed());
+        #[cfg(feature = "outbound-masque")]
+        {
+            let masque = RuntimeDns::new_for_masque_node(
+                &configuration,
+                egress,
+                resolution,
+                crate::security::SecurityContext::new(),
+            );
+            assert!(Arc::ptr_eq(
+                &root.refresh.get().unwrap().owner.budget,
+                &masque.refresh.get().unwrap().owner.budget
+            ));
+            masque.shutdown().await;
+            assert!(!root.refresh.get().unwrap().owner.is_closed());
+        }
+        root.shutdown().await;
+    }
 
-        assert_eq!(
-            matching_answer_set(&parse_response(&response).unwrap())
-                .unwrap()
-                .addresses,
-            [address]
-        );
-        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 1);
-        assert_eq!(dispatcher.tcp_calls.load(Ordering::Acquire), 0);
-        assert_eq!(
-            *dispatcher.udp_destinations.lock().unwrap(),
-            vec![Destination::Ip("192.0.2.1:53".parse().unwrap())]
-        );
-        assert_eq!(
-            *dispatcher.inbounds.lock().unwrap(),
-            vec![InboundKind::InternalDns]
-        );
+    #[tokio::test]
+    async fn stale_refresh_typed_answers_do_not_replay_upstream_authenticated_flags() {
+        let configuration = config(false, vec![nameserver(1, DnsTransport::Udp)]);
+        let dns = Arc::new(RuntimeDns::new(
+            &configuration,
+            Arc::new(MockDispatcher::default()),
+        ));
+        dns.enable_refresh(None);
+        let query = build_query(1, "ordinary.example", QueryType::A).unwrap();
+        let parsed = parse_query(&query).unwrap();
+        let classified = classify_query(&query).unwrap();
+        let mut upstream =
+            response_for_query(&query, &ResponseSpec::answer("192.0.2.50".parse().unwrap()));
+        upstream[3] |= 0x20;
+        let response = parse_response(&upstream).unwrap();
+        dns.cache_response(&response, &classified, &upstream, 0)
+            .await
+            .unwrap();
+        let super::super::CacheLookup::Stale((cached, ttl)) =
+            dns.cache.lock().await.lookup_with_ttl(
+                "ordinary.example",
+                QueryType::A,
+                Instant::now() + Duration::from_secs(61),
+                true,
+            )
+        else {
+            panic!("ordinary typed result retains only IP semantics");
+        };
+        let wire = synthesize_response(&parsed, &cached, ttl).unwrap();
+        assert_eq!(u16::from_be_bytes([wire[2], wire[3]]) & 0x0030, 0);
+        assert_eq!(&wire[8..12], &[0, 0, 0, 0]);
+        dns.shutdown().await;
     }
 
     #[tokio::test]
-    async fn wire_queries_use_distinct_nonzero_upstream_ids_and_restore_the_client_id() {
-        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 12));
+    async fn stale_refresh_returns_immediately_deduplicates_and_restores_hints() {
+        let old = "192.0.2.10".parse().unwrap();
+        let new = "192.0.2.11".parse().unwrap();
+        let release = Arc::new(Notify::new());
         let dispatcher = Arc::new(MockDispatcher::with_replies(
-            vec![
-                MockReply::Response(ResponseSpec::answer(address)),
-                MockReply::Response(ResponseSpec::answer(address)),
-            ],
+            vec![MockReply::Gated {
+                response: ResponseSpec::answer(new),
+                release: release.clone(),
+            }],
             vec![],
         ));
-        let resolver = RuntimeDns::new(
+        let dns = Arc::new(RuntimeDns::new(
             &config(false, vec![nameserver(1, DnsTransport::Udp)]),
             dispatcher.clone(),
-        );
-
-        for name in ["first.example", "second.example"] {
-            let query = build_query(77, name, QueryType::A).unwrap();
-            let response = resolver.exchange(&query).await.unwrap();
-            assert_eq!(parse_response(&response).unwrap().id, 77);
+        ));
+        dns.enable_refresh(None);
+        stale_seed(&dns, "stale.example", old).await;
+        for id in 1..=32 {
+            let wire = dns
+                .exchange(&build_query(id, "stale.example", QueryType::A).unwrap())
+                .await
+                .unwrap();
+            let parsed = parse_response(&wire).unwrap();
+            assert_eq!(parsed.id, id);
+            assert_eq!(parsed.answers[0].ttl, 1);
+            assert_eq!(matching_answer_set(&parsed).unwrap().addresses, [old]);
         }
-
-        let ids = dispatcher.udp_ids.lock().unwrap();
-        assert_eq!(ids.len(), 2);
-        assert!(ids.iter().all(|id| *id != 0));
-        assert_ne!(ids[0], ids[1]);
+        stale_wait(|| dispatcher.udp_calls.load(Ordering::Acquire) == 1).await;
+        assert_eq!(dns.singleflight.len(), 1);
+        assert_eq!(dns.domain_hint(old).await.as_deref(), Some("stale.example"));
+        release.notify_waiters();
+        stale_wait(|| dns.singleflight.len() == 0).await;
+        let wire = dns
+            .exchange(&build_query(33, "stale.example", QueryType::A).unwrap())
+            .await
+            .unwrap();
+        assert_eq!(
+            matching_answer_set(&parse_response(&wire).unwrap())
+                .unwrap()
+                .addresses,
+            [new]
+        );
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 1);
+        dns.shutdown().await;
     }
 
     #[tokio::test]
-    async fn udp_retry_reuses_one_transport_and_one_rewritten_id() {
-        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 13));
+    async fn stale_refresh_failure_backs_off_without_losing_the_resident() {
+        let old = "192.0.2.20".parse().unwrap();
+        let new = "192.0.2.21".parse().unwrap();
         let dispatcher = Arc::new(MockDispatcher::with_replies(
-            vec![MockReply::AfterRetry(ResponseSpec::answer(address))],
+            vec![
+                MockReply::TransportError,
+                MockReply::Response(ResponseSpec::answer(new)),
+            ],
             vec![],
         ));
-        let resolver = RuntimeDns::new(
+        let dns = Arc::new(RuntimeDns::new(
             &config(false, vec![nameserver(1, DnsTransport::Udp)]),
             dispatcher.clone(),
-        );
-        let query = build_query(0, "retry.example", QueryType::A).unwrap();
-        let response = resolver.exchange(&query).await.unwrap();
-
-        assert_eq!(parse_response(&response).unwrap().id, 0);
+        ));
+        dns.enable_refresh(None);
+        stale_seed(&dns, "retry.example", old).await;
+        let query = build_query(1, "retry.example", QueryType::A).unwrap();
+        dns.exchange(&query).await.unwrap();
+        stale_wait(|| {
+            dispatcher.udp_calls.load(Ordering::Acquire) == 1 && dns.singleflight.len() == 0
+        })
+        .await;
+        for _ in 0..16 {
+            dns.exchange(&query).await.unwrap();
+        }
         assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 1);
-        let ids = dispatcher.udp_ids.lock().unwrap();
-        assert_eq!(ids.len(), 2);
-        assert_ne!(ids[0], 0);
-        assert_eq!(ids[0], ids[1]);
+        let classified = classify_query(&query).unwrap();
+        dns.cache
+            .lock()
+            .await
+            .finish_refresh(&classified, Instant::now(), Duration::ZERO);
+        dns.exchange(&query).await.unwrap();
+        stale_wait(|| {
+            dispatcher.udp_calls.load(Ordering::Acquire) == 2 && dns.singleflight.len() == 0
+        })
+        .await;
+        let wire = dns.exchange(&query).await.unwrap();
+        assert_eq!(
+            matching_answer_set(&parse_response(&wire).unwrap())
+                .unwrap()
+                .addresses,
+            [new]
+        );
+        dns.shutdown().await;
     }
 
     #[tokio::test]
-    async fn udp_ignores_two_mismatches_but_the_third_fails_over() {
-        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 14));
-        let first_dispatcher = Arc::new(MockDispatcher::with_replies(
-            vec![MockReply::MismatchesThenResponse {
-                remaining: 2,
-                response: ResponseSpec::answer(address),
-            }],
+    async fn stale_refresh_shared_budget_keeps_generation_stop_owners_separate() {
+        let dispatcher = Arc::new(MockDispatcher::with_replies(
+            (0..5).map(|_| MockReply::Pending).collect(),
             vec![],
         ));
-        let first_resolver = RuntimeDns::new(
-            &config(false, vec![nameserver(1, DnsTransport::Udp)]),
-            first_dispatcher.clone(),
+        let configuration = config(false, vec![nameserver(1, DnsTransport::Udp)]);
+        let old = Arc::new(RuntimeDns::new(&configuration, dispatcher.clone()));
+        old.enable_refresh(None);
+        let current = Arc::new(
+            RuntimeDns::new(&configuration, dispatcher.clone()).with_mapping_from(Some(&old)),
         );
-        let query = build_query(88, "mismatch.example", QueryType::A).unwrap();
-        let response = first_resolver.exchange(&query).await.unwrap();
-        assert_eq!(parse_response(&response).unwrap().id, 88);
-        assert_eq!(first_dispatcher.udp_calls.load(Ordering::Acquire), 1);
+        current.enable_refresh(Some(&old));
+        assert!(Arc::ptr_eq(
+            &old.refresh.get().unwrap().owner.budget,
+            &current.refresh.get().unwrap().owner.budget
+        ));
+        assert!(!Arc::ptr_eq(
+            &old.refresh.get().unwrap().owner,
+            &current.refresh.get().unwrap().owner
+        ));
+        for index in 0..5 {
+            let name = format!("budget{index}.example");
+            stale_seed(&old, &name, "192.0.2.30".parse().unwrap()).await;
+            old.exchange(&build_query(index, &name, QueryType::A).unwrap())
+                .await
+                .unwrap();
+        }
+        stale_wait(|| dispatcher.udp_calls.load(Ordering::Acquire) == 4).await;
+        assert_eq!(old.singleflight.len(), 4);
+        stale_seed(&current, "current.example", "192.0.2.31".parse().unwrap()).await;
+        let query = build_query(7, "current.example", QueryType::A).unwrap();
+        current.exchange(&query).await.unwrap();
+        assert_eq!(current.singleflight.len(), 0);
+        old.shutdown().await;
+        assert_eq!(old.singleflight.len(), 0);
+        assert!(!current.refresh.get().unwrap().owner.is_closed());
+        current.exchange(&query).await.unwrap();
+        stale_wait(|| dispatcher.udp_calls.load(Ordering::Acquire) == 5).await;
+        current.shutdown().await;
+        assert_eq!(current.singleflight.len(), 0);
+        assert_eq!(
+            current
+                .refresh
+                .get()
+                .unwrap()
+                .owner
+                .budget
+                .available_permits(),
+            4
+        );
+    }
 
-        let fallback_dispatcher = Arc::new(MockDispatcher::with_replies(
+    #[tokio::test]
+    async fn stale_refresh_flush_and_retirement_cannot_refill_current_state() {
+        let release = Arc::new(Notify::new());
+        let old = "192.0.2.40".parse().unwrap();
+        let late = "192.0.2.41".parse().unwrap();
+        let dispatcher = Arc::new(MockDispatcher::with_replies(
             vec![
-                MockReply::MismatchesThenResponse {
-                    remaining: 3,
-                    response: ResponseSpec::answer(address),
+                MockReply::Gated {
+                    response: ResponseSpec::answer(late),
+                    release: release.clone(),
                 },
-                MockReply::Response(ResponseSpec::answer(address)),
+                MockReply::Pending,
             ],
             vec![],
         ));
-        let fallback_resolver = RuntimeDns::new(
-            &config(
-                false,
-                vec![
-                    nameserver(1, DnsTransport::Udp),
-                    nameserver(2, DnsTransport::Udp),
-                ],
-            ),
-            fallback_dispatcher.clone(),
-        );
-        let response = fallback_resolver.exchange(&query).await.unwrap();
-        assert_eq!(parse_response(&response).unwrap().id, 88);
-        assert_eq!(fallback_dispatcher.udp_calls.load(Ordering::Acquire), 2);
-    }
-
-    #[test]
-    fn typed_udp_ignores_a_mismatched_tc_response_before_rejecting_matching_tc() {
-        let query = build_query(88, "mismatch.example", QueryType::A).unwrap();
-        let parsed_query = parse_query(&query).unwrap();
-        let mut response = response_for_query(&query, &ResponseSpec::truncated());
-        response[..2].copy_from_slice(&89_u16.to_be_bytes());
-        assert!(!udp_response_matches_query(&parsed_query, &response).unwrap());
-
-        response[..2].copy_from_slice(&88_u16.to_be_bytes());
-        assert!(matches!(
-            udp_response_matches_query(&parsed_query, &response),
-            Err(AttemptError::InvalidResponse(DnsError::TruncatedResponse))
-        ));
+        let configuration = config(false, vec![nameserver(1, DnsTransport::Udp)]);
+        let dns = Arc::new(RuntimeDns::new(&configuration, dispatcher.clone()));
+        dns.enable_refresh(None);
+        stale_seed(&dns, "epoch.example", old).await;
+        let query = build_query(1, "epoch.example", QueryType::A).unwrap();
+        dns.exchange(&query).await.unwrap();
+        stale_wait(|| dispatcher.udp_calls.load(Ordering::Acquire) == 1).await;
+        dns.flush_cache().await;
+        release.notify_waiters();
+        stale_wait(|| dns.singleflight.len() == 0).await;
+        assert!(dns.cache.lock().await.is_empty());
+        assert!(dns.domain_hint(late).await.is_none());
+        stale_seed(&dns, "epoch.example", old).await;
+        dns.exchange(&query).await.unwrap();
+        stale_wait(|| dispatcher.udp_calls.load(Ordering::Acquire) == 2).await;
+        let current =
+            Arc::new(RuntimeDns::new(&configuration, dispatcher).with_mapping_from(Some(&dns)));
+        current.enable_refresh(Some(&dns));
+        {
+            let _publication = current.configuration_publication().await;
+            dns.retire_configuration_hints();
+        }
+        dns.refresh.get().unwrap().owner.shutdown().await;
+        assert_eq!(dns.singleflight.len(), 0);
+        assert!(current.cache.lock().await.is_empty());
+        assert!(current.domain_hint(old).await.is_none());
+        assert!(!current.refresh.get().unwrap().owner.is_closed());
+        dns.shutdown().await;
+        current.shutdown().await;
     }
 
     #[tokio::test]
-    async fn configured_tcp_nameserver_uses_dns_framing() {
-        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 11));
+    async fn stale_refresh_opaque_uses_wire_cache_and_stop_joins_its_flight() {
         let dispatcher = Arc::new(MockDispatcher::with_replies(
+            vec![MockReply::Pending],
             vec![],
-            vec![MockReply::Response(ResponseSpec::answer(address))],
         ));
-        let resolver = RuntimeDns::new(
-            &config(false, vec![nameserver(1, DnsTransport::Tcp)]),
+        let dns = Arc::new(RuntimeDns::new(
+            &config(false, vec![nameserver(1, DnsTransport::Udp)]),
             dispatcher.clone(),
+        ));
+        dns.enable_refresh(None);
+        let query = opaque_query(1, "txt-stale.example", 16);
+        let classified = classify_query(&query).unwrap();
+        let mut wire = super::super::synthesize_empty_response(&classified, 0).unwrap();
+        wire[6..8].copy_from_slice(&1_u16.to_be_bytes());
+        wire.extend_from_slice(&[
+            0xc0, 0x0c, 0, 16, 0, 1, 0, 0, 0, 30, 0, 4, 3, b'o', b'l', b'd',
+        ]);
+        let validated = validate_opaque_response(&classified, &wire).unwrap();
+        dns.cache
+            .lock()
+            .await
+            .insert_opaque(&validated, Instant::now() - Duration::from_secs(31));
+        for _ in 0..16 {
+            let response = dns.exchange(&query).await.unwrap();
+            assert_eq!(&response[response.len() - 4..], &[3, b'o', b'l', b'd']);
+        }
+        stale_wait(|| dispatcher.udp_calls.load(Ordering::Acquire) == 1).await;
+        assert_eq!(dns.singleflight.len(), 1);
+        assert!(
+            dns.domain_hint("192.0.2.1".parse().unwrap())
+                .await
+                .is_none()
         );
-
-        assert_eq!(resolver.resolve("example.com").await.unwrap(), [address]);
-        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 0);
-        assert_eq!(dispatcher.tcp_calls.load(Ordering::Acquire), 1);
-        assert_eq!(
-            *dispatcher.tcp_destinations.lock().unwrap(),
-            vec![Destination::Ip("192.0.2.1:53".parse().unwrap())]
-        );
+        tokio::time::timeout(Duration::from_secs(1), dns.shutdown())
+            .await
+            .unwrap();
+        assert_eq!(dns.singleflight.len(), 0);
+        assert_eq!(dns.resource_stats.snapshot().dns_current, 0);
         assert_eq!(
-            *dispatcher.tcp_queries.lock().unwrap(),
-            vec![QueryType::A as u16]
+            dns.refresh.get().unwrap().owner.budget.available_permits(),
+            4
         );
     }
 
     #[test]
-    fn tcp_pool_resource_contract_is_stable() {
-        assert_eq!(TCP_POOL_MAX_IDLE, 4);
-        assert_eq!(TCP_POOL_MAX_IDLE_PER_KEY, 2);
-        assert_eq!(TCP_POOL_IDLE_TIMEOUT, Duration::from_secs(30));
-        assert_eq!(TCP_POOL_FINAL_EVENT, "runtime_dns_tcp_pool_final");
+    fn address_query_does_not_reserve_unused_fallback_state() {
+        let upstream = nameserver(1, DnsTransport::Udp);
+        let resolver = RuntimeDns::new(
+            &config(false, vec![upstream]),
+            Arc::new(MockDispatcher::default()),
+        );
+        let query = build_query(7, "memory.example", QueryType::A).unwrap();
+        let classified = classify_query(&query).unwrap();
+        let permit = resolver.begin_query();
+        let address = resolver.exchange_address(
+            &query,
+            &classified,
+            permit.deadline,
+            FailureMode::WireServfail,
+        );
+        let leader = resolver.exchange_address_leader(&query, &classified, permit.deadline, 0);
+        // These are the production futures; constructing them opens no I/O.
+        let bytes = std::mem::size_of_val(&leader);
+        assert!(
+            bytes <= 1024,
+            "single-upstream DNS leader reserves {bytes} bytes including inactive fallback state"
+        );
+        let bytes = std::mem::size_of_val(&address);
+        assert!(
+            bytes <= 2048,
+            "ordinary address query retains {bytes} bytes"
+        );
     }
 
-    #[tokio::test]
-    async fn tcp_pool_reuses_one_validated_connection_across_queries() {
-        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 61));
-        let dispatcher = Arc::new(ScriptedTcpDispatcher::new(vec![vec![
-            TcpScriptReply::Response(ResponseSpec::answer(address)),
-            TcpScriptReply::Response(ResponseSpec::answer(address)),
-        ]]));
+    #[test]
+    fn udp_attempt_does_not_retain_unused_stream_handshake_state() {
+        let upstream = nameserver(1, DnsTransport::Udp);
         let resolver = RuntimeDns::new(
-            &config(false, vec![nameserver(1, DnsTransport::Tcp)]),
-            dispatcher.clone(),
+            &config(false, vec![upstream.clone()]),
+            Arc::new(MockDispatcher::default()),
+        );
+        let query = build_query(7, "memory.example", QueryType::A).unwrap();
+        let parsed = parse_query(&query).unwrap();
+        let permits = Semaphore::new(4);
+        // Construct the real racing attempt without polling or opening I/O.
+        let attempt = resolver.exchange_nameserver_limited(upstream, &query, &parsed, &permits);
+        let bytes = std::mem::size_of_val(&attempt);
+        assert!(
+            bytes <= 4096,
+            "UDP DNS attempt retains {bytes} bytes before selecting a transport"
         );
-
-        assert_eq!(resolver.resolve("first.example").await.unwrap(), [address]);
-        assert_eq!(resolver.resolve("second.example").await.unwrap(), [address]);
-
-        let snapshot = resolver.tcp_pool.snapshot();
-        assert_eq!(dispatcher.tcp_calls.load(Ordering::Acquire), 1);
-        assert_eq!(dispatcher.tcp_queries.load(Ordering::Acquire), 2);
-        assert_eq!(snapshot.physical_opens, 1);
-        assert_eq!(snapshot.reuse_hits, 1);
-        assert_eq!(snapshot.current_idle, 1);
-        assert_eq!(snapshot.current_busy, 0);
     }
 
     #[tokio::test]
-    async fn stale_reused_tcp_connection_rebuilds_only_once() {
-        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 62));
-        let dispatcher = Arc::new(ScriptedTcpDispatcher::new(vec![
-            vec![TcpScriptReply::Response(ResponseSpec::answer(address))],
-            vec![TcpScriptReply::Response(ResponseSpec::answer(address))],
-        ]));
-        let resolver = RuntimeDns::new(
-            &config(false, vec![nameserver(1, DnsTransport::Tcp)]),
-            dispatcher.clone(),
+    async fn classical_logical_selectors_drive_dns_policy_and_sniffing_without_egress() {
+        let configuration = crate::config::Config::parse_yaml(
+            br#"
+rule-providers:
+  domains:
+    type: inline
+    behavior: classical
+    payload: ['AND,((DOMAIN-SUFFIX,example),(DOMAIN-KEYWORD,api))']
+  blocked:
+    type: inline
+    behavior: classical
+    payload: ['OR,((DOMAIN,skip.example),(DOMAIN,other.example))']
+  addresses:
+    type: inline
+    behavior: classical
+    payload: ['AND,((IP-CIDR,192.0.2.0/24),(NOT,((IP-CIDR,192.0.2.7/32))))']
+dns:
+  enable: true
+  use-system-hosts: false
+  nameserver: ['rcode://success']
+  nameserver-policy:
+    'rule-set:domains': ['rcode://refused']
+sniffer:
+  enable: true
+  parse-pure-ip: false
+  force-dns-mapping: false
+  force-domain: ['rule-set:domains']
+  skip-domain: ['rule-set:blocked']
+  skip-src-address: ['rule-set:addresses']
+  skip-dst-address: ['rule-set:addresses']
+  sniff: {TLS: {ports: [443]}}
+"#,
+        )
+        .unwrap();
+        let dispatcher = Arc::new(MockDispatcher::with_replies(vec![], vec![]));
+        let resolver = RuntimeDns::new(&configuration.dns, dispatcher.clone());
+        for (name, expected) in [
+            ("api.example", RCODE_REFUSED),
+            ("www.example", RCODE_NOERROR),
+        ] {
+            let response = resolver
+                .exchange(&build_query(9, name, QueryType::A).unwrap())
+                .await
+                .unwrap();
+            assert_eq!(parse_response(&response).unwrap().rcode, expected);
+        }
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 0);
+        assert_eq!(dispatcher.tcp_calls.load(Ordering::Acquire), 0);
+        let policy = crate::sniffing::Policy::new(
+            Arc::new(configuration.sniffer),
+            Arc::new(EmptyGeoMatcher),
         );
-
-        assert_eq!(resolver.resolve("warm.example").await.unwrap(), [address]);
-        tokio::task::yield_now().await;
-        assert_eq!(resolver.resolve("retry.example").await.unwrap(), [address]);
-
-        let snapshot = resolver.tcp_pool.snapshot();
-        assert_eq!(dispatcher.tcp_calls.load(Ordering::Acquire), 2);
-        assert_eq!(snapshot.stale_retries, 1);
-        assert_eq!(snapshot.discards, 1);
-        assert_eq!(snapshot.current_idle, 1);
+        let destination = Destination::Ip("203.0.113.1:443".parse().unwrap());
+        let plan = policy
+            .plan(
+                "198.51.100.1:9000".parse().unwrap(),
+                &destination,
+                Some("api.example"),
+                false,
+            )
+            .unwrap();
+        assert!(plan.tcp_enabled());
+        assert_eq!(plan.accepts("skip.example"), Ok(false));
+        assert_eq!(plan.accepts("api.example"), Ok(true));
+        for (source, destination, expected) in [
+            ("192.0.2.1:9000", "203.0.113.1:443", false),
+            ("192.0.2.7:9000", "203.0.113.1:443", true),
+            ("198.51.100.1:9000", "192.0.2.1:443", false),
+        ] {
+            let plan = policy
+                .plan(
+                    source.parse().unwrap(),
+                    &Destination::Ip(destination.parse().unwrap()),
+                    Some("api.example"),
+                    false,
+                )
+                .unwrap();
+            assert_eq!(plan.tcp_enabled(), expected);
+        }
     }
 
     #[tokio::test]
-    async fn reused_tcp_id_mismatch_rebuilds_once_but_truncation_only_fails_over() {
-        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 63));
-        let mismatch_dispatcher = Arc::new(ScriptedTcpDispatcher::new(vec![
-            vec![
-                TcpScriptReply::Response(ResponseSpec::answer(address)),
-                TcpScriptReply::WrongId(ResponseSpec::answer(address)),
-            ],
-            vec![TcpScriptReply::Response(ResponseSpec::answer(address))],
-        ]));
-        let mismatch_resolver = RuntimeDns::new(
-            &config(false, vec![nameserver(1, DnsTransport::Tcp)]),
-            mismatch_dispatcher.clone(),
-        );
-        mismatch_resolver.resolve("warm.example").await.unwrap();
+    async fn rule_budget_propagates_through_fake_ip_policy_and_sniffer_without_egress() {
+        let payload = serde_json::to_string(&vec![
+            "AND,((DOMAIN-REGEX,(?=never)never),(DOMAIN-SUFFIX,example))";
+            16
+        ])
+        .unwrap();
+        let configuration = crate::config::Config::parse_yaml(
+            format!(
+                r#"
+mixed-port: 1080
+rule-providers:
+  left: {{type: inline, behavior: classical, payload: {payload}}}
+  right: {{type: inline, behavior: classical, payload: {payload}}}
+dns:
+  enable: true
+  use-system-hosts: false
+  enhanced-mode: fake-ip
+  fake-ip-filter-mode: whitelist
+  fake-ip-filter: ['rule-set:left']
+  nameserver: [192.0.2.1]
+  nameserver-policy:
+    'rule-set:left': [192.0.2.2]
+    'rule-set:right': [192.0.2.3]
+sniffer:
+  enable: true
+  force-domain: ['+.example']
+  skip-domain: ['rule-set:left,right']
+  sniff: {{TLS: {{ports: [443]}}}}
+"#
+            )
+            .as_bytes(),
+        )
+        .unwrap();
+        let dispatcher = Arc::new(MockDispatcher::with_replies(vec![], vec![]));
+        let resolver = RuntimeDns::new(&configuration.dns, dispatcher.clone());
+        let query = build_query(9, "api.example", QueryType::A).unwrap();
+        let response = resolver.exchange(&query).await.unwrap();
+        assert_eq!(parse_response(&response).unwrap().rcode, RCODE_SERVFAIL);
+        assert!(matches!(
+            resolver.resolve("api.example").await,
+            Err(RuntimeDnsError::RuleEvaluation(
+                crate::config::MatchFailure::Budget
+            ))
+        ));
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 0);
+        assert_eq!(dispatcher.tcp_calls.load(Ordering::Acquire), 0);
         assert_eq!(
-            mismatch_resolver.resolve("mismatch.example").await.unwrap(),
-            [address]
+            resolver
+                .recover_fake_ip("198.18.0.2".parse().unwrap())
+                .unwrap_err()
+                .kind(),
+            io::ErrorKind::NotFound
         );
-        assert_eq!(mismatch_dispatcher.tcp_calls.load(Ordering::Acquire), 2);
-        assert_eq!(mismatch_resolver.tcp_pool.snapshot().stale_retries, 1);
-
-        let truncated_dispatcher = Arc::new(ScriptedTcpDispatcher::new(vec![
-            vec![
-                TcpScriptReply::Response(ResponseSpec::answer(address)),
-                TcpScriptReply::Response(ResponseSpec::truncated()),
-            ],
-            vec![TcpScriptReply::Response(ResponseSpec::answer(address))],
-        ]));
-        let truncated_resolver = RuntimeDns::new(
-            &config(
+        let policy = crate::sniffing::Policy::new(
+            Arc::new(configuration.sniffer),
+            Arc::new(EmptyGeoMatcher),
+        );
+        let plan = policy
+            .plan(
+                "198.51.100.1:9000".parse().unwrap(),
+                &Destination::Ip("203.0.113.1:443".parse().unwrap()),
+                Some("api.example"),
                 false,
-                vec![
-                    nameserver(1, DnsTransport::Tcp),
-                    nameserver(2, DnsTransport::Tcp),
-                ],
-            ),
-            truncated_dispatcher.clone(),
+            )
+            .unwrap();
+        assert_eq!(
+            plan.accepts("api.example"),
+            Err(crate::config::MatchFailure::Budget)
         );
-        truncated_resolver.resolve("warm.example").await.unwrap();
         assert_eq!(
-            truncated_resolver
-                .resolve("truncated.example")
-                .await
-                .unwrap(),
-            [address]
+            plan.clone().accepts("api.example"),
+            Err(crate::config::MatchFailure::Budget)
         );
-        let snapshot = truncated_resolver.tcp_pool.snapshot();
-        assert_eq!(truncated_dispatcher.tcp_calls.load(Ordering::Acquire), 2);
-        assert_eq!(snapshot.stale_retries, 0);
-        assert_eq!(snapshot.discards, 1);
     }
 
     #[tokio::test]
-    async fn tcp_pool_key_includes_final_egress_route() {
-        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 64));
-        let direct = Arc::new(ScriptedTcpDispatcher::new(vec![vec![
-            TcpScriptReply::Response(ResponseSpec::answer(address)),
-        ]]));
-        let proxy = Arc::new(ScriptedTcpDispatcher::new(vec![vec![
-            TcpScriptReply::Response(ResponseSpec::answer(address)),
-        ]]));
-        let mut direct_nameserver = nameserver(1, DnsTransport::Tcp);
-        direct_nameserver.route = DnsRoute::Direct;
-        let mut proxy_nameserver = direct_nameserver;
-        proxy_nameserver.route = DnsRoute::Route(crate::config::RouteTargetId::Proxy(
-            crate::config::ProxyId::new(0).expect("proxy zero is valid"),
-        ));
-        let resolver = RuntimeDns::new_routed(
-            &config(false, vec![direct_nameserver]),
-            proxy.clone(),
-            direct.clone(),
-            RuleSet::compile(vec![rule(RuleKind::Match, RuleAction::Direct)]).unwrap(),
-            Arc::new(EmptyGeoMatcher),
-        );
-
-        for (id, name, nameserver) in [
-            (1, "direct.example", direct_nameserver),
-            (2, "proxy.example", proxy_nameserver),
-        ] {
-            let query = build_query(id, name, QueryType::A).unwrap();
-            let parsed = parse_query(&query).unwrap();
+    async fn upstream_wrappers_cover_system_dhcp_and_rcode_before_source_io() {
+        for endpoint in ["system", "dhcp://physical1", "rcode://refused"] {
+            let configuration = crate::config::Config::parse_yaml(format!("mixed-port: 1080\ndns:\n  enable: true\n  ipv6: true\n  use-system-hosts: false\n  nameserver: ['{endpoint}#ecs=192.0.2.255/25&disable-ipv6=true']\n").as_bytes()).unwrap();
+            let dispatcher = Arc::new(MockDispatcher::with_replies(
+                vec![MockReply::Response(ResponseSpec::answer(
+                    "203.0.113.10".parse().unwrap(),
+                ))],
+                vec![],
+            ));
+            let resolver = Arc::new(RuntimeDns::new(&configuration.dns, dispatcher.clone()));
+            resolver.sources.register(&resolver);
             resolver
-                .exchange_nameserver(nameserver, &query, &parsed)
+                .sources
+                .replace(dns_source_snapshot(1, "203.0.113.53"))
                 .await
                 .unwrap();
+            let blocked = build_query(79, "blocked.example", QueryType::Aaaa).unwrap();
+            let response = resolver.exchange(&blocked).await.unwrap();
+            assert_eq!(response[3] & 0x0f, RCODE_NOERROR);
+            assert_eq!(response[2] & 0x04, 0x04);
+            assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 0);
+            let query = build_query(80, "allowed.example", QueryType::A).unwrap();
+            let response = resolver.exchange(&query).await.unwrap();
+            if endpoint.starts_with("rcode") {
+                assert_eq!(response[3] & 0x0f, RCODE_REFUSED);
+                assert_eq!(response[10..12], [0, 1]);
+                assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 0);
+            } else {
+                assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 1);
+                let payloads = dispatcher.udp_payloads.lock().unwrap();
+                assert_eq!(
+                    &payloads[0][payloads[0].len() - 12..],
+                    &[0, 8, 0, 8, 0, 1, 25, 0, 192, 0, 2, 128]
+                );
+                let expected = if endpoint == "system" {
+                    "203.0.113.53:53"
+                } else {
+                    "192.0.2.53:53"
+                };
+                assert_eq!(
+                    *dispatcher.udp_destinations.lock().unwrap(),
+                    vec![Destination::Ip(expected.parse().unwrap())]
+                );
+            }
         }
-
-        assert_eq!(direct.tcp_calls.load(Ordering::Acquire), 1);
-        assert_eq!(proxy.tcp_calls.load(Ordering::Acquire), 1);
-        assert_eq!(resolver.tcp_pool.snapshot().current_idle, 2);
     }
 
     #[tokio::test]
-    async fn group_switch_keeps_dns_cache_and_tcp_pool_until_a_new_connection() {
-        use crate::config::{
-            ProxyGroupId, ProxyGroupMemberConfig, ProxyGroupMemberTarget, ProxyId, RouteTargetId,
-            SelectProxyGroupConfig,
-        };
-        use crate::routing::{ProxyGroups, RouteTargetDispatchers};
+    async fn upstream_typed_cache_separates_client_ecs_and_preserves_edns_wire() {
+        let first: IpAddr = "203.0.113.1".parse().unwrap();
+        let second: IpAddr = "203.0.113.2".parse().unwrap();
+        let plain: IpAddr = "203.0.113.3".parse().unwrap();
+        let dispatcher = Arc::new(MockDispatcher::with_replies(
+            [first, second, plain]
+                .into_iter()
+                .map(|address| MockReply::Response(ResponseSpec::answer(address)))
+                .collect(),
+            vec![],
+        ));
+        let resolver = RuntimeDns::new(
+            &config(false, vec![nameserver(1, DnsTransport::Udp)]),
+            dispatcher.clone(),
+        );
+        let plain_query = build_query(91, "cache.example", QueryType::A).unwrap();
+        for (index, (address, expected)) in [
+            ("192.0.2.1", first),
+            ("192.0.2.2", second),
+            ("192.0.2.1", first),
+        ]
+        .into_iter()
+        .enumerate()
+        {
+            let options = crate::config::DnsNameserverOptions {
+                ecs: Some(crate::config::DnsEcs {
+                    address: address.parse().unwrap(),
+                    prefix_len: 32,
+                }),
+                ..Default::default()
+            };
+            let mut query = super::super::options::with_ecs(&plain_query, &options)
+                .unwrap()
+                .into_owned();
+            let id = 92 + index as u16;
+            query[..2].copy_from_slice(&id.to_be_bytes());
+            let response = resolver.exchange(&query).await.unwrap();
+            assert_eq!(parse_response(&response).unwrap().id, id);
+            assert_eq!(
+                matching_answer_set(&parse_response(&response).unwrap())
+                    .unwrap()
+                    .addresses,
+                vec![expected]
+            );
+            assert_eq!(response[10..12], [0, 1]);
+            assert_eq!(&response[response.len() - 12..], &query[query.len() - 12..]);
+        }
+        for _ in 0..2 {
+            let response = resolver.exchange(&plain_query).await.unwrap();
+            assert_eq!(
+                matching_answer_set(&parse_response(&response).unwrap())
+                    .unwrap()
+                    .addresses,
+                vec![plain]
+            );
+        }
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 3);
+        assert_eq!(resolver.cache.lock().await.len(), 3);
+    }
 
-        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 65));
-        let old = Arc::new(ScriptedTcpDispatcher::new(vec![vec![
-            TcpScriptReply::Response(ResponseSpec::answer(address)),
-            TcpScriptReply::Response(ResponseSpec::answer(address)),
-        ]]));
-        let new = Arc::new(ScriptedTcpDispatcher::new(vec![vec![
-            TcpScriptReply::Response(ResponseSpec::answer(address)),
-        ]]));
-        let direct: Arc<dyn Dispatcher> = Arc::new(MockDispatcher::default());
-        let proxy_dispatchers: Vec<Arc<dyn Dispatcher>> = vec![old.clone(), new.clone()];
-        let groups = ProxyGroups::new(
-            &[SelectProxyGroupConfig {
-                name: "group".to_owned(),
-                members: vec![
-                    ProxyGroupMemberConfig {
-                        name: "old".to_owned(),
-                        target: ProxyGroupMemberTarget::Route(RouteTargetId::Proxy(
-                            ProxyId::new(0).unwrap(),
-                        )),
-                    },
-                    ProxyGroupMemberConfig {
-                        name: "new".to_owned(),
-                        target: ProxyGroupMemberTarget::Route(RouteTargetId::Proxy(
-                            ProxyId::new(1).unwrap(),
-                        )),
-                    },
-                ],
-                initial_member: 0,
-            }],
-            proxy_dispatchers.clone(),
-            direct.clone(),
-        )
-        .unwrap();
-        let route_targets =
-            RouteTargetDispatchers::with_proxy_groups(proxy_dispatchers, &groups).unwrap();
-        let group = RouteTargetId::Group(ProxyGroupId::new(0).unwrap());
-        let mut upstream = nameserver(1, DnsTransport::Tcp);
-        upstream.route = DnsRoute::Route(group);
-        let resolver = RuntimeDns::new_routed_proxies(
-            &config(false, vec![upstream]),
-            route_targets,
-            direct,
-            RuleSet::compile(vec![rule(RuleKind::Match, RuleAction::Route(group))]).unwrap(),
+    #[test]
+    fn all_dns_roles_share_the_session_trust_store() {
+        let mut config = config(false, vec![nameserver(1, DnsTransport::Tls)]);
+        config.default_nameservers = vec![nameserver(2, DnsTransport::Tls)];
+        config.proxy_nameservers = vec![nameserver(3, DnsTransport::Https)];
+        config.direct_nameservers = vec![nameserver(4, DnsTransport::Https)];
+        let security = crate::security::SecurityContext::new();
+        let resolver = RuntimeDns::assemble(
+            &config,
+            DnsEgress::Single(Arc::new(MockDispatcher::default())),
             Arc::new(EmptyGeoMatcher),
+            config.cache_max_size,
+            0,
+            security.clone(),
         );
+        for role in [
+            &resolver,
+            resolver.bootstrap.as_deref().unwrap(),
+            resolver.proxy_resolver.as_deref().unwrap(),
+            resolver.direct_resolver.as_deref().unwrap(),
+        ] {
+            assert!(security.shares_roots_with(&role.tcp_pool.security));
+        }
+    }
 
-        assert_eq!(resolver.resolve("cached.example").await.unwrap(), [address]);
-        groups.select("group", "new").unwrap();
-        assert_eq!(resolver.resolve("cached.example").await.unwrap(), [address]);
-        assert_eq!(new.tcp_calls.load(Ordering::Acquire), 0);
-
-        assert_eq!(resolver.resolve("pooled.example").await.unwrap(), [address]);
-        assert_eq!(old.tcp_calls.load(Ordering::Acquire), 1);
-        assert_eq!(old.tcp_queries.load(Ordering::Acquire), 2);
-        assert_eq!(new.tcp_calls.load(Ordering::Acquire), 0);
+    fn response_for_query(query: &[u8], spec: &ResponseSpec) -> Vec<u8> {
+        classify_query(query).unwrap();
+        let header = super::super::parse_wire_question_header(query).unwrap();
+        let mut response = query[..header.records_offset].to_vec();
+        let mut flags = DNS_FLAG_RESPONSE
+            | DNS_FLAG_RECURSION_DESIRED
+            | DNS_FLAG_RECURSION_AVAILABLE
+            | u16::from(spec.rcode);
+        if spec.truncated {
+            flags |= 0x0200;
+        }
+        response[2..4].copy_from_slice(&flags.to_be_bytes());
+        let answer_count = spec.answers.len() as u16;
+        response[6..8].copy_from_slice(&answer_count.to_be_bytes());
+        for address in &spec.answers {
+            response.extend_from_slice(&[0xc0, 0x0c]);
+            match address {
+                IpAddr::V4(address) => {
+                    response.extend_from_slice(&(QueryType::A as u16).to_be_bytes());
+                    response.extend_from_slice(&DNS_CLASS_IN.to_be_bytes());
+                    response.extend_from_slice(&60_u32.to_be_bytes());
+                    response.extend_from_slice(&4_u16.to_be_bytes());
+                    response.extend_from_slice(&address.octets());
+                }
+                IpAddr::V6(address) => {
+                    response.extend_from_slice(&(QueryType::Aaaa as u16).to_be_bytes());
+                    response.extend_from_slice(&DNS_CLASS_IN.to_be_bytes());
+                    response.extend_from_slice(&60_u32.to_be_bytes());
+                    response.extend_from_slice(&16_u16.to_be_bytes());
+                    response.extend_from_slice(&address.octets());
+                }
+            }
+        }
+        response.extend_from_slice(&query[header.records_offset..]);
+        response
+    }
 
-        tokio::task::yield_now().await;
-        assert_eq!(
-            resolver.resolve("rebuilt.example").await.unwrap(),
-            [address]
-        );
-        assert_eq!(new.tcp_calls.load(Ordering::Acquire), 1);
-        assert_eq!(new.tcp_queries.load(Ordering::Acquire), 1);
-        assert_eq!(resolver.tcp_pool.snapshot().stale_retries, 1);
+    fn parsed_response_with_answers(
+        name: &str,
+        query_type: QueryType,
+        answers: Vec<DnsRecord>,
+    ) -> DnsMessage {
+        let answer_count = u16::try_from(answers.len()).unwrap();
+        DnsMessage {
+            id: 1,
+            is_response: true,
+            authoritative: false,
+            recursion_desired: true,
+            recursion_available: true,
+            rcode: RCODE_NOERROR,
+            question: DnsQuestion {
+                name: name.to_owned(),
+                query_type,
+            },
+            answers,
+            answer_count,
+        }
     }
 
     #[tokio::test]
-    async fn tcp_pool_allows_active_connections_above_old_ceiling_but_retains_only_two_idle() {
-        const ACTIVE: usize = 12;
-        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 65));
-        let release = Arc::new(Semaphore::new(0));
-        let scripts = (0..ACTIVE)
-            .map(|_| {
-                vec![TcpScriptReply::Gated {
-                    response: ResponseSpec::answer(address),
-                    release: Arc::clone(&release),
-                }]
-            })
-            .collect();
-        let dispatcher = Arc::new(ScriptedTcpDispatcher::new(scripts));
-        let resolver = Arc::new(RuntimeDns::new(
-            &config(false, vec![nameserver(1, DnsTransport::Tcp)]),
-            dispatcher.clone(),
-        ));
-        let nameserver = nameserver(1, DnsTransport::Tcp);
-        let mut tasks = Vec::new();
-        for index in 0..ACTIVE {
-            let resolver = Arc::clone(&resolver);
-            tasks.push(tokio::spawn(async move {
-                let query = build_query(
-                    u16::try_from(index + 1).unwrap(),
-                    &format!("busy-{index}.example"),
-                    QueryType::A,
+    async fn runtime_dns_separates_bootstrap_proxy_direct_and_hosts() {
+        let config = crate::config::Config::parse_yaml(
+            br#"
+mixed-port: 1080
+hosts:
+  '+.local.example': [192.0.2.99]
+  alias.example: target.local.example
+dns:
+  enable: true
+  use-system-hosts: false
+  default-nameserver: [192.0.2.10]
+  nameserver: [udp://dns.example]
+  proxy-server-nameserver: [192.0.2.20]
+  direct-nameserver: [192.0.2.30]
+"#,
+        )
+        .unwrap();
+        let answers: Vec<IpAddr> = ["192.0.2.1", "203.0.113.1", "203.0.113.2", "203.0.113.3"]
+            .map(|ip| ip.parse().unwrap())
+            .to_vec();
+        let dispatcher = Arc::new(MockDispatcher::with_replies(
+            answers
+                .iter()
+                .copied()
+                .map(|ip| MockReply::Response(ResponseSpec::answer(ip)))
+                .collect(),
+            vec![],
+        ));
+        let dns = Arc::new(RuntimeDns::new(&config.dns, dispatcher.clone()));
+        assert_eq!(dns.resolve("business.example").await.unwrap(), [answers[1]]);
+        let resolution = crate::dns::resolution::ResolutionContext::runtime(false);
+        resolution.bind_runtime(Some(&dns)).unwrap();
+        let node = Destination::domain("proxy.example", 443).unwrap();
+        assert_eq!(
+            resolution
+                .resolve_proxy(&node, TokioInstant::now() + QUERY_TIMEOUT)
+                .await
+                .unwrap()
+                .addresses[0]
+                .ip(),
+            answers[2]
+        );
+        assert_eq!(
+            resolution
+                .resolve_direct(
+                    &Destination::domain("direct.example", 443).unwrap(),
+                    TokioInstant::now() + QUERY_TIMEOUT,
                 )
-                .unwrap();
-                let parsed = parse_query(&query).unwrap();
-                resolver
-                    .exchange_nameserver(nameserver, &query, &parsed)
-                    .await
-            }));
-        }
+                .await
+                .unwrap()
+                .addresses,
+            [SocketAddr::new(answers[3], 443)]
+        );
+        assert_eq!(
+            dns.resolve("alias.example").await.unwrap(),
+            ["192.0.2.99".parse::<IpAddr>().unwrap()]
+        );
+        assert_eq!(
+            *dispatcher.udp_destinations.lock().unwrap(),
+            [
+                "192.0.2.10:53",
+                "192.0.2.1:53",
+                "192.0.2.20:53",
+                "192.0.2.30:53"
+            ]
+            .map(|address| Destination::Ip(address.parse().unwrap()))
+        );
+        resolution.close();
+        assert!(
+            resolution
+                .resolve_proxy(&node, TokioInstant::now() + QUERY_TIMEOUT)
+                .await
+                .is_err()
+        );
+    }
 
-        timeout_at(TokioInstant::now() + Duration::from_secs(1), async {
-            while dispatcher.tcp_calls.load(Ordering::Acquire) != ACTIVE {
-                tokio::task::yield_now().await;
-            }
-        })
-        .await
-        .unwrap();
-        assert_eq!(dispatcher.tcp_calls.load(Ordering::Acquire), ACTIVE);
+    #[tokio::test]
+    async fn concurrent_upstreams_drop_the_losing_attempt() {
+        let dispatcher = Arc::new(MockDispatcher::with_replies(
+            vec![
+                MockReply::Pending,
+                MockReply::Response(ResponseSpec::rcode(RCODE_NOERROR)),
+            ],
+            vec![],
+        ));
+        let dns = RuntimeDns::new(
+            &config(
+                false,
+                vec![
+                    nameserver(1, DnsTransport::Udp),
+                    nameserver(2, DnsTransport::Udp),
+                ],
+            ),
+            dispatcher.clone(),
+        );
+        tokio::time::timeout(Duration::from_millis(100), dns.resolve("race.example"))
+            .await
+            .unwrap()
+            .unwrap();
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 2);
+        assert_eq!(dns.singleflight.len(), 0);
+    }
 
-        release.add_permits(ACTIVE);
-        for task in tasks {
-            task.await.unwrap().unwrap();
-        }
+    #[tokio::test]
+    async fn udp_exchange_uses_internal_context_and_fixed_ip_endpoint() {
+        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 10));
+        let dispatcher = Arc::new(MockDispatcher::with_replies(
+            vec![MockReply::Response(ResponseSpec::answer(address))],
+            vec![],
+        ));
+        let resolver = RuntimeDns::new(
+            &config(false, vec![nameserver(1, DnsTransport::Udp)]),
+            dispatcher.clone(),
+        );
+        let query = build_query(42, "example.com", QueryType::A).unwrap();
+        let response = resolver.exchange(&query).await.unwrap();
 
-        let snapshot = resolver.tcp_pool.snapshot();
-        assert_eq!(snapshot.peak_physical, ACTIVE);
-        assert_eq!(snapshot.peak_busy, ACTIVE);
-        assert_eq!(snapshot.current_physical, 2);
-        assert_eq!(snapshot.current_idle, 2);
-        assert_eq!(snapshot.idle_evictions, (ACTIVE - 2) as u64);
+        assert_eq!(
+            matching_answer_set(&parse_response(&response).unwrap())
+                .unwrap()
+                .addresses,
+            [address]
+        );
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 1);
+        assert_eq!(dispatcher.tcp_calls.load(Ordering::Acquire), 0);
+        assert_eq!(
+            *dispatcher.udp_destinations.lock().unwrap(),
+            vec![Destination::Ip("192.0.2.1:53".parse().unwrap())]
+        );
+        assert_eq!(
+            *dispatcher.inbounds.lock().unwrap(),
+            vec![InboundKind::InternalDns]
+        );
     }
 
     #[tokio::test]
-    async fn tcp_pool_expires_idle_and_lru_bounds_global_idle() {
-        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 66));
-        let dispatcher = Arc::new(ScriptedTcpDispatcher::new(
-            (0..7)
-                .map(|_| vec![TcpScriptReply::Response(ResponseSpec::answer(address))])
-                .collect(),
+    async fn wire_queries_use_distinct_nonzero_upstream_ids_and_restore_the_client_id() {
+        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 12));
+        let dispatcher = Arc::new(MockDispatcher::with_replies(
+            vec![
+                MockReply::Response(ResponseSpec::answer(address)),
+                MockReply::Response(ResponseSpec::answer(address)),
+            ],
+            vec![],
         ));
         let resolver = RuntimeDns::new(
-            &config(false, vec![nameserver(1, DnsTransport::Tcp)]),
+            &config(false, vec![nameserver(1, DnsTransport::Udp)]),
             dispatcher.clone(),
         );
 
-        for index in 1..=5 {
-            let mut upstream = nameserver(index, DnsTransport::Tcp);
-            upstream.route = DnsRoute::Route(crate::config::RouteTargetId::Proxy(
-                crate::config::ProxyId::new(0).expect("proxy zero is valid"),
-            ));
-            let query = build_query(
-                u16::from(index),
-                &format!("idle-{index}.example"),
-                QueryType::A,
-            )
-            .unwrap();
-            let parsed = parse_query(&query).unwrap();
-            resolver
-                .exchange_nameserver(upstream, &query, &parsed)
-                .await
-                .unwrap();
+        for name in ["first.example", "second.example"] {
+            let query = build_query(77, name, QueryType::A).unwrap();
+            let response = resolver.exchange(&query).await.unwrap();
+            assert_eq!(parse_response(&response).unwrap().id, 77);
         }
-        let snapshot = resolver.tcp_pool.snapshot();
-        assert_eq!(snapshot.current_idle, TCP_POOL_MAX_IDLE);
-        assert_eq!(snapshot.current_physical, TCP_POOL_MAX_IDLE);
-        assert_eq!(snapshot.idle_evictions, 1);
 
-        {
-            let mut state = resolver.tcp_pool.state.lock().await;
-            let oldest = oldest_idle_index(&state.idle).unwrap();
-            state.idle[oldest].idle_since =
-                TokioInstant::now() - TCP_POOL_IDLE_TIMEOUT - Duration::from_secs(1);
-        }
-        let upstream = nameserver(1, DnsTransport::Tcp);
-        let query = build_query(99, "expired.example", QueryType::A).unwrap();
-        let parsed = parse_query(&query).unwrap();
-        resolver
-            .exchange_nameserver(upstream, &query, &parsed)
-            .await
-            .unwrap();
-        let snapshot = resolver.tcp_pool.snapshot();
-        assert_eq!(snapshot.idle_expirations, 1);
-        assert_eq!(snapshot.current_idle, TCP_POOL_MAX_IDLE);
-        assert_eq!(dispatcher.tcp_calls.load(Ordering::Acquire), 6);
+        let ids = dispatcher.udp_ids.lock().unwrap();
+        assert_eq!(ids.len(), 2);
+        assert!(ids.iter().all(|id| *id != 0));
+        assert_ne!(ids[0], ids[1]);
     }
 
     #[tokio::test]
-    async fn dropping_runtime_dns_releases_every_idle_tcp_pool_slot() {
-        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 68));
-        let dispatcher = Arc::new(ScriptedTcpDispatcher::new(vec![vec![
-            TcpScriptReply::Response(ResponseSpec::answer(address)),
-        ]]));
+    async fn udp_retry_reuses_one_transport_and_one_rewritten_id() {
+        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 13));
+        let dispatcher = Arc::new(MockDispatcher::with_replies(
+            vec![MockReply::AfterRetry(ResponseSpec::answer(address))],
+            vec![],
+        ));
         let resolver = RuntimeDns::new(
-            &config(false, vec![nameserver(1, DnsTransport::Tcp)]),
-            dispatcher,
+            &config(false, vec![nameserver(1, DnsTransport::Udp)]),
+            dispatcher.clone(),
         );
-        resolver.resolve("drop-pool.example").await.unwrap();
-        let stats = Arc::clone(&resolver.tcp_pool.stats);
-        let reaper_cancel = resolver.tcp_pool.reaper_cancel.clone();
-        assert_eq!(stats.current_physical.load(Ordering::Acquire), 1);
-        assert_eq!(stats.current_idle.load(Ordering::Acquire), 1);
-        assert!(!reaper_cancel.is_cancelled());
-
-        drop(resolver);
+        let query = build_query(0, "retry.example", QueryType::A).unwrap();
+        let response = resolver.exchange(&query).await.unwrap();
 
-        assert!(reaper_cancel.is_cancelled());
-        assert_eq!(stats.current_physical.load(Ordering::Acquire), 0);
-        assert_eq!(stats.current_busy.load(Ordering::Acquire), 0);
-        assert_eq!(stats.current_connecting.load(Ordering::Acquire), 0);
-        assert_eq!(stats.current_idle.load(Ordering::Acquire), 0);
+        assert_eq!(parse_response(&response).unwrap().id, 0);
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 1);
+        let ids = dispatcher.udp_ids.lock().unwrap();
+        assert_eq!(ids.len(), 2);
+        assert_ne!(ids[0], 0);
+        assert_eq!(ids[0], ids[1]);
     }
 
     #[tokio::test]
-    async fn nameserver_route_selects_direct_proxy_and_endpoint_rules() {
-        let answer = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 40));
-        let ipv6_answer = IpAddr::V6("2001:db8::40".parse().unwrap());
-
-        let direct = Arc::new(MockDispatcher::with_replies(
-            vec![MockReply::Response(ResponseSpec::answer(ipv6_answer))],
+    async fn udp_ignores_two_mismatches_but_the_third_fails_over() {
+        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 14));
+        let first_dispatcher = Arc::new(MockDispatcher::with_replies(
+            vec![MockReply::MismatchesThenResponse {
+                remaining: 2,
+                response: ResponseSpec::answer(address),
+            }],
             vec![],
         ));
-        let proxy = Arc::new(MockDispatcher::default());
-        let mut direct_nameserver = nameserver(1, DnsTransport::Udp);
-        direct_nameserver.route = DnsRoute::Direct;
-        let resolver = RuntimeDns::new_routed(
-            &config(true, vec![direct_nameserver]),
-            proxy.clone(),
-            direct.clone(),
-            RuleSet::compile(vec![rule(
-                RuleKind::Match,
-                RuleAction::Route(crate::config::RouteTargetId::Proxy(
-                    crate::config::ProxyId::new(0).unwrap(),
-                )),
-            )])
-            .unwrap(),
-            Arc::new(EmptyGeoMatcher),
+        let first_resolver = RuntimeDns::new(
+            &config(false, vec![nameserver(1, DnsTransport::Udp)]),
+            first_dispatcher.clone(),
         );
-        let query = build_query(1, "example.com", QueryType::Aaaa).unwrap();
-        resolver.exchange(&query).await.unwrap();
-        assert_eq!(direct.udp_calls.load(Ordering::Acquire), 1);
-        assert_eq!(proxy.udp_calls.load(Ordering::Acquire), 0);
+        let query = build_query(88, "mismatch.example", QueryType::A).unwrap();
+        let response = first_resolver.exchange(&query).await.unwrap();
+        assert_eq!(parse_response(&response).unwrap().id, 88);
+        assert_eq!(first_dispatcher.udp_calls.load(Ordering::Acquire), 1);
 
-        let direct = Arc::new(MockDispatcher::default());
-        let proxy = Arc::new(MockDispatcher::with_replies(
-            vec![MockReply::Response(ResponseSpec::answer(answer))],
+        let fallback_dispatcher = Arc::new(MockDispatcher::with_replies(
+            vec![
+                MockReply::MismatchesThenResponse {
+                    remaining: 3,
+                    response: ResponseSpec::answer(address),
+                },
+                MockReply::Response(ResponseSpec::answer(address)),
+            ],
             vec![],
         ));
-        let mut rules_nameserver = nameserver(2, DnsTransport::Udp);
-        rules_nameserver.route = DnsRoute::Rules;
-        let resolver = RuntimeDns::new_routed(
-            &config(false, vec![rules_nameserver]),
-            proxy.clone(),
-            direct.clone(),
-            RuleSet::compile(vec![
-                rule(
-                    RuleKind::Domain("example.com".to_owned()),
-                    RuleAction::Direct,
-                ),
-                rule(
-                    RuleKind::Match,
-                    RuleAction::Route(crate::config::RouteTargetId::Proxy(
-                        crate::config::ProxyId::new(0).unwrap(),
-                    )),
-                ),
-            ])
-            .unwrap(),
-            Arc::new(EmptyGeoMatcher),
-        );
-        let query = build_query(2, "example.com", QueryType::A).unwrap();
-        resolver.exchange(&query).await.unwrap();
-        assert_eq!(proxy.udp_calls.load(Ordering::Acquire), 1);
-        assert_eq!(direct.udp_calls.load(Ordering::Acquire), 0);
-
-        let direct = Arc::new(MockDispatcher::with_replies(
-            vec![MockReply::Response(ResponseSpec::answer(answer))],
-            vec![],
-        ));
-        let proxy = Arc::new(MockDispatcher::default());
-        let resolver = RuntimeDns::new_routed(
-            &config(false, vec![rules_nameserver]),
-            proxy.clone(),
-            direct.clone(),
-            RuleSet::compile(vec![
-                rule(
-                    RuleKind::IpCidr(IpCidr {
-                        network: "192.0.2.0".parse().unwrap(),
-                        prefix_len: 24,
-                    }),
-                    RuleAction::Direct,
-                ),
-                rule(
-                    RuleKind::Match,
-                    RuleAction::Route(crate::config::RouteTargetId::Proxy(
-                        crate::config::ProxyId::new(0).unwrap(),
-                    )),
-                ),
-            ])
-            .unwrap(),
-            Arc::new(EmptyGeoMatcher),
+        let fallback_resolver = RuntimeDns::new(
+            &config(
+                false,
+                vec![
+                    nameserver(1, DnsTransport::Udp),
+                    nameserver(2, DnsTransport::Udp),
+                ],
+            ),
+            fallback_dispatcher.clone(),
         );
-        let query = build_query(3, "not-the-routing-domain.example", QueryType::A).unwrap();
-        resolver.exchange(&query).await.unwrap();
-        assert_eq!(direct.udp_calls.load(Ordering::Acquire), 1);
-        assert_eq!(proxy.udp_calls.load(Ordering::Acquire), 0);
+        let response = fallback_resolver.exchange(&query).await.unwrap();
+        assert_eq!(parse_response(&response).unwrap().id, 88);
+        assert_eq!(fallback_dispatcher.udp_calls.load(Ordering::Acquire), 2);
     }
 
-    #[tokio::test]
-    async fn dns_policy_selection_is_consistent_across_snapshot_swaps() {
-        for starts_empty in [false, true] {
-            for separate_policies in [false, true] {
-                for query_type in [1, 65] {
-                    let main = nameserver(1, DnsTransport::Udp);
-                    let policy = nameserver(2, DnsTransport::Udp);
-                    let mut dns_config = config(false, vec![main]);
-                    dns_config.nameserver_policies = if separate_policies {
-                        vec![
-                            dns_policy(&["cn@ads"], vec![nameserver(3, DnsTransport::Udp)]),
-                            dns_policy(&["cn"], vec![policy]),
-                        ]
-                    } else {
-                        vec![dns_policy(&["cn@ads", "cn"], vec![policy])]
-                    };
-                    let root = tempfile::tempdir().unwrap();
-                    // One CN Domain record: example.cn, with no attributes.
-                    std::fs::write(
-                        root.path().join(GEOSITE_FILE_NAME),
-                        b"\x0a\x14\x0a\x02cn\x12\x0e\x08\x02\x12\x0aexample.cn",
-                    )
-                    .unwrap();
-                    let loaded = Arc::new(
-                        GeoData::load_with_dns_policies(
-                            root.path(),
-                            &[],
-                            &dns_config.nameserver_policies,
-                        )
-                        .unwrap(),
-                    );
-                    let empty = Arc::new(GeoData::EMPTY);
-                    let (initial, replacement) = if starts_empty {
-                        (empty, loaded)
-                    } else {
-                        (loaded, empty)
-                    };
-                    let retired = Arc::downgrade(&initial);
-                    let dynamic = Arc::new(DynamicGeoData::new(initial));
-                    let matcher = Arc::new(SwapAfterFirstGeoSiteMatch {
-                        inner: dynamic.clone(),
-                        dynamic,
-                        replacement: Arc::new(StdMutex::new(Some(replacement))),
-                    });
-                    let release = Arc::new(Notify::new());
-                    let dispatcher = Arc::new(MockDispatcher::with_replies(
-                        vec![
-                            MockReply::Gated {
-                                response: ResponseSpec::rcode(RCODE_NOERROR),
-                                release: release.clone(),
-                            },
-                            MockReply::Response(ResponseSpec::rcode(RCODE_NOERROR)),
-                        ],
-                        vec![],
-                    ));
-                    let resolver =
-                        RuntimeDns::new_with_geo_matcher(&dns_config, dispatcher.clone(), matcher);
-                    let query = opaque_query(60, "www.example.cn", query_type);
-                    let mut exchange = std::pin::pin!(resolver.exchange(&query));
-                    tokio::select! {
-                        result = &mut exchange => panic!("upstream must wait for release: {result:?}"),
-                        () = async {
-                            while dispatcher.udp_destinations.lock().unwrap().is_empty() {
-                                tokio::task::yield_now().await;
-                            }
-                        } => {}
-                    }
-                    let released_before_upstream_reply = retired.upgrade().is_none();
-                    release.notify_one();
-                    let response = exchange.await.unwrap();
-                    assert_eq!(u16::from_be_bytes([response[0], response[1]]), 60);
-                    assert_eq!(response[3] & 0x0f, RCODE_NOERROR);
-                    assert!(released_before_upstream_reply);
-
-                    let expected = if starts_empty { main } else { policy };
-                    assert_eq!(
-                        *dispatcher.udp_destinations.lock().unwrap(),
-                        vec![Destination::Ip(SocketAddr::new(
-                            expected.address,
-                            expected.port
-                        ))],
-                        "starts_empty={starts_empty}, separate_policies={separate_policies}, query_type={query_type}",
-                    );
+    #[test]
+    fn typed_udp_ignores_a_mismatched_tc_response_before_retrying_matching_tc() {
+        let query = build_query(88, "mismatch.example", QueryType::A).unwrap();
+        let parsed_query = parse_query(&query).unwrap();
+        let mut response = response_for_query(&query, &ResponseSpec::truncated());
+        response[..2].copy_from_slice(&89_u16.to_be_bytes());
+        assert!(!udp_response_matches_query(&parsed_query, &response).unwrap());
 
-                    // A fresh query sees the published replacement, not the
-                    // snapshot retired by the preceding policy evaluation.
-                    resolver
-                        .exchange(&opaque_query(61, "next.example.cn", query_type))
-                        .await
-                        .unwrap();
-                    let next_expected = if starts_empty { policy } else { main };
-                    assert_eq!(
-                        *dispatcher.udp_destinations.lock().unwrap(),
-                        vec![
-                            Destination::Ip(SocketAddr::new(expected.address, expected.port)),
-                            Destination::Ip(SocketAddr::new(
-                                next_expected.address,
-                                next_expected.port
-                            )),
-                        ],
-                    );
-                }
-            }
-        }
+        response[..2].copy_from_slice(&88_u16.to_be_bytes());
+        assert!(udp_response_matches_query(&parsed_query, &response).unwrap());
     }
 
     #[tokio::test]
-    async fn geosite_policy_selects_direct_for_address_and_opaque_queries() {
-        let v4_answer = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 70));
-        let v6_answer = IpAddr::V6("2001:db8::70".parse().unwrap());
-        let direct = Arc::new(MockDispatcher::with_replies(
-            vec![],
-            vec![
-                MockReply::Response(ResponseSpec::answer(v4_answer)),
-                MockReply::Response(ResponseSpec::answer(v4_answer)),
-                MockReply::Response(ResponseSpec::answer(v4_answer)),
-                MockReply::Response(ResponseSpec::answer(v6_answer)),
-                MockReply::Response(ResponseSpec::rcode(RCODE_NOERROR)),
-            ],
-        ));
-        let proxy = Arc::new(MockDispatcher::with_replies(
+    async fn configured_tcp_nameserver_uses_dns_framing() {
+        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 11));
+        let dispatcher = Arc::new(MockDispatcher::with_replies(
             vec![],
-            vec![MockReply::Response(ResponseSpec::answer(v4_answer))],
+            vec![MockReply::Response(ResponseSpec::answer(address))],
         ));
-        let main = DnsNameserver {
-            transport: DnsTransport::Tcp,
-            address: "1.1.1.1".parse().unwrap(),
-            port: 53,
-            route: DnsRoute::Route(crate::config::RouteTargetId::Proxy(
-                crate::config::ProxyId::new(0).unwrap(),
-            )),
-        };
-        let policy_nameserver = DnsNameserver {
-            transport: DnsTransport::Tcp,
-            address: "223.5.5.5".parse().unwrap(),
-            port: 53,
-            route: DnsRoute::Direct,
-        };
-        let mut dns_config = config(true, vec![main]);
-        dns_config.nameserver_policies = vec![dns_policy(
-            &["private", "cn", "apple"],
-            vec![policy_nameserver],
-        )];
-        let resolver = RuntimeDns::new_routed(
-            &dns_config,
-            proxy.clone(),
-            direct.clone(),
-            RuleSet::compile(vec![rule(
-                RuleKind::Match,
-                RuleAction::Route(crate::config::RouteTargetId::Proxy(
-                    crate::config::ProxyId::new(0).unwrap(),
-                )),
-            )])
-            .unwrap(),
-            Arc::new(PolicyGeoMatcher),
+        let resolver = RuntimeDns::new(
+            &config(false, vec![nameserver(1, DnsTransport::Tcp)]),
+            dispatcher.clone(),
         );
 
-        for (id, domain) in [
-            (60, "host.internal.test"),
-            (61, "www.apple.com"),
-            (62, "www.example.cn"),
-        ] {
-            resolver
-                .exchange(&build_query(id, domain, QueryType::A).unwrap())
-                .await
-                .unwrap();
-        }
-        resolver
-            .exchange(&build_query(63, "v6.example.cn", QueryType::Aaaa).unwrap())
-            .await
-            .unwrap();
-        resolver
-            .exchange(&opaque_query(64, "svc.example.cn", 65))
-            .await
-            .unwrap();
-        resolver
-            .exchange(&build_query(65, "unmatched.test", QueryType::A).unwrap())
-            .await
-            .unwrap();
-
-        assert_eq!(direct.tcp_calls.load(Ordering::Acquire), 5);
-        assert_eq!(proxy.tcp_calls.load(Ordering::Acquire), 1);
+        assert_eq!(resolver.resolve("example.com").await.unwrap(), [address]);
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 0);
+        assert_eq!(dispatcher.tcp_calls.load(Ordering::Acquire), 1);
         assert_eq!(
-            *direct.tcp_destinations.lock().unwrap(),
-            vec![Destination::Ip("223.5.5.5:53".parse().unwrap()); 5]
+            *dispatcher.tcp_destinations.lock().unwrap(),
+            vec![Destination::Ip("192.0.2.1:53".parse().unwrap())]
         );
         assert_eq!(
-            *proxy.tcp_destinations.lock().unwrap(),
-            vec![Destination::Ip("1.1.1.1:53".parse().unwrap())]
+            *dispatcher.tcp_queries.lock().unwrap(),
+            vec![QueryType::A as u16]
+        );
+    }
+
+    #[test]
+    fn tcp_pool_resource_contract_is_stable() {
+        assert_eq!(TCP_POOL_MAX_IDLE, 4);
+        assert_eq!(TCP_POOL_MAX_IDLE_PER_KEY, 2);
+        assert_eq!(TCP_POOL_IDLE_TIMEOUT, Duration::from_secs(30));
+        assert_eq!(TCP_POOL_FINAL_EVENT, "runtime_dns_tcp_pool_final");
+    }
+
+    #[tokio::test]
+    async fn tcp_pool_reuses_one_validated_connection_across_queries() {
+        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 61));
+        let dispatcher = Arc::new(ScriptedTcpDispatcher::new(vec![vec![
+            TcpScriptReply::Response(ResponseSpec::answer(address)),
+            TcpScriptReply::Response(ResponseSpec::answer(address)),
+        ]]));
+        let resolver = RuntimeDns::new(
+            &config(false, vec![nameserver(1, DnsTransport::Tcp)]),
+            dispatcher.clone(),
+        );
+
+        assert_eq!(resolver.resolve("first.example").await.unwrap(), [address]);
+        assert_eq!(resolver.resolve("second.example").await.unwrap(), [address]);
+
+        let snapshot = resolver.tcp_pool.snapshot();
+        assert_eq!(dispatcher.tcp_calls.load(Ordering::Acquire), 1);
+        assert_eq!(dispatcher.tcp_queries.load(Ordering::Acquire), 2);
+        assert_eq!(snapshot.physical_opens, 1);
+        assert_eq!(snapshot.reuse_hits, 1);
+        assert_eq!(snapshot.current_idle, 1);
+        assert_eq!(snapshot.current_busy, 0);
+    }
+
+    #[tokio::test]
+    async fn stale_reused_tcp_connection_rebuilds_only_once() {
+        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 62));
+        let dispatcher = Arc::new(ScriptedTcpDispatcher::new(vec![
+            vec![TcpScriptReply::Response(ResponseSpec::answer(address))],
+            vec![TcpScriptReply::Response(ResponseSpec::answer(address))],
+        ]));
+        let resolver = RuntimeDns::new(
+            &config(false, vec![nameserver(1, DnsTransport::Tcp)]),
+            dispatcher.clone(),
+        );
+
+        assert_eq!(resolver.resolve("warm.example").await.unwrap(), [address]);
+        tokio::task::yield_now().await;
+        assert_eq!(resolver.resolve("retry.example").await.unwrap(), [address]);
+
+        let snapshot = resolver.tcp_pool.snapshot();
+        assert_eq!(dispatcher.tcp_calls.load(Ordering::Acquire), 2);
+        assert_eq!(snapshot.stale_retries, 1);
+        assert_eq!(snapshot.discards, 1);
+        assert_eq!(snapshot.current_idle, 1);
+    }
+
+    #[tokio::test]
+    async fn reused_tcp_id_mismatch_rebuilds_once_but_truncation_only_fails_over() {
+        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 63));
+        let mismatch_dispatcher = Arc::new(ScriptedTcpDispatcher::new(vec![
+            vec![
+                TcpScriptReply::Response(ResponseSpec::answer(address)),
+                TcpScriptReply::WrongId(ResponseSpec::answer(address)),
+            ],
+            vec![TcpScriptReply::Response(ResponseSpec::answer(address))],
+        ]));
+        let mismatch_resolver = RuntimeDns::new(
+            &config(false, vec![nameserver(1, DnsTransport::Tcp)]),
+            mismatch_dispatcher.clone(),
+        );
+        mismatch_resolver.resolve("warm.example").await.unwrap();
+        assert_eq!(
+            mismatch_resolver.resolve("mismatch.example").await.unwrap(),
+            [address]
+        );
+        assert_eq!(mismatch_dispatcher.tcp_calls.load(Ordering::Acquire), 2);
+        assert_eq!(mismatch_resolver.tcp_pool.snapshot().stale_retries, 1);
+
+        let truncated_dispatcher = Arc::new(ScriptedTcpDispatcher::new(vec![
+            vec![
+                TcpScriptReply::Response(ResponseSpec::answer(address)),
+                TcpScriptReply::Response(ResponseSpec::truncated()),
+            ],
+            vec![TcpScriptReply::Response(ResponseSpec::answer(address))],
+        ]));
+        let truncated_resolver = RuntimeDns::new(
+            &config(false, vec![nameserver(1, DnsTransport::Tcp)]),
+            truncated_dispatcher.clone(),
+        );
+        truncated_resolver.resolve("warm.example").await.unwrap();
+        assert!(
+            truncated_resolver
+                .resolve("truncated.example")
+                .await
+                .is_err()
+        );
+        assert_eq!(
+            truncated_resolver.resolve("fresh.example").await.unwrap(),
+            [address]
+        );
+        let snapshot = truncated_resolver.tcp_pool.snapshot();
+        assert_eq!(truncated_dispatcher.tcp_calls.load(Ordering::Acquire), 2);
+        assert_eq!(snapshot.stale_retries, 0);
+        assert_eq!(snapshot.discards, 1);
+    }
+
+    #[tokio::test]
+    async fn tcp_pool_key_includes_final_egress_route() {
+        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 64));
+        let direct = Arc::new(ScriptedTcpDispatcher::new(vec![vec![
+            TcpScriptReply::Response(ResponseSpec::answer(address)),
+        ]]));
+        let proxy = Arc::new(ScriptedTcpDispatcher::new(vec![vec![
+            TcpScriptReply::Response(ResponseSpec::answer(address)),
+        ]]));
+        let mut direct_nameserver = nameserver(1, DnsTransport::Tcp);
+        direct_nameserver.route = DnsRoute::Direct;
+        let mut proxy_nameserver = direct_nameserver.clone();
+        proxy_nameserver.route = DnsRoute::Route(crate::config::RouteTargetId::Proxy(
+            crate::config::ProxyId::new(0).expect("proxy zero is valid"),
+        ));
+        let resolver = RuntimeDns::new_routed(
+            &config(false, vec![direct_nameserver.clone()]),
+            proxy.clone(),
+            direct.clone(),
+            RuleSet::compile(vec![rule(RuleKind::Match, RuleAction::Direct)]).unwrap(),
+            Arc::new(EmptyGeoMatcher),
+        );
+
+        for (id, name, nameserver) in [
+            (1, "direct.example", direct_nameserver),
+            (2, "proxy.example", proxy_nameserver),
+        ] {
+            let query = build_query(id, name, QueryType::A).unwrap();
+            let parsed = parse_query(&query).unwrap();
+            resolver
+                .exchange_nameserver(nameserver, &query, &parsed)
+                .await
+                .unwrap();
+        }
+
+        assert_eq!(direct.tcp_calls.load(Ordering::Acquire), 1);
+        assert_eq!(proxy.tcp_calls.load(Ordering::Acquire), 1);
+        assert_eq!(resolver.tcp_pool.snapshot().current_idle, 2);
+    }
+
+    #[tokio::test]
+    async fn rematch_dns_rules_consume_controls_but_explicit_routes_refuse_them() {
+        use crate::{
+            config::Config,
+            routing::{ProxyGroups, RematchTargets, RouteTargetDispatchers},
+        };
+        let mut configured = Config::parse_yaml(
+            br#"
+mixed-port: 1080
+proxies: [{name: mark, type: rematch, target-rematch-name: phase}]
+proxy-groups: [{name: gate, type: select, proxies: [mark], disable-udp: true}]
+rules: ['REMATCH-NAME,phase,DIRECT', 'MATCH,gate', 'MATCH,REJECT']
+"#,
+        )
+        .unwrap();
+        let direct: Arc<dyn Dispatcher> = Arc::new(MockDispatcher::default());
+        let control = Arc::new(MockDispatcher::default());
+        let nodes: Vec<Arc<dyn Dispatcher>> = vec![control.clone()];
+        let selections = configured
+            .proxy_groups
+            .iter()
+            .map(|group| Arc::new(crate::routing::GroupSelection::new(group.initial_member)))
+            .collect::<Vec<_>>();
+        let groups = ProxyGroups::with_selections_and_drop(
+            &configured.proxy_groups,
+            nodes.clone(),
+            direct.clone(),
+            &selections,
+            direct.clone(),
+            RematchTargets::new(&configured.proxies),
+        )
+        .unwrap();
+        let targets = RouteTargetDispatchers::with_proxy_groups(nodes, &groups).unwrap();
+        let mut upstream = nameserver(1, DnsTransport::Udp);
+        upstream.route = DnsRoute::Rules;
+        let resolver = RuntimeDns::new_routed_proxies(
+            &config(false, vec![upstream.clone()]),
+            targets,
+            direct.clone(),
+            RuleSet::compile_config(&mut configured).unwrap(),
+            Arc::new(EmptyGeoMatcher),
+        );
+        let server = resolver.resolve_nameserver(&upstream).await.unwrap();
+        for network in [Network::Tcp, Network::Udp] {
+            let (key, dispatcher) = resolver.egress_for(&server, network, |_| false).unwrap();
+            assert!(matches!(key, DnsEgressKey::Direct));
+            assert!(Arc::ptr_eq(&dispatcher, &direct));
+        }
+        upstream.route = DnsRoute::Route(crate::config::RouteTargetId::Group(
+            crate::config::ProxyGroupId::new(0).unwrap(),
+        ));
+        let server = resolver.resolve_nameserver(&upstream).await.unwrap();
+        assert!(matches!(
+            resolver.egress_for(&server, Network::Udp, |_| false),
+            Err(AttemptError::Dispatch(DispatchError::NotAllowed))
+        ));
+        assert_eq!(control.tcp_calls.load(Ordering::Acquire), 0);
+        assert_eq!(control.udp_calls.load(Ordering::Acquire), 0);
+    }
+
+    #[tokio::test]
+    async fn subrule_dns_rules_keep_round_robin_for_new_physical_connections() {
+        use crate::{
+            config::Config,
+            routing::{ProxyGroups, RouteTargetDispatchers},
+        };
+        let mut configured = Config::parse_yaml(br#"
+mixed-port: 1080
+proxies:
+  - {name: a, type: socks5, server: 192.0.2.10, port: 1080}
+  - {name: b, type: socks5, server: 192.0.2.11, port: 1080}
+proxy-groups:
+  - {name: gate, type: load-balance, proxies: [PASS-RULE,a], strategy: round-robin, disable-udp: true}
+  - {name: pool, type: load-balance, proxies: [a,b], strategy: round-robin}
+rules: ['SUB-RULE,(DST-PORT,53),child', 'MATCH,REJECT']
+sub-rules: {child: ['MATCH,gate', 'MATCH,pool']}
+"#).unwrap();
+        let address = "203.0.113.65".parse().unwrap();
+        let a = Arc::new(ScriptedTcpDispatcher::new(vec![vec![
+            TcpScriptReply::Response(ResponseSpec::answer(address)),
+            TcpScriptReply::Response(ResponseSpec::answer(address)),
+        ]]));
+        let b = Arc::new(ScriptedTcpDispatcher::new(vec![vec![
+            TcpScriptReply::Response(ResponseSpec::answer(address)),
+        ]]));
+        let direct: Arc<dyn Dispatcher> = Arc::new(MockDispatcher::default());
+        let nodes: Vec<Arc<dyn Dispatcher>> = vec![a.clone(), b.clone()];
+        let groups =
+            ProxyGroups::new(&configured.proxy_groups, nodes.clone(), direct.clone()).unwrap();
+        let targets = RouteTargetDispatchers::with_proxy_groups(nodes, &groups).unwrap();
+        let mut upstream = nameserver(1, DnsTransport::Tcp);
+        upstream.route = DnsRoute::Rules;
+        let resolver = RuntimeDns::new_routed_proxies(
+            &config(false, vec![upstream.clone()]),
+            targets,
+            direct,
+            RuleSet::compile_config(&mut configured).unwrap(),
+            Arc::new(EmptyGeoMatcher),
+        );
+        assert_eq!(resolver.resolve("first.example").await.unwrap(), [address]);
+        assert_eq!(resolver.resolve("pooled.example").await.unwrap(), [address]);
+        assert_eq!(a.tcp_calls.load(Ordering::Acquire), 1);
+        assert_eq!(b.tcp_calls.load(Ordering::Acquire), 0);
+        tokio::task::yield_now().await;
+        assert_eq!(
+            resolver.resolve("rebuilt.example").await.unwrap(),
+            [address]
+        );
+        assert_eq!(b.tcp_calls.load(Ordering::Acquire), 1);
+        upstream.route = DnsRoute::Route(crate::config::RouteTargetId::Group(
+            crate::config::ProxyGroupId::new(0).unwrap(),
+        ));
+        let server = resolver.resolve_nameserver(&upstream).await.unwrap();
+        assert!(matches!(
+            resolver.egress_for(&server, Network::Tcp, |_| false),
+            Err(AttemptError::Dispatch(DispatchError::NotAllowed))
+        ));
+        assert_eq!(groups.selection(0).choose(None, None), 0);
+    }
+
+    #[tokio::test]
+    async fn group_switch_keeps_dns_cache_and_tcp_pool_until_a_new_connection() {
+        use crate::config::{
+            ProxyGroupId, ProxyGroupMemberConfig, ProxyGroupMemberTarget, ProxyId, RouteTargetId,
+            SelectProxyGroupConfig,
+        };
+        use crate::routing::{ProxyGroups, RouteTargetDispatchers};
+
+        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 65));
+        let old = Arc::new(ScriptedTcpDispatcher::new(vec![vec![
+            TcpScriptReply::Response(ResponseSpec::answer(address)),
+            TcpScriptReply::Response(ResponseSpec::answer(address)),
+        ]]));
+        let new = Arc::new(ScriptedTcpDispatcher::new(vec![vec![
+            TcpScriptReply::Response(ResponseSpec::answer(address)),
+        ]]));
+        let direct: Arc<dyn Dispatcher> = Arc::new(MockDispatcher::default());
+        let proxy_dispatchers: Vec<Arc<dyn Dispatcher>> = vec![old.clone(), new.clone()];
+        let groups = ProxyGroups::new(
+            &[SelectProxyGroupConfig {
+                kind: crate::config::GroupKind::Select,
+                strategy: crate::config::BalanceStrategy::default(),
+                hash_key: crate::config::BalanceHashKey::default(),
+                health: crate::config::HealthCheckConfig::default(),
+                tolerance: 0,
+                max_failed_times: 5,
+                disable_udp: false,
+                hidden: false,
+                icon: String::new(),
+                name: "group".to_owned(),
+                members: vec![
+                    ProxyGroupMemberConfig {
+                        name: "old".to_owned(),
+                        target: ProxyGroupMemberTarget::Route(RouteTargetId::Proxy(
+                            ProxyId::new(0).unwrap(),
+                        )),
+                    },
+                    ProxyGroupMemberConfig {
+                        name: "new".to_owned(),
+                        target: ProxyGroupMemberTarget::Route(RouteTargetId::Proxy(
+                            ProxyId::new(1).unwrap(),
+                        )),
+                    },
+                ],
+                initial_member: 0,
+            }],
+            proxy_dispatchers.clone(),
+            direct.clone(),
+        )
+        .unwrap();
+        let route_targets =
+            RouteTargetDispatchers::with_proxy_groups(proxy_dispatchers, &groups).unwrap();
+        let group = RouteTargetId::Group(ProxyGroupId::new(0).unwrap());
+        let mut upstream = nameserver(1, DnsTransport::Tcp);
+        upstream.route = DnsRoute::Route(group);
+        let resolver = RuntimeDns::new_routed_proxies(
+            &config(false, vec![upstream]),
+            route_targets,
+            direct,
+            RuleSet::compile(vec![rule(RuleKind::Match, RuleAction::Route(group))]).unwrap(),
+            Arc::new(EmptyGeoMatcher),
+        );
+
+        assert_eq!(resolver.resolve("cached.example").await.unwrap(), [address]);
+        groups.select("group", "new").unwrap();
+        assert_eq!(resolver.resolve("cached.example").await.unwrap(), [address]);
+        assert_eq!(new.tcp_calls.load(Ordering::Acquire), 0);
+
+        assert_eq!(resolver.resolve("pooled.example").await.unwrap(), [address]);
+        assert_eq!(old.tcp_calls.load(Ordering::Acquire), 1);
+        assert_eq!(old.tcp_queries.load(Ordering::Acquire), 2);
+        assert_eq!(new.tcp_calls.load(Ordering::Acquire), 0);
+
+        tokio::task::yield_now().await;
+        assert_eq!(
+            resolver.resolve("rebuilt.example").await.unwrap(),
+            [address]
+        );
+        assert_eq!(new.tcp_calls.load(Ordering::Acquire), 1);
+        assert_eq!(new.tcp_queries.load(Ordering::Acquire), 1);
+        assert_eq!(resolver.tcp_pool.snapshot().stale_retries, 1);
+    }
+
+    #[tokio::test]
+    async fn tcp_pool_allows_active_connections_above_old_ceiling_but_retains_only_two_idle() {
+        const ACTIVE: usize = 12;
+        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 65));
+        let release = Arc::new(Semaphore::new(0));
+        let scripts = (0..ACTIVE)
+            .map(|_| {
+                vec![TcpScriptReply::Gated {
+                    response: ResponseSpec::answer(address),
+                    release: Arc::clone(&release),
+                }]
+            })
+            .collect();
+        let dispatcher = Arc::new(ScriptedTcpDispatcher::new(scripts));
+        let resolver = Arc::new(RuntimeDns::new(
+            &config(false, vec![nameserver(1, DnsTransport::Tcp)]),
+            dispatcher.clone(),
+        ));
+        let nameserver = nameserver(1, DnsTransport::Tcp);
+        let mut tasks = Vec::new();
+        for index in 0..ACTIVE {
+            let resolver = Arc::clone(&resolver);
+            let nameserver = nameserver.clone();
+            tasks.push(tokio::spawn(async move {
+                let query = build_query(
+                    u16::try_from(index + 1).unwrap(),
+                    &format!("busy-{index}.example"),
+                    QueryType::A,
+                )
+                .unwrap();
+                let parsed = parse_query(&query).unwrap();
+                resolver
+                    .exchange_nameserver(nameserver, &query, &parsed)
+                    .await
+            }));
+        }
+
+        timeout_at(TokioInstant::now() + Duration::from_secs(1), async {
+            while dispatcher.tcp_calls.load(Ordering::Acquire) != ACTIVE {
+                tokio::task::yield_now().await;
+            }
+        })
+        .await
+        .unwrap();
+        assert_eq!(dispatcher.tcp_calls.load(Ordering::Acquire), ACTIVE);
+
+        release.add_permits(ACTIVE);
+        for task in tasks {
+            task.await.unwrap().unwrap();
+        }
+
+        let snapshot = resolver.tcp_pool.snapshot();
+        assert_eq!(snapshot.peak_physical, ACTIVE);
+        assert_eq!(snapshot.peak_busy, ACTIVE);
+        assert_eq!(snapshot.current_physical, 2);
+        assert_eq!(snapshot.current_idle, 2);
+        assert_eq!(snapshot.idle_evictions, (ACTIVE - 2) as u64);
+    }
+
+    #[tokio::test]
+    async fn tcp_pool_expires_idle_and_lru_bounds_global_idle() {
+        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 66));
+        let dispatcher = Arc::new(ScriptedTcpDispatcher::new(
+            (0..7)
+                .map(|_| vec![TcpScriptReply::Response(ResponseSpec::answer(address))])
+                .collect(),
+        ));
+        let resolver = RuntimeDns::new(
+            &config(false, vec![nameserver(1, DnsTransport::Tcp)]),
+            dispatcher.clone(),
+        );
+
+        for index in 1..=5 {
+            let mut upstream = nameserver(index, DnsTransport::Tcp);
+            upstream.route = DnsRoute::Route(crate::config::RouteTargetId::Proxy(
+                crate::config::ProxyId::new(0).expect("proxy zero is valid"),
+            ));
+            let query = build_query(
+                u16::from(index),
+                &format!("idle-{index}.example"),
+                QueryType::A,
+            )
+            .unwrap();
+            let parsed = parse_query(&query).unwrap();
+            resolver
+                .exchange_nameserver(upstream, &query, &parsed)
+                .await
+                .unwrap();
+        }
+        let snapshot = resolver.tcp_pool.snapshot();
+        assert_eq!(snapshot.current_idle, TCP_POOL_MAX_IDLE);
+        assert_eq!(snapshot.current_physical, TCP_POOL_MAX_IDLE);
+        assert_eq!(snapshot.idle_evictions, 1);
+
+        {
+            let mut state = resolver.tcp_pool.state.lock().await;
+            let oldest = oldest_idle_index(&state.idle).unwrap();
+            state.idle[oldest].idle_since =
+                TokioInstant::now() - TCP_POOL_IDLE_TIMEOUT - Duration::from_secs(1);
+        }
+        let upstream = nameserver(1, DnsTransport::Tcp);
+        let query = build_query(99, "expired.example", QueryType::A).unwrap();
+        let parsed = parse_query(&query).unwrap();
+        resolver
+            .exchange_nameserver(upstream, &query, &parsed)
+            .await
+            .unwrap();
+        let snapshot = resolver.tcp_pool.snapshot();
+        assert_eq!(snapshot.idle_expirations, 1);
+        assert_eq!(snapshot.current_idle, TCP_POOL_MAX_IDLE);
+        assert_eq!(dispatcher.tcp_calls.load(Ordering::Acquire), 6);
+    }
+
+    #[tokio::test]
+    async fn dropping_runtime_dns_releases_every_idle_tcp_pool_slot() {
+        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 68));
+        let dispatcher = Arc::new(ScriptedTcpDispatcher::new(vec![vec![
+            TcpScriptReply::Response(ResponseSpec::answer(address)),
+        ]]));
+        let resolver = RuntimeDns::new(
+            &config(false, vec![nameserver(1, DnsTransport::Tcp)]),
+            dispatcher,
+        );
+        resolver.resolve("drop-pool.example").await.unwrap();
+        let stats = Arc::clone(&resolver.tcp_pool.stats);
+        let reaper_cancel = resolver.tcp_pool.reaper_cancel.clone();
+        assert_eq!(stats.current_physical.load(Ordering::Acquire), 1);
+        assert_eq!(stats.current_idle.load(Ordering::Acquire), 1);
+        assert!(!reaper_cancel.is_cancelled());
+
+        drop(resolver);
+
+        assert!(reaper_cancel.is_cancelled());
+        assert_eq!(stats.current_physical.load(Ordering::Acquire), 0);
+        assert_eq!(stats.current_busy.load(Ordering::Acquire), 0);
+        assert_eq!(stats.current_connecting.load(Ordering::Acquire), 0);
+        assert_eq!(stats.current_idle.load(Ordering::Acquire), 0);
+    }
+
+    #[tokio::test]
+    async fn nameserver_route_selects_direct_proxy_and_endpoint_rules() {
+        let answer = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 40));
+        let ipv6_answer = IpAddr::V6("2001:db8::40".parse().unwrap());
+
+        let direct = Arc::new(MockDispatcher::with_replies(
+            vec![MockReply::Response(ResponseSpec::answer(ipv6_answer))],
+            vec![],
+        ));
+        let proxy = Arc::new(MockDispatcher::default());
+        let mut direct_nameserver = nameserver(1, DnsTransport::Udp);
+        direct_nameserver.route = DnsRoute::Direct;
+        let resolver = RuntimeDns::new_routed(
+            &config(true, vec![direct_nameserver.clone()]),
+            proxy.clone(),
+            direct.clone(),
+            RuleSet::compile(vec![rule(
+                RuleKind::Match,
+                RuleAction::Route(crate::config::RouteTargetId::Proxy(
+                    crate::config::ProxyId::new(0).unwrap(),
+                )),
+            )])
+            .unwrap(),
+            Arc::new(EmptyGeoMatcher),
+        );
+        let query = build_query(1, "example.com", QueryType::Aaaa).unwrap();
+        resolver.exchange(&query).await.unwrap();
+        assert_eq!(direct.udp_calls.load(Ordering::Acquire), 1);
+        assert_eq!(proxy.udp_calls.load(Ordering::Acquire), 0);
+
+        let direct = Arc::new(MockDispatcher::default());
+        let proxy = Arc::new(MockDispatcher::with_replies(
+            vec![MockReply::Response(ResponseSpec::answer(answer))],
+            vec![],
+        ));
+        let mut rules_nameserver = nameserver(2, DnsTransport::Udp);
+        rules_nameserver.route = DnsRoute::Rules;
+        let resolver = RuntimeDns::new_routed(
+            &config(false, vec![rules_nameserver.clone()]),
+            proxy.clone(),
+            direct.clone(),
+            RuleSet::compile(vec![
+                rule(
+                    RuleKind::Domain("example.com".to_owned()),
+                    RuleAction::Direct,
+                ),
+                rule(
+                    RuleKind::Match,
+                    RuleAction::Route(crate::config::RouteTargetId::Proxy(
+                        crate::config::ProxyId::new(0).unwrap(),
+                    )),
+                ),
+            ])
+            .unwrap(),
+            Arc::new(EmptyGeoMatcher),
+        );
+        let query = build_query(2, "example.com", QueryType::A).unwrap();
+        resolver.exchange(&query).await.unwrap();
+        assert_eq!(proxy.udp_calls.load(Ordering::Acquire), 1);
+        assert_eq!(direct.udp_calls.load(Ordering::Acquire), 0);
+
+        let direct = Arc::new(MockDispatcher::with_replies(
+            vec![MockReply::Response(ResponseSpec::answer(answer))],
+            vec![],
+        ));
+        let proxy = Arc::new(MockDispatcher::default());
+        let resolver = RuntimeDns::new_routed(
+            &config(false, vec![rules_nameserver.clone()]),
+            proxy.clone(),
+            direct.clone(),
+            RuleSet::compile(vec![
+                rule(
+                    RuleKind::IpCidr(IpCidr {
+                        network: "192.0.2.0".parse().unwrap(),
+                        prefix_len: 24,
+                    }),
+                    RuleAction::Direct,
+                ),
+                rule(
+                    RuleKind::Match,
+                    RuleAction::Route(crate::config::RouteTargetId::Proxy(
+                        crate::config::ProxyId::new(0).unwrap(),
+                    )),
+                ),
+            ])
+            .unwrap(),
+            Arc::new(EmptyGeoMatcher),
+        );
+        let query = build_query(3, "not-the-routing-domain.example", QueryType::A).unwrap();
+        resolver.exchange(&query).await.unwrap();
+        assert_eq!(direct.udp_calls.load(Ordering::Acquire), 1);
+        assert_eq!(proxy.udp_calls.load(Ordering::Acquire), 0);
+    }
+
+    #[tokio::test]
+    async fn domain_policies_use_specificity_and_preserve_geosite_order() {
+        let parsed = crate::config::Config::parse_yaml(
+            br#"
+mixed-port: 1080
+rules: ['MATCH,DIRECT']
+dns:
+  enable: true
+  ipv6: true
+  nameserver: [192.0.2.1]
+  nameserver-policy:
+    '+.example.test': 192.0.2.2
+    '*.example.test': [192.0.2.3]
+    'pin.example.test': 192.0.2.4
+    'api.*.example.test': 192.0.2.5
+    '.only.test': 192.0.2.6
+    '*.TLD': 192.0.2.7
+    'same.test': 192.0.2.8
+    'SAME.TEST': 192.0.2.9
+    'one.test,two.test': 192.0.2.10
+    '+.override.cn': 192.0.2.11
+    'GEOSITE:cn': 192.0.2.12
+    'blocked.cn': 192.0.2.13
+    'late.test': [192.0.2.14]
+"#,
+        )
+        .unwrap();
+        for query_type in [1, 28, 65] {
+            for (domain, upstream) in [
+                ("example.test", 2),
+                ("one.example.test", 3),
+                ("pin.example.test", 4),
+                ("deep.pin.example.test", 2),
+                ("api.region.example.test", 5),
+                ("only.test", 1),
+                ("deep.child.only.test", 6),
+                ("host.tld", 7),
+                ("deep.host.tld", 1),
+                ("same.test", 9),
+                ("one.test", 10),
+                ("two.test", 10),
+                ("override.cn", 11),
+                ("blocked.cn", 12),
+                ("late.test", 14),
+                ("other.test", 1),
+            ] {
+                let dispatcher = Arc::new(MockDispatcher::with_replies(
+                    vec![MockReply::Response(ResponseSpec::rcode(RCODE_NXDOMAIN))],
+                    vec![],
+                ));
+                let resolver = RuntimeDns::new_with_geo_matcher(
+                    &parsed.dns,
+                    dispatcher.clone(),
+                    Arc::new(PolicyGeoMatcher),
+                );
+                resolver
+                    .exchange(&opaque_query(1, domain, query_type))
+                    .await
+                    .unwrap();
+                assert_eq!(
+                    *dispatcher.udp_destinations.lock().unwrap(),
+                    [Destination::Ip(SocketAddr::from((
+                        [192, 0, 2, upstream],
+                        53
+                    )))],
+                    "{domain} type {query_type}",
+                );
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn dns_policy_selection_is_consistent_across_snapshot_swaps() {
+        for starts_empty in [false, true] {
+            for separate_policies in [false, true] {
+                for query_type in [1, 65] {
+                    let main = nameserver(1, DnsTransport::Udp);
+                    let policy = nameserver(2, DnsTransport::Udp);
+                    let mut dns_config = config(false, vec![main.clone()]);
+                    dns_config.nameserver_policies = if separate_policies {
+                        vec![
+                            dns_policy(&["cn@ads"], vec![nameserver(3, DnsTransport::Udp)]),
+                            dns_policy(&["cn"], vec![policy.clone()]),
+                        ]
+                    } else {
+                        vec![dns_policy(&["cn@ads", "cn"], vec![policy.clone()])]
+                    };
+                    let root = tempfile::tempdir().unwrap();
+                    // One CN Domain record: example.cn, with no attributes.
+                    std::fs::write(
+                        root.path().join(GEOSITE_FILE_NAME),
+                        b"\x0a\x14\x0a\x02cn\x12\x0e\x08\x02\x12\x0aexample.cn",
+                    )
+                    .unwrap();
+                    let loaded = Arc::new(
+                        GeoData::load_with_dns_policies(
+                            root.path(),
+                            &[],
+                            &dns_config.nameserver_policies,
+                        )
+                        .unwrap(),
+                    );
+                    let empty = Arc::new(GeoData::EMPTY);
+                    let (initial, replacement) = if starts_empty {
+                        (empty, loaded)
+                    } else {
+                        (loaded, empty)
+                    };
+                    let retired = Arc::downgrade(&initial);
+                    let dynamic = Arc::new(DynamicGeoData::new(initial));
+                    let matcher = Arc::new(SwapAfterFirstGeoSiteMatch {
+                        inner: dynamic.clone(),
+                        dynamic,
+                        replacement: Arc::new(StdMutex::new(Some(replacement))),
+                    });
+                    let release = Arc::new(Notify::new());
+                    let dispatcher = Arc::new(MockDispatcher::with_replies(
+                        vec![
+                            MockReply::Gated {
+                                response: ResponseSpec::rcode(RCODE_NOERROR),
+                                release: release.clone(),
+                            },
+                            MockReply::Response(ResponseSpec::rcode(RCODE_NOERROR)),
+                        ],
+                        vec![],
+                    ));
+                    let resolver =
+                        RuntimeDns::new_with_geo_matcher(&dns_config, dispatcher.clone(), matcher);
+                    let query = opaque_query(60, "www.example.cn", query_type);
+                    let mut exchange = std::pin::pin!(resolver.exchange(&query));
+                    tokio::select! {
+                        result = &mut exchange => panic!("upstream must wait for release: {result:?}"),
+                        () = async {
+                            while dispatcher.udp_destinations.lock().unwrap().is_empty() {
+                                tokio::task::yield_now().await;
+                            }
+                        } => {}
+                    }
+                    let released_before_upstream_reply = retired.upgrade().is_none();
+                    release.notify_one();
+                    let response = exchange.await.unwrap();
+                    assert_eq!(u16::from_be_bytes([response[0], response[1]]), 60);
+                    assert_eq!(response[3] & 0x0f, RCODE_NOERROR);
+                    assert!(released_before_upstream_reply);
+
+                    let expected = if starts_empty { &main } else { &policy };
+                    assert_eq!(
+                        *dispatcher.udp_destinations.lock().unwrap(),
+                        vec![Destination::Ip(expected.endpoint())],
+                        "starts_empty={starts_empty}, separate_policies={separate_policies}, query_type={query_type}",
+                    );
+
+                    // A fresh query sees the published replacement, not the
+                    // snapshot retired by the preceding policy evaluation.
+                    resolver
+                        .exchange(&opaque_query(61, "next.example.cn", query_type))
+                        .await
+                        .unwrap();
+                    let next_expected = if starts_empty { &policy } else { &main };
+                    assert_eq!(
+                        *dispatcher.udp_destinations.lock().unwrap(),
+                        vec![
+                            Destination::Ip(expected.endpoint()),
+                            Destination::Ip(next_expected.endpoint()),
+                        ],
+                    );
+                }
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn geosite_policy_selects_direct_for_address_and_opaque_queries() {
+        let v4_answer = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 70));
+        let v6_answer = IpAddr::V6("2001:db8::70".parse().unwrap());
+        let direct = Arc::new(MockDispatcher::with_replies(
+            vec![],
+            vec![
+                MockReply::Response(ResponseSpec::answer(v4_answer)),
+                MockReply::Response(ResponseSpec::answer(v4_answer)),
+                MockReply::Response(ResponseSpec::answer(v4_answer)),
+                MockReply::Response(ResponseSpec::answer(v6_answer)),
+                MockReply::Response(ResponseSpec::rcode(RCODE_NOERROR)),
+            ],
+        ));
+        let proxy = Arc::new(MockDispatcher::with_replies(
+            vec![],
+            vec![MockReply::Response(ResponseSpec::answer(v4_answer))],
+        ));
+        let main = DnsNameserver {
+            path: None,
+            http_auth: None,
+            options: Default::default(),
+            transport: DnsTransport::Tcp,
+            address: "1.1.1.1".parse().unwrap(),
+            port: 53,
+            route: DnsRoute::Route(crate::config::RouteTargetId::Proxy(
+                crate::config::ProxyId::new(0).unwrap(),
+            )),
+        };
+        let policy_nameserver = DnsNameserver {
+            path: None,
+            http_auth: None,
+            options: Default::default(),
+            transport: DnsTransport::Tcp,
+            address: "223.5.5.5".parse().unwrap(),
+            port: 53,
+            route: DnsRoute::Direct,
+        };
+        let mut dns_config = config(true, vec![main.clone()]);
+        dns_config.nameserver_policies = vec![dns_policy(
+            &["private", "cn", "apple"],
+            vec![policy_nameserver],
+        )];
+        let resolver = RuntimeDns::new_routed(
+            &dns_config,
+            proxy.clone(),
+            direct.clone(),
+            RuleSet::compile(vec![rule(
+                RuleKind::Match,
+                RuleAction::Route(crate::config::RouteTargetId::Proxy(
+                    crate::config::ProxyId::new(0).unwrap(),
+                )),
+            )])
+            .unwrap(),
+            Arc::new(PolicyGeoMatcher),
+        );
+
+        for (id, domain) in [
+            (60, "host.internal.test"),
+            (61, "www.apple.com"),
+            (62, "www.example.cn"),
+        ] {
+            resolver
+                .exchange(&build_query(id, domain, QueryType::A).unwrap())
+                .await
+                .unwrap();
+        }
+        resolver
+            .exchange(&build_query(63, "v6.example.cn", QueryType::Aaaa).unwrap())
+            .await
+            .unwrap();
+        resolver
+            .exchange(&opaque_query(64, "svc.example.cn", 65))
+            .await
+            .unwrap();
+        resolver
+            .exchange(&build_query(65, "unmatched.test", QueryType::A).unwrap())
+            .await
+            .unwrap();
+
+        assert_eq!(direct.tcp_calls.load(Ordering::Acquire), 5);
+        assert_eq!(proxy.tcp_calls.load(Ordering::Acquire), 1);
+        assert_eq!(
+            *direct.tcp_destinations.lock().unwrap(),
+            vec![Destination::Ip("223.5.5.5:53".parse().unwrap()); 5]
+        );
+        assert_eq!(
+            *proxy.tcp_destinations.lock().unwrap(),
+            vec![Destination::Ip("1.1.1.1:53".parse().unwrap())]
         );
     }
 
@@ -3233,528 +6311,1067 @@ mod tests {
         let direct = Arc::new(MockDispatcher::with_replies(
             vec![
                 MockReply::TransportError,
-                MockReply::Response(ResponseSpec::answer(answer)),
+                MockReply::Response(ResponseSpec::answer(answer)),
+            ],
+            vec![],
+        ));
+        let proxy = Arc::new(MockDispatcher::with_replies(
+            vec![MockReply::Response(ResponseSpec::answer(answer))],
+            vec![],
+        ));
+        let mut first = nameserver(10, DnsTransport::Udp);
+        first.route = DnsRoute::Direct;
+        let mut first_fallback = nameserver(11, DnsTransport::Udp);
+        first_fallback.route = DnsRoute::Direct;
+        let second = nameserver(12, DnsTransport::Udp);
+        let mut dns_config = config(false, vec![nameserver(1, DnsTransport::Udp)]);
+        dns_config.nameserver_policies = vec![
+            dns_policy(&["first"], vec![first, first_fallback]),
+            dns_policy(&["second"], vec![second]),
+        ];
+        let resolver = RuntimeDns::new_routed(
+            &dns_config,
+            proxy.clone(),
+            direct.clone(),
+            RuleSet::compile(vec![rule(
+                RuleKind::Match,
+                RuleAction::Route(crate::config::RouteTargetId::Proxy(
+                    crate::config::ProxyId::new(0).unwrap(),
+                )),
+            )])
+            .unwrap(),
+            Arc::new(PolicyGeoMatcher),
+        );
+
+        let response = resolver
+            .exchange(&build_query(66, "overlap.test", QueryType::A).unwrap())
+            .await
+            .unwrap();
+        assert_eq!(parse_response(&response).unwrap().rcode, RCODE_NOERROR);
+        assert_eq!(direct.udp_calls.load(Ordering::Acquire), 2);
+        assert_eq!(proxy.udp_calls.load(Ordering::Acquire), 0);
+        assert_eq!(
+            *direct.udp_destinations.lock().unwrap(),
+            [
+                Destination::Ip("192.0.2.10:53".parse().unwrap()),
+                Destination::Ip("192.0.2.11:53".parse().unwrap()),
+            ]
+        );
+    }
+
+    #[tokio::test]
+    async fn policy_exhaustion_never_falls_back_to_main_for_typed_or_opaque_queries() {
+        let answer = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 72));
+        for opaque in [false, true] {
+            let direct = Arc::new(MockDispatcher::with_replies(
+                vec![MockReply::TransportError],
+                vec![],
+            ));
+            let proxy = Arc::new(MockDispatcher::with_replies(
+                vec![MockReply::Response(ResponseSpec::answer(answer))],
+                vec![],
+            ));
+            let mut policy_nameserver = nameserver(20, DnsTransport::Udp);
+            policy_nameserver.route = DnsRoute::Direct;
+            let mut dns_config = config(false, vec![nameserver(1, DnsTransport::Udp)]);
+            dns_config.nameserver_policies = vec![dns_policy(&["cn"], vec![policy_nameserver])];
+            let resolver = RuntimeDns::new_routed(
+                &dns_config,
+                proxy.clone(),
+                direct.clone(),
+                RuleSet::compile(vec![rule(
+                    RuleKind::Match,
+                    RuleAction::Route(crate::config::RouteTargetId::Proxy(
+                        crate::config::ProxyId::new(0).unwrap(),
+                    )),
+                )])
+                .unwrap(),
+                Arc::new(PolicyGeoMatcher),
+            );
+
+            let query = if opaque {
+                opaque_query(67, "failed.example.cn", 16)
+            } else {
+                build_query(68, "failed.example.cn", QueryType::A).unwrap()
+            };
+            let response = resolver.exchange(&query).await.unwrap();
+            if opaque {
+                assert_eq!(
+                    validate_opaque_response(&classify_query(&query).unwrap(), &response)
+                        .unwrap()
+                        .rcode(),
+                    u16::from(RCODE_SERVFAIL)
+                );
+            } else {
+                assert_eq!(parse_response(&response).unwrap().rcode, RCODE_SERVFAIL);
+            }
+            assert_eq!(direct.udp_calls.load(Ordering::Acquire), 1);
+            assert_eq!(proxy.udp_calls.load(Ordering::Acquire), 0);
+        }
+    }
+
+    #[tokio::test]
+    async fn policy_nxdomain_is_terminal_and_ipv6_disabled_aaaa_stays_local() {
+        let direct = Arc::new(MockDispatcher::with_replies(
+            vec![
+                MockReply::Response(ResponseSpec::rcode(RCODE_NXDOMAIN)),
+                MockReply::Response(ResponseSpec::rcode(RCODE_NOERROR)),
+            ],
+            vec![],
+        ));
+        let proxy = Arc::new(MockDispatcher::default());
+        let mut first = nameserver(30, DnsTransport::Udp);
+        first.route = DnsRoute::Direct;
+        let mut fallback = nameserver(31, DnsTransport::Udp);
+        fallback.route = DnsRoute::Direct;
+        let mut dns_config = config(false, vec![nameserver(1, DnsTransport::Udp)]);
+        dns_config.nameserver_policies = vec![dns_policy(&["cn"], vec![first, fallback])];
+        let resolver = RuntimeDns::new_routed(
+            &dns_config,
+            proxy.clone(),
+            direct.clone(),
+            RuleSet::compile(vec![rule(
+                RuleKind::Match,
+                RuleAction::Route(crate::config::RouteTargetId::Proxy(
+                    crate::config::ProxyId::new(0).unwrap(),
+                )),
+            )])
+            .unwrap(),
+            Arc::new(PolicyGeoMatcher),
+        );
+
+        let response = resolver
+            .exchange(&build_query(69, "missing.example.cn", QueryType::A).unwrap())
+            .await
+            .unwrap();
+        assert_eq!(parse_response(&response).unwrap().rcode, RCODE_NXDOMAIN);
+        let response = resolver
+            .exchange(&build_query(70, "v6.example.cn", QueryType::Aaaa).unwrap())
+            .await
+            .unwrap();
+        assert_eq!(parse_response(&response).unwrap().rcode, RCODE_NOERROR);
+        assert_eq!(parse_response(&response).unwrap().answer_count, 0);
+        assert_eq!(direct.udp_calls.load(Ordering::Acquire), 1);
+        assert_eq!(proxy.udp_calls.load(Ordering::Acquire), 0);
+    }
+
+    #[tokio::test]
+    async fn opaque_queries_share_proxy_tag_and_endpoint_rules_egress() {
+        let proxy = Arc::new(MockDispatcher::with_replies(
+            vec![MockReply::Response(ResponseSpec::rcode(RCODE_NOERROR))],
+            vec![],
+        ));
+        let direct = Arc::new(MockDispatcher::default());
+        let resolver = RuntimeDns::new_routed(
+            &config(false, vec![nameserver(1, DnsTransport::Udp)]),
+            proxy.clone(),
+            direct.clone(),
+            RuleSet::compile(vec![rule(RuleKind::Match, RuleAction::Direct)]).unwrap(),
+            Arc::new(EmptyGeoMatcher),
+        );
+        resolver
+            .exchange(&opaque_query(4, "txt.example", 16))
+            .await
+            .unwrap();
+        assert_eq!(proxy.udp_calls.load(Ordering::Acquire), 1);
+        assert_eq!(direct.udp_calls.load(Ordering::Acquire), 0);
+
+        let proxy = Arc::new(MockDispatcher::default());
+        let direct = Arc::new(MockDispatcher::with_replies(
+            vec![MockReply::Response(ResponseSpec::rcode(RCODE_NOERROR))],
+            vec![],
+        ));
+        let mut rules_nameserver = nameserver(2, DnsTransport::Udp);
+        rules_nameserver.route = DnsRoute::Rules;
+        let resolver = RuntimeDns::new_routed(
+            &config(false, vec![rules_nameserver.clone()]),
+            proxy.clone(),
+            direct.clone(),
+            RuleSet::compile(vec![
+                rule(
+                    RuleKind::IpCidr(IpCidr {
+                        network: "192.0.2.0".parse().unwrap(),
+                        prefix_len: 24,
+                    }),
+                    RuleAction::Direct,
+                ),
+                rule(
+                    RuleKind::Match,
+                    RuleAction::Route(crate::config::RouteTargetId::Proxy(
+                        crate::config::ProxyId::new(0).unwrap(),
+                    )),
+                ),
+            ])
+            .unwrap(),
+            Arc::new(EmptyGeoMatcher),
+        );
+        resolver
+            .exchange(&opaque_query(5, "https.example", 65))
+            .await
+            .unwrap();
+        assert_eq!(direct.udp_calls.load(Ordering::Acquire), 1);
+        assert_eq!(proxy.udp_calls.load(Ordering::Acquire), 0);
+    }
+
+    #[tokio::test]
+    async fn direct_nameserver_round_trips_real_udp_and_tcp_sockets() {
+        let udp = UdpSocket::bind("127.0.0.1:0").await.unwrap();
+        let udp_address = udp.local_addr().unwrap();
+        let udp_server = tokio::spawn(async move {
+            let mut query = [0_u8; MAX_MESSAGE_SIZE];
+            let (length, peer) = udp.recv_from(&mut query).await.unwrap();
+            let response =
+                response_for_query(&query[..length], &ResponseSpec::rcode(RCODE_NOERROR));
+            udp.send_to(&response, peer).await.unwrap();
+        });
+        let proxy = Arc::new(MockDispatcher::default());
+        let direct: Arc<dyn Dispatcher> = Arc::new(DirectOutbound::new(Dialer::default()));
+        let udp_nameserver = DnsNameserver {
+            path: None,
+            http_auth: None,
+            options: Default::default(),
+            transport: DnsTransport::Udp,
+            address: udp_address.ip().into(),
+            port: udp_address.port(),
+            route: DnsRoute::Direct,
+        };
+        let resolver = RuntimeDns::new_routed(
+            &config(false, vec![udp_nameserver]),
+            proxy.clone(),
+            direct.clone(),
+            RuleSet::compile(vec![rule(
+                RuleKind::Match,
+                RuleAction::Route(crate::config::RouteTargetId::Proxy(
+                    crate::config::ProxyId::new(0).unwrap(),
+                )),
+            )])
+            .unwrap(),
+            Arc::new(EmptyGeoMatcher),
+        );
+        let query = opaque_query(50, "txt.example", 16);
+        let classified = classify_query(&query).unwrap();
+        let response = resolver.exchange(&query).await.unwrap();
+        assert_eq!(
+            validate_opaque_response(&classified, &response)
+                .unwrap()
+                .rcode(),
+            u16::from(RCODE_NOERROR)
+        );
+        udp_server.await.unwrap();
+        assert_eq!(proxy.udp_calls.load(Ordering::Acquire), 0);
+
+        let tcp = TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let tcp_address = tcp.local_addr().unwrap();
+        let tcp_server = tokio::spawn(async move {
+            let (mut stream, _) = tcp.accept().await.unwrap();
+            let length = stream.read_u16().await.unwrap() as usize;
+            let mut query = vec![0_u8; length];
+            stream.read_exact(&mut query).await.unwrap();
+            let response = response_for_query(&query, &ResponseSpec::rcode(RCODE_NOERROR));
+            stream.write_u16(response.len() as u16).await.unwrap();
+            stream.write_all(&response).await.unwrap();
+        });
+        let tcp_nameserver = DnsNameserver {
+            path: None,
+            http_auth: None,
+            options: Default::default(),
+            transport: DnsTransport::Tcp,
+            address: tcp_address.ip().into(),
+            port: tcp_address.port(),
+            route: DnsRoute::Direct,
+        };
+        let resolver = RuntimeDns::new_routed(
+            &config(false, vec![tcp_nameserver]),
+            proxy.clone(),
+            direct,
+            RuleSet::compile(vec![rule(
+                RuleKind::Match,
+                RuleAction::Route(crate::config::RouteTargetId::Proxy(
+                    crate::config::ProxyId::new(0).unwrap(),
+                )),
+            )])
+            .unwrap(),
+            Arc::new(EmptyGeoMatcher),
+        );
+        let query = opaque_query(51, "https.example", 65);
+        let classified = classify_query(&query).unwrap();
+        let response = resolver.exchange(&query).await.unwrap();
+        assert_eq!(
+            validate_opaque_response(&classified, &response)
+                .unwrap()
+                .rcode(),
+            u16::from(RCODE_NOERROR)
+        );
+        tcp_server.await.unwrap();
+        assert_eq!(proxy.tcp_calls.load(Ordering::Acquire), 0);
+    }
+
+    #[tokio::test]
+    async fn rules_reject_fails_over_to_the_next_nameserver() {
+        let answer = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 41));
+        let proxy = Arc::new(MockDispatcher::with_replies(
+            vec![MockReply::Response(ResponseSpec::answer(answer))],
+            vec![],
+        ));
+        let direct = Arc::new(MockDispatcher::default());
+        let mut rejected = nameserver(1, DnsTransport::Udp);
+        rejected.route = DnsRoute::Rules;
+        let allowed = nameserver(2, DnsTransport::Udp);
+        let resolver = RuntimeDns::new_routed(
+            &config(false, vec![rejected, allowed]),
+            proxy.clone(),
+            direct.clone(),
+            RuleSet::compile(vec![
+                rule(RuleKind::Network(Network::Udp), RuleAction::Reject),
+                rule(
+                    RuleKind::Match,
+                    RuleAction::Route(crate::config::RouteTargetId::Proxy(
+                        crate::config::ProxyId::new(0).unwrap(),
+                    )),
+                ),
+            ])
+            .unwrap(),
+            Arc::new(EmptyGeoMatcher),
+        );
+        let query = build_query(4, "example.com", QueryType::A).unwrap();
+        let response = resolver.exchange(&query).await.unwrap();
+        assert_eq!(parse_response(&response).unwrap().rcode, RCODE_NOERROR);
+        assert_eq!(proxy.udp_calls.load(Ordering::Acquire), 1);
+        assert_eq!(direct.udp_calls.load(Ordering::Acquire), 0);
+    }
+
+    #[tokio::test]
+    async fn opaque_qtypes_relay_cache_and_never_create_redir_host_hints() {
+        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 42));
+        let dispatcher = Arc::new(MockDispatcher::with_replies(
+            vec![
+                MockReply::Response(ResponseSpec::answer(address)),
+                MockReply::Response(ResponseSpec::rcode(RCODE_NOERROR)),
+                MockReply::Response(ResponseSpec::rcode(RCODE_NOERROR)),
+            ],
+            vec![],
+        ));
+        let resolver = RuntimeDns::new(
+            &config(false, vec![nameserver(1, DnsTransport::Udp)]),
+            dispatcher.clone(),
+        );
+
+        for (id, name, query_type) in [
+            (10, "txt.example", 16),
+            (11, "https.example", 65),
+            (12, "unknown.example", 65_400),
+        ] {
+            let query = opaque_query(id, name, query_type);
+            let classified = classify_query(&query).unwrap();
+            let response = resolver.exchange(&query).await.unwrap();
+            let validated = validate_opaque_response(&classified, &response).unwrap();
+            assert_eq!(validated.rcode(), u16::from(RCODE_NOERROR));
+        }
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 3);
+
+        let cached_query = opaque_query(99, "txt.example", 16);
+        // Controller diagnostics share the existing opaque cache, without
+        // passing through address-only middleware or adding a second cache.
+        let cached = resolver.query_upstream(&cached_query).await.unwrap();
+        assert_eq!(u16::from_be_bytes([cached[0], cached[1]]), 99);
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 3);
+        assert_eq!(resolver.domain_hint(address).await, None);
+    }
+
+    #[tokio::test]
+    async fn udp_truncation_retries_the_same_upstream_over_tcp() {
+        for query_type in [1, 16] {
+            let dispatcher = Arc::new(MockDispatcher::with_replies(
+                vec![MockReply::Response(ResponseSpec::truncated())],
+                vec![MockReply::Response(ResponseSpec::rcode(RCODE_NOERROR))],
+            ));
+            let resolver = RuntimeDns::new(
+                &config(false, vec![nameserver(7, DnsTransport::Udp)]),
+                dispatcher.clone(),
+            );
+            let query = opaque_query(20, "answer.example", query_type);
+            let response = resolver.exchange(&query).await.unwrap();
+            assert_eq!(response[3] & 0xf, 0);
+            assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 1);
+            assert_eq!(dispatcher.tcp_calls.load(Ordering::Acquire), 1);
+            assert_eq!(
+                *dispatcher.udp_destinations.lock().unwrap(),
+                *dispatcher.tcp_destinations.lock().unwrap()
+            );
+        }
+    }
+
+    #[tokio::test]
+    async fn transport_error_and_servfail_fail_over_in_order() {
+        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 12));
+        let dispatcher = Arc::new(MockDispatcher::with_replies(
+            vec![
+                MockReply::TransportError,
+                MockReply::Response(ResponseSpec::rcode(RCODE_SERVFAIL)),
+                MockReply::Response(ResponseSpec::answer(address)),
             ],
             vec![],
         ));
-        let proxy = Arc::new(MockDispatcher::with_replies(
-            vec![MockReply::Response(ResponseSpec::answer(answer))],
+        let resolver = RuntimeDns::new(
+            &config(
+                false,
+                vec![
+                    nameserver(1, DnsTransport::Udp),
+                    nameserver(2, DnsTransport::Udp),
+                    nameserver(3, DnsTransport::Udp),
+                ],
+            ),
+            dispatcher.clone(),
+        );
+
+        assert_eq!(resolver.resolve("example.com").await.unwrap(), [address]);
+        assert_eq!(
+            *dispatcher.udp_destinations.lock().unwrap(),
+            vec![
+                Destination::Ip("192.0.2.1:53".parse().unwrap()),
+                Destination::Ip("192.0.2.2:53".parse().unwrap()),
+                Destination::Ip("192.0.2.3:53".parse().unwrap()),
+            ]
+        );
+    }
+
+    #[tokio::test]
+    async fn exhausted_upstreams_return_servfail_for_address_and_opaque_queries() {
+        let dispatcher = Arc::new(MockDispatcher::with_replies(
+            vec![MockReply::TransportError, MockReply::TransportError],
             vec![],
         ));
-        let mut first = nameserver(10, DnsTransport::Udp);
-        first.route = DnsRoute::Direct;
-        let mut first_fallback = nameserver(11, DnsTransport::Udp);
-        first_fallback.route = DnsRoute::Direct;
-        let second = nameserver(12, DnsTransport::Udp);
-        let mut dns_config = config(false, vec![nameserver(1, DnsTransport::Udp)]);
-        dns_config.nameserver_policies = vec![
-            dns_policy(&["first"], vec![first, first_fallback]),
-            dns_policy(&["second"], vec![second]),
-        ];
-        let resolver = RuntimeDns::new_routed(
-            &dns_config,
-            proxy.clone(),
-            direct.clone(),
-            RuleSet::compile(vec![rule(
-                RuleKind::Match,
-                RuleAction::Route(crate::config::RouteTargetId::Proxy(
-                    crate::config::ProxyId::new(0).unwrap(),
-                )),
-            )])
-            .unwrap(),
-            Arc::new(PolicyGeoMatcher),
+        let resolver = RuntimeDns::new(
+            &config(
+                false,
+                vec![
+                    nameserver(1, DnsTransport::Udp),
+                    nameserver(2, DnsTransport::Udp),
+                ],
+            ),
+            dispatcher,
         );
+        let query = build_query(30, "address.example", QueryType::A).unwrap();
+        let response = resolver.exchange(&query).await.unwrap();
+        assert_eq!(parse_response(&response).unwrap().rcode, RCODE_SERVFAIL);
 
-        let response = resolver
-            .exchange(&build_query(66, "overlap.test", QueryType::A).unwrap())
-            .await
-            .unwrap();
-        assert_eq!(parse_response(&response).unwrap().rcode, RCODE_NOERROR);
-        assert_eq!(direct.udp_calls.load(Ordering::Acquire), 2);
-        assert_eq!(proxy.udp_calls.load(Ordering::Acquire), 0);
+        let dispatcher = Arc::new(MockDispatcher::with_replies(
+            vec![MockReply::TransportError, MockReply::TransportError],
+            vec![],
+        ));
+        let resolver = RuntimeDns::new(
+            &config(
+                false,
+                vec![
+                    nameserver(1, DnsTransport::Udp),
+                    nameserver(2, DnsTransport::Udp),
+                ],
+            ),
+            dispatcher,
+        );
+        let query = opaque_query(31, "txt.example", 16);
+        let classified = classify_query(&query).unwrap();
+        let response = resolver.exchange(&query).await.unwrap();
         assert_eq!(
-            *direct.udp_destinations.lock().unwrap(),
-            [
-                Destination::Ip("192.0.2.10:53".parse().unwrap()),
-                Destination::Ip("192.0.2.11:53".parse().unwrap()),
-            ]
+            validate_opaque_response(&classified, &response)
+                .unwrap()
+                .rcode(),
+            u16::from(RCODE_SERVFAIL)
+        );
+    }
+
+    #[test]
+    fn nameserver_failure_summary_does_not_expose_error_details() {
+        let error = AttemptError::Dispatch(DispatchError::Other(
+            "sentinel-token at 198.51.100.77:53".to_owned(),
+        ));
+        assert_eq!(error.summary(3).as_ref(), "nameserver 3 failed: dispatcher");
+    }
+
+    #[tokio::test]
+    async fn positive_cache_and_redir_host_hint_avoid_a_second_exchange() {
+        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 13));
+        let dispatcher = Arc::new(MockDispatcher::with_replies(
+            vec![MockReply::Response(ResponseSpec::answer(address))],
+            vec![],
+        ));
+        let resolver = RuntimeDns::new(
+            &config(false, vec![nameserver(1, DnsTransport::Udp)]),
+            dispatcher.clone(),
+        );
+
+        assert_eq!(resolver.resolve("Example.COM.").await.unwrap(), [address]);
+        assert_eq!(resolver.resolve("example.com").await.unwrap(), [address]);
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 1);
+        assert_eq!(
+            resolver.domain_hint(address).await,
+            Some("example.com".to_owned())
+        );
+    }
+
+    #[test]
+    fn concurrent_redir_host_hint_reads_and_dns_updates_complete() {
+        fn require_send<T: Send>(value: T) -> T {
+            value
+        }
+
+        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 13));
+        let domains = Arc::new(
+            (0..64)
+                .map(|index| format!("concurrent-{index}.example"))
+                .collect::<Vec<_>>(),
         );
+        let dispatcher = Arc::new(MockDispatcher::with_replies(
+            (0..domains.len())
+                .map(|_| MockReply::Response(ResponseSpec::answer(address)))
+                .collect(),
+            vec![],
+        ));
+        let resolver = Arc::new(RuntimeDns::new(
+            &config(false, vec![nameserver(1, DnsTransport::Udp)]),
+            dispatcher.clone(),
+        ));
+        let seeded = Arc::new(Notify::new());
+        let reader_started = Arc::new(Notify::new());
+        let writer_done = Arc::new(AtomicBool::new(false));
+        let (completed, completion) = std::sync::mpsc::channel();
+        let deadline = Instant::now() + Duration::from_secs(2);
+        let mut workers = Vec::new();
+        for writer in [true, false] {
+            let resolver = resolver.clone();
+            let domains = domains.clone();
+            let seeded = seeded.clone();
+            let reader_started = reader_started.clone();
+            let writer_done = writer_done.clone();
+            let completed = completed.clone();
+            workers.push(std::thread::spawn(move || {
+                let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+                    let runtime = tokio::runtime::Builder::new_current_thread()
+                        .enable_all()
+                        .build()
+                        .unwrap();
+                    runtime.block_on(require_send(async {
+                        tokio::time::timeout(Duration::from_secs(1), async {
+                            if writer {
+                                assert_eq!(resolver.resolve(&domains[0]).await.unwrap(), [address]);
+                                seeded.notify_one();
+                                reader_started.notified().await;
+                                for domain in domains.iter().skip(1) {
+                                    assert_eq!(resolver.resolve(domain).await.unwrap(), [address]);
+                                    assert_eq!(
+                                        resolver.domain_hint(address).await,
+                                        Some(domain.clone())
+                                    );
+                                    std::thread::yield_now();
+                                }
+                                writer_done.store(true, Ordering::Release);
+                            } else {
+                                seeded.notified().await;
+                                assert_eq!(
+                                    resolver.domain_hint(address).await,
+                                    Some(domains[0].clone())
+                                );
+                                reader_started.notify_one();
+                                while !writer_done.load(Ordering::Acquire) {
+                                    let hint = resolver.domain_hint(address).await.unwrap();
+                                    assert!(domains.contains(&hint));
+                                    tokio::task::yield_now().await;
+                                }
+                            }
+                        })
+                        .await
+                        .expect("concurrent DNS hint operations did not complete");
+                    }));
+                }));
+                let _ = completed.send(result);
+            }));
+        }
+        drop(completed);
+        for _ in 0..workers.len() {
+            let result = completion
+                .recv_timeout(deadline.saturating_duration_since(Instant::now()))
+                .expect("concurrent DNS hint workers exceeded the test deadline");
+            if let Err(panic) = result {
+                std::panic::resume_unwind(panic);
+            }
+        }
+        for worker in workers {
+            worker.join().unwrap();
+        }
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), domains.len());
+        assert_eq!(dispatcher.tcp_calls.load(Ordering::Acquire), 0);
     }
 
     #[tokio::test]
-    async fn policy_exhaustion_never_falls_back_to_main_for_typed_or_opaque_queries() {
-        let answer = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 72));
-        for opaque in [false, true] {
-            let direct = Arc::new(MockDispatcher::with_replies(
-                vec![MockReply::TransportError],
-                vec![],
-            ));
-            let proxy = Arc::new(MockDispatcher::with_replies(
-                vec![MockReply::Response(ResponseSpec::answer(answer))],
+    async fn configuration_replacement_retains_new_hint_map_and_existing_mappings() {
+        let old_address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 140));
+        let new_address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 141));
+        for (old_capacity, new_capacity) in [(0, 4), (4, 4), (0, 0), (4, 0)] {
+            let dispatcher = Arc::new(MockDispatcher::with_replies(
+                vec![
+                    MockReply::Response(ResponseSpec::answer(old_address)),
+                    MockReply::Response(ResponseSpec::answer(new_address)),
+                ],
                 vec![],
             ));
-            let mut policy_nameserver = nameserver(20, DnsTransport::Udp);
-            policy_nameserver.route = DnsRoute::Direct;
-            let mut dns_config = config(false, vec![nameserver(1, DnsTransport::Udp)]);
-            dns_config.nameserver_policies = vec![dns_policy(&["cn"], vec![policy_nameserver])];
-            let resolver = RuntimeDns::new_routed(
-                &dns_config,
-                proxy.clone(),
-                direct.clone(),
-                RuleSet::compile(vec![rule(
-                    RuleKind::Match,
-                    RuleAction::Route(crate::config::RouteTargetId::Proxy(
-                        crate::config::ProxyId::new(0).unwrap(),
-                    )),
-                )])
-                .unwrap(),
-                Arc::new(PolicyGeoMatcher),
-            );
-
-            let query = if opaque {
-                opaque_query(67, "failed.example.cn", 16)
-            } else {
-                build_query(68, "failed.example.cn", QueryType::A).unwrap()
+            let configuration = config(false, vec![nameserver(1, DnsTransport::Udp)]);
+            let assemble = |capacity| {
+                RuntimeDns::assemble(
+                    &configuration,
+                    DnsEgress::Single(dispatcher.clone()),
+                    Arc::new(EmptyGeoMatcher),
+                    MAX_CACHE_ENTRIES,
+                    capacity,
+                    crate::security::SecurityContext::new(),
+                )
             };
-            let response = resolver.exchange(&query).await.unwrap();
-            if opaque {
-                assert_eq!(
-                    validate_opaque_response(&classify_query(&query).unwrap(), &response)
-                        .unwrap()
-                        .rcode(),
-                    u16::from(RCODE_SERVFAIL)
+            let previous = assemble(old_capacity);
+            previous
+                .exchange(&build_query(891, "before.example", QueryType::A).unwrap())
+                .await
+                .unwrap();
+            let replacement = assemble(new_capacity);
+            let newly_allocated = replacement.hints.clone();
+            let current = replacement.with_mapping_from(Some(&previous));
+
+            current
+                .exchange(&build_query(892, "after.example", QueryType::A).unwrap())
+                .await
+                .unwrap();
+            assert_eq!(
+                current.domain_hint(new_address).await.as_deref(),
+                (old_capacity != 0 || new_capacity != 0).then_some("after.example")
+            );
+            assert_eq!(
+                current.domain_hint(old_address).await.as_deref(),
+                (old_capacity != 0).then_some("before.example")
+            );
+            if let Some(expected) = previous.hints.as_ref().or(newly_allocated.as_ref()) {
+                assert!(
+                    current
+                        .hints
+                        .as_ref()
+                        .is_some_and(|hints| Arc::ptr_eq(hints, expected))
                 );
             } else {
-                assert_eq!(parse_response(&response).unwrap().rcode, RCODE_SERVFAIL);
+                assert!(current.hints.is_none());
             }
-            assert_eq!(direct.udp_calls.load(Ordering::Acquire), 1);
-            assert_eq!(proxy.udp_calls.load(Ordering::Acquire), 0);
+            assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 2);
         }
     }
 
     #[tokio::test]
-    async fn policy_nxdomain_is_terminal_and_ipv6_disabled_aaaa_stays_local() {
-        let direct = Arc::new(MockDispatcher::with_replies(
-            vec![
-                MockReply::Response(ResponseSpec::rcode(RCODE_NXDOMAIN)),
-                MockReply::Response(ResponseSpec::rcode(RCODE_NOERROR)),
-            ],
-            vec![],
-        ));
-        let proxy = Arc::new(MockDispatcher::default());
-        let mut first = nameserver(30, DnsTransport::Udp);
-        first.route = DnsRoute::Direct;
-        let mut fallback = nameserver(31, DnsTransport::Udp);
-        fallback.route = DnsRoute::Direct;
-        let mut dns_config = config(false, vec![nameserver(1, DnsTransport::Udp)]);
-        dns_config.nameserver_policies = vec![dns_policy(&["cn"], vec![first, fallback])];
-        let resolver = RuntimeDns::new_routed(
-            &dns_config,
-            proxy.clone(),
-            direct.clone(),
-            RuleSet::compile(vec![rule(
-                RuleKind::Match,
-                RuleAction::Route(crate::config::RouteTargetId::Proxy(
-                    crate::config::ProxyId::new(0).unwrap(),
-                )),
-            )])
-            .unwrap(),
-            Arc::new(PolicyGeoMatcher),
-        );
-
-        let response = resolver
-            .exchange(&build_query(69, "missing.example.cn", QueryType::A).unwrap())
-            .await
-            .unwrap();
-        assert_eq!(parse_response(&response).unwrap().rcode, RCODE_NXDOMAIN);
-        let response = resolver
-            .exchange(&build_query(70, "v6.example.cn", QueryType::Aaaa).unwrap())
-            .await
-            .unwrap();
-        assert_eq!(parse_response(&response).unwrap().rcode, RCODE_NOERROR);
-        assert_eq!(parse_response(&response).unwrap().answer_count, 0);
-        assert_eq!(direct.udp_calls.load(Ordering::Acquire), 1);
-        assert_eq!(proxy.udp_calls.load(Ordering::Acquire), 0);
-    }
-
-    #[tokio::test]
-    async fn opaque_queries_share_proxy_tag_and_endpoint_rules_egress() {
-        let proxy = Arc::new(MockDispatcher::with_replies(
-            vec![MockReply::Response(ResponseSpec::rcode(RCODE_NOERROR))],
+    async fn zero_redir_host_capacity_disables_only_hints_not_typed_cache() {
+        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 14));
+        let dispatcher = Arc::new(MockDispatcher::with_replies(
+            vec![MockReply::Response(ResponseSpec::answer(address))],
             vec![],
         ));
-        let direct = Arc::new(MockDispatcher::default());
-        let resolver = RuntimeDns::new_routed(
+        let resolver = RuntimeDns::assemble(
             &config(false, vec![nameserver(1, DnsTransport::Udp)]),
-            proxy.clone(),
-            direct.clone(),
-            RuleSet::compile(vec![rule(RuleKind::Match, RuleAction::Direct)]).unwrap(),
+            DnsEgress::Single(dispatcher.clone()),
             Arc::new(EmptyGeoMatcher),
+            MAX_CACHE_ENTRIES,
+            0,
+            crate::security::SecurityContext::new(),
         );
-        resolver
-            .exchange(&opaque_query(4, "txt.example", 16))
-            .await
-            .unwrap();
-        assert_eq!(proxy.udp_calls.load(Ordering::Acquire), 1);
-        assert_eq!(direct.udp_calls.load(Ordering::Acquire), 0);
 
-        let proxy = Arc::new(MockDispatcher::default());
-        let direct = Arc::new(MockDispatcher::with_replies(
-            vec![MockReply::Response(ResponseSpec::rcode(RCODE_NOERROR))],
-            vec![],
-        ));
-        let mut rules_nameserver = nameserver(2, DnsTransport::Udp);
-        rules_nameserver.route = DnsRoute::Rules;
-        let resolver = RuntimeDns::new_routed(
-            &config(false, vec![rules_nameserver]),
-            proxy.clone(),
-            direct.clone(),
-            RuleSet::compile(vec![
-                rule(
-                    RuleKind::IpCidr(IpCidr {
-                        network: "192.0.2.0".parse().unwrap(),
-                        prefix_len: 24,
-                    }),
-                    RuleAction::Direct,
-                ),
-                rule(
-                    RuleKind::Match,
-                    RuleAction::Route(crate::config::RouteTargetId::Proxy(
-                        crate::config::ProxyId::new(0).unwrap(),
-                    )),
-                ),
-            ])
-            .unwrap(),
-            Arc::new(EmptyGeoMatcher),
-        );
-        resolver
-            .exchange(&opaque_query(5, "https.example", 65))
-            .await
-            .unwrap();
-        assert_eq!(direct.udp_calls.load(Ordering::Acquire), 1);
-        assert_eq!(proxy.udp_calls.load(Ordering::Acquire), 0);
+        assert!(resolver.hints.is_none());
+        assert_eq!(resolver.resolve("example.com").await.unwrap(), [address]);
+        assert_eq!(resolver.resolve("example.com").await.unwrap(), [address]);
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 1);
+        assert_eq!(resolver.domain_hint(address).await, None);
     }
 
     #[tokio::test]
-    async fn direct_nameserver_round_trips_real_udp_and_tcp_sockets() {
-        let udp = UdpSocket::bind("127.0.0.1:0").await.unwrap();
-        let udp_address = udp.local_addr().unwrap();
-        let udp_server = tokio::spawn(async move {
-            let mut query = [0_u8; MAX_MESSAGE_SIZE];
-            let (length, peer) = udp.recv_from(&mut query).await.unwrap();
-            let response =
-                response_for_query(&query[..length], &ResponseSpec::rcode(RCODE_NOERROR));
-            udp.send_to(&response, peer).await.unwrap();
-        });
-        let proxy = Arc::new(MockDispatcher::default());
-        let direct: Arc<dyn Dispatcher> = Arc::new(DirectOutbound::new(Dialer::default()));
-        let udp_nameserver = DnsNameserver {
-            transport: DnsTransport::Udp,
-            address: udp_address.ip(),
-            port: udp_address.port(),
-            route: DnsRoute::Direct,
-        };
-        let resolver = RuntimeDns::new_routed(
-            &config(false, vec![udp_nameserver]),
-            proxy.clone(),
-            direct.clone(),
-            RuleSet::compile(vec![rule(
-                RuleKind::Match,
-                RuleAction::Route(crate::config::RouteTargetId::Proxy(
-                    crate::config::ProxyId::new(0).unwrap(),
-                )),
-            )])
-            .unwrap(),
-            Arc::new(EmptyGeoMatcher),
-        );
-        let query = opaque_query(50, "txt.example", 16);
-        let classified = classify_query(&query).unwrap();
-        let response = resolver.exchange(&query).await.unwrap();
-        assert_eq!(
-            validate_opaque_response(&classified, &response)
-                .unwrap()
-                .rcode(),
-            u16::from(RCODE_NOERROR)
+    async fn nodata_and_nxdomain_are_negative_cached_without_failover() {
+        let dispatcher = Arc::new(MockDispatcher::with_replies(
+            vec![
+                MockReply::Response(ResponseSpec::rcode(RCODE_NOERROR)),
+                MockReply::Response(ResponseSpec::rcode(RCODE_NXDOMAIN)),
+            ],
+            vec![],
+        ));
+        let resolver = RuntimeDns::new(
+            &config(
+                false,
+                vec![
+                    nameserver(1, DnsTransport::Udp),
+                    nameserver(2, DnsTransport::Udp),
+                ],
+            ),
+            dispatcher.clone(),
         );
-        udp_server.await.unwrap();
-        assert_eq!(proxy.udp_calls.load(Ordering::Acquire), 0);
 
-        let tcp = TcpListener::bind("127.0.0.1:0").await.unwrap();
-        let tcp_address = tcp.local_addr().unwrap();
-        let tcp_server = tokio::spawn(async move {
-            let (mut stream, _) = tcp.accept().await.unwrap();
-            let length = stream.read_u16().await.unwrap() as usize;
-            let mut query = vec![0_u8; length];
-            stream.read_exact(&mut query).await.unwrap();
-            let response = response_for_query(&query, &ResponseSpec::rcode(RCODE_NOERROR));
-            stream.write_u16(response.len() as u16).await.unwrap();
-            stream.write_all(&response).await.unwrap();
-        });
-        let tcp_nameserver = DnsNameserver {
-            transport: DnsTransport::Tcp,
-            address: tcp_address.ip(),
-            port: tcp_address.port(),
-            route: DnsRoute::Direct,
-        };
-        let resolver = RuntimeDns::new_routed(
-            &config(false, vec![tcp_nameserver]),
-            proxy.clone(),
-            direct,
-            RuleSet::compile(vec![rule(
-                RuleKind::Match,
-                RuleAction::Route(crate::config::RouteTargetId::Proxy(
-                    crate::config::ProxyId::new(0).unwrap(),
-                )),
-            )])
-            .unwrap(),
-            Arc::new(EmptyGeoMatcher),
-        );
-        let query = opaque_query(51, "https.example", 65);
-        let classified = classify_query(&query).unwrap();
-        let response = resolver.exchange(&query).await.unwrap();
+        for id in [1, 2] {
+            let query = build_query(id, "nodata.example", QueryType::A).unwrap();
+            let response = parse_response(&resolver.exchange(&query).await.unwrap()).unwrap();
+            assert_eq!(response.id, id);
+            assert_eq!(response.rcode, RCODE_NOERROR);
+            assert_eq!(response.answer_count, 0);
+        }
+        for id in [3, 4] {
+            let query = build_query(id, "missing.example", QueryType::A).unwrap();
+            let response = parse_response(&resolver.exchange(&query).await.unwrap()).unwrap();
+            assert_eq!(response.id, id);
+            assert_eq!(response.rcode, RCODE_NXDOMAIN);
+            assert_eq!(response.answer_count, 0);
+        }
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 2);
         assert_eq!(
-            validate_opaque_response(&classified, &response)
-                .unwrap()
-                .rcode(),
-            u16::from(RCODE_NOERROR)
+            *dispatcher.udp_destinations.lock().unwrap(),
+            vec![
+                Destination::Ip("192.0.2.1:53".parse().unwrap()),
+                Destination::Ip("192.0.2.1:53".parse().unwrap()),
+            ]
         );
-        tcp_server.await.unwrap();
-        assert_eq!(proxy.tcp_calls.load(Ordering::Acquire), 0);
     }
 
     #[tokio::test]
-    async fn rules_reject_fails_over_to_the_next_nameserver() {
-        let answer = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 41));
-        let proxy = Arc::new(MockDispatcher::with_replies(
-            vec![MockReply::Response(ResponseSpec::answer(answer))],
+    async fn resolve_ipv6_disabled_returns_local_nodata_and_skips_aaaa() {
+        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 14));
+        let dispatcher = Arc::new(MockDispatcher::with_replies(
+            vec![MockReply::Response(ResponseSpec::answer(address))],
             vec![],
         ));
-        let direct = Arc::new(MockDispatcher::default());
-        let mut rejected = nameserver(1, DnsTransport::Udp);
-        rejected.route = DnsRoute::Rules;
-        let allowed = nameserver(2, DnsTransport::Udp);
-        let resolver = RuntimeDns::new_routed(
-            &config(false, vec![rejected, allowed]),
-            proxy.clone(),
-            direct.clone(),
-            RuleSet::compile(vec![
-                rule(RuleKind::Network(Network::Udp), RuleAction::Reject),
-                rule(
-                    RuleKind::Match,
-                    RuleAction::Route(crate::config::RouteTargetId::Proxy(
-                        crate::config::ProxyId::new(0).unwrap(),
-                    )),
-                ),
-            ])
-            .unwrap(),
-            Arc::new(EmptyGeoMatcher),
+        let resolver = RuntimeDns::new(
+            &config(false, vec![nameserver(1, DnsTransport::Udp)]),
+            dispatcher.clone(),
         );
-        let query = build_query(4, "example.com", QueryType::A).unwrap();
+        let query = build_query(0xbeef, "example.com", QueryType::Aaaa).unwrap();
         let response = resolver.exchange(&query).await.unwrap();
-        assert_eq!(parse_response(&response).unwrap().rcode, RCODE_NOERROR);
-        assert_eq!(proxy.udp_calls.load(Ordering::Acquire), 1);
-        assert_eq!(direct.udp_calls.load(Ordering::Acquire), 0);
+        let parsed = parse_response(&response).unwrap();
+        assert_eq!(parsed.id, 0xbeef);
+        assert_eq!(parsed.question.name, "example.com");
+        assert_eq!(parsed.question.query_type, QueryType::Aaaa);
+        assert_eq!(parsed.rcode, RCODE_NOERROR);
+        assert_eq!(parsed.answer_count, 0);
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 0);
+
+        assert_eq!(resolver.resolve("example.com").await.unwrap(), [address]);
+        assert_eq!(
+            *dispatcher.udp_queries.lock().unwrap(),
+            vec![QueryType::A as u16]
+        );
     }
 
     #[tokio::test]
-    async fn opaque_qtypes_relay_cache_and_never_create_redir_host_hints() {
-        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 42));
+    async fn resolve_ipv6_merges_answers_with_ipv4_first() {
+        let ipv4 = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 15));
+        let ipv6 = IpAddr::V6("2001:db8::15".parse().unwrap());
         let dispatcher = Arc::new(MockDispatcher::with_replies(
             vec![
-                MockReply::Response(ResponseSpec::answer(address)),
-                MockReply::Response(ResponseSpec::rcode(RCODE_NOERROR)),
-                MockReply::Response(ResponseSpec::rcode(RCODE_NOERROR)),
+                MockReply::Response(ResponseSpec::answer(ipv4)),
+                MockReply::Response(ResponseSpec::answer(ipv6)),
             ],
             vec![],
         ));
         let resolver = RuntimeDns::new(
-            &config(false, vec![nameserver(1, DnsTransport::Udp)]),
+            &config(true, vec![nameserver(1, DnsTransport::Udp)]),
             dispatcher.clone(),
         );
 
-        for (id, name, query_type) in [
-            (10, "txt.example", 16),
-            (11, "https.example", 65),
-            (12, "unknown.example", 65_400),
+        assert_eq!(resolver.resolve("example.com").await.unwrap(), [ipv4, ipv6]);
+        assert_eq!(
+            *dispatcher.udp_queries.lock().unwrap(),
+            vec![QueryType::A as u16, QueryType::Aaaa as u16]
+        );
+    }
+
+    #[tokio::test]
+    async fn resolve_ipv6_keeps_successful_answers_when_the_other_stack_fails() {
+        let ipv4 = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 15));
+        let ipv6 = IpAddr::V6("2001:db8::15".parse().unwrap());
+        for (replies, expected) in [
+            (
+                vec![
+                    MockReply::Response(ResponseSpec::answer(ipv4)),
+                    MockReply::TransportError,
+                ],
+                Some(ipv4),
+            ),
+            (
+                vec![
+                    MockReply::TransportError,
+                    MockReply::Response(ResponseSpec::answer(ipv6)),
+                ],
+                Some(ipv6),
+            ),
+            (
+                vec![MockReply::TransportError, MockReply::TransportError],
+                None,
+            ),
         ] {
-            let query = opaque_query(id, name, query_type);
-            let classified = classify_query(&query).unwrap();
-            let response = resolver.exchange(&query).await.unwrap();
-            let validated = validate_opaque_response(&classified, &response).unwrap();
-            assert_eq!(validated.rcode(), u16::from(RCODE_NOERROR));
+            let dispatcher = Arc::new(MockDispatcher::with_replies(replies, vec![]));
+            let resolver = RuntimeDns::new(
+                &config(true, vec![nameserver(1, DnsTransport::Udp)]),
+                dispatcher,
+            );
+            let result = resolver.resolve("example.com").await;
+            if let Some(address) = expected {
+                assert_eq!(result.unwrap(), [address]);
+            } else {
+                assert!(result.is_err());
+            }
+            assert_eq!(resolver.resource_stats.snapshot().dns_current, 0);
+            assert_eq!(resolver.resource_stats.snapshot().singleflight_current, 0);
         }
-        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 3);
+    }
 
-        let cached_query = opaque_query(99, "txt.example", 16);
-        let cached = resolver.exchange(&cached_query).await.unwrap();
-        assert_eq!(u16::from_be_bytes([cached[0], cached[1]]), 99);
-        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 3);
-        assert_eq!(resolver.domain_hint(address).await, None);
+    #[tokio::test(start_paused = true)]
+    async fn resolve_ipv6_queries_concurrently_and_waits_from_ipv4_completion() {
+        let ipv4 = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 15));
+        let ipv6 = IpAddr::V6("2001:db8::15".parse().unwrap());
+        let release_a = Arc::new(Notify::new());
+        let release_aaaa = Arc::new(Notify::new());
+        let dispatcher = Arc::new(MockDispatcher::with_replies(
+            vec![
+                MockReply::Gated {
+                    response: ResponseSpec::answer(ipv4),
+                    release: release_a.clone(),
+                },
+                MockReply::Gated {
+                    response: ResponseSpec::answer(ipv6),
+                    release: release_aaaa.clone(),
+                },
+            ],
+            vec![],
+        ));
+        let mut dns_config = config(true, vec![nameserver(1, DnsTransport::Udp)]);
+        dns_config.ipv6_timeout = Duration::from_millis(50);
+        let resolver = Arc::new(RuntimeDns::new(&dns_config, dispatcher.clone()));
+        let lookup = tokio::spawn({
+            let resolver = resolver.clone();
+            async move { resolver.resolve("example.com").await }
+        });
+        for _ in 0..10 {
+            if dispatcher.udp_queries.lock().unwrap().len() == 2 {
+                break;
+            }
+            tokio::task::yield_now().await;
+        }
+        assert_eq!(
+            *dispatcher.udp_queries.lock().unwrap(),
+            [QueryType::A as u16, QueryType::Aaaa as u16]
+        );
+        tokio::time::advance(Duration::from_millis(500)).await;
+        assert!(!lookup.is_finished());
+        release_a.notify_one();
+        for _ in 0..10 {
+            if resolver.resource_stats.snapshot().dns_current == 1 {
+                break;
+            }
+            tokio::task::yield_now().await;
+        }
+        assert_eq!(resolver.resource_stats.snapshot().dns_current, 1);
+        tokio::time::advance(Duration::from_millis(49)).await;
+        assert!(!lookup.is_finished());
+        release_aaaa.notify_one();
+        assert_eq!(lookup.await.unwrap().unwrap(), [ipv4, ipv6]);
     }
 
-    #[tokio::test]
-    async fn opaque_udp_tc_fails_over_without_opening_tcp() {
+    #[tokio::test(start_paused = true)]
+    async fn resolve_ipv6_timeout_releases_the_pending_query() {
+        let ipv4 = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 15));
         let dispatcher = Arc::new(MockDispatcher::with_replies(
             vec![
-                MockReply::Response(ResponseSpec::truncated()),
-                MockReply::Response(ResponseSpec::rcode(RCODE_NOERROR)),
+                MockReply::Response(ResponseSpec::answer(ipv4)),
+                MockReply::Pending,
             ],
             vec![],
         ));
         let resolver = RuntimeDns::new(
-            &config(
-                false,
-                vec![
-                    nameserver(7, DnsTransport::Udp),
-                    nameserver(8, DnsTransport::Udp),
-                ],
-            ),
+            &config(true, vec![nameserver(1, DnsTransport::Udp)]),
             dispatcher.clone(),
         );
-        let query = opaque_query(20, "txt.example", 16);
-        let classified = classify_query(&query).unwrap();
-        let response = resolver.exchange(&query).await.unwrap();
-        assert_eq!(
-            validate_opaque_response(&classified, &response)
-                .unwrap()
-                .rcode(),
-            u16::from(RCODE_NOERROR)
-        );
-        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 2);
-        assert_eq!(dispatcher.tcp_calls.load(Ordering::Acquire), 0);
+        let started = TokioInstant::now();
+        assert_eq!(resolver.resolve("example.com").await.unwrap(), [ipv4]);
+        assert_eq!(TokioInstant::now() - started, Duration::from_millis(100));
         assert_eq!(
-            *dispatcher.udp_destinations.lock().unwrap(),
-            vec![
-                Destination::Ip("192.0.2.7:53".parse().unwrap()),
-                Destination::Ip("192.0.2.8:53".parse().unwrap()),
-            ]
+            *dispatcher.udp_queries.lock().unwrap(),
+            [QueryType::A as u16, QueryType::Aaaa as u16]
         );
+        assert_eq!(resolver.resource_stats.snapshot().dns_current, 0);
+        assert_eq!(resolver.resource_stats.snapshot().singleflight_current, 0);
+    }
+
+    #[tokio::test]
+    async fn resolve_ipv6_cancellation_releases_both_queries() {
+        let dispatcher = Arc::new(MockDispatcher::with_replies(
+            vec![MockReply::Pending, MockReply::Pending],
+            vec![],
+        ));
+        let resolver = Arc::new(RuntimeDns::new(
+            &config(true, vec![nameserver(1, DnsTransport::Udp)]),
+            dispatcher.clone(),
+        ));
+        let lookup = tokio::spawn({
+            let resolver = resolver.clone();
+            async move { resolver.resolve("example.com").await }
+        });
+        for _ in 0..10 {
+            if dispatcher.udp_queries.lock().unwrap().len() == 2 {
+                break;
+            }
+            tokio::task::yield_now().await;
+        }
+        assert_eq!(resolver.resource_stats.snapshot().dns_current, 2);
+        lookup.abort();
+        assert!(lookup.await.unwrap_err().is_cancelled());
+        assert_eq!(resolver.resource_stats.snapshot().dns_current, 0);
+        assert_eq!(resolver.resource_stats.snapshot().singleflight_current, 0);
     }
 
     #[tokio::test]
-    async fn all_opaque_udp_tc_responses_converge_to_servfail_without_tcp() {
+    async fn configured_tcp_tc_response_fails_over() {
+        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 18));
         let dispatcher = Arc::new(MockDispatcher::with_replies(
+            vec![],
             vec![
                 MockReply::Response(ResponseSpec::truncated()),
-                MockReply::Response(ResponseSpec::truncated()),
+                MockReply::Response(ResponseSpec::answer(address)),
             ],
-            vec![],
         ));
         let resolver = RuntimeDns::new(
             &config(
                 false,
                 vec![
-                    nameserver(7, DnsTransport::Udp),
-                    nameserver(8, DnsTransport::Udp),
+                    nameserver(7, DnsTransport::Tcp),
+                    nameserver(8, DnsTransport::Tcp),
                 ],
             ),
             dispatcher.clone(),
         );
-        let query = opaque_query(21, "txt.example", 16);
-        let classified = classify_query(&query).unwrap();
-        let response = resolver.exchange(&query).await.unwrap();
-        assert_eq!(
-            validate_opaque_response(&classified, &response)
-                .unwrap()
-                .rcode(),
-            u16::from(RCODE_SERVFAIL)
+
+        assert_eq!(resolver.resolve("example.com").await.unwrap(), [address]);
+        assert_eq!(dispatcher.tcp_calls.load(Ordering::Acquire), 2);
+    }
+
+    #[test]
+    fn address_selection_follows_only_the_reachable_cname_chain_and_its_ttl() {
+        let selected = Ipv4Addr::new(203, 0, 113, 19);
+        let response = parsed_response_with_answers(
+            "alias.example",
+            QueryType::A,
+            vec![
+                DnsRecord {
+                    name: "alias.example".to_owned(),
+                    ttl: 60,
+                    data: RecordData::Cname("middle.example".to_owned()),
+                },
+                DnsRecord {
+                    name: "middle.example".to_owned(),
+                    ttl: 45,
+                    data: RecordData::Cname("target.example".to_owned()),
+                },
+                DnsRecord {
+                    name: "unrelated.example".to_owned(),
+                    ttl: 1,
+                    data: RecordData::A(Ipv4Addr::new(192, 0, 2, 200)),
+                },
+                DnsRecord {
+                    name: "target.example".to_owned(),
+                    ttl: 90,
+                    data: RecordData::A(selected),
+                },
+            ],
         );
-        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 2);
-        assert_eq!(dispatcher.tcp_calls.load(Ordering::Acquire), 0);
+
+        let matching = matching_answer_set(&response).unwrap();
+        assert_eq!(matching.addresses, [IpAddr::V4(selected)]);
+        assert_eq!(matching.ttl, Some(45));
+    }
+
+    #[test]
+    fn unrelated_address_owner_is_not_cached_under_the_question_name() {
+        let response = parsed_response_with_answers(
+            "victim.example",
+            QueryType::A,
+            vec![DnsRecord {
+                name: "unrelated.example".to_owned(),
+                ttl: 60,
+                data: RecordData::A(Ipv4Addr::new(192, 0, 2, 201)),
+            }],
+        );
+
+        let matching = matching_answer_set(&response).unwrap();
+        assert!(matching.addresses.is_empty());
+        assert_eq!(matching.ttl, None);
     }
 
-    #[tokio::test]
-    async fn transport_error_and_servfail_fail_over_in_order() {
-        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 12));
-        let dispatcher = Arc::new(MockDispatcher::with_replies(
+    #[test]
+    fn cname_loops_and_conflicting_targets_are_rejected() {
+        let looped = parsed_response_with_answers(
+            "one.example",
+            QueryType::A,
             vec![
-                MockReply::TransportError,
-                MockReply::Response(ResponseSpec::rcode(RCODE_SERVFAIL)),
-                MockReply::Response(ResponseSpec::answer(address)),
+                DnsRecord {
+                    name: "one.example".to_owned(),
+                    ttl: 60,
+                    data: RecordData::Cname("two.example".to_owned()),
+                },
+                DnsRecord {
+                    name: "two.example".to_owned(),
+                    ttl: 60,
+                    data: RecordData::Cname("one.example".to_owned()),
+                },
             ],
-            vec![],
-        ));
-        let resolver = RuntimeDns::new(
-            &config(
-                false,
-                vec![
-                    nameserver(1, DnsTransport::Udp),
-                    nameserver(2, DnsTransport::Udp),
-                    nameserver(3, DnsTransport::Udp),
-                ],
-            ),
-            dispatcher.clone(),
         );
+        assert!(matches!(
+            matching_answer_set(&looped),
+            Err(DnsError::InvalidCnameChain)
+        ));
 
-        assert_eq!(resolver.resolve("example.com").await.unwrap(), [address]);
-        assert_eq!(
-            *dispatcher.udp_destinations.lock().unwrap(),
+        let conflicting = parsed_response_with_answers(
+            "one.example",
+            QueryType::A,
             vec![
-                Destination::Ip("192.0.2.1:53".parse().unwrap()),
-                Destination::Ip("192.0.2.2:53".parse().unwrap()),
-                Destination::Ip("192.0.2.3:53".parse().unwrap()),
-            ]
-        );
-    }
-
-    #[tokio::test]
-    async fn exhausted_upstreams_return_servfail_for_address_and_opaque_queries() {
-        let dispatcher = Arc::new(MockDispatcher::with_replies(
-            vec![MockReply::TransportError, MockReply::TransportError],
-            vec![],
-        ));
-        let resolver = RuntimeDns::new(
-            &config(
-                false,
-                vec![
-                    nameserver(1, DnsTransport::Udp),
-                    nameserver(2, DnsTransport::Udp),
-                ],
-            ),
-            dispatcher,
+                DnsRecord {
+                    name: "one.example".to_owned(),
+                    ttl: 60,
+                    data: RecordData::Cname("two.example".to_owned()),
+                },
+                DnsRecord {
+                    name: "one.example".to_owned(),
+                    ttl: 30,
+                    data: RecordData::Cname("three.example".to_owned()),
+                },
+            ],
         );
-        let query = build_query(30, "address.example", QueryType::A).unwrap();
-        let response = resolver.exchange(&query).await.unwrap();
-        assert_eq!(parse_response(&response).unwrap().rcode, RCODE_SERVFAIL);
-
-        let dispatcher = Arc::new(MockDispatcher::with_replies(
-            vec![MockReply::TransportError, MockReply::TransportError],
-            vec![],
+        assert!(matches!(
+            matching_answer_set(&conflicting),
+            Err(DnsError::InvalidCnameChain)
         ));
-        let resolver = RuntimeDns::new(
-            &config(
-                false,
-                vec![
-                    nameserver(1, DnsTransport::Udp),
-                    nameserver(2, DnsTransport::Udp),
-                ],
-            ),
-            dispatcher,
-        );
-        let query = opaque_query(31, "txt.example", 16);
-        let classified = classify_query(&query).unwrap();
-        let response = resolver.exchange(&query).await.unwrap();
-        assert_eq!(
-            validate_opaque_response(&classified, &response)
-                .unwrap()
-                .rcode(),
-            u16::from(RCODE_SERVFAIL)
-        );
     }
 
     #[test]
-    fn nameserver_failure_summary_does_not_expose_error_details() {
-        let error = AttemptError::Dispatch(DispatchError::Other(
-            "sentinel-token at 198.51.100.77:53".to_owned(),
+    fn cname_selection_retains_only_sixteen_unique_addresses() {
+        let answers = (0..=MAX_ANSWERS)
+            .map(|index| DnsRecord {
+                name: "example.com".to_owned(),
+                ttl: 60,
+                data: RecordData::A(Ipv4Addr::new(192, 0, 2, u8::try_from(index).unwrap())),
+            })
+            .collect();
+        let response = parsed_response_with_answers("example.com", QueryType::A, answers);
+
+        assert!(matches!(
+            matching_answer_set(&response),
+            Ok(MatchingAnswerSet { addresses, .. }) if addresses.len() == MAX_ANSWERS
         ));
-        assert_eq!(error.summary(3).as_ref(), "nameserver 3 failed: dispatcher");
     }
 
     #[tokio::test]
-    async fn positive_cache_and_redir_host_hint_avoid_a_second_exchange() {
-        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 13));
+    async fn first_typed_response_keeps_all_records_while_cache_retains_sixteen_addresses() {
+        let addresses = (1..=20)
+            .map(|index| IpAddr::V4(Ipv4Addr::new(203, 0, 113, index)))
+            .collect::<Vec<_>>();
         let dispatcher = Arc::new(MockDispatcher::with_replies(
-            vec![MockReply::Response(ResponseSpec::answer(address))],
+            vec![MockReply::Response(ResponseSpec {
+                rcode: RCODE_NOERROR,
+                truncated: false,
+                answers: addresses,
+            })],
             vec![],
         ));
         let resolver = RuntimeDns::new(
@@ -3762,620 +7379,996 @@ mod tests {
             dispatcher.clone(),
         );
 
-        assert_eq!(resolver.resolve("Example.COM.").await.unwrap(), [address]);
-        assert_eq!(resolver.resolve("example.com").await.unwrap(), [address]);
+        let first = build_query(500, "many.example", QueryType::A).unwrap();
+        let first = resolver.exchange(&first).await.unwrap();
+        let first = parse_response(&first).unwrap();
+        assert_eq!(first.id, 500);
+        assert_eq!(first.answer_count, 20);
+        assert_eq!(first.answers.len(), 20);
+
+        let cached = build_query(501, "many.example", QueryType::A).unwrap();
+        let cached = resolver.exchange(&cached).await.unwrap();
+        let cached = parse_response(&cached).unwrap();
+        assert_eq!(cached.id, 501);
+        assert_eq!(usize::from(cached.answer_count), MAX_ANSWERS);
+        assert_eq!(cached.answers.len(), MAX_ANSWERS);
         assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 1);
-        assert_eq!(
-            resolver.domain_hint(address).await,
-            Some("example.com".to_owned())
-        );
     }
 
-    #[test]
-    fn concurrent_redir_host_hint_reads_and_dns_updates_complete() {
-        fn require_send<T: Send>(value: T) -> T {
-            value
-        }
-
-        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 13));
-        let domains = Arc::new(
-            (0..64)
-                .map(|index| format!("concurrent-{index}.example"))
-                .collect::<Vec<_>>(),
-        );
+    #[tokio::test]
+    async fn eighty_identical_queries_share_one_upstream_and_restore_every_client_id() {
+        const CLIENTS: usize = 80;
+        let release = Arc::new(Notify::new());
+        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 100));
         let dispatcher = Arc::new(MockDispatcher::with_replies(
-            (0..domains.len())
-                .map(|_| MockReply::Response(ResponseSpec::answer(address)))
-                .collect(),
+            vec![MockReply::Gated {
+                response: ResponseSpec::answer(address),
+                release: release.clone(),
+            }],
             vec![],
         ));
-        let resolver = Arc::new(RuntimeDns::new(
+        let resolver = Arc::new(RuntimeDns::assemble(
             &config(false, vec![nameserver(1, DnsTransport::Udp)]),
-            dispatcher.clone(),
+            DnsEgress::Single(dispatcher.clone()),
+            Arc::new(EmptyGeoMatcher),
+            MAX_CACHE_ENTRIES,
+            MAX_REDIR_HOST_ENTRIES,
+            crate::security::SecurityContext::new(),
         ));
-        let seeded = Arc::new(Notify::new());
-        let reader_started = Arc::new(Notify::new());
-        let writer_done = Arc::new(AtomicBool::new(false));
-        let (completed, completion) = std::sync::mpsc::channel();
-        let deadline = Instant::now() + Duration::from_secs(2);
-        let mut workers = Vec::new();
-        for writer in [true, false] {
+
+        let mut tasks = Vec::with_capacity(CLIENTS);
+        for index in 0..CLIENTS {
             let resolver = resolver.clone();
-            let domains = domains.clone();
-            let seeded = seeded.clone();
-            let reader_started = reader_started.clone();
-            let writer_done = writer_done.clone();
-            let completed = completed.clone();
-            workers.push(std::thread::spawn(move || {
-                let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
-                    let runtime = tokio::runtime::Builder::new_current_thread()
-                        .enable_all()
-                        .build()
-                        .unwrap();
-                    runtime.block_on(require_send(async {
-                        tokio::time::timeout(Duration::from_secs(1), async {
-                            if writer {
-                                assert_eq!(resolver.resolve(&domains[0]).await.unwrap(), [address]);
-                                seeded.notify_one();
-                                reader_started.notified().await;
-                                for domain in domains.iter().skip(1) {
-                                    assert_eq!(resolver.resolve(domain).await.unwrap(), [address]);
-                                    assert_eq!(
-                                        resolver.domain_hint(address).await,
-                                        Some(domain.clone())
-                                    );
-                                    std::thread::yield_now();
-                                }
-                                writer_done.store(true, Ordering::Release);
-                            } else {
-                                seeded.notified().await;
-                                assert_eq!(
-                                    resolver.domain_hint(address).await,
-                                    Some(domains[0].clone())
-                                );
-                                reader_started.notify_one();
-                                while !writer_done.load(Ordering::Acquire) {
-                                    let hint = resolver.domain_hint(address).await.unwrap();
-                                    assert!(domains.contains(&hint));
-                                    tokio::task::yield_now().await;
-                                }
-                            }
-                        })
-                        .await
-                        .expect("concurrent DNS hint operations did not complete");
-                    }));
-                }));
-                let _ = completed.send(result);
-            }));
-        }
-        drop(completed);
-        for _ in 0..workers.len() {
-            let result = completion
-                .recv_timeout(deadline.saturating_duration_since(Instant::now()))
-                .expect("concurrent DNS hint workers exceeded the test deadline");
-            if let Err(panic) = result {
-                std::panic::resume_unwind(panic);
-            }
+            tasks.push(tokio::spawn(async move {
+                let id = 1_000 + index as u16;
+                let query = build_query(id, "burst.example", QueryType::A).unwrap();
+                (id, resolver.exchange(&query).await)
+            }));
         }
-        for worker in workers {
-            worker.join().unwrap();
+        while resolver.resource_stats.snapshot().dns_current != CLIENTS
+            || resolver.singleflight.follower_count() != CLIENTS - 1
+        {
+            tokio::task::yield_now().await;
         }
-        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), domains.len());
-        assert_eq!(dispatcher.tcp_calls.load(Ordering::Acquire), 0);
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 1);
+        release.notify_waiters();
+
+        for task in tasks {
+            let (id, result) = task.await.unwrap();
+            let response = parse_response(&result.unwrap()).unwrap();
+            assert_eq!(response.id, id);
+            assert_eq!(matching_answer_set(&response).unwrap().addresses, [address]);
+        }
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 1);
+        assert_eq!(resolver.singleflight.len(), 0);
+        let stats = resolver.resource_stats.snapshot();
+        assert_eq!(stats.dns_current, 0);
+        assert_eq!(stats.singleflight_current, 0);
+        assert_eq!(stats.singleflight_peak, 1);
+        assert_eq!(stats.singleflight_joins, CLIENTS as u64 - 1);
     }
 
     #[tokio::test]
-    async fn zero_redir_host_capacity_disables_only_hints_not_typed_cache() {
-        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 14));
+    async fn opaque_queries_with_equal_semantics_share_one_upstream() {
+        let release = Arc::new(Notify::new());
         let dispatcher = Arc::new(MockDispatcher::with_replies(
-            vec![MockReply::Response(ResponseSpec::answer(address))],
+            vec![MockReply::Gated {
+                response: ResponseSpec::rcode(RCODE_NOERROR),
+                release: release.clone(),
+            }],
             vec![],
         ));
-        let resolver = RuntimeDns::assemble(
+        let resolver = Arc::new(RuntimeDns::new(
             &config(false, vec![nameserver(1, DnsTransport::Udp)]),
-            DnsEgress::Single(dispatcher.clone()),
-            Arc::new(EmptyGeoMatcher),
-            MAX_CACHE_ENTRIES,
-            0,
-        );
+            dispatcher.clone(),
+        ));
 
-        assert!(resolver.hints.is_none());
-        assert_eq!(resolver.resolve("example.com").await.unwrap(), [address]);
-        assert_eq!(resolver.resolve("example.com").await.unwrap(), [address]);
+        let first = {
+            let resolver = resolver.clone();
+            tokio::spawn(async move {
+                let query = opaque_query(601, "opaque-flight.example", 16);
+                resolver.exchange(&query).await
+            })
+        };
+        while dispatcher.udp_calls.load(Ordering::Acquire) != 1 {
+            tokio::task::yield_now().await;
+        }
+        let second = {
+            let resolver = resolver.clone();
+            tokio::spawn(async move {
+                let query = opaque_query(602, "opaque-flight.example", 16);
+                resolver.exchange(&query).await
+            })
+        };
+        while resolver.singleflight.follower_count() != 1 {
+            tokio::task::yield_now().await;
+        }
+        release.notify_waiters();
+
+        for (id, task) in [(601, first), (602, second)] {
+            let response = task.await.unwrap().unwrap();
+            assert_eq!(u16::from_be_bytes([response[0], response[1]]), id);
+        }
         assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 1);
-        assert_eq!(resolver.domain_hint(address).await, None);
+        assert_eq!(resolver.singleflight.len(), 0);
     }
 
     #[tokio::test]
-    async fn nodata_and_nxdomain_are_negative_cached_without_failover() {
+    async fn singleflight_key_keeps_distinct_wire_semantics_separate() {
+        let release = Arc::new(Notify::new());
         let dispatcher = Arc::new(MockDispatcher::with_replies(
             vec![
-                MockReply::Response(ResponseSpec::rcode(RCODE_NOERROR)),
-                MockReply::Response(ResponseSpec::rcode(RCODE_NXDOMAIN)),
+                MockReply::Gated {
+                    response: ResponseSpec::rcode(RCODE_NOERROR),
+                    release: release.clone(),
+                },
+                MockReply::Gated {
+                    response: ResponseSpec::rcode(RCODE_NOERROR),
+                    release: release.clone(),
+                },
             ],
             vec![],
         ));
-        let resolver = RuntimeDns::new(
-            &config(
-                false,
-                vec![
-                    nameserver(1, DnsTransport::Udp),
-                    nameserver(2, DnsTransport::Udp),
-                ],
-            ),
+        let resolver = Arc::new(RuntimeDns::new(
+            &config(false, vec![nameserver(1, DnsTransport::Udp)]),
             dispatcher.clone(),
-        );
+        ));
 
-        for id in [1, 2] {
-            let query = build_query(id, "nodata.example", QueryType::A).unwrap();
-            let response = parse_response(&resolver.exchange(&query).await.unwrap()).unwrap();
-            assert_eq!(response.id, id);
-            assert_eq!(response.rcode, RCODE_NOERROR);
-            assert_eq!(response.answer_count, 0);
-        }
-        for id in [3, 4] {
-            let query = build_query(id, "missing.example", QueryType::A).unwrap();
-            let response = parse_response(&resolver.exchange(&query).await.unwrap()).unwrap();
-            assert_eq!(response.id, id);
-            assert_eq!(response.rcode, RCODE_NXDOMAIN);
-            assert_eq!(response.answer_count, 0);
+        let first = {
+            let resolver = resolver.clone();
+            tokio::spawn(async move {
+                let query = opaque_query(610, "semantic.example", 16);
+                resolver.exchange(&query).await
+            })
+        };
+        let second = {
+            let resolver = resolver.clone();
+            tokio::spawn(async move {
+                let mut query = opaque_query(611, "semantic.example", 16);
+                query[2..4].copy_from_slice(&0_u16.to_be_bytes());
+                resolver.exchange(&query).await
+            })
+        };
+        while dispatcher.udp_calls.load(Ordering::Acquire) != 2 {
+            tokio::task::yield_now().await;
         }
-        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 2);
+        assert_eq!(resolver.singleflight.len(), 2);
+        release.notify_waiters();
+
         assert_eq!(
-            *dispatcher.udp_destinations.lock().unwrap(),
-            vec![
-                Destination::Ip("192.0.2.1:53".parse().unwrap()),
-                Destination::Ip("192.0.2.1:53".parse().unwrap()),
-            ]
+            u16::from_be_bytes(first.await.unwrap().unwrap()[..2].try_into().unwrap()),
+            610
+        );
+        assert_eq!(
+            u16::from_be_bytes(second.await.unwrap().unwrap()[..2].try_into().unwrap()),
+            611
         );
+        assert_eq!(resolver.singleflight.len(), 0);
+        assert_eq!(resolver.resource_stats.snapshot().singleflight_peak, 2);
     }
 
     #[tokio::test]
-    async fn ipv6_false_returns_local_nodata_and_resolve_never_queries_aaaa() {
-        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 14));
+    async fn cancelled_leader_wakes_follower_to_reselect_without_leaking_registry_entry() {
+        let release = Arc::new(Notify::new());
+        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 101));
         let dispatcher = Arc::new(MockDispatcher::with_replies(
-            vec![MockReply::Response(ResponseSpec::answer(address))],
+            vec![
+                MockReply::Gated {
+                    response: ResponseSpec::answer(address),
+                    release,
+                },
+                MockReply::Response(ResponseSpec::answer(address)),
+            ],
             vec![],
         ));
-        let resolver = RuntimeDns::new(
+        let resolver = Arc::new(RuntimeDns::new(
             &config(false, vec![nameserver(1, DnsTransport::Udp)]),
             dispatcher.clone(),
-        );
-        let query = build_query(0xbeef, "example.com", QueryType::Aaaa).unwrap();
-        let response = resolver.exchange(&query).await.unwrap();
-        let parsed = parse_response(&response).unwrap();
-        assert_eq!(parsed.id, 0xbeef);
-        assert_eq!(parsed.question.name, "example.com");
-        assert_eq!(parsed.question.query_type, QueryType::Aaaa);
-        assert_eq!(parsed.rcode, RCODE_NOERROR);
-        assert_eq!(parsed.answer_count, 0);
-        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 0);
+        ));
 
-        assert_eq!(resolver.resolve("example.com").await.unwrap(), [address]);
-        assert_eq!(
-            *dispatcher.udp_queries.lock().unwrap(),
-            vec![QueryType::A as u16]
-        );
+        let leader = {
+            let resolver = resolver.clone();
+            tokio::spawn(async move {
+                let query = build_query(620, "cancel.example", QueryType::A).unwrap();
+                resolver.exchange(&query).await
+            })
+        };
+        while dispatcher.udp_calls.load(Ordering::Acquire) != 1 {
+            tokio::task::yield_now().await;
+        }
+        let follower = {
+            let resolver = resolver.clone();
+            tokio::spawn(async move {
+                let query = build_query(621, "cancel.example", QueryType::A).unwrap();
+                resolver.exchange(&query).await
+            })
+        };
+        while resolver.singleflight.follower_count() != 1 {
+            tokio::task::yield_now().await;
+        }
+
+        leader.abort();
+        let _ = leader.await;
+        let response = tokio::time::timeout(Duration::from_secs(1), follower)
+            .await
+            .expect("follower must re-elect before its query deadline")
+            .unwrap()
+            .unwrap();
+        assert_eq!(parse_response(&response).unwrap().id, 621);
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 2);
+        assert_eq!(resolver.singleflight.len(), 0);
+        assert_eq!(resolver.resource_stats.snapshot().singleflight_current, 0);
     }
 
     #[tokio::test]
-    async fn ipv6_true_resolves_a_before_aaaa() {
-        let ipv4 = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 15));
-        let ipv6 = IpAddr::V6("2001:db8::15".parse().unwrap());
+    async fn shared_upstream_failure_is_mapped_by_each_callers_failure_mode() {
+        let release = Arc::new(Notify::new());
         let dispatcher = Arc::new(MockDispatcher::with_replies(
-            vec![
-                MockReply::Response(ResponseSpec::answer(ipv4)),
-                MockReply::Response(ResponseSpec::answer(ipv6)),
-            ],
+            vec![MockReply::GatedTransportError {
+                release: release.clone(),
+            }],
             vec![],
         ));
-        let resolver = RuntimeDns::new(
-            &config(true, vec![nameserver(1, DnsTransport::Udp)]),
+        let resolver = Arc::new(RuntimeDns::new(
+            &config(false, vec![nameserver(1, DnsTransport::Udp)]),
             dispatcher.clone(),
-        );
+        ));
 
-        assert_eq!(resolver.resolve("example.com").await.unwrap(), [ipv4, ipv6]);
-        assert_eq!(
-            *dispatcher.udp_queries.lock().unwrap(),
-            vec![QueryType::A as u16, QueryType::Aaaa as u16]
-        );
+        let wire_caller = {
+            let resolver = resolver.clone();
+            tokio::spawn(async move {
+                let query = build_query(630, "failure.example", QueryType::A).unwrap();
+                resolver.exchange(&query).await
+            })
+        };
+        while dispatcher.udp_calls.load(Ordering::Acquire) != 1 {
+            tokio::task::yield_now().await;
+        }
+        let bounded_caller = {
+            let resolver = resolver.clone();
+            tokio::spawn(async move { resolver.resolve("failure.example").await })
+        };
+        while resolver.singleflight.follower_count() != 1 {
+            tokio::task::yield_now().await;
+        }
+        release.notify_waiters();
+
+        let wire = wire_caller.await.unwrap().unwrap();
+        assert_eq!(parse_response(&wire).unwrap().rcode, RCODE_SERVFAIL);
+        assert!(matches!(
+            bounded_caller.await.unwrap(),
+            Err(RuntimeDnsError::UpstreamsExhausted { .. })
+        ));
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 1);
+        assert_eq!(resolver.singleflight.len(), 0);
     }
 
     #[tokio::test]
-    async fn udp_tc_fails_over_without_opening_tcp() {
-        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 16));
+    async fn cache_hit_does_not_create_another_singleflight_entry() {
+        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 102));
         let dispatcher = Arc::new(MockDispatcher::with_replies(
-            vec![
-                MockReply::Response(ResponseSpec::truncated()),
-                MockReply::Response(ResponseSpec::answer(address)),
-            ],
+            vec![MockReply::Response(ResponseSpec::answer(address))],
             vec![],
         ));
         let resolver = RuntimeDns::new(
-            &config(
-                false,
-                vec![
-                    nameserver(7, DnsTransport::Udp),
-                    nameserver(8, DnsTransport::Udp),
-                ],
-            ),
+            &config(false, vec![nameserver(1, DnsTransport::Udp)]),
             dispatcher.clone(),
         );
-
-        assert_eq!(resolver.resolve("example.com").await.unwrap(), [address]);
-        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 2);
-        assert_eq!(dispatcher.tcp_calls.load(Ordering::Acquire), 0);
-        assert_eq!(
-            *dispatcher.udp_destinations.lock().unwrap(),
-            vec![
-                Destination::Ip("192.0.2.7:53".parse().unwrap()),
-                Destination::Ip("192.0.2.8:53".parse().unwrap()),
-            ]
-        );
+        for id in [640, 641] {
+            let query = build_query(id, "cache-flight.example", QueryType::A).unwrap();
+            assert_eq!(
+                parse_response(&resolver.exchange(&query).await.unwrap())
+                    .unwrap()
+                    .id,
+                id
+            );
+        }
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 1);
+        assert_eq!(resolver.singleflight.len(), 0);
+        let stats = resolver.resource_stats.snapshot();
+        assert_eq!(stats.singleflight_peak, 1);
+        assert_eq!(stats.singleflight_current, 0);
+        assert_eq!(stats.dns_cache_hits, 1);
     }
 
     #[tokio::test]
-    async fn all_udp_tc_responses_converge_to_servfail_without_tcp() {
+    async fn dns_cache_configured_capacity_is_shared_by_address_and_opaque_questions() {
+        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 103));
         let dispatcher = Arc::new(MockDispatcher::with_replies(
-            vec![
-                MockReply::Response(ResponseSpec::truncated()),
-                MockReply::Response(ResponseSpec::truncated()),
-            ],
+            (0..5)
+                .map(|_| MockReply::Response(ResponseSpec::answer(address)))
+                .collect(),
             vec![],
         ));
-        let resolver = RuntimeDns::new(
-            &config(
-                false,
-                vec![
-                    nameserver(7, DnsTransport::Udp),
-                    nameserver(8, DnsTransport::Udp),
-                ],
-            ),
-            dispatcher.clone(),
-        );
-
-        let query = build_query(7, "example.com", QueryType::A).unwrap();
-        let response = resolver.exchange(&query).await.unwrap();
-        assert_eq!(parse_response(&response).unwrap().rcode, RCODE_SERVFAIL);
-        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 2);
-        assert_eq!(dispatcher.tcp_calls.load(Ordering::Acquire), 0);
+        let mut configuration = config(false, vec![nameserver(1, DnsTransport::Udp)]);
+        configuration.cache_max_size = 2;
+        let resolver = RuntimeDns::new(&configuration, dispatcher.clone());
+        for (index, name, qtype) in [
+            (0, "first.example", 1),
+            (1, "opaque.example", 16),
+            (2, "first.example", 1),
+            (3, "second.example", 1),
+            (4, "opaque.example", 16),
+            (5, "first.example", 1),
+        ] {
+            let query = opaque_query(index, name, qtype);
+            resolver.exchange(&query).await.unwrap();
+        }
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 5);
+        assert_eq!(resolver.cache.lock().await.len(), 2);
+        assert_eq!(resolver.singleflight.len(), 0);
     }
 
     #[tokio::test]
-    async fn configured_tcp_tc_response_fails_over() {
-        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 18));
+    async fn dns_cache_roles_keep_independent_results_and_eviction() {
+        let addresses = (1..=5)
+            .map(|last| IpAddr::V4(Ipv4Addr::new(203, 0, 113, last)))
+            .collect::<Vec<_>>();
         let dispatcher = Arc::new(MockDispatcher::with_replies(
+            addresses
+                .iter()
+                .map(|address| MockReply::Response(ResponseSpec::answer(*address)))
+                .collect(),
             vec![],
-            vec![
-                MockReply::Response(ResponseSpec::truncated()),
-                MockReply::Response(ResponseSpec::answer(address)),
-            ],
         ));
-        let resolver = RuntimeDns::new(
-            &config(
-                false,
-                vec![
-                    nameserver(7, DnsTransport::Tcp),
-                    nameserver(8, DnsTransport::Tcp),
-                ],
-            ),
-            dispatcher.clone(),
+        let mut configuration = config(false, vec![nameserver(1, DnsTransport::Udp)]);
+        configuration.cache_max_size = 1;
+        configuration.default_nameservers = configuration.nameservers.clone();
+        configuration.proxy_nameservers = configuration.nameservers.clone();
+        configuration.direct_nameservers = configuration.nameservers.clone();
+        let resolver = RuntimeDns::new(&configuration, dispatcher.clone());
+        let roles = [
+            &resolver,
+            resolver.bootstrap.as_deref().unwrap(),
+            resolver.proxy_resolver.as_deref().unwrap(),
+            resolver.direct_resolver.as_deref().unwrap(),
+        ];
+        for _ in 0..2 {
+            for (role, address) in roles.iter().zip(&addresses) {
+                assert_eq!(role.resolve("same.example").await.unwrap(), vec![*address]);
+            }
+        }
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 4);
+        assert_eq!(
+            resolver.resolve("new.example").await.unwrap(),
+            vec![addresses[4]]
         );
-
-        assert_eq!(resolver.resolve("example.com").await.unwrap(), [address]);
-        assert_eq!(dispatcher.tcp_calls.load(Ordering::Acquire), 2);
+        for (role, address) in roles.iter().zip(&addresses).skip(1) {
+            assert_eq!(role.resolve("same.example").await.unwrap(), vec![*address]);
+        }
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 5);
+    }
+
+    fn dns_source_snapshot(
+        generation: u64,
+        server: &str,
+    ) -> super::super::source::DnsNetworkUpdate {
+        use super::super::source::*;
+        DnsNetworkUpdate {
+            generation,
+            system: vec![SystemDnsServer {
+                address: server.parse().unwrap(),
+                interface: "physical0".into(),
+                scope_id: 0,
+                requires_encryption: false,
+            }],
+            dhcp: vec![DhcpDnsInterface {
+                interface: "physical1".into(),
+                servers: vec![DnsServerAddress {
+                    address: "192.0.2.53".parse().unwrap(),
+                    scope_id: 0,
+                }],
+                requires_encryption: false,
+            }],
+        }
     }
 
-    #[test]
-    fn address_selection_follows_only_the_reachable_cname_chain_and_its_ttl() {
-        let selected = Ipv4Addr::new(203, 0, 113, 19);
-        let response = parsed_response_with_answers(
-            "alias.example",
-            QueryType::A,
-            vec![
-                DnsRecord {
-                    name: "alias.example".to_owned(),
-                    ttl: 60,
-                    data: RecordData::Cname("middle.example".to_owned()),
-                },
-                DnsRecord {
-                    name: "middle.example".to_owned(),
-                    ttl: 45,
-                    data: RecordData::Cname("target.example".to_owned()),
-                },
-                DnsRecord {
-                    name: "unrelated.example".to_owned(),
-                    ttl: 1,
-                    data: RecordData::A(Ipv4Addr::new(192, 0, 2, 200)),
-                },
-                DnsRecord {
-                    name: "target.example".to_owned(),
-                    ttl: 90,
-                    data: RecordData::A(selected),
+    #[cfg(feature = "outbound-masque")]
+    #[tokio::test]
+    async fn masque_node_dns_sources_share_exclusions_and_invalidate_private_cache() {
+        use super::super::source::SourceExclusions;
+        use crate::config::DnsSource;
+        let dispatcher = Arc::new(MockDispatcher::default());
+        let mut configuration = config(false, vec![nameserver(1, DnsTransport::Udp)]);
+        configuration.use_system_hosts = false;
+        let physical = Arc::new(
+            RuntimeDns::new(&configuration, dispatcher.clone()).with_network_sources(
+                crate::dialer::Dialer::default(),
+                SourceExclusions {
+                    interface: Some("physical1".into()),
+                    addresses: vec!["203.0.113.53".parse().unwrap()],
                 },
-            ],
+            ),
         );
-
-        let matching = matching_answer_set(&response).unwrap();
-        assert_eq!(matching.addresses, [IpAddr::V4(selected)]);
-        assert_eq!(matching.ttl, Some(45));
-    }
-
-    #[test]
-    fn unrelated_address_owner_is_not_cached_under_the_question_name() {
-        let response = parsed_response_with_answers(
-            "victim.example",
-            QueryType::A,
-            vec![DnsRecord {
-                name: "unrelated.example".to_owned(),
-                ttl: 60,
-                data: RecordData::A(Ipv4Addr::new(192, 0, 2, 201)),
-            }],
+        let sources = physical.network_sources();
+        sources.register(&physical);
+        sources
+            .replace(dns_source_snapshot(1, "203.0.113.53"))
+            .await
+            .unwrap();
+        let bootstrap = super::super::resolution::ResolutionContext::runtime(false);
+        bootstrap.bind_runtime(Some(&physical)).unwrap();
+        configuration.nameservers = vec![DnsNameserver {
+            address: DnsAddress::Source(DnsSource::System),
+            ..nameserver(1, DnsTransport::Udp)
+        }];
+        let private = RuntimeDns::new_for_masque_node(
+            &configuration,
+            dispatcher.clone(),
+            bootstrap,
+            crate::security::SecurityContext::new(),
         );
-
-        let matching = matching_answer_set(&response).unwrap();
-        assert!(matching.addresses.is_empty());
-        assert_eq!(matching.ttl, None);
-    }
-
-    #[test]
-    fn cname_loops_and_conflicting_targets_are_rejected() {
-        let looped = parsed_response_with_answers(
-            "one.example",
-            QueryType::A,
-            vec![
-                DnsRecord {
-                    name: "one.example".to_owned(),
-                    ttl: 60,
-                    data: RecordData::Cname("two.example".to_owned()),
-                },
-                DnsRecord {
-                    name: "two.example".to_owned(),
-                    ttl: 60,
-                    data: RecordData::Cname("one.example".to_owned()),
-                },
-            ],
+        assert!(Arc::ptr_eq(&sources, &private.sources));
+        assert!(Arc::ptr_eq(&physical.cache_epoch, &private.cache_epoch));
+        assert!(private.source_dialer.is_some());
+        assert!(
+            private
+                .sources
+                .select(&DnsSource::System, None, &private.source_exclusions)
+                .await
+                .is_err()
         );
-        assert!(matches!(
-            matching_answer_set(&looped),
-            Err(DnsError::InvalidCnameChain)
-        ));
-
-        let conflicting = parsed_response_with_answers(
-            "one.example",
-            QueryType::A,
-            vec![
-                DnsRecord {
-                    name: "one.example".to_owned(),
-                    ttl: 60,
-                    data: RecordData::Cname("two.example".to_owned()),
-                },
-                DnsRecord {
-                    name: "one.example".to_owned(),
-                    ttl: 30,
-                    data: RecordData::Cname("three.example".to_owned()),
-                },
-            ],
+        assert!(
+            private
+                .sources
+                .select(
+                    &DnsSource::Dhcp("physical1".into()),
+                    None,
+                    &private.source_exclusions
+                )
+                .await
+                .is_err()
         );
-        assert!(matches!(
-            matching_answer_set(&conflicting),
-            Err(DnsError::InvalidCnameChain)
-        ));
-    }
-
-    #[test]
-    fn cname_selection_retains_only_sixteen_unique_addresses() {
-        let answers = (0..=MAX_ANSWERS)
-            .map(|index| DnsRecord {
-                name: "example.com".to_owned(),
-                ttl: 60,
-                data: RecordData::A(Ipv4Addr::new(192, 0, 2, u8::try_from(index).unwrap())),
-            })
-            .collect();
-        let response = parsed_response_with_answers("example.com", QueryType::A, answers);
+        assert_eq!(private.tcp_pool.max_idle, 0);
+        assert_eq!(private.tcp_pool.max_idle_per_key, 0);
 
-        assert!(matches!(
-            matching_answer_set(&response),
-            Ok(MatchingAnswerSet { addresses, .. }) if addresses.len() == MAX_ANSWERS
-        ));
+        let now = Instant::now();
+        for resolver in [physical.as_ref(), private.as_ref()] {
+            resolver
+                .cache
+                .lock()
+                .await
+                .insert(
+                    "cached.example",
+                    QueryType::A,
+                    CacheValue::Positive(vec!["192.0.2.10".parse().unwrap()]),
+                    60,
+                    now,
+                )
+                .unwrap();
+        }
+        let epoch = *private.cache_epoch.read().await;
+        sources
+            .replace(dns_source_snapshot(2, "203.0.113.54"))
+            .await
+            .unwrap();
+        assert_eq!(*private.cache_epoch.read().await, epoch.wrapping_add(1));
+        assert!(physical.cache.lock().await.is_empty());
+        assert!(private.cache.lock().await.is_empty());
+        let selected = private
+            .sources
+            .select(&DnsSource::System, None, &private.source_exclusions)
+            .await
+            .unwrap();
+        assert_eq!(
+            selected.endpoints[0].endpoint.ip(),
+            "203.0.113.54".parse::<IpAddr>().unwrap()
+        );
+        let weak = Arc::downgrade(&private);
+        drop(private);
+        assert!(weak.upgrade().is_none());
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 0);
+        assert_eq!(dispatcher.tcp_calls.load(Ordering::Acquire), 0);
     }
 
+    #[cfg(feature = "outbound-masque")]
     #[tokio::test]
-    async fn first_typed_response_keeps_all_records_while_cache_retains_sixteen_addresses() {
-        let addresses = (1..=20)
-            .map(|index| IpAddr::V4(Ipv4Addr::new(203, 0, 113, index)))
-            .collect::<Vec<_>>();
-        let dispatcher = Arc::new(MockDispatcher::with_replies(
-            vec![MockReply::Response(ResponseSpec {
-                rcode: RCODE_NOERROR,
-                truncated: false,
-                answers: addresses,
-            })],
-            vec![],
-        ));
-        let resolver = RuntimeDns::new(
-            &config(false, vec![nameserver(1, DnsTransport::Udp)]),
-            dispatcher.clone(),
+    async fn masque_node_dns_requires_a_physical_owner_to_inherit_sources() {
+        let dispatcher = Arc::new(MockDispatcher::default());
+        let mut configuration = config(false, vec![nameserver(1, DnsTransport::Udp)]);
+        configuration.use_system_hosts = false;
+        let unbound = Arc::new(RuntimeDns::new(&configuration, dispatcher.clone()));
+        unbound
+            .sources
+            .replace(dns_source_snapshot(1, "203.0.113.53"))
+            .await
+            .unwrap();
+        let bootstrap = super::super::resolution::ResolutionContext::runtime(false);
+        bootstrap.bind_runtime(Some(&unbound)).unwrap();
+        configuration.nameservers[0].address = DnsAddress::Source(crate::config::DnsSource::System);
+        let private = RuntimeDns::new_for_masque_node(
+            &configuration,
+            dispatcher,
+            bootstrap,
+            crate::security::SecurityContext::new(),
+        );
+        assert!(!Arc::ptr_eq(&unbound.sources, &private.sources));
+        assert!(private.source_dialer.is_none());
+        assert!(
+            private
+                .sources
+                .select(
+                    &crate::config::DnsSource::System,
+                    None,
+                    &private.source_exclusions
+                )
+                .await
+                .is_err()
+        );
+        let owner = Arc::downgrade(&unbound);
+        drop(unbound);
+        assert!(owner.upgrade().is_none());
+        assert!(
+            private
+                .node_bootstrap
+                .as_ref()
+                .unwrap()
+                .runtime_dns()
+                .is_none()
         );
-
-        let first = build_query(500, "many.example", QueryType::A).unwrap();
-        let first = resolver.exchange(&first).await.unwrap();
-        let first = parse_response(&first).unwrap();
-        assert_eq!(first.id, 500);
-        assert_eq!(first.answer_count, 20);
-        assert_eq!(first.answers.len(), 20);
-
-        let cached = build_query(501, "many.example", QueryType::A).unwrap();
-        let cached = resolver.exchange(&cached).await.unwrap();
-        let cached = parse_response(&cached).unwrap();
-        assert_eq!(cached.id, 501);
-        assert_eq!(usize::from(cached.answer_count), MAX_ANSWERS);
-        assert_eq!(cached.answers.len(), MAX_ANSWERS);
-        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 1);
     }
 
     #[tokio::test]
-    async fn eighty_identical_queries_share_one_upstream_and_restore_every_client_id() {
-        const CLIENTS: usize = 80;
-        let release = Arc::new(Notify::new());
-        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 100));
+    async fn dns_source_routes_policy_bootstrap_and_every_role_to_physical_metadata() {
+        let configuration = crate::config::Config::parse_yaml(b"mixed-port: 1080\ndns:\n  enable: true\n  use-system-hosts: false\n  default-nameserver: [system]\n  nameserver: [udp://dns.example]\n  proxy-server-nameserver: [system]\n  direct-nameserver: [system]\n  nameserver-policy: {policy.example: 'dhcp://physical1'}\n").unwrap();
+        let answer: IpAddr = "203.0.113.10".parse().unwrap();
         let dispatcher = Arc::new(MockDispatcher::with_replies(
-            vec![MockReply::Gated {
-                response: ResponseSpec::answer(address),
-                release: release.clone(),
-            }],
+            (0..5)
+                .map(|_| MockReply::Response(ResponseSpec::answer(answer)))
+                .collect(),
             vec![],
         ));
-        let resolver = Arc::new(RuntimeDns::assemble(
-            &config(false, vec![nameserver(1, DnsTransport::Udp)]),
-            DnsEgress::Single(dispatcher.clone()),
-            Arc::new(EmptyGeoMatcher),
-            MAX_CACHE_ENTRIES,
-            MAX_REDIR_HOST_ENTRIES,
+        let resolver = Arc::new(RuntimeDns::new(&configuration.dns, dispatcher.clone()));
+        resolver.sources.register(&resolver);
+        resolver
+            .sources
+            .replace(dns_source_snapshot(1, "203.0.113.53"))
+            .await
+            .unwrap();
+        resolver.resolve("main.example").await.unwrap();
+        resolver
+            .proxy_resolver
+            .as_ref()
+            .unwrap()
+            .resolve("proxy.example")
+            .await
+            .unwrap();
+        resolver
+            .direct_resolver
+            .as_ref()
+            .unwrap()
+            .resolve("direct.example")
+            .await
+            .unwrap();
+        resolver.resolve("policy.example").await.unwrap();
+        let expected: Vec<Destination> = [
+            "203.0.113.53",
+            "203.0.113.10",
+            "203.0.113.53",
+            "203.0.113.53",
+            "192.0.2.53",
+        ]
+        .into_iter()
+        .map(|ip| Destination::Ip(SocketAddr::new(ip.parse().unwrap(), 53)))
+        .collect();
+        assert_eq!(*dispatcher.udp_destinations.lock().unwrap(), expected);
+    }
+
+    #[tokio::test]
+    async fn dns_source_replacement_separates_old_flights_and_clears_every_role() {
+        let old: IpAddr = "203.0.113.10".parse().unwrap();
+        let new: IpAddr = "203.0.113.11".parse().unwrap();
+        let release = Arc::new(Notify::new());
+        let dispatcher = Arc::new(MockDispatcher::with_replies(
+            vec![
+                MockReply::Gated {
+                    response: ResponseSpec::answer(old),
+                    release: release.clone(),
+                },
+                MockReply::Response(ResponseSpec::answer(new)),
+            ],
+            vec![],
         ));
+        let configuration = crate::config::Config::parse_yaml(b"mixed-port: 1080\ndns:\n  enable: true\n  default-nameserver: [system]\n  nameserver: [system]\n  proxy-server-nameserver: [system]\n  direct-nameserver: [system]\n").unwrap();
+        let resolver = Arc::new(RuntimeDns::new(&configuration.dns, dispatcher.clone()));
+        resolver.sources.register(&resolver);
+        resolver
+            .sources
+            .replace(dns_source_snapshot(1, "203.0.113.53"))
+            .await
+            .unwrap();
+        let query = build_query(851, "replace.example", QueryType::A).unwrap();
+        let pending_query = query.clone();
+        let pending_resolver = resolver.clone();
+        let pending =
+            tokio::spawn(async move { pending_resolver.exchange(&pending_query).await.unwrap() });
+        tokio::time::timeout(Duration::from_secs(1), async {
+            while dispatcher.udp_calls.load(Ordering::Acquire) != 1 {
+                tokio::task::yield_now().await;
+            }
+        })
+        .await
+        .unwrap();
+        resolver
+            .sources
+            .replace(dns_source_snapshot(2, "203.0.113.54"))
+            .await
+            .unwrap();
+        assert_eq!(
+            resolver.resolve("replace.example").await.unwrap(),
+            vec![new]
+        );
+        release.notify_one();
+        assert_eq!(
+            pending.await.unwrap(),
+            response_for_query(&query, &ResponseSpec::answer(old))
+        );
+        assert_eq!(
+            resolver.resolve("replace.example").await.unwrap(),
+            vec![new]
+        );
+        assert!(resolver.domain_hint(old).await.is_none());
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 2);
+        assert_eq!(
+            *dispatcher.udp_destinations.lock().unwrap(),
+            vec![
+                Destination::Ip("203.0.113.53:53".parse().unwrap()),
+                Destination::Ip("203.0.113.54:53".parse().unwrap())
+            ]
+        );
+        resolver
+            .sources
+            .replace(dns_source_snapshot(3, "203.0.113.54"))
+            .await
+            .unwrap();
+        for role in [
+            &resolver,
+            resolver.bootstrap.as_ref().unwrap(),
+            resolver.proxy_resolver.as_ref().unwrap(),
+            resolver.direct_resolver.as_ref().unwrap(),
+        ] {
+            assert!(role.cache.lock().await.is_empty());
+        }
+        assert!(resolver.domain_hint(new).await.is_none());
+    }
 
-        let mut tasks = Vec::with_capacity(CLIENTS);
-        for index in 0..CLIENTS {
-            let resolver = resolver.clone();
-            tasks.push(tokio::spawn(async move {
-                let id = 1_000 + index as u16;
-                let query = build_query(id, "burst.example", QueryType::A).unwrap();
-                (id, resolver.exchange(&query).await)
-            }));
+    #[tokio::test]
+    async fn dns_source_tcp_pool_separates_generation_and_binding_with_live_old_connections() {
+        struct Combined {
+            udp: Arc<MockDispatcher>,
+            tcp: Arc<ScriptedTcpDispatcher>,
         }
-        while resolver.resource_stats.snapshot().dns_current != CLIENTS
-            || resolver.singleflight.follower_count() != CLIENTS - 1
-        {
-            tokio::task::yield_now().await;
+        #[async_trait]
+        impl Dispatcher for Combined {
+            async fn connect_tcp(
+                &self,
+                session: StreamSession,
+            ) -> Result<BoxStream, DispatchError> {
+                self.tcp.connect_tcp(session).await
+            }
+            async fn open_datagram(
+                &self,
+                session: DatagramSession,
+            ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+                self.udp.open_datagram(session).await
+            }
         }
-        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 1);
-        release.notify_waiters();
-
-        for task in tasks {
-            let (id, result) = task.await.unwrap();
-            let response = parse_response(&result.unwrap()).unwrap();
-            assert_eq!(response.id, id);
-            assert_eq!(matching_answer_set(&response).unwrap().addresses, [address]);
+        let old: IpAddr = "203.0.113.10".parse().unwrap();
+        let new: IpAddr = "203.0.113.11".parse().unwrap();
+        let tcp = Arc::new(ScriptedTcpDispatcher::new(vec![
+            vec![
+                TcpScriptReply::Response(ResponseSpec::answer(old)),
+                TcpScriptReply::Response(ResponseSpec::answer(old)),
+            ],
+            vec![
+                TcpScriptReply::Response(ResponseSpec::answer(new)),
+                TcpScriptReply::Response(ResponseSpec::answer(new)),
+            ],
+            vec![TcpScriptReply::Response(ResponseSpec::answer(new))],
+        ]));
+        let udp = Arc::new(MockDispatcher::with_replies(
+            (0..3)
+                .map(|_| MockReply::Response(ResponseSpec::truncated()))
+                .collect(),
+            vec![],
+        ));
+        let configuration = crate::config::Config::parse_yaml(
+            b"mixed-port: 1080\ndns: {enable: true, nameserver: [system]}\n",
+        )
+        .unwrap();
+        let resolver = Arc::new(RuntimeDns::new(
+            &configuration.dns,
+            Arc::new(Combined {
+                udp,
+                tcp: tcp.clone(),
+            }),
+        ));
+        resolver.sources.register(&resolver);
+        for (generation, expected) in [(1, old), (2, new), (3, new)] {
+            let mut snapshot = dns_source_snapshot(generation, "203.0.113.53");
+            if generation == 3 {
+                snapshot.system[0].interface = "physical1".into();
+            }
+            resolver.sources.replace(snapshot).await.unwrap();
+            assert_eq!(
+                resolver
+                    .resolve(&format!("pool{generation}.example"))
+                    .await
+                    .unwrap(),
+                vec![expected]
+            );
+            assert_eq!(tcp.tcp_calls.load(Ordering::Acquire), generation as usize);
         }
-        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 1);
-        assert_eq!(resolver.singleflight.len(), 0);
-        let stats = resolver.resource_stats.snapshot();
-        assert_eq!(stats.dns_current, 0);
-        assert_eq!(stats.singleflight_current, 0);
-        assert_eq!(stats.singleflight_peak, 1);
-        assert_eq!(stats.singleflight_joins, CLIENTS as u64 - 1);
+        assert_eq!(resolver.tcp_pool.state.lock().await.idle.len(), 3);
     }
 
     #[tokio::test]
-    async fn opaque_queries_with_equal_semantics_share_one_upstream() {
+    async fn dns_source_and_literal_share_four_endpoint_attempts() {
         let release = Arc::new(Notify::new());
+        let address: IpAddr = "203.0.113.10".parse().unwrap();
         let dispatcher = Arc::new(MockDispatcher::with_replies(
-            vec![MockReply::Gated {
-                response: ResponseSpec::rcode(RCODE_NOERROR),
-                release: release.clone(),
-            }],
+            (0..4)
+                .map(|_| MockReply::Gated {
+                    response: ResponseSpec::answer(address),
+                    release: release.clone(),
+                })
+                .collect(),
             vec![],
         ));
-        let resolver = Arc::new(RuntimeDns::new(
-            &config(false, vec![nameserver(1, DnsTransport::Udp)]),
-            dispatcher.clone(),
-        ));
-
-        let first = {
-            let resolver = resolver.clone();
-            tokio::spawn(async move {
-                let query = opaque_query(601, "opaque-flight.example", 16);
-                resolver.exchange(&query).await
-            })
-        };
-        while dispatcher.udp_calls.load(Ordering::Acquire) != 1 {
-            tokio::task::yield_now().await;
+        let configuration = crate::config::Config::parse_yaml(b"mixed-port: 1080\ndns: {enable: true, nameserver: [1.1.1.1, system, system, system]}\n").unwrap();
+        let resolver = Arc::new(RuntimeDns::new(&configuration.dns, dispatcher.clone()));
+        let mut snapshot = dns_source_snapshot(1, "203.0.113.53");
+        for server in ["203.0.113.54", "203.0.113.55"] {
+            let mut entry = snapshot.system[0].clone();
+            entry.address = server.parse().unwrap();
+            snapshot.system.push(entry);
         }
-        let second = {
-            let resolver = resolver.clone();
-            tokio::spawn(async move {
-                let query = opaque_query(602, "opaque-flight.example", 16);
-                resolver.exchange(&query).await
-            })
-        };
-        while resolver.singleflight.follower_count() != 1 {
+        resolver.sources.replace(snapshot).await.unwrap();
+        let querying = resolver.clone();
+        let task = tokio::spawn(async move { querying.resolve("limited.example").await.unwrap() });
+        tokio::time::timeout(Duration::from_secs(1), async {
+            while dispatcher.udp_calls.load(Ordering::Acquire) < 4 {
+                tokio::task::yield_now().await;
+            }
+        })
+        .await
+        .unwrap();
+        for _ in 0..10 {
             tokio::task::yield_now().await;
         }
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 4);
         release.notify_waiters();
+        assert_eq!(task.await.unwrap(), vec![address]);
+    }
 
-        for (id, task) in [(601, first), (602, second)] {
-            let response = task.await.unwrap().unwrap();
-            assert_eq!(u16::from_be_bytes([response[0], response[1]]), id);
+    #[tokio::test]
+    async fn dns_source_unavailable_does_not_use_a_public_fallback() {
+        let configuration = crate::config::Config::parse_yaml(
+            b"mixed-port: 1080\ndns: {enable: true, nameserver: [system]}\n",
+        )
+        .unwrap();
+        let dispatcher = Arc::new(MockDispatcher::default());
+        let resolver = RuntimeDns::new(&configuration.dns, dispatcher.clone());
+        resolver
+            .sources
+            .replace(super::super::source::DnsNetworkUpdate {
+                generation: 1,
+                system: vec![],
+                dhcp: vec![],
+            })
+            .await
+            .unwrap();
+        assert!(resolver.resolve("unavailable.example").await.is_err());
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 0);
+    }
+
+    #[tokio::test]
+    async fn dns_rcode_preserves_query_flags_and_wire_without_network_or_result_caching() {
+        for rcode in 0..=5 {
+            let dispatcher = Arc::new(MockDispatcher::default());
+            let resolver = RuntimeDns::new(
+                &config(
+                    false,
+                    vec![
+                        nameserver(1, DnsTransport::Udp),
+                        nameserver(2, DnsTransport::Rcode(rcode)),
+                    ],
+                ),
+                dispatcher.clone(),
+            );
+            for query_type in [1, 16] {
+                for flags in [0x0100_u16, 0x0180, 0x0010] {
+                    for id in [800, 801] {
+                        let mut query = opaque_query(id, "local.example", query_type);
+                        query[2..4].copy_from_slice(&flags.to_be_bytes());
+                        // Preserve a legal empty EDNS OPT record as well.
+                        query[10..12].copy_from_slice(&1_u16.to_be_bytes());
+                        query.extend_from_slice(&[0, 0, 41, 16, 0, 0, 0, 0, 0, 0, 0]);
+                        let mut expected = query.clone();
+                        expected[2..4].copy_from_slice(
+                            &(flags | DNS_FLAG_RESPONSE | u16::from(rcode)).to_be_bytes(),
+                        );
+                        assert_eq!(resolver.exchange(&query).await.unwrap(), expected);
+                    }
+                }
+            }
+            assert!(resolver.cache.lock().await.is_empty());
+            assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 0);
+            assert_eq!(dispatcher.tcp_calls.load(Ordering::Acquire), 0);
         }
-        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 1);
-        assert_eq!(resolver.singleflight.len(), 0);
     }
 
     #[tokio::test]
-    async fn singleflight_key_keeps_distinct_wire_semantics_separate() {
-        let release = Arc::new(Notify::new());
+    async fn dns_rcode_policy_runs_after_fake_ip_allocation_and_flush_preserves_mapping() {
+        let config = crate::config::Config::parse_yaml(b"mixed-port: 1080\ndns:\n  enable: true\n  enhanced-mode: fake-ip\n  fake-ip-filter: [real.example]\n  nameserver: [rcode://success]\n  nameserver-policy:\n    '+.example': rcode://refused\n").unwrap();
+        let dispatcher = Arc::new(MockDispatcher::default());
+        let resolver = RuntimeDns::new(&config.dns, dispatcher.clone());
+        let fake_query = build_query(810, "fake.example", QueryType::A).unwrap();
+        let fake = parse_response(&resolver.exchange(&fake_query).await.unwrap()).unwrap();
+        let RecordData::A(address) = fake.answers[0].data else {
+            panic!("fake A answer")
+        };
+        assert_eq!(fake.rcode, 0);
+        let real_query = build_query(811, "real.example", QueryType::A).unwrap();
+        let real = parse_response(&resolver.exchange(&real_query).await.unwrap()).unwrap();
+        assert_eq!(real.rcode, RCODE_REFUSED);
+        assert!(!real.recursion_available);
+        resolver.flush_cache().await;
+        assert_eq!(
+            resolver.recover_fake_ip(address.into()).unwrap().as_deref(),
+            Some("fake.example")
+        );
+        let after = parse_response(&resolver.exchange(&fake_query).await.unwrap()).unwrap();
+        assert_eq!(after.answers[0].data, RecordData::A(address));
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 0);
+    }
+
+    #[tokio::test]
+    async fn dns_flush_clears_typed_wire_and_hints_in_every_role() {
+        let old = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 110));
+        let new = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 111));
         let dispatcher = Arc::new(MockDispatcher::with_replies(
-            vec![
-                MockReply::Gated {
-                    response: ResponseSpec::rcode(RCODE_NOERROR),
-                    release: release.clone(),
-                },
-                MockReply::Gated {
-                    response: ResponseSpec::rcode(RCODE_NOERROR),
-                    release: release.clone(),
-                },
-            ],
+            [old, new]
+                .into_iter()
+                .flat_map(|address| {
+                    (0..8).map(move |_| MockReply::Response(ResponseSpec::answer(address)))
+                })
+                .collect(),
             vec![],
         ));
-        let resolver = Arc::new(RuntimeDns::new(
-            &config(false, vec![nameserver(1, DnsTransport::Udp)]),
-            dispatcher.clone(),
-        ));
-
-        let first = {
-            let resolver = resolver.clone();
-            tokio::spawn(async move {
-                let query = opaque_query(610, "semantic.example", 16);
-                resolver.exchange(&query).await
-            })
-        };
-        let second = {
-            let resolver = resolver.clone();
-            tokio::spawn(async move {
-                let mut query = opaque_query(611, "semantic.example", 16);
-                query[2..4].copy_from_slice(&0_u16.to_be_bytes());
-                resolver.exchange(&query).await
-            })
-        };
-        while dispatcher.udp_calls.load(Ordering::Acquire) != 2 {
-            tokio::task::yield_now().await;
+        let mut configuration = config(false, vec![nameserver(1, DnsTransport::Udp)]);
+        configuration.default_nameservers = configuration.nameservers.clone();
+        configuration.proxy_nameservers = configuration.nameservers.clone();
+        configuration.direct_nameservers = configuration.nameservers.clone();
+        let resolver = RuntimeDns::new(&configuration, dispatcher.clone());
+        let roles = [
+            &resolver,
+            resolver.bootstrap.as_deref().unwrap(),
+            resolver.proxy_resolver.as_deref().unwrap(),
+            resolver.direct_resolver.as_deref().unwrap(),
+        ];
+        for (round, address) in [old, new].into_iter().enumerate() {
+            for role in roles {
+                for query_type in [1, 16] {
+                    let query = opaque_query(820, "clear.example", query_type);
+                    assert_eq!(
+                        role.exchange(&query).await.unwrap(),
+                        response_for_query(&query, &ResponseSpec::answer(address))
+                    );
+                    // Both result classes are retained without another query.
+                    role.exchange(&query).await.unwrap();
+                }
+            }
+            assert_eq!(
+                dispatcher.udp_calls.load(Ordering::Acquire),
+                (round + 1) * 8
+            );
+            assert_eq!(
+                resolver.domain_hint(address).await.as_deref(),
+                Some("clear.example")
+            );
+            resolver.flush_cache().await;
+            for role in roles {
+                assert!(role.cache.lock().await.is_empty());
+            }
+            assert!(resolver.domain_hint(address).await.is_none());
         }
-        assert_eq!(resolver.singleflight.len(), 2);
-        release.notify_waiters();
+    }
 
-        assert_eq!(
-            u16::from_be_bytes(first.await.unwrap().unwrap()[..2].try_into().unwrap()),
-            610
-        );
-        assert_eq!(
-            u16::from_be_bytes(second.await.unwrap().unwrap()[..2].try_into().unwrap()),
-            611
-        );
-        assert_eq!(resolver.singleflight.len(), 0);
-        assert_eq!(resolver.resource_stats.snapshot().singleflight_peak, 2);
+    #[tokio::test]
+    async fn dns_flush_separates_old_flights_and_blocks_typed_wire_and_hint_refill() {
+        for role_index in 0..4 {
+            for query_type in [1, 16] {
+                let release = Arc::new(Notify::new());
+                let old = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 112));
+                let new = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 113));
+                let dispatcher = Arc::new(MockDispatcher::with_replies(
+                    vec![
+                        MockReply::Gated {
+                            response: ResponseSpec::answer(old),
+                            release: release.clone(),
+                        },
+                        MockReply::Response(ResponseSpec::answer(new)),
+                    ],
+                    vec![],
+                ));
+                let mut configuration = config(false, vec![nameserver(1, DnsTransport::Udp)]);
+                configuration.default_nameservers = configuration.nameservers.clone();
+                configuration.proxy_nameservers = configuration.nameservers.clone();
+                configuration.direct_nameservers = configuration.nameservers.clone();
+                let root = Arc::new(RuntimeDns::new(&configuration, dispatcher.clone()));
+                let role = match role_index {
+                    0 => root.clone(),
+                    1 => root.bootstrap.as_ref().unwrap().clone(),
+                    2 => root.proxy_resolver.as_ref().unwrap().clone(),
+                    _ => root.direct_resolver.as_ref().unwrap().clone(),
+                };
+                let query = opaque_query(830, "pending.example", query_type);
+                let old_query = query.clone();
+                let old_role = role.clone();
+                let leader =
+                    tokio::spawn(async move { old_role.exchange(&old_query).await.unwrap() });
+                tokio::time::timeout(Duration::from_secs(1), async {
+                    while dispatcher.udp_calls.load(Ordering::Acquire) != 1 {
+                        tokio::task::yield_now().await;
+                    }
+                })
+                .await
+                .unwrap();
+                let mut follower_query = query.clone();
+                restore_response_id(&mut follower_query, 831);
+                let old_follower_query = follower_query.clone();
+                let old_role = role.clone();
+                let follower =
+                    tokio::spawn(
+                        async move { old_role.exchange(&old_follower_query).await.unwrap() },
+                    );
+                tokio::time::timeout(Duration::from_secs(1), async {
+                    while role.singleflight.follower_count() != 1 {
+                        tokio::task::yield_now().await;
+                    }
+                })
+                .await
+                .unwrap();
+                root.flush_cache().await;
+                let fresh = role.exchange(&query).await.unwrap();
+                assert_eq!(
+                    fresh,
+                    response_for_query(&query, &ResponseSpec::answer(new))
+                );
+                assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 2);
+                release.notify_one();
+                assert_eq!(
+                    leader.await.unwrap(),
+                    response_for_query(&query, &ResponseSpec::answer(old))
+                );
+                assert_eq!(
+                    follower.await.unwrap(),
+                    response_for_query(&follower_query, &ResponseSpec::answer(old))
+                );
+                let mut cached = role.exchange(&query).await.unwrap();
+                let ttl_offset = cached.len() - 10;
+                let ttl =
+                    u32::from_be_bytes(cached[ttl_offset..ttl_offset + 4].try_into().unwrap());
+                assert!((1..=60).contains(&ttl));
+                // Cache replay decrements TTL while retaining the fresh result.
+                cached[ttl_offset..ttl_offset + 4].copy_from_slice(&60_u32.to_be_bytes());
+                assert_eq!(cached, fresh);
+                assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 2);
+                assert!(root.domain_hint(old).await.is_none());
+                assert_eq!(role.singleflight.len(), 0);
+            }
+        }
     }
 
     #[tokio::test]
-    async fn cancelled_leader_wakes_follower_to_reselect_without_leaking_registry_entry() {
-        let release = Arc::new(Notify::new());
-        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 101));
+    async fn dns_flush_holds_one_admission_boundary_until_every_role_is_cleared() {
+        let old = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 116));
+        let new = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 117));
         let dispatcher = Arc::new(MockDispatcher::with_replies(
             vec![
-                MockReply::Gated {
-                    response: ResponseSpec::answer(address),
-                    release,
-                },
-                MockReply::Response(ResponseSpec::answer(address)),
+                MockReply::Response(ResponseSpec::answer(old)),
+                MockReply::Response(ResponseSpec::answer(new)),
             ],
             vec![],
         ));
@@ -4383,110 +8376,152 @@ mod tests {
             &config(false, vec![nameserver(1, DnsTransport::Udp)]),
             dispatcher.clone(),
         ));
-
-        let leader = {
-            let resolver = resolver.clone();
-            tokio::spawn(async move {
-                let query = build_query(620, "cancel.example", QueryType::A).unwrap();
-                resolver.exchange(&query).await
-            })
-        };
-        while dispatcher.udp_calls.load(Ordering::Acquire) != 1 {
-            tokio::task::yield_now().await;
-        }
-        let follower = {
-            let resolver = resolver.clone();
-            tokio::spawn(async move {
-                let query = build_query(621, "cancel.example", QueryType::A).unwrap();
-                resolver.exchange(&query).await
-            })
-        };
-        while resolver.singleflight.follower_count() != 1 {
-            tokio::task::yield_now().await;
-        }
-
-        leader.abort();
-        let _ = leader.await;
-        let response = tokio::time::timeout(Duration::from_secs(1), follower)
-            .await
-            .expect("follower must re-elect before its query deadline")
-            .unwrap()
-            .unwrap();
-        assert_eq!(parse_response(&response).unwrap().id, 621);
-        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 2);
-        assert_eq!(resolver.singleflight.len(), 0);
-        assert_eq!(resolver.resource_stats.snapshot().singleflight_current, 0);
+        assert_eq!(
+            resolver.resolve("barrier.example").await.unwrap(),
+            vec![old]
+        );
+        let bootstrap_cache = resolver.bootstrap.as_ref().unwrap().cache.lock().await;
+        let flushing = resolver.clone();
+        let flush = tokio::spawn(async move { flushing.flush_cache().await });
+        tokio::time::timeout(Duration::from_secs(1), async {
+            while resolver.cache_epoch.try_read().is_ok() {
+                tokio::task::yield_now().await;
+            }
+        })
+        .await
+        .unwrap();
+        let querying = resolver.clone();
+        let query = tokio::spawn(async move { querying.resolve("barrier.example").await.unwrap() });
+        tokio::time::timeout(Duration::from_secs(1), async {
+            while resolver.resource_stats.snapshot().dns_current == 0 {
+                tokio::task::yield_now().await;
+            }
+        })
+        .await
+        .unwrap();
+        assert!(!query.is_finished());
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 1);
+        drop(bootstrap_cache);
+        flush.await.unwrap();
+        assert_eq!(query.await.unwrap(), vec![new]);
     }
 
     #[tokio::test]
-    async fn shared_upstream_failure_is_mapped_by_each_callers_failure_mode() {
+    async fn dns_flush_blocks_old_resource_generation_from_refilling_shared_hints() {
         let release = Arc::new(Notify::new());
+        let old = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 114));
+        let new = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 115));
         let dispatcher = Arc::new(MockDispatcher::with_replies(
-            vec![MockReply::GatedTransportError {
-                release: release.clone(),
-            }],
+            vec![
+                MockReply::Gated {
+                    response: ResponseSpec::answer(old),
+                    release: release.clone(),
+                },
+                MockReply::Response(ResponseSpec::answer(new)),
+            ],
             vec![],
         ));
-        let resolver = Arc::new(RuntimeDns::new(
-            &config(false, vec![nameserver(1, DnsTransport::Udp)]),
-            dispatcher.clone(),
-        ));
-
-        let wire_caller = {
-            let resolver = resolver.clone();
-            tokio::spawn(async move {
-                let query = build_query(630, "failure.example", QueryType::A).unwrap();
-                resolver.exchange(&query).await
-            })
-        };
-        while dispatcher.udp_calls.load(Ordering::Acquire) != 1 {
-            tokio::task::yield_now().await;
-        }
-        let bounded_caller = {
-            let resolver = resolver.clone();
-            tokio::spawn(async move { resolver.resolve("failure.example").await })
-        };
-        while resolver.singleflight.follower_count() != 1 {
-            tokio::task::yield_now().await;
+        let mut configuration = config(false, vec![nameserver(1, DnsTransport::Udp)]);
+        configuration.proxy_nameservers = configuration.nameservers.clone();
+        configuration.direct_nameservers = configuration.nameservers.clone();
+        let previous = Arc::new(RuntimeDns::new(&configuration, dispatcher.clone()));
+        let query = build_query(840, "generation.example", QueryType::A).unwrap();
+        let old_query = query.clone();
+        let old_role = previous.clone();
+        let leader = tokio::spawn(async move { old_role.exchange(&old_query).await.unwrap() });
+        tokio::time::timeout(Duration::from_secs(1), async {
+            while dispatcher.udp_calls.load(Ordering::Acquire) != 1 {
+                tokio::task::yield_now().await;
+            }
+        })
+        .await
+        .unwrap();
+        let current =
+            RuntimeDns::new(&configuration, dispatcher.clone()).with_mapping_from(Some(&previous));
+        for role in [
+            current.bootstrap.as_deref().unwrap(),
+            current.proxy_resolver.as_deref().unwrap(),
+            current.direct_resolver.as_deref().unwrap(),
+        ] {
+            assert!(Arc::ptr_eq(&current.cache_epoch, &role.cache_epoch));
         }
-        release.notify_waiters();
-
-        let wire = wire_caller.await.unwrap().unwrap();
-        assert_eq!(parse_response(&wire).unwrap().rcode, RCODE_SERVFAIL);
-        assert!(matches!(
-            bounded_caller.await.unwrap(),
-            Err(RuntimeDnsError::UpstreamsExhausted { .. })
-        ));
-        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 1);
-        assert_eq!(resolver.singleflight.len(), 0);
+        current.flush_cache().await;
+        release.notify_one();
+        leader.await.unwrap();
+        assert!(current.domain_hint(old).await.is_none());
+        assert!(previous.cache.lock().await.is_empty());
+        assert_eq!(
+            current.resolve("generation.example").await.unwrap(),
+            vec![new]
+        );
+        assert_eq!(
+            current.domain_hint(new).await.as_deref(),
+            Some("generation.example")
+        );
     }
 
     #[tokio::test]
-    async fn cache_hit_does_not_create_another_singleflight_entry() {
-        let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 102));
+    async fn configuration_publication_stops_late_old_tree_hint_refill() {
+        let old = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 120));
+        let late = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 121));
+        let new = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 122));
         let dispatcher = Arc::new(MockDispatcher::with_replies(
-            vec![MockReply::Response(ResponseSpec::answer(address))],
+            vec![
+                MockReply::Response(ResponseSpec::answer(old)),
+                MockReply::Response(ResponseSpec::answer(late)),
+                MockReply::Response(ResponseSpec::answer(new)),
+            ],
             vec![],
         ));
-        let resolver = RuntimeDns::new(
-            &config(false, vec![nameserver(1, DnsTransport::Udp)]),
-            dispatcher.clone(),
+        let configuration = config(false, vec![nameserver(1, DnsTransport::Udp)]);
+        let previous = RuntimeDns::new(&configuration, dispatcher.clone());
+        previous.resolve("old.example").await.unwrap();
+        let current =
+            RuntimeDns::new(&configuration, dispatcher).with_mapping_from(Some(&previous));
+        {
+            let _publication = current.configuration_publication().await;
+            previous.retire_configuration_hints();
+        }
+        assert!(current.domain_hint(old).await.is_none());
+        // This query starts after the boundary and therefore sees the new
+        // epoch. The retired policy still must not write the active hint map.
+        assert_eq!(previous.resolve("late.example").await.unwrap(), vec![late]);
+        assert!(current.domain_hint(late).await.is_none());
+        assert_eq!(current.resolve("new.example").await.unwrap(), vec![new]);
+        assert_eq!(
+            current.domain_hint(new).await.as_deref(),
+            Some("new.example")
         );
-        for id in [640, 641] {
-            let query = build_query(id, "cache-flight.example", QueryType::A).unwrap();
-            assert_eq!(
-                parse_response(&resolver.exchange(&query).await.unwrap())
-                    .unwrap()
-                    .id,
-                id
-            );
+    }
+
+    #[tokio::test]
+    async fn dns_cache_arc_configuration_changes_actual_upstream_reuse() {
+        for (algorithm, expected_calls) in [
+            (crate::config::DnsCacheAlgorithm::Lru, 4),
+            (crate::config::DnsCacheAlgorithm::Arc, 3),
+        ] {
+            let address = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 104));
+            let dispatcher = Arc::new(MockDispatcher::with_replies(
+                (0..expected_calls)
+                    .map(|_| MockReply::Response(ResponseSpec::answer(address)))
+                    .collect(),
+                vec![],
+            ));
+            let mut configuration = config(false, vec![nameserver(1, DnsTransport::Udp)]);
+            configuration.cache_max_size = 2;
+            configuration.cache_algorithm = algorithm;
+            let resolver = RuntimeDns::new(&configuration, dispatcher.clone());
+            for name in [
+                "a.example",
+                "a.example",
+                "b.example",
+                "c.example",
+                "a.example",
+            ] {
+                assert_eq!(resolver.resolve(name).await.unwrap(), vec![address]);
+            }
+            assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), expected_calls);
         }
-        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 1);
-        assert_eq!(resolver.singleflight.len(), 0);
-        let stats = resolver.resource_stats.snapshot();
-        assert_eq!(stats.singleflight_peak, 1);
-        assert_eq!(stats.singleflight_current, 0);
-        assert_eq!(stats.dns_cache_hits, 1);
     }
 
     #[tokio::test]
@@ -4552,6 +8587,7 @@ mod tests {
             Arc::new(EmptyGeoMatcher),
             MAX_CACHE_ENTRIES,
             MAX_REDIR_HOST_ENTRIES,
+            crate::security::SecurityContext::new(),
         ));
         let observed_at = TokioInstant::now();
         let permit = resolver.begin_query();
@@ -4581,6 +8617,7 @@ mod tests {
             Arc::new(EmptyGeoMatcher),
             MAX_CACHE_ENTRIES,
             MAX_REDIR_HOST_ENTRIES,
+            crate::security::SecurityContext::new(),
         ));
         let query = build_query(92, "retained.example", QueryType::A).unwrap();
 
@@ -4591,4 +8628,338 @@ mod tests {
         drop(response);
         assert_eq!(resolver.resource_stats.snapshot().dns_current, 0);
     }
+    fn fake_ip_replacement_yaml(enabled: bool) -> String {
+        format!(
+            "ipv6: true\nprofile: {{store-fake-ip: false}}\ndns:\n  enable: {enabled}\n  ipv6: true\n  enhanced-mode: fake-ip\n  fake-ip-range: 198.18.0.1/24\n  fake-ip-range6: fd00:1::1/120\n  use-hosts: false\n  use-system-hosts: false\n  nameserver: [192.0.2.1]\n"
+        )
+    }
+
+    async fn fake_ip_replacement_answers(
+        resolver: &RuntimeDns,
+        host: &str,
+        query_type: QueryType,
+    ) -> Vec<IpAddr> {
+        let response = resolver
+            .exchange(&build_query(904, host, query_type).unwrap())
+            .await
+            .unwrap();
+        let response = parse_response(&response).unwrap();
+        assert_eq!(response.id, 904);
+        matching_answer_set(&response).unwrap().addresses
+    }
+
+    #[tokio::test]
+    async fn configuration_replacement_retains_new_fake_ip_pool_and_existing_mappings() {
+        let before = [
+            (QueryType::A, "198.18.0.4".parse::<IpAddr>().unwrap()),
+            (QueryType::Aaaa, "fd00:1::4".parse().unwrap()),
+        ];
+        for (old_enabled, new_enabled) in
+            [(false, true), (true, true), (false, false), (true, false)]
+        {
+            let old_config =
+                crate::config::Config::parse_yaml(fake_ip_replacement_yaml(old_enabled).as_bytes())
+                    .unwrap();
+            let new_config =
+                crate::config::Config::parse_yaml(fake_ip_replacement_yaml(new_enabled).as_bytes())
+                    .unwrap();
+            assert!(crate::config::live_update::startup_compatible(
+                &old_config,
+                &new_config
+            ));
+            // Real upstream replies make the old None-overwrite fail on the
+            // actual wire answer rather than an exhausted mock response list.
+            let dispatcher = Arc::new(MockDispatcher::with_replies(
+                vec![
+                    MockReply::Response(ResponseSpec::answer("203.0.113.7".parse().unwrap())),
+                    MockReply::Response(ResponseSpec::answer("2001:db8::7".parse().unwrap())),
+                ],
+                vec![],
+            ));
+            let previous = RuntimeDns::new(&old_config.dns, dispatcher.clone());
+            if old_enabled {
+                for (query_type, address) in before {
+                    assert_eq!(
+                        fake_ip_replacement_answers(&previous, "before.example", query_type).await,
+                        [address]
+                    );
+                }
+            }
+            let replacement = RuntimeDns::new(&new_config.dns, dispatcher.clone());
+            let newly_allocated = replacement.fake_pools.clone();
+            let current = replacement.with_mapping_from(Some(&previous));
+            if new_enabled {
+                let after = if old_enabled {
+                    ["198.18.0.5", "fd00:1::5"]
+                } else {
+                    ["198.18.0.4", "fd00:1::4"]
+                };
+                for ((query_type, _), address) in before.into_iter().zip(after) {
+                    assert_eq!(
+                        fake_ip_replacement_answers(&current, "after.example", query_type).await,
+                        [address.parse::<IpAddr>().unwrap()],
+                        "DNS enable transition {old_enabled} -> {new_enabled}"
+                    );
+                }
+            } else {
+                let query = build_query(905, "after.example", QueryType::A).unwrap();
+                assert!(matches!(
+                    current.exchange(&query).await,
+                    Err(RuntimeDnsError::Disabled)
+                ));
+            }
+            if let Some(expected) = previous.fake_pools.as_ref().or(newly_allocated.as_ref()) {
+                assert!(
+                    current
+                        .fake_pools
+                        .as_ref()
+                        .is_some_and(|pool| Arc::ptr_eq(pool, expected))
+                );
+            } else {
+                assert!(current.fake_pools.is_none());
+            }
+            if old_enabled {
+                for (_, address) in before {
+                    assert_eq!(
+                        current.recover_fake_ip(address).unwrap().as_deref(),
+                        Some("before.example")
+                    );
+                }
+            }
+            assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 0);
+        }
+    }
+
+    #[tokio::test]
+    async fn configuration_replacement_keeps_incompatible_fake_ip_pools_separate() {
+        let yaml = fake_ip_replacement_yaml(true);
+        let old_config = crate::config::Config::parse_yaml(yaml.as_bytes()).unwrap();
+        let before = [
+            (QueryType::A, "198.18.0.4".parse::<IpAddr>().unwrap()),
+            (QueryType::Aaaa, "fd00:1::4".parse().unwrap()),
+        ];
+        for (old, new, expected_v4, expected_v6) in [
+            (
+                "enhanced-mode: fake-ip",
+                "enhanced-mode: redir-host",
+                "203.0.113.7",
+                Some("2001:db8::7"),
+            ),
+            (
+                "fake-ip-range: 198.18.0.1/24",
+                "fake-ip-range: 198.19.0.1/24",
+                "198.19.0.4",
+                Some("fd00:1::4"),
+            ),
+            (
+                "fake-ip-range6: fd00:1::1/120",
+                "fake-ip-range6: fd00:2::1/120",
+                "198.18.0.4",
+                Some("fd00:2::4"),
+            ),
+            ("  ipv6: true", "  ipv6: false", "198.18.0.4", None),
+        ] {
+            let configuration =
+                crate::config::Config::parse_yaml(yaml.replace(old, new).as_bytes()).unwrap();
+            assert!(!crate::config::live_update::startup_compatible(
+                &old_config,
+                &configuration
+            ));
+            let dispatcher = Arc::new(MockDispatcher::with_replies(
+                vec![
+                    MockReply::Response(ResponseSpec::answer("203.0.113.7".parse().unwrap())),
+                    MockReply::Response(ResponseSpec::answer("2001:db8::7".parse().unwrap())),
+                ],
+                vec![],
+            ));
+            let previous = RuntimeDns::new(&old_config.dns, dispatcher.clone());
+            for (query_type, address) in before {
+                assert_eq!(
+                    fake_ip_replacement_answers(&previous, "before.example", query_type).await,
+                    [address]
+                );
+            }
+            let replacement = RuntimeDns::new(&configuration.dns, dispatcher.clone());
+            let newly_allocated = replacement.fake_pools.clone();
+            let current = replacement.with_mapping_from(Some(&previous));
+            assert_eq!(
+                fake_ip_replacement_answers(&current, "after.example", QueryType::A).await,
+                [expected_v4.parse::<IpAddr>().unwrap()]
+            );
+            assert_eq!(
+                fake_ip_replacement_answers(&current, "after.example", QueryType::Aaaa).await,
+                expected_v6
+                    .map(|ip| ip.parse::<IpAddr>().unwrap())
+                    .into_iter()
+                    .collect::<Vec<_>>()
+            );
+            if let Some(expected) = newly_allocated {
+                let current_pool = current.fake_pools.as_ref().unwrap();
+                assert!(Arc::ptr_eq(current_pool, &expected));
+                assert!(!Arc::ptr_eq(
+                    current_pool,
+                    previous.fake_pools.as_ref().unwrap()
+                ));
+            } else {
+                assert!(current.fake_pools.is_none());
+            }
+            for (_, address) in before {
+                assert_eq!(
+                    previous.recover_fake_ip(address).unwrap().as_deref(),
+                    Some("before.example")
+                );
+            }
+            assert_eq!(
+                dispatcher.udp_calls.load(Ordering::Acquire),
+                if configuration.dns.fake_ip.enabled {
+                    0
+                } else {
+                    2
+                }
+            );
+        }
+    }
+
+    #[tokio::test]
+    async fn fake_ip_answers_recover_names_and_keep_internal_resolution_real() {
+        let config = crate::config::Config::parse_yaml(
+            br#"
+mixed-port: 1080
+hosts:
+  alias.example: synthetic.example
+  fixed.example: 192.0.2.9
+dns:
+  enable: true
+  enhanced-mode: fake-ip
+  fake-ip-filter: [real.example]
+  fake-ip-ttl: 0
+  nameserver: [192.0.2.1]
+  use-system-hosts: false
+"#,
+        )
+        .unwrap();
+        let real: IpAddr = "203.0.113.7".parse().unwrap();
+        let dispatcher = Arc::new(MockDispatcher::with_replies(
+            vec![
+                MockReply::Response(ResponseSpec::answer(real)),
+                MockReply::Response(ResponseSpec::answer(real)),
+                MockReply::Response(ResponseSpec::answer(real)),
+            ],
+            vec![],
+        ));
+        let resolver = RuntimeDns::new(&config.dns, dispatcher.clone());
+        for name in ["synthetic.example", "alias.example"] {
+            let wire = resolver
+                .exchange(&build_query(10, name, QueryType::A).unwrap())
+                .await
+                .unwrap();
+            let answer = parse_response(&wire).unwrap();
+            assert!(answer.authoritative);
+            assert!(answer.answers.iter().all(|record| record.ttl == 1));
+            let address = matching_answer_set(&answer).unwrap().addresses[0];
+            assert_eq!(address, "198.18.0.4".parse::<IpAddr>().unwrap());
+            assert_eq!(
+                resolver.recover_fake_ip(address).unwrap().as_deref(),
+                Some("synthetic.example")
+            );
+        }
+        assert_eq!(dispatcher.udp_calls.load(Ordering::Acquire), 0);
+        assert_eq!(resolver.resolve("synthetic.example").await.unwrap(), [real]);
+        for name in ["synthetic.example", "fixed.example"] {
+            let wire = resolver
+                .query_upstream(&build_query(10, name, QueryType::A).unwrap())
+                .await
+                .unwrap();
+            assert_eq!(
+                matching_answer_set(&parse_response(&wire).unwrap())
+                    .unwrap()
+                    .addresses,
+                [real]
+            );
+        }
+        let wire = resolver
+            .exchange(&build_query(11, "real.example", QueryType::A).unwrap())
+            .await
+            .unwrap();
+        assert_eq!(
+            matching_answer_set(&parse_response(&wire).unwrap())
+                .unwrap()
+                .addresses,
+            [real]
+        );
+        let updated = RuntimeDns::new(&config.dns, dispatcher).with_mapping_from(Some(&resolver));
+        assert_eq!(
+            updated
+                .recover_fake_ip("198.18.0.4".parse().unwrap())
+                .unwrap()
+                .as_deref(),
+            Some("synthetic.example")
+        );
+        assert!(
+            updated
+                .recover_fake_ip("198.18.0.9".parse().unwrap())
+                .is_err()
+        );
+    }
+    #[tokio::test]
+    async fn dns_fallback_obeys_policy_domains_and_answer_filters() {
+        let config = crate::config::Config::parse_yaml(
+            br#"
+mixed-port: 1080
+dns:
+  enable: true
+  use-system-hosts: false
+  nameserver: [192.0.2.1]
+  fallback: [192.0.2.2]
+  fallback-lazy-query: true
+  fallback-filter:
+    geoip: false
+    ipcidr: [203.0.113.0/24]
+    domain: ['+.fallback.example']
+  nameserver-policy:
+    policy.fallback.example: 192.0.2.3
+"#,
+        )
+        .unwrap();
+        let filtered: IpAddr = "203.0.113.10".parse().unwrap();
+        let accepted: IpAddr = "192.0.2.30".parse().unwrap();
+        for (host, answers, endpoints, expected) in [
+            (
+                "ordinary.example",
+                vec![filtered, accepted],
+                vec![1, 2],
+                accepted,
+            ),
+            ("only.fallback.example", vec![accepted], vec![2], accepted),
+            ("policy.fallback.example", vec![filtered], vec![3], filtered),
+            ("accepted.example", vec![accepted], vec![1], accepted),
+        ] {
+            let dispatcher = Arc::new(MockDispatcher::with_replies(
+                answers
+                    .into_iter()
+                    .map(|ip| MockReply::Response(ResponseSpec::answer(ip)))
+                    .collect(),
+                vec![],
+            ));
+            let resolver = RuntimeDns::new(&config.dns, dispatcher.clone());
+            assert_eq!(resolver.resolve(host).await.unwrap(), [expected]);
+            assert_eq!(
+                *dispatcher.udp_destinations.lock().unwrap(),
+                endpoints
+                    .into_iter()
+                    .map(|last| Destination::Ip(SocketAddr::from(([192, 0, 2, last], 53))))
+                    .collect::<Vec<_>>()
+            );
+        }
+        // Empty successful answers also trigger fallback.
+        let dispatcher = Arc::new(MockDispatcher::with_replies(
+            vec![
+                MockReply::Response(ResponseSpec::rcode(RCODE_NXDOMAIN)),
+                MockReply::Response(ResponseSpec::answer(accepted)),
+            ],
+            vec![],
+        ));
+        let resolver = RuntimeDns::new(&config.dns, dispatcher);
+        assert_eq!(resolver.resolve("empty.example").await.unwrap(), [accepted]);
+    }
 }
diff --git a/src/dns/source.rs b/src/dns/source.rs
new file mode 100644
index 0000000..3bfe762
--- /dev/null
+++ b/src/dns/source.rs
@@ -0,0 +1,614 @@
+//! Explicit physical DNS metadata. This module never configures a network.
+use std::{
+    collections::HashMap,
+    io,
+    net::{IpAddr, SocketAddr, SocketAddrV6},
+    sync::{Arc, Mutex as StdMutex, Weak},
+    time::{Duration, Instant},
+};
+
+use serde::{Deserialize, Serialize};
+use tokio::sync::{Mutex, RwLock};
+
+use crate::{config::DnsSource, dialer::Dialer};
+
+#[cfg(target_os = "linux")]
+mod linux;
+#[cfg(all(windows, feature = "windows-uwp"))]
+pub(crate) mod windows;
+
+pub(crate) const MAX_METADATA_BYTES: usize = 64 * 1024;
+const DISCOVERY_TTL: Duration = Duration::from_secs(20);
+
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub(crate) struct DnsServerAddress {
+    pub address: IpAddr,
+    #[serde(default)]
+    pub scope_id: u32,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub(crate) struct SystemDnsServer {
+    pub address: IpAddr,
+    pub interface: String,
+    #[serde(default)]
+    pub scope_id: u32,
+    #[serde(default)]
+    pub requires_encryption: bool,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub(crate) struct DhcpDnsInterface {
+    pub interface: String,
+    pub servers: Vec<DnsServerAddress>,
+    #[serde(default)]
+    pub requires_encryption: bool,
+}
+
+/// Host-supplied network data, separate from the Mihomo YAML schema.
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub(crate) struct DnsNetworkUpdate {
+    pub generation: u64,
+    pub system: Vec<SystemDnsServer>,
+    pub dhcp: Vec<DhcpDnsInterface>,
+}
+
+impl DnsNetworkUpdate {
+    pub(crate) fn validate(&self) -> io::Result<()> {
+        check_metadata_size(self)?;
+        if self.generation == 0 {
+            return Err(invalid("DNS network generation must be positive"));
+        }
+        let mut interfaces = std::collections::HashSet::new();
+        for server in &self.system {
+            validate_interface(&server.interface)?;
+            endpoint(server.address, server.scope_id)?;
+        }
+        for lease in &self.dhcp {
+            validate_interface(&lease.interface)?;
+            if !interfaces.insert(&lease.interface) {
+                return Err(invalid("duplicate DHCP DNS interface"));
+            }
+            for server in &lease.servers {
+                endpoint(server.address, server.scope_id)?;
+            }
+        }
+        Ok(())
+    }
+}
+
+pub(crate) fn check_metadata_size(value: &impl Serialize) -> io::Result<()> {
+    struct Size(usize);
+    impl io::Write for Size {
+        fn write(&mut self, bytes: &[u8]) -> io::Result<usize> {
+            self.0 = self
+                .0
+                .checked_add(bytes.len())
+                .filter(|size| *size <= MAX_METADATA_BYTES)
+                .ok_or_else(|| invalid("DNS network metadata exceeds 64 KiB"))?;
+            Ok(bytes.len())
+        }
+        fn flush(&mut self) -> io::Result<()> {
+            Ok(())
+        }
+    }
+    serde_json::to_writer(Size(0), value)
+        .map_err(|_| invalid("DNS network metadata exceeds 64 KiB"))
+}
+
+pub(crate) fn validate_interface(name: &str) -> io::Result<()> {
+    if name.is_empty()
+        || name.len() > 256
+        || name.chars().any(char::is_control)
+        || name.trim() != name
+        || name.contains(['/', '\\'])
+    {
+        return Err(invalid("invalid DNS source interface"));
+    }
+    Ok(())
+}
+
+fn invalid(message: &'static str) -> io::Error {
+    io::Error::new(io::ErrorKind::InvalidInput, message)
+}
+pub(super) fn unavailable() -> io::Error {
+    io::Error::new(
+        io::ErrorKind::NotFound,
+        "physical DNS source is unavailable",
+    )
+}
+
+fn endpoint(ip: IpAddr, scope: u32) -> io::Result<SocketAddr> {
+    let ip = ip.to_canonical();
+    if ip.is_unspecified() || ip.is_multicast() || ip.is_loopback() {
+        return Err(invalid("DNS source must be a physical unicast address"));
+    }
+    match ip {
+        IpAddr::V4(_) if scope != 0 => Err(invalid("IPv4 DNS source cannot have a scope")),
+        IpAddr::V6(ip) if ip.is_unicast_link_local() && scope == 0 => {
+            Err(invalid("link-local DNS source requires a scope"))
+        }
+        IpAddr::V6(ip) if scope != 0 => Ok(SocketAddr::V6(SocketAddrV6::new(ip, 53, 0, scope))),
+        _ => Ok(SocketAddr::new(ip, 53)),
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub(crate) struct DnsBinding {
+    pub interface: Arc<str>,
+    pub interface_index: Option<std::num::NonZeroU32>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(super) struct SourceEndpoint {
+    pub endpoint: SocketAddr,
+    pub binding: DnsBinding,
+    pub requires_encryption: bool,
+}
+
+pub(super) struct SourceSelection {
+    pub generation: u64,
+    pub endpoints: Arc<[SourceEndpoint]>,
+}
+
+#[derive(Clone, Default)]
+pub(crate) struct SourceExclusions {
+    pub interface: Option<Arc<str>>,
+    pub addresses: Vec<IpAddr>,
+}
+impl SourceExclusions {
+    pub(super) fn permits(&self, server: &SourceEndpoint) -> bool {
+        self.interface.as_deref() != Some(server.binding.interface.as_ref())
+            && !self.addresses.contains(&server.endpoint.ip())
+    }
+}
+
+struct Discovery {
+    refreshed: Instant,
+    endpoints: Arc<[SourceEndpoint]>,
+}
+#[derive(Default)]
+struct SourceState {
+    generation: u64,
+    host: Option<DnsNetworkUpdate>,
+    discovery: HashMap<DnsSource, Discovery>,
+}
+
+/// Shared by resource generations. Weak roots make invalidation cover every
+/// still-live DNS tree without retaining retired resource generations.
+pub(crate) struct NetworkSources {
+    epoch: Arc<RwLock<u64>>,
+    state: StdMutex<SourceState>,
+    roots: StdMutex<Vec<Weak<super::runtime::RuntimeDns>>>,
+    discovery: Mutex<()>,
+}
+impl Default for NetworkSources {
+    fn default() -> Self {
+        Self {
+            epoch: Arc::new(RwLock::new(0)),
+            state: StdMutex::new(SourceState::default()),
+            roots: StdMutex::new(Vec::new()),
+            discovery: Mutex::new(()),
+        }
+    }
+}
+impl std::fmt::Debug for NetworkSources {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("NetworkSources").finish_non_exhaustive()
+    }
+}
+
+impl NetworkSources {
+    pub(crate) fn epoch(&self) -> Arc<RwLock<u64>> {
+        self.epoch.clone()
+    }
+    pub(crate) fn register(&self, root: &Arc<super::runtime::RuntimeDns>) {
+        let mut roots = self
+            .roots
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
+        roots.retain(|root| root.strong_count() != 0);
+        roots.push(Arc::downgrade(root));
+    }
+    async fn clear_roots(&self) {
+        let roots = {
+            let mut roots = self
+                .roots
+                .lock()
+                .unwrap_or_else(std::sync::PoisonError::into_inner);
+            roots.retain(|root| root.strong_count() != 0);
+            roots.iter().filter_map(Weak::upgrade).collect::<Vec<_>>()
+        };
+        for root in roots {
+            root.clear_cache_tree().await;
+        }
+    }
+
+    pub(crate) async fn replace(&self, update: DnsNetworkUpdate) -> io::Result<()> {
+        update.validate()?;
+        let mut epoch = self.epoch.write().await;
+        {
+            let mut state = self
+                .state
+                .lock()
+                .unwrap_or_else(std::sync::PoisonError::into_inner);
+            if let Some(previous) = &state.host {
+                if update.generation < previous.generation {
+                    return Err(invalid("obsolete DNS network generation"));
+                }
+                if update.generation == previous.generation {
+                    return if *previous == update {
+                        Ok(())
+                    } else {
+                        Err(invalid("conflicting DNS network generation"))
+                    };
+                }
+            }
+            state.host = Some(update);
+            state.discovery = HashMap::new();
+            state.generation = state.generation.wrapping_add(1);
+        }
+        *epoch = epoch.wrapping_add(1);
+        self.clear_roots().await;
+        Ok(())
+    }
+
+    pub(super) async fn select(
+        &self,
+        source: &DnsSource,
+        dialer: Option<&Dialer>,
+        exclusions: &SourceExclusions,
+    ) -> io::Result<SourceSelection> {
+        // Serialize only lazy metadata refreshes, never DNS I/O. The guard is
+        // cancelled with its query; a host replacement does not wait on it.
+        let _discovery = self.discovery.lock().await;
+        let observed = {
+            let _epoch = self.epoch.read().await;
+            let state = self
+                .state
+                .lock()
+                .unwrap_or_else(std::sync::PoisonError::into_inner);
+            if let Some(host) = &state.host {
+                return select_host(host, source, state.generation, exclusions);
+            }
+            if let Some(cached) = state.discovery.get(source)
+                && cached.refreshed.elapsed() < DISCOVERY_TTL
+            {
+                return selection(state.generation, cached.endpoints.clone(), exclusions);
+            }
+            state.generation
+        };
+        let endpoints = match self.discover(source, dialer, exclusions).await {
+            Ok(endpoints) => endpoints,
+            Err(error) if error.kind() == io::ErrorKind::Interrupted => return Err(error),
+            Err(_) => Vec::new(),
+        };
+        let mut epoch = self.epoch.write().await;
+        let generation = {
+            let mut state = self
+                .state
+                .lock()
+                .unwrap_or_else(std::sync::PoisonError::into_inner);
+            // A replaced host snapshot is authoritative even if an old OS
+            // discovery finished later. Never publish that stale completion.
+            if let Some(host) = &state.host {
+                return select_host(host, source, state.generation, exclusions);
+            }
+            if state.generation != observed {
+                return Err(unavailable());
+            }
+            let changed = state
+                .discovery
+                .get(source)
+                .is_none_or(|old| old.endpoints.as_ref() != endpoints);
+            state
+                .discovery
+                .retain(|_, entry| entry.refreshed.elapsed() < DISCOVERY_TTL);
+            let bytes = state
+                .discovery
+                .iter()
+                .filter(|(key, _)| *key != source)
+                .map(|(key, entry)| discovery_bytes(key, &entry.endpoints))
+                .sum::<usize>();
+            let added = discovery_bytes(source, &endpoints);
+            if bytes
+                .checked_add(added)
+                .is_none_or(|size| size > MAX_METADATA_BYTES)
+            {
+                return Err(unavailable());
+            }
+            if changed {
+                state.generation = state.generation.wrapping_add(1);
+                *epoch = epoch.wrapping_add(1);
+            }
+            state.discovery.insert(
+                source.clone(),
+                Discovery {
+                    refreshed: Instant::now(),
+                    endpoints: endpoints.into(),
+                },
+            );
+            (state.generation, changed)
+        };
+        if generation.1 {
+            self.clear_roots().await;
+        }
+        let state = self
+            .state
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
+        selection(
+            generation.0,
+            state.discovery.get(source).unwrap().endpoints.clone(),
+            exclusions,
+        )
+    }
+
+    async fn discover(
+        &self,
+        source: &DnsSource,
+        dialer: Option<&Dialer>,
+        exclusions: &SourceExclusions,
+    ) -> io::Result<Vec<SourceEndpoint>> {
+        #[cfg(target_os = "linux")]
+        {
+            let source = source.clone();
+            let exclusions = exclusions.clone();
+            dialer
+                .ok_or_else(unavailable)?
+                .run_dns_discovery(move |check| linux::discover(&source, &exclusions, check))
+                .await
+        }
+        #[cfg(all(windows, feature = "windows-uwp"))]
+        {
+            if !matches!(source, DnsSource::System) {
+                return Err(unavailable());
+            }
+            let dialer = dialer.ok_or_else(unavailable)?;
+            let adapter = dialer.physical_dns_adapter().ok_or_else(unavailable)?;
+            let snapshot = dialer
+                .run_dns_discovery(move |check| windows::snapshot(&adapter, check))
+                .await?;
+            Ok(select_host(&snapshot, source, 0, exclusions)?
+                .endpoints
+                .to_vec())
+        }
+        #[cfg(not(any(target_os = "linux", all(windows, feature = "windows-uwp"))))]
+        {
+            let _ = (source, dialer, exclusions);
+            Err(unavailable())
+        }
+    }
+}
+
+fn select_host(
+    host: &DnsNetworkUpdate,
+    source: &DnsSource,
+    generation: u64,
+    exclusions: &SourceExclusions,
+) -> io::Result<SourceSelection> {
+    let mut servers = Vec::new();
+    match source {
+        DnsSource::System => {
+            for server in &host.system {
+                servers.push(SourceEndpoint {
+                    endpoint: endpoint(server.address, server.scope_id)?,
+                    binding: DnsBinding {
+                        interface: server.interface.as_str().into(),
+                        interface_index: None,
+                    },
+                    requires_encryption: server.requires_encryption,
+                });
+            }
+        }
+        DnsSource::Dhcp(interface) => {
+            if let Some(lease) = host
+                .dhcp
+                .iter()
+                .find(|lease| lease.interface == interface.as_ref())
+            {
+                for server in &lease.servers {
+                    servers.push(SourceEndpoint {
+                        endpoint: endpoint(server.address, server.scope_id)?,
+                        binding: DnsBinding {
+                            interface: lease.interface.as_str().into(),
+                            interface_index: None,
+                        },
+                        requires_encryption: lease.requires_encryption,
+                    });
+                }
+            }
+        }
+    }
+    selection(generation, servers.into(), exclusions)
+}
+fn selection(
+    generation: u64,
+    servers: Arc<[SourceEndpoint]>,
+    exclusions: &SourceExclusions,
+) -> io::Result<SourceSelection> {
+    let servers = servers
+        .iter()
+        .filter(|server| exclusions.permits(server))
+        .cloned()
+        .collect::<Vec<_>>();
+    if servers.is_empty() || servers.iter().any(|server| server.requires_encryption) {
+        return Err(unavailable());
+    }
+    Ok(SourceSelection {
+        generation,
+        endpoints: servers.into(),
+    })
+}
+
+fn discovery_bytes(source: &DnsSource, endpoints: &[SourceEndpoint]) -> usize {
+    let key = match source {
+        DnsSource::System => 0,
+        DnsSource::Dhcp(name) => name.len(),
+    };
+    64 + key
+        + endpoints
+            .iter()
+            .map(|entry| entry.binding.interface.len() + 64)
+            .sum::<usize>()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn update(generation: u64, address: &str) -> DnsNetworkUpdate {
+        DnsNetworkUpdate {
+            generation,
+            system: vec![SystemDnsServer {
+                address: address.parse().unwrap(),
+                interface: "physical0".into(),
+                scope_id: 0,
+                requires_encryption: false,
+            }],
+            dhcp: vec![DhcpDnsInterface {
+                interface: "physical1".into(),
+                servers: vec![DnsServerAddress {
+                    address: "192.0.2.53".parse().unwrap(),
+                    scope_id: 0,
+                }],
+                requires_encryption: false,
+            }],
+        }
+    }
+
+    #[tokio::test]
+    async fn replacement_is_monotonic_idempotent_and_selects_exact_interface() {
+        let sources = NetworkSources::default();
+        let current = update(1, "203.0.113.53");
+        sources.replace(current.clone()).await.unwrap();
+        let epoch = *sources.epoch.read().await;
+        sources.replace(current.clone()).await.unwrap();
+        assert_eq!(*sources.epoch.read().await, epoch);
+        assert!(sources.replace(update(1, "203.0.113.54")).await.is_err());
+        sources.replace(update(2, "203.0.113.54")).await.unwrap();
+        assert!(sources.replace(current).await.is_err());
+        let system = sources
+            .select(&DnsSource::System, None, &SourceExclusions::default())
+            .await
+            .unwrap();
+        assert_eq!(
+            system.endpoints[0].endpoint.ip(),
+            "203.0.113.54".parse::<IpAddr>().unwrap()
+        );
+        let dhcp = sources
+            .select(
+                &DnsSource::Dhcp("physical1".into()),
+                None,
+                &SourceExclusions::default(),
+            )
+            .await
+            .unwrap();
+        assert_eq!(
+            dhcp.endpoints[0].endpoint.ip(),
+            "192.0.2.53".parse::<IpAddr>().unwrap()
+        );
+        assert!(
+            sources
+                .select(
+                    &DnsSource::Dhcp("physical0".into()),
+                    None,
+                    &SourceExclusions::default()
+                )
+                .await
+                .is_err()
+        );
+    }
+
+    #[tokio::test]
+    async fn replacement_excludes_tun_and_never_downgrades_encryption() {
+        let sources = NetworkSources::default();
+        let mut snapshot = update(1, "203.0.113.53");
+        snapshot.system[0].requires_encryption = true;
+        sources.replace(snapshot.clone()).await.unwrap();
+        assert!(
+            sources
+                .select(&DnsSource::System, None, &SourceExclusions::default())
+                .await
+                .is_err()
+        );
+        snapshot.generation = 2;
+        snapshot.system[0].requires_encryption = false;
+        sources.replace(snapshot).await.unwrap();
+        for exclusions in [
+            SourceExclusions {
+                interface: Some("physical0".into()),
+                addresses: vec![],
+            },
+            SourceExclusions {
+                interface: None,
+                addresses: vec!["203.0.113.53".parse().unwrap()],
+            },
+        ] {
+            assert!(
+                sources
+                    .select(&DnsSource::System, None, &exclusions)
+                    .await
+                    .is_err()
+            );
+        }
+        sources
+            .replace(DnsNetworkUpdate {
+                generation: 3,
+                system: vec![],
+                dhcp: vec![],
+            })
+            .await
+            .unwrap();
+        assert!(
+            sources
+                .select(&DnsSource::System, None, &SourceExclusions::default())
+                .await
+                .is_err()
+        );
+    }
+
+    #[test]
+    fn metadata_is_strict_bounded_and_rejects_stub_addresses() {
+        assert!(update(0, "203.0.113.53").validate().is_err());
+        let mut large = update(1, "203.0.113.53");
+        large.system = vec![large.system[0].clone(); 1024];
+        assert!(large.validate().is_err());
+        assert!(
+            serde_json::from_str::<DnsNetworkUpdate>(
+                r#"{"generation":1,"system":[],"dhcp":[],"extra":true}"#
+            )
+            .is_err()
+        );
+        for address in [
+            "127.0.0.53",
+            "::1",
+            "::ffff:127.0.0.53",
+            "0.0.0.0",
+            "224.0.0.1",
+            "ff02::1",
+        ] {
+            assert!(endpoint(address.parse().unwrap(), 0).is_err(), "{address}");
+        }
+        assert!(endpoint("fe80::53".parse().unwrap(), 0).is_err());
+        let SocketAddr::V6(scoped) = endpoint("fe80::53".parse().unwrap(), 3).unwrap() else {
+            panic!("IPv6")
+        };
+        assert_eq!(scoped.scope_id(), 3);
+        assert!(endpoint("192.0.2.53".parse().unwrap(), 3).is_err());
+        for name in [
+            "",
+            "../physical0",
+            "physical0\n",
+            " physical0",
+            "physical0/",
+        ] {
+            assert!(validate_interface(name).is_err());
+        }
+        assert!(discovery_bytes(&DnsSource::Dhcp("physical1".into()), &[]) > 64);
+    }
+}
diff --git a/src/dns/source/linux.rs b/src/dns/source/linux.rs
new file mode 100644
index 0000000..93e5732
--- /dev/null
+++ b/src/dns/source/linux.rs
@@ -0,0 +1,444 @@
+//! Read-only discovery through services already running on the system bus.
+use super::{DnsBinding, MAX_METADATA_BYTES, SourceEndpoint, SourceExclusions, unavailable};
+use crate::config::DnsSource;
+use serde_json::Value;
+use std::{
+    ffi::CString,
+    io::{self, Read},
+    net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr},
+    os::fd::AsRawFd,
+    process::{Child, Command, Stdio},
+    time::{Duration, Instant},
+};
+
+const RESOLVE: &str = "org.freedesktop.resolve1";
+const RESOLVE_PATH: &str = "/org/freedesktop/resolve1";
+const RESOLVE_MANAGER: &str = "org.freedesktop.resolve1.Manager";
+const NM: &str = "org.freedesktop.NetworkManager";
+const NM_PATH: &str = "/org/freedesktop/NetworkManager";
+
+pub(super) fn discover(
+    source: &DnsSource,
+    exclusions: &SourceExclusions,
+    check: &dyn Fn() -> io::Result<()>,
+) -> io::Result<Vec<SourceEndpoint>> {
+    let deadline = Instant::now() + Duration::from_secs(3);
+    let bus = Bus { deadline, check };
+    match source {
+        DnsSource::System => system(&bus, exclusions),
+        DnsSource::Dhcp(interface) => dhcp(&bus, interface, exclusions),
+    }
+}
+
+fn system(bus: &Bus<'_>, exclusions: &SourceExclusions) -> io::Result<Vec<SourceEndpoint>> {
+    let data = bus.property(RESOLVE, RESOLVE_PATH, RESOLVE_MANAGER, "DNS")?;
+    let rows = array_body(&data)?;
+    let mut servers = Vec::new();
+    let global_tls = bus
+        .property(RESOLVE, RESOLVE_PATH, RESOLVE_MANAGER, "DNSOverTLS")
+        .and_then(|value| string_body(&value).map(str::to_owned))?;
+    let mut policies = std::collections::HashMap::new();
+    for row in rows {
+        let row = row.as_array().ok_or_else(unavailable)?;
+        if row.len() != 3 {
+            return Err(unavailable());
+        }
+        let index = row[0]
+            .as_u64()
+            .and_then(|value| u32::try_from(value).ok())
+            .ok_or_else(unavailable)?;
+        if index == 0 {
+            continue;
+        } // Global servers have no physical link attribution.
+        let Some(interface) = interface_name(index) else {
+            continue;
+        };
+        if !physical_interface(&interface, exclusions) {
+            continue;
+        }
+        let encrypted = if let Some(policy) = policies.get(&index) {
+            *policy
+        } else {
+            let path = bus.call(
+                RESOLVE,
+                RESOLVE_PATH,
+                RESOLVE_MANAGER,
+                "GetLink",
+                &["i", &index.to_string()],
+            )?;
+            let path = string_body(&path)?;
+            let tls = bus.property(RESOLVE, path, "org.freedesktop.resolve1.Link", "DNSOverTLS")?;
+            let tls = string_body(&tls)?;
+            let required = if tls.is_empty() {
+                global_tls.as_str()
+            } else {
+                tls
+            } != "no";
+            policies.insert(index, required);
+            required
+        };
+        let family = row[1].as_i64().ok_or_else(unavailable)?;
+        let address = decode_address(family, &row[2])?;
+        let endpoint = socket_address(address, index)?;
+        let server = SourceEndpoint {
+            endpoint,
+            binding: DnsBinding {
+                interface: interface.into(),
+                interface_index: std::num::NonZeroU32::new(index),
+            },
+            requires_encryption: encrypted,
+        };
+        if exclusions.permits(&server) && !servers.contains(&server) {
+            servers.push(server);
+        }
+    }
+    Ok(servers)
+}
+
+fn dhcp(
+    bus: &Bus<'_>,
+    interface: &str,
+    exclusions: &SourceExclusions,
+) -> io::Result<Vec<SourceEndpoint>> {
+    super::validate_interface(interface)?;
+    if !physical_interface(interface, exclusions) {
+        return Err(unavailable());
+    }
+    let name = CString::new(interface).map_err(|_| unavailable())?;
+    // SAFETY: `name` is a validated NUL-terminated interface name.
+    let index = unsafe { libc::if_nametoindex(name.as_ptr()) };
+    if index == 0 {
+        return Err(unavailable());
+    }
+    let device = bus.call(NM, NM_PATH, NM, "GetDeviceByIpIface", &["s", interface])?;
+    let device = string_body(&device)?;
+    let state = bus.property(NM, device, "org.freedesktop.NetworkManager.Device", "State")?;
+    if number_body(&state)? != 100 {
+        return Err(unavailable());
+    }
+    let lease = bus.property(
+        NM,
+        device,
+        "org.freedesktop.NetworkManager.Device",
+        "Dhcp4Config",
+    )?;
+    let lease = string_body(&lease)?;
+    if lease == "/" {
+        return Err(unavailable());
+    }
+    let options = bus.property(
+        NM,
+        lease,
+        "org.freedesktop.NetworkManager.DHCP4Config",
+        "Options",
+    )?;
+    let dns = option(&options, "domain_name_servers").ok_or_else(unavailable)?;
+    let mut servers = Vec::new();
+    for address in dns.split_ascii_whitespace() {
+        let address = address
+            .parse::<Ipv4Addr>()
+            .map(IpAddr::V4)
+            .map_err(|_| unavailable())?;
+        let server = SourceEndpoint {
+            endpoint: socket_address(address, index)?,
+            binding: DnsBinding {
+                interface: interface.into(),
+                interface_index: std::num::NonZeroU32::new(index),
+            },
+            requires_encryption: false,
+        };
+        if exclusions.permits(&server) && !servers.contains(&server) {
+            servers.push(server);
+        }
+    }
+    // Lease ownership does not prove a plaintext link policy. Require a
+    // policy from the existing resolver; unknown policy is unavailable.
+    let path = bus.call(
+        RESOLVE,
+        RESOLVE_PATH,
+        RESOLVE_MANAGER,
+        "GetLink",
+        &["i", &index.to_string()],
+    )?;
+    let path = string_body(&path)?;
+    let tls = bus.property(RESOLVE, path, "org.freedesktop.resolve1.Link", "DNSOverTLS")?;
+    let mut tls = string_body(&tls)?.to_owned();
+    if tls.is_empty() {
+        tls = string_body(&bus.property(RESOLVE, RESOLVE_PATH, RESOLVE_MANAGER, "DNSOverTLS")?)?
+            .to_owned();
+    }
+    for server in &mut servers {
+        server.requires_encryption = tls != "no";
+    }
+    Ok(servers)
+}
+
+fn physical_interface(name: &str, exclusions: &SourceExclusions) -> bool {
+    super::validate_interface(name).is_ok()
+        && exclusions.interface.as_deref() != Some(name)
+        && name != "lo"
+        && !std::path::Path::new("/sys/class/net")
+            .join(name)
+            .join("tun_flags")
+            .exists()
+        && std::fs::read_to_string(
+            std::path::Path::new("/sys/class/net")
+                .join(name)
+                .join("operstate"),
+        )
+        .is_ok_and(|state| matches!(state.trim(), "up" | "unknown"))
+}
+fn interface_name(index: u32) -> Option<String> {
+    let mut name = [0 as libc::c_char; libc::IF_NAMESIZE];
+    // SAFETY: the buffer has IF_NAMESIZE bytes and remains live for the call.
+    if unsafe { libc::if_indextoname(index, name.as_mut_ptr()) }.is_null() {
+        return None;
+    }
+    // SAFETY: a successful call produced a terminated interface name.
+    unsafe { std::ffi::CStr::from_ptr(name.as_ptr()) }
+        .to_str()
+        .ok()
+        .map(str::to_owned)
+}
+fn socket_address(ip: IpAddr, index: u32) -> io::Result<SocketAddr> {
+    let scope = match ip {
+        IpAddr::V6(ip) if ip.is_unicast_link_local() => index,
+        _ => 0,
+    };
+    super::endpoint(ip, scope)
+}
+fn decode_address(family: i64, value: &Value) -> io::Result<IpAddr> {
+    let bytes = value
+        .as_array()
+        .ok_or_else(unavailable)?
+        .iter()
+        .map(|value| {
+            value
+                .as_u64()
+                .and_then(|value| u8::try_from(value).ok())
+                .ok_or_else(unavailable)
+        })
+        .collect::<io::Result<Vec<_>>>()?;
+    match family {
+        2 if bytes.len() == 4 => Ok(IpAddr::V4(Ipv4Addr::new(
+            bytes[0], bytes[1], bytes[2], bytes[3],
+        ))),
+        10 if bytes.len() == 16 => Ok(IpAddr::V6(Ipv6Addr::from(
+            <[u8; 16]>::try_from(bytes.as_slice()).unwrap(),
+        ))),
+        _ => Err(unavailable()),
+    }
+}
+fn body(value: &Value) -> io::Result<&Value> {
+    value.get("data").ok_or_else(unavailable)
+}
+fn string_body(value: &Value) -> io::Result<&str> {
+    let body = body(value)?;
+    body.as_str()
+        .or_else(|| {
+            body.as_array()
+                .filter(|body| body.len() == 1)?
+                .first()?
+                .as_str()
+        })
+        .ok_or_else(unavailable)
+}
+fn number_body(value: &Value) -> io::Result<u64> {
+    let body = body(value)?;
+    body.as_u64()
+        .or_else(|| {
+            body.as_array()
+                .filter(|body| body.len() == 1)?
+                .first()?
+                .as_u64()
+        })
+        .ok_or_else(unavailable)
+}
+fn array_body(value: &Value) -> io::Result<&[Value]> {
+    let data = body(value)?.as_array().ok_or_else(unavailable)?;
+    // busctl's body contains one array argument. Accept the property form as
+    // well, where the data itself is that argument.
+    if let [first] = data.as_slice()
+        && let Some(first) = first.as_array()
+        && first.first().is_none_or(Value::is_array)
+    {
+        return Ok(first);
+    }
+    Ok(data)
+}
+fn option<'a>(value: &'a Value, key: &str) -> Option<&'a str> {
+    let mut data = value.get("data")?;
+    if let Some(array) = data.as_array()
+        && array.len() == 1
+        && array[0].is_object()
+    {
+        data = &array[0];
+    }
+    let value = if let Some(object) = data.as_object() {
+        object.get(key)?
+    } else {
+        data.as_array()?.iter().find_map(|entry| {
+            let pair = entry.as_array()?;
+            (pair.len() == 2 && pair[0].as_str() == Some(key)).then(|| &pair[1])
+        })?
+    };
+    value.as_str().or_else(|| string_body(value).ok())
+}
+
+struct Bus<'a> {
+    deadline: Instant,
+    check: &'a dyn Fn() -> io::Result<()>,
+}
+impl Bus<'_> {
+    fn property(
+        &self,
+        service: &str,
+        path: &str,
+        interface: &str,
+        property: &str,
+    ) -> io::Result<Value> {
+        self.run(&["get-property", service, path, interface, property])
+    }
+    fn call(
+        &self,
+        service: &str,
+        path: &str,
+        interface: &str,
+        method: &str,
+        arguments: &[&str],
+    ) -> io::Result<Value> {
+        let mut argv = vec!["call", service, path, interface, method];
+        argv.extend_from_slice(arguments);
+        self.run(&argv)
+    }
+    fn run(&self, argv: &[&str]) -> io::Result<Value> {
+        (self.check)()?;
+        if Instant::now() >= self.deadline {
+            return Err(io::ErrorKind::TimedOut.into());
+        }
+        let child = Command::new("/usr/bin/busctl")
+            .args([
+                "--system",
+                "--json=short",
+                "--no-pager",
+                "--auto-start=no",
+                "--allow-interactive-authorization=no",
+                "--timeout=3s",
+            ])
+            .args(argv)
+            .stdin(Stdio::null())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .spawn()?;
+        let mut child = OwnedChild(child);
+        let mut stdout = child.0.stdout.take().ok_or_else(unavailable)?;
+        let mut stderr = child.0.stderr.take().ok_or_else(unavailable)?;
+        nonblocking(stdout.as_raw_fd())?;
+        nonblocking(stderr.as_raw_fd())?;
+        let mut output = Vec::new();
+        let mut errors = 0;
+        loop {
+            (self.check)()?;
+            if Instant::now() >= self.deadline {
+                return Err(io::ErrorKind::TimedOut.into());
+            }
+            drain(&mut stdout, &mut output)?;
+            discard(&mut stderr, &mut errors)?;
+            if let Some(status) = child.0.try_wait()? {
+                drain(&mut stdout, &mut output)?;
+                discard(&mut stderr, &mut errors)?;
+                if !status.success() {
+                    return Err(unavailable());
+                }
+                return serde_json::from_slice(&output).map_err(|_| unavailable());
+            }
+            std::thread::sleep(Duration::from_millis(5));
+        }
+    }
+}
+struct OwnedChild(Child);
+impl Drop for OwnedChild {
+    fn drop(&mut self) {
+        let _ = self.0.kill();
+        let _ = self.0.wait();
+    }
+}
+fn nonblocking(fd: i32) -> io::Result<()> {
+    // SAFETY: fd is a live owned pipe and F_GETFL/F_SETFL use integer flags.
+    let flags = unsafe { libc::fcntl(fd, libc::F_GETFL) };
+    if flags < 0 || unsafe { libc::fcntl(fd, libc::F_SETFL, flags | libc::O_NONBLOCK) } < 0 {
+        return Err(io::Error::last_os_error());
+    }
+    Ok(())
+}
+fn drain(reader: &mut impl Read, output: &mut Vec<u8>) -> io::Result<()> {
+    let mut buffer = [0; 4096];
+    loop {
+        match reader.read(&mut buffer) {
+            Ok(0) => return Ok(()),
+            Ok(count) => {
+                if output
+                    .len()
+                    .checked_add(count)
+                    .is_none_or(|size| size > MAX_METADATA_BYTES)
+                {
+                    return Err(unavailable());
+                }
+                output.extend_from_slice(&buffer[..count]);
+            }
+            Err(error) if error.kind() == io::ErrorKind::WouldBlock => return Ok(()),
+            Err(error) if error.kind() == io::ErrorKind::Interrupted => continue,
+            Err(error) => return Err(error),
+        }
+    }
+}
+fn discard(reader: &mut impl Read, total: &mut usize) -> io::Result<()> {
+    let mut buffer = [0; 4096];
+    loop {
+        match reader.read(&mut buffer) {
+            Ok(0) => return Ok(()),
+            Ok(count) => {
+                *total = total
+                    .checked_add(count)
+                    .filter(|size| *size <= MAX_METADATA_BYTES)
+                    .ok_or_else(unavailable)?;
+            }
+            Err(error) if error.kind() == io::ErrorKind::WouldBlock => return Ok(()),
+            Err(error) if error.kind() == io::ErrorKind::Interrupted => continue,
+            Err(error) => return Err(error),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn busctl_property_and_call_bodies_keep_link_and_lease_metadata() {
+        // busctl get-property dumps the variant's subtree; a method reply
+        // dumps an array of arguments. Dictionaries use JSON objects.
+        let property = json!({"type":"a(iiay)","data":[[7,2,[10,0,0,53]]]});
+        let rows = array_body(&property).unwrap();
+        assert_eq!(rows.len(), 1);
+        assert_eq!(rows[0][0], 7);
+        assert_eq!(
+            decode_address(2, &rows[0][2]).unwrap(),
+            "10.0.0.53".parse::<IpAddr>().unwrap()
+        );
+        assert_eq!(
+            string_body(&json!({"type":"o","data":["/link/7"]})).unwrap(),
+            "/link/7"
+        );
+        assert_eq!(number_body(&json!({"type":"u","data":100})).unwrap(), 100);
+        let lease = json!({"type":"a{sv}","data":{
+            "domain_name_servers":{"type":"s","data":"10.0.0.53 10.0.0.54"}
+        }});
+        assert_eq!(
+            option(&lease, "domain_name_servers"),
+            Some("10.0.0.53 10.0.0.54")
+        );
+        assert!(decode_address(2, &json!([10, 0, 0, 256])).is_err());
+    }
+}
diff --git a/src/dns/source/windows.rs b/src/dns/source/windows.rs
new file mode 100644
index 0000000..a35caf9
--- /dev/null
+++ b/src/dns/source/windows.rs
@@ -0,0 +1,160 @@
+//! Session-Host discovery for the Provider's immutable physical adapter GUID.
+use super::{DnsNetworkUpdate, MAX_METADATA_BYTES, SystemDnsServer, unavailable};
+use std::{
+    io,
+    mem::size_of,
+    net::{IpAddr, Ipv4Addr, Ipv6Addr},
+};
+use windows::{
+    Win32::{
+        Foundation::{ERROR_BUFFER_OVERFLOW, NO_ERROR},
+        NetworkManagement::IpHelper::{
+            DNS_INTERFACE_SETTINGS, DNS_INTERFACE_SETTINGS_VERSION3, DNS_INTERFACE_SETTINGS3,
+            DNS_SETTING_DOH, DNS_SETTING_DOH_PROFILE, FreeInterfaceDnsSettings,
+            GET_ADAPTERS_ADDRESSES_FLAGS, GetAdaptersAddresses, GetInterfaceDnsSettings,
+            IP_ADAPTER_ADDRESSES_LH,
+        },
+        Networking::WinSock::{AF_INET, AF_INET6, AF_UNSPEC, SOCKADDR_IN, SOCKADDR_IN6},
+    },
+    core::GUID,
+};
+
+pub(crate) fn snapshot(
+    adapter_name: &str,
+    check: &dyn Fn() -> io::Result<()>,
+) -> io::Result<DnsNetworkUpdate> {
+    let guid = GUID::try_from(adapter_name).map_err(|_| unavailable())?;
+    check()?;
+    let mut settings = Settings(DNS_INTERFACE_SETTINGS3 {
+        Version: DNS_INTERFACE_SETTINGS_VERSION3,
+        ..Default::default()
+    });
+    // SAFETY: v3 layout starts with DNS_INTERFACE_SETTINGS, and is live here.
+    let status = unsafe { GetInterfaceDnsSettings(guid, (&raw mut settings.0).cast()) };
+    if status != NO_ERROR {
+        return Err(unavailable());
+    }
+    let encrypted = settings.0.cServerProperties != 0
+        || settings.0.cProfileServerProperties != 0
+        || settings.0.Flags & u64::from(DNS_SETTING_DOH | DNS_SETTING_DOH_PROFILE) != 0;
+    check()?;
+    let mut storage = vec![0_usize; (15 * 1024_usize).div_ceil(size_of::<usize>())];
+    for _ in 0..3 {
+        check()?;
+        let mut length =
+            u32::try_from(storage.len() * size_of::<usize>()).map_err(|_| unavailable())?;
+        // SAFETY: the aligned storage remains live while the OS list is read.
+        let status = unsafe {
+            GetAdaptersAddresses(
+                u32::from(AF_UNSPEC.0),
+                GET_ADAPTERS_ADDRESSES_FLAGS(0),
+                None,
+                Some(storage.as_mut_ptr().cast()),
+                &mut length,
+            )
+        };
+        if status == ERROR_BUFFER_OVERFLOW.0 {
+            if length as usize > MAX_METADATA_BYTES {
+                return Err(unavailable());
+            }
+            storage.resize(
+                (length as usize)
+                    .div_ceil(size_of::<usize>())
+                    .max(storage.len() + 1),
+                0,
+            );
+            continue;
+        }
+        if status != NO_ERROR.0 {
+            return Err(unavailable());
+        }
+        let mut current = storage.as_ptr().cast::<IP_ADAPTER_ADDRESSES_LH>();
+        while !current.is_null() {
+            check()?;
+            // SAFETY: GetAdaptersAddresses initialized the linked entries.
+            let adapter = unsafe { &*current };
+            if !adapter.AdapterName.is_null() {
+                // SAFETY: this terminated string belongs to live storage.
+                let name = unsafe { adapter.AdapterName.to_string() }.map_err(|_| unavailable())?;
+                if name
+                    .trim_matches(['{', '}'])
+                    .eq_ignore_ascii_case(adapter_name)
+                {
+                    let mut servers = Vec::new();
+                    let mut dns = adapter.FirstDnsServerAddress;
+                    while !dns.is_null() {
+                        check()?;
+                        // SAFETY: DNS entries and address pointers belong to the same live storage.
+                        let dns_entry = unsafe { &*dns };
+                        let address = dns_entry.Address;
+                        if !address.lpSockaddr.is_null() {
+                            // SAFETY: the pointer identifies at least the returned sockaddr header.
+                            let family = unsafe { (*address.lpSockaddr).sa_family };
+                            let value = if family == AF_INET
+                                && address.iSockaddrLength >= size_of::<SOCKADDR_IN>() as i32
+                            {
+                                // SAFETY: the family and length identify SOCKADDR_IN.
+                                let address = unsafe { &*address.lpSockaddr.cast::<SOCKADDR_IN>() };
+                                // SAFETY: S_un_b is the IPv4 octet view.
+                                let bytes = unsafe { address.sin_addr.S_un.S_un_b };
+                                Some((
+                                    IpAddr::V4(Ipv4Addr::new(
+                                        bytes.s_b1, bytes.s_b2, bytes.s_b3, bytes.s_b4,
+                                    )),
+                                    0,
+                                ))
+                            } else if family == AF_INET6
+                                && address.iSockaddrLength >= size_of::<SOCKADDR_IN6>() as i32
+                            {
+                                // SAFETY: family/length identify SOCKADDR_IN6 and its address/scope unions.
+                                let address =
+                                    unsafe { &*address.lpSockaddr.cast::<SOCKADDR_IN6>() };
+                                Some((
+                                    IpAddr::V6(Ipv6Addr::from(unsafe { address.sin6_addr.u.Byte })),
+                                    unsafe { address.Anonymous.sin6_scope_id },
+                                ))
+                            } else {
+                                None
+                            };
+                            if let Some((address, scope)) = value
+                                && super::endpoint(address, scope).is_ok()
+                            {
+                                let server = SystemDnsServer {
+                                    address,
+                                    interface: adapter_name.to_owned(),
+                                    scope_id: scope,
+                                    // The read API requires empty input Flags;
+                                    // its default settings cover IPv4. Without
+                                    // a proven IPv6 policy, do not downgrade an
+                                    // IPv6 DNS server to UDP/TCP.
+                                    requires_encryption: encrypted || address.is_ipv6(),
+                                };
+                                if !servers.contains(&server) {
+                                    servers.push(server);
+                                }
+                            }
+                        }
+                        dns = dns_entry.Next;
+                    }
+                    let update = DnsNetworkUpdate {
+                        generation: 1,
+                        system: servers,
+                        dhcp: Vec::new(),
+                    };
+                    update.validate()?;
+                    return Ok(update);
+                }
+            }
+            current = adapter.Next;
+        }
+        return Err(unavailable());
+    }
+    Err(unavailable())
+}
+struct Settings(DNS_INTERFACE_SETTINGS3);
+impl Drop for Settings {
+    fn drop(&mut self) {
+        // SAFETY: API-owned fields use its paired deallocator, including a failed call.
+        unsafe { FreeInterfaceDnsSettings((&raw mut self.0).cast::<DNS_INTERFACE_SETTINGS>()) };
+    }
+}
diff --git a/src/dns/tests_ech.rs b/src/dns/tests_ech.rs
new file mode 100644
index 0000000..126d4a6
--- /dev/null
+++ b/src/dns/tests_ech.rs
@@ -0,0 +1,302 @@
+use super::*;
+use crate::dispatch::DatagramTransport;
+use crate::dns::{build_wire_query, https_ech_config, source::*};
+use async_trait::async_trait;
+
+fn ech_rdata(priority: u16, value: &[u8]) -> Vec<u8> {
+    let mut data = priority.to_be_bytes().to_vec();
+    data.push(0); // uncompressed TargetName root
+    data.extend_from_slice(&5u16.to_be_bytes());
+    data.extend_from_slice(&(value.len() as u16).to_be_bytes());
+    data.extend_from_slice(value);
+    data
+}
+fn response(query: &[u8], records: &[(u16, Vec<u8>)]) -> Vec<u8> {
+    let mut wire = query.to_vec();
+    wire[2..4].copy_from_slice(&0x8180u16.to_be_bytes());
+    wire[6..8].copy_from_slice(&(records.len() as u16).to_be_bytes());
+    for (kind, data) in records {
+        wire.extend_from_slice(&[0xc0, 0x0c]);
+        wire.extend_from_slice(&kind.to_be_bytes());
+        wire.extend_from_slice(&1u16.to_be_bytes());
+        wire.extend_from_slice(&60u32.to_be_bytes());
+        wire.extend_from_slice(&(data.len() as u16).to_be_bytes());
+        wire.extend_from_slice(data);
+    }
+    wire
+}
+#[test]
+fn https_ech_extracts_first_wire_record_and_binary_parameter() {
+    let query = build_wire_query(7, "ech.example", 65).unwrap();
+    let value = vec![0xfe, 0, 0xff, 0x80];
+    let wire = response(
+        &query,
+        &[
+            (64, ech_rdata(1, b"svcb-is-not-an-https-answer")),
+            (65, ech_rdata(20, &value)),
+            (65, ech_rdata(1, b"lower-priority-is-later")),
+        ],
+    );
+    assert_eq!(https_ech_config(&query, &wire).unwrap(), value);
+    assert!(https_ech_config(&query, &response(&query, &[(64, ech_rdata(1, b"x"))])).is_err());
+}
+#[test]
+fn https_ech_rejects_malformed_target_parameters_and_response_identity() {
+    let query = build_wire_query(7, "ech.example", 65).unwrap();
+    let valid = ech_rdata(1, b"key");
+    let mut duplicate = valid.clone();
+    duplicate.extend_from_slice(&[0, 5, 0, 0]);
+    let mut decreasing = valid.clone();
+    decreasing.extend_from_slice(&[0, 1, 0, 0]);
+    let compressed = vec![0, 1, 0xc0, 0x0c, 0, 5, 0, 1, 7];
+    let mut truncated = valid.clone();
+    truncated.pop();
+    for data in [duplicate, decreasing, compressed, truncated] {
+        assert!(https_ech_config(&query, &response(&query, &[(65, data)])).is_err());
+    }
+    let mut wire = response(&query, &[(65, valid)]);
+    wire[0] ^= 1;
+    assert!(https_ech_config(&query, &wire).is_err());
+}
+
+#[derive(Default)]
+struct Egress {
+    calls: AtomicUsize,
+    active: Arc<AtomicUsize>,
+    queries: Arc<StdMutex<Vec<(Destination, super::super::WireQuestion)>>>,
+    records: Vec<(u16, Vec<u8>)>,
+    pending: bool,
+}
+#[async_trait]
+impl Dispatcher for Egress {
+    async fn connect_tcp(&self, _: StreamSession) -> Result<BoxStream, DispatchError> {
+        Err(DispatchError::NotAllowed)
+    }
+    async fn open_datagram(
+        &self,
+        _: DatagramSession,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        self.calls.fetch_add(1, Ordering::Relaxed);
+        self.active.fetch_add(1, Ordering::Relaxed);
+        Ok(Box::new(Transport {
+            active: self.active.clone(),
+            queries: self.queries.clone(),
+            records: self.records.clone(),
+            query: None,
+            pending: self.pending,
+        }))
+    }
+}
+struct Transport {
+    active: Arc<AtomicUsize>,
+    queries: Arc<StdMutex<Vec<(Destination, super::super::WireQuestion)>>>,
+    records: Vec<(u16, Vec<u8>)>,
+    query: Option<Datagram>,
+    pending: bool,
+}
+impl Drop for Transport {
+    fn drop(&mut self) {
+        self.active.fetch_sub(1, Ordering::Relaxed);
+    }
+}
+#[async_trait]
+impl DatagramTransport for Transport {
+    fn supports_shared_destinations(&self) -> bool {
+        false
+    }
+
+    async fn send(&mut self, datagram: Datagram) -> Result<(), DispatchError> {
+        let parsed = classify_query(&datagram.payload).unwrap();
+        self.queries
+            .lock()
+            .unwrap()
+            .push((datagram.remote.clone(), parsed.question));
+        self.query = Some(datagram);
+        Ok(())
+    }
+    async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+        if self.pending {
+            return std::future::pending().await;
+        }
+        let query = self.query.take().unwrap();
+        Ok(Datagram {
+            remote: query.remote,
+            payload: Bytes::from(response(&query.payload, &self.records)),
+            sniffed_domain: None,
+        })
+    }
+}
+fn configuration(enabled: bool) -> crate::config::Config {
+    crate::config::Config::parse_yaml(format!("mixed-port: 1080\nhosts: {{query.example: 192.0.2.44}}\ndns:\n  enable: {enabled}\n  use-system-hosts: false\n  enhanced-mode: fake-ip\n  nameserver: [192.0.2.53]\n  proxy-server-nameserver: [203.0.113.53]\n").as_bytes()).unwrap()
+}
+fn source_snapshot(server: Option<&str>) -> DnsNetworkUpdate {
+    DnsNetworkUpdate {
+        generation: 1,
+        system: server
+            .into_iter()
+            .map(|address| SystemDnsServer {
+                address: address.parse().unwrap(),
+                interface: "physical0".into(),
+                scope_id: 0,
+                requires_encryption: false,
+            })
+            .collect(),
+        dhcp: vec![],
+    }
+}
+fn context(dns: &Arc<RuntimeDns>) -> super::super::resolution::ResolutionContext {
+    let context = super::super::resolution::ResolutionContext::runtime(false);
+    context.bind_runtime(Some(dns)).unwrap();
+    context
+}
+#[tokio::test]
+async fn dynamic_ech_uses_proxy_role_bypasses_hosts_and_reuses_wire_cache() {
+    let egress = Arc::new(Egress {
+        records: vec![(65, ech_rdata(1, b"binary-config"))],
+        ..Default::default()
+    });
+    let dns = Arc::new(RuntimeDns::new(&configuration(true).dns, egress.clone()));
+    let context = context(&dns);
+    for _ in 0..2 {
+        assert_eq!(
+            context
+                .resolve_ech(
+                    "query.example",
+                    TokioInstant::now() + Duration::from_secs(1)
+                )
+                .await
+                .unwrap(),
+            b"binary-config"
+        );
+    }
+    assert_eq!(egress.calls.load(Ordering::Relaxed), 1);
+    let queries = egress.queries.lock().unwrap();
+    assert_eq!(
+        queries[0].0,
+        Destination::Ip("203.0.113.53:53".parse().unwrap())
+    );
+    assert_eq!(queries[0].1.query_type, 65);
+    assert_eq!(queries[0].1.name, "query.example");
+    assert_eq!(egress.active.load(Ordering::Relaxed), 0);
+}
+#[tokio::test(start_paused = true)]
+async fn dynamic_ech_deadline_and_stop_release_query_transport_and_flight() {
+    for enabled in [true, false] {
+        for stop in [false, true] {
+            let egress = Arc::new(Egress {
+                pending: true,
+                ..Default::default()
+            });
+            let dns = Arc::new(RuntimeDns::new(&configuration(enabled).dns, egress.clone()));
+            if !enabled {
+                dns.sources
+                    .replace(source_snapshot(Some("192.0.2.99")))
+                    .await
+                    .unwrap();
+            }
+            let context = context(&dns);
+            let task = tokio::spawn({
+                let context = context.clone();
+                async move {
+                    context
+                        .resolve_ech(
+                            "pending.example",
+                            TokioInstant::now() + Duration::from_millis(50),
+                        )
+                        .await
+                }
+            });
+            while egress.active.load(Ordering::Relaxed) == 0 {
+                tokio::task::yield_now().await;
+            }
+            if stop {
+                context.close();
+            } else {
+                tokio::time::advance(Duration::from_millis(50)).await;
+            }
+            let error = task.await.unwrap().unwrap_err();
+            assert_eq!(
+                error.kind(),
+                if stop {
+                    io::ErrorKind::Interrupted
+                } else {
+                    io::ErrorKind::TimedOut
+                }
+            );
+            assert_eq!(egress.active.load(Ordering::Relaxed), 0);
+            let role = if enabled {
+                dns.proxy_resolver.as_ref().unwrap()
+            } else {
+                dns.ech_system_resolver.as_ref().unwrap()
+            };
+            assert_eq!(role.tcp_pool.http2.is_closed(), stop);
+            assert_eq!(role.resource_stats.snapshot().dns_current, 0);
+            assert_eq!(role.singleflight.len(), 0);
+        }
+    }
+}
+
+#[tokio::test]
+async fn disabled_dns_and_measurement_ech_require_physical_system_metadata() {
+    let egress = Arc::new(Egress {
+        records: vec![(65, ech_rdata(1, b"system-config"))],
+        ..Default::default()
+    });
+    let dns = Arc::new(RuntimeDns::new(&configuration(false).dns, egress.clone()));
+    dns.sources
+        .replace(source_snapshot(Some("192.0.2.99")))
+        .await
+        .unwrap();
+    assert_eq!(
+        context(&dns)
+            .resolve_ech("ech.example", TokioInstant::now() + Duration::from_secs(1))
+            .await
+            .unwrap(),
+        b"system-config"
+    );
+    assert_eq!(
+        egress.queries.lock().unwrap()[0].0,
+        Destination::Ip("192.0.2.99:53".parse().unwrap())
+    );
+    let unavailable = Arc::new(RuntimeDns::new(&configuration(false).dns, egress.clone()));
+    unavailable
+        .sources
+        .replace(source_snapshot(None))
+        .await
+        .unwrap();
+    assert!(
+        context(&unavailable)
+            .resolve_ech("ech.example", TokioInstant::now() + Duration::from_secs(1))
+            .await
+            .is_err()
+    );
+    assert_eq!(egress.calls.load(Ordering::Relaxed), 1);
+    let measurement = super::super::resolution::ResolutionContext::measurement(
+        Arc::new(crate::dialer::SystemResolver),
+        false,
+    );
+    measurement.bind_measurement_ech(&dns).unwrap();
+    assert_eq!(
+        measurement
+            .resolve_ech("ech.example", TokioInstant::now() + Duration::from_secs(1))
+            .await
+            .unwrap(),
+        b"system-config"
+    );
+    drop(dns);
+    assert!(
+        measurement
+            .resolve_ech("ech.example", TokioInstant::now() + Duration::from_secs(1))
+            .await
+            .is_err()
+    );
+    let dialer = crate::dialer::Dialer::default();
+    let leaf = RuntimeDns::measurement_ech(dialer.clone(), crate::security::SecurityContext::new());
+    assert!(Arc::ptr_eq(&leaf.sources, &dialer.dns_sources()));
+    assert!(matches!(
+        leaf.nameservers[0].address,
+        DnsAddress::Source(crate::config::DnsSource::System)
+    ));
+    assert_eq!(leaf.tcp_pool.max_idle, 0);
+    assert_eq!(leaf.tcp_pool.stats.idle_limit, 0);
+}
diff --git a/src/dns/tests_encrypted.rs b/src/dns/tests_encrypted.rs
new file mode 100644
index 0000000..647ae5b
--- /dev/null
+++ b/src/dns/tests_encrypted.rs
@@ -0,0 +1,286 @@
+use super::*;
+use crate::dispatch::DatagramTransport;
+use async_trait::async_trait;
+
+pub(super) struct Peer {
+    pub(super) tls: Arc<rustls::ServerConfig>,
+    pub(super) https: bool,
+    pub(super) opens: AtomicUsize,
+    pub(super) tasks: StdMutex<Vec<tokio::task::JoinHandle<()>>>,
+}
+#[async_trait]
+impl Dispatcher for Peer {
+    async fn connect_tcp(&self, _: StreamSession) -> Result<BoxStream, DispatchError> {
+        self.opens.fetch_add(1, Ordering::Relaxed);
+        let (client, peer) = tokio::io::duplex(64 * 1024);
+        let tls = self.tls.clone();
+        let https = self.https;
+        self.tasks.lock().unwrap().push(tokio::spawn(async move {
+            let Ok(mut stream) = tokio_rustls::TlsAcceptor::from(tls).accept(peer).await else { return; };
+            for _ in 0..2 {
+                let query = if https {
+                    let mut head = Vec::new();
+                    while !head.ends_with(b"\r\n\r\n") {
+                        let Ok(byte) = stream.read_u8().await else { return; };
+                        head.push(byte);
+                        assert!(head.len() < 16 * 1024);
+                    }
+                    let head = String::from_utf8(head).unwrap();
+                    let target = head.lines().next().unwrap().strip_prefix("GET /dns-query?dns=").unwrap().strip_suffix(" HTTP/1.1").unwrap();
+                    use base64::Engine as _;
+                    let query = base64::engine::general_purpose::URL_SAFE_NO_PAD.decode(target).unwrap();
+                    assert_eq!(&query[..2], &[0, 0]);
+                    query
+                } else {
+                    let Ok(length) = stream.read_u16().await else { return; };
+                    let mut query = vec![0; length as usize];
+                    stream.read_exact(&mut query).await.unwrap();
+                    query
+                };
+                let question = classify_query(&query).unwrap();
+                let response = super::super::synthesize_empty_response(&question, 0).unwrap();
+                if https {
+                    // Chunked replies exercise persistence without detached HTTP drivers.
+                    stream.write_all(format!("HTTP/1.1 200 OK\r\nContent-Type: application/dns-message\r\nTransfer-Encoding: chunked\r\n\r\n{:x}\r\n", response.len()).as_bytes()).await.unwrap();
+                    stream.write_all(&response).await.unwrap();
+                    stream.write_all(b"\r\n0\r\n\r\n").await.unwrap();
+                } else {
+                    stream.write_u16(response.len() as u16).await.unwrap();
+                    stream.write_all(&response).await.unwrap();
+                }
+                stream.flush().await.unwrap();
+            }
+        }));
+        Ok(Box::new(client))
+    }
+    async fn open_datagram(
+        &self,
+        _: DatagramSession,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        Err(DispatchError::NotAllowed)
+    }
+}
+impl Peer {
+    pub(super) async fn join(&self) {
+        let tasks = std::mem::take(&mut *self.tasks.lock().unwrap());
+        for task in tasks {
+            task.await.unwrap();
+        }
+    }
+}
+
+#[tokio::test]
+async fn encrypted_dns_authenticates_and_reuses_tls_and_https_streams() {
+    let certificate = rcgen::generate_simple_self_signed(vec!["dns.example".into()]).unwrap();
+    let server = rustls::ServerConfig::builder_with_provider(Arc::new(
+        rustls::crypto::ring::default_provider(),
+    ))
+    .with_protocol_versions(&[&rustls::version::TLS13])
+    .unwrap()
+    .with_no_client_auth()
+    .with_single_cert(
+        vec![certificate.cert.der().clone()],
+        rustls::pki_types::PrivateKeyDer::Pkcs8(certificate.signing_key.serialize_der().into()),
+    )
+    .unwrap();
+    let mut roots = rustls::RootCertStore::empty();
+    roots.add(certificate.cert.der().clone()).unwrap();
+    for (upstream, alpn) in [
+        ("tls://dns.example", None),
+        ("https://dns.example/dns-query", None),
+        ("https://dns.example/dns-query", Some(b"http/1.1".to_vec())),
+    ] {
+        let mut server = server.clone();
+        server.alpn_protocols = alpn.into_iter().collect();
+        let config = crate::config::Config::parse_yaml(format!("mixed-port: 1080\nhosts: {{dns.example: 192.0.2.1}}\ndns:\n  enable: true\n  use-system-hosts: false\n  nameserver: ['{upstream}']\n").as_bytes()).unwrap();
+        let peer = Arc::new(Peer {
+            tls: Arc::new(server),
+            https: upstream.starts_with("https"),
+            opens: AtomicUsize::new(0),
+            tasks: StdMutex::new(Vec::new()),
+        });
+        let mut dns = RuntimeDns::new(&config.dns, peer.clone());
+        Arc::get_mut(&mut dns.tcp_pool).unwrap().security =
+            crate::security::SecurityContext::with_tls_roots(roots.clone());
+        assert!(dns.resolve("first.example").await.unwrap().is_empty());
+        assert!(dns.resolve("second.example").await.unwrap().is_empty());
+        assert_eq!(peer.opens.load(Ordering::Relaxed), 1);
+        assert_eq!(dns.tcp_pool.snapshot().reuse_hits, 1);
+        peer.join().await;
+        // The same peer's untrusted certificate cannot reach a DNS exchange.
+        let untrusted = RuntimeDns::new(&config.dns, peer.clone());
+        assert!(untrusted.resolve("untrusted.example").await.is_err());
+        peer.join().await;
+    }
+}
+
+struct H2Peer {
+    tls: Arc<rustls::ServerConfig>,
+    opens: AtomicUsize,
+    tasks: StdMutex<Vec<tokio::task::JoinHandle<()>>>,
+}
+
+#[async_trait]
+impl Dispatcher for H2Peer {
+    async fn connect_tcp(&self, _: StreamSession) -> Result<BoxStream, DispatchError> {
+        self.opens.fetch_add(1, Ordering::Relaxed);
+        let (client, peer) = tokio::io::duplex(64 * 1024);
+        let tls = self.tls.clone();
+        self.tasks.lock().unwrap().push(tokio::spawn(async move {
+            let stream = tokio_rustls::TlsAcceptor::from(tls)
+                .accept(peer)
+                .await
+                .unwrap();
+            assert_eq!(stream.get_ref().1.alpn_protocol(), Some(&b"h2"[..]));
+            let mut connection = h2::server::handshake(stream).await.unwrap();
+            let mut pending = Vec::new();
+            // Neither response is sent until both streams arrive on this
+            // connection. Serial H1 or per-query H2 connections cannot pass.
+            for _ in 0..2 {
+                let (request, respond) = connection.accept().await.unwrap().unwrap();
+                assert_eq!(request.method(), http::Method::GET);
+                assert!(request.body().is_end_stream());
+                assert_eq!(request.uri().path(), "/dns/query");
+                assert_eq!(request.headers()["authorization"], "Basic YWxpY2U6cDp3b3Jk");
+                use base64::Engine as _;
+                let query = base64::engine::general_purpose::URL_SAFE_NO_PAD
+                    .decode(request.uri().query().unwrap().strip_prefix("dns=").unwrap())
+                    .unwrap();
+                assert_eq!(&query[..2], &[0, 0]);
+                let question = classify_query(&query).unwrap();
+                pending.push((
+                    super::super::synthesize_empty_response(&question, 0).unwrap(),
+                    respond,
+                ));
+            }
+            for (wire, mut respond) in pending {
+                let response = http::Response::builder()
+                    .status(200)
+                    .header("content-type", "application/dns-message")
+                    .header("content-length", wire.len())
+                    .body(())
+                    .unwrap();
+                respond
+                    .send_response(response, false)
+                    .unwrap()
+                    .send_data(Bytes::from(wire), true)
+                    .unwrap();
+            }
+            while connection.accept().await.transpose().unwrap().is_some() {}
+        }));
+        Ok(Box::new(client))
+    }
+
+    async fn open_datagram(
+        &self,
+        _: DatagramSession,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        Err(DispatchError::NotAllowed)
+    }
+}
+
+#[tokio::test]
+async fn doh_h2_negotiates_multiplexes_and_joins_resolver_drivers() {
+    let certificate = rcgen::generate_simple_self_signed(vec!["dns.example".into()]).unwrap();
+    let mut server = rustls::ServerConfig::builder_with_provider(Arc::new(
+        rustls::crypto::ring::default_provider(),
+    ))
+    .with_protocol_versions(&[&rustls::version::TLS13])
+    .unwrap()
+    .with_no_client_auth()
+    .with_single_cert(
+        vec![certificate.cert.der().clone()],
+        rustls::pki_types::PrivateKeyDer::Pkcs8(certificate.signing_key.serialize_der().into()),
+    )
+    .unwrap();
+    server.alpn_protocols = vec![b"h2".to_vec()];
+    let mut roots = rustls::RootCertStore::empty();
+    roots.add(certificate.cert.der().clone()).unwrap();
+    let peer = Arc::new(H2Peer {
+        tls: Arc::new(server),
+        opens: AtomicUsize::new(0),
+        tasks: StdMutex::new(Vec::new()),
+    });
+    let config = crate::config::Config::parse_yaml(b"mixed-port: 1080\nhosts: {dns.example: 192.0.2.1}\ndns:\n  enable: true\n  use-system-hosts: false\n  nameserver: ['https://alice:p%3Aword@dns.example/dns%2Fquery?discard=value']\n").unwrap();
+    let mut dns = RuntimeDns::new(&config.dns, peer.clone());
+    Arc::get_mut(&mut dns.tcp_pool).unwrap().security =
+        crate::security::SecurityContext::with_tls_roots(roots);
+    let (first, second) = tokio::time::timeout(Duration::from_secs(3), async {
+        tokio::join!(dns.resolve("first.example"), dns.resolve("second.example"))
+    })
+    .await
+    .unwrap();
+    assert!(first.unwrap().is_empty());
+    assert!(second.unwrap().is_empty());
+    assert_eq!(peer.opens.load(Ordering::Relaxed), 1);
+    assert_eq!(dns.tcp_pool.snapshot().reuse_hits, 1);
+    assert_eq!(dns.tcp_pool.snapshot().current_physical, 1);
+    dns.shutdown().await;
+    assert_eq!(dns.tcp_pool.snapshot().current_physical, 0);
+    assert_eq!(dns.tcp_pool.http2.driver_count(), 0);
+    for task in std::mem::take(&mut *peer.tasks.lock().unwrap()) {
+        task.await.unwrap();
+    }
+}
+
+#[tokio::test]
+async fn upstream_tls_options_verify_names_skip_roots_and_disable_only_dot_reuse() {
+    let certificate = rcgen::generate_simple_self_signed(vec!["dns.example".into()]).unwrap();
+    let server = rustls::ServerConfig::builder_with_provider(Arc::new(
+        rustls::crypto::ring::default_provider(),
+    ))
+    .with_protocol_versions(&[&rustls::version::TLS13])
+    .unwrap()
+    .with_no_client_auth()
+    .with_single_cert(
+        vec![certificate.cert.der().clone()],
+        rustls::pki_types::PrivateKeyDer::Pkcs8(certificate.signing_key.serialize_der().into()),
+    )
+    .unwrap();
+    let mut roots = rustls::RootCertStore::empty();
+    roots.add(certificate.cert.der().clone()).unwrap();
+    for (upstream, trusted, succeeds, opens) in [
+        (
+            "tls://192.0.2.1#name-cert-verify=dns.example&disable-reuse=true",
+            true,
+            true,
+            2,
+        ),
+        (
+            "https://192.0.2.1/dns-query#name-cert-verify=dns.example&disable-reuse=true",
+            true,
+            true,
+            1,
+        ),
+        ("tls://192.0.2.1#skip-cert-verify=true", false, true, 1),
+        (
+            "tls://192.0.2.1#name-cert-verify=wrong.example&skip-cert-verify=true",
+            true,
+            false,
+            2,
+        ),
+    ] {
+        let config = crate::config::Config::parse_yaml(format!("mixed-port: 1080\ndns:\n  enable: true\n  use-system-hosts: false\n  nameserver: ['{upstream}']\n").as_bytes()).unwrap();
+        let peer = Arc::new(Peer {
+            tls: Arc::new(server.clone()),
+            https: upstream.starts_with("https"),
+            opens: AtomicUsize::new(0),
+            tasks: StdMutex::new(Vec::new()),
+        });
+        let mut dns = RuntimeDns::new(&config.dns, peer.clone());
+        if trusted {
+            Arc::get_mut(&mut dns.tcp_pool).unwrap().security =
+                crate::security::SecurityContext::with_tls_roots(roots.clone());
+        }
+        for name in ["first.example", "second.example"] {
+            assert_eq!(dns.resolve(name).await.is_ok(), succeeds, "{upstream}");
+        }
+        assert_eq!(peer.opens.load(Ordering::Relaxed), opens, "{upstream}");
+        assert_eq!(
+            dns.tcp_pool.snapshot().current_idle,
+            usize::from(succeeds && opens == 1),
+            "{upstream}"
+        );
+        peer.join().await;
+    }
+}
diff --git a/src/dns/tests_quic.rs b/src/dns/tests_quic.rs
new file mode 100644
index 0000000..e60e4ad
--- /dev/null
+++ b/src/dns/tests_quic.rs
@@ -0,0 +1,815 @@
+//! Actual DoQ/H3 over bounded memory datagrams; no OS sockets or DNS sources.
+use super::*;
+use crate::{
+    dispatch::{DatagramBudget, DatagramTransport},
+    transport::quic::OwnedRuntime,
+};
+use async_trait::async_trait;
+use futures_util::FutureExt;
+use std::panic::{AssertUnwindSafe, resume_unwind};
+use std::{
+    io::IoSliceMut,
+    pin::Pin,
+    task::{Context, Poll, ready},
+};
+use tokio::{
+    sync::{Notify, mpsc},
+    task::JoinSet,
+};
+
+struct Packets {
+    sender: mpsc::Sender<Bytes>,
+    receiver: mpsc::Receiver<Bytes>,
+    peer: SocketAddr,
+    silent: bool,
+    live: Arc<AtomicUsize>,
+    closed: Arc<AtomicUsize>,
+    budget: DatagramBudget,
+    largest_sent: Arc<AtomicUsize>,
+}
+#[async_trait]
+impl DatagramTransport for Packets {
+    fn supports_shared_destinations(&self) -> bool {
+        false
+    }
+
+    fn payload_budget(&self, _: &Destination) -> DatagramBudget {
+        self.budget
+    }
+    async fn send(&mut self, packet: Datagram) -> Result<(), DispatchError> {
+        assert_eq!(packet.remote, Destination::Ip(self.peer));
+        self.largest_sent
+            .fetch_max(packet.payload.len(), Ordering::AcqRel);
+        self.sender
+            .send(packet.payload)
+            .await
+            .map_err(|_| DispatchError::NotAllowed)
+    }
+    async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+        if self.silent {
+            std::future::pending::<()>().await;
+        }
+        Ok(Datagram {
+            remote: self.peer.into(),
+            payload: self
+                .receiver
+                .recv()
+                .await
+                .ok_or(DispatchError::NotAllowed)?,
+            sniffed_domain: None,
+        })
+    }
+    async fn close(&mut self) -> Result<(), DispatchError> {
+        self.closed.fetch_add(1, Ordering::AcqRel);
+        self.receiver.close();
+        Ok(())
+    }
+}
+impl Drop for Packets {
+    fn drop(&mut self) {
+        self.live.fetch_sub(1, Ordering::AcqRel);
+    }
+}
+
+#[derive(Debug)]
+struct PeerSocket {
+    sender: mpsc::Sender<Bytes>,
+    receiver: StdMutex<mpsc::Receiver<Bytes>>,
+    local: SocketAddr,
+    peer: SocketAddr,
+    largest_sent: Arc<AtomicUsize>,
+}
+#[derive(Debug)]
+struct Writable(StdMutex<tokio_util::sync::PollSender<Bytes>>);
+impl quinn::UdpPoller for Writable {
+    fn poll_writable(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let mut sender = self.0.lock().unwrap();
+        if ready!(sender.poll_reserve(cx)).is_ok() {
+            sender.abort_send();
+        }
+        Poll::Ready(Ok(()))
+    }
+}
+impl quinn::AsyncUdpSocket for PeerSocket {
+    fn create_io_poller(self: Arc<Self>) -> Pin<Box<dyn quinn::UdpPoller>> {
+        Box::pin(Writable(StdMutex::new(tokio_util::sync::PollSender::new(
+            self.sender.clone(),
+        ))))
+    }
+    fn try_send(&self, packet: &quinn::udp::Transmit<'_>) -> io::Result<()> {
+        assert_eq!(packet.destination, self.peer);
+        self.largest_sent
+            .fetch_max(packet.contents.len(), Ordering::AcqRel);
+        match self
+            .sender
+            .try_send(Bytes::copy_from_slice(packet.contents))
+        {
+            Ok(()) | Err(mpsc::error::TrySendError::Closed(_)) => Ok(()),
+            Err(mpsc::error::TrySendError::Full(_)) => Err(io::ErrorKind::WouldBlock.into()),
+        }
+    }
+    fn poll_recv(
+        &self,
+        cx: &mut Context<'_>,
+        buffers: &mut [IoSliceMut<'_>],
+        metadata: &mut [quinn::udp::RecvMeta],
+    ) -> Poll<io::Result<usize>> {
+        let Some(packet) = ready!(self.receiver.lock().unwrap().poll_recv(cx)) else {
+            return Poll::Pending;
+        };
+        buffers[0][..packet.len()].copy_from_slice(&packet);
+        metadata[0] = quinn::udp::RecvMeta {
+            addr: self.peer,
+            len: packet.len(),
+            stride: packet.len(),
+            ecn: None,
+            dst_ip: Some(self.local.ip()),
+        };
+        Poll::Ready(Ok(1))
+    }
+    fn local_addr(&self) -> io::Result<SocketAddr> {
+        Ok(self.local)
+    }
+}
+
+#[derive(Clone, Copy)]
+enum Tcp {
+    Http,
+    Pending,
+}
+#[derive(Clone, Copy)]
+enum Udp {
+    Ready,
+    Silent,
+    Unavailable,
+}
+#[derive(Clone, Copy)]
+enum H3Reply {
+    Normal,
+    HoldHeaders,
+    HoldBody,
+    LargeHeaders,
+    Goaway,
+}
+
+struct Peer {
+    h1: encrypted_tests::Peer,
+    tls: rustls::ServerConfig,
+    protocol: super::super::quic::Kind,
+    tcp: Tcp,
+    udp: Udp,
+    tcp_calls: AtomicUsize,
+    tls_hello: Arc<AtomicUsize>,
+    udp_calls: AtomicUsize,
+    live: Arc<AtomicUsize>,
+    closed: Arc<AtomicUsize>,
+    udp_budget: DatagramBudget,
+    initial_udp_payload: u16,
+    h3_reply: H3Reply,
+    response_ready: Arc<Notify>,
+    response_release: Arc<Notify>,
+    rejected: Arc<AtomicUsize>,
+    largest_client_sent: Arc<AtomicUsize>,
+    largest_server_sent: Arc<AtomicUsize>,
+    requests: Arc<AtomicUsize>,
+    cancel: CancellationToken,
+    tasks: StdMutex<Vec<tokio::task::JoinHandle<()>>>,
+}
+#[async_trait]
+impl Dispatcher for Peer {
+    async fn connect_tcp(&self, session: StreamSession) -> Result<BoxStream, DispatchError> {
+        self.tcp_calls.fetch_add(1, Ordering::AcqRel);
+        if matches!(self.tcp, Tcp::Http) {
+            return self.h1.connect_tcp(session).await;
+        }
+        let (client, mut peer) = tokio::io::duplex(64 * 1024);
+        let hello = self.tls_hello.clone();
+        let cancel = self.cancel.clone();
+        self.tasks.lock().unwrap().push(tokio::spawn(async move {
+            if peer.read_u8().await.is_ok() { hello.fetch_add(1, Ordering::AcqRel); }
+            let mut sink = tokio::io::sink();
+            let _ = tokio::select! { ()=cancel.cancelled()=>Ok(0), result=tokio::io::copy(&mut peer, &mut sink)=>result };
+        }));
+        Ok(Box::new(client))
+    }
+    async fn open_datagram(
+        &self,
+        _: DatagramSession,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        self.udp_calls.fetch_add(1, Ordering::AcqRel);
+        if matches!(self.udp, Udp::Unavailable) {
+            return Err(DispatchError::NotAllowed);
+        }
+        let peer_address: SocketAddr = "192.0.2.1:853".parse().unwrap();
+        let client_address: SocketAddr = "192.0.2.2:1234".parse().unwrap();
+        let (to_peer, from_client) = mpsc::channel(32);
+        let (to_client, from_peer) = mpsc::channel(32);
+        let socket = Arc::new(PeerSocket {
+            sender: to_client,
+            receiver: StdMutex::new(from_client),
+            local: peer_address,
+            peer: client_address,
+            largest_sent: self.largest_server_sent.clone(),
+        });
+        let mut tls = self.tls.clone();
+        tls.alpn_protocols = vec![if matches!(self.protocol, super::super::quic::Kind::Doq) {
+            b"doq".to_vec()
+        } else {
+            b"h3".to_vec()
+        }];
+        let crypto = quinn::crypto::rustls::QuicServerConfig::try_from(tls).unwrap();
+        let mut config = quinn::ServerConfig::with_crypto(Arc::new(crypto));
+        Arc::get_mut(&mut config.transport)
+            .unwrap()
+            .initial_mtu(self.initial_udp_payload)
+            .min_mtu(self.initial_udp_payload)
+            .mtu_discovery_config(None);
+        let runtime = Arc::new(OwnedRuntime::new(CancellationToken::new()));
+        let mut endpoint_config = quinn::EndpointConfig::default();
+        if u64::from(self.udp_budget.transmit()) > endpoint_config.get_max_udp_payload_size() {
+            endpoint_config
+                .max_udp_payload_size(self.udp_budget.transmit())
+                .unwrap();
+        }
+        let endpoint = quinn::Endpoint::new_with_abstract_socket(
+            endpoint_config,
+            Some(config),
+            socket,
+            runtime.clone(),
+        )
+        .unwrap();
+        let cancel = self.cancel.clone();
+        let protocol = self.protocol;
+        let requests = self.requests.clone();
+        let reply = self.h3_reply;
+        let response_ready = self.response_ready.clone();
+        let response_release = self.response_release.clone();
+        let rejected = self.rejected.clone();
+        self.tasks.lock().unwrap().push(tokio::spawn(async move {
+            let mut responses = JoinSet::new();
+            let serve = async {
+                let Ok(connection) = endpoint.accept().await.unwrap().await else {
+                    return;
+                };
+                if matches!(protocol, super::super::quic::Kind::Doq) {
+                    while let Ok((mut send, mut receive)) = connection.accept_bi().await {
+                        let length = receive.read_u16().await.unwrap() as usize;
+                        assert!(length <= MAX_MESSAGE_SIZE);
+                        let mut query = vec![0; length];
+                        receive.read_exact(&mut query).await.unwrap();
+                        assert!(receive.read(&mut [0; 1]).await.unwrap().is_none());
+                        let response = response(&query);
+                        requests.fetch_add(1, Ordering::AcqRel);
+                        send.write_all(&(response.len() as u16).to_be_bytes())
+                            .await
+                            .unwrap();
+                        send.write_all(&response).await.unwrap();
+                        send.finish().unwrap();
+                    }
+                } else {
+                    let mut h3 = h3::server::builder()
+                        .build::<_, Bytes>(h3_quinn::Connection::new(connection))
+                        .await
+                        .unwrap();
+                    while let Ok(Some(request)) = h3.accept().await {
+                        let (request, mut stream) = request.resolve_request().await.unwrap();
+                        assert_eq!(request.method(), http::Method::GET);
+                        assert_eq!(request.uri().path(), "/dns-query");
+                        assert_eq!(request.headers()["authorization"], "Basic YWxpY2U6cHc=");
+                        assert!(stream.recv_data().await.unwrap().is_none());
+                        use base64::Engine as _;
+                        let query = base64::engine::general_purpose::URL_SAFE_NO_PAD
+                            .decode(request.uri().query().unwrap().strip_prefix("dns=").unwrap())
+                            .unwrap();
+                        let wire = response(&query);
+                        let first = requests.fetch_add(1, Ordering::AcqRel) == 0;
+                        if matches!(reply, H3Reply::Goaway) {
+                            h3.shutdown(0).await.unwrap();
+                        }
+                        let response_ready = response_ready.clone();
+                        let response_release = response_release.clone();
+                        let rejected = rejected.clone();
+                        responses.spawn(async move {
+                            let held = first && matches!(reply,
+                                H3Reply::HoldHeaders | H3Reply::HoldBody | H3Reply::Goaway);
+                            if held && matches!(reply, H3Reply::HoldHeaders) {
+                                response_ready.notify_one();
+                                response_release.notified().await;
+                            }
+                            let mut headers = http::Response::builder()
+                                .status(200)
+                                .header("content-type", "application/dns-message");
+                            if matches!(reply, H3Reply::LargeHeaders) {
+                                headers = headers.header("x-fixture", "x".repeat(8192));
+                            }
+                            let outcome = async {
+                                stream.send_response(headers.body(()).unwrap()).await?;
+                                if held && !matches!(reply, H3Reply::HoldHeaders) {
+                                    response_ready.notify_one();
+                                    response_release.notified().await;
+                                }
+                                if held && !matches!(reply, H3Reply::Goaway) {
+                                    // Exceed one receive window so the peer must
+                                    // observe STOP rather than enqueueing a tiny response.
+                                    stream.send_data(Bytes::from(vec![0; 128 * 1024])).await?;
+                                } else {
+                                    stream.send_data(Bytes::from(wire)).await?;
+                                }
+                                stream.finish().await
+                            }.await;
+                            if held && !matches!(reply, H3Reply::Goaway) {
+                                assert!(matches!(&outcome,
+                                    Err(h3::error::StreamError::RemoteTerminate { code })
+                                    if code.value() == 0),
+                                    "query receive Drop must stop only this peer response: {outcome:?}");
+                                rejected.fetch_add(1, Ordering::AcqRel);
+                            } else {
+                                outcome.unwrap();
+                            }
+                        });
+                    }
+                }
+            };
+            tokio::select! { biased; ()=cancel.cancelled()=>{}, ()=serve=>{} }
+            responses.abort_all();
+            let mut failure = None;
+            while let Some(result) = responses.join_next().await {
+                if let Err(error) = result && error.is_panic() && failure.is_none() {
+                    failure = Some(error.into_panic());
+                }
+            }
+            endpoint.close(0_u8.into(), b"");
+            runtime.stop().await;
+            if let Some(failure) = failure { resume_unwind(failure); }
+        }));
+        self.live.fetch_add(1, Ordering::AcqRel);
+        Ok(Box::new(Packets {
+            sender: to_peer,
+            receiver: from_peer,
+            peer: peer_address,
+            silent: matches!(self.udp, Udp::Silent),
+            live: self.live.clone(),
+            closed: self.closed.clone(),
+            budget: self.udp_budget,
+            largest_sent: self.largest_client_sent.clone(),
+        }))
+    }
+}
+fn response(query: &[u8]) -> Vec<u8> {
+    assert_eq!(&query[..2], &[0, 0]);
+    assert_eq!(
+        u16::from_be_bytes([query[10], query[11]]),
+        1,
+        "ECS wrapper survives ID normalization"
+    );
+    super::super::synthesize_empty_response(&classify_query(query).unwrap(), 0).unwrap()
+}
+impl Peer {
+    fn new(
+        protocol: super::super::quic::Kind,
+        tcp: Tcp,
+        udp: Udp,
+    ) -> (Arc<Self>, rustls::RootCertStore) {
+        let certificate = rcgen::generate_simple_self_signed(vec!["dns.example".into()]).unwrap();
+        let tls = rustls::ServerConfig::builder_with_provider(Arc::new(
+            rustls::crypto::ring::default_provider(),
+        ))
+        .with_protocol_versions(&[&rustls::version::TLS13])
+        .unwrap()
+        .with_no_client_auth()
+        .with_single_cert(
+            vec![certificate.cert.der().clone()],
+            rustls::pki_types::PrivateKeyDer::Pkcs8(certificate.signing_key.serialize_der().into()),
+        )
+        .unwrap();
+        let mut roots = rustls::RootCertStore::empty();
+        roots.add(certificate.cert.der().clone()).unwrap();
+        (
+            Arc::new(Self {
+                h1: encrypted_tests::Peer {
+                    tls: Arc::new(tls.clone()),
+                    https: true,
+                    opens: AtomicUsize::new(0),
+                    tasks: StdMutex::new(Vec::new()),
+                },
+                tls,
+                protocol,
+                tcp,
+                udp,
+                tcp_calls: AtomicUsize::new(0),
+                tls_hello: Arc::new(AtomicUsize::new(0)),
+                udp_calls: AtomicUsize::new(0),
+                live: Arc::new(AtomicUsize::new(0)),
+                closed: Arc::new(AtomicUsize::new(0)),
+                udp_budget: DatagramBudget::new(1400, 1400),
+                initial_udp_payload: 1200,
+                h3_reply: H3Reply::Normal,
+                response_ready: Arc::new(Notify::new()),
+                response_release: Arc::new(Notify::new()),
+                rejected: Arc::new(AtomicUsize::new(0)),
+                largest_client_sent: Arc::new(AtomicUsize::new(0)),
+                largest_server_sent: Arc::new(AtomicUsize::new(0)),
+                requests: Arc::new(AtomicUsize::new(0)),
+                cancel: CancellationToken::new(),
+                tasks: StdMutex::new(Vec::new()),
+            }),
+            roots,
+        )
+    }
+    async fn stop(&self) {
+        self.cancel.cancel();
+        let mut failure = None;
+        for task in std::mem::take(&mut *self.tasks.lock().unwrap()) {
+            if let Err(error) = task.await {
+                if error.is_panic() && failure.is_none() {
+                    failure = Some(error.into_panic());
+                }
+            }
+        }
+        self.h1.join().await;
+        if let Some(failure) = failure {
+            resume_unwind(failure);
+        }
+    }
+}
+fn resolver(
+    peer: Arc<Peer>,
+    roots: rustls::RootCertStore,
+    upstream: &str,
+    prefer: bool,
+) -> Arc<RuntimeDns> {
+    let config = crate::config::Config::parse_yaml(format!("mixed-port: 1080\ndns:\n  enable: true\n  prefer-h3: {prefer}\n  use-system-hosts: false\n  nameserver: ['{upstream}']\n").as_bytes()).unwrap();
+    let mut dns = RuntimeDns::new(&config.dns, peer);
+    Arc::get_mut(&mut dns.tcp_pool).unwrap().security =
+        crate::security::SecurityContext::with_tls_roots(roots);
+    Arc::new(dns)
+}
+async fn two_queries(dns: &RuntimeDns) {
+    for (id, name) in [(0x1234, "first.example"), (0x2345, "second.example")] {
+        let query = build_query(id, name, QueryType::A).unwrap();
+        let wire = dns.exchange(&query).await.unwrap();
+        assert_eq!(&wire[..2], &query[..2]);
+        validate_response_identity(&parse_query(&query).unwrap(), &wire).unwrap();
+    }
+}
+
+// Always join both owners before rethrowing a primary assertion or timeout.
+async fn checked(peer: &Peer, dns: &RuntimeDns, future: impl Future<Output = ()>) {
+    let result = AssertUnwindSafe(tokio::time::timeout(Duration::from_secs(5), future))
+        .catch_unwind()
+        .await;
+    let cleanup = AssertUnwindSafe(async {
+        let dns_stopped = tokio::time::timeout(Duration::from_secs(3), dns.shutdown()).await;
+        let peer_stopped = tokio::time::timeout(Duration::from_secs(3), peer.stop()).await;
+        dns_stopped.unwrap();
+        peer_stopped.unwrap();
+        assert_eq!(dns.tcp_pool.quic.task_count(), 0);
+        assert_eq!(peer.live.load(Ordering::Acquire), 0);
+    })
+    .catch_unwind()
+    .await;
+    match result {
+        Err(error) => resume_unwind(error),
+        Ok(Err(error)) => panic!("DNS memory exchange exceeded its bound: {error}"),
+        Ok(Ok(())) => {}
+    }
+    if let Err(error) = cleanup {
+        resume_unwind(error);
+    }
+}
+
+fn literal_server(dns: &RuntimeDns) -> ResolvedNameserver {
+    let config = dns.nameservers[0].clone();
+    ResolvedNameserver {
+        endpoint: config.endpoint(),
+        config,
+        physical: None,
+        source_generation: 0,
+        source_binding: None,
+    }
+}
+
+async fn wait_until(mut ready: impl FnMut() -> bool) {
+    tokio::time::timeout(Duration::from_secs(2), async {
+        while !ready() {
+            tokio::task::yield_now().await;
+        }
+    })
+    .await
+    .unwrap();
+}
+
+#[tokio::test]
+async fn dns_quic_doq_and_forced_h3_exchange_real_frames_reuse_and_stop() {
+    for (kind, endpoint) in [
+        (
+            super::super::quic::Kind::Doq,
+            "quic://192.0.2.1:853#name-cert-verify=dns.example&ecs=192.0.2.1",
+        ),
+        (
+            super::super::quic::Kind::H3,
+            "https://alice:pw@192.0.2.1:853/dns-query?discard=value#h3=true&name-cert-verify=dns.example&ecs=192.0.2.1",
+        ),
+    ] {
+        let (peer, roots) = Peer::new(kind, Tcp::Pending, Udp::Ready);
+        let dns = resolver(peer.clone(), roots, endpoint, false);
+        two_queries(&dns).await;
+        assert_eq!(peer.requests.load(Ordering::Acquire), 2);
+        assert_eq!(peer.udp_calls.load(Ordering::Acquire), 1);
+        assert_eq!(peer.tcp_calls.load(Ordering::Acquire), 0);
+        dns.shutdown().await;
+        assert_eq!(dns.tcp_pool.quic.task_count(), 0);
+        assert_eq!(peer.live.load(Ordering::Acquire), 0);
+        assert_eq!(peer.closed.load(Ordering::Acquire), 1);
+        peer.stop().await;
+    }
+}
+
+#[tokio::test]
+async fn dns_quic_directional_mtu_keeps_initial_small_and_receives_larger_peer_packets() {
+    for (kind, upstream) in [
+        (
+            super::super::quic::Kind::Doq,
+            "quic://192.0.2.1:853#name-cert-verify=dns.example&ecs=192.0.2.1",
+        ),
+        (
+            super::super::quic::Kind::H3,
+            "https://alice:pw@192.0.2.1:853/dns-query#h3=true&name-cert-verify=dns.example&ecs=192.0.2.1",
+        ),
+    ] {
+        let (mut peer, roots) = Peer::new(kind, Tcp::Pending, Udp::Ready);
+        let config = Arc::get_mut(&mut peer).unwrap();
+        config.udp_budget = DatagramBudget::new(1200, 4096);
+        config.initial_udp_payload = 1280;
+        let dns = resolver(peer.clone(), roots, upstream, false);
+        checked(&peer, &dns, async {
+            two_queries(&dns).await;
+            assert_eq!(peer.requests.load(Ordering::Acquire), 2);
+            assert_eq!(peer.udp_calls.load(Ordering::Acquire), 1);
+            let client_payload = peer.largest_client_sent.load(Ordering::Acquire);
+            assert!((1..=1200).contains(&client_payload));
+            assert!(peer.largest_server_sent.load(Ordering::Acquire) >= 1280);
+        })
+        .await;
+    }
+}
+
+#[cfg(feature = "outbound-wireguard")]
+#[tokio::test]
+async fn dns_quic_private_node_preserves_forced_h3_wrappers_and_stop() {
+    use base64::{Engine as _, engine::general_purpose::STANDARD};
+    let config = crate::config::Config::parse_yaml(format!(
+        "mixed-port: 1080\ndns: {{prefer-h3: true}}\nproxies: [{{name: wg, type: wireguard, server: 198.51.100.1, port: 51820, ip: 10.0.0.2, private-key: '{}', public-key: '{}', remote-dns-resolve: true, dns: ['https://alice:pw@192.0.2.1:853/dns-query#undeclared%26h3=true%26name-cert-verify=dns.example%26ecs=192.0.2.1%26disable-ipv6=true']}}]",
+        STANDARD.encode([1; 32]), STANDARD.encode([2; 32])
+    ).as_bytes()).unwrap();
+    assert!(config.dns.prefer_h3);
+    let crate::config::ProxyProtocol::WireGuard(node) = &config.proxies[0].protocol else {
+        panic!("expected WireGuard")
+    };
+    // Match the production private-resolver construction; global DNS options
+    // are not copied into this node's independently owned configuration.
+    let private = crate::config::DnsConfig {
+        enable: true,
+        ipv6: true,
+        nameservers: node.dns.clone(),
+        use_hosts: false,
+        use_system_hosts: false,
+        ..Default::default()
+    };
+    let (peer, roots) = Peer::new(super::super::quic::Kind::H3, Tcp::Pending, Udp::Ready);
+    let dns = RuntimeDns::new_for_node(
+        &private,
+        peer.clone(),
+        super::super::resolution::ResolutionContext::default(),
+        crate::security::SecurityContext::with_tls_roots(roots),
+    );
+    assert!(!dns.prefer_h3);
+    let blocked = build_query(9, "blocked.example", QueryType::Aaaa).unwrap();
+    let blocked = dns.exchange(&blocked).await.unwrap();
+    assert_eq!(&blocked[6..12], &[0; 6]);
+    assert_eq!(peer.udp_calls.load(Ordering::Acquire), 0);
+    two_queries(&dns).await;
+    assert_eq!(peer.requests.load(Ordering::Acquire), 2);
+    assert_eq!(peer.tcp_calls.load(Ordering::Acquire), 0);
+    dns.shutdown().await;
+    assert_eq!(dns.tcp_pool.quic.task_count(), 0);
+    assert_eq!(peer.live.load(Ordering::Acquire), 0);
+    peer.stop().await;
+}
+
+#[tokio::test]
+async fn dns_quic_prefer_h3_races_success_and_cleans_losers_without_reprobing() {
+    for (tcp, udp, expects_h3) in [
+        (Tcp::Pending, Udp::Ready, true),
+        (Tcp::Http, Udp::Silent, false),
+        (Tcp::Http, Udp::Unavailable, false),
+    ] {
+        let (peer, roots) = Peer::new(super::super::quic::Kind::H3, tcp, udp);
+        let dns = resolver(
+            peer.clone(),
+            roots,
+            "https://alice:pw@192.0.2.1:853/dns-query#name-cert-verify=dns.example&ecs=192.0.2.1",
+            true,
+        );
+        two_queries(&dns).await;
+        assert_eq!(peer.tcp_calls.load(Ordering::Acquire), 1);
+        assert_eq!(peer.udp_calls.load(Ordering::Acquire), 1);
+        assert_eq!(
+            peer.requests.load(Ordering::Acquire),
+            if expects_h3 { 2 } else { 0 }
+        );
+        if expects_h3 {
+            assert_eq!(peer.tls_hello.load(Ordering::Acquire), 1);
+        }
+        dns.shutdown().await;
+        assert_eq!(peer.live.load(Ordering::Acquire), 0);
+        assert_eq!(dns.tcp_pool.quic.task_count(), 0);
+        peer.stop().await;
+    }
+}
+
+#[tokio::test]
+async fn dns_quic_forced_failure_does_not_fallback_and_stop_joins_canceled_handshake() {
+    let (peer, roots) = Peer::new(super::super::quic::Kind::H3, Tcp::Http, Udp::Unavailable);
+    let dns = resolver(
+        peer.clone(),
+        roots,
+        "https://alice:pw@192.0.2.1:853/dns-query#h3=true&name-cert-verify=dns.example",
+        true,
+    );
+    assert!(dns.resolve("first.example").await.is_err());
+    assert_eq!(peer.tcp_calls.load(Ordering::Acquire), 0);
+    dns.shutdown().await;
+    peer.stop().await;
+    for (kind, upstream) in [
+        (
+            super::super::quic::Kind::Doq,
+            "quic://192.0.2.1:853#name-cert-verify=dns.example",
+        ),
+        (
+            super::super::quic::Kind::H3,
+            "https://alice:pw@192.0.2.1:853/dns-query#h3=true&name-cert-verify=dns.example",
+        ),
+    ] {
+        let (peer, roots) = Peer::new(kind, Tcp::Pending, Udp::Silent);
+        let dns = resolver(peer.clone(), roots, upstream, false);
+        checked(&peer, &dns, async {
+            let request_dns = dns.clone();
+            let request = tokio_util::task::AbortOnDropHandle::new(tokio::spawn(async move {
+                request_dns.resolve("first.example").await
+            }));
+            wait_until(|| peer.udp_calls.load(Ordering::Acquire) != 0).await;
+            request.abort();
+            assert!(request.await.unwrap_err().is_cancelled());
+        })
+        .await;
+        assert_eq!(peer.closed.load(Ordering::Acquire), 1);
+        assert_eq!(peer.requests.load(Ordering::Acquire), 0);
+    }
+}
+
+#[tokio::test]
+async fn dns_quic_h3_canceled_response_preserves_sibling_and_connection() {
+    for reply in [H3Reply::HoldHeaders, H3Reply::HoldBody] {
+        let (mut peer, roots) = Peer::new(super::super::quic::Kind::H3, Tcp::Pending, Udp::Ready);
+        Arc::get_mut(&mut peer).unwrap().h3_reply = reply;
+        let dns = resolver(
+            peer.clone(),
+            roots,
+            "https://alice:pw@192.0.2.1:853/dns-query#h3=true&name-cert-verify=dns.example&ecs=192.0.2.1",
+            false,
+        );
+        checked(&peer, &dns, async {
+            let request_dns = dns.clone();
+            let query = build_query(1, "cancel.example", QueryType::A).unwrap();
+            let request = tokio_util::task::AbortOnDropHandle::new(tokio::spawn(async move {
+                request_dns.exchange(&query).await
+            }));
+            peer.response_ready.notified().await;
+            assert!(
+                !request.is_finished(),
+                "the peer has withheld the selected response phase"
+            );
+            request.abort();
+            assert!(request.await.unwrap_err().is_cancelled());
+            two_queries(&dns).await;
+            assert_eq!(peer.udp_calls.load(Ordering::Acquire), 1);
+            assert_eq!(peer.requests.load(Ordering::Acquire), 3);
+            peer.response_release.notify_one();
+            wait_until(|| peer.rejected.load(Ordering::Acquire) == 1).await;
+        })
+        .await;
+        assert_eq!(peer.closed.load(Ordering::Acquire), 1);
+    }
+}
+
+#[tokio::test]
+async fn dns_quic_h3_large_headers_progress_with_small_stream_credit() {
+    let (mut peer, roots) = Peer::new(super::super::quic::Kind::H3, Tcp::Pending, Udp::Ready);
+    Arc::get_mut(&mut peer).unwrap().h3_reply = H3Reply::LargeHeaders;
+    let dns = resolver(
+        peer.clone(),
+        roots,
+        "https://alice:pw@192.0.2.1:853/dns-query#h3=true&name-cert-verify=dns.example&ecs=192.0.2.1",
+        false,
+    );
+    checked(&peer, &dns, async {
+        // The peer sends an 8192-byte field within the 16KiB header limit,
+        // while each native receive stream starts with only 4098-byte credit.
+        // Normal SETTINGS/control and two complete response frames must progress.
+        two_queries(&dns).await;
+        assert_eq!(peer.requests.load(Ordering::Acquire), 2);
+        assert_eq!(peer.udp_calls.load(Ordering::Acquire), 1);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn dns_quic_h3_goaway_drains_existing_query_and_opens_new_connection() {
+    let (mut peer, roots) = Peer::new(super::super::quic::Kind::H3, Tcp::Pending, Udp::Ready);
+    Arc::get_mut(&mut peer).unwrap().h3_reply = H3Reply::Goaway;
+    let dns = resolver(
+        peer.clone(),
+        roots,
+        "https://alice:pw@192.0.2.1:853/dns-query#h3=true&name-cert-verify=dns.example&ecs=192.0.2.1",
+        false,
+    );
+    checked(&peer, &dns, async {
+        let server = literal_server(&dns);
+        let (key, _) = dns.quic_route(&server).unwrap();
+        let old_lease = dns
+            .start_quic(&server, super::super::quic::Kind::H3)
+            .unwrap()
+            .finish()
+            .await
+            .unwrap();
+        let request_dns = dns.clone();
+        let first_query = build_query(11, "first.example", QueryType::A).unwrap();
+        let request = tokio_util::task::AbortOnDropHandle::new(tokio::spawn(async move {
+            request_dns.exchange(&first_query).await
+        }));
+        peer.response_ready.notified().await;
+        wait_until(|| !dns.tcp_pool.quic.has(&key)).await;
+        assert!(
+            !request.is_finished(),
+            "GOAWAY must not complete or cancel the existing query"
+        );
+        let query = build_query(12, "second.example", QueryType::A).unwrap();
+        let wire = dns.exchange(&query).await.unwrap();
+        validate_response_identity(&parse_query(&query).unwrap(), &wire).unwrap();
+        assert_eq!(peer.udp_calls.load(Ordering::Acquire), 2);
+        peer.response_release.notify_one();
+        let wire = request.await.unwrap().unwrap();
+        assert_eq!(&wire[..2], &11_u16.to_be_bytes());
+        assert_eq!(peer.requests.load(Ordering::Acquire), 2);
+        drop(old_lease);
+    })
+    .await;
+    assert_eq!(peer.closed.load(Ordering::Acquire), 2);
+}
+
+#[tokio::test]
+async fn dns_quic_unpublished_h3_initialization_cancel_joins_without_query() {
+    let (peer, roots) = Peer::new(super::super::quic::Kind::H3, Tcp::Pending, Udp::Ready);
+    let dns = resolver(
+        peer.clone(),
+        roots,
+        "https://alice:pw@192.0.2.1:853/dns-query#h3=true&name-cert-verify=dns.example",
+        false,
+    );
+    checked(&peer, &dns, async {
+        let server = literal_server(&dns);
+        let mut pending = dns
+            .start_quic(&server, super::super::quic::Kind::H3)
+            .unwrap();
+        pending.wait_ready().await.unwrap();
+        // It has completed TLS/H3 setup, but no lease or query was published.
+        pending.cancel().await;
+        assert!(dns.cached_quic(&server).unwrap().is_none());
+        assert_eq!(peer.live.load(Ordering::Acquire), 0);
+        assert_eq!(peer.closed.load(Ordering::Acquire), 1);
+        assert_eq!(peer.requests.load(Ordering::Acquire), 0);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn dns_quic_invalid_prepare_budget_closes_unattached_transport() {
+    for kind in [super::super::quic::Kind::Doq, super::super::quic::Kind::H3] {
+        let (mut peer, roots) = Peer::new(kind, Tcp::Pending, Udp::Ready);
+        Arc::get_mut(&mut peer).unwrap().udp_budget = DatagramBudget::new(1199, 1400);
+        let upstream = if matches!(kind, super::super::quic::Kind::Doq) {
+            "quic://192.0.2.1:853#name-cert-verify=dns.example"
+        } else {
+            "https://alice:pw@192.0.2.1:853/dns-query#h3=true&name-cert-verify=dns.example"
+        };
+        let dns = resolver(peer.clone(), roots, upstream, false);
+        checked(&peer, &dns, async {
+            assert!(dns.resolve("first.example").await.is_err());
+            assert_eq!(peer.closed.load(Ordering::Acquire), 1);
+            assert_eq!(peer.live.load(Ordering::Acquire), 0);
+            assert_eq!(peer.requests.load(Ordering::Acquire), 0);
+        })
+        .await;
+    }
+}
diff --git a/src/dns/trace.rs b/src/dns/trace.rs
new file mode 100644
index 0000000..c8232c7
--- /dev/null
+++ b/src/dns/trace.rs
@@ -0,0 +1,24 @@
+//! Bounded, request-local path labels. No addresses, questions or credentials.
+use std::{future::Future, sync::Mutex};
+tokio::task_local! { static TRACE: Mutex<Vec<&'static str>>; }
+pub(crate) fn record(step: &'static str) {
+    let _ = TRACE.try_with(|trace| {
+        let mut trace = trace.lock().unwrap();
+        if trace.len() < 32 {
+            trace.push(step);
+        }
+    });
+}
+pub(crate) fn snapshot() -> Vec<&'static str> {
+    TRACE
+        .try_with(|trace| trace.lock().unwrap().clone())
+        .unwrap_or_default()
+}
+pub(crate) async fn capture<T>(future: impl Future<Output = T>) -> (T, Vec<&'static str>) {
+    TRACE
+        .scope(Mutex::new(Vec::new()), async {
+            let result = future.await;
+            (result, snapshot())
+        })
+        .await
+}
diff --git a/src/geodata/asn.rs b/src/geodata/asn.rs
new file mode 100644
index 0000000..8019ff0
--- /dev/null
+++ b/src/geodata/asn.rs
@@ -0,0 +1,123 @@
+//! One owned MMDB, with direct index lookups and no address cache.
+
+use std::{io::Read, net::IpAddr, path::Path};
+
+use maxminddb::Reader;
+
+use super::{GeoDataError, GeoDataKind, open_asset};
+
+#[derive(Debug, Clone, Copy)]
+enum Format {
+    Numeric,
+    IpInfo,
+}
+
+impl Format {
+    fn parse(value: &str) -> Result<Self, GeoDataError> {
+        match value {
+            "GeoLite2-ASN" | "DBIP-ASN-Lite (compat=GeoLite2-ASN)" => Ok(Self::Numeric),
+            "ipinfo generic_asn_free.mmdb" => Ok(Self::IpInfo),
+            _ => invalid("unsupported ASN database type"),
+        }
+    }
+}
+
+pub(super) struct AsnDb {
+    reader: Reader<Vec<u8>>,
+    format: Format,
+    capacity: usize,
+}
+
+impl AsnDb {
+    pub(super) fn load(dir: &Path) -> Result<Self, GeoDataError> {
+        AsnCandidate::load(dir)?.into_database()
+    }
+
+    pub(super) fn capacity(&self) -> usize {
+        self.capacity
+    }
+
+    pub(super) fn matches(&self, payload: &str, address: IpAddr) -> bool {
+        let Ok(record) = self.reader.lookup(address) else {
+            return false;
+        };
+        match self.format {
+            Format::Numeric => {
+                let number = if !record.has_data() {
+                    0
+                } else {
+                    match record.decode_path::<u32>(&maxminddb::path!["autonomous_system_number"]) {
+                        Ok(Some(value)) => value,
+                        // Malformed/missing fields are not a legitimate absent network.
+                        _ => return false,
+                    }
+                };
+                canonical_number_matches(payload, number)
+            }
+            Format::IpInfo => record
+                .decode_path::<&str>(&maxminddb::path!["asn"])
+                .ok()
+                .flatten()
+                .and_then(|value| value.strip_prefix("AS"))
+                .is_some_and(|value| value == payload),
+        }
+    }
+}
+
+/// Verified candidate storage. Verification borrows this buffer while the
+/// old database remains available; ownership transfers only after retirement.
+pub(super) struct AsnCandidate {
+    bytes: Vec<u8>,
+    format: Format,
+}
+impl AsnCandidate {
+    pub(super) fn load(dir: &Path) -> Result<Self, GeoDataError> {
+        let (mut file, len) = open_asset(dir, GeoDataKind::Asn)?;
+        let len = usize::try_from(len)
+            .map_err(|_| GeoDataError::AllocationFailed { bytes: usize::MAX })?;
+        let mut bytes = Vec::new();
+        bytes
+            .try_reserve_exact(len)
+            .map_err(|_| GeoDataError::AllocationFailed { bytes: len })?;
+        bytes.resize(len, 0);
+        file.read_exact(&mut bytes)
+            .map_err(|source| super::io_error(GeoDataKind::Asn, source))?;
+        let format = {
+            let reader =
+                Reader::from_source(bytes.as_slice()).map_err(|_| error("invalid ASN MMDB"))?;
+            let format = Format::parse(&reader.metadata().database_type)?;
+            reader
+                .verify()
+                .map_err(|_| error("invalid ASN MMDB index or data"))?;
+            format
+        };
+        Ok(Self { bytes, format })
+    }
+
+    pub(super) fn into_database(self) -> Result<AsnDb, GeoDataError> {
+        let capacity = self.bytes.capacity();
+        // Moves the already verified bytes without a second full buffer or
+        // another graph verification. Only reader metadata is reconstructed.
+        let reader = Reader::from_source(self.bytes).map_err(|_| error("invalid ASN MMDB"))?;
+        Ok(AsnDb {
+            reader,
+            format: self.format,
+            capacity,
+        })
+    }
+}
+
+fn canonical_number_matches(payload: &str, number: u32) -> bool {
+    !payload.is_empty()
+        && payload.len() <= 10
+        && payload.bytes().all(|byte| byte.is_ascii_digit())
+        && (payload.len() == 1 || !payload.starts_with('0'))
+        && payload.parse::<u32>().ok() == Some(number)
+}
+
+fn error(detail: &str) -> GeoDataError {
+    GeoDataError::InvalidAsn(detail.to_owned())
+}
+fn invalid<T>(detail: &str) -> Result<T, GeoDataError> {
+    Err(error(detail))
+}
diff --git a/src/geodata/asn_tests.rs b/src/geodata/asn_tests.rs
new file mode 100644
index 0000000..5ee55ad
--- /dev/null
+++ b/src/geodata/asn_tests.rs
@@ -0,0 +1,134 @@
+use std::{fs, sync::Arc};
+
+use super::*;
+use crate::{
+    config::{Config, Network, RuleAction},
+    routing::{RoutingContext, RuleEvaluation, RuleSet},
+    session::Destination,
+};
+
+pub(super) const FIXTURE: &[u8] =
+    include_bytes!("../../tests/fixtures/geodata/GeoLite2-ASN-Test.mmdb");
+
+fn rule(kind: RuleKind) -> RuleSpec {
+    RuleSpec {
+        kind,
+        action: RuleAction::Reject,
+        no_resolve: false,
+    }
+}
+
+#[test]
+fn asn_official_fixture_direct_lookup_and_absent_asset() {
+    let dir = tempfile::tempdir().unwrap();
+    assert!(GeoData::load(dir.path(), &[]).unwrap().is_empty());
+    fs::write(dir.path().join(ASN_FILE_NAME), FIXTURE).unwrap();
+    let rules = [rule(RuleKind::IpAsn("15169".into()))];
+    let data = GeoData::load(dir.path(), &rules).unwrap();
+    assert_eq!(data.allocation_capacity(), FIXTURE.len());
+    assert!(data.matches_asn("15169", "1.0.0.1".parse().unwrap()));
+    assert!(data.matches_asn("6730", "2001:1700::1".parse().unwrap()));
+    assert!(data.matches_asn("0", "192.0.2.1".parse().unwrap()));
+    for payload in ["AS15169", "015169", "+15169", "0"] {
+        assert!(!data.matches_asn(payload, "1.0.0.1".parse().unwrap()));
+    }
+    assert!(!GeoData::EMPTY.matches_asn("0", "192.0.2.1".parse().unwrap()));
+    assert!(!GeoData::load(dir.path(), &[]).unwrap().asn_available());
+}
+
+#[test]
+fn asn_schema_visitors_and_lazy_resolution_use_actual_context() {
+    let mut empty = Config::parse_yaml(b"mixed-port: 1080\nrules: ['IP-ASN,,DIRECT']\n").unwrap();
+    assert_eq!(empty.rules[0].kind, RuleKind::IpAsn(String::new()));
+    RuleSet::compile(empty.take_runtime_rules()).unwrap();
+    let dir = tempfile::tempdir().unwrap();
+    fs::write(dir.path().join(ASN_FILE_NAME), FIXTURE).unwrap();
+    let mut config = Config::parse_yaml(
+        br#"
+mixed-port: 1080
+geox-url: {asn: https://assets.example.test/ASN.mmdb}
+rule-providers:
+  local: {type: inline, behavior: classical, payload: ["IP-ASN,AS15169", "SRC-IP-ASN,6730"]}
+sub-rules:
+  nested: ["OR,((IP-ASN,0015169),(SRC-IP-ASN,6730)),DIRECT"]
+rules:
+  - IP-ASN,15169,REJECT,no-resolve
+  - IP-ASN,15169,REJECT
+  - IP-ASN,6730,DIRECT,src,no-resolve
+  - SRC-IP-ASN,6730,DIRECT
+  - RULE-SET,local,DIRECT
+"#,
+    )
+    .unwrap();
+    let requirements = GeoRequirements::for_config(&config).unwrap();
+    assert!(requirements.requires(GeoDataKind::Asn));
+    assert!(requirements.codes(GeoDataKind::Asn).next().is_none());
+    assert_eq!(config.rules[2], config.rules[3]);
+    assert_eq!(
+        config.geodata_update.as_ref().unwrap().urls.asn,
+        "https://assets.example.test/ASN.mmdb"
+    );
+    let data = GeoData::load(dir.path(), &config.rules).unwrap();
+    let mut runtime_config = config.clone();
+    let rules = RuleSet::compile(runtime_config.take_runtime_rules()).unwrap();
+    let mut context = RoutingContext::new(
+        Network::Tcp,
+        &Destination::domain("example.test", 443).unwrap(),
+    )
+    .unwrap();
+    assert!(matches!(
+        rules.evaluate_with_geo(&context, &data),
+        RuleEvaluation::NeedsIpResolution { rule_index: 1 }
+    ));
+    assert!(matches!(
+        rules.evaluate_with_geo(&context, &GeoData::EMPTY),
+        RuleEvaluation::Matched(result) if result.action == RuleAction::Direct
+    ));
+    let source_rule = rule(RuleKind::SrcIpAsn("6730".into()));
+    assert_eq!(
+        crate::routing::matches_rule(&source_rule, &context, &data),
+        Ok(false)
+    );
+    context.set_source("[2001:1700::1]:49152".parse().unwrap());
+    assert_eq!(
+        crate::routing::matches_rule(&source_rule, &context, &data),
+        Ok(true)
+    );
+    let literal = RoutingContext::new(
+        Network::Tcp,
+        &Destination::Ip("1.0.0.1:443".parse().unwrap()),
+    )
+    .unwrap();
+    assert_eq!(
+        crate::routing::matches_rule(&rule(RuleKind::IpAsn("15169".into())), &literal, &data),
+        Ok(true)
+    );
+    // Definition and classical content are independently traversed even when
+    // the main list has no direct ASN predicate.
+    config.rules = vec![rule(RuleKind::Match)];
+    assert!(
+        GeoRequirements::for_config(&config)
+            .unwrap()
+            .requires(GeoDataKind::Asn)
+    );
+    let collection = crate::config::RuleCollection::from_payload(
+        vec!["IP-ASN,15169".into()],
+        crate::config::providers::RuleBehavior::Classical,
+    )
+    .unwrap();
+    assert!(
+        collection
+            .matches_ip("1.0.0.1".parse().unwrap(), &data, &Default::default())
+            .unwrap()
+    );
+    let nested = rule(RuleKind::Not(Box::new(rule(RuleKind::RuleSet {
+        name: "local".into(),
+        content: Some(Arc::new(collection)),
+        source: false,
+    }))));
+    assert!(
+        GeoRequirements::collect(&[nested], &[])
+            .unwrap()
+            .requires(GeoDataKind::Asn)
+    );
+}
diff --git a/src/geodata/country.rs b/src/geodata/country.rs
new file mode 100644
index 0000000..5e7f222
--- /dev/null
+++ b/src/geodata/country.rs
@@ -0,0 +1,537 @@
+//! Verified country MMDBs, with selective compact indexes for Meta records.
+
+use std::{fmt, io::Read, net::IpAddr, path::Path};
+
+use maxminddb::{MaxMindDbError, Metadata, Reader, WithinOptions};
+use serde::{
+    Deserialize,
+    de::{self, SeqAccess, Visitor},
+};
+
+use super::{
+    AllocationLedger, Cidr4, Cidr6, Code, GeoDataError, GeoDataKind, IpCategory, compact_v4,
+    compact_v6, compact_vec, ensure_vec_capacity, open_asset_path, selector_code,
+};
+
+const METADATA_MARKER: &[u8] = b"\xab\xcd\xefMaxMind.com";
+const METADATA_HEADROOM: usize = 512;
+const EMPTY_DESCRIPTION: &str = "description - Expected: non-empty map Actual: {}";
+
+#[derive(Debug, Clone, Copy)]
+enum Format {
+    MaxMind,
+    Sing,
+    Meta,
+}
+
+impl Format {
+    fn parse(value: &str) -> Self {
+        match value {
+            "sing-geoip" => Self::Sing,
+            "Meta-geoip0" => Self::Meta,
+            _ => Self::MaxMind,
+        }
+    }
+}
+
+pub(super) struct CountryDb {
+    storage: Storage,
+    selectors: Vec<String>,
+    capacity: usize,
+}
+
+enum Storage {
+    Reader {
+        reader: Reader<Vec<u8>>,
+        format: Format,
+    },
+    Meta {
+        categories: Vec<IpCategory>,
+        ipv6: bool,
+    },
+}
+
+impl CountryDb {
+    pub(super) fn load(path: &Path, selectors: &[String]) -> Result<Self, GeoDataError> {
+        CountryCandidate::load(path)?.into_database(selectors)
+    }
+
+    pub(super) fn capacity(&self) -> usize {
+        self.capacity
+    }
+
+    pub(super) fn available(&self, selector: &str) -> bool {
+        self.selectors
+            .binary_search_by(|value| {
+                value
+                    .bytes()
+                    .cmp(selector.bytes().map(|byte| byte.to_ascii_lowercase()))
+            })
+            .is_ok()
+    }
+
+    pub(super) fn matches(&self, selector: &str, address: IpAddr) -> bool {
+        if !self.available(selector) {
+            return false;
+        }
+        let code = selector_code(selector);
+        let (reader, format) = match &self.storage {
+            Storage::Reader { reader, format } => (reader, format),
+            Storage::Meta { categories, ipv6 } => {
+                // Reader rejects IPv6 queries against IPv4-only databases,
+                // including inverse selectors. This is not a no-record result.
+                if !ipv6 && address.is_ipv6() {
+                    return false;
+                }
+                let matched = categories
+                    .binary_search_by(|category| category.code.cmp_str(code))
+                    .ok()
+                    .is_some_and(|at| categories[at].matches(address));
+                return matched != selector.starts_with('!');
+            }
+        };
+        let Ok(record) = reader.lookup(address) else {
+            return false;
+        };
+        let matched = match format {
+            Format::MaxMind => {
+                match record.decode_path::<&str>(&maxminddb::path!["country", "iso_code"]) {
+                    Ok(value) => value.is_some_and(|value| value.eq_ignore_ascii_case(code)),
+                    Err(_) => return false,
+                }
+            }
+            Format::Sing => match record.decode::<&str>() {
+                Ok(value) => value.is_some_and(|value| canonical_code_matches(value, code)),
+                Err(_) => return false,
+            },
+            Format::Meta => match record.decode::<BorrowedCodes<'_>>() {
+                Ok(Some(BorrowedCodes::One(value))) => canonical_code_matches(value, code),
+                Ok(Some(BorrowedCodes::Many(values))) => values
+                    .iter()
+                    .any(|value| canonical_code_matches(value, code)),
+                Ok(None) => false,
+                Err(_) => return false,
+            },
+        };
+        matched != selector.starts_with('!')
+    }
+}
+
+// Only string references are materialized for Meta's multi-code records. No
+// country strings, full MaxMind maps or per-address cache survive the lookup.
+enum BorrowedCodes<'a> {
+    One(&'a str),
+    Many(Vec<&'a str>),
+}
+
+impl<'de> Deserialize<'de> for BorrowedCodes<'de> {
+    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        struct CodesVisitor;
+        impl<'de> Visitor<'de> for CodesVisitor {
+            type Value = BorrowedCodes<'de>;
+            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+                formatter.write_str("a country code or an array of country codes")
+            }
+            fn visit_borrowed_str<E: de::Error>(self, value: &'de str) -> Result<Self::Value, E> {
+                Ok(BorrowedCodes::One(value))
+            }
+            fn visit_seq<A: SeqAccess<'de>>(
+                self,
+                mut sequence: A,
+            ) -> Result<Self::Value, A::Error> {
+                let mut values = Vec::new();
+                while let Some(value) = sequence.next_element::<&'de str>()? {
+                    values
+                        .try_reserve(1)
+                        .map_err(|_| de::Error::custom("country code allocation failed"))?;
+                    values.push(value);
+                }
+                Ok(BorrowedCodes::Many(values))
+            }
+        }
+        deserializer.deserialize_any(CodesVisitor)
+    }
+}
+
+/// Full index/data verification borrows the candidate bytes while the old
+/// reader remains usable. Ownership transfers after old readers are drained.
+pub(super) struct CountryCandidate {
+    bytes: Vec<u8>,
+    format: Format,
+}
+
+impl CountryCandidate {
+    pub(super) fn load(path: &Path) -> Result<Self, GeoDataError> {
+        let (mut file, len) = open_asset_path(path)?;
+        let len = usize::try_from(len)
+            .map_err(|_| GeoDataError::AllocationFailed { bytes: usize::MAX })?;
+        let capacity = len
+            .checked_add(METADATA_HEADROOM)
+            .ok_or(GeoDataError::AllocationFailed { bytes: usize::MAX })?;
+        let mut bytes = Vec::new();
+        bytes
+            .try_reserve_exact(capacity)
+            .map_err(|_| GeoDataError::AllocationFailed { bytes: capacity })?;
+        bytes.resize(len, 0);
+        file.read_exact(&mut bytes)
+            .map_err(|source| GeoDataError::Io {
+                path: path.into(),
+                source,
+            })?;
+        verify_country_mmdb(&mut bytes)?;
+        let format = {
+            let reader = Reader::from_source(bytes.as_slice())
+                .map_err(|_| invalid("invalid country MMDB"))?;
+            Format::parse(&reader.metadata().database_type)
+        };
+        Ok(Self { bytes, format })
+    }
+
+    pub(super) fn into_database(self, selectors: &[String]) -> Result<CountryDb, GeoDataError> {
+        let mut stored = Vec::new();
+        stored
+            .try_reserve_exact(selectors.len())
+            .map_err(|_| GeoDataError::AllocationFailed {
+                bytes: selectors
+                    .len()
+                    .saturating_mul(std::mem::size_of::<String>()),
+            })?;
+        for selector in selectors {
+            let mut value = String::new();
+            value.try_reserve_exact(selector.len()).map_err(|_| {
+                GeoDataError::AllocationFailed {
+                    bytes: selector.len(),
+                }
+            })?;
+            value.push_str(selector);
+            stored.push(value);
+        }
+        stored.sort_unstable();
+        let selector_capacity = stored
+            .iter()
+            .fold(
+                stored.capacity().checked_mul(std::mem::size_of::<String>()),
+                |total, value| total.and_then(|total| total.checked_add(value.capacity())),
+            )
+            .ok_or(GeoDataError::AllocationFailed { bytes: usize::MAX })?;
+        let projected = if matches!(self.format, Format::Meta) {
+            match project_meta(&self.bytes, &stored) {
+                Ok(projected) => projected,
+                Err(GeoDataError::AllocationFailed { .. }) => None,
+                Err(error) => return Err(error),
+            }
+        } else {
+            None
+        };
+        let (storage, capacity) = match projected {
+            Some((categories, capacity, ipv6)) => {
+                // Drop the verified file after projection; it is not retained
+                // alongside the selected immutable CIDRs.
+                (Storage::Meta { categories, ipv6 }, capacity)
+            }
+            None => {
+                let capacity = self.bytes.capacity();
+                let reader =
+                    Reader::from_source(self.bytes).map_err(|_| invalid("invalid country MMDB"))?;
+                (
+                    Storage::Reader {
+                        reader,
+                        format: self.format,
+                    },
+                    capacity,
+                )
+            }
+        };
+        let capacity = capacity
+            .checked_add(selector_capacity)
+            .ok_or(GeoDataError::AllocationFailed { bytes: usize::MAX })?;
+        Ok(CountryDb {
+            storage,
+            selectors: stored,
+            capacity,
+        })
+    }
+}
+
+/// A representation choice, never a resource admission limit. Invalid Meta
+/// record types retain Reader's per-address error behavior, and a projection
+/// that is not smaller than the file retains the original reader as well.
+fn project_meta(
+    bytes: &[u8],
+    selectors: &[String],
+) -> Result<Option<(Vec<IpCategory>, usize, bool)>, GeoDataError> {
+    let reader = Reader::from_source(bytes).map_err(|_| invalid("invalid country MMDB"))?;
+    let ipv6 = reader.metadata().ip_version == 6;
+    let mut ledger = AllocationLedger::default();
+    let mut categories: Vec<IpCategory> = Vec::new();
+    for selector in selectors {
+        let code = Code::parse(GeoDataKind::GeoIp, selector_code(selector).as_bytes())?;
+        ensure_vec_capacity(&mut categories, 1, &mut ledger)?;
+        categories.push(IpCategory {
+            code,
+            v4: Vec::new(),
+            v6: Vec::new(),
+            selectors: Vec::new(),
+        });
+    }
+    categories.sort_unstable_by_key(|category| category.code);
+    categories.dedup_by_key(|category| category.code);
+    compact_vec(&mut categories, &mut ledger)?;
+    if ledger.used >= bytes.len() {
+        return Ok(None);
+    }
+    let Ok(networks) = reader.networks(WithinOptions::default().include_aliased_networks()) else {
+        return Ok(None);
+    };
+    for (visited, record) in networks.enumerate() {
+        // Aliases can revisit the same verified subtree. If projection work
+        // ceases to be proportional to this file, keep its compact MMDB tree.
+        if visited >= bytes.len() {
+            return Ok(None);
+        }
+        let Ok(record) = record else { return Ok(None) };
+        let Ok(Some(codes)) = record.decode::<BorrowedCodes<'_>>() else {
+            return Ok(None);
+        };
+        let Ok(network) = record.network() else {
+            return Ok(None);
+        };
+        let codes: &[&str] = match &codes {
+            BorrowedCodes::One(code) => std::slice::from_ref(code),
+            BorrowedCodes::Many(codes) => codes,
+        };
+        for code in codes {
+            // Stored Meta strings are case-sensitive. Only selectors are
+            // canonicalized; an uppercase record must not gain a new match.
+            let Ok(at) = categories.binary_search_by(|category| category.code.as_str().cmp(code))
+            else {
+                continue;
+            };
+            let category = &mut categories[at];
+            match network.network() {
+                IpAddr::V4(address) => {
+                    ensure_vec_capacity(&mut category.v4, 1, &mut ledger)?;
+                    category.v4.push(Cidr4 {
+                        network: address.octets(),
+                        prefix: network.prefix(),
+                    });
+                    if ipv6 {
+                        // The iterator formats the ::/96 IPv4 subtree as V4.
+                        // Literal IPv6 lookups in that subtree still match it.
+                        ensure_vec_capacity(&mut category.v6, 1, &mut ledger)?;
+                        category.v6.push(Cidr6 {
+                            network: u128::from(u32::from(address)).to_be_bytes(),
+                            prefix: network.prefix() + 96,
+                        });
+                    }
+                }
+                IpAddr::V6(address) => {
+                    ensure_vec_capacity(&mut category.v6, 1, &mut ledger)?;
+                    category.v6.push(Cidr6 {
+                        network: address.octets(),
+                        prefix: network.prefix(),
+                    });
+                    if address.is_unspecified() && network.prefix() <= 96 {
+                        // A data leaf above the IPv4 subtree answers every V4
+                        // lookup, while remaining a V6 CIDR for V6 lookups.
+                        ensure_vec_capacity(&mut category.v4, 1, &mut ledger)?;
+                        category.v4.push(Cidr4 {
+                            network: [0; 4],
+                            prefix: 0,
+                        });
+                    }
+                }
+            }
+        }
+        if ledger.used >= bytes.len() {
+            compact_projection(&mut categories, &mut ledger)?;
+            if ledger.used >= bytes.len() {
+                return Ok(None);
+            }
+        }
+    }
+    compact_projection(&mut categories, &mut ledger)?;
+    compact_vec(&mut categories, &mut ledger)?;
+    Ok((ledger.used < bytes.len()).then_some((categories, ledger.used, ipv6)))
+}
+
+fn compact_projection(
+    categories: &mut [IpCategory],
+    ledger: &mut AllocationLedger,
+) -> Result<(), GeoDataError> {
+    for category in categories {
+        compact_v4(&mut category.v4);
+        compact_v6(&mut category.v6);
+        compact_vec(&mut category.v4, ledger)?;
+        compact_vec(&mut category.v6, ledger)?;
+    }
+    Ok(())
+}
+
+/// Some official sing/Meta databases have a valid empty description map.
+/// maxminddb 0.32 verifies the complete original metadata graph before rejecting
+/// that optional information. Validate its unchanged tree/data with a temporary
+/// nonempty description, then restore the original metadata and byte identity.
+pub(super) fn verify_country_mmdb(bytes: &mut Vec<u8>) -> Result<(), GeoDataError> {
+    let replacement = {
+        let reader =
+            Reader::from_source(bytes.as_slice()).map_err(|_| invalid("invalid country MMDB"))?;
+        match reader.verify() {
+            Ok(()) => return Ok(()),
+            Err(MaxMindDbError::InvalidDatabase {
+                message,
+                offset: None,
+            }) if message == EMPTY_DESCRIPTION
+                && reader.metadata().description.is_empty()
+                && matches!(
+                    reader.metadata().database_type.as_str(),
+                    "sing-geoip" | "Meta-geoip0"
+                ) =>
+            {
+                validation_metadata(reader.metadata())?
+            }
+            Err(_) => return Err(invalid("invalid country MMDB index or data")),
+        }
+    };
+    // Use the same marker location as Reader. Moving it or adding another one
+    // would enlarge the data section and could admit an originally bad pointer.
+    let start = bytes
+        .windows(METADATA_MARKER.len())
+        .rposition(|part| part == METADATA_MARKER)
+        .and_then(|index| index.checked_add(METADATA_MARKER.len()))
+        .ok_or_else(|| invalid("invalid country MMDB metadata boundary"))?;
+    let original = &bytes[start..];
+    let mut saved = Vec::new();
+    saved
+        .try_reserve_exact(original.len())
+        .map_err(|_| GeoDataError::AllocationFailed {
+            bytes: original.len(),
+        })?;
+    saved.extend_from_slice(original);
+    let required = start
+        .checked_add(replacement.len())
+        .ok_or(GeoDataError::AllocationFailed { bytes: usize::MAX })?;
+    if required > bytes.capacity() {
+        bytes
+            .try_reserve_exact(required - bytes.len())
+            .map_err(|_| GeoDataError::AllocationFailed { bytes: required })?;
+    }
+    let view = MetadataView::new(bytes, start, saved, &replacement);
+    let result = Reader::from_source(view.bytes.as_slice())
+        .and_then(|reader| reader.verify())
+        .map_err(|_| invalid("invalid country MMDB index or data"));
+    drop(view);
+    result
+}
+
+struct MetadataView<'a> {
+    bytes: &'a mut Vec<u8>,
+    start: usize,
+    original: Vec<u8>,
+}
+
+impl<'a> MetadataView<'a> {
+    fn new(bytes: &'a mut Vec<u8>, start: usize, original: Vec<u8>, replacement: &[u8]) -> Self {
+        bytes.truncate(start);
+        bytes.extend_from_slice(replacement);
+        Self {
+            bytes,
+            start,
+            original,
+        }
+    }
+}
+
+impl Drop for MetadataView<'_> {
+    fn drop(&mut self) {
+        self.bytes.truncate(self.start);
+        // Original capacity was retained, so restoration cannot reallocate.
+        self.bytes.extend_from_slice(&self.original);
+    }
+}
+
+// Encode only the nine public, already validated Metadata fields in MMDB 2.0
+// wire format. No tree/data bytes or original unknown metadata are re-encoded;
+// the latter's entire graph passed verification before the narrow exception.
+fn validation_metadata(metadata: &Metadata) -> Result<Vec<u8>, GeoDataError> {
+    let base = METADATA_HEADROOM
+        .checked_add(metadata.database_type.len())
+        .ok_or(GeoDataError::AllocationFailed { bytes: usize::MAX })?;
+    let capacity = metadata
+        .languages
+        .iter()
+        .try_fold(base, |total, language| {
+            total.checked_add(language.len())?.checked_add(8)
+        })
+        .ok_or(GeoDataError::AllocationFailed { bytes: usize::MAX })?;
+    let mut out = Vec::new();
+    out.try_reserve_exact(capacity)
+        .map_err(|_| GeoDataError::AllocationFailed { bytes: capacity })?;
+    mmdb_header(&mut out, 7, 9)?;
+    for (name, kind, value) in [
+        (
+            "binary_format_major_version",
+            5,
+            u64::from(metadata.binary_format_major_version),
+        ),
+        (
+            "binary_format_minor_version",
+            5,
+            u64::from(metadata.binary_format_minor_version),
+        ),
+        ("build_epoch", 9, metadata.build_epoch),
+        ("ip_version", 5, u64::from(metadata.ip_version)),
+        ("node_count", 6, u64::from(metadata.node_count)),
+        ("record_size", 5, u64::from(metadata.record_size)),
+    ] {
+        mmdb_string(&mut out, name)?;
+        let width = 8 - value.leading_zeros() as usize / 8;
+        mmdb_header(&mut out, kind, width)?;
+        out.extend_from_slice(&value.to_be_bytes()[8 - width..]);
+    }
+    mmdb_string(&mut out, "database_type")?;
+    mmdb_string(&mut out, &metadata.database_type)?;
+    mmdb_string(&mut out, "description")?;
+    mmdb_header(&mut out, 7, 1)?;
+    mmdb_string(&mut out, "en")?;
+    mmdb_string(&mut out, "Vole validation")?;
+    mmdb_string(&mut out, "languages")?;
+    mmdb_header(&mut out, 11, metadata.languages.len())?;
+    for language in &metadata.languages {
+        mmdb_string(&mut out, language)?;
+    }
+    Ok(out)
+}
+
+fn mmdb_string(out: &mut Vec<u8>, value: &str) -> Result<(), GeoDataError> {
+    mmdb_header(out, 2, value.len())?;
+    out.extend_from_slice(value.as_bytes());
+    Ok(())
+}
+
+fn mmdb_header(out: &mut Vec<u8>, kind: u8, size: usize) -> Result<(), GeoDataError> {
+    let (prefix, width, extra) = match size {
+        0..=28 => (size as u8, 0, 0),
+        29..=284 => (29, 1, size - 29),
+        285..=65_820 => (30, 2, size - 285),
+        65_821..=16_843_036 => (31, 3, size - 65_821),
+        _ => return Err(invalid("country MMDB metadata value cannot be represented")),
+    };
+    out.push(if kind < 8 { kind << 5 } else { 0 } | prefix);
+    if kind >= 8 {
+        out.push(kind - 7);
+    }
+    let extra = (extra as u32).to_be_bytes();
+    out.extend_from_slice(&extra[4 - width..]);
+    Ok(())
+}
+
+fn invalid(detail: &str) -> GeoDataError {
+    GeoDataError::InvalidCountry(detail.into())
+}
+
+fn canonical_code_matches(value: &str, selector: &str) -> bool {
+    value
+        .bytes()
+        .eq(selector.bytes().map(|byte| byte.to_ascii_lowercase()))
+}
diff --git a/src/geodata/country_tests.rs b/src/geodata/country_tests.rs
new file mode 100644
index 0000000..0b16dc5
--- /dev/null
+++ b/src/geodata/country_tests.rs
@@ -0,0 +1,634 @@
+use std::{fs, sync::Arc, time::Duration};
+
+use sha2::{Digest, Sha256};
+use tokio_util::sync::CancellationToken;
+
+use super::*;
+use crate::{
+    config::{Config, Network, RuleCollection},
+    dns::fallback::Filter,
+    routing::{RoutingContext, matches_rule},
+    session::Destination,
+};
+
+const COUNTRY: &[u8] = include_bytes!("../../tests/fixtures/geodata/Country-Test.mmdb");
+const SING: &[u8] = include_bytes!("../../tests/fixtures/geodata/Sing-Test.mmdb");
+const META: &[u8] = include_bytes!("../../tests/fixtures/geodata/Meta-Test.mmdb");
+
+fn config() -> Config {
+    Config::parse_yaml(
+        br#"
+dns:
+  enable: true
+  fallback: [1.1.1.1]
+  fallback-filter: {geoip: true, geoip-code: CN}
+rule-providers:
+  geo: {type: inline, behavior: classical, payload: ["GEOIP,CN"]}
+rules:
+  - GEOIP,CN,REJECT,no-resolve
+  - SRC-GEOIP,CN,DIRECT
+  - GEOIP,!CN,REJECT,no-resolve
+  - GEOIP,US,DIRECT,no-resolve
+  - RULE-SET,geo,DIRECT
+  - MATCH,DIRECT
+"#,
+    )
+    .unwrap()
+}
+
+fn stage(session: &GeoUpdateSession, bytes: &[u8]) -> ([u8; 32], u64) {
+    fs::write(session.temporary_path(), bytes).unwrap();
+    (Sha256::digest(bytes).into(), bytes.len() as u64)
+}
+
+// Independently remove the one description entry from the existing synthetic
+// MMDB fixture. Tree/data/marker bytes keep their exact offsets.
+fn empty_description(fixture: &[u8]) -> Vec<u8> {
+    let description = b"\xe1\x42en\x56Vole synthetic country";
+    let start = fixture
+        .windows(description.len())
+        .position(|value| value == description)
+        .unwrap();
+    let mut bytes = fixture.to_vec();
+    bytes.splice(start..start + description.len(), [0xe0]);
+    bytes
+}
+
+#[test]
+fn country_mmdb_empty_description_keeps_original_bytes_metadata_and_lookup() {
+    for (fixture, filename) in [(SING, "geoip.db"), (META, "geoip.metadb")] {
+        let original = empty_description(fixture);
+        let metadata = {
+            let reader = maxminddb::Reader::from_source(original.as_slice()).unwrap();
+            assert!(reader.metadata().description.is_empty());
+            assert!(reader.verify().is_err());
+            reader.metadata().clone()
+        };
+        let mut bytes = original.clone();
+        bytes.reserve_exact(512);
+        let pointer = bytes.as_ptr();
+        country::verify_country_mmdb(&mut bytes).unwrap();
+        assert_eq!(bytes, original);
+        assert_eq!(bytes.as_ptr(), pointer);
+        let reader = maxminddb::Reader::from_source(bytes.as_slice()).unwrap();
+        assert_eq!(reader.metadata(), &metadata);
+
+        let directory = tempfile::tempdir().unwrap();
+        let path = directory.path().join(filename);
+        fs::write(&path, &original).unwrap();
+        let manager =
+            GeoDataManager::open(directory.path().join("geodata"), Duration::from_secs(3600))
+                .unwrap();
+        let registration = manager
+            .register(GeoRequirements::for_config(&config()).unwrap())
+            .unwrap();
+        assert!(registration.initial_report().geoip.available);
+        let snapshot = registration.matcher().snapshot();
+        assert!(snapshot.matches_geoip("cn", "1.2.3.4".parse().unwrap()));
+        assert!(snapshot.matches_geoip("cn", "2001:db8::1".parse().unwrap()));
+        assert!(snapshot.matches_geoip("!cn", "8000::1".parse().unwrap()));
+        assert_eq!(fs::read(path).unwrap(), original);
+    }
+    // An empty description is not a general exception for other DB schemas.
+    let mut country = empty_description(COUNTRY);
+    let original = country.clone();
+    assert!(country::verify_country_mmdb(&mut country).is_err());
+    assert_eq!(country, original);
+}
+
+#[test]
+fn country_mmdb_empty_description_still_rejects_corrupt_tree_separator_and_data() {
+    for fixture in [SING, META] {
+        let valid = empty_description(fixture);
+        let metadata = maxminddb::Reader::from_source(valid.as_slice())
+            .unwrap()
+            .metadata()
+            .clone();
+        let tree_bytes = metadata.node_count as usize * usize::from(metadata.record_size) / 4;
+        for corruption in ["tree", "separator", "data-pointer", "utf8"] {
+            let mut bytes = valid.clone();
+            match corruption {
+                "tree" => bytes[..3].copy_from_slice(&[0xff; 3]),
+                "separator" => bytes[tree_bytes] = 1,
+                // Small pointer 0 resolves to its own record: verification
+                // must follow pointer targets rather than use IgnoredAny.
+                "data-pointer" => {
+                    bytes[tree_bytes + 16..tree_bytes + 18].copy_from_slice(&[0x20, 0])
+                }
+                "utf8" => {
+                    // CN string is the first data record for sing, and the
+                    // first element of the root array for Meta.
+                    let offset = if metadata.database_type == "sing-geoip" {
+                        17
+                    } else {
+                        19
+                    };
+                    bytes[tree_bytes + offset] = 0xff;
+                }
+                _ => unreachable!(),
+            }
+            let original = bytes.clone();
+            assert!(
+                country::verify_country_mmdb(&mut bytes).is_err(),
+                "{corruption}"
+            );
+            assert_eq!(bytes, original, "{corruption}");
+            assert_eq!(
+                maxminddb::Reader::from_source(bytes.as_slice())
+                    .unwrap()
+                    .metadata(),
+                &metadata
+            );
+        }
+    }
+}
+
+#[test]
+fn country_mmdb_schemas_share_route_source_collection_and_fallback() {
+    for fixture in [COUNTRY, SING, META] {
+        let dir = tempfile::tempdir().unwrap();
+        fs::write(dir.path().join("cOuNtRy.MmDb"), fixture).unwrap();
+        let manager =
+            GeoDataManager::open(dir.path().join("geodata"), Duration::from_secs(3600)).unwrap();
+        let config = config();
+        assert!(!config.geodata_update.as_ref().unwrap().geodata_mode);
+        let registration = manager
+            .register(GeoRequirements::for_config(&config).unwrap())
+            .unwrap();
+        assert!(registration.initial_report().geoip.available);
+        let snapshot = registration.matcher().snapshot();
+        assert!(snapshot.country.is_some() && snapshot.ips.is_empty());
+        for address in ["1.2.3.4", "2001:db8::1"] {
+            let destination = Destination::Ip(
+                format!(
+                    "{}:443",
+                    if address.contains(':') {
+                        format!("[{address}]")
+                    } else {
+                        address.into()
+                    }
+                )
+                .parse()
+                .unwrap(),
+            );
+            let mut context = RoutingContext::new(Network::Tcp, &destination).unwrap();
+            context.set_source("[2001:db8::2]:12345".parse().unwrap());
+            assert_eq!(
+                matches_rule(&config.rules[0], &context, snapshot.as_ref()),
+                Ok(true)
+            );
+            assert_eq!(
+                matches_rule(&config.rules[1], &context, snapshot.as_ref()),
+                Ok(true)
+            );
+            assert_eq!(
+                matches_rule(&config.rules[2], &context, snapshot.as_ref()),
+                Ok(false)
+            );
+            let ip = address.parse().unwrap();
+            assert!(!Filter::new(&config.dns.fallback).address(ip, snapshot.as_ref()));
+            let collection = RuleCollection::from_payload(
+                vec!["GEOIP,CN".into()],
+                crate::config::providers::RuleBehavior::Classical,
+            )
+            .unwrap();
+            assert!(
+                collection
+                    .matches_ip(
+                        ip,
+                        snapshot.as_ref(),
+                        &crate::config::RuleDecision::default()
+                    )
+                    .unwrap()
+            );
+        }
+        let other = "8000::1".parse().unwrap();
+        assert!(snapshot.matches_geoip("us", other));
+        assert!(snapshot.matches_geoip("!cn", other));
+        assert!(Filter::new(&config.dns.fallback).address(other, snapshot.as_ref()));
+    }
+}
+
+#[test]
+fn country_mmdb_discovery_uses_first_name_and_preserves_missing_semantics() {
+    let dir = tempfile::tempdir().unwrap();
+    fs::write(dir.path().join("geoip.metadb"), COUNTRY).unwrap();
+    fs::write(dir.path().join("COUNTRY.MMDB"), b"broken").unwrap();
+    let manager =
+        GeoDataManager::open(dir.path().join("geodata"), Duration::from_secs(3600)).unwrap();
+    let registration = manager
+        .register(GeoRequirements::for_config(&config()).unwrap())
+        .unwrap();
+    assert!(!registration.initial_report().geoip.available);
+    assert!(
+        !registration
+            .matcher()
+            .matches_geoip("!cn", "8000::1".parse().unwrap())
+    );
+    let session = manager.begin_update(GeoDataKind::GeoIp).unwrap();
+    assert_eq!(
+        session.temporary_path().file_name().unwrap(),
+        "COUNTRY.MMDB"
+    );
+    drop(session);
+    drop(registration);
+    fs::remove_file(dir.path().join("COUNTRY.MMDB")).unwrap();
+    fs::remove_file(dir.path().join("geoip.metadb")).unwrap();
+    let registration = manager
+        .register(GeoRequirements::for_config(&config()).unwrap())
+        .unwrap();
+    assert!(!registration.initial_report().geoip.available);
+    let update = manager.begin_update(GeoDataKind::GeoIp).unwrap();
+    assert_eq!(update.temporary_path().file_name().unwrap(), "geoip.metadb");
+    let (hash, size) = stage(&update, META);
+    assert!(update.commit(None, hash, size).unwrap().geoip_available);
+    assert_eq!(fs::read(dir.path().join("geoip.metadb")).unwrap(), META);
+    assert!(!manager.store_dir().join("geoip.metadb").exists());
+}
+
+#[test]
+fn country_mmdb_update_rejects_bad_candidate_and_drains_before_publish() {
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("GeoIP.DB");
+    fs::write(&path, COUNTRY).unwrap();
+    let manager =
+        GeoDataManager::open(dir.path().join("geodata"), Duration::from_secs(3600)).unwrap();
+    let registration = manager
+        .register(GeoRequirements::for_config(&config()).unwrap())
+        .unwrap();
+    let matcher = registration.matcher();
+    let old = matcher.snapshot();
+    let update = manager.begin_update(GeoDataKind::GeoIp).unwrap();
+    let (hash, size) = stage(&update, b"broken");
+    assert!(update.commit(None, hash, size).is_err());
+    assert!(Arc::ptr_eq(&old, &matcher.snapshot()));
+    assert_eq!(fs::read(&path).unwrap(), COUNTRY);
+
+    let update = manager.begin_update(GeoDataKind::GeoIp).unwrap();
+    let (hash, size) = stage(&update, META);
+    let cancellation = CancellationToken::new();
+    let token = cancellation.clone();
+    let worker =
+        std::thread::spawn(move || update.commit_with_cancellation(None, hash, size, &token));
+    let deadline = std::time::Instant::now() + Duration::from_secs(2);
+    while matcher.geoip_available("cn") && std::time::Instant::now() < deadline {
+        std::thread::yield_now();
+    }
+    assert!(!matcher.geoip_available("cn"));
+    cancellation.cancel();
+    assert!(matches!(
+        worker.join().unwrap(),
+        Err(GeoDataManagerError::Cancelled)
+    ));
+    assert!(Arc::ptr_eq(&old, &matcher.snapshot()));
+    assert_eq!(fs::read(&path).unwrap(), COUNTRY);
+    drop(old);
+    let update = manager.begin_update(GeoDataKind::GeoIp).unwrap();
+    let (hash, size) = stage(&update, META);
+    assert!(
+        update
+            .commit(Some("new".into()), hash, size)
+            .unwrap()
+            .geoip_available
+    );
+    assert_eq!(fs::read(&path).unwrap(), META);
+    assert!(matcher.matches_geoip("cn", "1.2.3.4".parse().unwrap()));
+}
+
+#[test]
+fn country_mmdb_mode_changes_do_not_reuse_dat_etag_for_the_same_url() {
+    let dir = tempfile::tempdir().unwrap();
+    let manager =
+        GeoDataManager::open(dir.path().join("geodata"), Duration::from_secs(3600)).unwrap();
+    let registration = manager
+        .register(GeoRequirements::for_config(&config()).unwrap())
+        .unwrap();
+    let url = "https://assets.example.test/shared";
+    let lease = registration.updater_lease();
+    let update = manager
+        .begin_update_for_active_registration(
+            &lease,
+            GeoDataKind::GeoIp,
+            url,
+            std::time::SystemTime::now(),
+        )
+        .unwrap()
+        .unwrap();
+    let (hash, size) = stage(&update, COUNTRY);
+    update.commit(Some("country".into()), hash, size).unwrap();
+    drop(registration);
+    let mut config = config();
+    config.geodata_update.as_mut().unwrap().geodata_mode = true;
+    let registration = manager
+        .register(GeoRequirements::for_config(&config).unwrap())
+        .unwrap();
+    let update = manager
+        .begin_update_for_active_registration(
+            &registration.updater_lease(),
+            GeoDataKind::GeoIp,
+            url,
+            std::time::SystemTime::now(),
+        )
+        .unwrap()
+        .unwrap();
+    assert!(update.request_etag().is_none());
+    assert_eq!(
+        update.temporary_path().file_name().unwrap(),
+        GEOIP_FILE_NAME
+    );
+}
+
+// Independent MMDB tree writer: routes and aliases share data offsets, exactly
+// as real Meta databases do. Reuse only the existing fixture's metadata fields.
+fn meta_projection_fixture(
+    ipv6: bool,
+    routes: &[(&str, u8, usize)],
+    records: &[&[u8]],
+    aliases: &[(&str, u8, &str, u8)],
+) -> Vec<u8> {
+    #[derive(Clone, Copy)]
+    enum Edge {
+        Empty,
+        Node(usize),
+        Record(usize),
+    }
+    fn bits(address: &str) -> (u128, u8) {
+        match address.parse::<std::net::IpAddr>().unwrap() {
+            std::net::IpAddr::V4(address) => (u128::from(u32::from(address)), 32),
+            std::net::IpAddr::V6(address) => (u128::from(address), 128),
+        }
+    }
+    fn parent(nodes: &mut Vec<[Edge; 2]>, address: &str, prefix: u8) -> (usize, usize) {
+        let (address, width) = bits(address);
+        let mut node = 0;
+        for bit in 0..prefix - 1 {
+            let branch = ((address >> (width - bit - 1)) & 1) as usize;
+            node = match nodes[node][branch] {
+                Edge::Node(next) => next,
+                Edge::Empty => {
+                    let next = nodes.len();
+                    nodes.push([Edge::Empty; 2]);
+                    nodes[node][branch] = Edge::Node(next);
+                    next
+                }
+                Edge::Record(_) => panic!("route overlaps another route"),
+            };
+        }
+        (node, ((address >> (width - prefix)) & 1) as usize)
+    }
+    let mut nodes = vec![[Edge::Empty; 2]];
+    for &(address, prefix, record) in routes {
+        let (node, branch) = parent(&mut nodes, address, prefix);
+        nodes[node][branch] = Edge::Record(record);
+    }
+    for &(address, prefix, target, target_prefix) in aliases {
+        let (target_node, target_branch) = parent(&mut nodes, target, target_prefix);
+        let Edge::Node(target) = nodes[target_node][target_branch] else {
+            panic!("alias target must be a tree node")
+        };
+        let (node, branch) = parent(&mut nodes, address, prefix);
+        nodes[node][branch] = Edge::Node(target);
+    }
+    let mut offsets = Vec::new();
+    let mut data = Vec::new();
+    for record in records {
+        offsets.push(data.len());
+        data.extend_from_slice(record);
+    }
+    let mut bytes = Vec::new();
+    for node in &nodes {
+        for edge in node {
+            let pointer = match edge {
+                Edge::Empty => nodes.len(),
+                Edge::Node(node) => *node,
+                Edge::Record(record) => nodes.len() + 16 + offsets[*record],
+            };
+            assert!(pointer < 1 << 24);
+            bytes.extend_from_slice(&(pointer as u32).to_be_bytes()[1..]);
+        }
+    }
+    bytes.extend_from_slice(&[0; 16]);
+    bytes.extend_from_slice(&data);
+    let marker = b"\xab\xcd\xefMaxMind.com";
+    let start = META
+        .windows(marker.len())
+        .position(|part| part == marker)
+        .unwrap();
+    let mut metadata = META[start..].to_vec();
+    let at = metadata
+        .windows(10)
+        .position(|part| part == b"node_count")
+        .unwrap()
+        + 10;
+    let count = u32::try_from(nodes.len()).unwrap().to_be_bytes();
+    metadata.splice(at..at + 2, [0xc4].into_iter().chain(count));
+    if !ipv6 {
+        let at = metadata
+            .windows(10)
+            .position(|part| part == b"ip_version")
+            .unwrap()
+            + 11;
+        metadata[at] = 4;
+    }
+    bytes.extend_from_slice(&metadata);
+    maxminddb::Reader::from_source(bytes.as_slice())
+        .unwrap()
+        .verify()
+        .unwrap();
+    bytes
+}
+
+// Decode with independent serde-owned values for parity with the unprojected
+// official reader, including invalid typed records and no-record inversion.
+fn meta_reader_matches(
+    reader: &maxminddb::Reader<&[u8]>,
+    selector: &str,
+    address: std::net::IpAddr,
+) -> bool {
+    #[derive(serde::Deserialize)]
+    #[serde(untagged)]
+    enum Codes {
+        One(String),
+        Many(Vec<String>),
+    }
+    let Ok(record) = reader.lookup(address) else {
+        return false;
+    };
+    let Ok(codes) = record.decode::<Codes>() else {
+        return false;
+    };
+    let code = selector
+        .strip_prefix('!')
+        .unwrap_or(selector)
+        .to_ascii_lowercase();
+    let matched = match codes {
+        Some(Codes::One(value)) => value == code,
+        Some(Codes::Many(values)) => values.contains(&code),
+        None => false,
+    };
+    matched != selector.starts_with('!')
+}
+
+#[test]
+fn country_meta_projection_preserves_multicode_aliases_and_random_lookup_parity() {
+    let bytes = meta_projection_fixture(
+        true,
+        &[
+            ("::102:300", 120, 0),
+            ("::808:800", 120, 1),
+            ("2400:3200::", 32, 0),
+            ("8000::", 1, 1),
+            ("4000::", 2, 2),
+            ("3000::", 4, 3),
+        ],
+        &[
+            b"\x02\x04\x42cn\x47private",
+            b"\x42us",
+            b"\x00\x04",
+            b"\x42CN",
+        ],
+        &[
+            ("::ffff:0:0", 96, "::", 96),
+            ("2002::", 16, "::", 96),
+            ("2001::", 32, "::", 96),
+        ],
+    );
+    let directory = tempfile::tempdir().unwrap();
+    let path = directory.path().join("geoip.metadb");
+    fs::write(&path, &bytes).unwrap();
+    let selectors = ["cn", "!cn", "private", "!private", "us", "zz", "!zz"].map(String::from);
+    let database = country::CountryDb::load(&path, &selectors).unwrap();
+    assert!(
+        database.capacity() < bytes.len(),
+        "projection must replace owned file bytes"
+    );
+    let cn = country::CountryDb::load(&path, &["cn".into()]).unwrap();
+    let both = country::CountryDb::load(&path, &["cn".into(), "!cn".into()]).unwrap();
+    assert_eq!(
+        both.capacity() - cn.capacity(),
+        std::mem::size_of::<String>() + 3
+    );
+    assert!(database.available("!ZZ"));
+    assert!(!database.available("other"));
+    let reader = maxminddb::Reader::from_source(bytes.as_slice()).unwrap();
+    let mut addresses = [
+        "1.2.2.255",
+        "1.2.3.0",
+        "1.2.3.255",
+        "1.2.4.0",
+        "8.8.8.8",
+        "0.0.0.0",
+        "255.255.255.255",
+        "::102:304",
+        "::ffff:102:304",
+        "2002:102:304::",
+        "2001:0:102:304::",
+        "::ffff:102:2ff",
+        "2002:102:400::",
+        "2001:0:102:400::",
+        "::",
+        "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff",
+        "2400:31ff:ffff:ffff:ffff:ffff:ffff:ffff",
+        "2400:3200::",
+        "2400:3200:ffff:ffff:ffff:ffff:ffff:ffff",
+        "2400:3201::",
+        "3000::1",
+        "4000::1",
+        "6000::1",
+        "8000::1",
+    ]
+    .map(|value| value.parse::<std::net::IpAddr>().unwrap())
+    .to_vec();
+    let mut state = 0x1234_5678_9abc_def0_u64;
+    for _ in 0..512 {
+        state ^= state << 13;
+        state ^= state >> 7;
+        state ^= state << 17;
+        addresses.push(std::net::Ipv4Addr::from(state as u32).into());
+        addresses.push(
+            std::net::Ipv6Addr::from((u128::from(state) << 64) | u128::from(state.rotate_left(23)))
+                .into(),
+        );
+    }
+    for address in addresses {
+        for selector in selectors.iter().map(String::as_str).chain(["CN", "!CN"]) {
+            assert_eq!(
+                database.matches(selector, address),
+                meta_reader_matches(&reader, selector, address),
+                "{selector} {address}"
+            );
+        }
+    }
+    assert_eq!(fs::read(path).unwrap(), bytes);
+}
+
+#[test]
+fn country_meta_projection_preserves_ipv4_only_and_early_ipv6_leaf() {
+    let bytes = meta_projection_fixture(false, &[("1.2.3.0", 24, 0)], &[b"\x42cn"], &[]);
+    for bytes in [bytes.as_slice(), META] {
+        let directory = tempfile::tempdir().unwrap();
+        let path = directory.path().join("geoip.metadb");
+        fs::write(&path, bytes).unwrap();
+        let selectors = ["cn".into(), "!cn".into()];
+        let database = country::CountryDb::load(&path, &selectors).unwrap();
+        assert!(database.capacity() < bytes.len());
+        let reader = maxminddb::Reader::from_source(bytes).unwrap();
+        for address in [
+            "1.2.3.4",
+            "8.8.8.8",
+            "0.0.0.0",
+            "::",
+            "::102:304",
+            "::ffff:102:304",
+            "2001:db8::1",
+            "8000::1",
+        ] {
+            let address = address.parse().unwrap();
+            for selector in &selectors {
+                assert_eq!(
+                    database.matches(selector, address),
+                    meta_reader_matches(&reader, selector, address),
+                    "{selector} {address}"
+                );
+            }
+        }
+    }
+}
+
+#[test]
+fn country_meta_projection_retains_reader_for_invalid_records_or_larger_indexes() {
+    // The first record is valid and matches CN; the later structurally valid
+    // map is not a country string/array. It must never invert into a match.
+    let invalid = meta_projection_fixture(
+        false,
+        &[("0.0.0.0", 1, 0), ("128.0.0.0", 1, 1)],
+        &[b"\x42cn", b"\xe0"],
+        &[],
+    );
+    let many = (0..32)
+        .map(|value| format!("code{value}"))
+        .chain(["cn".into(), "!cn".into()])
+        .collect::<Vec<_>>();
+    for (bytes, selectors) in [
+        (invalid.as_slice(), vec!["cn".into(), "!cn".into()]),
+        (META, many),
+    ] {
+        let directory = tempfile::tempdir().unwrap();
+        let path = directory.path().join("geoip.metadb");
+        fs::write(&path, bytes).unwrap();
+        let database = country::CountryDb::load(&path, &selectors).unwrap();
+        assert!(database.capacity() >= bytes.len());
+        let reader = maxminddb::Reader::from_source(bytes).unwrap();
+        for address in ["1.2.3.4", "128.0.0.1", "8.8.8.8", "2001:db8::1", "8000::1"] {
+            let address = address.parse().unwrap();
+            for selector in &selectors {
+                assert!(database.available(selector));
+                assert_eq!(
+                    database.matches(selector, address),
+                    meta_reader_matches(&reader, selector, address),
+                    "{selector} {address}"
+                );
+            }
+        }
+    }
+}
diff --git a/src/geodata/manager.rs b/src/geodata/manager.rs
index fe2bab7..f7f12c5 100644
--- a/src/geodata/manager.rs
+++ b/src/geodata/manager.rs
@@ -39,7 +39,7 @@ struct SnapshotReleaseState {
 
 impl SnapshotReleaseState {
     fn wait(&self, cancellation: &CancellationToken) -> Result<(), GeoDataManagerError> {
-        let deadline = Instant::now() + super::updater::DEFAULT_DOWNLOAD_TIMEOUT;
+        let deadline = Instant::now() + crate::resource::http::DEFAULT_DOWNLOAD_TIMEOUT;
         let mut released = lock(&self.released);
         while !*released {
             check_cancellation(cancellation)?;
@@ -119,6 +119,12 @@ impl std::fmt::Debug for DynamicGeoData {
 }
 
 impl GeoMatcher for DynamicGeoData {
+    fn asn_available(&self) -> bool {
+        self.current.load().asn_available()
+    }
+    fn matches_asn(&self, payload: &str, address: IpAddr) -> bool {
+        self.current.load().matches_asn(payload, address)
+    }
     fn routing_snapshot(&self) -> Option<Arc<dyn GeoMatcher>> {
         Some(self.current.load_full())
     }
@@ -135,6 +141,17 @@ impl GeoMatcher for DynamicGeoData {
         self.current.load().matches_geosite(code, domain)
     }
 
+    fn matches_geosite_bounded(
+        &self,
+        code: &str,
+        domain: &str,
+        decision: &crate::config::RuleDecision,
+    ) -> Result<bool, crate::config::MatchFailure> {
+        self.current
+            .load()
+            .matches_geosite_bounded(code, domain, decision)
+    }
+
     fn matches_geoip(&self, code: &str, address: IpAddr) -> bool {
         self.current.load().matches_geoip(code, address)
     }
@@ -179,6 +196,7 @@ impl GeoDataResourceReport {
 pub struct GeoDataLoadReport {
     pub geosite: GeoDataResourceReport,
     pub geoip: GeoDataResourceReport,
+    pub asn: GeoDataResourceReport,
     pub allocation_capacity: usize,
     pub peak_allocation_capacity: usize,
 }
@@ -189,6 +207,7 @@ impl GeoDataLoadReport {
         match kind {
             GeoDataKind::GeoSite => &self.geosite,
             GeoDataKind::GeoIp => &self.geoip,
+            GeoDataKind::Asn => &self.asn,
         }
     }
 }
@@ -207,6 +226,8 @@ pub struct GeoResourceState {
     pub etag: Option<String>,
     pub hash: Option<String>,
     pub(crate) source_url: Option<String>,
+    pub(crate) source_identity: Option<String>,
+    pub(crate) asset_identity: Option<String>,
 }
 
 /// Current resource-manager view.
@@ -214,6 +235,7 @@ pub struct GeoResourceState {
 pub struct GeoDataStatus {
     pub geosite: GeoResourceState,
     pub geoip: GeoResourceState,
+    pub asn: GeoResourceState,
 }
 
 impl GeoDataStatus {
@@ -222,6 +244,7 @@ impl GeoDataStatus {
         match kind {
             GeoDataKind::GeoSite => &self.geosite,
             GeoDataKind::GeoIp => &self.geoip,
+            GeoDataKind::Asn => &self.asn,
         }
     }
 }
@@ -233,6 +256,8 @@ pub struct GeoDataReloadReport {
     pub geosite_available: bool,
     pub geoip_required: bool,
     pub geoip_available: bool,
+    pub asn_required: bool,
+    pub asn_available: bool,
 }
 
 #[derive(Debug, Error)]
@@ -271,6 +296,10 @@ struct PersistentResourceState {
     hash: Option<String>,
     #[serde(default)]
     source_url: Option<String>,
+    #[serde(default)]
+    source_identity: Option<String>,
+    #[serde(default)]
+    asset_identity: Option<String>,
 }
 
 impl PersistentResourceState {
@@ -290,7 +319,21 @@ impl PersistentResourceState {
                 .or_else(|| self.last_error.clone()),
             etag: self.etag.clone(),
             hash: self.hash.clone(),
-            source_url: self.source_url.clone(),
+            source_url: self
+                .source_url
+                .as_deref()
+                .and_then(crate::resource::http::source_origin),
+            source_identity: self.source_identity.clone().or_else(|| {
+                self.source_url
+                    .as_deref()
+                    .filter(|raw| {
+                        url::Url::parse(raw).ok().is_some_and(|url| {
+                            url.username().is_empty() && url.password().is_none()
+                        })
+                    })
+                    .map(crate::resource::http::source_identity)
+            }),
+            asset_identity: self.asset_identity.clone(),
         }
     }
 }
@@ -304,6 +347,8 @@ struct PersistentState {
     geosite: PersistentResourceState,
     #[serde(default)]
     geoip: PersistentResourceState,
+    #[serde(default)]
+    asn: PersistentResourceState,
 }
 
 impl PersistentState {
@@ -311,6 +356,7 @@ impl PersistentState {
         match kind {
             GeoDataKind::GeoSite => &mut self.geosite,
             GeoDataKind::GeoIp => &mut self.geoip,
+            GeoDataKind::Asn => &mut self.asn,
         }
     }
 }
@@ -323,6 +369,7 @@ const fn state_version() -> u8 {
 struct RegistrationEntry {
     lease: Arc<()>,
     requirements: GeoRequirements,
+    assets: AssetPaths,
     matcher: Arc<DynamicGeoData>,
     report: GeoDataLoadReport,
     retired: Option<Arc<SnapshotReleaseState>>,
@@ -340,11 +387,49 @@ impl RegistrationEntry {
         self.report = GeoDataLoadReport {
             geosite: dormant_report(&self.requirements, GeoDataKind::GeoSite),
             geoip: dormant_report(&self.requirements, GeoDataKind::GeoIp),
+            asn: dormant_report(&self.requirements, GeoDataKind::Asn),
             allocation_capacity: 0,
             peak_allocation_capacity: 0,
         };
     }
 
+    /// MMDB candidates are fully verified while old data is still usable.
+    /// Retain one rollback reference until all other snapshot readers finish.
+    fn unload_verified_database(
+        &mut self,
+        cancellation: &CancellationToken,
+    ) -> Result<(), GeoDataManagerError> {
+        self.drain(cancellation)?;
+        let mut old = self.matcher.current.swap(Arc::new(GeoData::EMPTY));
+        let deadline = Instant::now() + crate::resource::http::DEFAULT_DOWNLOAD_TIMEOUT;
+        loop {
+            if let Err(error) = check_cancellation(cancellation) {
+                self.matcher.activate(old);
+                return Err(error);
+            }
+            // try_unwrap atomically obtains exclusive ownership, so a Weak
+            // upgrade cannot retain the old payload after this succeeds.
+            match Arc::try_unwrap(old) {
+                Ok(snapshot) => {
+                    // Payload fields drop before SnapshotRelease.
+                    drop(snapshot);
+                    break;
+                }
+                Err(snapshot) => old = snapshot,
+            }
+            let remaining = deadline.saturating_duration_since(Instant::now());
+            if remaining.is_zero() {
+                self.matcher.activate(old);
+                return Err(GeoDataManagerError::Validation(
+                    "GeoData readers did not release the retired snapshot in time".to_owned(),
+                ));
+            }
+            std::thread::sleep(remaining.min(Duration::from_millis(25)));
+        }
+        self.unload();
+        Ok(())
+    }
+
     fn drain(&mut self, cancellation: &CancellationToken) -> Result<(), GeoDataManagerError> {
         if let Some(retired) = &self.retired {
             retired.wait(cancellation)?;
@@ -360,6 +445,121 @@ impl RegistrationEntry {
     }
 }
 
+fn restore_requirement_matcher(
+    entry: &mut RegistrationEntry,
+    old: &std::sync::Weak<GeoData>,
+    old_report: GeoDataLoadReport,
+) {
+    let (snapshot, report) = old.upgrade().map_or_else(
+        || load_snapshot(&entry.assets, &entry.requirements),
+        |snapshot| (snapshot, old_report),
+    );
+    entry.retired = None;
+    entry.publish(snapshot, report);
+}
+
+/// Fixed paths for one registration. MMDB discovery never changes the store
+/// used by GeoSite/ASN, state, locks, or provider data-directory derivation.
+#[derive(Debug, Clone)]
+struct AssetPaths {
+    store_dir: PathBuf,
+    geoip: PathBuf,
+    mmdb: bool,
+    discovery_error: Option<String>,
+}
+
+impl AssetPaths {
+    fn dat(store_dir: &Path) -> Self {
+        Self {
+            store_dir: store_dir.into(),
+            geoip: store_dir.join(super::GEOIP_FILE_NAME),
+            mmdb: false,
+            discovery_error: None,
+        }
+    }
+
+    fn for_registration(store_dir: &Path, geodata_mode: bool) -> Self {
+        Self::discover(store_dir, geodata_mode).unwrap_or_else(|error| Self {
+            store_dir: store_dir.into(),
+            geoip: store_dir.parent().unwrap_or(store_dir).join("geoip.metadb"),
+            mmdb: true,
+            discovery_error: Some(bounded_error(error.to_string())),
+        })
+    }
+
+    fn discover(store_dir: &Path, geodata_mode: bool) -> Result<Self, GeoDataManagerError> {
+        if geodata_mode {
+            return Ok(Self::dat(store_dir));
+        }
+        let root = store_dir.parent().unwrap_or(store_dir);
+        let mut selected = None;
+        for entry in fs::read_dir(root).map_err(|source| io_at(root, source))? {
+            let entry = entry.map_err(|source| io_at(root, source))?;
+            let name = entry.file_name();
+            let Some(text) = name.to_str() else { continue };
+            if !["Country.mmdb", "geoip.db", "geoip.metadb"]
+                .iter()
+                .any(|expected| text.eq_ignore_ascii_case(expected))
+                || entry
+                    .file_type()
+                    .map_err(|source| io_at(&entry.path(), source))?
+                    .is_dir()
+            {
+                continue;
+            }
+            if selected.as_ref().is_none_or(|old| &name < old) {
+                selected = Some(name);
+            }
+        }
+        Ok(Self {
+            store_dir: store_dir.into(),
+            geoip: root.join(selected.unwrap_or_else(|| "geoip.metadb".into())),
+            mmdb: true,
+            discovery_error: None,
+        })
+    }
+
+    fn path(&self, kind: GeoDataKind) -> PathBuf {
+        if kind == GeoDataKind::GeoIp {
+            self.geoip.clone()
+        } else {
+            self.store_dir.join(kind.file_name())
+        }
+    }
+
+    fn identity(&self, kind: GeoDataKind) -> String {
+        if kind == GeoDataKind::GeoIp {
+            format!(
+                "{}:{}",
+                if self.mmdb { "mmdb" } else { "dat" },
+                self.geoip.file_name().unwrap().to_string_lossy()
+            )
+        } else {
+            kind.file_name().into()
+        }
+    }
+
+    fn staged(&self, directory: &Path) -> Self {
+        Self {
+            store_dir: directory.into(),
+            geoip: directory.join(self.geoip.file_name().unwrap()),
+            mmdb: self.mmdb,
+            discovery_error: self.discovery_error.clone(),
+        }
+    }
+}
+
+enum VerifiedCandidate {
+    Asn(super::asn::AsnCandidate),
+    Country(super::country::CountryCandidate),
+}
+
+#[derive(Default)]
+struct UpdateSource {
+    url: Option<String>,
+    etag: Option<String>,
+}
+
 fn dormant_report(requirements: &GeoRequirements, kind: GeoDataKind) -> GeoDataResourceReport {
     if requirements.requires(kind) {
         GeoDataResourceReport::degraded("GeoData matcher is unavailable while reloading")
@@ -383,7 +583,7 @@ fn check_cancellation(cancellation: &CancellationToken) -> Result<(), GeoDataMan
 #[derive(Debug)]
 pub struct GeoDataManager {
     store_dir: PathBuf,
-    update_interval: Duration,
+    update_interval: AtomicU64,
     state: Mutex<PersistentState>,
     registration: Mutex<Option<RegistrationEntry>>,
 }
@@ -404,7 +604,7 @@ impl GeoDataManager {
         let state = read_initial_state(&store_dir)?;
         let manager = Arc::new(Self {
             store_dir,
-            update_interval,
+            update_interval: AtomicU64::new(update_interval.as_secs()),
             state: Mutex::new(state),
             registration: Mutex::new(None),
         });
@@ -426,17 +626,32 @@ impl GeoDataManager {
     pub fn register(
         self: &Arc<Self>,
         requirements: GeoRequirements,
+    ) -> Result<GeoDataRegistration, GeoDataManagerError> {
+        self.register_with_interval(
+            requirements,
+            Duration::from_secs(self.update_interval.load(Ordering::Relaxed)),
+        )
+    }
+
+    pub(crate) fn register_with_interval(
+        self: &Arc<Self>,
+        requirements: GeoRequirements,
+        interval: Duration,
     ) -> Result<GeoDataRegistration, GeoDataManagerError> {
         let mut registration = lock(&self.registration);
         if registration.is_some() {
             return Err(GeoDataManagerError::RegistrationActive);
         }
-        let (snapshot, report) = load_snapshot(&self.store_dir, &requirements);
+        self.update_interval
+            .store(interval.as_secs(), Ordering::Relaxed);
+        let assets = AssetPaths::for_registration(&self.store_dir, requirements.geodata_mode);
+        let (snapshot, report) = load_snapshot(&assets, &requirements);
         let matcher = Arc::new(DynamicGeoData::new(snapshot));
         let lease = Arc::new(());
         *registration = Some(RegistrationEntry {
             lease: lease.clone(),
             requirements,
+            assets,
             matcher: matcher.clone(),
             report: report.clone(),
             retired: None,
@@ -473,22 +688,68 @@ impl GeoDataManager {
             // even when cancellation prevents unloading the current matcher.
             entry.reload_pending = true;
             check_cancellation(cancellation)?;
+            if entry.assets.discovery_error.is_some() {
+                entry.assets =
+                    AssetPaths::for_registration(&self.store_dir, entry.requirements.geodata_mode);
+            }
             entry.unload();
             entry.drain(cancellation)?;
-            let (snapshot, report) = load_snapshot(&self.store_dir, &entry.requirements);
+            let (snapshot, report) = load_snapshot(&entry.assets, &entry.requirements);
             check_cancellation(cancellation)?;
             entry.publish(snapshot, report);
         }
         Ok(reload_report(registration.as_ref()))
     }
 
+    pub(crate) fn replace_requirements(
+        &self,
+        lease: &GeoDataRegistrationLease,
+        requirements: GeoRequirements,
+        cancellation: &CancellationToken,
+    ) -> Result<(), GeoDataManagerError> {
+        let mut registration = lock(&self.registration);
+        let entry = registration
+            .as_mut()
+            .filter(|entry| lease.matches(entry))
+            .ok_or(GeoDataManagerError::RegistrationActive)?;
+        if entry.requirements == requirements && !entry.reload_pending {
+            return Ok(());
+        }
+        check_cancellation(cancellation)?;
+        // Do not retain a second full GeoData allocation while draining. A weak
+        // rollback reference can recover a reader-held payload; once drained,
+        // reload the original requirements from their unchanged asset paths.
+        let old = Arc::downgrade(&entry.matcher.snapshot());
+        let old_report = entry.report.clone();
+        let next_assets = if entry.requirements.geodata_mode != requirements.geodata_mode {
+            AssetPaths::for_registration(&self.store_dir, requirements.geodata_mode)
+        } else {
+            entry.assets.clone()
+        };
+        entry.unload();
+        if let Err(error) = entry.drain(cancellation) {
+            restore_requirement_matcher(entry, &old, old_report);
+            return Err(error);
+        }
+        let (snapshot, report) = load_snapshot(&next_assets, &requirements);
+        if let Err(error) = check_cancellation(cancellation) {
+            drop(snapshot);
+            restore_requirement_matcher(entry, &old, old_report);
+            return Err(error);
+        }
+        entry.assets = next_assets;
+        entry.requirements = requirements;
+        entry.publish(snapshot, report);
+        Ok(())
+    }
+
     fn refresh_durable_state(
         &self,
         cancellation: &CancellationToken,
     ) -> Result<PersistentState, GeoDataManagerError> {
         check_cancellation(cancellation)?;
         let mut disk = read_state(&self.store_dir)?;
-        if disk.geosite.updating || disk.geoip.updating {
+        if disk.geosite.updating || disk.geoip.updating || disk.asn.updating {
             self.recover_interrupted_state()?;
             disk = read_state(&self.store_dir)?;
         }
@@ -523,7 +784,7 @@ impl GeoDataManager {
 
     /// Returns the durable scheduling state for the active registration.
     /// `None` means the supplied lease is stale or already dropped.
-    fn status_for_active_registration(
+    pub(super) fn status_for_active_registration(
         &self,
         lease: &GeoDataRegistrationLease,
         cancellation: &CancellationToken,
@@ -540,7 +801,7 @@ impl GeoDataManager {
     pub fn due_resources(&self, now: SystemTime) -> Result<Vec<GeoDataKind>, GeoDataManagerError> {
         let now = unix_seconds(now);
         let status = self.status()?;
-        Ok([GeoDataKind::GeoSite, GeoDataKind::GeoIp]
+        Ok(GeoDataKind::ALL
             .into_iter()
             .filter(|kind| {
                 let resource = status.resource(*kind);
@@ -558,10 +819,10 @@ impl GeoDataManager {
     /// A source change is immediately due regardless of the previous source's
     /// durable next-check time.
     #[cfg(test)]
-    pub(crate) fn due_resources_for_active_registration(
+    pub(crate) fn due_resources_for_active_registration<const N: usize>(
         &self,
         lease: &GeoDataRegistrationLease,
-        sources: [(GeoDataKind, &str); 2],
+        sources: [(GeoDataKind, &str); N],
         now: SystemTime,
     ) -> Result<Vec<GeoDataKind>, GeoDataManagerError> {
         self.due_resources_for_active_registration_with_cancellation(
@@ -572,10 +833,10 @@ impl GeoDataManager {
         )
     }
 
-    pub(crate) fn due_resources_for_active_registration_with_cancellation(
+    pub(crate) fn due_resources_for_active_registration_with_cancellation<const N: usize>(
         &self,
         lease: &GeoDataRegistrationLease,
-        sources: [(GeoDataKind, &str); 2],
+        sources: [(GeoDataKind, &str); N],
         now: SystemTime,
         cancellation: &CancellationToken,
     ) -> Result<Vec<GeoDataKind>, GeoDataManagerError> {
@@ -583,10 +844,21 @@ impl GeoDataManager {
         let Some(status) = self.status_for_active_registration(lease, cancellation)? else {
             return Ok(Vec::new());
         };
+        let registration = lock(&self.registration);
+        let Some(entry) = registration.as_ref().filter(|entry| lease.matches(entry)) else {
+            return Ok(Vec::new());
+        };
         Ok(sources
             .into_iter()
             .filter_map(|(kind, source_url)| {
-                resource_due(status.resource(kind), source_url, now).then_some(kind)
+                resource_due(
+                    status.resource(kind),
+                    source_url,
+                    &entry.assets.identity(kind),
+                    now,
+                    self.update_interval.load(Ordering::Relaxed),
+                )
+                .then_some(kind)
             })
             .collect())
     }
@@ -601,7 +873,18 @@ impl GeoDataManager {
     ) -> Result<GeoUpdateSession, GeoDataManagerError> {
         let lock_file = self.acquire_update_lock()?;
         let state = read_state(&self.store_dir)?;
-        self.start_update_session(kind, None, None, None, lock_file, state)
+        let assets = lock(&self.registration).as_ref().map_or_else(
+            || AssetPaths::dat(&self.store_dir),
+            |entry| entry.assets.clone(),
+        );
+        self.start_update_session(
+            kind,
+            UpdateSource::default(),
+            None,
+            lock_file,
+            state,
+            assets,
+        )
     }
 
     /// Begins a source-bound update only if the active registration is still
@@ -632,6 +915,36 @@ impl GeoDataManager {
         source_url: &str,
         now: SystemTime,
         cancellation: &CancellationToken,
+    ) -> Result<Option<GeoUpdateSession>, GeoDataManagerError> {
+        self.begin_registration_update(lease, kind, source_url, now, cancellation, false)
+    }
+
+    pub(crate) fn force_update_for_active_registration_with_cancellation(
+        self: &Arc<Self>,
+        lease: &GeoDataRegistrationLease,
+        kind: GeoDataKind,
+        source_url: &str,
+        cancellation: &CancellationToken,
+    ) -> Result<Option<GeoUpdateSession>, GeoDataManagerError> {
+        self.begin_registration_update(
+            lease,
+            kind,
+            source_url,
+            SystemTime::now(),
+            cancellation,
+            true,
+        )
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn begin_registration_update(
+        self: &Arc<Self>,
+        lease: &GeoDataRegistrationLease,
+        kind: GeoDataKind,
+        source_url: &str,
+        now: SystemTime,
+        cancellation: &CancellationToken,
+        force: bool,
     ) -> Result<Option<GeoUpdateSession>, GeoDataManagerError> {
         check_cancellation(cancellation)?;
         if source_url.len() > MAX_SOURCE_URL_BYTES {
@@ -640,34 +953,51 @@ impl GeoDataManager {
         let lock_file = self.acquire_update_lock()?;
         let state = read_state(&self.store_dir)?;
         self.observe_durable_state(&state, cancellation)?;
-        let status = {
+        let selected = {
             let registration = lock(&self.registration);
             registration
                 .as_ref()
                 .filter(|entry| lease.matches(entry))
-                .map(|entry| scoped_status(&state, &entry.report))
+                .map(|entry| (scoped_status(&state, &entry.report), entry.assets.clone()))
         };
-        let Some(status) = status else {
+        let Some((status, assets)) = selected else {
             return Ok(None);
         };
-        if !resource_due(status.resource(kind), source_url, unix_seconds(now)) {
+        if !status.resource(kind).required {
+            return Ok(None);
+        }
+        if !force
+            && !resource_due(
+                status.resource(kind),
+                source_url,
+                &assets.identity(kind),
+                unix_seconds(now),
+                self.update_interval.load(Ordering::Relaxed),
+            )
+        {
             return Ok(None);
         }
         let resource = status.resource(kind);
-        let request_etag = (resource.source_url.as_deref() == Some(source_url)
+        let request_etag = (resource.source_identity.as_deref()
+            == Some(crate::resource::http::source_identity(source_url).as_str())
+            && resource.asset_identity.as_deref() == Some(assets.identity(kind).as_str())
             && resource.available
-            && resource.hash.as_deref().is_some_and(|expected| {
-                asset_matches_hash(&self.store_dir.join(kind.file_name()), expected)
-            }))
+            && resource
+                .hash
+                .as_deref()
+                .is_some_and(|expected| asset_matches_hash(&assets.path(kind), expected)))
         .then(|| resource.etag.clone())
         .flatten();
         self.start_update_session(
             kind,
-            Some(source_url.to_owned()),
-            request_etag,
+            UpdateSource {
+                url: Some(source_url.to_owned()),
+                etag: request_etag,
+            },
             Some(lease.clone()),
             lock_file,
             state,
+            assets,
         )
         .map(Some)
     }
@@ -685,19 +1015,31 @@ impl GeoDataManager {
     fn start_update_session(
         self: &Arc<Self>,
         kind: GeoDataKind,
-        source_url: Option<String>,
-        request_etag: Option<String>,
+        source: UpdateSource,
         validation_lease: Option<GeoDataRegistrationLease>,
         lock_file: File,
         mut state: PersistentState,
+        mut assets: AssetPaths,
     ) -> Result<GeoUpdateSession, GeoDataManagerError> {
-        let staging_dir = self.store_dir.join(format!(
+        if kind == GeoDataKind::GeoIp && assets.discovery_error.is_some() {
+            assets = AssetPaths::discover(&self.store_dir, !assets.mmdb)?;
+            if let Some(entry) = lock(&self.registration).as_mut()
+                && entry.assets.discovery_error.is_some()
+                && entry.assets.mmdb == assets.mmdb
+                && validation_lease
+                    .as_ref()
+                    .is_none_or(|lease| lease.matches(entry))
+            {
+                entry.assets = assets.clone();
+            }
+        }
+        let staging_dir = assets.path(kind).parent().unwrap().join(format!(
             ".update-{}-{}",
             std::process::id(),
             next_nonzero_id(&NEXT_TEMP_ID)
         ));
         create_private_directory_new(&staging_dir)?;
-        let staging_path = staging_dir.join(kind.file_name());
+        let staging_path = assets.staged(&staging_dir).path(kind);
 
         state.resource_mut(kind).updating = true;
         persist_state(&self.store_dir, &state)?;
@@ -706,11 +1048,12 @@ impl GeoDataManager {
         Ok(GeoUpdateSession {
             manager: self.clone(),
             kind,
+            assets,
             lock_file,
             staging_dir,
             staging_path,
-            source_url,
-            request_etag,
+            source_url: source.url,
+            request_etag: source.etag,
             validation_lease,
             completed: false,
         })
@@ -730,7 +1073,7 @@ impl GeoDataManager {
         }
         let mut state = read_state(&self.store_dir)?;
         let mut changed = false;
-        for kind in [GeoDataKind::GeoSite, GeoDataKind::GeoIp] {
+        for kind in GeoDataKind::ALL {
             let resource = state.resource_mut(kind);
             if resource.updating {
                 resource.updating = false;
@@ -750,22 +1093,36 @@ impl GeoDataManager {
         &self,
         kind: GeoDataKind,
         candidate_dir: &Path,
-    ) -> Result<(), GeoDataManagerError> {
-        validate_asset_structure(candidate_dir, kind)
-            .map_err(|error| GeoDataManagerError::Validation(error.to_string()))?;
-
-        let other = match kind {
-            GeoDataKind::GeoSite => GeoDataKind::GeoIp,
-            GeoDataKind::GeoIp => GeoDataKind::GeoSite,
+        assets: &AssetPaths,
+    ) -> Result<Option<VerifiedCandidate>, GeoDataManagerError> {
+        let verified = if kind == GeoDataKind::Asn {
+            Some(VerifiedCandidate::Asn(
+                super::asn::AsnCandidate::load(candidate_dir)
+                    .map_err(|error| GeoDataManagerError::Validation(error.to_string()))?,
+            ))
+        } else if kind == GeoDataKind::GeoIp && assets.mmdb {
+            Some(VerifiedCandidate::Country(
+                super::country::CountryCandidate::load(&assets.staged(candidate_dir).geoip)
+                    .map_err(|error| GeoDataManagerError::Validation(error.to_string()))?,
+            ))
+        } else {
+            None
         };
-        let other_source = self.store_dir.join(other.file_name());
-        let other_candidate = candidate_dir.join(other.file_name());
-        if other_source.is_file() && fs::hard_link(&other_source, &other_candidate).is_err() {
-            fs::copy(&other_source, &other_candidate)
-                .map_err(|source| io_at(&other_candidate, source))?;
+        if verified.is_none() {
+            validate_asset_structure(candidate_dir, kind)
+                .map_err(|error| GeoDataManagerError::Validation(error.to_string()))?;
         }
 
-        Ok(())
+        for other in GeoDataKind::ALL.into_iter().filter(|other| *other != kind) {
+            let other_source = assets.path(other);
+            let other_candidate = assets.staged(candidate_dir).path(other);
+            if other_source.is_file() && fs::hard_link(&other_source, &other_candidate).is_err() {
+                fs::copy(&other_source, &other_candidate)
+                    .map_err(|source| io_at(&other_candidate, source))?;
+            }
+        }
+
+        Ok(verified)
     }
 
     fn finish_success(
@@ -774,9 +1131,10 @@ impl GeoDataManager {
         source_url: Option<String>,
         etag: Option<String>,
         hash: String,
+        asset_identity: String,
     ) -> Result<(), GeoDataManagerError> {
         let now = unix_seconds(SystemTime::now());
-        let interval = self.update_interval.as_secs();
+        let interval = self.update_interval.load(Ordering::Relaxed);
         let mut state = read_state(&self.store_dir)?;
         let resource = state.resource_mut(kind);
         resource.available = true;
@@ -786,7 +1144,13 @@ impl GeoDataManager {
         resource.last_error = None;
         resource.etag = etag;
         resource.hash = Some(hash);
-        resource.source_url = source_url;
+        resource.source_identity = source_url
+            .as_deref()
+            .map(crate::resource::http::source_identity);
+        resource.source_url = source_url
+            .as_deref()
+            .and_then(crate::resource::http::source_origin);
+        resource.asset_identity = Some(asset_identity);
         persist_state(&self.store_dir, &state)?;
         *lock(&self.state) = state;
         Ok(())
@@ -797,17 +1161,26 @@ impl GeoDataManager {
         kind: GeoDataKind,
         source_url: Option<String>,
         etag: Option<String>,
+        asset_identity: String,
     ) -> Result<(), GeoDataManagerError> {
         let now = unix_seconds(SystemTime::now());
         let mut state = read_state(&self.store_dir)?;
         let resource = state.resource_mut(kind);
         resource.updating = false;
-        resource.next_check = Some(now.saturating_add(self.update_interval.as_secs()));
+        resource.last_success = Some(now);
+        resource.next_check =
+            Some(now.saturating_add(self.update_interval.load(Ordering::Relaxed)));
         resource.last_error = None;
         if etag.is_some() {
             resource.etag = etag;
         }
-        resource.source_url = source_url;
+        resource.source_identity = source_url
+            .as_deref()
+            .map(crate::resource::http::source_identity);
+        resource.source_url = source_url
+            .as_deref()
+            .and_then(crate::resource::http::source_origin);
+        resource.asset_identity = Some(asset_identity);
         persist_state(&self.store_dir, &state)?;
         *lock(&self.state) = state;
         Ok(())
@@ -907,6 +1280,7 @@ impl Drop for GeoDataRegistration {
 pub struct GeoUpdateSession {
     manager: Arc<GeoDataManager>,
     kind: GeoDataKind,
+    assets: AssetPaths,
     lock_file: File,
     staging_dir: PathBuf,
     staging_path: PathBuf,
@@ -1001,21 +1375,23 @@ impl GeoUpdateSession {
         let mut registration = lock(&self.manager.registration);
         self.validate_active_lease(registration.as_ref())?;
         let candidate = if let Some(entry) = registration.as_mut()
-            && [GeoDataKind::GeoSite, GeoDataKind::GeoIp]
-                .into_iter()
-                .any(|kind| {
-                    let report = entry.report.resource(kind);
-                    report.required && !report.available
-                }) {
+            && GeoDataKind::ALL.into_iter().any(|kind| {
+                let report = entry.report.resource(kind);
+                report.required && !report.available
+            }) {
             entry.unload();
             entry.drain(cancellation)?;
-            Some(load_snapshot(&self.manager.store_dir, &entry.requirements))
+            Some(load_snapshot(&entry.assets, &entry.requirements))
         } else {
             None
         };
         check_cancellation(cancellation)?;
-        self.manager
-            .finish_not_modified(self.kind, self.source_url.clone(), etag)?;
+        self.manager.finish_not_modified(
+            self.kind,
+            self.source_url.clone(),
+            etag,
+            self.assets.identity(self.kind),
+        )?;
         check_cancellation(cancellation)?;
         if let Some(entry) = registration.as_mut()
             && let Some((snapshot, report)) = candidate
@@ -1064,13 +1440,25 @@ impl GeoUpdateSession {
         // Framing checks and disk staging do not allocate matchers. Keep the
         // old rules until this boundary, then release every old reader before
         // constructing the new generation.
-        self.manager.stage_candidate(self.kind, &self.staging_dir)?;
+        let candidate = self
+            .manager
+            .stage_candidate(self.kind, &self.staging_dir, &self.assets)?;
+        if let Some(candidate) = candidate {
+            return self.commit_verified_candidate(
+                &mut registration,
+                candidate,
+                etag,
+                sha256,
+                cancellation,
+            );
+        }
         let candidate = if let Some(entry) = registration.as_mut()
             && entry.requirements.requires(self.kind)
         {
             entry.unload();
             entry.drain(cancellation)?;
-            let (snapshot, report) = load_snapshot(&self.staging_dir, &entry.requirements);
+            let (snapshot, report) =
+                load_snapshot(&self.assets.staged(&self.staging_dir), &entry.requirements);
             check_cancellation(cancellation)?;
             let target = report.resource(self.kind);
             if !target.available {
@@ -1088,16 +1476,17 @@ impl GeoUpdateSession {
             None
         };
         check_cancellation(cancellation)?;
-        let destination = self.manager.store_dir.join(self.kind.file_name());
+        let destination = self.assets.path(self.kind);
         fs::rename(&self.staging_path, &destination)
             .map_err(|source| io_at(&destination, source))?;
-        sync_directory(&self.manager.store_dir)?;
+        sync_directory(destination.parent().unwrap())?;
 
         self.manager.finish_success(
             self.kind,
             self.source_url.clone(),
             etag,
             hex_digest(&sha256),
+            self.assets.identity(self.kind),
         )?;
         check_cancellation(cancellation)?;
         if let Some(entry) = registration.as_mut()
@@ -1108,10 +1497,139 @@ impl GeoUpdateSession {
         Ok(reload_report(registration.as_ref()))
     }
 
+    /// MMDB validation, persistence and recovery are separate from DAT's
+    /// existing degraded-reload contract. A failed candidate never becomes
+    /// the replacement for a usable MMDB generation.
+    fn commit_verified_candidate(
+        &self,
+        registration: &mut Option<RegistrationEntry>,
+        candidate: VerifiedCandidate,
+        etag: Option<String>,
+        sha256: [u8; 32],
+        cancellation: &CancellationToken,
+    ) -> Result<GeoDataReloadReport, GeoDataManagerError> {
+        let destination = self.assets.path(self.kind);
+        let previous_path = self.staging_dir.join("previous.mmdb");
+        let previous = read_state(&self.manager.store_dir)?;
+        let had_file = destination.is_file();
+        if had_file && fs::hard_link(&destination, &previous_path).is_err() {
+            fs::copy(&destination, &previous_path)
+                .map_err(|source| io_at(&previous_path, source))?;
+        }
+        let mut retired = false;
+        let mut file_published = false;
+        let result = (|| {
+            check_cancellation(cancellation)?;
+            let loaded = if let Some(entry) = registration.as_mut()
+                && entry.requirements.requires(self.kind)
+            {
+                entry.unload_verified_database(cancellation)?;
+                retired = true;
+                let (snapshot, report) = load_snapshot_with_candidate(
+                    &self.assets.staged(&self.staging_dir),
+                    &entry.requirements,
+                    Some(candidate),
+                );
+                if !report.resource(self.kind).available {
+                    return Err(GeoDataManagerError::Validation(
+                        report
+                            .resource(self.kind)
+                            .error
+                            .clone()
+                            .unwrap_or_else(|| "MMDB candidate unavailable".into()),
+                    ));
+                }
+                Some((snapshot, report))
+            } else {
+                None
+            };
+            check_cancellation(cancellation)?;
+            fs::rename(&self.staging_path, &destination)
+                .map_err(|source| io_at(&destination, source))?;
+            file_published = true;
+            sync_directory(destination.parent().unwrap())?;
+            self.manager.finish_success(
+                self.kind,
+                self.source_url.clone(),
+                etag,
+                hex_digest(&sha256),
+                self.assets.identity(self.kind),
+            )?;
+            check_cancellation(cancellation)?;
+            if let Some(entry) = registration.as_mut()
+                && let Some((snapshot, report)) = loaded
+            {
+                entry.publish(snapshot, report);
+            }
+            Ok(reload_report(registration.as_ref()))
+        })();
+        if let Err(original) = result {
+            // The candidate snapshot/buffer has left the closure and dropped
+            // before recovery reads the previous file into owned storage.
+            let mut disk_restored = !file_published;
+            let rollback = if file_published {
+                (|| {
+                    if had_file {
+                        fs::rename(&previous_path, &destination)
+                            .map_err(|source| io_at(&destination, source))?;
+                    } else {
+                        fs::remove_file(&destination)
+                            .map_err(|source| io_at(&destination, source))?;
+                    }
+                    disk_restored = true;
+                    sync_directory(destination.parent().unwrap())?;
+                    persist_state(&self.manager.store_dir, &previous)?;
+                    *lock(&self.manager.state) = previous;
+                    Ok::<(), GeoDataManagerError>(())
+                })()
+            } else {
+                Ok(())
+            };
+            if retired && let Some(entry) = registration.as_mut() {
+                if disk_restored {
+                    let (snapshot, report) = load_snapshot(&entry.assets, &entry.requirements);
+                    entry.publish(snapshot, report);
+                } else {
+                    // An actual disk/state rollback error is exceptional. Do
+                    // not present uncertain on-disk ASN contents as the old generation.
+                    let mut requirements = entry.requirements.clone();
+                    match self.kind {
+                        GeoDataKind::Asn => requirements.asn = false,
+                        GeoDataKind::GeoIp => requirements.ips = super::CodeSet::EMPTY,
+                        GeoDataKind::GeoSite => unreachable!(),
+                    }
+                    let (snapshot, mut report) = load_snapshot(&entry.assets, &requirements);
+                    let unavailable =
+                        GeoDataResourceReport::degraded("MMDB disk state could not be restored");
+                    match self.kind {
+                        GeoDataKind::Asn => report.asn = unavailable,
+                        GeoDataKind::GeoIp => report.geoip = unavailable,
+                        GeoDataKind::GeoSite => unreachable!(),
+                    }
+                    entry.publish(snapshot, report);
+                }
+            }
+            if let Err(rollback) = rollback {
+                return Err(GeoDataManagerError::Validation(bounded_error(format!(
+                    "MMDB update failed: {original}; previous disk state could not be restored: {rollback}"
+                ))));
+            }
+            return Err(original);
+        }
+        result
+    }
+
     fn validate_active_lease(
         &self,
         registration: Option<&RegistrationEntry>,
     ) -> Result<(), GeoDataManagerError> {
+        if registration.is_some_and(|entry| {
+            entry.assets.mmdb != self.assets.mmdb || entry.assets.geoip != self.assets.geoip
+        }) {
+            return Err(GeoDataManagerError::Validation(
+                "GeoData update asset selection is no longer active".into(),
+            ));
+        }
         if let Some(lease) = &self.validation_lease {
             let entry = registration
                 .filter(|entry| lease.matches(entry))
@@ -1162,19 +1680,57 @@ impl Drop for GeoUpdateSession {
 }
 
 fn load_snapshot(
-    asset_dir: &Path,
+    assets: &AssetPaths,
     requirements: &GeoRequirements,
+) -> (Arc<GeoData>, GeoDataLoadReport) {
+    load_snapshot_with_candidate(assets, requirements, None)
+}
+
+fn load_snapshot_with_candidate(
+    assets: &AssetPaths,
+    requirements: &GeoRequirements,
+    candidate: Option<VerifiedCandidate>,
 ) -> (Arc<GeoData>, GeoDataLoadReport) {
     let mut sites = Vec::new();
     let mut ips = Vec::new();
-    let mut used = 0;
-    let mut peak = 0;
+    let mut used: usize = 0;
+    let mut peak: usize = 0;
     let mut site_report = GeoDataResourceReport::not_required();
     let mut ip_report = GeoDataResourceReport::not_required();
+    let mut asn_report = GeoDataResourceReport::not_required();
+    let mut asn = None;
+    let mut country = None;
+    let (country_candidate, asn_candidate) = match candidate {
+        Some(VerifiedCandidate::Country(value)) => (Some(value), None),
+        Some(VerifiedCandidate::Asn(value)) => (None, Some(value)),
+        None => (None, None),
+    };
 
-    if requirements.requires(GeoDataKind::GeoIp) {
+    if requirements.requires(GeoDataKind::GeoIp)
+        && let Some(error) = &assets.discovery_error
+    {
+        ip_report = GeoDataResourceReport::degraded(error);
+    } else if requirements.requires(GeoDataKind::GeoIp) && assets.mmdb {
+        match country_candidate.map_or_else(
+            || super::country::CountryDb::load(&assets.geoip, &requirements.ips.selectors),
+            |candidate| candidate.into_database(&requirements.ips.selectors),
+        ) {
+            Ok(database) => {
+                if let Some(total) = used.checked_add(database.capacity()) {
+                    used = total;
+                    peak = peak.max(used);
+                    country = Some(database);
+                    ip_report = GeoDataResourceReport::available();
+                } else {
+                    ip_report =
+                        GeoDataResourceReport::degraded("country allocation capacity overflow");
+                }
+            }
+            Err(error) => ip_report = GeoDataResourceReport::degraded(error),
+        }
+    } else if requirements.requires(GeoDataKind::GeoIp) {
         match load_ips_for_requirements(
-            asset_dir,
+            &assets.store_dir,
             requirements.code_set(GeoDataKind::GeoIp),
             used,
             peak,
@@ -1191,7 +1747,7 @@ fn load_snapshot(
     }
     if requirements.requires(GeoDataKind::GeoSite) {
         match load_sites_for_requirements(
-            asset_dir,
+            &assets.store_dir,
             requirements.code_set(GeoDataKind::GeoSite),
             used,
             peak,
@@ -1206,12 +1762,32 @@ fn load_snapshot(
         }
     }
 
-    let snapshot = Arc::new(GeoData::from_loaded(sites, ips, used, peak));
+    if requirements.requires(GeoDataKind::Asn) {
+        match asn_candidate.map_or_else(
+            || super::asn::AsnDb::load(&assets.store_dir),
+            super::asn::AsnCandidate::into_database,
+        ) {
+            Ok(database) => {
+                if let Some(total) = used.checked_add(database.capacity()) {
+                    used = total;
+                    peak = peak.max(used);
+                    asn = Some(database);
+                    asn_report = GeoDataResourceReport::available();
+                } else {
+                    asn_report =
+                        GeoDataResourceReport::degraded("ASN allocation capacity overflow");
+                }
+            }
+            Err(error) => asn_report = GeoDataResourceReport::degraded(error),
+        }
+    }
+    let snapshot = Arc::new(GeoData::from_loaded(sites, ips, country, asn, used, peak));
     (
         snapshot,
         GeoDataLoadReport {
             geosite: site_report,
             geoip: ip_report,
+            asn: asn_report,
             allocation_capacity: used,
             peak_allocation_capacity: peak,
         },
@@ -1221,12 +1797,15 @@ fn load_snapshot(
 fn reload_report(registration: Option<&RegistrationEntry>) -> GeoDataReloadReport {
     let geosite = registration.map(|entry| &entry.report.geosite);
     let geoip = registration.map(|entry| &entry.report.geoip);
+    let asn = registration.map(|entry| &entry.report.asn);
     GeoDataReloadReport {
         active_registration: registration.is_some(),
         geosite_required: geosite.is_some_and(|report| report.required),
         geosite_available: geosite.is_some_and(|report| report.required && report.available),
         geoip_required: geoip.is_some_and(|report| report.required),
         geoip_available: geoip.is_some_and(|report| report.required && report.available),
+        asn_required: asn.is_some_and(|report| report.required),
+        asn_available: asn.is_some_and(|report| report.required && report.available),
     }
 }
 
@@ -1238,6 +1817,9 @@ fn scoped_status(disk: &PersistentState, report: &GeoDataLoadReport) -> GeoDataS
             .geosite
             .with_required(report.geosite.required, site_error),
         geoip: disk.geoip.with_required(report.geoip.required, ip_error),
+        asn: disk
+            .asn
+            .with_required(report.asn.required, report_error(&report.asn)),
     }
 }
 
@@ -1249,6 +1831,7 @@ fn status_for_entry(
         || GeoDataStatus {
             geosite: disk.geosite.with_required(false, None),
             geoip: disk.geoip.with_required(false, None),
+            asn: disk.asn.with_required(false, None),
         },
         |entry| scoped_status(disk, &entry.report),
     )
@@ -1260,14 +1843,22 @@ fn report_error(report: &GeoDataResourceReport) -> Option<&str> {
         .flatten()
 }
 
-fn resource_due(resource: &GeoResourceState, source_url: &str, now: u64) -> bool {
+fn resource_due(
+    resource: &GeoResourceState,
+    source_url: &str,
+    asset_identity: &str,
+    now: u64,
+    interval: u64,
+) -> bool {
     resource.required
         && !resource.updating
         && (!resource.available
-            || resource.source_url.as_deref() != Some(source_url)
+            || resource.source_identity.as_deref()
+                != Some(crate::resource::http::source_identity(source_url).as_str())
+            || resource.asset_identity.as_deref() != Some(asset_identity)
             || resource
-                .next_check
-                .is_none_or(|next_check| next_check <= now))
+                .last_success
+                .is_none_or(|last| last.saturating_add(interval) <= now))
 }
 
 fn asset_matches_hash(path: &Path, expected: &str) -> bool {
@@ -1459,8 +2050,11 @@ fn unix_seconds(time: SystemTime) -> u64 {
 fn asset_generation_changed(previous: &PersistentState, current: &PersistentState) -> bool {
     previous.geosite.hash != current.geosite.hash
         || previous.geosite.last_success != current.geosite.last_success
+        || previous.geoip.asset_identity != current.geoip.asset_identity
         || previous.geoip.hash != current.geoip.hash
         || previous.geoip.last_success != current.geoip.last_success
+        || previous.asn.hash != current.asn.hash
+        || previous.asn.last_success != current.asn.last_success
 }
 
 fn hex_digest(value: &[u8; 32]) -> String {
@@ -1506,6 +2100,48 @@ mod tests {
     use super::*;
     use crate::config::{DnsNameserverPolicy, RuleAction, RuleKind, RuleSpec};
 
+    #[test]
+    fn source_identity_is_private_and_changes_invalidate_update_scheduling() {
+        let first = "https://user:first@asset.example/data?token=private";
+        let second = "https://user:second@asset.example/data?token=private";
+        let resource = PersistentResourceState {
+            available: true,
+            last_success: Some(10),
+            source_url: crate::resource::http::source_origin(first),
+            source_identity: Some(crate::resource::http::source_identity(first)),
+            asset_identity: Some("same-asset".into()),
+            ..Default::default()
+        };
+        let stored = serde_json::to_string(&resource).unwrap();
+        assert!(!stored.contains("user"));
+        assert!(!stored.contains("first"));
+        assert!(!stored.contains("private"));
+        let view = resource.with_required(true, None);
+        assert_eq!(view.source_url.as_deref(), Some("https://asset.example"));
+        assert!(!resource_due(&view, first, "same-asset", 11, 3600));
+        assert!(resource_due(&view, second, "same-asset", 11, 3600));
+        let legacy = PersistentResourceState {
+            source_url: Some("https://asset.example/data".into()),
+            source_identity: None,
+            ..resource.clone()
+        }
+        .with_required(true, None);
+        assert!(!resource_due(
+            &legacy,
+            "https://asset.example/data",
+            "same-asset",
+            11,
+            3600
+        ));
+        let legacy_auth = PersistentResourceState {
+            source_url: Some(first.into()),
+            source_identity: None,
+            ..resource
+        }
+        .with_required(true, None);
+        assert!(resource_due(&legacy_auth, first, "same-asset", 11, 3600));
+    }
+
     fn varint(mut value: u64) -> Vec<u8> {
         let mut output = Vec::new();
         loop {
@@ -1560,8 +2196,170 @@ mod tests {
         }
     }
 
+    #[test]
+    fn asn_update_verifies_before_retiring_and_preserves_healthy_siblings() {
+        let dir = tempdir().unwrap();
+        let fixture = super::super::asn_tests::FIXTURE;
+        let asn_path = dir.path().join(super::super::ASN_FILE_NAME);
+        fs::write(&asn_path, fixture).unwrap();
+        fs::write(
+            dir.path().join(super::super::GEOSITE_FILE_NAME),
+            site_file("cn", "example.test"),
+        )
+        .unwrap();
+        fs::write(
+            dir.path().join(super::super::GEOIP_FILE_NAME),
+            ip_file("cn", [10, 0, 0, 0], 8),
+        )
+        .unwrap();
+        let manager = GeoDataManager::open(dir.path(), Duration::from_secs(3600)).unwrap();
+        let registration = manager
+            .register(requirements(&[
+                rule(RuleKind::IpAsn("15169".into())),
+                rule(RuleKind::GeoSite("cn".into())),
+                rule(RuleKind::GeoIp("cn".into())),
+            ]))
+            .unwrap();
+        let matcher = registration.matcher();
+        let before = matcher.snapshot();
+        assert!(registration.initial_report().asn.available);
+        for malformed in [b"broken".to_vec(), {
+            let mut bytes = fixture.to_vec();
+            bytes[..6].fill(255);
+            bytes
+        }] {
+            let update = manager.begin_update(GeoDataKind::Asn).unwrap();
+            fs::write(update.temporary_path(), &malformed).unwrap();
+            assert!(
+                update
+                    .commit(
+                        None,
+                        Sha256::digest(&malformed).into(),
+                        malformed.len() as u64
+                    )
+                    .is_err()
+            );
+            assert!(Arc::ptr_eq(&before, &matcher.snapshot()));
+            assert_eq!(fs::read(&asn_path).unwrap(), fixture);
+            assert!(matcher.matches_asn("15169", "1.0.0.1".parse().unwrap()));
+            assert!(manager.status().unwrap().asn.last_error.is_some());
+        }
+        let released = before.release.as_ref().unwrap().0.clone();
+        drop(before);
+        let update = manager.begin_update(GeoDataKind::Asn).unwrap();
+        fs::write(update.temporary_path(), fixture).unwrap();
+        let report = update
+            .commit(
+                Some("asn-v1".into()),
+                Sha256::digest(fixture).into(),
+                fixture.len() as u64,
+            )
+            .unwrap();
+        assert!(*lock(&released.released));
+        assert!(report.asn_available && report.geosite_available && report.geoip_available);
+        assert!(matcher.matches_geosite("cn", "www.example.test"));
+        assert!(matcher.matches_geoip("cn", "10.0.0.1".parse().unwrap()));
+        let status = manager.status().unwrap();
+        assert_eq!(status.asn.etag.as_deref(), Some("asn-v1"));
+        assert!(status.asn.hash.is_some() && status.asn.last_success.is_some());
+        let current = matcher.snapshot();
+        manager
+            .begin_update(GeoDataKind::Asn)
+            .unwrap()
+            .not_modified(Some("asn-v1".into()))
+            .unwrap();
+        assert!(Arc::ptr_eq(&current, &matcher.snapshot()));
+        let lease = registration.updater_lease();
+        assert_eq!(
+            manager
+                .due_resources_for_active_registration(
+                    &lease,
+                    [(GeoDataKind::Asn, "https://assets.example.test/ASN.mmdb")],
+                    SystemTime::now()
+                )
+                .unwrap(),
+            [GeoDataKind::Asn]
+        );
+    }
+
+    #[test]
+    fn asn_state_io_failure_restores_old_file_and_matcher() {
+        let dir = tempdir().unwrap();
+        let fixture = super::super::asn_tests::FIXTURE;
+        let asn_path = dir.path().join(super::super::ASN_FILE_NAME);
+        fs::write(&asn_path, fixture).unwrap();
+        let manager = GeoDataManager::open(dir.path(), Duration::from_secs(3600)).unwrap();
+        let registration = manager
+            .register(requirements(&[rule(RuleKind::IpAsn("15169".into()))]))
+            .unwrap();
+        let matcher = registration.matcher();
+        let old = matcher.snapshot();
+        let update = manager.begin_update(GeoDataKind::Asn).unwrap();
+        fs::write(update.temporary_path(), fixture).unwrap();
+        let worker = std::thread::spawn(move || {
+            update.commit(None, Sha256::digest(fixture).into(), fixture.len() as u64)
+        });
+        let deadline = Instant::now() + Duration::from_secs(2);
+        while matcher.asn_available() && Instant::now() < deadline {
+            std::thread::yield_now();
+        }
+        assert!(!matcher.asn_available());
+        // The commit has verified the candidate and is waiting for this old
+        // reader. Turn only the state destination into an actual I/O error.
+        let state_path = dir.path().join(STATE_FILE);
+        fs::remove_file(&state_path).unwrap();
+        fs::create_dir(&state_path).unwrap();
+        drop(old);
+        assert!(worker.join().unwrap().is_err());
+        assert_eq!(fs::read(&asn_path).unwrap(), fixture);
+        assert!(matcher.matches_asn("15169", "1.0.0.1".parse().unwrap()));
+        fs::remove_dir(&state_path).unwrap();
+        assert!(manager.status().unwrap().asn.available);
+    }
+
+    #[test]
+    fn asn_retirement_cancellation_restores_previous_snapshot() {
+        let dir = tempdir().unwrap();
+        fs::write(
+            dir.path().join(super::super::ASN_FILE_NAME),
+            super::super::asn_tests::FIXTURE,
+        )
+        .unwrap();
+        let manager = GeoDataManager::open(dir.path(), Duration::from_secs(3600)).unwrap();
+        let registration = manager
+            .register(requirements(&[rule(RuleKind::IpAsn("15169".into()))]))
+            .unwrap();
+        let matcher = registration.matcher();
+        let old = matcher.snapshot();
+        let cancellation = CancellationToken::new();
+        let worker_token = cancellation.clone();
+        let worker_manager = manager.clone();
+        let worker = std::thread::spawn(move || {
+            let mut registration = lock(&worker_manager.registration);
+            registration
+                .as_mut()
+                .unwrap()
+                .unload_verified_database(&worker_token)
+        });
+        let deadline = Instant::now() + Duration::from_secs(2);
+        while matcher.asn_available() && Instant::now() < deadline {
+            std::thread::yield_now();
+        }
+        assert!(!matcher.asn_available());
+        cancellation.cancel();
+        assert!(matches!(
+            worker.join().unwrap(),
+            Err(GeoDataManagerError::Cancelled)
+        ));
+        assert!(Arc::ptr_eq(&old, &matcher.snapshot()));
+        assert!(matcher.matches_asn("15169", "1.0.0.1".parse().unwrap()));
+        assert!(manager.status().unwrap().asn.available);
+    }
+
     fn requirements(rules: &[RuleSpec]) -> GeoRequirements {
-        GeoRequirements::collect(rules, &[]).unwrap()
+        GeoRequirements::collect(rules, &[])
+            .unwrap()
+            .with_geodata_mode(true)
     }
 
     fn stage_candidate(session: &GeoUpdateSession, contents: &[u8]) -> ([u8; 32], u64) {
@@ -1579,7 +2377,9 @@ mod tests {
     #[test]
     fn requirements_validate_and_deduplicate_across_dns_and_rules() {
         let policy = DnsNameserverPolicy {
-            geosite_codes: vec!["CN".to_owned(), "private".to_owned()].into_boxed_slice(),
+            selector: crate::config::DnsPolicySelector::GeoSite(
+                vec!["CN".to_owned(), "private".to_owned()].into_boxed_slice(),
+            ),
             nameservers: Vec::new().into_boxed_slice(),
         };
         let requirements = GeoRequirements::collect(
@@ -1882,7 +2682,10 @@ mod tests {
         let manager = GeoDataManager::open(root.path(), Duration::from_secs(3_600)).unwrap();
         let peer = GeoDataManager::open(root.path(), Duration::from_secs(3_600)).unwrap();
         let registration = manager
-            .register(requirements(&[rule(RuleKind::GeoSite("cn".to_owned()))]))
+            .register_with_interval(
+                requirements(&[rule(RuleKind::GeoSite("cn".to_owned()))]),
+                Duration::from_secs(6 * 3600),
+            )
             .unwrap();
         let matcher = registration.matcher();
 
@@ -1907,7 +2710,10 @@ mod tests {
         assert_eq!(status.geosite.etag.as_deref(), Some("\"v1\""));
         assert_eq!(status.geosite.hash.as_deref().map(str::len), Some(64));
         assert!(status.geosite.last_success.is_some());
-        assert!(status.geosite.next_check > status.geosite.last_success);
+        assert_eq!(
+            status.geosite.next_check.unwrap() - status.geosite.last_success.unwrap(),
+            6 * 3600
+        );
         assert!(manager.due_resources(SystemTime::now()).unwrap().is_empty());
         let peer_status = peer.status().unwrap();
         assert!(peer_status.geosite.available);
@@ -2223,6 +3029,116 @@ mod tests {
         drop(replacement);
     }
 
+    #[test]
+    fn cancelled_requirement_change_restores_the_old_matcher_and_registration() {
+        let root = tempdir().unwrap();
+        fs::write(
+            root.path().join(super::super::GEOSITE_FILE_NAME),
+            site_file("a", "a.example"),
+        )
+        .unwrap();
+        let manager = GeoDataManager::open(root.path(), Duration::from_secs(3600)).unwrap();
+        let original = requirements(&[rule(RuleKind::GeoSite("a".into()))]);
+        let registration = manager.register(original.clone()).unwrap();
+        let matcher = registration.matcher();
+        let reader = matcher.snapshot();
+        assert!(reader.matches_geosite("a", "www.a.example"));
+        let lease = registration.updater_lease();
+        let cancel = CancellationToken::new();
+        let worker_manager = manager.clone();
+        let worker_cancel = cancel.clone();
+        let worker = std::thread::spawn(move || {
+            worker_manager.replace_requirements(
+                &lease,
+                requirements(&[rule(RuleKind::GeoSite("b".into()))]),
+                &worker_cancel,
+            )
+        });
+        let deadline = Instant::now() + Duration::from_secs(2);
+        while matcher.geosite_available("a") {
+            assert!(Instant::now() < deadline);
+            std::thread::yield_now();
+        }
+        cancel.cancel();
+        assert!(worker.join().unwrap().is_err());
+        assert!(matcher.matches_geosite("a", "www.a.example"));
+        assert_eq!(
+            lock(&manager.registration).as_ref().unwrap().requirements,
+            original
+        );
+        assert!(!lock(&manager.registration).as_ref().unwrap().reload_pending);
+        drop(reader);
+    }
+
+    #[test]
+    fn explicit_refresh_keeps_source_validators_but_bypasses_only_the_schedule() {
+        let root = tempdir().unwrap();
+        let manager = GeoDataManager::open(root.path(), Duration::from_secs(3600)).unwrap();
+        let source = "https://assets.example.test/geosite.dat";
+        let registration = manager
+            .register(requirements(&[rule(RuleKind::GeoSite("a".into()))]))
+            .unwrap();
+        let lease = registration.updater_lease();
+        let update = manager
+            .begin_update_for_active_registration(
+                &lease,
+                GeoDataKind::GeoSite,
+                source,
+                SystemTime::now(),
+            )
+            .unwrap()
+            .unwrap();
+        let (hash, size) = stage_candidate(&update, &site_file("a", "a.example"));
+        update
+            .commit(Some("\"same-source\"".into()), hash, size)
+            .unwrap();
+        assert!(
+            manager
+                .begin_update_for_active_registration(
+                    &lease,
+                    GeoDataKind::GeoSite,
+                    source,
+                    SystemTime::now()
+                )
+                .unwrap()
+                .is_none()
+        );
+        let cancel = CancellationToken::new();
+        let forced = manager
+            .force_update_for_active_registration_with_cancellation(
+                &lease,
+                GeoDataKind::GeoSite,
+                source,
+                &cancel,
+            )
+            .unwrap()
+            .unwrap();
+        assert_eq!(forced.request_etag(), Some("\"same-source\""));
+        forced.not_modified(Some("\"same-source\"".into())).unwrap();
+        assert!(
+            manager
+                .force_update_for_active_registration_with_cancellation(
+                    &lease,
+                    GeoDataKind::GeoIp,
+                    source,
+                    &cancel
+                )
+                .unwrap()
+                .is_none()
+        );
+        cancel.cancel();
+        assert!(
+            manager
+                .force_update_for_active_registration_with_cancellation(
+                    &lease,
+                    GeoDataKind::GeoSite,
+                    source,
+                    &cancel
+                )
+                .is_err()
+        );
+    }
+
     #[test]
     fn due_and_etag_are_bound_to_the_active_registration_and_source() {
         let root = tempdir().unwrap();
diff --git a/src/geodata/mod.rs b/src/geodata/mod.rs
index d90e08e..4c6c5f7 100644
--- a/src/geodata/mod.rs
+++ b/src/geodata/mod.rs
@@ -1,4 +1,4 @@
-//! Selective Xray GeoData loading with compact, shared category matchers.
+//! Selective DAT matchers and shared country/ASN MMDB readers.
 //!
 //! The loader deliberately scans protobuf wire framing itself. It indexes only
 //! category ranges during the first pass and decodes records only for codes
@@ -23,14 +23,20 @@ use crate::{
     routing::GeoMatcher,
 };
 
+mod asn;
+#[cfg(test)]
+mod asn_tests;
+mod country;
+#[cfg(test)]
+mod country_tests;
 mod manager;
 mod selectors;
 pub(crate) mod service;
-pub(crate) mod updater;
 
 pub(crate) use selectors::normalize_selector;
 use selectors::{fold_attribute, selector_attributes, selector_code};
 
+pub(crate) use manager::GeoDataRegistrationLease;
 pub use manager::{
     DynamicGeoData, GeoDataLoadReport, GeoDataManager, GeoDataManagerError, GeoDataRegistration,
     GeoDataReloadReport, GeoDataResourceReport, GeoDataStatus, GeoResourceState, GeoUpdateSession,
@@ -38,22 +44,26 @@ pub use manager::{
 
 pub const GEOSITE_FILE_NAME: &str = "geosite.dat";
 pub const GEOIP_FILE_NAME: &str = "geoip.dat";
+pub const ASN_FILE_NAME: &str = "ASN.mmdb";
 
 const MAX_CODE_BYTES: usize = 64;
 
-/// The two supported Xray GeoData assets.
+/// Logical assets; GeoIP selects a DAT or country MMDB per registration.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum GeoDataKind {
     GeoSite,
     GeoIp,
+    Asn,
 }
 
 impl GeoDataKind {
+    pub const ALL: [Self; 3] = [Self::GeoSite, Self::GeoIp, Self::Asn];
     #[must_use]
     pub const fn file_name(self) -> &'static str {
         match self {
             Self::GeoSite => GEOSITE_FILE_NAME,
             Self::GeoIp => GEOIP_FILE_NAME,
+            Self::Asn => ASN_FILE_NAME,
         }
     }
 }
@@ -63,6 +73,7 @@ impl std::fmt::Display for GeoDataKind {
         formatter.write_str(match self {
             Self::GeoSite => "GeoSite",
             Self::GeoIp => "GeoIP",
+            Self::Asn => "ASN",
         })
     }
 }
@@ -91,6 +102,10 @@ pub enum GeoDataError {
     InvalidRegex { code: String, detail: String },
     #[error("invalid GeoIP CIDR in `{code}`: {detail}")]
     InvalidCidr { code: String, detail: String },
+    #[error("invalid ASN MMDB: {0}")]
+    InvalidAsn(String),
+    #[error("invalid country MMDB: {0}")]
+    InvalidCountry(String),
     #[error("GeoData resource `{resource}` is {actual}; limit is {maximum}")]
     ResourceLimit {
         resource: &'static str,
@@ -110,9 +125,11 @@ impl From<GeoDataError> for VoleError {
 /// Diagnostic capacity accounting, never a memory admission policy.
 ///
 /// Includes Vole-owned matcher/index vectors and arenas, with old/new buffer
-/// overlap during growth. Compiled regex programs and search caches are opaque
-/// third-party allocations and are not counted, nor are allocator overhead or
-/// the process peak; those require independent measurements.
+/// overlap during growth. Owned MMDB file bytes are included, but candidate
+/// validation overlap and MMDB metadata/verification allocations are excluded.
+/// Compiled regex programs and search caches are opaque third-party allocations
+/// and are not counted, nor are allocator overhead or the process peak; those
+/// require independent measurements.
 #[derive(Debug, Default)]
 struct AllocationLedger {
     used: usize,
@@ -140,6 +157,8 @@ impl AllocationLedger {
 pub struct GeoData {
     sites: Vec<SiteCategory>,
     ips: Vec<IpCategory>,
+    country: Option<country::CountryDb>,
+    asn: Option<asn::AsnDb>,
     allocation_capacity: usize,
     peak_allocation_capacity: usize,
     // Fields drop in declaration order: signal only after matcher storage is
@@ -153,6 +172,8 @@ impl std::fmt::Debug for GeoData {
             .debug_struct("GeoData")
             .field("site_categories", &self.sites.len())
             .field("ip_categories", &self.ips.len())
+            .field("country_available", &self.country.is_some())
+            .field("asn_available", &self.asn.is_some())
             .field("allocation_capacity", &self.allocation_capacity)
             .field("peak_allocation_capacity", &self.peak_allocation_capacity)
             .finish()
@@ -169,12 +190,14 @@ impl GeoData {
     pub const EMPTY: Self = Self {
         sites: Vec::new(),
         ips: Vec::new(),
+        country: None,
+        asn: None,
         allocation_capacity: 0,
         peak_allocation_capacity: 0,
         release: None,
     };
 
-    /// Loads only categories referenced by `rules` from the two fixed sibling
+    /// Loads referenced DAT categories and the ASN MMDB from fixed sibling
     /// assets in `config_dir`.
     pub fn load(config_dir: &Path, rules: &[RuleSpec]) -> Result<Self, GeoDataError> {
         Self::load_with_dns_policies(config_dir, rules, &[])
@@ -205,12 +228,28 @@ impl GeoData {
         if !requested.sites.values.is_empty() {
             load_site_file(config_dir, &requested.sites, &mut sites, &mut ledger)?;
         }
-        Ok(Self::from_loaded(sites, ips, ledger.used, ledger.peak))
+        let asn = if requested.asn {
+            let database = asn::AsnDb::load(config_dir)?;
+            ledger.reserve(database.capacity())?;
+            Some(database)
+        } else {
+            None
+        };
+        Ok(Self::from_loaded(
+            sites,
+            ips,
+            None,
+            asn,
+            ledger.used,
+            ledger.peak,
+        ))
     }
 
     fn from_loaded(
         mut sites: Vec<SiteCategory>,
         mut ips: Vec<IpCategory>,
+        country: Option<country::CountryDb>,
+        asn: Option<asn::AsnDb>,
         allocation_capacity: usize,
         peak_allocation_capacity: usize,
     ) -> Self {
@@ -218,10 +257,13 @@ impl GeoData {
         // manager reloads share this allocation-free indexing step.
         sites.sort_unstable_by_key(|category| category.code);
         ips.sort_unstable_by_key(|category| category.code);
-        let release = (!sites.is_empty() || !ips.is_empty()).then(manager::SnapshotRelease::new);
+        let release = (!sites.is_empty() || !ips.is_empty() || country.is_some() || asn.is_some())
+            .then(manager::SnapshotRelease::new);
         Self {
             sites,
             ips,
+            country,
+            asn,
             allocation_capacity,
             peak_allocation_capacity,
             release,
@@ -244,7 +286,7 @@ impl GeoData {
 
     #[must_use]
     pub fn is_empty(&self) -> bool {
-        self.sites.is_empty() && self.ips.is_empty()
+        self.sites.is_empty() && self.ips.is_empty() && self.country.is_none() && self.asn.is_none()
     }
 
     #[must_use]
@@ -254,7 +296,14 @@ impl GeoData {
 
     #[must_use]
     pub fn geoip_available(&self, code: &str) -> bool {
-        self.ip_category(code).is_some()
+        lan_selector(code)
+            || self.country.as_ref().is_some_and(|db| db.available(code))
+            || self.ip_category(code).is_some()
+    }
+
+    #[must_use]
+    pub fn asn_available(&self) -> bool {
+        self.asn.is_some()
     }
 
     fn site_category(&self, code: &str) -> Option<&SiteCategory> {
@@ -274,7 +323,42 @@ impl GeoData {
     }
 }
 
+pub(crate) fn lan_selector(code: &str) -> bool {
+    code.strip_prefix('!')
+        .unwrap_or(code)
+        .eq_ignore_ascii_case("lan")
+}
+pub(crate) fn matches_lan(code: &str, ip: IpAddr) -> Option<bool> {
+    if !lan_selector(code) {
+        return None;
+    }
+    // netip's LAN predicates unmap IPv4 except IsUnspecified.
+    let canonical = match ip {
+        IpAddr::V6(ip) => ip
+            .to_ipv4_mapped()
+            .map(IpAddr::V4)
+            .unwrap_or(IpAddr::V6(ip)),
+        IpAddr::V4(_) => ip,
+    };
+    let local = ip.is_unspecified()
+        || canonical.is_loopback()
+        || canonical.is_multicast()
+        || match canonical {
+            IpAddr::V4(ip) => ip.is_private() || ip.is_link_local(),
+            IpAddr::V6(ip) => ip.is_unique_local() || ip.is_unicast_link_local(),
+        };
+    Some(local != code.starts_with('!'))
+}
+
 impl GeoMatcher for GeoData {
+    fn asn_available(&self) -> bool {
+        GeoData::asn_available(self)
+    }
+    fn matches_asn(&self, payload: &str, address: IpAddr) -> bool {
+        self.asn
+            .as_ref()
+            .is_some_and(|database| database.matches(payload, address))
+    }
     fn geosite_available(&self, code: &str) -> bool {
         GeoData::geosite_available(self, code)
     }
@@ -288,9 +372,31 @@ impl GeoMatcher for GeoData {
             .is_some_and(|category| !domain.is_empty() && category.matches_selector(code, domain))
     }
 
+    fn matches_geosite_bounded(
+        &self,
+        code: &str,
+        domain: &str,
+        decision: &crate::config::RuleDecision,
+    ) -> Result<bool, crate::config::MatchFailure> {
+        decision.visit()?;
+        match self.site_category(code) {
+            Some(category) if !domain.is_empty() => {
+                category.matches_selector_bounded(code, domain, Some(decision))
+            }
+            _ => Ok(false),
+        }
+    }
+
     fn matches_geoip(&self, code: &str, address: IpAddr) -> bool {
-        self.ip_category(code)
-            .is_some_and(|category| category.matches(address) != code.starts_with('!'))
+        matches_lan(code, address).unwrap_or_else(|| {
+            self.country.as_ref().map_or_else(
+                || {
+                    self.ip_category(code)
+                        .is_some_and(|category| category.matches(address) != code.starts_with('!'))
+                },
+                |db| db.matches(code, address),
+            )
+        })
     }
 }
 
@@ -352,6 +458,9 @@ impl CodeSet {
 
     fn insert(&mut self, kind: GeoDataKind, raw: &str) -> Result<(), GeoDataError> {
         let selector = normalize_selector(kind, raw)?;
+        if kind == GeoDataKind::GeoIp && lan_selector(&selector) {
+            return Ok(());
+        }
         if self.selectors.contains(&selector) {
             return Ok(());
         }
@@ -379,30 +488,64 @@ impl CodeSet {
     }
 }
 
+static EMPTY_CODE_SET: CodeSet = CodeSet::EMPTY;
+
 #[derive(Debug)]
 struct RequestedCodes {
     sites: CodeSet,
     ips: CodeSet,
+    asn: bool,
 }
 
 impl RequestedCodes {
-    fn collect(
-        rules: &[RuleSpec],
+    fn collect<'a>(
+        rules: impl IntoIterator<Item = &'a RuleSpec>,
         dns_policies: &[DnsNameserverPolicy],
     ) -> Result<Self, GeoDataError> {
         let mut requested = Self {
             sites: CodeSet::EMPTY,
             ips: CodeSet::EMPTY,
+            asn: false,
         };
-        for rule in rules {
+        let mut pending: Vec<_> = rules.into_iter().collect();
+        while let Some(rule) = pending.pop() {
             match &rule.kind {
+                RuleKind::And(children) | RuleKind::Or(children) => pending.extend(children),
+                RuleKind::RuleSet {
+                    content: Some(content),
+                    ..
+                } => pending.extend(&content.classical),
+                RuleKind::Not(child)
+                | RuleKind::Flow {
+                    predicate: child, ..
+                }
+                | RuleKind::SubRule {
+                    predicate: child, ..
+                } => pending.push(child),
+                RuleKind::IpAsn(_) | RuleKind::SrcIpAsn(_) => requested.asn = true,
                 RuleKind::GeoSite(code) => requested.sites.insert(GeoDataKind::GeoSite, code)?,
-                RuleKind::GeoIp(code) => requested.ips.insert(GeoDataKind::GeoIp, code)?,
+                RuleKind::GeoIp(code) | RuleKind::SrcGeoIp(code) => {
+                    requested.ips.insert(GeoDataKind::GeoIp, code)?
+                }
                 _ => (),
             }
         }
         for policy in dns_policies {
-            for code in &policy.geosite_codes {
+            if let crate::config::DnsPolicySelector::RuleSets { sets, .. } = &policy.selector {
+                let rules = sets
+                    .iter()
+                    .flat_map(|set| set.classical.iter().cloned())
+                    .collect::<Vec<_>>();
+                let nested = Self::collect(&rules, &[])?;
+                requested.asn |= nested.asn;
+                for code in nested.sites.selectors {
+                    requested.sites.insert(GeoDataKind::GeoSite, &code)?;
+                }
+                for code in nested.ips.selectors {
+                    requested.ips.insert(GeoDataKind::GeoIp, &code)?;
+                }
+            }
+            for code in policy.geosite_codes() {
                 requested.sites.insert(GeoDataKind::GeoSite, code)?;
             }
         }
@@ -410,7 +553,7 @@ impl RequestedCodes {
     }
 
     const fn total(&self) -> usize {
-        self.sites.selectors.len() + self.ips.selectors.len()
+        self.sites.selectors.len() + self.ips.selectors.len() + self.asn as usize
     }
 }
 
@@ -425,9 +568,103 @@ impl RequestedCodes {
 pub struct GeoRequirements {
     sites: CodeSet,
     ips: CodeSet,
+    asn: bool,
+    geodata_mode: bool,
 }
 
 impl GeoRequirements {
+    pub(crate) fn for_config(config: &crate::config::Config) -> Result<Self, GeoDataError> {
+        Self::for_rules(
+            config,
+            config
+                .rules
+                .iter()
+                .chain(config.sub_rules.iter().flat_map(|sub| &sub.rules)),
+        )
+    }
+
+    pub(crate) fn for_rules<'a>(
+        config: &crate::config::Config,
+        rules: impl IntoIterator<Item = &'a RuleSpec>,
+    ) -> Result<Self, GeoDataError> {
+        let mut policies: Vec<_> = config
+            .dns
+            .nameserver_policies
+            .iter()
+            .chain(&config.dns.proxy_policies)
+            .map(|policy| DnsNameserverPolicy {
+                selector: policy.selector.clone(),
+                nameservers: Box::new([]),
+            })
+            .collect();
+        if config.dns.enable && config.dns.fake_ip.enabled {
+            policies.extend(config.dns.fake_ip.filter.iter().cloned().map(|selector| {
+                DnsNameserverPolicy {
+                    selector,
+                    nameservers: Box::new([]),
+                }
+            }));
+        }
+        if config.dns.enable && !config.dns.fallback.nameservers.is_empty() {
+            policies.extend(config.dns.fallback.domains.iter().cloned().map(|selector| {
+                DnsNameserverPolicy {
+                    selector,
+                    nameservers: Box::new([]),
+                }
+            }));
+        }
+        if config.sniffer.enable {
+            policies.extend(
+                config
+                    .sniffer
+                    .force_domain
+                    .iter()
+                    .chain(&config.sniffer.skip_domain)
+                    .cloned()
+                    .map(|selector| DnsNameserverPolicy {
+                        selector,
+                        nameservers: Box::new([]),
+                    }),
+            );
+        }
+        let requested = RequestedCodes::collect(rules, &policies)?;
+        let mut result = Self {
+            sites: requested.sites,
+            ips: requested.ips,
+            asn: requested.asn,
+            geodata_mode: config
+                .geodata_update
+                .as_ref()
+                .is_some_and(|update| update.geodata_mode),
+        };
+        if config.sniffer.enable {
+            result.extend(&Self::collect(&config.sniffer.skip_src_address, &[])?)?;
+            result.extend(&Self::collect(&config.sniffer.skip_dst_address, &[])?)?;
+        }
+        if config.dns.enable
+            && !config.dns.fallback.nameservers.is_empty()
+            && let Some(code) = &config.dns.fallback.geoip
+            && code != "lan"
+        {
+            result.ips.insert(GeoDataKind::GeoIp, code)?;
+        }
+        if config.dns.enable && config.dns.fake_ip.enabled {
+            result.extend(&Self::collect(&config.dns.fake_ip.rules, &[])?)?;
+        }
+        Ok(result)
+    }
+
+    pub(crate) fn extend(&mut self, other: &Self) -> Result<(), GeoDataError> {
+        self.asn |= other.asn;
+        for selector in &other.sites.selectors {
+            self.sites.insert(GeoDataKind::GeoSite, selector)?;
+        }
+        for selector in &other.ips.selectors {
+            self.ips.insert(GeoDataKind::GeoIp, selector)?;
+        }
+        Ok(())
+    }
+
     /// Collects all GeoSite and GeoIP selectors used by business rules and DNS
     /// nameserver policies. Each underlying category is decoded only once.
     pub fn collect(
@@ -438,12 +675,21 @@ impl GeoRequirements {
         Ok(Self {
             sites: requested.sites,
             ips: requested.ips,
+            asn: requested.asn,
+            geodata_mode: false,
         })
     }
 
+    /// Selects DAT (true) or country MMDB (false, the YAML default).
+    #[must_use]
+    pub fn with_geodata_mode(mut self, enabled: bool) -> Self {
+        self.geodata_mode = enabled;
+        self
+    }
+
     #[must_use]
     pub const fn is_empty(&self) -> bool {
-        self.sites.values.is_empty() && self.ips.values.is_empty()
+        self.sites.values.is_empty() && self.ips.values.is_empty() && !self.asn
     }
 
     #[must_use]
@@ -451,6 +697,7 @@ impl GeoRequirements {
         match kind {
             GeoDataKind::GeoSite => !self.sites.values.is_empty(),
             GeoDataKind::GeoIp => !self.ips.values.is_empty(),
+            GeoDataKind::Asn => self.asn,
         }
     }
 
@@ -464,6 +711,7 @@ impl GeoRequirements {
         let set = match kind {
             GeoDataKind::GeoSite => &self.sites,
             GeoDataKind::GeoIp => &self.ips,
+            GeoDataKind::Asn => &EMPTY_CODE_SET,
         };
         set.selectors.iter().map(String::as_str)
     }
@@ -472,6 +720,7 @@ impl GeoRequirements {
         match kind {
             GeoDataKind::GeoSite => &self.sites,
             GeoDataKind::GeoIp => &self.ips,
+            GeoDataKind::Asn => &EMPTY_CODE_SET,
         }
     }
 }
@@ -517,6 +766,9 @@ fn load_ips_for_requirements(
 }
 
 fn validate_asset_structure(asset_dir: &Path, kind: GeoDataKind) -> Result<(), GeoDataError> {
+    if kind == GeoDataKind::Asn {
+        return asn::AsnCandidate::load(asset_dir).map(drop);
+    }
     let (mut file, len) = open_asset(asset_dir, kind)?;
     let mut ledger = AllocationLedger::default();
     let _ = index_selected(&mut file, len, kind, &CodeSet::EMPTY, &mut ledger)?;
@@ -609,6 +861,11 @@ fn load_selected_file<T>(
 
 fn open_asset(config_dir: &Path, kind: GeoDataKind) -> Result<(File, u64), GeoDataError> {
     let path = config_dir.join(kind.file_name());
+    open_asset_path(&path)
+}
+
+fn open_asset_path(path: &Path) -> Result<(File, u64), GeoDataError> {
+    let path = path.to_path_buf();
     let symlink_metadata = fs::symlink_metadata(&path).map_err(|source| GeoDataError::Io {
         path: path.clone(),
         source,
@@ -823,23 +1080,38 @@ impl SiteCategory {
     }
 
     fn matches_selector(&self, selector: &str, domain: &str) -> bool {
+        self.matches_selector_bounded(selector, domain, None)
+            .expect("unbounded linear matching")
+    }
+
+    fn matches_selector_bounded(
+        &self,
+        selector: &str,
+        domain: &str,
+        decision: Option<&crate::config::RuleDecision>,
+    ) -> Result<bool, crate::config::MatchFailure> {
         let attributes = selector_attributes(selector);
         let filter = self
             .filters
             .iter()
             .find(|filter| filter.attributes.eq_ignore_ascii_case(attributes));
         let matched = if attributes.is_empty() {
-            self.matches(domain, &self.patterns, None)
+            self.matches(domain, &self.patterns, None, decision)?
         } else if let Some(filter) = filter {
             if filter.all_records {
-                self.matches(domain, &self.patterns, None)
+                self.matches(domain, &self.patterns, None, decision)?
             } else {
-                self.matches(domain, &filter.patterns, Some(&filter.regex_indices))
+                self.matches(
+                    domain,
+                    &filter.patterns,
+                    Some(&filter.regex_indices),
+                    decision,
+                )?
             }
         } else {
-            return false;
+            return Ok(false);
         };
-        matched != selector.starts_with('!')
+        Ok(matched != selector.starts_with('!'))
     }
 
     fn matches(
@@ -847,18 +1119,22 @@ impl SiteCategory {
         domain: &str,
         patterns: &[SitePattern],
         regex_indices: Option<&[usize]>,
-    ) -> bool {
+        decision: Option<&crate::config::RuleDecision>,
+    ) -> Result<bool, crate::config::MatchFailure> {
         // The loader validates/normalizes each value once. Reuse the compact
         // ranges as a sorted index; a miss must not scan all Domain/Full records
         // for every UDP packet. Category membership is a union, not rule order.
+        if let Some(decision) = decision {
+            decision.visit()?;
+        }
         let bytes = domain.as_bytes();
         if self.contains(patterns, SitePatternKind::Full, bytes) {
-            return true;
+            return Ok(true);
         }
         let mut suffix = bytes;
         loop {
             if self.contains(patterns, SitePatternKind::Domain, suffix) {
-                return true;
+                return Ok(true);
             }
             let Some(dot) = suffix.iter().position(|byte| *byte == b'.') else {
                 break;
@@ -869,20 +1145,36 @@ impl SiteCategory {
             .iter()
             .take_while(|pattern| pattern.kind == SitePatternKind::Substr)
         {
+            if let Some(decision) = decision {
+                decision.visit()?;
+            }
             let value = pattern.value(&self.values);
             if bytes.windows(value.len()).any(|window| window == value) {
-                return true;
+                return Ok(true);
             }
         }
         // The regex library owns its compiled representation and search cache;
         // matching is not guaranteed to be allocation-free on first use.
-        let matches_regex = |regex: &Regex| regex.is_match(domain.as_bytes());
-        match regex_indices {
-            Some(indices) => indices
-                .iter()
-                .any(|&index| matches_regex(&self.regexes[index])),
-            None => self.regexes.iter().any(matches_regex),
+        let matches_regex = |regex: &Regex| match decision {
+            Some(decision) => decision.linear(regex.as_str().len(), domain.len(), || {
+                regex.is_match(domain.as_bytes())
+            }),
+            None => Ok(regex.is_match(domain.as_bytes())),
+        };
+        if let Some(indices) = regex_indices {
+            for &index in indices {
+                if matches_regex(&self.regexes[index])? {
+                    return Ok(true);
+                }
+            }
+        } else {
+            for regex in &self.regexes {
+                if matches_regex(regex)? {
+                    return Ok(true);
+                }
+            }
         }
+        Ok(false)
     }
 }
 
@@ -1052,7 +1344,7 @@ fn parse_site_category<'a>(
     release_vec(&present, ledger);
     release_vec(&filter_matches, ledger);
     match result {
-        Ok(regexes) => {
+        Ok(mut regexes) => {
             // In-place sort does not duplicate the arena or retain a second
             // index. Keep every record, including overlapping types/duplicates.
             patterns.sort_unstable_by(|left, right| {
@@ -1066,7 +1358,12 @@ fn parse_site_category<'a>(
                         .cmp(&right.kind)
                         .then_with(|| left.value(&values).cmp(right.value(&values)))
                 });
+                compact_vec(&mut filter.patterns, ledger)?;
+                compact_vec(&mut filter.regex_indices, ledger)?;
             }
+            compact_vec(&mut patterns, ledger)?;
+            compact_vec(&mut values, ledger)?;
+            compact_vec(&mut regexes, ledger)?;
             Ok(SiteCategory {
                 code: range.code,
                 patterns,
@@ -1604,6 +1901,8 @@ fn parse_ip_category(
         }
         compact_v4(&mut v4);
         compact_v6(&mut v6);
+        compact_vec(&mut v4, ledger)?;
+        compact_vec(&mut v6, ledger)?;
         Ok(())
     })();
     match result {
@@ -1851,6 +2150,21 @@ fn release_vec<T>(values: &Vec<T>, ledger: &mut AllocationLedger) {
     ledger.release(values.capacity().saturating_mul(mem::size_of::<T>()));
 }
 
+fn compact_vec<T>(values: &mut Vec<T>, ledger: &mut AllocationLedger) -> Result<(), GeoDataError> {
+    if values.capacity() == values.len() || mem::size_of::<T>() == 0 {
+        return Ok(());
+    }
+    let old = values.capacity() * mem::size_of::<T>();
+    let desired = values.len() * mem::size_of::<T>();
+    // Account for a possible moved allocation, including its overlap. The
+    // allocator may keep capacity; charge the actual retained size afterwards.
+    ledger.reserve(desired)?;
+    values.shrink_to_fit();
+    ledger.release(old);
+    ledger.reserve(values.capacity() * mem::size_of::<T>() - desired)?;
+    Ok(())
+}
+
 fn read_key(file: &mut File, end: u64, kind: GeoDataKind) -> Result<(u32, u8), GeoDataError> {
     let key = read_varint(file, end, kind)?;
     let field = key >> 3;
diff --git a/src/geodata/service.rs b/src/geodata/service.rs
index 04f6bf2..7b4a8a4 100644
--- a/src/geodata/service.rs
+++ b/src/geodata/service.rs
@@ -2,7 +2,7 @@
 //!
 //! The service is attached to a running instance, but the manager and its
 //! cross-process lock own the shared resource state. Network traffic is sent
-//! only through the final MATCH route dispatcher supplied by the runtime.
+//! through the shared runtime route dispatcher.
 
 use std::{
     io,
@@ -12,15 +12,14 @@ use std::{
 
 use tokio_util::sync::CancellationToken;
 
-use super::{
-    GeoDataKind, GeoDataManager, GeoDataManagerError,
-    manager::GeoDataRegistrationLease,
-    updater::{
-        DEFAULT_DOWNLOAD_TIMEOUT, GeoDataDownloadOutcome, GeoDataDownloadRequest,
-        download_geodata_via_proxy,
+use super::{GeoDataKind, GeoDataManager, GeoDataManagerError, manager::GeoDataRegistrationLease};
+use crate::{
+    config::GeoDataUrls,
+    dispatch::Dispatcher,
+    resource::http::{
+        DEFAULT_DOWNLOAD_TIMEOUT, DownloadOutcome, DownloadRequest, HttpOptions, download,
     },
 };
-use crate::{config::GeoDataUrls, dispatch::Dispatcher};
 
 const STATUS_POLL_INTERVAL: Duration = Duration::from_secs(15);
 const MIN_LOOP_DELAY: Duration = Duration::from_secs(1);
@@ -33,25 +32,44 @@ const RETRY_BACKOFF: [Duration; 4] = [
 ];
 
 pub(crate) struct GeoDataUpdateService {
+    security: crate::security::SecurityContext,
     manager: Arc<GeoDataManager>,
     dispatcher: Arc<dyn Dispatcher>,
     registration: GeoDataRegistrationLease,
     urls: GeoDataUrls,
+    geodata_mode: bool,
+    options: HttpOptions,
+    etag_support: bool,
+    auto_update: bool,
 }
 
 impl GeoDataUpdateService {
     #[must_use]
+    #[allow(clippy::too_many_arguments)]
     pub(crate) fn new(
         manager: Arc<GeoDataManager>,
         dispatcher: Arc<dyn Dispatcher>,
         registration: GeoDataRegistrationLease,
         urls: GeoDataUrls,
+        geodata_mode: bool,
+        user_agent: String,
+        etag_support: bool,
+        auto_update: bool,
+        security: crate::security::SecurityContext,
     ) -> Self {
         Self {
+            security,
             manager,
             dispatcher,
             registration,
             urls,
+            geodata_mode,
+            options: HttpOptions {
+                user_agent,
+                ..HttpOptions::default()
+            },
+            etag_support,
+            auto_update,
         }
     }
 
@@ -79,7 +97,7 @@ impl GeoDataUpdateService {
                         if !retries.ready(kind, Instant::now()) {
                             continue;
                         }
-                        match self.update_one(kind, cancellation.clone()).await {
+                        match self.update_one(kind, cancellation.clone(), false).await {
                             Ok(UpdateAttempt::Completed) => retries.succeeded(kind),
                             Ok(UpdateAttempt::Busy) => {
                                 retries.defer(kind, UPDATE_BUSY_RETRY);
@@ -125,39 +143,86 @@ impl GeoDataUpdateService {
         let manager = self.manager.clone();
         let registration = self.registration.clone();
         let urls = self.urls.clone();
+        let auto_update = self.auto_update;
+        let geodata_mode = self.geodata_mode;
         blocking_operation(move || {
-            manager.due_resources_for_active_registration_with_cancellation(
+            let due = manager.due_resources_for_active_registration_with_cancellation(
                 &registration,
                 [
                     (GeoDataKind::GeoSite, urls.geosite.as_str()),
-                    (GeoDataKind::GeoIp, urls.geoip.as_str()),
+                    (
+                        GeoDataKind::GeoIp,
+                        resource_url(&urls, GeoDataKind::GeoIp, geodata_mode),
+                    ),
+                    (GeoDataKind::Asn, urls.asn.as_str()),
                 ],
                 SystemTime::now(),
                 &cancellation,
-            )
+            )?;
+            if auto_update {
+                return Ok(due);
+            }
+            let status = manager.status_for_active_registration(&registration, &cancellation)?;
+            Ok(due
+                .into_iter()
+                .filter(|kind| {
+                    status
+                        .as_ref()
+                        .is_some_and(|status| !status.resource(*kind).available)
+                })
+                .collect())
         })
         .await?
-        .map_err(|error| error.to_string())
+        .map_err(|error: GeoDataManagerError| error.to_string())
+    }
+
+    /// Explicit Controller refresh uses the same lock, download and commit path.
+    /// Only assets required by the active registration are acquired.
+    pub(crate) async fn refresh_active(
+        &self,
+        cancellation: CancellationToken,
+    ) -> Result<(), &'static str> {
+        for kind in GeoDataKind::ALL {
+            if cancellation.is_cancelled() {
+                return Err("runtime stopped");
+            }
+            match self.update_one(kind, cancellation.clone(), true).await {
+                Ok(UpdateAttempt::Completed) => {}
+                Ok(UpdateAttempt::Busy) => return Err("GeoData update is busy"),
+                Err(_) => return Err("GeoData update failed"),
+            }
+        }
+        Ok(())
     }
 
     async fn update_one(
         &self,
         kind: GeoDataKind,
         cancellation: CancellationToken,
+        force: bool,
     ) -> Result<UpdateAttempt, String> {
-        let source_url = resource_url(&self.urls, kind).to_owned();
+        let source_url = resource_url(&self.urls, kind, self.geodata_mode).to_owned();
         let manager = self.manager.clone();
         let registration = self.registration.clone();
         let begin_source = source_url.clone();
         let begin_cancellation = cancellation.clone();
         let session = match blocking_operation(move || {
-            manager.begin_update_for_active_registration_with_cancellation(
-                &registration,
-                kind,
-                &begin_source,
-                SystemTime::now(),
-                &begin_cancellation,
-            )
+            if force {
+                manager.force_update_for_active_registration_with_cancellation(
+                    &registration,
+                    kind,
+                    &begin_source,
+                    &begin_cancellation,
+                )
+            } else {
+                manager.begin_update_for_active_registration_with_cancellation(
+                    &registration,
+                    kind,
+                    &begin_source,
+                    SystemTime::now(),
+                    &begin_cancellation,
+                )
+            }
         })
         .await?
         {
@@ -166,17 +231,22 @@ impl GeoDataUpdateService {
             Err(GeoDataManagerError::UpdateBusy) => return Ok(UpdateAttempt::Busy),
             Err(error) => return Err(error.to_string()),
         };
-        let etag = session.request_etag().map(ToOwned::to_owned);
-        let request = GeoDataDownloadRequest {
+        let etag = self
+            .etag_support
+            .then(|| session.request_etag().map(ToOwned::to_owned))
+            .flatten();
+        let request = DownloadRequest {
+            security: self.security.clone(),
             dispatcher: self.dispatcher.clone(),
             url: source_url,
             etag: etag.clone(),
             temporary_path: session.temporary_path().to_path_buf(),
             timeout: DEFAULT_DOWNLOAD_TIMEOUT,
             cancellation: cancellation.clone(),
+            options: self.options.clone(),
         };
-        match download_geodata_via_proxy(request).await {
-            Ok(GeoDataDownloadOutcome::NotModified) => {
+        match download(request).await {
+            Ok(DownloadOutcome::NotModified { .. }) => {
                 blocking_operation(move || {
                     session.not_modified_with_cancellation(etag, &cancellation)
                 })
@@ -185,7 +255,7 @@ impl GeoDataUpdateService {
                 tracing::info!(geodata_kind = %kind, "Vole GeoData is current");
                 Ok(UpdateAttempt::Completed)
             }
-            Ok(GeoDataDownloadOutcome::Downloaded {
+            Ok(DownloadOutcome::Downloaded {
                 etag, sha256, size, ..
             }) => {
                 let report = blocking_operation(move || {
@@ -242,6 +312,7 @@ struct RetrySlot {
 struct RetryState {
     geosite: RetrySlot,
     geoip: RetrySlot,
+    asn: RetrySlot,
 }
 
 impl RetryState {
@@ -249,6 +320,7 @@ impl RetryState {
         match kind {
             GeoDataKind::GeoSite => &self.geosite,
             GeoDataKind::GeoIp => &self.geoip,
+            GeoDataKind::Asn => &self.asn,
         }
     }
 
@@ -256,6 +328,7 @@ impl RetryState {
         match kind {
             GeoDataKind::GeoSite => &mut self.geosite,
             GeoDataKind::GeoIp => &mut self.geoip,
+            GeoDataKind::Asn => &mut self.asn,
         }
     }
 
@@ -282,15 +355,19 @@ impl RetryState {
     }
 
     fn next_delay(&self, now: Instant) -> Option<Duration> {
-        [self.geosite.retry_at, self.geoip.retry_at]
-            .into_iter()
-            .flatten()
-            .map(|retry_at| retry_at.saturating_duration_since(now))
-            .min()
+        [
+            self.geosite.retry_at,
+            self.geoip.retry_at,
+            self.asn.retry_at,
+        ]
+        .into_iter()
+        .flatten()
+        .map(|retry_at| retry_at.saturating_duration_since(now))
+        .min()
     }
 
     fn clear_expired_not_due(&mut self, due: &[GeoDataKind], now: Instant) {
-        for kind in [GeoDataKind::GeoSite, GeoDataKind::GeoIp] {
+        for kind in GeoDataKind::ALL {
             if !due.contains(&kind)
                 && self
                     .slot(kind)
@@ -303,10 +380,17 @@ impl RetryState {
     }
 }
 
-fn resource_url(urls: &GeoDataUrls, kind: GeoDataKind) -> &str {
+fn resource_url(urls: &GeoDataUrls, kind: GeoDataKind, geodata_mode: bool) -> &str {
     match kind {
         GeoDataKind::GeoSite => &urls.geosite,
-        GeoDataKind::GeoIp => &urls.geoip,
+        GeoDataKind::GeoIp => {
+            if geodata_mode {
+                &urls.geoip
+            } else {
+                &urls.mmdb
+            }
+        }
+        GeoDataKind::Asn => &urls.asn,
     }
 }
 
@@ -388,9 +472,16 @@ mod tests {
             Arc::new(NoNetworkDispatcher),
             registration.updater_lease(),
             GeoDataUrls {
+                mmdb: "https://assets.example.test/geoip.metadb".into(),
                 geoip: "https://rules.example.test/geoip.dat".to_owned(),
                 geosite: "https://rules.example.test/geosite.dat".to_owned(),
+                asn: "https://rules.example.test/ASN.mmdb".to_owned(),
             },
+            true,
+            "fixture".into(),
+            true,
+            true,
+            crate::security::SecurityContext::new(),
         );
         let run = tokio::spawn(service.run(cancellation.clone()));
         tokio::time::timeout(Duration::from_secs(1), async {
@@ -439,17 +530,23 @@ mod tests {
     #[test]
     fn resources_use_configured_urls() {
         let urls = GeoDataUrls {
+            mmdb: "https://assets.example.test/geoip.metadb".into(),
             geoip: "https://rules.example.test/custom-geoip".to_owned(),
             geosite: "https://rules.example.test/custom-geosite".to_owned(),
+            asn: "https://rules.example.test/custom-asn".to_owned(),
         };
         assert_eq!(
-            resource_url(&urls, GeoDataKind::GeoSite),
+            resource_url(&urls, GeoDataKind::GeoSite, true),
             "https://rules.example.test/custom-geosite"
         );
         assert_eq!(
-            resource_url(&urls, GeoDataKind::GeoIp),
+            resource_url(&urls, GeoDataKind::GeoIp, true),
             "https://rules.example.test/custom-geoip"
         );
+        assert_eq!(
+            resource_url(&urls, GeoDataKind::GeoIp, false),
+            "https://assets.example.test/geoip.metadb"
+        );
     }
 
     #[test]
diff --git a/src/geodata/tests.rs b/src/geodata/tests.rs
index f5985b3..b445c65 100644
--- a/src/geodata/tests.rs
+++ b/src/geodata/tests.rs
@@ -110,11 +110,13 @@ fn rule(kind: RuleKind) -> RuleSpec {
 
 fn dns_policy(codes: &[&str]) -> DnsNameserverPolicy {
     DnsNameserverPolicy {
-        geosite_codes: codes
-            .iter()
-            .map(|code| (*code).to_owned())
-            .collect::<Vec<_>>()
-            .into_boxed_slice(),
+        selector: crate::config::DnsPolicySelector::GeoSite(
+            codes
+                .iter()
+                .map(|code| (*code).to_owned())
+                .collect::<Vec<_>>()
+                .into_boxed_slice(),
+        ),
         nameservers: Vec::new().into_boxed_slice(),
     }
 }
@@ -460,7 +462,11 @@ fn category_lookup_preserves_independent_codes_through_load_and_reload() {
     let data = GeoData::load(dir.path(), &rules).unwrap();
     let manager = GeoDataManager::open(dir.path(), std::time::Duration::from_secs(60)).unwrap();
     let registration = manager
-        .register(GeoRequirements::collect(&rules, &[]).unwrap())
+        .register(
+            GeoRequirements::collect(&rules, &[])
+                .unwrap()
+                .with_geodata_mode(true),
+        )
         .unwrap();
     assert!(registration.initial_report().geosite.available);
     assert!(registration.initial_report().geoip.available);
@@ -1048,6 +1054,7 @@ fn geosite_byte_regex_preserves_search_classes_and_supported_flags() {
         (r"^\w+\.test$", "abc_42.test", "a-b.test"),
         (r"^\w+\.test$", "abc.test", "é.test"),
         (r"needle", "has-needle.example", "absent.example"),
+        (r"UPPER", "UPPER.example", "upper.example"),
         (r"(?i:FLAG)", "flag.example", "quiet.example"),
         (r"(?m:^line$)", "first\nline\nlast", "first\nnot-line\nlast"),
         (r"(?s:^a.b$)", "a\nb", "ab"),
@@ -1061,6 +1068,17 @@ fn geosite_byte_regex_preserves_search_classes_and_supported_flags() {
         let data =
             GeoData::load(dir.path(), &[rule(RuleKind::GeoSite("byte-regex".into()))]).unwrap();
         assert!(data.matches_geosite("byte-regex", matched), "{pattern}");
+        assert!(
+            data.matches_geosite_bounded("byte-regex", matched, &Default::default())
+                .unwrap(),
+            "{pattern}"
+        );
+        assert!(
+            !data
+                .matches_geosite_bounded("byte-regex", not_matched, &Default::default())
+                .unwrap(),
+            "{pattern}"
+        );
         assert!(
             !data.matches_geosite("byte-regex", not_matched),
             "{pattern}"
@@ -1152,6 +1170,53 @@ fn geoip_records_load_without_count_limits_before_cidr_compaction() {
     assert!(!data.matches_geoip("cn", "203.0.113.10".parse().unwrap()));
 }
 
+#[test]
+fn loaded_geodata_releases_growth_slack_without_dropping_records() {
+    let dir = tempdir().unwrap();
+    let records: Vec<_> = (0..513)
+        .map(|index| domain(3, &format!("record-{index}.example")))
+        .collect();
+    write_asset(
+        dir.path(),
+        GEOSITE_FILE_NAME,
+        &site_list(&[site("cn", &records)]),
+    );
+    let cidrs = vec![cidr(&[203, 0, 113, 9], 32); 513];
+    write_asset(
+        dir.path(),
+        GEOIP_FILE_NAME,
+        &geoip_list(&[geoip("cn", &cidrs, false)]),
+    );
+    let data = GeoData::load(
+        dir.path(),
+        &[
+            rule(RuleKind::GeoSite("cn".into())),
+            rule(RuleKind::GeoIp("cn".into())),
+        ],
+    )
+    .unwrap();
+    for index in 0..513 {
+        assert!(data.matches_geosite("cn", &format!("record-{index}.example")));
+    }
+    assert!(data.matches_geoip("cn", "203.0.113.9".parse().unwrap()));
+    assert!(!data.matches_geoip("cn", "203.0.113.10".parse().unwrap()));
+    let site = &data.sites[0];
+    let retained =
+        site.patterns.capacity() * mem::size_of::<SitePattern>() + site.values.capacity();
+    let content = site.patterns.len() * mem::size_of::<SitePattern>() + site.values.len();
+    assert!(
+        retained <= content + content / 10,
+        "loaded immutable storage retains growth slack"
+    );
+    let ip = &data.ips[0];
+    assert!(
+        ip.v4.capacity() <= ip.v4.len() + 1,
+        "compacted prefixes retain pre-compaction capacity"
+    );
+    assert!(data.allocation_capacity() >= retained + ip.v4.capacity() * mem::size_of::<Cidr4>());
+    assert!(data.peak_allocation_capacity() >= data.allocation_capacity());
+}
+
 #[test]
 fn large_assets_skip_unselected_payloads_without_file_size_quotas() {
     use std::io::Write;
@@ -1170,6 +1235,7 @@ fn large_assets_skip_unselected_payloads_without_file_size_quotas() {
         file.write_all(&category).unwrap();
         file.seek(SeekFrom::Current(padding as i64)).unwrap();
         let (selected, rule_kind) = match kind {
+            GeoDataKind::Asn => unreachable!("this case tests DAT framing"),
             GeoDataKind::GeoSite => (
                 site("selected", &[domain(3, "last.test")]),
                 RuleKind::GeoSite("selected".into()),
@@ -1182,6 +1248,7 @@ fn large_assets_skip_unselected_payloads_without_file_size_quotas() {
         file.write_all(&field_bytes(1, &selected)).unwrap();
         let data = GeoData::load(dir.path(), &[rule(rule_kind)]).unwrap();
         match kind {
+            GeoDataKind::Asn => unreachable!("this case tests DAT framing"),
             GeoDataKind::GeoSite => assert!(data.matches_geosite("selected", "last.test")),
             GeoDataKind::GeoIp => {
                 assert!(data.matches_geoip("selected", "10.0.0.1".parse().unwrap()))
@@ -1214,74 +1281,69 @@ fn literal_ip_family_does_not_cross_match() {
     assert!(!data.matches_geoip("v4", "::ffff:203.0.113.1".parse().unwrap()));
 }
 
-/// Opt-in compatibility check for the real Xray GeoData assets shipped by the
-/// app. CI does not require those external files; run with
-/// `VOLE_GEODATA_DIR=/path/to/assets/dat cargo test real_xray_geodata -- --ignored --nocapture`.
 #[test]
-#[ignore = "requires VOLE_GEODATA_DIR containing real geosite.dat and geoip.dat"]
-fn real_xray_geodata_loads_common_codes_without_memory_quotas() {
-    let dir = std::env::var_os("VOLE_GEODATA_DIR")
-        .map(PathBuf::from)
-        .expect("VOLE_GEODATA_DIR must point to the directory containing both .dat files");
-    let rules = [
-        rule(RuleKind::GeoSite("cn".to_owned())),
-        rule(RuleKind::GeoSite("geolocation-!cn".to_owned())),
-        rule(RuleKind::GeoIp("cn".to_owned())),
-        rule(RuleKind::GeoIp("private".to_owned())),
-    ];
-    let baseline = GeoData::load(
-        &dir,
-        &[rules[0].clone(), rules[2].clone(), rules[3].clone()],
+fn ingress_source_geoip_and_builtin_lan_avoid_destination_resolution() {
+    use crate::{
+        config::Network,
+        routing::{RoutingContext, RuleEvaluation, RuleSet},
+    };
+    let dir = tempdir().unwrap();
+    write_asset(
+        dir.path(),
+        GEOIP_FILE_NAME,
+        &geoip_list(&[geoip("CN", &[cidr(&[192, 0, 2, 0], 24)], false)]),
+    );
+    let mut config = crate::config::Config::parse_yaml(
+        b"mixed-port: 1080\nrules: ['SRC-GEOIP,CN,REJECT', 'GEOIP,lan,DIRECT,src', 'MATCH,DIRECT']",
     )
     .unwrap();
-    eprintln!(
-        "real GeoData baseline allocation without GEOLOCATION-!CN: retained={} bytes, accounted_peak={} bytes",
-        baseline.allocation_capacity(),
-        baseline.peak_allocation_capacity(),
+    let requirements = GeoRequirements::for_config(&config).unwrap();
+    assert_eq!(
+        requirements.codes(GeoDataKind::GeoIp).collect::<Vec<_>>(),
+        ["cn"]
     );
-    assert!(baseline.matches_geosite("cn", "baidu.com"));
-    assert!(baseline.matches_geoip("private", "10.0.0.1".parse().unwrap()));
-    assert!(baseline.matches_geoip("cn", "1.0.1.1".parse().unwrap()));
-    drop(baseline);
-
-    let documented = GeoData::load(
-        &dir,
-        &[
-            rule(RuleKind::GeoSite("category-ads-all".to_owned())),
-            rules[0].clone(),
-            rules[2].clone(),
-            rules[3].clone(),
-        ],
+    let data = GeoData::load(dir.path(), &config.rules).unwrap();
+    let rules = RuleSet::compile(config.take_runtime_rules()).unwrap();
+    let mut context = RoutingContext::new(
+        Network::Tcp,
+        &crate::session::Destination::domain("unresolved.example", 443).unwrap(),
     )
-    .unwrap_or_else(|error| panic!("documented GeoData combination failed: {error}"));
-    eprintln!(
-        "documented GeoData allocation: retained={} bytes, accounted_peak={} bytes",
-        documented.allocation_capacity(),
-        documented.peak_allocation_capacity(),
+    .unwrap();
+    context.set_source("192.0.2.1:1234".parse().unwrap());
+    assert!(
+        matches!(rules.evaluate_with_geo(&context, &data), RuleEvaluation::Matched(result) if result.rule_index == 0)
     );
-    assert!(documented.matches_geosite("cn", "baidu.com"));
-    assert!(documented.matches_geoip("private", "10.0.0.1".parse().unwrap()));
-    drop(documented);
-
-    let policy = dns_policy(&["private", "cn", "apple"]);
-    let policy_data =
-        GeoData::load_with_dns_policies(&dir, &[rules[2].clone(), rules[3].clone()], &[policy])
-            .unwrap_or_else(|error| panic!("Simple Profile DNS policy GeoData failed: {error}"));
-    assert!(policy_data.matches_geosite("private", "localhost"));
-    assert!(policy_data.matches_geosite("cn", "baidu.com"));
-    assert!(policy_data.matches_geosite("apple", "apple.com"));
-    drop(policy_data);
-
-    let data = GeoData::load(&dir, &rules)
-        .unwrap_or_else(|error| panic!("real GeoData compatibility failed: {error}"));
-
-    eprintln!(
-        "real GeoData allocation: retained={} bytes, accounted_peak={} bytes",
-        data.allocation_capacity(),
-        data.peak_allocation_capacity(),
+    context.set_source(
+        "fe80::1"
+            .parse::<IpAddr>()
+            .map(|ip| std::net::SocketAddr::new(ip, 1234))
+            .unwrap(),
     );
-    assert!(data.matches_geosite("cn", "baidu.com"));
-    assert!(data.matches_geosite("geolocation-!cn", "google.com"));
-    assert!(data.matches_geoip("private", "10.0.0.1".parse().unwrap()));
-    assert!(data.matches_geoip("cn", "1.0.1.1".parse().unwrap()));
+    assert!(
+        matches!(rules.evaluate(&context), RuleEvaluation::Matched(result) if result.rule_index == 1)
+    );
+    assert!(context.effective_ip().is_none());
+    for ip in [
+        "127.0.0.1",
+        "10.0.0.1",
+        "0.0.0.0",
+        "224.0.0.1",
+        "::1",
+        "fc00::1",
+        "fe80::1",
+        "ff02::1",
+        "::ffff:10.0.0.1",
+        "::ffff:127.0.0.1",
+    ] {
+        assert_eq!(matches_lan("lan", ip.parse().unwrap()), Some(true));
+    }
+    assert_eq!(
+        matches_lan("!lan", "203.0.113.1".parse().unwrap()),
+        Some(true)
+    );
+    let only_lan = crate::config::Config::parse_yaml(
+        b"mixed-port: 1080\nrules: ['SRC-GEOIP,lan,DIRECT', 'GEOIP,!LAN,REJECT']",
+    )
+    .unwrap();
+    assert!(GeoRequirements::for_config(&only_lan).unwrap().is_empty());
 }
diff --git a/src/geodata/updater.rs b/src/geodata/updater.rs
deleted file mode 100644
index 515b335..0000000
--- a/src/geodata/updater.rs
+++ /dev/null
@@ -1,1549 +0,0 @@
-//! Streaming GeoData downloads forced through one raw proxy dispatcher.
-//!
-//! This module deliberately does not know about routing or DIRECT. The caller
-//! must pass the raw dispatcher for the selected default proxy. Every hop,
-//! including redirects, opens a domain destination through that dispatcher.
-
-use std::{
-    fs::{self, File, OpenOptions},
-    io::{self, Write},
-    net::SocketAddr,
-    path::PathBuf,
-    sync::Arc,
-    time::Duration,
-};
-
-use async_trait::async_trait;
-use bytes::BytesMut;
-use rustls::{ClientConfig, RootCertStore, client::Resumption, pki_types::ServerName};
-use sha2::{Digest, Sha256};
-use thiserror::Error;
-use tokio::io::{AsyncReadExt, AsyncWriteExt};
-use tokio_rustls::TlsConnector;
-use tokio_util::sync::CancellationToken;
-use url::{Host, Url};
-
-use crate::{
-    dispatch::{BoxStream, DispatchError, Dispatcher},
-    session::{Destination, InboundKind, StreamSession},
-};
-
-pub(crate) const DEFAULT_DOWNLOAD_TIMEOUT: Duration = Duration::from_secs(90);
-
-const MAX_REDIRECTS: usize = 5;
-const MAX_URL_BYTES: usize = 4 * 1024;
-const MAX_REQUEST_ETAG_BYTES: usize = 1024;
-const MAX_RESPONSE_HEAD_BYTES: usize = 32 * 1024;
-const MAX_RESPONSE_HEADERS: usize = 64;
-const MAX_INFORMATIONAL_RESPONSES: usize = 4;
-const MAX_CHUNK_LINE_BYTES: usize = 1024;
-const MAX_TRAILER_BYTES: usize = 8 * 1024;
-const MAX_TRAILER_HEADERS: usize = 32;
-const IO_BUFFER_BYTES: usize = 16 * 1024;
-
-pub(crate) struct GeoDataDownloadRequest {
-    pub dispatcher: Arc<dyn Dispatcher>,
-    pub url: String,
-    pub etag: Option<String>,
-    /// A new temporary file. The downloader refuses to replace an existing
-    /// path; publishing the completed file is the manager's responsibility.
-    pub temporary_path: PathBuf,
-    pub timeout: Duration,
-    pub cancellation: CancellationToken,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) enum GeoDataDownloadOutcome {
-    NotModified,
-    Downloaded {
-        etag: Option<String>,
-        sha256: [u8; 32],
-        size: u64,
-        final_url: String,
-    },
-}
-
-#[derive(Debug, Error)]
-pub(crate) enum GeoDataDownloadError {
-    #[error("invalid GeoData URL: {0}")]
-    InvalidUrl(String),
-    #[error("GeoData download URL must use HTTPS")]
-    HttpsRequired,
-    #[error("GeoData download URL must contain a domain host")]
-    DomainRequired,
-    #[error("GeoData download URL must not contain credentials")]
-    CredentialsNotAllowed,
-    #[error("GeoData download ETag is not a bounded HTTP header value")]
-    InvalidEtag,
-    #[error("GeoData proxy dispatch failed: {0}")]
-    Dispatch(#[source] DispatchError),
-    #[error("GeoData TLS setup failed: {0}")]
-    TlsSetup(String),
-    #[error("GeoData TLS handshake failed: {0}")]
-    TlsHandshake(String),
-    #[error("GeoData HTTP protocol error: {0}")]
-    Protocol(String),
-    #[error("GeoData server returned HTTP status {0}")]
-    HttpStatus(u16),
-    #[error("GeoData download followed more than {MAX_REDIRECTS} redirects")]
-    TooManyRedirects,
-    #[error("GeoData download timed out after {0:?}")]
-    TimedOut(Duration),
-    #[error("GeoData download was cancelled")]
-    Cancelled,
-    #[error("failed to {operation} GeoData temporary file {path}: {source}")]
-    File {
-        operation: &'static str,
-        path: PathBuf,
-        #[source]
-        source: io::Error,
-    },
-    #[error("GeoData network I/O failed: {0}")]
-    NetworkIo(#[source] io::Error),
-}
-
-/// Downloads one GeoData asset exclusively through `request.dispatcher`.
-///
-/// The successful `Downloaded` result leaves a fully flushed temporary file at
-/// `request.temporary_path`. All other outcomes remove the temporary file.
-pub(crate) async fn download_geodata_via_proxy(
-    request: GeoDataDownloadRequest,
-) -> Result<GeoDataDownloadOutcome, GeoDataDownloadError> {
-    let connector = WebPkiHttpsConnector::new()?;
-    download_with_connector(request, &connector).await
-}
-
-#[async_trait]
-trait HttpsConnector: Send + Sync {
-    async fn connect(
-        &self,
-        server_name: &str,
-        stream: BoxStream,
-    ) -> Result<BoxStream, GeoDataDownloadError>;
-}
-
-struct WebPkiHttpsConnector {
-    connector: TlsConnector,
-}
-
-impl WebPkiHttpsConnector {
-    fn new() -> Result<Self, GeoDataDownloadError> {
-        let provider = Arc::new(rustls::crypto::ring::default_provider());
-        let roots: RootCertStore = webpki_roots::TLS_SERVER_ROOTS.iter().cloned().collect();
-        let mut config = ClientConfig::builder_with_provider(provider)
-            .with_safe_default_protocol_versions()
-            .map_err(|error| GeoDataDownloadError::TlsSetup(error.to_string()))?
-            .with_root_certificates(Arc::new(roots))
-            .with_no_client_auth();
-        config.alpn_protocols = vec![b"http/1.1".to_vec()];
-        config.resumption = Resumption::disabled();
-        Ok(Self {
-            connector: TlsConnector::from(Arc::new(config)),
-        })
-    }
-}
-
-#[async_trait]
-impl HttpsConnector for WebPkiHttpsConnector {
-    async fn connect(
-        &self,
-        server_name: &str,
-        stream: BoxStream,
-    ) -> Result<BoxStream, GeoDataDownloadError> {
-        let server_name = ServerName::try_from(server_name.to_owned())
-            .map_err(|error| GeoDataDownloadError::TlsSetup(error.to_string()))?;
-        self.connector
-            .connect(server_name, stream)
-            .await
-            .map(|stream| Box::new(stream) as BoxStream)
-            .map_err(|error| GeoDataDownloadError::TlsHandshake(error.to_string()))
-    }
-}
-
-async fn download_with_connector(
-    request: GeoDataDownloadRequest,
-    connector: &dyn HttpsConnector,
-) -> Result<GeoDataDownloadOutcome, GeoDataDownloadError> {
-    let initial_url = parse_geodata_url(&request.url)?;
-    validate_etag(request.etag.as_deref())?;
-
-    let temporary_path = request.temporary_path.clone();
-    let file = OpenOptions::new()
-        .write(true)
-        .create_new(true)
-        .open(&temporary_path)
-        .map_err(|source| GeoDataDownloadError::File {
-            operation: "create",
-            path: temporary_path.clone(),
-            source,
-        })?;
-
-    let cancellation = request.cancellation.clone();
-    let timeout = request.timeout;
-    let result = {
-        let operation = download_inner(request, connector, initial_url, file);
-        tokio::pin!(operation);
-        tokio::select! {
-            biased;
-            () = cancellation.cancelled() => Err(GeoDataDownloadError::Cancelled),
-            timed = tokio::time::timeout(timeout, &mut operation) => {
-                match timed {
-                    Ok(result) => result,
-                    Err(_) => Err(GeoDataDownloadError::TimedOut(timeout)),
-                }
-            }
-        }
-    };
-
-    if !matches!(result, Ok(GeoDataDownloadOutcome::Downloaded { .. })) {
-        let _ = fs::remove_file(&temporary_path);
-    }
-    result
-}
-
-async fn download_inner(
-    request: GeoDataDownloadRequest,
-    connector: &dyn HttpsConnector,
-    mut current_url: Url,
-    file: File,
-) -> Result<GeoDataDownloadOutcome, GeoDataDownloadError> {
-    let mut file = Some(file);
-
-    for redirects_followed in 0..=MAX_REDIRECTS {
-        let endpoint = DownloadEndpoint::from_url(&current_url)?;
-        let session = StreamSession {
-            inbound: InboundKind::InternalGeoData,
-            source: SocketAddr::from(([0, 0, 0, 0], 0)),
-            destination: Destination::domain(endpoint.host.clone(), endpoint.port)
-                .map_err(|error| GeoDataDownloadError::InvalidUrl(error.to_string()))?,
-            sniffed_domain: None,
-        };
-        let stream = request
-            .dispatcher
-            .connect_tcp(session)
-            .await
-            .map_err(GeoDataDownloadError::Dispatch)?;
-        #[cfg(feature = "benchmark-geodata-http")]
-        let stream = if current_url.scheme() == "http" {
-            stream
-        } else {
-            connector.connect(&endpoint.host, stream).await?
-        };
-        #[cfg(not(feature = "benchmark-geodata-http"))]
-        let stream = connector.connect(&endpoint.host, stream).await?;
-        let mut response = HttpReader::new(stream);
-
-        response
-            .stream
-            .write_all(&build_request(&endpoint, request.etag.as_deref()))
-            .await
-            .map_err(GeoDataDownloadError::NetworkIo)?;
-        response
-            .stream
-            .flush()
-            .await
-            .map_err(GeoDataDownloadError::NetworkIo)?;
-
-        let head = response.read_final_head().await?;
-        if is_redirect(head.status) {
-            if redirects_followed == MAX_REDIRECTS {
-                return Err(GeoDataDownloadError::TooManyRedirects);
-            }
-            let location = head.location.ok_or_else(|| {
-                GeoDataDownloadError::Protocol(
-                    "redirect response does not contain Location".to_owned(),
-                )
-            })?;
-            current_url = resolve_redirect(&current_url, &location)?;
-            continue;
-        }
-
-        match head.status {
-            304 if request.etag.is_some() => return Ok(GeoDataDownloadOutcome::NotModified),
-            304 => {
-                return Err(GeoDataDownloadError::Protocol(
-                    "received 304 without sending If-None-Match".to_owned(),
-                ));
-            }
-            200 => {}
-            status => return Err(GeoDataDownloadError::HttpStatus(status)),
-        }
-
-        validate_content_encoding(head.content_encoding.as_deref())?;
-        let framing = body_framing(&head)?;
-        let target = file
-            .take()
-            .expect("temporary file must be consumed by one final response");
-        let mut sink = BodySink::new(target);
-        match framing {
-            BodyFraming::ContentLength(length) => {
-                response.copy_exact_body(length, &mut sink).await?;
-            }
-            BodyFraming::Chunked => {
-                response.copy_chunked_body(&mut sink).await?;
-            }
-            BodyFraming::UntilEof => {
-                response.copy_body_until_eof(&mut sink).await?;
-            }
-        }
-        let (sha256, size) = sink.finish(&request.temporary_path)?;
-        return Ok(GeoDataDownloadOutcome::Downloaded {
-            etag: head.etag,
-            sha256,
-            size,
-            final_url: current_url.to_string(),
-        });
-    }
-
-    Err(GeoDataDownloadError::TooManyRedirects)
-}
-
-#[derive(Debug)]
-struct DownloadEndpoint {
-    host: String,
-    port: u16,
-    authority: String,
-    origin_form: String,
-}
-
-impl DownloadEndpoint {
-    fn from_url(url: &Url) -> Result<Self, GeoDataDownloadError> {
-        let host = match url.host() {
-            Some(Host::Domain(host)) => host.to_owned(),
-            _ => return Err(GeoDataDownloadError::DomainRequired),
-        };
-        let port = url
-            .port_or_known_default()
-            .ok_or_else(|| GeoDataDownloadError::InvalidUrl("missing HTTP(S) port".to_owned()))?;
-        let default_port = if url.scheme() == "http" { 80 } else { 443 };
-        let authority = if port == default_port {
-            host.clone()
-        } else {
-            format!("{host}:{port}")
-        };
-        let mut origin_form = if url.path().is_empty() {
-            "/".to_owned()
-        } else {
-            url.path().to_owned()
-        };
-        if let Some(query) = url.query() {
-            origin_form.push('?');
-            origin_form.push_str(query);
-        }
-        Ok(Self {
-            host,
-            port,
-            authority,
-            origin_form,
-        })
-    }
-}
-
-fn parse_geodata_url(raw: &str) -> Result<Url, GeoDataDownloadError> {
-    if raw.len() > MAX_URL_BYTES {
-        return Err(GeoDataDownloadError::InvalidUrl(format!(
-            "URL exceeds {MAX_URL_BYTES} bytes"
-        )));
-    }
-    let mut url =
-        Url::parse(raw).map_err(|error| GeoDataDownloadError::InvalidUrl(error.to_string()))?;
-    let allowed_scheme = url.scheme() == "https";
-    #[cfg(feature = "benchmark-geodata-http")]
-    let allowed_scheme = allowed_scheme || url.scheme() == "http";
-    if !allowed_scheme {
-        return Err(GeoDataDownloadError::HttpsRequired);
-    }
-    if !url.username().is_empty() || url.password().is_some() {
-        return Err(GeoDataDownloadError::CredentialsNotAllowed);
-    }
-    if !matches!(url.host(), Some(Host::Domain(_))) {
-        return Err(GeoDataDownloadError::DomainRequired);
-    }
-    #[cfg(feature = "benchmark-geodata-http")]
-    if url.scheme() == "http" {
-        let authority = raw
-            .split_once("://")
-            .map(|(_, suffix)| suffix)
-            .and_then(|suffix| suffix.split(['/', '?', '#']).next())
-            .unwrap_or_default();
-        if authority.contains('@') {
-            return Err(GeoDataDownloadError::CredentialsNotAllowed);
-        }
-        if url.fragment().is_some() {
-            return Err(GeoDataDownloadError::InvalidUrl(
-                "URL must not contain a fragment".to_owned(),
-            ));
-        }
-    }
-    url.set_fragment(None);
-    Ok(url)
-}
-
-fn resolve_redirect(base: &Url, location: &str) -> Result<Url, GeoDataDownloadError> {
-    if location.len() > MAX_URL_BYTES || !is_header_value(location.as_bytes()) {
-        return Err(GeoDataDownloadError::InvalidUrl(
-            "redirect Location is not a bounded HTTP header value".to_owned(),
-        ));
-    }
-    let joined = base
-        .join(location)
-        .map_err(|error| GeoDataDownloadError::InvalidUrl(error.to_string()))?;
-    if base.scheme() == "https" && joined.scheme() != "https" {
-        return Err(GeoDataDownloadError::HttpsRequired);
-    }
-    parse_geodata_url(joined.as_str())
-}
-
-fn validate_etag(etag: Option<&str>) -> Result<(), GeoDataDownloadError> {
-    if let Some(etag) = etag
-        && (etag.len() > MAX_REQUEST_ETAG_BYTES || !is_header_value(etag.as_bytes()))
-    {
-        return Err(GeoDataDownloadError::InvalidEtag);
-    }
-    Ok(())
-}
-
-fn build_request(endpoint: &DownloadEndpoint, etag: Option<&str>) -> Vec<u8> {
-    let conditional = etag.map_or_else(String::new, |etag| format!("If-None-Match: {etag}\r\n"));
-    format!(
-        "GET {} HTTP/1.1\r\nHost: {}\r\nAccept: application/octet-stream\r\nAccept-Encoding: identity\r\nUser-Agent: Vole/0.1\r\nConnection: close\r\n{}\r\n",
-        endpoint.origin_form, endpoint.authority, conditional
-    )
-    .into_bytes()
-}
-
-fn is_redirect(status: u16) -> bool {
-    matches!(status, 301 | 302 | 303 | 307 | 308)
-}
-
-#[derive(Debug)]
-struct ResponseHead {
-    status: u16,
-    content_length: Option<u64>,
-    transfer_encoding: Option<String>,
-    content_encoding: Option<String>,
-    etag: Option<String>,
-    location: Option<String>,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum BodyFraming {
-    ContentLength(u64),
-    Chunked,
-    UntilEof,
-}
-
-fn body_framing(head: &ResponseHead) -> Result<BodyFraming, GeoDataDownloadError> {
-    if head.transfer_encoding.is_some() && head.content_length.is_some() {
-        return Err(GeoDataDownloadError::Protocol(
-            "response contains both Transfer-Encoding and Content-Length".to_owned(),
-        ));
-    }
-    if let Some(encoding) = &head.transfer_encoding {
-        if !encoding.eq_ignore_ascii_case("chunked") {
-            return Err(GeoDataDownloadError::Protocol(format!(
-                "unsupported Transfer-Encoding `{encoding}`"
-            )));
-        }
-        return Ok(BodyFraming::Chunked);
-    }
-    if let Some(length) = head.content_length {
-        return Ok(BodyFraming::ContentLength(length));
-    }
-    Ok(BodyFraming::UntilEof)
-}
-
-fn validate_content_encoding(encoding: Option<&str>) -> Result<(), GeoDataDownloadError> {
-    if let Some(encoding) = encoding
-        && !encoding
-            .split(',')
-            .all(|value| value.trim().eq_ignore_ascii_case("identity"))
-    {
-        return Err(GeoDataDownloadError::Protocol(format!(
-            "unsupported Content-Encoding `{encoding}`"
-        )));
-    }
-    Ok(())
-}
-
-struct HttpReader {
-    stream: BoxStream,
-    buffered: BytesMut,
-}
-
-impl HttpReader {
-    fn new(stream: BoxStream) -> Self {
-        Self {
-            stream,
-            buffered: BytesMut::with_capacity(4 * 1024),
-        }
-    }
-
-    async fn read_final_head(&mut self) -> Result<ResponseHead, GeoDataDownloadError> {
-        for informational_count in 0..=MAX_INFORMATIONAL_RESPONSES {
-            let block = self.read_head_block().await?;
-            let head = parse_response_head(&block)?;
-            if !(100..200).contains(&head.status) {
-                return Ok(head);
-            }
-            if head.status == 101 {
-                return Err(GeoDataDownloadError::Protocol(
-                    "HTTP protocol switching is not supported".to_owned(),
-                ));
-            }
-            if informational_count == MAX_INFORMATIONAL_RESPONSES {
-                return Err(GeoDataDownloadError::Protocol(
-                    "too many informational responses".to_owned(),
-                ));
-            }
-        }
-        unreachable!("informational response loop always returns");
-    }
-
-    async fn read_head_block(&mut self) -> Result<Vec<u8>, GeoDataDownloadError> {
-        loop {
-            if let Some(end) = find_bytes(&self.buffered, b"\r\n\r\n") {
-                if end + 4 > MAX_RESPONSE_HEAD_BYTES {
-                    return Err(GeoDataDownloadError::Protocol(format!(
-                        "response head exceeds {MAX_RESPONSE_HEAD_BYTES} bytes"
-                    )));
-                }
-                let mut block = self.buffered.split_to(end + 4).to_vec();
-                block.truncate(end);
-                return Ok(block);
-            }
-            if self.buffered.len() >= MAX_RESPONSE_HEAD_BYTES {
-                return Err(GeoDataDownloadError::Protocol(format!(
-                    "response head exceeds {MAX_RESPONSE_HEAD_BYTES} bytes"
-                )));
-            }
-            let mut scratch = [0_u8; 4 * 1024];
-            let read = self
-                .stream
-                .read(&mut scratch)
-                .await
-                .map_err(GeoDataDownloadError::NetworkIo)?;
-            if read == 0 {
-                return Err(GeoDataDownloadError::Protocol(
-                    "response ended before its HTTP head".to_owned(),
-                ));
-            }
-            self.buffered.extend_from_slice(&scratch[..read]);
-        }
-    }
-
-    async fn copy_exact_body(
-        &mut self,
-        mut remaining: u64,
-        sink: &mut BodySink,
-    ) -> Result<(), GeoDataDownloadError> {
-        let mut scratch = [0_u8; IO_BUFFER_BYTES];
-        while remaining > 0 {
-            let wanted = usize::try_from(remaining.min(IO_BUFFER_BYTES as u64))
-                .expect("bounded read size fits usize");
-            let read = self.read_some(&mut scratch[..wanted]).await?;
-            if read == 0 {
-                return Err(GeoDataDownloadError::Protocol(format!(
-                    "response body ended with {remaining} bytes missing"
-                )));
-            }
-            sink.write(&scratch[..read])?;
-            remaining -= read as u64;
-        }
-        Ok(())
-    }
-
-    async fn copy_body_until_eof(
-        &mut self,
-        sink: &mut BodySink,
-    ) -> Result<(), GeoDataDownloadError> {
-        let mut scratch = [0_u8; IO_BUFFER_BYTES];
-        loop {
-            let read = self.read_some(&mut scratch).await?;
-            if read == 0 {
-                return Ok(());
-            }
-            sink.write(&scratch[..read])?;
-        }
-    }
-
-    async fn copy_chunked_body(&mut self, sink: &mut BodySink) -> Result<(), GeoDataDownloadError> {
-        loop {
-            let line = self.read_line(MAX_CHUNK_LINE_BYTES).await?;
-            if !is_header_value(&line) {
-                return Err(GeoDataDownloadError::Protocol(
-                    "chunk-size line contains invalid bytes".to_owned(),
-                ));
-            }
-            let size_text = line
-                .split(|byte| *byte == b';')
-                .next()
-                .expect("split always returns one value");
-            let size_text = trim_ascii_whitespace(size_text);
-            if size_text.is_empty() || size_text.len() > 16 {
-                return Err(GeoDataDownloadError::Protocol(
-                    "invalid chunk size".to_owned(),
-                ));
-            }
-            let size_text = std::str::from_utf8(size_text).map_err(|_| {
-                GeoDataDownloadError::Protocol("chunk size is not ASCII".to_owned())
-            })?;
-            let size = u64::from_str_radix(size_text, 16).map_err(|_| {
-                GeoDataDownloadError::Protocol("invalid hexadecimal chunk size".to_owned())
-            })?;
-            if size == 0 {
-                self.read_trailers().await?;
-                return Ok(());
-            }
-            self.copy_exact_body(size, sink).await?;
-            let terminator = self.read_exact_small(2).await?;
-            if terminator != b"\r\n" {
-                return Err(GeoDataDownloadError::Protocol(
-                    "chunk data is not followed by CRLF".to_owned(),
-                ));
-            }
-        }
-    }
-
-    async fn read_trailers(&mut self) -> Result<(), GeoDataDownloadError> {
-        let mut total = 0_usize;
-        for count in 0..=MAX_TRAILER_HEADERS {
-            let line = self.read_line(MAX_TRAILER_BYTES).await?;
-            total = total.checked_add(line.len() + 2).ok_or_else(|| {
-                GeoDataDownloadError::Protocol("trailer size overflow".to_owned())
-            })?;
-            if total > MAX_TRAILER_BYTES {
-                return Err(GeoDataDownloadError::Protocol(format!(
-                    "trailers exceed {MAX_TRAILER_BYTES} bytes"
-                )));
-            }
-            if line.is_empty() {
-                return Ok(());
-            }
-            if count == MAX_TRAILER_HEADERS {
-                return Err(GeoDataDownloadError::Protocol(format!(
-                    "trailers contain more than {MAX_TRAILER_HEADERS} fields"
-                )));
-            }
-            validate_trailer_line(&line)?;
-        }
-        unreachable!("trailer loop always returns");
-    }
-
-    async fn read_line(&mut self, maximum: usize) -> Result<Vec<u8>, GeoDataDownloadError> {
-        loop {
-            if let Some(end) = find_bytes(&self.buffered, b"\r\n") {
-                if end > maximum {
-                    return Err(GeoDataDownloadError::Protocol(format!(
-                        "HTTP line exceeds {maximum} bytes"
-                    )));
-                }
-                let mut line = self.buffered.split_to(end + 2).to_vec();
-                line.truncate(end);
-                return Ok(line);
-            }
-            if self.buffered.len() > maximum {
-                return Err(GeoDataDownloadError::Protocol(format!(
-                    "HTTP line exceeds {maximum} bytes"
-                )));
-            }
-            let mut scratch = [0_u8; 4 * 1024];
-            let read = self
-                .stream
-                .read(&mut scratch)
-                .await
-                .map_err(GeoDataDownloadError::NetworkIo)?;
-            if read == 0 {
-                return Err(GeoDataDownloadError::Protocol(
-                    "response ended in the middle of an HTTP line".to_owned(),
-                ));
-            }
-            self.buffered.extend_from_slice(&scratch[..read]);
-        }
-    }
-
-    async fn read_exact_small(&mut self, length: usize) -> Result<Vec<u8>, GeoDataDownloadError> {
-        let mut output = vec![0_u8; length];
-        let mut written = 0;
-        while written < length {
-            if self.buffered.is_empty() {
-                let mut scratch = [0_u8; 4 * 1024];
-                let read = self
-                    .stream
-                    .read(&mut scratch)
-                    .await
-                    .map_err(GeoDataDownloadError::NetworkIo)?;
-                if read == 0 {
-                    return Err(GeoDataDownloadError::Protocol(
-                        "response body ended unexpectedly".to_owned(),
-                    ));
-                }
-                self.buffered.extend_from_slice(&scratch[..read]);
-            }
-            let take = (length - written).min(self.buffered.len());
-            let bytes = self.buffered.split_to(take);
-            output[written..written + take].copy_from_slice(&bytes);
-            written += take;
-        }
-        Ok(output)
-    }
-
-    async fn read_some(&mut self, output: &mut [u8]) -> Result<usize, GeoDataDownloadError> {
-        if !self.buffered.is_empty() {
-            let take = output.len().min(self.buffered.len());
-            let bytes = self.buffered.split_to(take);
-            output[..take].copy_from_slice(&bytes);
-            return Ok(take);
-        }
-        self.stream
-            .read(output)
-            .await
-            .map_err(GeoDataDownloadError::NetworkIo)
-    }
-}
-
-fn parse_response_head(block: &[u8]) -> Result<ResponseHead, GeoDataDownloadError> {
-    if !block.is_ascii() {
-        return Err(GeoDataDownloadError::Protocol(
-            "response head contains non-ASCII bytes".to_owned(),
-        ));
-    }
-    let text = std::str::from_utf8(block)
-        .map_err(|_| GeoDataDownloadError::Protocol("invalid response head".to_owned()))?;
-    let mut lines = text.split("\r\n");
-    let status_line = lines
-        .next()
-        .ok_or_else(|| GeoDataDownloadError::Protocol("missing HTTP status line".to_owned()))?;
-    let mut status_parts = status_line.splitn(3, ' ');
-    if status_parts.next() != Some("HTTP/1.1") {
-        return Err(GeoDataDownloadError::Protocol(
-            "server did not respond with HTTP/1.1".to_owned(),
-        ));
-    }
-    let status_text = status_parts
-        .next()
-        .ok_or_else(|| GeoDataDownloadError::Protocol("missing HTTP status".to_owned()))?;
-    if status_text.len() != 3 || !status_text.bytes().all(|byte| byte.is_ascii_digit()) {
-        return Err(GeoDataDownloadError::Protocol(
-            "invalid HTTP status".to_owned(),
-        ));
-    }
-    let status = status_text
-        .parse::<u16>()
-        .map_err(|_| GeoDataDownloadError::Protocol("invalid HTTP status".to_owned()))?;
-
-    let mut content_length = None;
-    let mut transfer_encoding = None;
-    let mut content_encoding = None;
-    let mut etag = None;
-    let mut location = None;
-    let mut header_count = 0_usize;
-
-    for line in lines {
-        header_count += 1;
-        if header_count > MAX_RESPONSE_HEADERS {
-            return Err(GeoDataDownloadError::Protocol(format!(
-                "response contains more than {MAX_RESPONSE_HEADERS} headers"
-            )));
-        }
-        if line.starts_with(' ') || line.starts_with('\t') {
-            return Err(GeoDataDownloadError::Protocol(
-                "obsolete folded headers are not supported".to_owned(),
-            ));
-        }
-        let (name, value) = line.split_once(':').ok_or_else(|| {
-            GeoDataDownloadError::Protocol("malformed HTTP response header".to_owned())
-        })?;
-        if !is_header_name(name.as_bytes()) {
-            return Err(GeoDataDownloadError::Protocol(
-                "invalid HTTP response header name".to_owned(),
-            ));
-        }
-        let value = value.trim_matches([' ', '\t']);
-        if !is_header_value(value.as_bytes()) {
-            return Err(GeoDataDownloadError::Protocol(
-                "invalid HTTP response header value".to_owned(),
-            ));
-        }
-        if name.eq_ignore_ascii_case("content-length") {
-            set_once(&mut content_length, "Content-Length")?;
-            content_length = Some(value.parse::<u64>().map_err(|_| {
-                GeoDataDownloadError::Protocol("invalid Content-Length".to_owned())
-            })?);
-        } else if name.eq_ignore_ascii_case("transfer-encoding") {
-            set_string_once(&mut transfer_encoding, value, "Transfer-Encoding")?;
-        } else if name.eq_ignore_ascii_case("content-encoding") {
-            set_string_once(&mut content_encoding, value, "Content-Encoding")?;
-        } else if name.eq_ignore_ascii_case("etag") {
-            set_string_once(&mut etag, value, "ETag")?;
-        } else if name.eq_ignore_ascii_case("location") {
-            set_string_once(&mut location, value, "Location")?;
-        }
-    }
-
-    Ok(ResponseHead {
-        status,
-        content_length,
-        transfer_encoding,
-        content_encoding,
-        etag,
-        location,
-    })
-}
-
-fn set_once<T>(
-    slot: &mut Option<T>,
-    header_name: &'static str,
-) -> Result<(), GeoDataDownloadError> {
-    if slot.is_some() {
-        return Err(GeoDataDownloadError::Protocol(format!(
-            "duplicate {header_name} header"
-        )));
-    }
-    Ok(())
-}
-
-fn set_string_once(
-    slot: &mut Option<String>,
-    value: &str,
-    header_name: &'static str,
-) -> Result<(), GeoDataDownloadError> {
-    set_once(slot, header_name)?;
-    *slot = Some(value.to_owned());
-    Ok(())
-}
-
-fn validate_trailer_line(line: &[u8]) -> Result<(), GeoDataDownloadError> {
-    if !line.is_ascii()
-        || line
-            .first()
-            .is_some_and(|byte| matches!(byte, b' ' | b'\t'))
-    {
-        return Err(GeoDataDownloadError::Protocol(
-            "invalid HTTP trailer".to_owned(),
-        ));
-    }
-    let Some(colon) = line.iter().position(|byte| *byte == b':') else {
-        return Err(GeoDataDownloadError::Protocol(
-            "malformed HTTP trailer".to_owned(),
-        ));
-    };
-    let name = &line[..colon];
-    let value = trim_ascii_whitespace(&line[colon + 1..]);
-    if !is_header_name(name) || !is_header_value(value) {
-        return Err(GeoDataDownloadError::Protocol(
-            "invalid HTTP trailer".to_owned(),
-        ));
-    }
-    if name.eq_ignore_ascii_case(b"content-length")
-        || name.eq_ignore_ascii_case(b"transfer-encoding")
-        || name.eq_ignore_ascii_case(b"content-encoding")
-        || name.eq_ignore_ascii_case(b"location")
-    {
-        return Err(GeoDataDownloadError::Protocol(
-            "forbidden framing field in HTTP trailer".to_owned(),
-        ));
-    }
-    Ok(())
-}
-
-fn is_header_name(bytes: &[u8]) -> bool {
-    !bytes.is_empty()
-        && bytes.iter().all(|byte| {
-            byte.is_ascii_alphanumeric()
-                || matches!(
-                    byte,
-                    b'!' | b'#'
-                        | b'$'
-                        | b'%'
-                        | b'&'
-                        | b'\''
-                        | b'*'
-                        | b'+'
-                        | b'-'
-                        | b'.'
-                        | b'^'
-                        | b'_'
-                        | b'`'
-                        | b'|'
-                        | b'~'
-                )
-        })
-}
-
-fn is_header_value(bytes: &[u8]) -> bool {
-    bytes
-        .iter()
-        .all(|byte| *byte == b'\t' || (0x20..=0x7e).contains(byte))
-}
-
-fn trim_ascii_whitespace(mut bytes: &[u8]) -> &[u8] {
-    while bytes.first().is_some_and(u8::is_ascii_whitespace) {
-        bytes = &bytes[1..];
-    }
-    while bytes.last().is_some_and(u8::is_ascii_whitespace) {
-        bytes = &bytes[..bytes.len() - 1];
-    }
-    bytes
-}
-
-fn find_bytes(haystack: &[u8], needle: &[u8]) -> Option<usize> {
-    haystack
-        .windows(needle.len())
-        .position(|window| window == needle)
-}
-
-struct BodySink {
-    file: File,
-    hasher: Sha256,
-    size: u64,
-}
-
-impl BodySink {
-    fn new(file: File) -> Self {
-        Self {
-            file,
-            hasher: Sha256::new(),
-            size: 0,
-        }
-    }
-
-    fn write(&mut self, bytes: &[u8]) -> Result<(), GeoDataDownloadError> {
-        let added = u64::try_from(bytes.len()).expect("buffer length fits u64");
-        let next = self
-            .size
-            .checked_add(added)
-            .ok_or_else(|| GeoDataDownloadError::Protocol("body size overflows u64".to_owned()))?;
-        self.file
-            .write_all(bytes)
-            .map_err(GeoDataDownloadError::NetworkIo)?;
-        self.hasher.update(bytes);
-        self.size = next;
-        Ok(())
-    }
-
-    fn finish(mut self, path: &std::path::Path) -> Result<([u8; 32], u64), GeoDataDownloadError> {
-        self.file
-            .flush()
-            .and_then(|()| self.file.sync_all())
-            .map_err(|source| GeoDataDownloadError::File {
-                operation: "flush",
-                path: path.to_path_buf(),
-                source,
-            })?;
-        let sha256 = self.hasher.finalize().into();
-        Ok((sha256, self.size))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::{
-        collections::VecDeque,
-        sync::{Arc, Mutex},
-    };
-
-    use async_trait::async_trait;
-    use tempfile::tempdir;
-    use tokio::io::{AsyncReadExt, AsyncWriteExt};
-
-    use super::*;
-    use crate::{
-        dispatch::{DatagramTransport, DispatchError},
-        session::{DatagramSession, Destination},
-    };
-
-    struct PlainHttpsConnector;
-
-    #[async_trait]
-    impl HttpsConnector for PlainHttpsConnector {
-        async fn connect(
-            &self,
-            _server_name: &str,
-            stream: BoxStream,
-        ) -> Result<BoxStream, GeoDataDownloadError> {
-            Ok(stream)
-        }
-    }
-
-    #[cfg(feature = "benchmark-geodata-http")]
-    #[derive(Default)]
-    struct RecordingHttpsConnector(Mutex<Vec<String>>);
-
-    #[cfg(feature = "benchmark-geodata-http")]
-    #[async_trait]
-    impl HttpsConnector for RecordingHttpsConnector {
-        async fn connect(
-            &self,
-            server_name: &str,
-            stream: BoxStream,
-        ) -> Result<BoxStream, GeoDataDownloadError> {
-            self.0.lock().unwrap().push(server_name.to_owned());
-            Ok(stream)
-        }
-    }
-
-    struct ScriptedDispatcher {
-        responses: Mutex<VecDeque<Vec<u8>>>,
-        sessions: Mutex<Vec<StreamSession>>,
-        requests: Arc<Mutex<Vec<Vec<u8>>>>,
-    }
-
-    struct HangingDispatcher;
-
-    #[async_trait]
-    impl Dispatcher for HangingDispatcher {
-        async fn connect_tcp(&self, _session: StreamSession) -> Result<BoxStream, DispatchError> {
-            std::future::pending().await
-        }
-
-        async fn open_datagram(
-            &self,
-            _session: DatagramSession,
-        ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
-            Err(DispatchError::NotAllowed)
-        }
-    }
-
-    impl ScriptedDispatcher {
-        fn new(responses: impl IntoIterator<Item = Vec<u8>>) -> Self {
-            Self {
-                responses: Mutex::new(responses.into_iter().collect()),
-                sessions: Mutex::new(Vec::new()),
-                requests: Arc::new(Mutex::new(Vec::new())),
-            }
-        }
-
-        fn sessions(&self) -> Vec<StreamSession> {
-            self.sessions.lock().expect("sessions lock").clone()
-        }
-
-        fn requests(&self) -> Vec<Vec<u8>> {
-            self.requests.lock().expect("requests lock").clone()
-        }
-    }
-
-    #[async_trait]
-    impl Dispatcher for ScriptedDispatcher {
-        async fn connect_tcp(&self, session: StreamSession) -> Result<BoxStream, DispatchError> {
-            self.sessions.lock().expect("sessions lock").push(session);
-            let response = self
-                .responses
-                .lock()
-                .expect("responses lock")
-                .pop_front()
-                .ok_or_else(|| DispatchError::Other("no scripted response".to_owned()))?;
-            let requests = Arc::clone(&self.requests);
-            let (client, mut server) = tokio::io::duplex(128 * 1024);
-            tokio::spawn(async move {
-                let mut request = Vec::new();
-                let mut scratch = [0_u8; 1024];
-                loop {
-                    let read = server.read(&mut scratch).await.expect("read request");
-                    if read == 0 {
-                        break;
-                    }
-                    request.extend_from_slice(&scratch[..read]);
-                    if find_bytes(&request, b"\r\n\r\n").is_some() {
-                        break;
-                    }
-                }
-                requests.lock().expect("requests lock").push(request);
-                server.write_all(&response).await.expect("write response");
-                server.shutdown().await.expect("shutdown response");
-            });
-            Ok(Box::new(client))
-        }
-
-        async fn open_datagram(
-            &self,
-            _session: DatagramSession,
-        ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
-            Err(DispatchError::NotAllowed)
-        }
-    }
-
-    fn request(
-        dispatcher: Arc<dyn Dispatcher>,
-        url: &str,
-        temporary_path: PathBuf,
-    ) -> GeoDataDownloadRequest {
-        GeoDataDownloadRequest {
-            dispatcher,
-            url: url.to_owned(),
-            etag: Some("\"old\"".to_owned()),
-            temporary_path,
-            timeout: Duration::from_secs(2),
-            cancellation: CancellationToken::new(),
-        }
-    }
-
-    #[cfg(feature = "benchmark-geodata-http")]
-    #[tokio::test]
-    async fn benchmark_http_uses_the_raw_stream_and_existing_download_outcomes() {
-        for (name, response) in [
-            (
-                "download",
-                b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n4\r\ndata\r\n0\r\n\r\n"
-                    .as_slice(),
-            ),
-            (
-                "not-modified",
-                b"HTTP/1.1 304 Not Modified\r\n\r\n".as_slice(),
-            ),
-            (
-                "truncated",
-                b"HTTP/1.1 200 OK\r\nContent-Length: 8\r\n\r\nshort".as_slice(),
-            ),
-        ] {
-            let directory = tempdir().unwrap();
-            let path = directory.path().join("fixture.new");
-            let dispatcher = Arc::new(ScriptedDispatcher::new([response.to_vec()]));
-            // The real connector would reject this plaintext in-memory peer if
-            // HTTP accidentally attempted a TLS handshake.
-            let outcome = download_geodata_via_proxy(request(
-                dispatcher.clone(),
-                "http://rules.example.test/geoip.dat",
-                path.clone(),
-            ))
-            .await;
-            match name {
-                "download" => {
-                    assert!(matches!(
-                        outcome,
-                        Ok(GeoDataDownloadOutcome::Downloaded { size: 4, .. })
-                    ));
-                    assert_eq!(fs::read(&path).unwrap(), b"data");
-                }
-                "not-modified" => {
-                    assert_eq!(outcome.unwrap(), GeoDataDownloadOutcome::NotModified);
-                    assert!(!path.exists());
-                }
-                "truncated" => {
-                    assert!(matches!(outcome, Err(GeoDataDownloadError::Protocol(_))));
-                    assert!(!path.exists());
-                }
-                _ => unreachable!(),
-            }
-            let sessions = dispatcher.sessions();
-            assert_eq!(sessions.len(), 1);
-            assert_eq!(sessions[0].inbound, InboundKind::InternalGeoData);
-            assert_eq!(
-                sessions[0].destination,
-                Destination::domain("rules.example.test", 80).unwrap()
-            );
-            assert!(
-                std::str::from_utf8(&dispatcher.requests()[0])
-                    .unwrap()
-                    .contains("\r\nHost: rules.example.test\r\n")
-            );
-        }
-    }
-
-    #[cfg(feature = "benchmark-geodata-http")]
-    #[tokio::test]
-    async fn benchmark_http_redirects_allow_plaintext_hops_and_https_upgrade() {
-        let directory = tempdir().unwrap();
-        let path = directory.path().join("redirect.new");
-        let dispatcher = Arc::new(ScriptedDispatcher::new([
-            b"HTTP/1.1 302 Found\r\nLocation: http://cdn.example.test:8080/next.dat\r\nContent-Length: 0\r\n\r\n".to_vec(),
-            b"HTTP/1.1 302 Found\r\nLocation: https://secure.example.test/final.dat\r\nContent-Length: 0\r\n\r\n".to_vec(),
-            b"HTTP/1.1 200 OK\r\nContent-Length: 4\r\n\r\ndata".to_vec(),
-        ]));
-        let connector = RecordingHttpsConnector::default();
-        let outcome = download_with_connector(
-            request(
-                dispatcher.clone(),
-                "http://rules.example.test/start.dat",
-                path,
-            ),
-            &connector,
-        )
-        .await
-        .unwrap();
-        assert!(
-            matches!(outcome, GeoDataDownloadOutcome::Downloaded { final_url, .. } if final_url == "https://secure.example.test/final.dat")
-        );
-        assert_eq!(*connector.0.lock().unwrap(), ["secure.example.test"]);
-        let destinations: Vec<_> = dispatcher
-            .sessions()
-            .into_iter()
-            .map(|session| session.destination)
-            .collect();
-        assert_eq!(
-            destinations,
-            [
-                Destination::domain("rules.example.test", 80).unwrap(),
-                Destination::domain("cdn.example.test", 8080).unwrap(),
-                Destination::domain("secure.example.test", 443).unwrap(),
-            ]
-        );
-        assert!(
-            std::str::from_utf8(&dispatcher.requests()[1])
-                .unwrap()
-                .contains("\r\nHost: cdn.example.test:8080\r\n")
-        );
-    }
-
-    #[cfg(not(feature = "benchmark-geodata-http"))]
-    #[tokio::test]
-    async fn plaintext_geodata_is_rejected_before_dispatch() {
-        let directory = tempdir().unwrap();
-        let path = directory.path().join("http.new");
-        let dispatcher = Arc::new(ScriptedDispatcher::new([]));
-        let error = download_geodata_via_proxy(request(
-            dispatcher.clone(),
-            "http://rules.example.test/geoip.dat",
-            path.clone(),
-        ))
-        .await
-        .unwrap_err();
-        assert!(matches!(error, GeoDataDownloadError::HttpsRequired));
-        assert!(dispatcher.sessions().is_empty());
-        assert!(!path.exists());
-    }
-
-    #[tokio::test]
-    async fn follows_https_redirect_and_streams_chunked_body_through_raw_proxy() {
-        let directory = tempdir().expect("tempdir");
-        let temporary_path = directory.path().join("geosite.dat.new");
-        let dispatcher = Arc::new(ScriptedDispatcher::new([
-            b"HTTP/1.1 302 Found\r\nLocation: https://cdn.example.test/final.dat?version=2\r\nContent-Length: 0\r\n\r\n".to_vec(),
-            b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\nContent-Encoding: identity\r\nETag: \"new\"\r\n\r\n4\r\ngeo-\r\n4\r\ndata\r\n0\r\nX-Checksum: present\r\n\r\n".to_vec(),
-        ]));
-        let outcome = download_with_connector(
-            request(
-                dispatcher.clone(),
-                "https://rules.example.test/geosite.dat",
-                temporary_path.clone(),
-            ),
-            &PlainHttpsConnector,
-        )
-        .await
-        .expect("download succeeds");
-
-        let expected_sha256: [u8; 32] = Sha256::digest(b"geo-data").into();
-        assert_eq!(
-            outcome,
-            GeoDataDownloadOutcome::Downloaded {
-                etag: Some("\"new\"".to_owned()),
-                sha256: expected_sha256,
-                size: 8,
-                final_url: "https://cdn.example.test/final.dat?version=2".to_owned(),
-            }
-        );
-        assert_eq!(
-            fs::read(&temporary_path).expect("temporary data"),
-            b"geo-data"
-        );
-
-        let sessions = dispatcher.sessions();
-        assert_eq!(sessions.len(), 2);
-        assert!(sessions.iter().all(|session| {
-            session.inbound == InboundKind::InternalGeoData
-                && session.source == SocketAddr::from(([0, 0, 0, 0], 0))
-                && session.sniffed_domain.is_none()
-        }));
-        assert_eq!(
-            sessions[0].destination,
-            Destination::Domain {
-                host: "rules.example.test".to_owned(),
-                port: 443,
-            }
-        );
-        assert_eq!(
-            sessions[1].destination,
-            Destination::Domain {
-                host: "cdn.example.test".to_owned(),
-                port: 443,
-            }
-        );
-
-        let requests = dispatcher.requests();
-        assert_eq!(requests.len(), 2);
-        let first = std::str::from_utf8(&requests[0]).expect("request is ASCII");
-        assert!(first.starts_with("GET /geosite.dat HTTP/1.1\r\n"));
-        assert!(first.contains("\r\nHost: rules.example.test\r\n"));
-        assert!(first.contains("\r\nAccept-Encoding: identity\r\n"));
-        assert!(first.contains("\r\nIf-None-Match: \"old\"\r\n"));
-    }
-
-    #[tokio::test]
-    async fn not_modified_removes_the_unused_temporary_file() {
-        let directory = tempdir().expect("tempdir");
-        let temporary_path = directory.path().join("geoip.dat.new");
-        let dispatcher = Arc::new(ScriptedDispatcher::new([
-            b"HTTP/1.1 304 Not Modified\r\nETag: \"old\"\r\n\r\n".to_vec(),
-        ]));
-        let outcome = download_with_connector(
-            request(
-                dispatcher,
-                "https://rules.example.test/geoip.dat",
-                temporary_path.clone(),
-            ),
-            &PlainHttpsConnector,
-        )
-        .await
-        .expect("conditional request succeeds");
-
-        assert_eq!(outcome, GeoDataDownloadOutcome::NotModified);
-        assert!(!temporary_path.exists());
-    }
-
-    #[tokio::test]
-    async fn supports_content_length_and_eof_delimited_bodies() {
-        let directory = tempdir().expect("tempdir");
-        let content_length_path = directory.path().join("content-length.new");
-        let content_length_dispatcher = Arc::new(ScriptedDispatcher::new([
-            b"HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n12345ignored".to_vec(),
-        ]));
-        let content_length = download_with_connector(
-            request(
-                content_length_dispatcher,
-                "https://rules.example.test/content-length",
-                content_length_path.clone(),
-            ),
-            &PlainHttpsConnector,
-        )
-        .await
-        .expect("content-length body");
-        assert!(matches!(
-            content_length,
-            GeoDataDownloadOutcome::Downloaded { size: 5, .. }
-        ));
-        assert_eq!(
-            fs::read(content_length_path).expect("length file"),
-            b"12345"
-        );
-
-        let eof_path = directory.path().join("eof.new");
-        let eof_dispatcher = Arc::new(ScriptedDispatcher::new([
-            b"HTTP/1.1 200 OK\r\nConnection: close\r\n\r\neof-body".to_vec(),
-        ]));
-        let eof = download_with_connector(
-            request(
-                eof_dispatcher,
-                "https://rules.example.test/eof",
-                eof_path.clone(),
-            ),
-            &PlainHttpsConnector,
-        )
-        .await
-        .expect("EOF body");
-        assert!(matches!(
-            eof,
-            GeoDataDownloadOutcome::Downloaded { size: 8, .. }
-        ));
-        assert_eq!(fs::read(eof_path).expect("EOF file"), b"eof-body");
-    }
-
-    #[tokio::test]
-    async fn streams_body_beyond_former_file_size_limits() {
-        let directory = tempdir().unwrap();
-        let temporary_path = directory.path().join("large.new");
-        let length = 32 * 1024 * 1024 + 1;
-        let mut response =
-            format!("HTTP/1.1 200 OK\r\nContent-Length: {length}\r\n\r\n").into_bytes();
-        response.resize(response.len() + length, b'x');
-        let dispatcher = Arc::new(ScriptedDispatcher::new([response]));
-        let mut request = request(
-            dispatcher,
-            "https://rules.example.test/geoip.dat",
-            temporary_path.clone(),
-        );
-        request.timeout = Duration::from_secs(15);
-        let outcome = download_with_connector(request, &PlainHttpsConnector)
-            .await
-            .unwrap();
-        assert!(
-            matches!(outcome, GeoDataDownloadOutcome::Downloaded { size, .. } if size == length as u64)
-        );
-        assert_eq!(fs::metadata(temporary_path).unwrap().len(), length as u64);
-    }
-
-    #[tokio::test]
-    async fn truncated_body_still_removes_partial_file() {
-        let directory = tempdir().unwrap();
-        let temporary_path = directory.path().join("truncated.new");
-        let dispatcher = Arc::new(ScriptedDispatcher::new([
-            b"HTTP/1.1 200 OK\r\nContent-Length: 8\r\n\r\nshort".to_vec(),
-        ]));
-        let error = download_with_connector(
-            request(
-                dispatcher,
-                "https://rules.example.test/geoip.dat",
-                temporary_path.clone(),
-            ),
-            &PlainHttpsConnector,
-        )
-        .await
-        .unwrap_err();
-        assert!(matches!(error, GeoDataDownloadError::Protocol(_)));
-        assert!(!temporary_path.exists());
-    }
-
-    #[tokio::test]
-    async fn rejects_redirect_to_http_without_dispatching_the_second_hop() {
-        let directory = tempdir().expect("tempdir");
-        let temporary_path = directory.path().join("redirect.new");
-        let dispatcher = Arc::new(ScriptedDispatcher::new([
-            b"HTTP/1.1 302 Found\r\nLocation: http://unsafe.example.test/file\r\nContent-Length: 0\r\n\r\n".to_vec(),
-        ]));
-        let error = download_with_connector(
-            request(
-                dispatcher.clone(),
-                "https://rules.example.test/geoip.dat",
-                temporary_path.clone(),
-            ),
-            &PlainHttpsConnector,
-        )
-        .await
-        .expect_err("HTTP redirect must be rejected");
-
-        assert!(matches!(error, GeoDataDownloadError::HttpsRequired));
-        assert_eq!(dispatcher.sessions().len(), 1);
-        assert!(!temporary_path.exists());
-    }
-
-    #[tokio::test]
-    async fn cancellation_wins_before_proxy_dispatch() {
-        let directory = tempdir().expect("tempdir");
-        let temporary_path = directory.path().join("cancelled.new");
-        let dispatcher = Arc::new(ScriptedDispatcher::new([
-            b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n".to_vec(),
-        ]));
-        let request = request(
-            dispatcher.clone(),
-            "https://rules.example.test/geoip.dat",
-            temporary_path.clone(),
-        );
-        request.cancellation.cancel();
-        let error = download_with_connector(request, &PlainHttpsConnector)
-            .await
-            .expect_err("cancelled request");
-
-        assert!(matches!(error, GeoDataDownloadError::Cancelled));
-        assert!(dispatcher.sessions().is_empty());
-        assert!(!temporary_path.exists());
-    }
-
-    #[tokio::test]
-    async fn timeout_covers_proxy_connection_and_removes_temporary_file() {
-        let directory = tempdir().expect("tempdir");
-        let temporary_path = directory.path().join("timeout.new");
-        let mut request = request(
-            Arc::new(HangingDispatcher),
-            "https://rules.example.test/geoip.dat",
-            temporary_path.clone(),
-        );
-        request.timeout = Duration::from_millis(10);
-        let error = download_with_connector(request, &PlainHttpsConnector)
-            .await
-            .expect_err("request must time out");
-
-        assert!(matches!(
-            error,
-            GeoDataDownloadError::TimedOut(duration)
-                if duration == Duration::from_millis(10)
-        ));
-        assert!(!temporary_path.exists());
-    }
-
-    #[test]
-    fn parser_rejects_ambiguous_or_unbounded_framing() {
-        let both = parse_response_head(
-            b"HTTP/1.1 200 OK\r\nContent-Length: 1\r\nTransfer-Encoding: chunked",
-        )
-        .expect("head parses");
-        assert!(matches!(
-            body_framing(&both),
-            Err(GeoDataDownloadError::Protocol(_))
-        ));
-
-        let length = parse_response_head(b"HTTP/1.1 200 OK\r\nContent-Length: 33554433")
-            .expect("head parses");
-        assert_eq!(
-            body_framing(&length).unwrap(),
-            BodyFraming::ContentLength(33_554_433)
-        );
-        assert!(
-            parse_response_head(b"HTTP/1.1 200 OK\r\nContent-Length: 18446744073709551616")
-                .is_err()
-        );
-    }
-
-    #[test]
-    fn url_and_etag_validation_preserve_the_geodata_contract() {
-        #[cfg(not(feature = "benchmark-geodata-http"))]
-        assert!(matches!(
-            parse_geodata_url("http://example.test/file"),
-            Err(GeoDataDownloadError::HttpsRequired)
-        ));
-        assert!(matches!(
-            parse_geodata_url("https://127.0.0.1/file"),
-            Err(GeoDataDownloadError::DomainRequired)
-        ));
-        assert!(matches!(
-            parse_geodata_url("https://user@example.test/file"),
-            Err(GeoDataDownloadError::CredentialsNotAllowed)
-        ));
-        assert_eq!(
-            parse_geodata_url("https://example.test/file#fragment")
-                .unwrap()
-                .as_str(),
-            "https://example.test/file"
-        );
-        assert!(parse_geodata_url("ftp://example.test/file").is_err());
-        assert!(matches!(
-            validate_etag(Some("\"ok\"\r\nX-Evil: yes")),
-            Err(GeoDataDownloadError::InvalidEtag)
-        ));
-    }
-
-    #[test]
-    fn download_endpoints_use_scheme_specific_ports_and_authorities() {
-        for (raw, port, authority) in [
-            ("https://example.test/file", 443, "example.test"),
-            ("https://example.test:80/file", 80, "example.test:80"),
-            ("https://example.test:8443/file", 8443, "example.test:8443"),
-        ] {
-            let endpoint = DownloadEndpoint::from_url(&parse_geodata_url(raw).unwrap()).unwrap();
-            assert_eq!(endpoint.port, port);
-            assert_eq!(endpoint.authority, authority);
-        }
-        #[cfg(feature = "benchmark-geodata-http")]
-        {
-            for (raw, port, authority) in [
-                ("http://example.test/file", 80, "example.test"),
-                ("http://example.test:443/file", 443, "example.test:443"),
-            ] {
-                let endpoint =
-                    DownloadEndpoint::from_url(&parse_geodata_url(raw).unwrap()).unwrap();
-                assert_eq!(endpoint.port, port);
-                assert_eq!(endpoint.authority, authority);
-            }
-            for raw in [
-                "http://127.0.0.1/file",
-                "http://[::1]/file",
-                "http://user@example.test/file",
-                "http://@example.test/file",
-                "http://example.test/file#fragment",
-            ] {
-                assert!(parse_geodata_url(raw).is_err());
-            }
-            let base = parse_geodata_url("http://example.test/start").unwrap();
-            assert_eq!(
-                resolve_redirect(&base, "/next").unwrap().as_str(),
-                "http://example.test/next"
-            );
-            for location in [
-                "ftp://example.test/file",
-                "http://127.0.0.1/file",
-                "http://user@example.test/file",
-                "/file#fragment",
-            ] {
-                assert!(resolve_redirect(&base, location).is_err());
-            }
-        }
-    }
-}
diff --git a/src/http_processing/authority.rs b/src/http_processing/authority.rs
new file mode 100644
index 0000000..6a1aa42
--- /dev/null
+++ b/src/http_processing/authority.rs
@@ -0,0 +1,320 @@
+//! Host-owned CA identity and a small generation-owned leaf certificate cache.
+//! No files, trust installation, global issuer, detached task or private-key log.
+use rcgen::{
+    CertificateParams, ExtendedKeyUsagePurpose, Issuer, KeyPair, KeyUsagePurpose, PublicKeyData,
+};
+use rustls::{
+    ServerConfig,
+    pki_types::{CertificateDer, PrivateKeyDer, PrivatePkcs8KeyDer, pem::PemObject},
+};
+use sha2::{Digest, Sha256};
+use std::{
+    collections::VecDeque,
+    fmt, io,
+    sync::{Arc, Mutex},
+    time::{Duration, Instant},
+};
+use x509_parser::{parse_x509_certificate, time::ASN1Time};
+
+const MAX_IDENTITY: usize = 32 * 1024;
+const MAX_LEAVES: usize = 32;
+const MAX_LEAF_BYTES: usize = 256 * 1024;
+const IDLE: Duration = Duration::from_secs(600);
+const LEAF_LIFETIME: i64 = 24 * 3600;
+fn invalid() -> io::Error {
+    io::Error::new(
+        io::ErrorKind::InvalidInput,
+        "invalid HTTP certificate authority",
+    )
+}
+struct Entry {
+    name: Box<str>,
+    config: Arc<ServerConfig>,
+    bytes: usize,
+    used: Instant,
+    expires: i64,
+}
+struct State {
+    leaves: VecDeque<Entry>,
+    bytes: usize,
+}
+pub(super) struct Authority {
+    issuer: Issuer<'static, KeyPair>,
+    certificate: CertificateDer<'static>,
+    not_before: i64,
+    not_after: i64,
+    provider: Arc<rustls::crypto::CryptoProvider>,
+    // One synchronous ECDSA issuance at a time, with lookup and insertion in
+    // the same short section. Concurrent same-name requests share the result.
+    // No queued signing jobs can outlive cancellation or the Stop barrier.
+    state: Mutex<State>,
+}
+impl fmt::Debug for Authority {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("HttpAuthority").finish_non_exhaustive()
+    }
+}
+impl Authority {
+    pub(super) fn load(certificate_pem: &str, key_pem: &str) -> io::Result<Arc<Self>> {
+        if certificate_pem.len() > MAX_IDENTITY || key_pem.len() > MAX_IDENTITY {
+            return Err(invalid());
+        }
+        let mut certificates = CertificateDer::pem_slice_iter(certificate_pem.as_bytes());
+        let certificate = certificates
+            .next()
+            .ok_or_else(invalid)?
+            .map_err(|_| invalid())?;
+        if certificates.next().is_some() {
+            return Err(invalid());
+        }
+        let (remaining, parsed) =
+            parse_x509_certificate(certificate.as_ref()).map_err(|_| invalid())?;
+        if !remaining.is_empty()
+            || !parsed.validity().is_valid()
+            || !parsed
+                .basic_constraints()
+                .map_err(|_| invalid())?
+                .is_some_and(|ext| ext.value.ca)
+            || parsed
+                .key_usage()
+                .map_err(|_| invalid())?
+                .is_some_and(|ext| !ext.value.key_cert_sign())
+        {
+            return Err(invalid());
+        }
+        let private = PrivateKeyDer::from_pem_slice(key_pem.as_bytes()).map_err(|_| invalid())?;
+        let key = KeyPair::try_from(&private).map_err(|_| invalid())?;
+        if key.subject_public_key_info() != parsed.public_key().raw {
+            return Err(invalid());
+        }
+        let not_before = parsed.validity().not_before.timestamp();
+        let not_after = parsed.validity().not_after.timestamp();
+        let issuer = Issuer::from_ca_cert_der(&certificate, key).map_err(|_| invalid())?;
+        Ok(Arc::new(Self {
+            issuer,
+            certificate,
+            not_before,
+            not_after,
+            provider: Arc::new(rustls::crypto::ring::default_provider()),
+            state: Mutex::new(State {
+                leaves: VecDeque::new(),
+                bytes: 0,
+            }),
+        }))
+    }
+    /// Public certificate identity; private-key spelling never affects a token.
+    pub(super) fn identity(&self) -> [u8; 32] {
+        Sha256::digest(self.certificate.as_ref()).into()
+    }
+    pub(super) fn server_config(&self, name: &str) -> io::Result<Arc<ServerConfig>> {
+        // Validate before a key is generated and never put IP literals or an
+        // unbounded untrusted SNI in the leaf cache.
+        if name.len() > 253
+            || name.parse::<std::net::IpAddr>().is_ok()
+            || !matches!(
+                rustls::pki_types::ServerName::try_from(name),
+                Ok(rustls::pki_types::ServerName::DnsName(_))
+            )
+        {
+            return Err(invalid());
+        }
+        let now = Instant::now();
+        let unix = ASN1Time::now().timestamp();
+        if unix < self.not_before || unix >= self.not_after {
+            return Err(invalid());
+        }
+        let mut state = self.state.lock().map_err(|_| invalid())?;
+        let mut index = 0;
+        while index < state.leaves.len() {
+            let entry = &state.leaves[index];
+            if now.saturating_duration_since(entry.used) >= IDLE || entry.expires <= unix {
+                let expired = state.leaves.remove(index).unwrap();
+                state.bytes -= expired.bytes;
+            } else {
+                index += 1;
+            }
+        }
+        if let Some(entry) = state
+            .leaves
+            .iter_mut()
+            .find(|entry| entry.name.as_ref() == name)
+        {
+            entry.used = now;
+            return Ok(entry.config.clone());
+        }
+        let key = KeyPair::generate().map_err(|_| invalid())?;
+        let mut params = CertificateParams::new(vec![name.into()]).map_err(|_| invalid())?;
+        params.not_before = ASN1Time::from_timestamp((unix - 300).max(self.not_before))
+            .map_err(|_| invalid())?
+            .to_datetime();
+        let expires = (unix + LEAF_LIFETIME).min(self.not_after);
+        params.not_after = ASN1Time::from_timestamp(expires)
+            .map_err(|_| invalid())?
+            .to_datetime();
+        params.key_usages = vec![KeyUsagePurpose::DigitalSignature];
+        params.extended_key_usages = vec![ExtendedKeyUsagePurpose::ServerAuth];
+        params.use_authority_key_identifier_extension = true;
+        let leaf = params
+            .signed_by(&key, &self.issuer)
+            .map_err(|_| invalid())?;
+        let private = key.serialize_der();
+        // Include a conservative fixed cost for the rustls config and signer.
+        let bytes = leaf.der().len() + self.certificate.len() + private.len() + name.len() + 4096;
+        if bytes > MAX_LEAF_BYTES {
+            return Err(invalid());
+        }
+        let mut config = ServerConfig::builder_with_provider(self.provider.clone())
+            .with_safe_default_protocol_versions()
+            .map_err(|_| invalid())?
+            .with_no_client_auth()
+            .with_single_cert(
+                vec![leaf.der().clone(), self.certificate.clone()],
+                PrivateKeyDer::Pkcs8(PrivatePkcs8KeyDer::from(private)),
+            )
+            .map_err(|_| invalid())?;
+        config.alpn_protocols = vec![b"h2".to_vec(), b"http/1.1".to_vec()];
+        config.send_tls13_tickets = 0;
+        config.session_storage = Arc::new(rustls::server::NoServerSessionStorage {});
+        let config = Arc::new(config);
+        while state.leaves.len() >= MAX_LEAVES || state.bytes + bytes > MAX_LEAF_BYTES {
+            let oldest = state
+                .leaves
+                .iter()
+                .enumerate()
+                .min_by_key(|(_, entry)| entry.used)
+                .map(|(i, _)| i)
+                .ok_or_else(invalid)?;
+            let evicted = state.leaves.remove(oldest).unwrap();
+            state.bytes -= evicted.bytes;
+        }
+        state.bytes += bytes;
+        state.leaves.push_back(Entry {
+            name: name.into(),
+            config: config.clone(),
+            bytes,
+            used: now,
+            expires,
+        });
+        Ok(config)
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rcgen::{BasicConstraints, IsCa};
+    fn pem(label: &str, bytes: &[u8]) -> String {
+        use base64::Engine as _;
+        format!(
+            "-----BEGIN {label}-----\n{}\n-----END {label}-----\n",
+            base64::engine::general_purpose::STANDARD.encode(bytes)
+        )
+    }
+    fn identity() -> (String, String) {
+        let mut params = CertificateParams::default();
+        params.is_ca = IsCa::Ca(BasicConstraints::Unconstrained);
+        params.key_usages = vec![KeyUsagePurpose::KeyCertSign, KeyUsagePurpose::CrlSign];
+        let key = KeyPair::generate().unwrap();
+        let cert = params.self_signed(&key).unwrap();
+        (
+            pem("CERTIFICATE", cert.der()),
+            pem("PRIVATE KEY", &key.serialize_der()),
+        )
+    }
+    #[test]
+    fn authority_checks_ca_identity_and_bounds_generation_owned_leaves() {
+        let (cert, key) = identity();
+        let authority = Authority::load(&cert, &key).unwrap();
+        let first = authority.server_config("one.example").unwrap();
+        assert!(Arc::ptr_eq(
+            &first,
+            &authority.server_config("one.example").unwrap()
+        ));
+        for index in 0..MAX_LEAVES * 2 {
+            authority
+                .server_config(&format!("{index}.example"))
+                .unwrap();
+        }
+        let state = authority.state.lock().unwrap();
+        assert!(state.leaves.len() <= MAX_LEAVES);
+        assert!(state.bytes <= MAX_LEAF_BYTES);
+        drop(state);
+        let (_, other) = identity();
+        assert!(Authority::load(&cert, &other).is_err());
+        assert!(authority.server_config("127.0.0.1").is_err());
+        let leaf = rcgen::generate_simple_self_signed(vec!["leaf.example".into()]).unwrap();
+        assert!(
+            Authority::load(
+                &pem("CERTIFICATE", leaf.cert.der()),
+                &pem("PRIVATE KEY", &leaf.signing_key.serialize_der())
+            )
+            .is_err()
+        );
+    }
+    #[test]
+    fn ca_chain_bytes_are_charged_to_each_retained_leaf() {
+        let names = (0..96)
+            .map(|index| format!("{index}.{}.example", "a".repeat(48)))
+            .collect::<Vec<_>>();
+        let mut params = CertificateParams::new(names).unwrap();
+        params.is_ca = IsCa::Ca(BasicConstraints::Unconstrained);
+        params.key_usages = vec![KeyUsagePurpose::KeyCertSign];
+        let key = KeyPair::generate().unwrap();
+        let cert = params.self_signed(&key).unwrap();
+        assert!(cert.der().len() > 4096);
+        let authority = Authority::load(
+            &pem("CERTIFICATE", cert.der()),
+            &pem("PRIVATE KEY", &key.serialize_der()),
+        )
+        .unwrap();
+        for index in 0..64 {
+            authority
+                .server_config(&format!("{index}.example"))
+                .unwrap();
+        }
+        let state = authority.state.lock().unwrap();
+        assert!(state.bytes <= MAX_LEAF_BYTES);
+        assert!(state.bytes >= state.leaves.len() * (cert.der().len() + 4096));
+    }
+    #[tokio::test]
+    async fn issued_leaf_identifies_its_authority_in_a_memory_tls_handshake() {
+        let (cert, key) = identity();
+        let authority = Authority::load(&cert, &key).unwrap();
+        let mut roots = rustls::RootCertStore::empty();
+        roots.add(authority.certificate.clone()).unwrap();
+        let client = rustls::ClientConfig::builder_with_provider(authority.provider.clone())
+            .with_safe_default_protocol_versions()
+            .unwrap()
+            .with_root_certificates(roots)
+            .with_no_client_auth();
+        let (client_io, server_io) = tokio::io::duplex(16 * 1024);
+        let acceptor =
+            tokio_rustls::TlsAcceptor::from(authority.server_config("one.example").unwrap());
+        let connector = tokio_rustls::TlsConnector::from(Arc::new(client));
+        let (server, client) = tokio::join!(
+            acceptor.accept(server_io),
+            connector.connect("one.example".try_into().unwrap(), client_io)
+        );
+        let _server = server.unwrap();
+        let client = client.unwrap();
+        let certificates = client.get_ref().1.peer_certificates().unwrap();
+        let (_, leaf) = parse_x509_certificate(certificates[0].as_ref()).unwrap();
+        use x509_parser::extensions::ParsedExtension;
+        let leaf_id =
+            leaf.extensions()
+                .iter()
+                .find_map(|extension| match extension.parsed_extension() {
+                    ParsedExtension::AuthorityKeyIdentifier(id) => id.key_identifier.as_ref(),
+                    _ => None,
+                });
+        let (_, ca) = parse_x509_certificate(authority.certificate.as_ref()).unwrap();
+        let ca_id =
+            ca.extensions()
+                .iter()
+                .find_map(|extension| match extension.parsed_extension() {
+                    ParsedExtension::SubjectKeyIdentifier(id) => Some(id),
+                    _ => None,
+                });
+        assert!(leaf_id.is_some());
+        assert_eq!(leaf_id, ca_id);
+    }
+}
diff --git a/src/http_processing/body.rs b/src/http_processing/body.rs
new file mode 100644
index 0000000..cfcd29f
--- /dev/null
+++ b/src/http_processing/body.rs
@@ -0,0 +1,629 @@
+//! Bounded, atomic content rewriting. Adapters retain their framing cursors.
+use super::body_budget as budget;
+#[path = "body_codec.rs"]
+mod codec;
+#[path = "body_json.rs"]
+mod json;
+pub(crate) use budget::{Budget, BudgetedBytes, MAX_BODY};
+
+use super::{
+    headers::Fields,
+    rules::{BodyOperation, Phase, Rule, RuleAction},
+};
+use url::Url;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum Bypass {
+    NoRules,
+    ForbiddenBody,
+    Streaming,
+    Trailers,
+    Charset,
+    Encoding,
+    IdentityExcluded,
+    Budget,
+    Size,
+    InvalidText,
+    Transform,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum Encoding {
+    Identity,
+    Gzip,
+    Deflate,
+    Brotli,
+    Unsupported,
+}
+
+/// Capture before request-header actions. Content negotiation must reflect the
+/// client that will actually receive the response, not a rewritten header.
+pub(crate) struct OriginalRequestMeta {
+    pub(crate) head: bool,
+    pub(crate) connect: bool,
+    pub(crate) identity_allowed: bool,
+}
+impl OriginalRequestMeta {
+    pub(crate) fn new(method: &str, fields: &Fields) -> Self {
+        Self {
+            head: method == "HEAD",
+            connect: method == "CONNECT",
+            identity_allowed: identity_allowed(fields),
+        }
+    }
+}
+
+pub(crate) struct WireBodyMeta {
+    pub(crate) encoding: Encoding,
+    pub(crate) length: Option<u64>,
+    bypass: Option<Bypass>,
+}
+impl WireBodyMeta {
+    pub(crate) fn new(
+        fields: &Fields,
+        original: &OriginalRequestMeta,
+        phase: Phase,
+        status: Option<u16>,
+        length: Option<u64>,
+        upgraded: bool,
+    ) -> Self {
+        let values = |name: &'static str| {
+            fields
+                .iter()
+                .filter(move |(key, _)| key.eq_ignore_ascii_case(name))
+                .map(|(_, value)| value.as_str())
+        };
+        let mut encodings = values("content-encoding")
+            .flat_map(|value| value.split(','))
+            .map(str::trim);
+        let encoding = match encodings.next() {
+            None => Encoding::Identity,
+            Some(value) if value.eq_ignore_ascii_case("identity") => Encoding::Identity,
+            Some(value) if value.eq_ignore_ascii_case("gzip") => Encoding::Gzip,
+            Some(value) if value.eq_ignore_ascii_case("deflate") => Encoding::Deflate,
+            Some(value) if value.eq_ignore_ascii_case("br") => Encoding::Brotli,
+            _ => Encoding::Unsupported,
+        };
+        let encoding = if encodings.next().is_some() {
+            Encoding::Unsupported
+        } else {
+            encoding
+        };
+        let mut bypass = None;
+        if original.head
+            || original.connect
+            || upgraded
+            || status.is_some_and(|status| status < 200 || matches!(status, 204 | 304))
+        {
+            bypass = Some(Bypass::ForbiddenBody);
+        } else if status == Some(206) || values("content-range").next().is_some() {
+            bypass = Some(Bypass::Streaming);
+        } else if values("trailer").next().is_some() {
+            bypass = Some(Bypass::Trailers);
+        } else if phase == Phase::Response && !original.identity_allowed {
+            bypass = Some(Bypass::IdentityExcluded);
+        }
+        for content_type in values("content-type") {
+            let mut parts = content_type.split(';');
+            let media = parts.next().unwrap_or_default().trim().to_ascii_lowercase();
+            if media == "text/event-stream"
+                || media == "application/grpc"
+                || media.starts_with("application/grpc+")
+                || media.starts_with("multipart/")
+            {
+                bypass = Some(Bypass::Streaming);
+            }
+            for parameter in parts {
+                if let Some((key, value)) = parameter.split_once('=')
+                    && key.trim().eq_ignore_ascii_case("charset")
+                    && !matches!(
+                        value.trim().trim_matches('"').to_ascii_lowercase().as_str(),
+                        "utf-8" | "utf8"
+                    )
+                {
+                    bypass = Some(Bypass::Charset);
+                }
+            }
+        }
+        if values("content-type").count() > 1 {
+            bypass = Some(Bypass::Charset);
+        }
+        Self {
+            encoding,
+            length,
+            bypass,
+        }
+    }
+    pub(crate) fn eligibility(&self) -> Result<(), Bypass> {
+        if let Some(reason) = self.bypass {
+            return Err(reason);
+        }
+        if self.encoding == Encoding::Unsupported {
+            return Err(Bypass::Encoding);
+        }
+        if self.length.is_some_and(|length| length > MAX_BODY as u64) {
+            return Err(Bypass::Size);
+        }
+        Ok(())
+    }
+}
+
+fn quality(value: &str) -> Option<u16> {
+    let value = value.trim();
+    let (integer, fraction) = value.split_once('.').unwrap_or((value, ""));
+    if !matches!(integer, "0" | "1")
+        || fraction.len() > 3
+        || !fraction.bytes().all(|value| value.is_ascii_digit())
+    {
+        return None;
+    }
+    let decimal = if fraction.is_empty() {
+        0
+    } else {
+        fraction.parse::<u16>().ok()? * 10u16.pow(3 - fraction.len() as u32)
+    };
+    if integer == "1" {
+        (decimal == 0).then_some(1000)
+    } else {
+        Some(decimal)
+    }
+}
+
+fn identity_allowed(fields: &Fields) -> bool {
+    let mut identity = None;
+    let mut wildcard = None;
+    for (_, value) in fields
+        .iter()
+        .filter(|(name, _)| name.eq_ignore_ascii_case("accept-encoding"))
+    {
+        for coding in value.split(',').filter(|coding| !coding.trim().is_empty()) {
+            let mut parts = coding.split(';');
+            let token = parts.next().unwrap_or_default().trim();
+            let mut weight = 1000;
+            let mut seen_quality = false;
+            for parameter in parts {
+                let Some((name, value)) = parameter.split_once('=') else {
+                    return false;
+                };
+                if !name.trim().eq_ignore_ascii_case("q") || seen_quality {
+                    return false;
+                }
+                let Some(parsed) = quality(value) else {
+                    return false;
+                };
+                seen_quality = true;
+                weight = parsed;
+            }
+            let slot = if token.eq_ignore_ascii_case("identity") {
+                &mut identity
+            } else if token == "*" {
+                &mut wildcard
+            } else {
+                continue;
+            };
+            if slot.is_some() {
+                return false;
+            }
+            *slot = Some(weight);
+        }
+    }
+    identity.or(wildcard).is_none_or(|quality| quality != 0)
+}
+
+pub(crate) fn has_rules(rules: &[Rule], original: &Url, phase: Phase) -> bool {
+    rules.iter().any(|rule| {
+        matches!(&rule.action, RuleAction::Body { phase: p, operation } if *p == phase && !matches!(operation, BodyOperation::JsonPatch(patch) if patch.is_empty()))
+            && rule.matches(original)
+    })
+}
+
+pub(crate) struct Transaction<'a> {
+    budget: Budget,
+    raw: BudgetedBytes,
+    rules: &'a [Rule],
+    original: &'a Url,
+    phase: Phase,
+    encoding: Encoding,
+}
+pub(crate) struct ResultBody {
+    pub(crate) body: BudgetedBytes,
+    pub(crate) changed: bool,
+    pub(crate) bypass: Option<Bypass>,
+    original: Option<BudgetedBytes>,
+}
+impl ResultBody {
+    pub(crate) fn rollback(&mut self, reason: Bypass) {
+        if let Some(original) = self.original.take() {
+            self.body = original;
+        }
+        self.changed = false;
+        self.bypass = Some(reason);
+    }
+    pub(crate) fn finalize_headers(&mut self, fields: &mut Fields) {
+        if !self.changed {
+            return;
+        }
+        let mut candidate = fields.clone();
+        repair_metadata(&mut candidate, self.body.as_ref().len());
+        if super::headers::check(&candidate).is_ok() {
+            *fields = candidate;
+            self.original.take();
+        } else {
+            self.rollback(Bypass::Budget);
+        }
+    }
+}
+
+impl<'a> Transaction<'a> {
+    pub(crate) fn begin(
+        budget: &Budget,
+        rules: &'a [Rule],
+        original: &'a Url,
+        phase: Phase,
+        wire: &WireBodyMeta,
+    ) -> Result<Self, Bypass> {
+        if !has_rules(rules, original, phase) {
+            return Err(Bypass::NoRules);
+        }
+        wire.eligibility()?;
+        let capacity = wire.length.map_or(MAX_BODY + 1, |length| length as usize);
+        let raw = BudgetedBytes::new(budget, capacity).ok_or(Bypass::Budget)?;
+        Ok(Self {
+            budget: budget.clone(),
+            raw,
+            rules,
+            original,
+            phase,
+            encoding: wire.encoding,
+        })
+    }
+    pub(crate) fn remaining(&self) -> usize {
+        self.raw.remaining()
+    }
+    pub(crate) fn push(&mut self, bytes: &[u8]) -> Result<(), Bypass> {
+        self.raw.extend(bytes).map_err(|_| Bypass::Size)?;
+        if self.raw.as_ref().len() > MAX_BODY {
+            return Err(Bypass::Size);
+        }
+        Ok(())
+    }
+    pub(crate) fn into_raw(self) -> BudgetedBytes {
+        self.raw
+    }
+    pub(crate) fn finish(self, has_trailers: bool) -> ResultBody {
+        let fallback = |raw, reason| ResultBody {
+            body: raw,
+            changed: false,
+            bypass: Some(reason),
+            original: None,
+        };
+        if has_trailers {
+            return fallback(self.raw, Bypass::Trailers);
+        }
+        if self.raw.as_ref().len() > MAX_BODY {
+            return fallback(self.raw, Bypass::Size);
+        }
+        let decoded = match codec::decode(self.raw.as_ref(), self.encoding, &self.budget) {
+            Ok(decoded) => decoded,
+            Err(reason) => return fallback(self.raw, reason),
+        };
+        let baseline = decoded
+            .as_ref()
+            .map_or(self.raw.as_ref(), |value| value.as_ref());
+        if std::str::from_utf8(baseline).is_err() {
+            return fallback(self.raw, Bypass::InvalidText);
+        }
+        let mut candidate = None;
+        for rule in self.rules {
+            let RuleAction::Body { phase, operation } = &rule.action else {
+                continue;
+            };
+            if *phase != self.phase || !rule.matches(self.original) {
+                continue;
+            }
+            match operation {
+                BodyOperation::Set(value) => {
+                    let Some(output) = BudgetedBytes::copy(&self.budget, value.as_bytes()) else {
+                        return fallback(self.raw, Bypass::Budget);
+                    };
+                    candidate = Some(output);
+                }
+                BodyOperation::Replace(search) => {
+                    let input = candidate
+                        .as_ref()
+                        .map_or(baseline, |value: &BudgetedBytes| value.as_ref());
+                    let input = std::str::from_utf8(input).expect("body candidates stay UTF-8");
+                    let Some(mut output) = BudgetedBytes::new(&self.budget, MAX_BODY) else {
+                        return fallback(self.raw, Bypass::Budget);
+                    };
+                    if output
+                        .write_text(|output| search.apply_into(input, output, MAX_BODY))
+                        .is_err()
+                    {
+                        return fallback(self.raw, Bypass::Transform);
+                    }
+                    candidate = Some(output);
+                }
+                BodyOperation::JsonPatch(patch) if patch.is_empty() => {}
+                BodyOperation::JsonPatch(patch) => {
+                    let input = candidate
+                        .as_ref()
+                        .map_or(baseline, |value: &BudgetedBytes| value.as_ref());
+                    let input = std::str::from_utf8(input).expect("body candidates stay UTF-8");
+                    match json::apply(input, patch, &self.budget) {
+                        Ok(output) => candidate = Some(output),
+                        Err(reason) => return fallback(self.raw, reason),
+                    }
+                }
+            }
+        }
+        match candidate {
+            Some(output) if output.as_ref() != baseline => ResultBody {
+                body: output,
+                changed: true,
+                bypass: None,
+                original: Some(self.raw),
+            },
+            _ => ResultBody {
+                body: self.raw,
+                changed: false,
+                bypass: None,
+                original: None,
+            },
+        }
+    }
+}
+
+/// Final representation repair follows successful content changes and therefore
+/// takes precedence over independently successful ordinary header actions.
+pub(crate) fn repair_metadata(fields: &mut Fields, length: usize) {
+    fields.retain(|(name, _)| {
+        !matches!(
+            name.to_ascii_lowercase().as_str(),
+            "content-length"
+                | "transfer-encoding"
+                | "content-encoding"
+                | "etag"
+                | "last-modified"
+                | "content-md5"
+                | "content-digest"
+                | "repr-digest"
+                | "signature"
+                | "signature-input"
+                | "accept-ranges"
+        )
+    });
+    for (name, value) in fields.iter_mut() {
+        if name.eq_ignore_ascii_case("content-type") {
+            let mut pieces = value.split(';');
+            let mut repaired = pieces.next().unwrap_or_default().to_owned();
+            for parameter in pieces {
+                if parameter
+                    .split_once('=')
+                    .is_some_and(|(key, _)| key.trim().eq_ignore_ascii_case("charset"))
+                {
+                    continue;
+                }
+                repaired.push(';');
+                repaired.push_str(parameter);
+            }
+            repaired.push_str("; charset=utf-8");
+            *value = repaired;
+        }
+    }
+    fields.push(("Content-Length".into(), length.to_string()));
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn rules(yaml: &str) -> Vec<Rule> {
+        let raw: Vec<super::super::rules::RawRule> = serde_yaml_ng::from_str(yaml).unwrap();
+        let mut total = 0;
+        raw.into_iter()
+            .map(|raw| Rule::compile(raw, &mut total).unwrap())
+            .collect()
+    }
+    #[test]
+    fn identity_negotiation_uses_specific_weight_and_original_metadata() {
+        for (text, allowed) in [
+            ("gzip", true),
+            ("identity;q=0", false),
+            ("*;q=0", false),
+            ("*;q=0, identity;q=0.5", true),
+            ("identity;q=0, *;q=1", false),
+        ] {
+            let request =
+                OriginalRequestMeta::new("GET", &vec![("Accept-Encoding".into(), text.into())]);
+            assert_eq!(request.identity_allowed, allowed);
+            let wire = WireBodyMeta::new(
+                &vec![],
+                &request,
+                Phase::Response,
+                Some(200),
+                Some(0),
+                false,
+            );
+            assert_eq!(wire.eligibility().is_ok(), allowed);
+        }
+    }
+    #[test]
+    fn bounded_set_holds_raw_until_success_and_preserves_trailer_original() {
+        let rules = rules("- {url: '.', action: response-body-set, value: changed}");
+        let url = Url::parse("http://a.example/").unwrap();
+        let request = OriginalRequestMeta::new("GET", &vec![]);
+        let wire = WireBodyMeta::new(
+            &vec![],
+            &request,
+            Phase::Response,
+            Some(200),
+            Some(8),
+            false,
+        );
+        let budget = Budget::default();
+        for trailers in [false, true] {
+            let mut transaction =
+                Transaction::begin(&budget, &rules, &url, Phase::Response, &wire).unwrap();
+            transaction.push(b"original").unwrap();
+            let result = transaction.finish(trailers);
+            assert_eq!(result.changed, !trailers);
+            assert_eq!(
+                result.body.as_ref(),
+                if trailers {
+                    b"original".as_slice()
+                } else {
+                    b"changed".as_slice()
+                }
+            );
+        }
+        assert_eq!(budget.used(), 0);
+    }
+    #[test]
+    fn body_exclusions_use_wire_metadata_and_allow_normal_zero_bodies() {
+        let request = OriginalRequestMeta::new("GET", &vec![]);
+        for (name, value) in [
+            ("Content-Type", "text/event-stream"),
+            ("Content-Type", "application/json; charset=iso-8859-1"),
+            ("Trailer", "X-Final"),
+            ("Content-Range", "bytes 0-1/3"),
+        ] {
+            let wire = WireBodyMeta::new(
+                &vec![(name.into(), value.into())],
+                &request,
+                Phase::Response,
+                Some(200),
+                Some(0),
+                false,
+            );
+            assert!(wire.eligibility().is_err());
+        }
+        assert!(
+            WireBodyMeta::new(
+                &vec![],
+                &request,
+                Phase::Response,
+                Some(200),
+                Some(0),
+                false
+            )
+            .eligibility()
+            .is_ok()
+        );
+        assert!(
+            WireBodyMeta::new(
+                &vec![],
+                &request,
+                Phase::Response,
+                Some(204),
+                Some(0),
+                false
+            )
+            .eligibility()
+            .is_err()
+        );
+    }
+
+    #[test]
+    fn text_rules_accumulate_but_failed_patch_restores_the_entire_stage() {
+        let url = Url::parse("https://a.example/").unwrap();
+        let meta = OriginalRequestMeta::new("POST", &vec![]);
+        let wire = WireBodyMeta::new(&vec![], &meta, Phase::Request, None, Some(8), false);
+        let budget = Budget::default();
+        let text = rules(
+            r#"
+- {url: '.', action: request-body-set, value: 'a=1,b=2'}
+- {url: '.', action: request-body-replace, search: '([0-9])', search-mode: regex, replacement: '${1}0'}
+"#,
+        );
+        let mut transaction =
+            Transaction::begin(&budget, &text, &url, Phase::Request, &wire).unwrap();
+        transaction.push(b"original").unwrap();
+        let mut result = transaction.finish(false);
+        let mut fields = vec![
+            ("Content-MD5".into(), "old".into()),
+            ("Content-Type".into(), "text/plain; charset=ascii".into()),
+        ];
+        result.finalize_headers(&mut fields);
+        assert!(result.changed);
+        assert_eq!(result.body.as_ref(), b"a=10,b=20");
+        assert!(
+            fields
+                .iter()
+                .all(|(name, _)| !name.eq_ignore_ascii_case("content-md5"))
+        );
+        assert!(
+            fields
+                .iter()
+                .any(|(name, value)| name.eq_ignore_ascii_case("content-type")
+                    && value == "text/plain; charset=utf-8")
+        );
+        drop(result);
+        let failed = rules(
+            r#"
+- {url: '.', action: request-body-set, value: '{"ok":true}'}
+- {url: '.', action: request-body-json-patch, patch: [{op: test, path: /ok, value: false}]}
+"#,
+        );
+        let mut transaction =
+            Transaction::begin(&budget, &failed, &url, Phase::Request, &wire).unwrap();
+        transaction.push(b"original").unwrap();
+        let result = transaction.finish(false);
+        assert!(!result.changed);
+        assert_eq!(result.body.as_ref(), b"original");
+        assert_eq!(result.bypass, Some(Bypass::Transform));
+        drop(result);
+        assert_eq!(budget.used(), 0);
+    }
+
+    #[test]
+    fn header_repair_failure_keeps_raw_and_independent_header_actions() {
+        let rules = rules("- {url: '.', action: response-body-set, value: changed}");
+        let url = Url::parse("http://a.example/").unwrap();
+        let request = OriginalRequestMeta::new("GET", &vec![]);
+        let wire = WireBodyMeta::new(
+            &vec![],
+            &request,
+            Phase::Response,
+            Some(200),
+            Some(8),
+            false,
+        );
+        let budget = Budget::default();
+        let mut transaction =
+            Transaction::begin(&budget, &rules, &url, Phase::Response, &wire).unwrap();
+        transaction.push(b"original").unwrap();
+        let mut result = transaction.finish(false);
+        let mut fields = vec![("X-Independent".into(), "kept".into()); 100];
+        result.finalize_headers(&mut fields);
+        assert!(!result.changed);
+        assert_eq!(result.bypass, Some(Bypass::Budget));
+        assert_eq!(result.body.as_ref(), b"original");
+        assert_eq!(fields.len(), 100);
+    }
+
+    #[test]
+    fn compressed_noop_retains_original_representation() {
+        use std::io::Write;
+        let rules = rules("- {url: '.', action: response-body-set, value: original}");
+        let mut gzip = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+        gzip.write_all(b"original").unwrap();
+        let gzip = gzip.finish().unwrap();
+        let url = Url::parse("http://a.example/").unwrap();
+        let request = OriginalRequestMeta::new("GET", &vec![]);
+        let wire = WireBodyMeta::new(
+            &vec![("Content-Encoding".into(), "gzip".into())],
+            &request,
+            Phase::Response,
+            Some(200),
+            Some(gzip.len() as u64),
+            false,
+        );
+        let budget = Budget::default();
+        let mut transaction =
+            Transaction::begin(&budget, &rules, &url, Phase::Response, &wire).unwrap();
+        transaction.push(&gzip).unwrap();
+        let result = transaction.finish(false);
+        assert!(!result.changed);
+        assert_eq!(result.body.as_ref(), gzip);
+    }
+}
diff --git a/src/http_processing/body_budget.rs b/src/http_processing/body_budget.rs
new file mode 100644
index 0000000..004482e
--- /dev/null
+++ b/src/http_processing/body_budget.rs
@@ -0,0 +1,161 @@
+//! Runtime-wide, nonwaiting ownership of temporary HTTP body allocations.
+use bytes::Bytes;
+use std::{
+    io,
+    sync::{
+        Arc,
+        atomic::{AtomicUsize, Ordering},
+    },
+};
+
+pub(crate) const MAX_BODY: usize = 256 * 1024;
+pub(crate) const WORKSPACE: usize = 2 * 1024 * 1024;
+
+#[derive(Clone)]
+pub(crate) struct Budget(Arc<Inner>);
+struct Inner {
+    used: AtomicUsize,
+    limit: usize,
+}
+
+impl Default for Budget {
+    fn default() -> Self {
+        Self(Arc::new(Inner {
+            used: AtomicUsize::new(0),
+            limit: WORKSPACE,
+        }))
+    }
+}
+
+impl Budget {
+    pub(crate) fn reserve(&self, bytes: usize) -> Option<Reservation> {
+        self.0
+            .used
+            .try_update(Ordering::AcqRel, Ordering::Acquire, |used| {
+                used.checked_add(bytes).filter(|next| *next <= self.0.limit)
+            })
+            .ok()?;
+        Some(Reservation {
+            budget: self.clone(),
+            bytes,
+        })
+    }
+
+    #[cfg(test)]
+    pub(crate) fn used(&self) -> usize {
+        self.0.used.load(Ordering::Acquire)
+    }
+}
+
+pub(crate) struct Reservation {
+    budget: Budget,
+    bytes: usize,
+}
+impl Drop for Reservation {
+    fn drop(&mut self) {
+        self.budget.0.used.fetch_sub(self.bytes, Ordering::AcqRel);
+    }
+}
+
+/// A fixed-capacity allocation. Its reservation follows every Bytes slice and
+/// is released only when the last sender/driver has dropped the actual owner.
+pub(crate) struct BudgetedBytes {
+    bytes: Vec<u8>,
+    _reservation: Reservation,
+}
+
+impl BudgetedBytes {
+    pub(crate) fn new(budget: &Budget, capacity: usize) -> Option<Self> {
+        let bytes = capacity.checked_add(std::mem::size_of::<Self>())?;
+        let reservation = budget.reserve(bytes)?;
+        let mut buffer = Vec::new();
+        buffer.try_reserve_exact(capacity).ok()?;
+        // Vec's allocation policy is allowed to return more than requested.
+        // Never silently retain an unreserved capacity.
+        if buffer.capacity() > capacity {
+            return None;
+        }
+        Some(Self {
+            bytes: buffer,
+            _reservation: reservation,
+        })
+    }
+
+    pub(crate) fn copy(budget: &Budget, value: &[u8]) -> Option<Self> {
+        let mut result = Self::new(budget, value.len())?;
+        result.extend(value).ok()?;
+        Some(result)
+    }
+
+    pub(crate) fn extend(&mut self, value: &[u8]) -> io::Result<()> {
+        if value.len() > self.remaining() {
+            return Err(io::Error::new(
+                io::ErrorKind::FileTooLarge,
+                "HTTP body workspace exceeded",
+            ));
+        }
+        self.bytes.extend_from_slice(value);
+        Ok(())
+    }
+
+    pub(crate) fn remaining(&self) -> usize {
+        self.bytes.capacity() - self.bytes.len()
+    }
+
+    pub(crate) fn into_bytes(self) -> Bytes {
+        Bytes::from_owner(self)
+    }
+
+    pub(crate) fn write_text(
+        &mut self,
+        operation: impl FnOnce(&mut String) -> io::Result<()>,
+    ) -> io::Result<()> {
+        let mut text = String::from_utf8(std::mem::take(&mut self.bytes))
+            .map_err(|_| io::Error::new(io::ErrorKind::InvalidData, "HTTP body text is invalid"))?;
+        let result = operation(&mut text);
+        self.bytes = text.into_bytes();
+        result
+    }
+}
+
+impl AsRef<[u8]> for BudgetedBytes {
+    fn as_ref(&self) -> &[u8] {
+        &self.bytes
+    }
+}
+impl io::Write for BudgetedBytes {
+    fn write(&mut self, value: &[u8]) -> io::Result<usize> {
+        self.extend(value)?;
+        Ok(value.len())
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn ownership_survives_bytes_clone_and_slice() {
+        let budget = Budget::default();
+        let output = BudgetedBytes::copy(&budget, b"original")
+            .unwrap()
+            .into_bytes();
+        let retained = output.slice(2..5);
+        drop(output);
+        assert!(budget.used() >= 8);
+        assert_eq!(&retained[..], b"igi");
+        drop(retained);
+        assert_eq!(budget.used(), 0);
+    }
+    #[test]
+    fn full_workspace_never_waits_and_drop_restores_admission() {
+        let budget = Budget::default();
+        let reservation = budget.reserve(WORKSPACE).unwrap();
+        assert!(BudgetedBytes::new(&budget, 1).is_none());
+        drop(reservation);
+        assert!(BudgetedBytes::new(&budget, MAX_BODY).is_some());
+        assert_eq!(budget.used(), 0);
+    }
+}
diff --git a/src/http_processing/body_codec.rs b/src/http_processing/body_codec.rs
new file mode 100644
index 0000000..ace8abd
--- /dev/null
+++ b/src/http_processing/body_codec.rs
@@ -0,0 +1,372 @@
+//! Content decoding into caller-owned bounded buffers. No recompression or
+//! hidden buffering adapters are used; successful rewrites emit identity.
+use super::{Budget, BudgetedBytes, Bypass, Encoding, MAX_BODY};
+use brotli::{Allocator, SliceWrapper, SliceWrapperMut};
+use flate2::{Decompress, FlushDecompress, Status};
+use std::{
+    marker::PhantomData,
+    sync::{
+        Arc,
+        atomic::{AtomicBool, AtomicUsize, Ordering},
+    },
+};
+
+const CODEC: usize = 256 * 1024;
+const CHUNK: usize = 8192;
+
+pub(super) fn decode(
+    input: &[u8],
+    encoding: Encoding,
+    budget: &Budget,
+) -> Result<Option<BudgetedBytes>, Bypass> {
+    if encoding == Encoding::Identity {
+        return Ok(None);
+    }
+    if encoding == Encoding::Unsupported {
+        return Err(Bypass::Encoding);
+    }
+    let _workspace = budget.reserve(CODEC).ok_or(Bypass::Budget)?;
+    let mut output = BudgetedBytes::new(budget, MAX_BODY).ok_or(Bypass::Budget)?;
+    match encoding {
+        Encoding::Gzip => gzip(input, &mut output)?,
+        Encoding::Deflate => {
+            let consumed = inflate(input, true, &mut output)?;
+            if consumed != input.len() {
+                return Err(Bypass::Transform);
+            }
+        }
+        Encoding::Brotli => brotli(input, &mut output)?,
+        _ => return Err(Bypass::Encoding),
+    }
+    Ok(Some(output))
+}
+
+fn inflate(input: &[u8], zlib: bool, output: &mut BudgetedBytes) -> Result<usize, Bypass> {
+    // The locked flate2 rust_backend uses miniz_oxide's fixed InflateState.
+    // CODEC covers it, this stack chunk, and decoder bookkeeping before new().
+    let mut decoder = Decompress::new(zlib);
+    let mut buffer = [0u8; CHUNK];
+    loop {
+        let start_in = decoder.total_in();
+        let start_out = decoder.total_out();
+        let status = decoder
+            .decompress(
+                &input[start_in as usize..],
+                &mut buffer,
+                FlushDecompress::None,
+            )
+            .map_err(|_| Bypass::Transform)?;
+        let produced = (decoder.total_out() - start_out) as usize;
+        output
+            .extend(&buffer[..produced])
+            .map_err(|_| Bypass::Size)?;
+        if status == Status::StreamEnd {
+            return Ok(decoder.total_in() as usize);
+        }
+        if start_in == decoder.total_in() && produced == 0 {
+            return Err(Bypass::Transform);
+        }
+    }
+}
+
+fn gzip(mut input: &[u8], output: &mut BudgetedBytes) -> Result<(), Bypass> {
+    if input.is_empty() {
+        return Err(Bypass::Transform);
+    }
+    while !input.is_empty() {
+        if input.len() < 10 || input[..3] != [0x1f, 0x8b, 8] || input[3] & 0xe0 != 0 {
+            return Err(Bypass::Transform);
+        }
+        let flags = input[3];
+        let mut at = 10usize;
+        if flags & 4 != 0 {
+            let extra = input.get(at..at + 2).ok_or(Bypass::Transform)?;
+            at += 2 + u16::from_le_bytes([extra[0], extra[1]]) as usize;
+            if at > input.len() {
+                return Err(Bypass::Transform);
+            }
+        }
+        for flag in [8, 16] {
+            if flags & flag != 0 {
+                at += input
+                    .get(at..)
+                    .ok_or(Bypass::Transform)?
+                    .iter()
+                    .position(|byte| *byte == 0)
+                    .ok_or(Bypass::Transform)?
+                    + 1;
+            }
+        }
+        if flags & 2 != 0 {
+            let crc = input.get(at..at + 2).ok_or(Bypass::Transform)?;
+            if u16::from_le_bytes([crc[0], crc[1]]) != crc32fast::hash(&input[..at]) as u16 {
+                return Err(Bypass::Transform);
+            }
+            at += 2;
+        }
+        let before = output.as_ref().len();
+        let consumed = inflate(input.get(at..).ok_or(Bypass::Transform)?, false, output)?;
+        at = at.checked_add(consumed).ok_or(Bypass::Transform)?;
+        let trailer = input.get(at..at + 8).ok_or(Bypass::Transform)?;
+        let crc = u32::from_le_bytes(trailer[..4].try_into().expect("four bytes"));
+        let size = u32::from_le_bytes(trailer[4..].try_into().expect("four bytes"));
+        let member = &output.as_ref()[before..];
+        if crc != crc32fast::hash(member) || size != member.len() as u32 {
+            return Err(Bypass::Transform);
+        }
+        input = &input[at + 8..];
+    }
+    Ok(())
+}
+
+struct Pool {
+    used: AtomicUsize,
+    failed: AtomicBool,
+}
+impl Pool {
+    fn reserve(&self, bytes: usize) -> bool {
+        let success = self
+            .used
+            .try_update(Ordering::AcqRel, Ordering::Acquire, |used| {
+                used.checked_add(bytes).filter(|used| *used <= CODEC)
+            })
+            .is_ok();
+        if !success {
+            self.failed.store(true, Ordering::Release);
+        }
+        success
+    }
+}
+struct Alloc<T> {
+    pool: Arc<Pool>,
+    marker: PhantomData<T>,
+}
+impl<T> Alloc<T> {
+    fn new(pool: &Arc<Pool>) -> Self {
+        Self {
+            pool: pool.clone(),
+            marker: PhantomData,
+        }
+    }
+}
+struct Cell<T> {
+    values: Vec<T>,
+    pool: Option<Arc<Pool>>,
+    charged: usize,
+}
+impl<T> Default for Cell<T> {
+    fn default() -> Self {
+        Self {
+            values: Vec::new(),
+            pool: None,
+            charged: 0,
+        }
+    }
+}
+impl<T> SliceWrapper<T> for Cell<T> {
+    fn slice(&self) -> &[T] {
+        &self.values
+    }
+}
+impl<T> SliceWrapperMut<T> for Cell<T> {
+    fn slice_mut(&mut self) -> &mut [T] {
+        &mut self.values
+    }
+}
+impl<T> Drop for Cell<T> {
+    fn drop(&mut self) {
+        if let Some(pool) = &self.pool {
+            pool.used.fetch_sub(self.charged, Ordering::AcqRel);
+        }
+    }
+}
+impl<T: Default> Allocator<T> for Alloc<T> {
+    type AllocatedMemory = Cell<T>;
+    fn alloc_cell(&mut self, len: usize) -> Self::AllocatedMemory {
+        if len == 0 {
+            return Cell::default();
+        }
+        let Some(bytes) = len
+            .checked_mul(std::mem::size_of::<T>())
+            .and_then(|bytes| bytes.checked_add(std::mem::size_of::<Cell<T>>()))
+        else {
+            self.pool.failed.store(true, Ordering::Release);
+            return Cell::default();
+        };
+        if !self.pool.reserve(bytes) {
+            return Cell::default();
+        }
+        let mut result = Cell {
+            values: Vec::new(),
+            pool: Some(self.pool.clone()),
+            charged: bytes,
+        };
+        if result.values.try_reserve_exact(len).is_err() || result.values.capacity() > len {
+            self.pool.failed.store(true, Ordering::Release);
+            return Cell::default();
+        }
+        result.values.resize_with(len, T::default);
+        result
+    }
+    fn free_cell(&mut self, value: Self::AllocatedMemory) {
+        drop(value);
+    }
+}
+
+fn brotli(input: &[u8], output: &mut BudgetedBytes) -> Result<(), Bypass> {
+    type State = brotli::BrotliState<Alloc<u8>, Alloc<u32>, Alloc<brotli::HuffmanCode>>;
+    let pool = Arc::new(Pool {
+        used: AtomicUsize::new(0),
+        failed: AtomicBool::new(false),
+    });
+    if !pool.reserve(std::mem::size_of::<State>() + CHUNK + std::mem::size_of::<Pool>() + 64) {
+        return Err(Bypass::Budget);
+    }
+    let mut state = State::new_strict(Alloc::new(&pool), Alloc::new(&pool), Alloc::new(&pool));
+    // This constructor allocation precedes the upstream decoder's error path.
+    // Our allocator returns either the entire cell or an empty failure cell.
+    if state.context_map_table.slice().is_empty() {
+        return Err(Bypass::Budget);
+    }
+    let mut at = 0;
+    let mut total = 0;
+    let mut buffer = [0u8; CHUNK];
+    loop {
+        let before = at;
+        let mut available_in = input.len() - at;
+        let mut available_out = buffer.len();
+        let mut produced = 0;
+        let result = brotli::BrotliDecompressStream(
+            &mut available_in,
+            &mut at,
+            input,
+            &mut available_out,
+            &mut produced,
+            &mut buffer,
+            &mut total,
+            &mut state,
+        );
+        output
+            .extend(&buffer[..produced])
+            .map_err(|_| Bypass::Size)?;
+        match result {
+            brotli::BrotliResult::ResultSuccess if at == input.len() => return Ok(()),
+            brotli::BrotliResult::NeedsMoreOutput if produced != 0 => {}
+            brotli::BrotliResult::NeedsMoreInput if at < input.len() && at != before => {}
+            _ if pool.failed.load(Ordering::Acquire) => return Err(Bypass::Budget),
+            _ => return Err(Bypass::Transform),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::Write;
+    #[test]
+    fn codecs_decode_and_reject_truncation_or_invalid_trailers() {
+        let budget = Budget::default();
+        let input = b"bounded UTF-8 body";
+        let mut gzip = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+        gzip.write_all(input).unwrap();
+        let mut gzip = gzip.finish().unwrap();
+        assert_eq!(
+            decode(&gzip, Encoding::Gzip, &budget)
+                .unwrap()
+                .unwrap()
+                .as_ref(),
+            input
+        );
+        gzip.pop();
+        assert!(decode(&gzip, Encoding::Gzip, &budget).is_err());
+        let mut deflate =
+            flate2::write::ZlibEncoder::new(Vec::new(), flate2::Compression::default());
+        deflate.write_all(input).unwrap();
+        assert_eq!(
+            decode(&deflate.finish().unwrap(), Encoding::Deflate, &budget)
+                .unwrap()
+                .unwrap()
+                .as_ref(),
+            input
+        );
+        let mut encoded = Vec::new();
+        brotli::BrotliCompress(
+            &mut input.as_slice(),
+            &mut encoded,
+            &brotli::enc::BrotliEncoderParams::default(),
+        )
+        .unwrap();
+        assert_eq!(
+            decode(&encoded, Encoding::Brotli, &budget)
+                .unwrap()
+                .unwrap()
+                .as_ref(),
+            input
+        );
+        assert_eq!(
+            decode(b"\x0b\x05\x80old=1 old=2\x03", Encoding::Brotli, &budget)
+                .unwrap()
+                .unwrap()
+                .as_ref(),
+            b"old=1 old=2"
+        );
+        assert_eq!(budget.used(), 0);
+    }
+    #[test]
+    fn compressed_expansion_and_allocator_failure_are_bounded() {
+        let budget = Budget::default();
+        let mut gzip = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::fast());
+        gzip.write_all(&vec![b'a'; MAX_BODY + 1]).unwrap();
+        assert!(matches!(
+            decode(&gzip.finish().unwrap(), Encoding::Gzip, &budget),
+            Err(Bypass::Size)
+        ));
+        let pool = Arc::new(Pool {
+            used: AtomicUsize::new(CODEC),
+            failed: AtomicBool::new(false),
+        });
+        assert!(Alloc::<u32>::new(&pool).alloc_cell(1).slice().is_empty());
+        assert!(pool.failed.load(Ordering::Acquire));
+        assert_eq!(budget.used(), 0);
+    }
+
+    #[test]
+    fn upstream_brotli_allocation_failure_is_a_decoder_error() {
+        let input = b"allocator failure must preserve the raw compressed response";
+        let mut encoded = Vec::new();
+        brotli::BrotliCompress(
+            &mut input.as_slice(),
+            &mut encoded,
+            &brotli::enc::BrotliEncoderParams::default(),
+        )
+        .unwrap();
+        let pool = Arc::new(Pool {
+            used: AtomicUsize::new(0),
+            failed: AtomicBool::new(false),
+        });
+        let mut state = brotli::BrotliState::new_strict(
+            Alloc::<u8>::new(&pool),
+            Alloc::<u32>::new(&pool),
+            Alloc::<brotli::HuffmanCode>::new(&pool),
+        );
+        assert!(!state.context_map_table.slice().is_empty());
+        pool.used.store(CODEC, Ordering::Release);
+        let mut available_in = encoded.len();
+        let mut input_offset = 0;
+        let mut available_out = 1024;
+        let mut output_offset = 0;
+        let mut total = 0;
+        let result = brotli::BrotliDecompressStream(
+            &mut available_in,
+            &mut input_offset,
+            &encoded,
+            &mut available_out,
+            &mut output_offset,
+            &mut [0; 1024],
+            &mut total,
+            &mut state,
+        );
+        assert!(matches!(result, brotli::BrotliResult::ResultFailure));
+        assert!(pool.failed.load(Ordering::Acquire));
+    }
+}
diff --git a/src/http_processing/body_json.rs b/src/http_processing/body_json.rs
new file mode 100644
index 0000000..227bce9
--- /dev/null
+++ b/src/http_processing/body_json.rs
@@ -0,0 +1,637 @@
+//! A small budgeted JSON tree and RFC 6902 adapter. Numbers retain their source
+//! spelling; parsing never routes business JSON through an f64-backed Value.
+use super::{Budget, BudgetedBytes, Bypass, MAX_BODY};
+use crate::http_processing::rules::PatchOperation;
+use std::io::Write;
+
+const ARENA: usize = 256 * 1024;
+const DEPTH: usize = 64;
+
+enum Node {
+    Null,
+    Bool(bool),
+    Number(Box<str>),
+    String(Box<str>),
+    Array(Vec<Node>),
+    Object(Vec<(Box<str>, Node)>),
+}
+struct Arena {
+    used: usize,
+}
+impl Arena {
+    fn charge(&mut self, bytes: usize) -> Result<(), Bypass> {
+        self.used = self
+            .used
+            .checked_add(bytes)
+            .filter(|value| *value <= ARENA)
+            .ok_or(Bypass::Budget)?;
+        Ok(())
+    }
+    fn room(&self, bytes: usize) -> Result<(), Bypass> {
+        self.used
+            .checked_add(bytes)
+            .filter(|value| *value <= ARENA)
+            .map(|_| ())
+            .ok_or(Bypass::Budget)
+    }
+    fn text(&mut self, text: &str) -> Result<Box<str>, Bypass> {
+        self.charge(text.len())?;
+        Ok(text.into())
+    }
+    fn push<T>(&mut self, values: &mut Vec<T>, value: T) -> Result<(), Bypass> {
+        if values.len() == values.capacity() {
+            let next = values
+                .capacity()
+                .max(2)
+                .checked_mul(2)
+                .ok_or(Bypass::Budget)?;
+            self.charge(
+                next.checked_mul(std::mem::size_of::<T>())
+                    .ok_or(Bypass::Budget)?,
+            )?;
+            values
+                .try_reserve_exact(next - values.len())
+                .map_err(|_| Bypass::Budget)?;
+            if values.capacity() > next {
+                return Err(Bypass::Budget);
+            }
+        }
+        values.push(value);
+        Ok(())
+    }
+}
+
+struct Parser<'a> {
+    text: &'a str,
+    at: usize,
+    arena: &'a mut Arena,
+}
+impl<'a> Parser<'a> {
+    fn parse(text: &'a str, arena: &'a mut Arena) -> Result<Node, Bypass> {
+        // RawValue validates syntax using the borrowed raw path, without first
+        // constructing an unbudgeted serde_json::Value or rounding numbers.
+        serde_json::from_str::<&serde_json::value::RawValue>(text)
+            .map_err(|_| Bypass::Transform)?;
+        let mut parser = Self { text, at: 0, arena };
+        let value = parser.value(0)?;
+        parser.white();
+        if parser.at != text.len() {
+            return Err(Bypass::Transform);
+        }
+        Ok(value)
+    }
+    fn white(&mut self) {
+        while self
+            .text
+            .as_bytes()
+            .get(self.at)
+            .is_some_and(u8::is_ascii_whitespace)
+        {
+            self.at += 1;
+        }
+    }
+    fn token(&mut self, token: &str) -> Result<(), Bypass> {
+        if !self.text[self.at..].starts_with(token) {
+            return Err(Bypass::Transform);
+        }
+        self.at += token.len();
+        Ok(())
+    }
+    fn string(&mut self) -> Result<Box<str>, Bypass> {
+        let start = self.at;
+        self.token("\"")?;
+        loop {
+            match self.text.as_bytes().get(self.at) {
+                Some(b'\\') => self.at += 2,
+                Some(b'"') => {
+                    self.at += 1;
+                    break;
+                }
+                Some(_) => self.at += 1,
+                None => return Err(Bypass::Transform),
+            }
+        }
+        let raw = &self.text[start..self.at];
+        // Covers the parser's escaped-string scratch, returned String, and
+        // conversion to a tightly sized box before allocating any of them.
+        self.arena
+            .room(raw.len().checked_mul(3).ok_or(Bypass::Budget)?)?;
+        let value: String = serde_json::from_str(raw).map_err(|_| Bypass::Transform)?;
+        self.arena.charge(value.len())?;
+        Ok(value.into_boxed_str())
+    }
+    fn value(&mut self, depth: usize) -> Result<Node, Bypass> {
+        if depth > DEPTH {
+            return Err(Bypass::Budget);
+        }
+        self.white();
+        let value = match self.text.as_bytes().get(self.at).copied() {
+            Some(b'n') => {
+                self.token("null")?;
+                Node::Null
+            }
+            Some(b't') => {
+                self.token("true")?;
+                Node::Bool(true)
+            }
+            Some(b'f') => {
+                self.token("false")?;
+                Node::Bool(false)
+            }
+            Some(b'"') => Node::String(self.string()?),
+            Some(b'[') => {
+                self.at += 1;
+                self.white();
+                let mut values = Vec::new();
+                if self.text.as_bytes().get(self.at) != Some(&b']') {
+                    loop {
+                        let value = self.value(depth + 1)?;
+                        self.arena.push(&mut values, value)?;
+                        self.white();
+                        if self.text.as_bytes().get(self.at) != Some(&b',') {
+                            break;
+                        }
+                        self.at += 1;
+                    }
+                }
+                self.token("]")?;
+                Node::Array(values)
+            }
+            Some(b'{') => {
+                self.at += 1;
+                self.white();
+                let mut values: Vec<(Box<str>, Node)> = Vec::new();
+                if self.text.as_bytes().get(self.at) != Some(&b'}') {
+                    loop {
+                        self.white();
+                        let key = self.string()?;
+                        if values.iter().any(|(old, _)| *old == key) {
+                            return Err(Bypass::Transform);
+                        }
+                        self.white();
+                        self.token(":")?;
+                        let value = self.value(depth + 1)?;
+                        self.arena.push(&mut values, (key, value))?;
+                        self.white();
+                        if self.text.as_bytes().get(self.at) != Some(&b',') {
+                            break;
+                        }
+                        self.at += 1;
+                    }
+                }
+                self.token("}")?;
+                Node::Object(values)
+            }
+            Some(b'-' | b'0'..=b'9') => {
+                let start = self.at;
+                while self.text.as_bytes().get(self.at).is_some_and(|byte| {
+                    matches!(byte, b'0'..=b'9' | b'-' | b'+' | b'.' | b'e' | b'E')
+                }) {
+                    self.at += 1;
+                }
+                Node::Number(self.arena.text(&self.text[start..self.at])?)
+            }
+            _ => return Err(Bypass::Transform),
+        };
+        Ok(value)
+    }
+}
+
+fn duplicate(value: &Node, arena: &mut Arena, depth: usize) -> Result<Node, Bypass> {
+    if depth > DEPTH {
+        return Err(Bypass::Budget);
+    }
+    Ok(match value {
+        Node::Null => Node::Null,
+        Node::Bool(value) => Node::Bool(*value),
+        Node::Number(value) => Node::Number(arena.text(value)?),
+        Node::String(value) => Node::String(arena.text(value)?),
+        Node::Array(values) => {
+            let mut result = Vec::new();
+            for value in values {
+                let value = duplicate(value, arena, depth + 1)?;
+                arena.push(&mut result, value)?;
+            }
+            Node::Array(result)
+        }
+        Node::Object(values) => {
+            let mut result = Vec::new();
+            for (key, value) in values {
+                let key = arena.text(key)?;
+                let value = duplicate(value, arena, depth + 1)?;
+                arena.push(&mut result, (key, value))?;
+            }
+            Node::Object(result)
+        }
+    })
+}
+
+fn pointer(path: &str, arena: &mut Arena) -> Result<Vec<Box<str>>, Bypass> {
+    if path.is_empty() {
+        return Ok(Vec::new());
+    }
+    if !path.starts_with('/') {
+        return Err(Bypass::Transform);
+    }
+    let mut result = Vec::new();
+    for piece in path[1..].split('/') {
+        arena.room(piece.len().checked_mul(2).ok_or(Bypass::Budget)?)?;
+        let mut value = String::with_capacity(piece.len());
+        let mut chars = piece.chars();
+        while let Some(character) = chars.next() {
+            value.push(if character == '~' {
+                match chars.next() {
+                    Some('0') => '~',
+                    Some('1') => '/',
+                    _ => return Err(Bypass::Transform),
+                }
+            } else {
+                character
+            });
+        }
+        arena.charge(value.len())?;
+        arena.push(&mut result, value.into_boxed_str())?;
+    }
+    if result.len() > DEPTH {
+        return Err(Bypass::Budget);
+    }
+    Ok(result)
+}
+
+fn index(token: &str, length: usize, append: bool) -> Result<usize, Bypass> {
+    if append && token == "-" {
+        return Ok(length);
+    }
+    if token.is_empty()
+        || (token.len() > 1 && token.starts_with('0'))
+        || !token.bytes().all(|byte| byte.is_ascii_digit())
+    {
+        return Err(Bypass::Transform);
+    }
+    let index: usize = token.parse().map_err(|_| Bypass::Transform)?;
+    if index > length || (!append && index == length) {
+        return Err(Bypass::Transform);
+    }
+    Ok(index)
+}
+fn get<'a>(mut value: &'a Node, path: &[Box<str>]) -> Result<&'a Node, Bypass> {
+    for token in path {
+        value = match value {
+            Node::Object(values) => {
+                &values
+                    .iter()
+                    .find(|(key, _)| key == token)
+                    .ok_or(Bypass::Transform)?
+                    .1
+            }
+            Node::Array(values) => &values[index(token, values.len(), false)?],
+            _ => return Err(Bypass::Transform),
+        };
+    }
+    Ok(value)
+}
+fn get_mut<'a>(mut value: &'a mut Node, path: &[Box<str>]) -> Result<&'a mut Node, Bypass> {
+    for token in path {
+        value = match value {
+            Node::Object(values) => {
+                &mut values
+                    .iter_mut()
+                    .find(|(key, _)| key == token)
+                    .ok_or(Bypass::Transform)?
+                    .1
+            }
+            Node::Array(values) => {
+                let i = index(token, values.len(), false)?;
+                &mut values[i]
+            }
+            _ => return Err(Bypass::Transform),
+        };
+    }
+    Ok(value)
+}
+fn add(root: &mut Node, path: &[Box<str>], value: Node, arena: &mut Arena) -> Result<(), Bypass> {
+    let Some((token, parent)) = path.split_last() else {
+        *root = value;
+        return Ok(());
+    };
+    match get_mut(root, parent)? {
+        Node::Object(values) => {
+            if let Some((_, old)) = values.iter_mut().find(|(key, _)| key == token) {
+                *old = value;
+            } else {
+                let key = arena.text(token)?;
+                arena.push(values, (key, value))?;
+            }
+        }
+        Node::Array(values) => {
+            let at = index(token, values.len(), true)?;
+            // Grow with the same charged allocation policy before insert.
+            arena.push(values, Node::Null)?;
+            values[at..].rotate_right(1);
+            values[at] = value;
+        }
+        _ => return Err(Bypass::Transform),
+    }
+    Ok(())
+}
+fn remove(root: &mut Node, path: &[Box<str>]) -> Result<Node, Bypass> {
+    let Some((token, parent)) = path.split_last() else {
+        return Err(Bypass::Transform);
+    };
+    match get_mut(root, parent)? {
+        Node::Object(values) => {
+            let at = values
+                .iter()
+                .position(|(key, _)| key == token)
+                .ok_or(Bypass::Transform)?;
+            Ok(values.remove(at).1)
+        }
+        Node::Array(values) => {
+            let at = index(token, values.len(), false)?;
+            Ok(values.remove(at))
+        }
+        _ => Err(Bypass::Transform),
+    }
+}
+
+// Add a bounded signed i64 adjustment to an arbitrarily long decimal exponent.
+fn adjust_exponent(raw: &str, adjustment: i64) -> String {
+    let negative = raw.starts_with('-');
+    let digits = raw.trim_start_matches(['-', '+']).trim_start_matches('0');
+    let mut digits = if digits.is_empty() {
+        b"0".to_vec()
+    } else {
+        digits.as_bytes().to_vec()
+    };
+    if let Ok(value) = raw.parse::<i64>()
+        && let Some(value) = value.checked_add(adjustment)
+    {
+        return value.to_string();
+    }
+    // Overflowing exponents have greater magnitude than any adjustment arising
+    // from a <=256 KiB mantissa, so their sign cannot change here.
+    let increase = negative == (adjustment < 0);
+    let mut adjustment = adjustment.unsigned_abs();
+    for digit in digits.iter_mut().rev() {
+        if adjustment == 0 {
+            break;
+        }
+        let units = (adjustment % 10) as u8;
+        adjustment /= 10;
+        if increase {
+            let value = *digit - b'0' + units;
+            *digit = b'0' + value % 10;
+            adjustment += u64::from(value >= 10);
+        } else {
+            let old = *digit - b'0';
+            *digit = b'0'
+                + if old < units {
+                    old + 10 - units
+                } else {
+                    old - units
+                };
+            adjustment += u64::from(old < units);
+        }
+    }
+    if adjustment != 0 {
+        digits.insert(0, b'0' + adjustment as u8);
+    }
+    let text = String::from_utf8(digits).expect("decimal digits");
+    let text = text.trim_start_matches('0');
+    if negative {
+        format!("-{}", if text.is_empty() { "0" } else { text })
+    } else {
+        if text.is_empty() { "0" } else { text }.to_owned()
+    }
+}
+fn number(value: &str) -> (bool, String, String) {
+    let negative = value.starts_with('-');
+    let unsigned = value.trim_start_matches('-');
+    let (mantissa, exponent) = unsigned.split_once(['e', 'E']).unwrap_or((unsigned, "0"));
+    let fraction = mantissa.split_once('.').map_or(0, |(_, tail)| tail.len());
+    let digits: String = mantissa
+        .chars()
+        .filter(|character| *character != '.')
+        .collect();
+    let digits = digits.trim_start_matches('0');
+    if digits.is_empty() {
+        return (false, "0".into(), "0".into());
+    }
+    let trimmed = digits.trim_end_matches('0');
+    let adjustment = (digits.len() - trimmed.len()) as i64 - fraction as i64;
+    (
+        negative,
+        trimmed.to_owned(),
+        adjust_exponent(exponent, adjustment),
+    )
+}
+fn equal(left: &Node, right: &Node, arena: &Arena) -> Result<bool, Bypass> {
+    Ok(match (left, right) {
+        (Node::Null, Node::Null) => true,
+        (Node::Bool(a), Node::Bool(b)) => a == b,
+        (Node::String(a), Node::String(b)) => a == b,
+        (Node::Number(a), Node::Number(b)) => {
+            arena.room((a.len() + b.len()).checked_mul(8).ok_or(Bypass::Budget)?)?;
+            number(a) == number(b)
+        }
+        (Node::Array(a), Node::Array(b)) => {
+            if a.len() != b.len() {
+                return Ok(false);
+            }
+            for (a, b) in a.iter().zip(b) {
+                if !equal(a, b, arena)? {
+                    return Ok(false);
+                }
+            }
+            true
+        }
+        (Node::Object(a), Node::Object(b)) => {
+            if a.len() != b.len() {
+                return Ok(false);
+            }
+            for (key, value) in a {
+                let Some((_, other)) = b.iter().find(|(candidate, _)| candidate == key) else {
+                    return Ok(false);
+                };
+                if !equal(value, other, arena)? {
+                    return Ok(false);
+                }
+            }
+            true
+        }
+        _ => false,
+    })
+}
+
+fn write(value: &Node, writer: &mut BudgetedBytes, depth: usize) -> Result<(), Bypass> {
+    if depth > DEPTH {
+        return Err(Bypass::Budget);
+    }
+    let bytes = |writer: &mut BudgetedBytes, value: &[u8]| {
+        writer.write_all(value).map_err(|_| Bypass::Size)
+    };
+    match value {
+        Node::Null => bytes(writer, b"null")?,
+        Node::Bool(true) => bytes(writer, b"true")?,
+        Node::Bool(false) => bytes(writer, b"false")?,
+        Node::Number(value) => bytes(writer, value.as_bytes())?,
+        Node::String(value) => serde_json::to_writer(writer, value).map_err(|_| Bypass::Size)?,
+        Node::Array(values) => {
+            bytes(writer, b"[")?;
+            for (index, value) in values.iter().enumerate() {
+                if index != 0 {
+                    bytes(writer, b",")?;
+                }
+                write(value, writer, depth + 1)?;
+            }
+            bytes(writer, b"]")?;
+        }
+        Node::Object(values) => {
+            bytes(writer, b"{")?;
+            for (index, (key, value)) in values.iter().enumerate() {
+                if index != 0 {
+                    bytes(writer, b",")?;
+                }
+                serde_json::to_writer(&mut *writer, key).map_err(|_| Bypass::Size)?;
+                bytes(writer, b":")?;
+                write(value, writer, depth + 1)?;
+            }
+            bytes(writer, b"}")?;
+        }
+    }
+    Ok(())
+}
+
+pub(super) fn apply(
+    input: &str,
+    patch: &[PatchOperation],
+    budget: &Budget,
+) -> Result<BudgetedBytes, Bypass> {
+    let _reservation = budget.reserve(ARENA).ok_or(Bypass::Budget)?;
+    let mut arena = Arena {
+        used: std::mem::size_of::<Node>(),
+    };
+    let mut root = Parser::parse(input, &mut arena)?;
+    for operation in patch {
+        let path = match operation {
+            PatchOperation::Add { path, .. }
+            | PatchOperation::Remove { path }
+            | PatchOperation::Replace { path, .. }
+            | PatchOperation::Move { path, .. }
+            | PatchOperation::Copy { path, .. }
+            | PatchOperation::Test { path, .. } => path,
+        };
+        let path = pointer(path, &mut arena)?;
+        match operation {
+            PatchOperation::Add { value, .. }
+            | PatchOperation::Replace { value, .. }
+            | PatchOperation::Test { value, .. } => {
+                let mut literal = BudgetedBytes::new(budget, MAX_BODY).ok_or(Bypass::Budget)?;
+                serde_json::to_writer(&mut literal, value).map_err(|_| Bypass::Size)?;
+                let value = Parser::parse(
+                    std::str::from_utf8(literal.as_ref()).map_err(|_| Bypass::Transform)?,
+                    &mut arena,
+                )?;
+                if matches!(operation, PatchOperation::Test { .. }) {
+                    if !equal(get(&root, &path)?, &value, &arena)? {
+                        return Err(Bypass::Transform);
+                    }
+                } else if matches!(operation, PatchOperation::Replace { .. }) {
+                    *get_mut(&mut root, &path)? = value;
+                } else {
+                    add(&mut root, &path, value, &mut arena)?;
+                }
+            }
+            PatchOperation::Remove { .. } => {
+                remove(&mut root, &path)?;
+            }
+            PatchOperation::Move { from, .. } | PatchOperation::Copy { from, .. } => {
+                let from = pointer(from, &mut arena)?;
+                if matches!(operation, PatchOperation::Move { .. }) {
+                    if path.starts_with(&from) && path.len() > from.len() {
+                        return Err(Bypass::Transform);
+                    }
+                    if from == path {
+                        get(&root, &from)?;
+                        continue;
+                    }
+                    let value = remove(&mut root, &from)?;
+                    add(&mut root, &path, value, &mut arena)?;
+                } else {
+                    let value = duplicate(get(&root, &from)?, &mut arena, 0)?;
+                    add(&mut root, &path, value, &mut arena)?;
+                }
+            }
+        }
+    }
+    if patch
+        .iter()
+        .all(|operation| matches!(operation, PatchOperation::Test { .. }))
+    {
+        return BudgetedBytes::copy(budget, input.as_bytes()).ok_or(Bypass::Budget);
+    }
+    let mut output = BudgetedBytes::new(budget, MAX_BODY).ok_or(Bypass::Budget)?;
+    write(&root, &mut output, 0)?;
+    Ok(output)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn patch(input: &str, operations: serde_json::Value) -> Result<Vec<u8>, Bypass> {
+        let patch: Vec<PatchOperation> = serde_json::from_value(operations).unwrap();
+        let output = apply(input, &patch, &Budget::default())?;
+        Ok(output.as_ref().to_vec())
+    }
+    #[test]
+    fn six_patch_operations_preserve_types_and_pointer_escapes() {
+        let output = patch(
+            r#"{"a/b":[1,2],"~":true,"n":9007199254740993123456789}"#,
+            serde_json::json!([
+                {"op":"test","path":"/~0","value":true},
+                {"op":"add","path":"/a~1b/-","value":null},
+                {"op":"copy","from":"/a~1b/0","path":"/copied"},
+                {"op":"move","from":"/a~1b/1","path":"/moved"},
+                {"op":"replace","path":"/~0","value":false},
+                {"op":"remove","path":"/a~1b/0"}
+            ]),
+        )
+        .unwrap();
+        let output = std::str::from_utf8(&output).unwrap();
+        assert!(output.contains("9007199254740993123456789"));
+        assert!(output.contains(r#""a/b":[null]"#));
+        assert!(output.contains(r#""~":false"#));
+    }
+    #[test]
+    fn numeric_test_uses_exact_decimal_equality_and_rejects_duplicate_keys() {
+        for text in ["1", "1.0", "1e0", "10e-1"] {
+            assert!(patch(text, serde_json::json!([{"op":"test","path":"","value":1}])).is_ok());
+        }
+        assert!(patch(r#"{"a":1,"\u0061":2}"#, serde_json::json!([])).is_err());
+        assert!(patch("[1,2]", serde_json::json!([{"op":"remove","path":"/01"}])).is_err());
+        assert!(patch("{}", serde_json::json!([{"op":"remove","path":""}])).is_err());
+        assert!(
+            patch(
+                r#"{"a":{}}"#,
+                serde_json::json!([{"op":"move","from":"/a","path":"/a/b"}])
+            )
+            .is_err()
+        );
+    }
+    #[test]
+    fn structural_growth_is_rejected_before_unbounded_cloning() {
+        let input = format!("[{}]", "0,".repeat(20_000).trim_end_matches(','));
+        assert!(matches!(
+            patch(&input, serde_json::json!([])),
+            Err(Bypass::Budget)
+        ));
+        assert_eq!(
+            number("10e9999999999999999999999"),
+            number("1e10000000000000000000000")
+        );
+        assert_eq!(
+            number("0.0010e-9999999999999999999999"),
+            number("1e-10000000000000000000002")
+        );
+    }
+}
diff --git a/src/http_processing/config.rs b/src/http_processing/config.rs
new file mode 100644
index 0000000..492c5c0
--- /dev/null
+++ b/src/http_processing/config.rs
@@ -0,0 +1,320 @@
+//! Immutable business HTTP policy, separate from Mihomo configuration.
+#[path = "document.rs"]
+mod document;
+pub(crate) use document::{Document, compile_rule, nonnull};
+
+use super::{
+    private_context::CaMaterial,
+    providers::Payload,
+    rules::{self, Rule, UrlAction},
+};
+#[cfg(any(test, all(windows, feature = "windows-uwp")))]
+use serde::Deserialize;
+use serde::Serialize;
+use sha2::{Digest, Sha256};
+use std::{collections::BTreeMap, fmt, io, sync::Arc};
+use url::Url;
+
+pub(crate) const MAX_ADDENDUM: usize = 1024 * 1024;
+#[cfg(any(test, all(windows, feature = "windows-uwp")))]
+pub(crate) const MAX_SNAPSHOT: usize = MAX_ADDENDUM * 8;
+pub(super) use rules::MAX_URL;
+#[cfg(feature = "inbound-http")]
+pub(super) use rules::checked_url;
+
+pub(super) fn invalid() -> io::Error {
+    io::Error::new(
+        io::ErrorKind::InvalidInput,
+        "invalid HTTP processing configuration",
+    )
+}
+
+pub(super) fn require_http_adapter() -> io::Result<()> {
+    if !cfg!(feature = "inbound-http") {
+        return Err(io::Error::new(
+            io::ErrorKind::Unsupported,
+            "HTTP processing is not compiled in",
+        ));
+    }
+    Ok(())
+}
+
+#[derive(Clone)]
+pub(crate) struct PolicyCandidate {
+    pub(crate) document: Arc<Document>,
+    pub(super) rules: Arc<[Rule]>,
+    pub(super) payloads: BTreeMap<String, Arc<Payload>>,
+    pub(super) identity: [u8; 32],
+    pub(super) origins: Box<[SourceLocation]>,
+    pub(super) source_identity: Option<[u8; 32]>,
+}
+
+#[derive(Clone, Serialize)]
+#[serde(tag = "source", rename_all = "kebab-case")]
+pub(crate) enum SourceLocation {
+    Local { index: usize },
+    Provider { provider: String, index: usize },
+}
+
+impl PolicyCandidate {
+    pub(crate) fn identity(&self) -> [u8; 32] {
+        self.identity
+    }
+
+    pub(crate) fn source_identity(&self) -> Option<[u8; 32]> {
+        self.source_identity
+    }
+
+    pub(crate) fn origin(&self, index: usize) -> Option<&SourceLocation> {
+        self.origins.get(index)
+    }
+
+    pub(crate) fn bind_source(mut self: Arc<Self>, identity: [u8; 32]) -> Arc<Self> {
+        let candidate = Arc::make_mut(&mut self);
+        let mut hash = Sha256::new();
+        hash.update(candidate.identity);
+        hash.update(identity);
+        candidate.identity = hash.finalize().into();
+        candidate.source_identity = Some(identity);
+        self
+    }
+
+    pub(crate) fn bind_ca(
+        self: &Arc<Self>,
+        material: Option<&CaMaterial>,
+    ) -> io::Result<Arc<Policy>> {
+        require_http_adapter()?;
+        #[cfg(feature = "inbound-http")]
+        let mitm = super::mitm::Mitm::compile(self.document.mitm.clone(), material)?;
+        #[cfg(not(feature = "inbound-http"))]
+        let _ = material;
+        let mut hash = Sha256::new();
+        hash.update(self.identity);
+        #[cfg(feature = "inbound-http")]
+        if let Some(mitm) = &mitm {
+            hash.update(mitm.identity());
+        }
+        Ok(Arc::new(Policy {
+            identity: hash.finalize().into(),
+            document: self.document.clone(),
+            candidate: Some(self.clone()),
+            #[cfg(feature = "inbound-http")]
+            mitm,
+        }))
+    }
+
+    /// Complete actual content for an internal, protected cross-process
+    /// snapshot. CA material is deliberately not representable here.
+    #[cfg(any(test, all(windows, feature = "windows-uwp")))]
+    pub(crate) fn export_snapshot(&self) -> io::Result<String> {
+        #[derive(Serialize)]
+        struct Snapshot<'a> {
+            document: &'a Document,
+            payloads: BTreeMap<&'a str, &'a Payload>,
+            source_identity: Option<[u8; 32]>,
+        }
+        let snapshot = Snapshot {
+            document: &self.document,
+            payloads: self
+                .payloads
+                .iter()
+                .map(|(name, payload)| (name.as_str(), payload.as_ref()))
+                .collect(),
+            source_identity: self.source_identity,
+        };
+        let encoded = serde_yaml_ng::to_string(&snapshot).map_err(|_| invalid())?;
+        if encoded.len() > MAX_SNAPSHOT {
+            return Err(invalid());
+        }
+        Ok(encoded)
+    }
+
+    #[cfg(any(test, all(windows, feature = "windows-uwp")))]
+    pub(crate) fn import_snapshot(input: &str) -> io::Result<Arc<Self>> {
+        #[derive(Deserialize)]
+        #[serde(deny_unknown_fields)]
+        struct Snapshot {
+            #[serde(deserialize_with = "nonnull")]
+            document: Document,
+            #[serde(deserialize_with = "nonnull")]
+            payloads: BTreeMap<String, Payload>,
+            source_identity: Option<[u8; 32]>,
+        }
+        if input.len() > MAX_SNAPSHOT {
+            return Err(invalid());
+        }
+        super::numeric_input::validate(input.as_bytes())?;
+        let value =
+            crate::config::yaml::parse_with_budget(input.as_bytes(), &mut (MAX_SNAPSHOT * 4))
+                .map_err(|_| invalid())?;
+        let mut snapshot: Snapshot = serde_yaml_ng::from_value(value).map_err(|_| invalid())?;
+        snapshot.document.input_bytes = serde_yaml_ng::to_string(&snapshot.document)
+            .map_err(|_| invalid())?
+            .len();
+        snapshot.document.finish()?;
+        let names: std::collections::BTreeSet<_> = snapshot
+            .document
+            .active_provider_names()
+            .filter(|name| {
+                !matches!(
+                    snapshot.document.providers[*name],
+                    super::providers::ProviderSpec::Inline { .. }
+                )
+            })
+            .map(str::to_owned)
+            .collect();
+        if snapshot.payloads.keys().any(|name| !names.contains(name)) {
+            return Err(invalid());
+        }
+        for payload in snapshot.payloads.values_mut() {
+            payload.finish()?;
+        }
+        let candidate = Arc::new(snapshot.document).compile(
+            &snapshot
+                .payloads
+                .into_iter()
+                .map(|(name, payload)| (name, Arc::new(payload)))
+                .collect(),
+        )?;
+        Ok(if let Some(identity) = snapshot.source_identity {
+            candidate.bind_source(identity)
+        } else {
+            candidate
+        })
+    }
+}
+
+pub(crate) struct Policy {
+    identity: [u8; 32],
+    document: Arc<Document>,
+    candidate: Option<Arc<PolicyCandidate>>,
+    #[cfg(feature = "inbound-http")]
+    mitm: Option<Arc<super::mitm::Mitm>>,
+}
+
+impl fmt::Debug for Policy {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("HttpPolicy")
+            .field("rules", &self.all_rules().len())
+            .field("prepared", &self.is_prepared())
+            .finish_non_exhaustive()
+    }
+}
+impl PartialEq for Policy {
+    fn eq(&self, other: &Self) -> bool {
+        self.identity == other.identity
+    }
+}
+impl Eq for Policy {}
+
+pub(super) enum Action {
+    Forward(Url),
+    Redirect { status: u16, url: Url },
+    Reject,
+}
+
+impl Policy {
+    pub(crate) fn for_evaluation(candidate: Arc<PolicyCandidate>) -> Arc<Self> {
+        Arc::new(Self::from_static(
+            candidate.document.clone(),
+            Some(candidate),
+        ))
+    }
+
+    pub(crate) fn compile_optional(input: Option<&str>) -> crate::Result<Option<Arc<Self>>> {
+        let input = input.filter(|value| !value.is_empty());
+        #[cfg(not(feature = "inbound-http"))]
+        if input.is_some() {
+            return Err(crate::VoleError::InvalidConfig(
+                "HTTP processing is not compiled in".into(),
+            ));
+        }
+        input.map(Self::compile).transpose().map_err(|_| {
+            crate::VoleError::InvalidConfig("invalid HTTP processing configuration".into())
+        })
+    }
+
+    pub(crate) fn compile(input: &str) -> io::Result<Arc<Self>> {
+        Document::parse(input)?.static_policy()
+    }
+
+    pub(super) fn from_static(
+        document: Arc<Document>,
+        candidate: Option<Arc<PolicyCandidate>>,
+    ) -> Self {
+        let identity = candidate
+            .as_ref()
+            .map_or_else(|| document.identity(), |candidate| candidate.identity());
+        Self {
+            identity,
+            document,
+            candidate,
+            #[cfg(feature = "inbound-http")]
+            mitm: None,
+        }
+    }
+
+    pub(crate) fn document(&self) -> &Arc<Document> {
+        &self.document
+    }
+    pub(crate) fn candidate(&self) -> Option<&Arc<PolicyCandidate>> {
+        self.candidate.as_ref()
+    }
+    pub(crate) fn is_prepared(&self) -> bool {
+        self.candidate.is_some()
+            && (!self.document.mitm.enabled || {
+                #[cfg(feature = "inbound-http")]
+                {
+                    self.mitm.is_some()
+                }
+                #[cfg(not(feature = "inbound-http"))]
+                {
+                    false
+                }
+            })
+    }
+    pub(crate) fn plain_port(&self, port: u16) -> bool {
+        !self.rules().is_empty() && self.document.http_ports.contains(&port)
+    }
+    pub(crate) fn rules(&self) -> &[Rule] {
+        if self.document.rewrite.enabled {
+            self.all_rules()
+        } else {
+            &[]
+        }
+    }
+    pub(crate) fn all_rules(&self) -> &[Rule] {
+        self.candidate
+            .as_ref()
+            .map_or(&[], |candidate| &candidate.rules)
+    }
+    #[cfg(feature = "inbound-http")]
+    pub(crate) fn body_budget(&self) -> &super::body_budget::Budget {
+        static BUDGET: std::sync::LazyLock<super::body_budget::Budget> =
+            std::sync::LazyLock::new(super::body_budget::Budget::default);
+        &BUDGET
+    }
+    #[cfg(feature = "inbound-http")]
+    pub(super) fn mitm(&self) -> Option<&Arc<super::mitm::Mitm>> {
+        self.mitm.as_ref()
+    }
+    pub(super) fn evaluate(&self, url: Url) -> io::Result<Action> {
+        if url.as_str().len() > MAX_URL {
+            return Err(invalid());
+        }
+        for rule in self.rules() {
+            if let Some(action) = rule.evaluate_url(&url)? {
+                return Ok(match action {
+                    UrlAction::Forward(url) => Action::Forward(url),
+                    UrlAction::Redirect { status, url } => Action::Redirect { status, url },
+                    UrlAction::Reject => Action::Reject,
+                });
+            }
+        }
+        Ok(Action::Forward(url))
+    }
+}
+
+#[cfg(test)]
+#[path = "document_tests.rs"]
+mod tests;
diff --git a/src/http_processing/document.rs b/src/http_processing/document.rs
new file mode 100644
index 0000000..ce26f37
--- /dev/null
+++ b/src/http_processing/document.rs
@@ -0,0 +1,248 @@
+//! The independent HTTP document. Parsing is pure and never reads resources.
+use super::{MAX_ADDENDUM, Policy, PolicyCandidate, SourceLocation, invalid};
+use crate::http_processing::{
+    mitm::RawMitm,
+    providers::{Payload, ProviderSpec},
+    rules::{MAX_RULES, RawRule, Rule},
+};
+use serde::{Deserialize, Deserializer, Serialize};
+use sha2::{Digest, Sha256};
+use std::{
+    collections::{BTreeMap, BTreeSet},
+    io,
+    sync::Arc,
+};
+
+pub(crate) fn nonnull<'de, D, T>(deserializer: D) -> Result<T, D::Error>
+where
+    D: Deserializer<'de>,
+    T: Deserialize<'de>,
+{
+    Option::<T>::deserialize(deserializer)?
+        .ok_or_else(|| serde::de::Error::custom("null is not an omitted HTTP setting"))
+}
+
+fn plain_ports() -> Vec<u16> {
+    vec![80, 8080]
+}
+fn enabled() -> bool {
+    true
+}
+
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(deny_unknown_fields, rename_all = "kebab-case")]
+pub(crate) struct Document {
+    #[serde(default = "plain_ports", deserialize_with = "nonnull")]
+    pub(crate) http_ports: Vec<u16>,
+    #[serde(default, rename = "rewrite-providers", deserialize_with = "nonnull")]
+    pub(crate) providers: BTreeMap<String, ProviderSpec>,
+    #[serde(default, deserialize_with = "nonnull")]
+    pub(crate) rewrite: Rewrite,
+    #[serde(default, deserialize_with = "nonnull")]
+    pub(crate) mitm: RawMitm,
+    #[serde(skip)]
+    identity: [u8; 32],
+    #[serde(skip)]
+    pub(crate) input_bytes: usize,
+}
+
+#[derive(Clone, Default, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub(crate) struct Rewrite {
+    #[serde(default)]
+    pub(crate) enabled: bool,
+    #[serde(default, deserialize_with = "nonnull")]
+    pub(crate) rules: Vec<RuleEntry>,
+}
+
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(untagged)]
+pub(crate) enum RuleEntry {
+    Rule(RawRule),
+    Reference(Reference),
+}
+
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(deny_unknown_fields, rename_all = "kebab-case")]
+pub(crate) struct Reference {
+    pub(crate) rule_set: String,
+    #[serde(default = "enabled")]
+    pub(crate) enabled: bool,
+}
+
+impl Document {
+    pub(crate) fn parse(input: &str) -> io::Result<Arc<Self>> {
+        if input.len() > MAX_ADDENDUM {
+            return Err(invalid());
+        }
+        crate::http_processing::numeric_input::validate(input.as_bytes())?;
+        let value =
+            crate::config::yaml::parse_with_budget(input.as_bytes(), &mut (MAX_ADDENDUM * 4))
+                .map_err(|_| invalid())?;
+        if !value.is_mapping() {
+            return Err(invalid());
+        }
+        let mut document: Self = serde_yaml_ng::from_value(value).map_err(|_| invalid())?;
+        document.input_bytes = input.len();
+        document.finish()?;
+        Ok(Arc::new(document))
+    }
+
+    pub(super) fn finish(&mut self) -> io::Result<()> {
+        super::require_http_adapter()?;
+        validate_ports(&self.http_ports)?;
+        validate_ports(&self.mitm.ports)?;
+        self.mitm.validate_static()?;
+        if self.providers.len() > MAX_RULES || self.rewrite.rules.len() > MAX_RULES {
+            return Err(invalid());
+        }
+        for (name, provider) in &self.providers {
+            if name.trim().is_empty() || name.chars().any(char::is_control) {
+                return Err(invalid());
+            }
+            provider.validate()?;
+        }
+        let mut references = BTreeSet::new();
+        let mut text = 0;
+        for entry in &self.rewrite.rules {
+            match entry {
+                RuleEntry::Rule(rule) => {
+                    compile_rule(rule.clone(), &mut text)?;
+                }
+                RuleEntry::Reference(reference) => {
+                    if !self.providers.contains_key(&reference.rule_set)
+                        || !references.insert(&reference.rule_set)
+                    {
+                        return Err(invalid());
+                    }
+                }
+            }
+        }
+        let mut paths = BTreeSet::new();
+        for provider in self.providers.values() {
+            if let ProviderSpec::Http {
+                path: Some(path), ..
+            } = provider
+                && !paths.insert(path)
+            {
+                return Err(invalid());
+            }
+        }
+        self.identity = Sha256::digest(serde_json::to_vec(self).map_err(|_| invalid())?).into();
+        Ok(())
+    }
+
+    pub(crate) fn identity(&self) -> [u8; 32] {
+        self.identity
+    }
+
+    pub(crate) fn active_provider_names(&self) -> impl Iterator<Item = &str> {
+        self.rewrite.rules.iter().filter_map(|entry| match entry {
+            RuleEntry::Reference(reference) if reference.enabled => {
+                Some(reference.rule_set.as_str())
+            }
+            _ => None,
+        })
+    }
+
+    pub(crate) fn unresolved_count(&self) -> usize {
+        self.active_provider_names()
+            .filter(|name| !matches!(self.providers[*name], ProviderSpec::Inline { .. }))
+            .count()
+    }
+
+    pub(crate) fn static_policy(self: &Arc<Self>) -> io::Result<Arc<Policy>> {
+        let candidate = if self.unresolved_count() == 0 {
+            Some(self.compile(&BTreeMap::new())?)
+        } else {
+            None
+        };
+        Ok(Arc::new(Policy::from_static(self.clone(), candidate)))
+    }
+
+    pub(crate) fn compile(
+        self: &Arc<Self>,
+        contents: &BTreeMap<String, Arc<Payload>>,
+    ) -> io::Result<Arc<PolicyCandidate>> {
+        let mut rules = Vec::new();
+        let mut text = 0;
+        let mut payloads = BTreeMap::new();
+        let mut origins = Vec::new();
+        let mut bytes = self.input_bytes;
+        for (index, entry) in self.rewrite.rules.iter().enumerate() {
+            match entry {
+                RuleEntry::Rule(rule) => {
+                    if rules.len() == MAX_RULES {
+                        return Err(invalid());
+                    }
+                    rules.push(compile_rule(rule.clone(), &mut text)?);
+                    origins.push(SourceLocation::Local { index });
+                }
+                RuleEntry::Reference(reference) if reference.enabled => {
+                    let raw_rules = match &self.providers[&reference.rule_set] {
+                        ProviderSpec::Inline { payload } => payload.as_slice(),
+                        _ => {
+                            let payload = contents.get(&reference.rule_set).ok_or_else(|| {
+                                io::Error::new(
+                                    io::ErrorKind::NotFound,
+                                    "HTTP rewrite resource is not prepared",
+                                )
+                            })?;
+                            bytes = bytes
+                                .checked_add(payload.input_bytes())
+                                .ok_or_else(invalid)?;
+                            if bytes > MAX_ADDENDUM {
+                                return Err(invalid());
+                            }
+                            payloads.insert(reference.rule_set.clone(), payload.clone());
+                            payload.rules()
+                        }
+                    };
+                    for (index, rule) in raw_rules.iter().enumerate() {
+                        if rules.len() == MAX_RULES {
+                            return Err(invalid());
+                        }
+                        rules.push(compile_rule(rule.clone(), &mut text)?);
+                        origins.push(SourceLocation::Provider {
+                            provider: reference.rule_set.clone(),
+                            index,
+                        });
+                    }
+                }
+                RuleEntry::Reference(_) => (),
+            }
+            if rules.len() > MAX_RULES {
+                return Err(invalid());
+            }
+        }
+        let mut hash = Sha256::new();
+        hash.update(self.identity);
+        for (name, payload) in &payloads {
+            hash.update((name.len() as u64).to_be_bytes());
+            hash.update(name.as_bytes());
+            hash.update(payload.identity());
+        }
+        Ok(Arc::new(PolicyCandidate {
+            document: self.clone(),
+            rules: rules.into(),
+            payloads,
+            identity: hash.finalize().into(),
+            origins: origins.into(),
+            source_identity: None,
+        }))
+    }
+}
+
+pub(crate) fn compile_rule(raw: RawRule, text: &mut usize) -> io::Result<Rule> {
+    Rule::compile(raw, text)
+}
+
+fn validate_ports(ports: &[u16]) -> io::Result<()> {
+    if ports.len() > 64
+        || ports.contains(&0)
+        || ports.iter().collect::<BTreeSet<_>>().len() != ports.len()
+    {
+        return Err(invalid());
+    }
+    Ok(())
+}
diff --git a/src/http_processing/document_tests.rs b/src/http_processing/document_tests.rs
new file mode 100644
index 0000000..1ffbccc
--- /dev/null
+++ b/src/http_processing/document_tests.rs
@@ -0,0 +1,85 @@
+use super::*;
+#[cfg(feature = "inbound-http")]
+#[test]
+fn http_document_is_static_strict_and_keeps_disabled_sources_unprepared() {
+    let document = Document::parse("rewrite-providers: {missing: {type: file, path: missing.yaml}}\nrewrite: {enabled: true, rules: [{rule-set: missing}]}\n").unwrap();
+    assert_eq!(document.unresolved_count(), 1);
+    assert!(!document.static_policy().unwrap().is_prepared());
+    for bad in [
+        "null",
+        "rewrite: []",
+        "rewrite: {rules: null}",
+        "http-ports: [80,80]",
+        "mitm: {ports: [443,443]}",
+        "mitm: {domains: null}",
+        "rewrite-providers: {x: {type: inline, payload: null}}",
+        "rewrite-providers: {x: {type: file, path: x, interval: 0}}",
+        "rewrite: {rules: [{rule-set: unknown, enabled: false}]}",
+    ] {
+        assert!(Document::parse(bad).is_err(), "accepted {bad}");
+    }
+}
+#[cfg(feature = "inbound-http")]
+#[test]
+fn inline_http_resources_expand_at_reference_position_and_roundtrip_actual_content() {
+    let doc = Document::parse("rewrite-providers:\n  inside:\n    type: inline\n    payload: [{url: '/old/', action: replace, replacement: '/new/'}]\nrewrite:\n  enabled: true\n  rules:\n    - {rule-set: inside}\n    - {url: '.', action: reject}\n").unwrap();
+    let candidate = doc.compile(&BTreeMap::new()).unwrap();
+    let policy = candidate.bind_ca(None).unwrap();
+    let Action::Forward(url) = policy
+        .evaluate(checked_url("https://example.com/old/a").unwrap())
+        .unwrap()
+    else {
+        panic!()
+    };
+    assert_eq!(url.as_str(), "https://example.com/new/a");
+    let restored = PolicyCandidate::import_snapshot(&candidate.export_snapshot().unwrap()).unwrap();
+    assert_eq!(restored.identity(), candidate.identity());
+    assert!(matches!(
+        restored
+            .bind_ca(None)
+            .unwrap()
+            .evaluate(checked_url("https://example.com/other").unwrap())
+            .unwrap(),
+        Action::Reject
+    ));
+}
+
+#[cfg(not(feature = "inbound-http"))]
+#[test]
+fn http_documents_without_adapter_are_rejected_before_resource_preparation() {
+    for input in [
+        "{}",
+        "rewrite: {enabled: true, rules: [{url: '.', action: reject}]}",
+        "rewrite-providers: {missing: {type: file, path: missing.yaml}}\nrewrite: {rules: [{rule-set: missing}]}",
+    ] {
+        let error = Document::parse(input)
+            .err()
+            .expect("HTTP input was accepted");
+        assert_eq!(error.kind(), io::ErrorKind::Unsupported);
+    }
+    // Even an internal DTO that bypasses parsing cannot become a runtime policy.
+    let document: Document = serde_yaml_ng::from_str("{}").unwrap();
+    let candidate = Arc::new(document).compile(&BTreeMap::new()).unwrap();
+    assert_eq!(
+        candidate.bind_ca(None).err().unwrap().kind(),
+        io::ErrorKind::Unsupported
+    );
+    assert!(Policy::compile_optional(None).unwrap().is_none());
+    assert!(Policy::compile_optional(Some("")).unwrap().is_none());
+}
+#[test]
+fn external_http_payload_is_mandatory_and_never_carries_local_authority() {
+    for invalid in [
+        "{}",
+        "payload: null",
+        "payload: []\nmitm: {enabled: true}",
+        "payload: [{rule-set: nested}]",
+    ] {
+        assert!(Payload::parse(invalid.as_bytes()).is_err());
+    }
+    assert!(Payload::parse(b"payload: []").unwrap().rules().is_empty());
+    let doc = Document::parse(
+        "rewrite-providers: {x: {type: file, path: rules.yaml}}\nrewrite: {rules: [{rule-set: x}, {rule-set: x, enabled: false}]}",
+    );
+    assert!(doc.is_err());
+}
diff --git a/src/http_processing/h1.rs b/src/http_processing/h1.rs
new file mode 100644
index 0000000..f656baa
--- /dev/null
+++ b/src/http_processing/h1.rs
@@ -0,0 +1,261 @@
+//! URL actions reuse the existing streaming HTTP/1 framing and body relay.
+use super::{HttpContext, Intercept, Scheme, config::checked_url, io::Replay, request::Decision};
+use crate::{
+    inbound::http::{
+        HttpServerConfig, RequestHead,
+        framing::{self, RequestPlan},
+        server,
+    },
+    security::{StandardTlsClient, TlsClientOptions},
+    session::StreamSession,
+};
+use std::{io, time::Duration};
+use tokio::{
+    io::{AsyncBufRead, AsyncBufReadExt, AsyncRead, AsyncReadExt, AsyncWrite, BufReader},
+    time::{Instant, timeout, timeout_at},
+};
+use tokio_util::sync::CancellationToken;
+use url::Url;
+
+fn invalid() -> io::Error {
+    io::Error::new(
+        io::ErrorKind::InvalidData,
+        "invalid intercepted HTTP request",
+    )
+}
+
+impl HttpContext {
+    /// No read occurs for a noncandidate port. A transparent result returns all
+    /// consumed bytes; the caller keeps the same IO and replays that prefix.
+    pub(crate) async fn try_intercept<S: AsyncRead + AsyncWrite + Unpin + Send>(
+        &self,
+        stream: &mut S,
+        session: StreamSession,
+        cancellation: CancellationToken,
+    ) -> io::Result<Intercept> {
+        if !self.candidate_port(session.destination.port()) {
+            return Ok(Intercept::Transparent { prefix: Vec::new() });
+        }
+        if self
+            .policy()
+            .mitm()
+            .is_some_and(|policy| policy.candidate_port(session.destination.port()))
+        {
+            return self.intercept_tls(stream, session, cancellation).await;
+        }
+        let mut prefix = Vec::new();
+        let deadline = Instant::now() + Duration::from_secs(10);
+        let recognized = tokio::select! {biased;
+            ()=cancellation.cancelled()=>return Err(io::Error::new(io::ErrorKind::Interrupted,"HTTP processing stopped")),
+            result=timeout_at(deadline,async {
+                for _ in 0..32 {
+                    let byte=stream.read_u8().await?;prefix.push(byte);
+                    if byte==b' ' {return Ok(prefix.len()>1);}
+                    if !byte.is_ascii_uppercase() && byte!=b'-' {return Ok(false);}
+                }
+                Ok::<_,io::Error>(false)
+            })=>match result {Ok(Ok(value))=>value,Ok(Err(error)) if error.kind()==io::ErrorKind::UnexpectedEof=>false,Ok(Err(error))=>return Err(error),Err(_)=>false},
+        };
+        if !recognized || prefix == b"CONNECT " {
+            return Ok(Intercept::Transparent { prefix });
+        }
+        // Allocate H1's larger streaming state only on the selected path;
+        // otherwise it also enlarges every TLS/H2 connection future.
+        let mut replay = Replay::new(prefix, stream);
+        Box::pin(self.serve_h1(&mut replay, session, Scheme::Http, cancellation)).await?;
+        Ok(Intercept::Handled)
+    }
+
+    /// Also serves HTTP/1 after selective TLS termination. HTTPS callers must
+    /// authorize each original authority before this request is forwarded.
+    pub(crate) async fn serve_h1<S: AsyncRead + AsyncWrite + Unpin + Send>(
+        &self,
+        stream: &mut S,
+        session: StreamSession,
+        scheme: Scheme,
+        cancellation: CancellationToken,
+    ) -> io::Result<()> {
+        let operation = async {
+            let (read, mut write) = tokio::io::split(stream);
+            let mut reader = BufReader::with_capacity(framing::COPY_BUFFER, read);
+            let config = HttpServerConfig::processing();
+            loop {
+                let request = timeout(config.header_timeout, async {
+                    if reader.fill_buf().await?.is_empty() {
+                        return Ok(None);
+                    }
+                    let bytes = framing::read_head(&mut reader, config.header_limit).await?;
+                    crate::inbound::http::parser::parse_request_head(&bytes, Vec::new()).map(Some)
+                })
+                .await
+                .map_err(|_| io::Error::new(io::ErrorKind::TimedOut, "HTTP request timed out"))??;
+                let Some(request) = request else {
+                    return Ok(());
+                };
+                if request.is_connect() {
+                    return Err(invalid());
+                }
+                if !self
+                    .forward_h1(
+                        &mut reader,
+                        &mut write,
+                        &request,
+                        session.clone(),
+                        scheme,
+                        &config,
+                    )
+                    .await?
+                {
+                    return Ok(());
+                }
+            }
+        };
+        tokio::select! {biased;
+            ()=cancellation.cancelled()=>Ok(()),
+            result=operation=>result,
+        }
+    }
+
+    pub(crate) async fn forward_h1<R: AsyncBufRead + Unpin, W: AsyncWrite + Unpin>(
+        &self,
+        reader: &mut R,
+        writer: &mut W,
+        request: &RequestHead,
+        session: StreamSession,
+        scheme: Scheme,
+        config: &HttpServerConfig,
+    ) -> io::Result<bool> {
+        let original = request_url(request, scheme)?;
+        let asterisk = request.method == "OPTIONS" && request.target == "*";
+        let decision = match self.plan(original, session, scheme, !asterisk) {
+            Ok(decision) => decision,
+            Err(error) if error.kind() != io::ErrorKind::PermissionDenied => {
+                framing::write_timed(
+                    writer,
+                    b"HTTP/1.1 502 Bad Gateway\r\nConnection: close\r\nContent-Length: 0\r\n\r\n",
+                    config.header_timeout,
+                )
+                .await?;
+                return Ok(false);
+            }
+            Err(error) => return Err(error),
+        };
+        let target = match decision {
+            Decision::Reject => {
+                framing::write_timed(
+                    writer,
+                    b"HTTP/1.1 403 Forbidden\r\nConnection: close\r\nContent-Length: 0\r\n\r\n",
+                    config.header_timeout,
+                )
+                .await?;
+                return Ok(false);
+            }
+            Decision::Redirect { status, url } => {
+                let reason = if status == 302 {
+                    "Found"
+                } else {
+                    "Temporary Redirect"
+                };
+                let head = format!(
+                    "HTTP/1.1 {status} {reason}\r\nLocation: {url}\r\nConnection: close\r\nContent-Length: 0\r\n\r\n"
+                );
+                framing::write_timed(writer, head.as_bytes(), config.header_timeout).await?;
+                return Ok(false);
+            }
+            Decision::Forward(target) => *target,
+        };
+        let mut origin = if asterisk {
+            "*".to_owned()
+        } else {
+            target.url.path().to_owned()
+        };
+        if let Some(query) = target.url.query() {
+            origin.push('?');
+            origin.push_str(query);
+        }
+        // Validate framing before any editable fields enter the pipeline.
+        RequestPlan::for_target(
+            request,
+            target.logical_destination.clone(),
+            origin.clone(),
+            false,
+        )?;
+        let message = super::h1_body::Message {
+            policy: self.policy(),
+            original: &target.original,
+            request,
+            meta: super::body::OriginalRequestMeta::new(&request.method, &request.headers),
+            continued: std::sync::atomic::AtomicBool::new(false),
+        };
+        let mut outgoing = request.clone();
+        if target.strip_origin_credentials {
+            super::headers::strip_origin_credentials(&mut outgoing.headers);
+        }
+        super::headers::apply(
+            self.policy().rules(),
+            &target.original,
+            super::rules::Phase::Request,
+            &mut outgoing.headers,
+        );
+        let mut plan =
+            RequestPlan::for_target(&outgoing, target.logical_destination.clone(), origin, false)?;
+        if target.strip_origin_credentials {
+            plan.trailer_blocklist.insert("cookie".into());
+        }
+        let deadline = Instant::now() + config.connect_timeout;
+        let mut outbound = timeout_at(deadline, self.dispatcher.connect_tcp(target.session))
+            .await
+            .map_err(|_| io::Error::new(io::ErrorKind::TimedOut, "HTTP outbound timed out"))?
+            .map_err(|_| io::Error::other("HTTP outbound failed"))?;
+        if target.url.scheme() == "https" {
+            let tls = StandardTlsClient::with_options(
+                self.security(),
+                target
+                    .url
+                    .host_str()
+                    .ok_or_else(invalid)?
+                    .trim_matches(['[', ']']),
+                TlsClientOptions {
+                    alpn: vec![b"http/1.1".to_vec()],
+                    ..Default::default()
+                },
+                0,
+                64 * 1024,
+            )?;
+            outbound = timeout_at(deadline, tls.connect(outbound))
+                .await
+                .map_err(|_| {
+                    io::Error::new(io::ErrorKind::TimedOut, "HTTP upstream TLS timed out")
+                })?
+                .map_err(|_| io::Error::other("HTTP upstream TLS failed"))?;
+        }
+        server::forward_processed(reader, writer, outbound, request, plan, config, &message).await
+    }
+}
+fn request_url(request: &RequestHead, scheme: Scheme) -> io::Result<Url> {
+    let mut hosts = request
+        .headers
+        .iter()
+        .filter(|(name, _)| name.eq_ignore_ascii_case("host"));
+    let host = hosts.next().map(|(_, value)| value);
+    if hosts.next().is_some() || (request.version == "HTTP/1.1" && host.is_none()) {
+        return Err(invalid());
+    }
+    if request.method == "OPTIONS" && request.target == "*" {
+        let host = host.ok_or_else(invalid)?;
+        return checked_url(&format!("{}://{host}/", scheme.name())).map_err(|_| invalid());
+    }
+    if request.target.starts_with('/') {
+        let host = host.ok_or_else(invalid)?;
+        if request.target.starts_with("//") {
+            return Err(invalid());
+        }
+        checked_url(&format!("{}://{host}{}", scheme.name(), request.target)).map_err(|_| invalid())
+    } else {
+        let url = checked_url(&request.target).map_err(|_| invalid())?;
+        if url.scheme() != scheme.name() {
+            return Err(invalid());
+        }
+        Ok(url)
+    }
+}
diff --git a/src/http_processing/h1_body.rs b/src/http_processing/h1_body.rs
new file mode 100644
index 0000000..75a1a27
--- /dev/null
+++ b/src/http_processing/h1_body.rs
@@ -0,0 +1,492 @@
+//! Optional HTTP/1 entity probing. Unselected messages retain the old relay.
+use super::{
+    Policy,
+    body::{self, BudgetedBytes, OriginalRequestMeta, Transaction, WireBodyMeta},
+    headers::Fields,
+    rules::Phase,
+};
+use crate::inbound::http::{
+    HttpServerConfig, RequestHead,
+    framing::{self, Body, RequestPlan, ResponseHead},
+};
+use std::{
+    collections::HashSet,
+    io,
+    sync::atomic::{AtomicBool, Ordering},
+    time::Duration,
+};
+use tokio::io::{AsyncBufRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
+use url::Url;
+
+pub(crate) struct Message<'a> {
+    pub(crate) policy: &'a Policy,
+    pub(crate) original: &'a Url,
+    pub(crate) request: &'a RequestHead,
+    pub(crate) meta: OriginalRequestMeta,
+    pub(crate) continued: AtomicBool,
+}
+
+impl Message<'_> {
+    pub(crate) fn suppress_continue(&self) -> bool {
+        self.continued.load(Ordering::Relaxed)
+    }
+    pub(crate) async fn request<R: AsyncBufRead + Unpin, W: AsyncWrite + Unpin>(
+        &self,
+        reader: &mut R,
+        writer: &mut W,
+        plan: &mut RequestPlan,
+        config: &HttpServerConfig,
+    ) -> io::Result<PreparedBody> {
+        let wire = WireBodyMeta::new(
+            &self.request.headers,
+            &self.meta,
+            Phase::Request,
+            None,
+            length(plan.body),
+            !plan.upgrade.is_empty(),
+        );
+        let transaction = Transaction::begin(
+            self.policy.body_budget(),
+            self.policy.rules(),
+            self.original,
+            Phase::Request,
+            &wire,
+        )
+        .ok();
+        if transaction.is_some()
+            && self
+                .request
+                .headers
+                .iter()
+                .any(|(name, _)| name.eq_ignore_ascii_case("expect"))
+        {
+            framing::write_timed(
+                writer,
+                b"HTTP/1.1 100 Continue\r\n\r\n",
+                config.header_timeout,
+            )
+            .await?;
+            framing::timeout_io(config.header_timeout, writer.flush()).await?;
+            self.continued.store(true, Ordering::Relaxed);
+            plan.edit_headers(|fields| {
+                fields.retain(|(name, _)| !name.eq_ignore_ascii_case("expect"))
+            })?;
+        }
+        let mut prepared = probe(
+            reader,
+            plan.body,
+            &plan.trailer_blocklist,
+            config.body_idle_timeout,
+            transaction,
+        )
+        .await?;
+        if prepared.result.is_some() {
+            plan.edit_headers(|fields| prepared.finalize_headers(fields))?;
+        }
+        Ok(prepared)
+    }
+
+    pub(crate) async fn response<R: AsyncBufRead + Unpin>(
+        &self,
+        reader: &mut R,
+        response: &mut ResponseHead,
+        config: &HttpServerConfig,
+    ) -> io::Result<PreparedBody> {
+        let body = response.body(&self.request.method);
+        let wire = WireBodyMeta::new(
+            response.headers(),
+            &self.meta,
+            Phase::Response,
+            Some(response.status),
+            length(body),
+            response.status == 101,
+        );
+        self.response_headers(response)?;
+        let transaction = Transaction::begin(
+            self.policy.body_budget(),
+            self.policy.rules(),
+            self.original,
+            Phase::Response,
+            &wire,
+        )
+        .ok();
+        let mut prepared = probe(
+            reader,
+            body,
+            response.trailer_blocklist(),
+            config.body_idle_timeout,
+            transaction,
+        )
+        .await?;
+        if prepared.result.is_some() {
+            response.edit_headers(|fields| prepared.finalize_headers(fields))?;
+        }
+        Ok(prepared)
+    }
+
+    /// Informational responses and successful upgrades have no body stage,
+    /// but their ordinary fields still participate in the response pipeline.
+    pub(crate) fn response_headers(&self, response: &mut ResponseHead) -> io::Result<()> {
+        response.edit_headers(|fields| {
+            super::headers::apply(self.policy.rules(), self.original, Phase::Response, fields);
+        })
+    }
+}
+
+fn length(body: Body) -> Option<u64> {
+    match body {
+        Body::Empty => Some(0),
+        Body::Length(length) => Some(length),
+        _ => None,
+    }
+}
+
+pub(crate) struct PreparedBody {
+    framing: Body,
+    cursor: Option<Cursor>,
+    prefix: Option<BudgetedBytes>,
+    result: Option<body::ResultBody>,
+}
+impl PreparedBody {
+    fn finalize_headers(&mut self, fields: &mut Fields) {
+        if let Some(mut result) = self.result.take() {
+            result.finalize_headers(fields);
+            if result.changed {
+                self.framing = Body::Length(result.body.as_ref().len() as u64);
+            }
+            self.prefix = Some(result.body);
+        }
+    }
+    pub(crate) fn original(body: Body) -> Self {
+        Self {
+            framing: body,
+            cursor: None,
+            prefix: None,
+            result: None,
+        }
+    }
+    pub(crate) async fn transfer<R: AsyncBufRead + Unpin, W: AsyncWrite + Unpin>(
+        self,
+        reader: &mut R,
+        writer: &mut W,
+        idle: Duration,
+        blocklist: &HashSet<String>,
+        dechunk: bool,
+    ) -> io::Result<()> {
+        let Some(mut cursor) = self.cursor else {
+            return framing::transfer_body(reader, writer, self.framing, idle, blocklist, dechunk)
+                .await;
+        };
+        let chunked = self.framing == Body::Chunked && !dechunk;
+        if let Some(prefix) = self.prefix {
+            send(writer, prefix.as_ref(), chunked, idle).await?;
+            // Keep the reservation until write_all actually completes.
+            drop(prefix);
+        }
+        let mut bytes = [0u8; framing::COPY_BUFFER];
+        loop {
+            let count = cursor.read(reader, &mut bytes, idle, blocklist).await?;
+            if count == 0 {
+                break;
+            }
+            send(writer, &bytes[..count], chunked, idle).await?;
+        }
+        if chunked {
+            framing::write_timed(writer, b"0\r\n", idle).await?;
+            for (name, value) in cursor.trailers {
+                framing::write_timed(writer, format!("{name}: {value}\r\n").as_bytes(), idle)
+                    .await?;
+            }
+            framing::write_timed(writer, b"\r\n", idle).await?;
+        }
+        framing::timeout_io(idle, writer.flush()).await
+    }
+}
+
+async fn send<W: AsyncWrite + Unpin>(
+    writer: &mut W,
+    bytes: &[u8],
+    chunked: bool,
+    idle: Duration,
+) -> io::Result<()> {
+    if bytes.is_empty() {
+        return Ok(());
+    }
+    if chunked {
+        framing::write_timed(writer, format!("{:x}\r\n", bytes.len()).as_bytes(), idle).await?;
+    }
+    framing::write_timed(writer, bytes, idle).await?;
+    if chunked {
+        framing::write_timed(writer, b"\r\n", idle).await?;
+    }
+    Ok(())
+}
+
+async fn probe<R: AsyncBufRead + Unpin>(
+    reader: &mut R,
+    body: Body,
+    blocklist: &HashSet<String>,
+    idle: Duration,
+    transaction: Option<Transaction<'_>>,
+) -> io::Result<PreparedBody> {
+    let Some(mut transaction) = transaction else {
+        return Ok(PreparedBody::original(body));
+    };
+    let mut cursor = Cursor::new(body);
+    let mut bytes = [0u8; framing::COPY_BUFFER];
+    loop {
+        if cursor.done || matches!(cursor.body, Body::Empty | Body::Length(0)) {
+            let result = transaction.finish(!cursor.trailers.is_empty());
+            return Ok(PreparedBody {
+                framing: body,
+                cursor: Some(cursor),
+                prefix: None,
+                result: Some(result),
+            });
+        }
+        let available = transaction.remaining().min(bytes.len());
+        if available == 0 {
+            return Ok(PreparedBody {
+                framing: body,
+                cursor: Some(cursor),
+                prefix: Some(transaction.into_raw()),
+                result: None,
+            });
+        }
+        let count = cursor
+            .read(reader, &mut bytes[..available], idle, blocklist)
+            .await?;
+        if count == 0 {
+            let result = transaction.finish(!cursor.trailers.is_empty());
+            return Ok(PreparedBody {
+                framing: body,
+                cursor: Some(cursor),
+                prefix: None,
+                result: Some(result),
+            });
+        }
+        if transaction.push(&bytes[..count]).is_err() {
+            return Ok(PreparedBody {
+                framing: body,
+                cursor: Some(cursor),
+                prefix: Some(transaction.into_raw()),
+                result: None,
+            });
+        }
+    }
+}
+
+struct Cursor {
+    body: Body,
+    chunk_remaining: u64,
+    chunk_crlf: bool,
+    done: bool,
+    trailers: Fields,
+}
+impl Cursor {
+    fn new(body: Body) -> Self {
+        Self {
+            body,
+            chunk_remaining: 0,
+            chunk_crlf: false,
+            done: false,
+            trailers: vec![],
+        }
+    }
+    async fn read<R: AsyncBufRead + Unpin>(
+        &mut self,
+        reader: &mut R,
+        output: &mut [u8],
+        idle: Duration,
+        blocklist: &HashSet<String>,
+    ) -> io::Result<usize> {
+        if self.done || matches!(self.body, Body::Empty | Body::Length(0)) {
+            self.done = true;
+            return Ok(0);
+        }
+        if self.body == Body::Chunked && self.chunk_remaining == 0 {
+            if self.chunk_crlf {
+                let mut crlf = [0; 2];
+                framing::timeout_io(idle, reader.read_exact(&mut crlf)).await?;
+                if crlf != *b"\r\n" {
+                    return Err(io::ErrorKind::InvalidData.into());
+                }
+            }
+            let line = framing::timeout_io(idle, framing::read_line(reader, 1024)).await?;
+            self.chunk_remaining = framing::chunk_size(&line)?;
+            self.chunk_crlf = true;
+            if self.chunk_remaining == 0 {
+                let mut bytes = 0;
+                loop {
+                    let line = framing::timeout_io(
+                        idle,
+                        framing::read_line(reader, 8192usize.saturating_sub(bytes)),
+                    )
+                    .await?;
+                    bytes += line.len();
+                    if line == b"\r\n" {
+                        break;
+                    }
+                    if self.trailers.len() >= 100 {
+                        return Err(io::ErrorKind::InvalidData.into());
+                    }
+                    let text = std::str::from_utf8(&line[..line.len() - 2])
+                        .map_err(|_| io::ErrorKind::InvalidData)?;
+                    let mut fields =
+                        crate::inbound::http::parser::parse_headers(std::iter::once(text))?;
+                    if framing::forbidden_trailer(&fields[0].0, blocklist) {
+                        return Err(io::ErrorKind::InvalidData.into());
+                    }
+                    self.trailers.append(&mut fields);
+                }
+                self.done = true;
+                return Ok(0);
+            }
+        }
+        let limit = match self.body {
+            Body::Length(remaining) => remaining.min(output.len() as u64) as usize,
+            Body::Chunked => self.chunk_remaining.min(output.len() as u64) as usize,
+            _ => output.len(),
+        };
+        let count = framing::timeout_io(idle, reader.read(&mut output[..limit])).await?;
+        if count == 0 {
+            if self.body != Body::UntilEof {
+                return Err(io::ErrorKind::UnexpectedEof.into());
+            }
+            self.done = true;
+        }
+        match &mut self.body {
+            Body::Length(remaining) => *remaining -= count as u64,
+            Body::Chunked => self.chunk_remaining -= count as u64,
+            _ => {}
+        }
+        Ok(count)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn rules() -> Vec<super::super::rules::Rule> {
+        let value: serde_yaml_ng::Value =
+            serde_yaml_ng::from_str("{url: '.', action: response-body-set, value: changed}")
+                .unwrap();
+        vec![
+            super::super::rules::Rule::compile(serde_yaml_ng::from_value(value).unwrap(), &mut 0)
+                .unwrap(),
+        ]
+    }
+    #[tokio::test]
+    async fn entity_probe_preserves_overflow_and_late_trailers() {
+        let rules = rules();
+        let url = Url::parse("http://example.com/").unwrap();
+        let meta = OriginalRequestMeta::new("GET", &vec![]);
+        let wire = WireBodyMeta::new(&vec![], &meta, Phase::Response, Some(200), None, false);
+        let budget = body::Budget::default();
+        let payload = vec![b'x'; body::MAX_BODY + 123];
+        let mut input = format!("{:x}\r\n", payload.len()).into_bytes();
+        input.extend_from_slice(&payload);
+        input.extend_from_slice(b"\r\n0\r\n\r\n");
+        let mut reader = input.as_slice();
+        let transaction =
+            Transaction::begin(&budget, &rules, &url, Phase::Response, &wire).unwrap();
+        let prepared = probe(
+            &mut reader,
+            Body::Chunked,
+            &HashSet::new(),
+            Duration::from_secs(1),
+            Some(transaction),
+        )
+        .await
+        .unwrap();
+        let mut output = vec![];
+        prepared
+            .transfer(
+                &mut reader,
+                &mut output,
+                Duration::from_secs(1),
+                &HashSet::new(),
+                true,
+            )
+            .await
+            .unwrap();
+        assert_eq!(output, payload);
+        assert!(reader.is_empty());
+        assert_eq!(budget.used(), 0);
+
+        let mut reader = b"3\r\nold\r\n0\r\nX-End: present\r\n\r\n".as_slice();
+        let transaction =
+            Transaction::begin(&budget, &rules, &url, Phase::Response, &wire).unwrap();
+        let mut prepared = probe(
+            &mut reader,
+            Body::Chunked,
+            &HashSet::new(),
+            Duration::from_secs(1),
+            Some(transaction),
+        )
+        .await
+        .unwrap();
+        prepared.finalize_headers(&mut vec![]);
+        let mut output = vec![];
+        prepared
+            .transfer(
+                &mut reader,
+                &mut output,
+                Duration::from_secs(1),
+                &HashSet::new(),
+                false,
+            )
+            .await
+            .unwrap();
+        assert_eq!(output, b"3\r\nold\r\n0\r\nX-End: present\r\n\r\n");
+    }
+    #[tokio::test]
+    async fn known_length_commits_only_complete_entities() {
+        let rules = rules();
+        let url = Url::parse("http://example.com/").unwrap();
+        let budget = body::Budget::default();
+        let meta = OriginalRequestMeta::new("GET", &vec![]);
+        let wire = WireBodyMeta::new(&vec![], &meta, Phase::Response, Some(200), Some(3), false);
+        let transaction =
+            Transaction::begin(&budget, &rules, &url, Phase::Response, &wire).unwrap();
+        let mut reader = b"old".as_slice();
+        let mut prepared = probe(
+            &mut reader,
+            Body::Length(3),
+            &HashSet::new(),
+            Duration::from_secs(1),
+            Some(transaction),
+        )
+        .await
+        .unwrap();
+        let mut fields = vec![("Content-Length".into(), "3".into())];
+        prepared.finalize_headers(&mut fields);
+        let mut output = vec![];
+        prepared
+            .transfer(
+                &mut reader,
+                &mut output,
+                Duration::from_secs(1),
+                &HashSet::new(),
+                false,
+            )
+            .await
+            .unwrap();
+        assert_eq!(output, b"changed");
+        assert_eq!(fields, vec![("Content-Length".into(), "7".into())]);
+        let wire = WireBodyMeta::new(&vec![], &meta, Phase::Response, Some(200), Some(4), false);
+        let transaction =
+            Transaction::begin(&budget, &rules, &url, Phase::Response, &wire).unwrap();
+        assert!(
+            probe(
+                &mut b"old".as_slice(),
+                Body::Length(4),
+                &HashSet::new(),
+                Duration::from_secs(1),
+                Some(transaction)
+            )
+            .await
+            .is_err()
+        );
+    }
+}
diff --git a/src/http_processing/h1_boundary_tests.rs b/src/http_processing/h1_boundary_tests.rs
new file mode 100644
index 0000000..aa69c8d
--- /dev/null
+++ b/src/http_processing/h1_boundary_tests.rs
@@ -0,0 +1,409 @@
+//! Protocol boundaries exercised through the real HTTP/1 adapter with duplex IO.
+use super::*;
+use crate::{
+    dispatch::{BoxStream, DatagramTransport, DispatchError},
+    session::{DatagramSession, Destination, InboundKind, InboundMetadata, StreamSession},
+};
+use async_trait::async_trait;
+use std::{
+    io,
+    pin::Pin,
+    sync::{Arc, Mutex},
+    task::{Context, Poll, ready},
+    time::Duration,
+};
+use tokio::{
+    io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt, DuplexStream, ReadBuf},
+    time::timeout,
+};
+use tokio_util::sync::CancellationToken;
+
+#[derive(Default)]
+struct Origin {
+    drain: bool,
+    buffered: bool,
+    reply: Reply,
+    received: Arc<Mutex<Vec<u8>>>,
+    tasks: Mutex<Vec<tokio::task::JoinHandle<()>>>,
+}
+#[derive(Clone, Copy, Default)]
+enum Reply {
+    #[default]
+    Standard,
+    Continue,
+    Upgrade,
+}
+#[async_trait]
+impl Dispatcher for Origin {
+    async fn connect_tcp(&self, _: StreamSession) -> Result<BoxStream, DispatchError> {
+        let (client, mut peer) = tokio::io::duplex(4096);
+        let received = self.received.clone();
+        let drain = self.drain;
+        let reply = self.reply;
+        self.tasks.lock().unwrap().push(tokio::spawn(async move {
+            let mut bytes = Vec::new();
+            loop {
+                match peer.read_u8().await {
+                    Ok(byte) => bytes.push(byte),
+                    Err(error) if error.kind() == io::ErrorKind::UnexpectedEof => {
+                        *received.lock().unwrap() = bytes;
+                        return;
+                    }
+                    Err(error) => panic!("origin head: {error}"),
+                }
+                assert!(bytes.len() <= 32768);
+                if bytes.ends_with(b"\r\n\r\n") {
+                    break;
+                }
+            }
+            if drain {
+                peer.read_to_end(&mut bytes).await.unwrap();
+            } else {
+                if matches!(reply, Reply::Upgrade) {
+                    peer.write_all(b"HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nServer: original\r\nX-Stage: original\r\n\r\nserver-first")
+                        .await
+                        .unwrap();
+                    let mut ping = [0; 4];
+                    peer.read_exact(&mut ping).await.unwrap();
+                    assert_eq!(&ping, b"ping");
+                    peer.write_all(b"pong").await.unwrap();
+                    peer.shutdown().await.unwrap();
+                    *received.lock().unwrap() = bytes;
+                    return;
+                }
+                if matches!(reply, Reply::Continue) {
+                    peer.write_all(b"HTTP/1.1 100 Continue\r\nServer: original\r\nX-Stage: original\r\n\r\n")
+                        .await
+                        .unwrap();
+                }
+                let head = std::str::from_utf8(&bytes).unwrap();
+                let length = head.lines().find_map(|line| {
+                    let (name, value) = line.split_once(':')?;
+                    name.eq_ignore_ascii_case("content-length")
+                        .then(|| value.trim().parse::<usize>().unwrap())
+                });
+                if let Some(length) = length {
+                    let at = bytes.len();
+                    bytes.resize(at + length, 0);
+                    peer.read_exact(&mut bytes[at..]).await.unwrap();
+                }
+                if matches!(reply, Reply::Continue) {
+                    peer.write_all(b"HTTP/1.1 103 Early Hints\r\nServer: original\r\nX-Stage: original\r\n\r\n")
+                        .await
+                        .unwrap();
+                }
+                peer.write_all(
+                    b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\nServer: original\r\nX-Stage: original\r\n\r\nok",
+                )
+                .await
+                .unwrap();
+                peer.shutdown().await.unwrap();
+            }
+            *received.lock().unwrap() = bytes;
+        }));
+        if self.buffered {
+            Ok(Box::new(FlushOnly {
+                inner: client,
+                pending: vec![],
+                at: 0,
+            }))
+        } else {
+            Ok(Box::new(client))
+        }
+    }
+    async fn open_datagram(
+        &self,
+        _: DatagramSession,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        Err(DispatchError::NotAllowed)
+    }
+}
+impl Origin {
+    async fn join(&self) {
+        let tasks = std::mem::take(&mut *self.tasks.lock().unwrap());
+        for task in tasks {
+            timeout(Duration::from_secs(1), task)
+                .await
+                .unwrap()
+                .unwrap();
+        }
+    }
+}
+
+// AsyncWrite is allowed to accept bytes before sending them. VMess and several
+// other protocol transports depend on flush to make their last frame visible.
+struct FlushOnly {
+    inner: DuplexStream,
+    pending: Vec<u8>,
+    at: usize,
+}
+impl AsyncRead for FlushOnly {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        output: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.inner).poll_read(cx, output)
+    }
+}
+impl AsyncWrite for FlushOnly {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+        input: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        assert!(self.pending.len() + input.len() <= 32768);
+        self.pending.extend_from_slice(input);
+        Poll::Ready(Ok(input.len()))
+    }
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let this = self.get_mut();
+        while this.at < this.pending.len() {
+            let count = ready!(Pin::new(&mut this.inner).poll_write(cx, &this.pending[this.at..]))?;
+            if count == 0 {
+                return Poll::Ready(Err(io::ErrorKind::WriteZero.into()));
+            }
+            this.at += count;
+        }
+        this.pending.clear();
+        this.at = 0;
+        Pin::new(&mut this.inner).poll_flush(cx)
+    }
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        ready!(self.as_mut().poll_flush(cx))?;
+        Pin::new(&mut self.inner).poll_shutdown(cx)
+    }
+}
+
+fn session() -> StreamSession {
+    StreamSession {
+        metadata: InboundMetadata::new(80),
+        inbound: InboundKind::Tun,
+        source: "198.18.0.2:54321".parse().unwrap(),
+        destination: Destination::Ip("203.0.113.1:80".parse().unwrap()),
+        sniffed_domain: None,
+    }
+}
+fn context(origin: Arc<Origin>, body: bool) -> HttpContext {
+    let input = format!(
+        "rewrite:\n  enabled: true\n  rules:\n  - {{url: '.', action: replace, replacement-mode: url, replacement: 'http://new.invalid/rewritten'}}\n  - {{url: '.', action: request-header-set, header: Authorization, value: 'Bearer explicit'}}\n  - {{url: '.', action: request-header-set, header: Cookie, value: 'new=explicit'}}\n  - {{url: '^http://old\\.invalid/', action: response-header-set, header: X-Stage, value: changed}}\n  - {{url: '^http://old\\.invalid/', action: response-header-remove, header: Server}}\n{}",
+        if body {
+            "  - {url: '.', action: request-body-set, value: changed}\n"
+        } else {
+            ""
+        }
+    );
+    HttpContext::new(
+        Policy::compile(&input).unwrap(),
+        origin,
+        SecurityContext::new(),
+    )
+}
+async fn exchange(context: HttpContext, input: &[u8]) -> (io::Result<Intercept>, Vec<u8>) {
+    let (mut client, mut peer) = tokio::io::duplex(4096);
+    let task = tokio::spawn(async move {
+        context
+            .try_intercept(&mut peer, session(), CancellationToken::new())
+            .await
+    });
+    client.write_all(input).await.unwrap();
+    let mut output = Vec::new();
+    timeout(Duration::from_secs(1), client.read_to_end(&mut output))
+        .await
+        .unwrap()
+        .unwrap();
+    (task.await.unwrap(), output)
+}
+
+async fn head(client: &mut DuplexStream) -> String {
+    timeout(Duration::from_secs(1), async {
+        let mut bytes = Vec::new();
+        while !bytes.ends_with(b"\r\n\r\n") {
+            assert!(bytes.len() < 32768);
+            bytes.push(client.read_u8().await.unwrap());
+        }
+        String::from_utf8(bytes).unwrap()
+    })
+    .await
+    .unwrap()
+}
+fn rewritten(head: &str, status: u16) {
+    assert!(head.starts_with(&format!("HTTP/1.1 {status} ")));
+    let lowercase = head.to_ascii_lowercase();
+    assert!(lowercase.contains("x-stage: changed\r\n"));
+    assert!(!lowercase.contains("server:"));
+}
+
+#[tokio::test]
+async fn cross_origin_explicit_credentials_survive_and_empty_requests_are_flushed() {
+    let origin = Arc::new(Origin {
+        buffered: true,
+        ..Default::default()
+    });
+    let (result, output) = exchange(
+        context(origin.clone(), false),
+        b"GET / HTTP/1.1\r\nHost: old.invalid\r\nAuthorization: Bearer original\r\nCookie: old=original\r\nConnection: close\r\n\r\n",
+    )
+    .await;
+    assert!(matches!(result.unwrap(), Intercept::Handled));
+    assert!(output.ends_with(b"\r\n\r\nok"));
+    origin.join().await;
+    let received = origin.received.lock().unwrap();
+    let text = std::str::from_utf8(&received).unwrap();
+    assert!(text.starts_with("GET /rewritten HTTP/1.1\r\n"));
+    let lowercase = text.to_ascii_lowercase();
+    assert!(lowercase.contains("authorization: bearer explicit\r\n"));
+    assert!(lowercase.contains("cookie: new=explicit\r\n"));
+    assert!(!text.contains("original"));
+}
+
+#[tokio::test]
+async fn cross_origin_cookie_trailers_cannot_restore_original_credentials() {
+    let origin = Arc::new(Origin {
+        drain: true,
+        ..Default::default()
+    });
+    let (result, output) = exchange(
+        context(origin.clone(), false),
+        b"POST / HTTP/1.1\r\nHost: old.invalid\r\nCookie: old=original\r\nTransfer-Encoding: chunked\r\nTrailer: Cookie\r\nConnection: close\r\n\r\n3\r\nold\r\n0\r\nCookie: trailer=original-secret\r\n\r\n",
+    )
+    .await;
+    assert_eq!(result.err().unwrap().kind(), io::ErrorKind::InvalidData);
+    assert!(output.starts_with(b"HTTP/1.1 400"));
+    origin.join().await;
+    let received = origin.received.lock().unwrap();
+    let text = std::str::from_utf8(&received).unwrap();
+    assert!(
+        text.to_ascii_lowercase()
+            .contains("cookie: new=explicit\r\n")
+    );
+    assert!(!text.contains("original-secret"));
+    assert!(!text.contains("old=original"));
+}
+
+#[tokio::test]
+async fn request_body_commit_rebuilds_a_valid_fixed_length_head() {
+    let origin = Arc::new(Origin {
+        buffered: true,
+        ..Default::default()
+    });
+    let (result, output) = exchange(
+        context(origin.clone(), true),
+        b"POST / HTTP/1.1\r\nHost: old.invalid\r\nContent-Length: 3\r\nConnection: close\r\n\r\nold",
+    )
+    .await;
+    assert!(matches!(result.unwrap(), Intercept::Handled));
+    assert!(output.ends_with(b"\r\n\r\nok"));
+    origin.join().await;
+    let received = origin.received.lock().unwrap();
+    let text = std::str::from_utf8(&received).unwrap();
+    assert!(text.contains("Content-Length: 7\r\n"));
+    assert!(text.ends_with("\r\n\r\nchanged"));
+}
+
+#[tokio::test]
+async fn local_continue_preserves_original_connection_trailer_blocklist() {
+    let origin = Arc::new(Origin::default());
+    let context = context(origin.clone(), true);
+    let (mut client, peer) = tokio::io::duplex(4096);
+    let mut peer = FlushOnly {
+        inner: peer,
+        pending: vec![],
+        at: 0,
+    };
+    let task = tokio::spawn(async move {
+        context
+            .try_intercept(&mut peer, session(), CancellationToken::new())
+            .await
+    });
+    client.write_all(b"POST / HTTP/1.1\r\nHost: old.invalid\r\nTransfer-Encoding: chunked\r\nExpect: 100-continue\r\nConnection: X-Private, close\r\nX-Private: original\r\n\r\n").await.unwrap();
+    let mut interim = [0u8; 25];
+    timeout(Duration::from_secs(1), client.read_exact(&mut interim))
+        .await
+        .unwrap()
+        .unwrap();
+    assert_eq!(&interim, b"HTTP/1.1 100 Continue\r\n\r\n");
+    client
+        .write_all(b"3\r\nold\r\n0\r\nX-Private: trailer-secret\r\n\r\n")
+        .await
+        .unwrap();
+    let error = timeout(Duration::from_secs(1), task)
+        .await
+        .unwrap()
+        .unwrap()
+        .err()
+        .unwrap();
+    assert_eq!(error.kind(), io::ErrorKind::InvalidData);
+    origin.join().await;
+    assert!(origin.received.lock().unwrap().is_empty());
+}
+
+#[tokio::test]
+async fn informational_headers_are_rewritten_and_continue_is_flushed_before_upload() {
+    let origin = Arc::new(Origin {
+        buffered: true,
+        reply: Reply::Continue,
+        ..Default::default()
+    });
+    let context = context(origin.clone(), false);
+    let (mut client, peer) = tokio::io::duplex(4096);
+    let mut peer = FlushOnly {
+        inner: peer,
+        pending: vec![],
+        at: 0,
+    };
+    let task = tokio::spawn(async move {
+        context
+            .try_intercept(&mut peer, session(), CancellationToken::new())
+            .await
+    });
+    client.write_all(b"POST / HTTP/1.1\r\nHost: old.invalid\r\nContent-Length: 3\r\nExpect: 100-continue\r\nConnection: close\r\n\r\n").await.unwrap();
+    rewritten(&head(&mut client).await, 100);
+    client.write_all(b"old").await.unwrap();
+    rewritten(&head(&mut client).await, 103);
+    rewritten(&head(&mut client).await, 200);
+    let mut body = Vec::new();
+    timeout(Duration::from_secs(1), client.read_to_end(&mut body))
+        .await
+        .unwrap()
+        .unwrap();
+    assert_eq!(body, b"ok");
+    assert!(matches!(task.await.unwrap().unwrap(), Intercept::Handled));
+    origin.join().await;
+    assert!(origin.received.lock().unwrap().ends_with(b"\r\n\r\nold"));
+}
+
+#[tokio::test]
+async fn upgrade_headers_are_rewritten_and_flushed_before_tunnel_half_close() {
+    let origin = Arc::new(Origin {
+        buffered: true,
+        reply: Reply::Upgrade,
+        ..Default::default()
+    });
+    let context = context(origin.clone(), false);
+    let (mut client, peer) = tokio::io::duplex(4096);
+    let mut peer = FlushOnly {
+        inner: peer,
+        pending: vec![],
+        at: 0,
+    };
+    let task = tokio::spawn(async move {
+        context
+            .try_intercept(&mut peer, session(), CancellationToken::new())
+            .await
+    });
+    client.write_all(b"GET / HTTP/1.1\r\nHost: old.invalid\r\nConnection: Upgrade\r\nUpgrade: websocket\r\n\r\n").await.unwrap();
+    let response = head(&mut client).await;
+    rewritten(&response, 101);
+    assert!(response.contains("Connection: Upgrade\r\nUpgrade: websocket\r\n"));
+    client.write_all(b"ping").await.unwrap();
+    client.shutdown().await.unwrap();
+    let mut body = Vec::new();
+    timeout(Duration::from_secs(1), client.read_to_end(&mut body))
+        .await
+        .unwrap()
+        .unwrap();
+    assert_eq!(body, b"server-firstpong");
+    assert!(matches!(task.await.unwrap().unwrap(), Intercept::Handled));
+    origin.join().await;
+}
diff --git a/src/http_processing/h2.rs b/src/http_processing/h2.rs
new file mode 100644
index 0000000..430364f
--- /dev/null
+++ b/src/http_processing/h2.rs
@@ -0,0 +1,685 @@
+//! HTTP/2 downstream owner. Every request and upstream driver is polled inline.
+use super::{
+    HttpContext, Scheme,
+    body::{OriginalRequestMeta, Transaction, WireBodyMeta},
+    config::checked_url,
+    h2_body::{self, IDLE},
+    h2_h1, h2_headers, headers,
+    request::{Decision, Target},
+    rules::Phase,
+};
+use crate::{
+    dispatch::BoxStream,
+    security::{StandardTlsClient, TlsClientOptions},
+    session::StreamSession,
+};
+use bytes::Bytes;
+use futures_util::{StreamExt, future::poll_fn, stream::FuturesUnordered};
+use http::{HeaderValue, Method, Request, Response, StatusCode, Version};
+use std::{
+    future::Future,
+    io,
+    pin::Pin,
+    sync::{Arc, Mutex},
+    task::Poll,
+    time::Duration,
+};
+use tokio::{
+    io::{AsyncRead, AsyncWrite},
+    time::{Instant, timeout, timeout_at},
+};
+use tokio_util::sync::CancellationToken;
+const STREAMS: usize = 8;
+const SETUP: Duration = Duration::from_secs(10);
+struct MessageMeta {
+    original: OriginalRequestMeta,
+    length: Option<u64>,
+    asterisk: bool,
+}
+struct BodyMessage {
+    phase: Phase,
+    wire: Option<WireBodyMeta>,
+    expected: Option<u64>,
+    strip_credentials: bool,
+}
+fn failed() -> io::Error {
+    io::Error::new(io::ErrorKind::ConnectionAborted, "HTTP proxy stream failed")
+}
+
+impl HttpContext {
+    pub(in crate::http_processing) async fn serve_h2<S: AsyncRead + AsyncWrite + Unpin + Send>(
+        &self,
+        stream: &mut S,
+        session: StreamSession,
+        cancellation: CancellationToken,
+    ) -> io::Result<()> {
+        let operation = async {
+            let mut builder = h2::server::Builder::new();
+            builder
+                .initial_window_size(32 * 1024)
+                .initial_connection_window_size(64 * 1024)
+                .header_table_size(0)
+                .max_header_list_size(32 * 1024)
+                .max_frame_size(16 * 1024)
+                .max_send_buffer_size(16 * 1024)
+                .max_concurrent_streams(STREAMS as u32)
+                .max_concurrent_reset_streams(16)
+                .max_local_error_reset_streams(Some(16));
+            let mut connection = timeout(SETUP, builder.handshake::<_, Bytes>(stream))
+                .await
+                .map_err(|_| io::ErrorKind::TimedOut)?
+                .map_err(|_| failed())?;
+            let mut requests = FuturesUnordered::new();
+            let idle = tokio::time::sleep(IDLE);
+            tokio::pin!(idle);
+            loop {
+                // accept also drives DATA, SETTINGS, WINDOW_UPDATE and resets.
+                // It stays polled while all eight request slots are occupied.
+                tokio::select! {biased;
+                    ()=&mut idle,if requests.is_empty()=>return Ok(()),
+                    result=requests.next(),if !requests.is_empty()=>{
+                        let _=result;idle.as_mut().reset(Instant::now()+IDLE);
+                    },
+                    accepted=connection.accept()=>match accepted {
+                        Some(Ok((request,mut response)))=>{
+                            idle.as_mut().reset(Instant::now()+IDLE);
+                            if requests.len()>=STREAMS {response.send_reset(h2::Reason::REFUSED_STREAM);} else {
+                                // The ready queue also owns an empty sentinel
+                                // with the same future type. Keep its storage
+                                // small on every downstream connection.
+                                requests.push(Box::pin(self.h2_request(request,response,session.clone())));
+                            }
+                        },
+                        Some(Err(_))=>return Err(failed()),
+                        None=>return Ok(()),
+                    }
+                }
+            }
+        };
+        tokio::select! {biased;()=cancellation.cancelled()=>Ok(()),result=operation=>result}
+    }
+
+    async fn h2_request(
+        &self,
+        request: Request<h2::RecvStream>,
+        response: h2::server::SendResponse<Bytes>,
+        session: StreamSession,
+    ) {
+        let response = ResponseSlot(Arc::new(Mutex::new(ResponseState {
+            response,
+            infos: 0,
+            final_started: false,
+        })));
+        if self.h2_forward(request, &response, session).await.is_err() {
+            response.reset();
+        }
+    }
+    async fn h2_forward(
+        &self,
+        request: Request<h2::RecvStream>,
+        response: &ResponseSlot,
+        session: StreamSession,
+    ) -> io::Result<()> {
+        if request.method() == Method::CONNECT {
+            return local(response, StatusCode::METHOD_NOT_ALLOWED, None);
+        }
+        let length = match h2_headers::request(request.headers()) {
+            Ok(length) => length,
+            Err(_) => return local(response, StatusCode::BAD_REQUEST, None),
+        };
+        let original_fields = headers::from_map(request.headers());
+        let mut original_meta = OriginalRequestMeta::new(
+            request.method().as_str(),
+            original_fields.as_ref().unwrap_or(&Vec::new()),
+        );
+        if original_fields.is_none() {
+            original_meta.identity_allowed = false;
+        }
+        let wire = original_fields.as_ref().map(|fields| {
+            WireBodyMeta::new(fields, &original_meta, Phase::Request, None, length, false)
+        });
+        let (original, asterisk) = match original_url(&request) {
+            Ok(value) => value,
+            Err(_) => return local(response, StatusCode::BAD_REQUEST, None),
+        };
+        let target = match self.plan(original, session, Scheme::Https, !asterisk) {
+            Ok(Decision::Reject) => return local(response, StatusCode::FORBIDDEN, None),
+            Ok(Decision::Redirect { status, url }) => {
+                return local(
+                    response,
+                    StatusCode::from_u16(status).map_err(|_| failed())?,
+                    Some(url.as_str()),
+                );
+            }
+            Ok(Decision::Forward(target)) => *target,
+            Err(error) => {
+                return local(
+                    response,
+                    if error.kind() == io::ErrorKind::PermissionDenied {
+                        StatusCode::FORBIDDEN
+                    } else {
+                        StatusCode::BAD_GATEWAY
+                    },
+                    None,
+                );
+            }
+        };
+        if request.headers().contains_key("expect") && !request.body().is_end_stream() {
+            response.continue_upload()?;
+        }
+        let (mut parts, body) = request.into_parts();
+        parts.headers = h2_headers::clean(parts.headers, target.strip_origin_credentials, true)?;
+        headers::apply_map(
+            self.policy().rules(),
+            &target.original,
+            Phase::Request,
+            &mut parts.headers,
+        );
+        let (body, length) = self
+            .prepare_body(
+                h2_body::Source::h2(body),
+                &target.original,
+                &mut parts.headers,
+                BodyMessage {
+                    phase: Phase::Request,
+                    wire,
+                    expected: length,
+                    strip_credentials: target.strip_origin_credentials,
+                },
+            )
+            .await?;
+        let request = Request::from_parts(parts, body);
+        let metadata = MessageMeta {
+            original: original_meta,
+            length,
+            asterisk,
+        };
+        let (io, protocol) = self.http_upstream(&target).await?;
+        if protocol.as_deref() == Some(b"h2") {
+            self.h2_upstream(io, request, response, target, metadata)
+                .await
+        } else {
+            self.h1_upstream(io, request, response, target, metadata)
+                .await
+        }
+    }
+    async fn prepare_body(
+        &self,
+        source: h2_body::Source,
+        original: &url::Url,
+        headers: &mut http::HeaderMap,
+        message: BodyMessage,
+    ) -> io::Result<(h2_body::Source, Option<u64>)> {
+        let Some(wire) = message.wire else {
+            return Ok((source, message.expected));
+        };
+        let Ok(transaction) = Transaction::begin(
+            self.policy().body_budget(),
+            self.policy().rules(),
+            original,
+            message.phase,
+            &wire,
+        ) else {
+            return Ok((source, message.expected));
+        };
+        let prepared = h2_body::prepare(
+            source,
+            transaction,
+            message.expected,
+            message.strip_credentials,
+            headers,
+        )
+        .await?;
+        Ok((prepared.source, prepared.expected))
+    }
+    async fn http_upstream(&self, target: &Target) -> io::Result<(BoxStream, Option<Vec<u8>>)> {
+        let deadline = Instant::now() + SETUP;
+        let stream = timeout_at(
+            deadline,
+            self.dispatcher().connect_tcp(target.session.clone()),
+        )
+        .await
+        .map_err(|_| io::ErrorKind::TimedOut)?
+        .map_err(|_| failed())?;
+        if target.url.scheme() == "http" {
+            return Ok((stream, None));
+        }
+        let tls = StandardTlsClient::with_options(
+            self.security(),
+            target
+                .url
+                .host_str()
+                .ok_or_else(failed)?
+                .trim_matches(['[', ']']),
+            TlsClientOptions {
+                alpn: vec![b"h2".to_vec(), b"http/1.1".to_vec()],
+                ..Default::default()
+            },
+            0,
+            32 * 1024,
+        )?;
+        timeout_at(deadline, tls.connect_negotiated(stream))
+            .await
+            .map_err(|_| io::Error::from(io::ErrorKind::TimedOut))?
+            .map_err(|_| failed())
+    }
+    async fn h2_upstream(
+        &self,
+        io: BoxStream,
+        request: Request<h2_body::Source>,
+        response: &ResponseSlot,
+        target: Target,
+        metadata: MessageMeta,
+    ) -> io::Result<()> {
+        let MessageMeta {
+            original: original_meta,
+            length,
+            asterisk,
+        } = metadata;
+        let mut builder = h2::client::Builder::new();
+        builder
+            .initial_window_size(32 * 1024)
+            .initial_connection_window_size(64 * 1024)
+            .header_table_size(0)
+            .max_header_list_size(32 * 1024)
+            .max_frame_size(16 * 1024)
+            .max_send_buffer_size(16 * 1024)
+            .enable_push(false)
+            .max_concurrent_streams(1);
+        let (sender, driver) = timeout(SETUP, builder.handshake::<_, Bytes>(io))
+            .await
+            .map_err(|_| io::ErrorKind::TimedOut)?
+            .map_err(|_| failed())?;
+        let exchange = Box::pin(async {
+            let (parts, body) = request.into_parts();
+            let method = parts.method.clone();
+            // Original credentials were removed before request-header actions.
+            // A second origin cleanup must not erase explicitly supplied ones.
+            let mut headers = h2_headers::clean(parts.headers, false, true)?;
+            headers.remove("expect");
+            let uri = if asterisk {
+                http::Uri::builder()
+                    .scheme("https")
+                    .authority(target.logical_destination.authority())
+                    .path_and_query("*")
+                    .build()
+                    .map_err(|_| failed())?
+            } else {
+                target.url.as_str().parse().map_err(|_| failed())?
+            };
+            let mut outgoing = Request::builder()
+                .method(parts.method)
+                .uri(uri)
+                .version(Version::HTTP_2)
+                .body(())
+                .map_err(|_| failed())?;
+            *outgoing.headers_mut() = headers;
+            let mut sender = sender.ready().await.map_err(|_| failed())?;
+            let (mut incoming, upload) =
+                sender.send_request(outgoing, false).map_err(|_| failed())?;
+            let (upload_finished, uploaded) = tokio::sync::oneshot::channel();
+            let upload = async move {
+                let result =
+                    h2_body::relay(body, upload, length, target.strip_origin_credentials).await;
+                if result.is_ok() {
+                    let _ = upload_finished.send(());
+                }
+                result
+            };
+            let download = async {
+                let incoming = response_after_upload(uploaded, async {
+                    let mut infos = 0;
+                    loop {
+                        let event = poll_fn(|cx| {
+                            if let Poll::Ready(Some(info)) = incoming.poll_informational(cx) {
+                                return Poll::Ready(info.map(Head::Informational));
+                            }
+                            Pin::new(&mut incoming)
+                                .poll(cx)
+                                .map(|value| value.map(Head::Final))
+                        })
+                        .await
+                        .map_err(|_| failed())?;
+                        match event {
+                            Head::Informational(info) => {
+                                infos += 1;
+                                if infos > 16 {
+                                    return Err(failed());
+                                }
+                                if info.status() != StatusCode::CONTINUE {
+                                    let (mut parts, ()) = info.into_parts();
+                                    parts.headers = h2_headers::clean(parts.headers, false, false)?;
+                                    response
+                                        .informational(Response::from_parts(parts, ()))
+                                        .map_err(|_| failed())?;
+                                }
+                            }
+                            Head::Final(response) => break Ok(response),
+                        }
+                    }
+                })
+                .await?;
+                let (mut parts, body) = incoming.into_parts();
+                let expected = h2_headers::response_body(&parts.headers, parts.status, &method)?;
+                let wire = headers::from_map(&parts.headers).map(|fields| {
+                    WireBodyMeta::new(
+                        &fields,
+                        &original_meta,
+                        Phase::Response,
+                        Some(parts.status.as_u16()),
+                        expected,
+                        false,
+                    )
+                });
+                headers::apply_map(
+                    self.policy().rules(),
+                    &target.original,
+                    Phase::Response,
+                    &mut parts.headers,
+                );
+                parts.headers = h2_headers::clean(parts.headers, false, false)?;
+                let (body, expected) = self
+                    .prepare_body(
+                        h2_body::Source::h2(body),
+                        &target.original,
+                        &mut parts.headers,
+                        BodyMessage {
+                            phase: Phase::Response,
+                            wire,
+                            expected,
+                            strip_credentials: false,
+                        },
+                    )
+                    .await?;
+                let downstream = response
+                    .final_response(Response::from_parts(parts, ()), false)
+                    .map_err(|_| failed())?;
+                h2_body::relay(body, downstream, expected, false).await
+            };
+            // A complete final response ends this exchange even when the
+            // client has not finished uploading. Dropping the inline upload
+            // returns its receive owner; h2 closes that half with NO_ERROR
+            // after the final response, without blocking sibling streams.
+            tokio::pin!(upload);
+            tokio::pin!(download);
+            tokio::select! {biased;
+                result=&mut download=>result,
+                result=&mut upload=>{
+                    // An early final response may reset the upstream's input
+                    // before its nonempty response has crossed the downstream
+                    // window. Once headers were committed, finish that bounded
+                    // response rather than replacing it with a reset.
+                    if result.is_err() && !response.final_started() { result?; }
+                    download.await
+                }
+            }
+        });
+        inline_driver(driver, exchange).await
+    }
+    async fn h1_upstream(
+        &self,
+        io: BoxStream,
+        request: Request<h2_body::Source>,
+        response: &ResponseSlot,
+        target: Target,
+        metadata: MessageMeta,
+    ) -> io::Result<()> {
+        let MessageMeta {
+            original: original_meta,
+            length,
+            asterisk,
+        } = metadata;
+        let (mut sender, driver) = timeout(
+            SETUP,
+            hyper::client::conn::http1::Builder::new()
+                .max_headers(100)
+                .max_buf_size(32 * 1024)
+                .writev(true)
+                .handshake::<_, h2_h1::Upload>(hyper_util::rt::TokioIo::new(io)),
+        )
+        .await
+        .map_err(|_| io::ErrorKind::TimedOut)?
+        .map_err(|_| failed())?;
+        // Hyper requires a static informational callback. Only this bounded
+        // request handle is shared; no body queue or extra task is introduced.
+        let state = response.clone();
+        let info_cancel = CancellationToken::new();
+        let upload_idle = h2_h1::UploadIdle::new();
+        let exchange = Box::pin(async {
+            let (parts, body) = request.into_parts();
+            let method = parts.method.clone();
+            let mut headers = h2_headers::clean(parts.headers, false, true)?;
+            headers.remove("expect");
+            headers.remove("te");
+            headers.insert(
+                "host",
+                HeaderValue::from_str(&target.logical_destination.authority())
+                    .map_err(|_| failed())?,
+            );
+            let mut path = if asterisk {
+                "*".to_owned()
+            } else {
+                target.url.path().to_owned()
+            };
+            if !asterisk && let Some(query) = target.url.query() {
+                path.push('?');
+                path.push_str(query);
+            }
+            let mut request = Request::builder()
+                .method(parts.method)
+                .uri(path)
+                .version(Version::HTTP_11)
+                .body(h2_h1::Upload::new(
+                    body,
+                    length,
+                    target.strip_origin_credentials,
+                    upload_idle.clone(),
+                ))
+                .map_err(|_| failed())?;
+            *request.headers_mut() = headers;
+            let info = state.clone();
+            let cancel_info = info_cancel.clone();
+            hyper::ext::on_informational(&mut request, move |response| {
+                let outcome = (|| {
+                    // Check before cloning Hyper's borrowed response head.
+                    h2_headers::check(response.headers())?;
+                    let headers = h2_headers::clean(response.headers().clone(), false, false)?;
+                    let mut message = Response::builder()
+                        .status(response.status())
+                        .version(Version::HTTP_2)
+                        .body(())
+                        .map_err(|_| failed())?;
+                    *message.headers_mut() = headers;
+                    info.informational(message)
+                })();
+                if outcome.is_err() {
+                    cancel_info.cancel();
+                }
+            });
+            sender.ready().await.map_err(|_| failed())?;
+            let incoming = upload_idle
+                .wait_response(sender.send_request(request))
+                .await?;
+            if incoming.status() == StatusCode::SWITCHING_PROTOCOLS {
+                return Err(failed());
+            }
+            let (mut parts, body) = incoming.into_parts();
+            let expected = h2_headers::response_body(&parts.headers, parts.status, &method)?;
+            let wire = headers::from_map(&parts.headers).map(|fields| {
+                WireBodyMeta::new(
+                    &fields,
+                    &original_meta,
+                    Phase::Response,
+                    Some(parts.status.as_u16()),
+                    expected,
+                    false,
+                )
+            });
+            headers::apply_map(
+                self.policy().rules(),
+                &target.original,
+                Phase::Response,
+                &mut parts.headers,
+            );
+            parts.headers = h2_headers::clean(parts.headers, false, false)?;
+            let (body, expected) = self
+                .prepare_body(
+                    h2_body::Source::h1(body),
+                    &target.original,
+                    &mut parts.headers,
+                    BodyMessage {
+                        phase: Phase::Response,
+                        wire,
+                        expected,
+                        strip_credentials: false,
+                    },
+                )
+                .await?;
+            parts.version = Version::HTTP_2;
+            let downstream = state.final_response(Response::from_parts(parts, ()), false)?;
+            h2_h1::download(body, downstream, expected).await
+        });
+        tokio::select! {biased;()=info_cancel.cancelled()=>Err(failed()),result=inline_driver(driver,exchange)=>result}
+    }
+}
+async fn response_after_upload<F, T>(
+    uploaded: tokio::sync::oneshot::Receiver<()>,
+    response: F,
+) -> io::Result<T>
+where
+    F: Future<Output = io::Result<T>>,
+{
+    tokio::pin!(response);
+    // Keep accepting early responses while the separately bounded upload is
+    // active. A response head gets its own idle budget only after upload EOS.
+    tokio::select! {biased;
+        result=&mut response=>result,
+        result=uploaded=>{
+            result.map_err(|_|failed())?;
+            timeout(IDLE,response).await.map_err(|_|io::ErrorKind::TimedOut)?
+        }
+    }
+}
+enum Head {
+    Informational(Response<()>),
+    Final(Response<h2::RecvStream>),
+}
+#[derive(Clone)]
+struct ResponseSlot(Arc<Mutex<ResponseState>>);
+struct ResponseState {
+    response: h2::server::SendResponse<Bytes>,
+    infos: usize,
+    final_started: bool,
+}
+impl ResponseSlot {
+    fn informational(&self, response: Response<()>) -> io::Result<()> {
+        let mut state = self.0.lock().map_err(|_| failed())?;
+        state.infos += 1;
+        if state.infos > 16 {
+            return Err(failed());
+        }
+        // 100 Continue is acknowledged locally, once, before upload forwarding.
+        if response.status() == StatusCode::CONTINUE {
+            return Ok(());
+        }
+        state
+            .response
+            .send_informational(response)
+            .map_err(|_| failed())
+    }
+    fn continue_upload(&self) -> io::Result<()> {
+        self.0
+            .lock()
+            .map_err(|_| failed())?
+            .response
+            .send_informational(
+                Response::builder()
+                    .status(StatusCode::CONTINUE)
+                    .body(())
+                    .map_err(|_| failed())?,
+            )
+            .map_err(|_| failed())
+    }
+    fn final_response(
+        &self,
+        response: Response<()>,
+        end: bool,
+    ) -> io::Result<h2::SendStream<Bytes>> {
+        let mut state = self.0.lock().map_err(|_| failed())?;
+        let stream = state
+            .response
+            .send_response(response, end)
+            .map_err(|_| failed())?;
+        state.final_started = true;
+        Ok(stream)
+    }
+    fn final_started(&self) -> bool {
+        self.0.lock().is_ok_and(|state| state.final_started)
+    }
+    fn reset(&self) {
+        if let Ok(mut state) = self.0.lock() {
+            state.response.send_reset(h2::Reason::INTERNAL_ERROR);
+        }
+    }
+}
+async fn inline_driver<D, E, T, X>(driver: D, exchange: E) -> io::Result<T>
+where
+    D: Future<Output = Result<(), X>>,
+    E: Future<Output = io::Result<T>>,
+{
+    tokio::pin!(exchange);
+    // Driver shutdown can fail after a complete response was delivered (for
+    // example a peer closes before TLS close_notify is flushed). The response
+    // and body futures own message integrity, including errors on truncation;
+    // do not replace buffered valid data with the driver's shutdown result.
+    {
+        tokio::pin!(driver);
+        tokio::select! {biased;result=&mut exchange=>return result,_=&mut driver=>{}}
+    }
+    // Drop a completed driver before waiting, so its remaining senders cannot
+    // keep a failed ResponseFuture or body channel artificially alive.
+    exchange.await
+}
+fn local(response: &ResponseSlot, status: StatusCode, location: Option<&str>) -> io::Result<()> {
+    let mut message = Response::builder()
+        .status(status)
+        .header("content-length", "0");
+    if let Some(location) = location {
+        message = message.header("location", location);
+    }
+    response
+        .final_response(message.body(()).map_err(|_| failed())?, true)
+        .map_err(|_| failed())?;
+    Ok(())
+}
+fn original_url(request: &Request<h2::RecvStream>) -> io::Result<(url::Url, bool)> {
+    let uri = request.uri();
+    if uri.scheme_str() != Some("https") {
+        return Err(failed());
+    }
+    let authority = uri.authority().ok_or_else(failed)?.as_str();
+    let path = uri.path_and_query().map_or("/", |path| path.as_str());
+    let asterisk = path == "*" && request.method() == Method::OPTIONS;
+    if path.len() > 8192 || (!asterisk && (!path.starts_with('/') || path.starts_with("//"))) {
+        return Err(failed());
+    }
+    let url = checked_url(&format!(
+        "https://{authority}{}",
+        if asterisk { "/" } else { path }
+    ))?;
+    let mut hosts = request.headers().get_all("host").iter();
+    if let Some(host) = hosts.next() {
+        if hosts.next().is_some() {
+            return Err(failed());
+        }
+        let host = checked_url(&format!(
+            "https://{}/",
+            host.to_str().map_err(|_| failed())?
+        ))?;
+        if host.host() != url.host() || host.port_or_known_default() != url.port_or_known_default()
+        {
+            return Err(failed());
+        }
+    }
+    Ok((url, asterisk))
+}
diff --git a/src/http_processing/h2_body.rs b/src/http_processing/h2_body.rs
new file mode 100644
index 0000000..0ea1b6f
--- /dev/null
+++ b/src/http_processing/h2_body.rs
@@ -0,0 +1,436 @@
+//! One native frame at a time, with credit returned after bounded forwarding.
+use super::{
+    body::{Bypass, Transaction},
+    h2_headers, headers,
+};
+use bytes::Bytes;
+use http::HeaderMap;
+use hyper::body::{Body, Frame, SizeHint};
+use std::{
+    io,
+    pin::Pin,
+    task::{Context, Poll},
+};
+use tokio::time::{Duration, timeout};
+pub(super) const IDLE: Duration = Duration::from_secs(30);
+
+enum Kind {
+    H2 {
+        source: h2::RecvStream,
+        trailers: bool,
+    },
+    H1(hyper::body::Incoming),
+    Buffered {
+        data: Option<Bytes>,
+        trailers: Option<HeaderMap>,
+    },
+}
+
+/// The same bounded body owner feeds both native H2 DATA and Hyper's HTTP/1
+/// upload. Receive credit follows the current frame, never a detached task.
+pub(super) struct Source {
+    kind: Kind,
+    prefix: Option<Bytes>,
+    pending: Option<Bytes>,
+    credit: usize,
+    pending_credit: usize,
+}
+impl Source {
+    pub(super) fn h2(source: h2::RecvStream) -> Self {
+        Self {
+            kind: Kind::H2 {
+                source,
+                trailers: false,
+            },
+            prefix: None,
+            pending: None,
+            credit: 0,
+            pending_credit: 0,
+        }
+    }
+    pub(super) fn h1(source: hyper::body::Incoming) -> Self {
+        Self {
+            kind: Kind::H1(source),
+            prefix: None,
+            pending: None,
+            credit: 0,
+            pending_credit: 0,
+        }
+    }
+    fn buffered(data: Bytes, trailers: Option<HeaderMap>) -> Self {
+        Self {
+            kind: Kind::Buffered {
+                data: Some(data),
+                trailers,
+            },
+            prefix: None,
+            pending: None,
+            credit: 0,
+            pending_credit: 0,
+        }
+    }
+    fn release(&mut self) -> io::Result<()> {
+        let credit = std::mem::take(&mut self.credit);
+        if credit != 0
+            && let Kind::H2 { source, .. } = &mut self.kind
+        {
+            source
+                .flow_control()
+                .release_capacity(credit)
+                .map_err(|_| failed())?;
+        }
+        Ok(())
+    }
+    fn rewind(&mut self, prefix: Bytes, remaining: Bytes) -> io::Result<()> {
+        if self.credit != 0 {
+            let used = self
+                .credit
+                .checked_sub(remaining.len())
+                .ok_or_else(failed)?;
+            if let Kind::H2 { source, .. } = &mut self.kind {
+                source
+                    .flow_control()
+                    .release_capacity(used)
+                    .map_err(|_| failed())?;
+            }
+            self.pending_credit = remaining.len();
+            self.credit = 0;
+        }
+        self.prefix = Some(prefix);
+        if !remaining.is_empty() {
+            self.pending = Some(remaining);
+        }
+        Ok(())
+    }
+}
+impl Drop for Source {
+    fn drop(&mut self) {
+        let _ = self.release();
+        if self.pending_credit != 0
+            && let Kind::H2 { source, .. } = &mut self.kind
+        {
+            let _ = source.flow_control().release_capacity(self.pending_credit);
+        }
+    }
+}
+impl Body for Source {
+    type Data = Bytes;
+    type Error = io::Error;
+    fn poll_frame(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<io::Result<Frame<Bytes>>>> {
+        if let Err(error) = self.release() {
+            return Poll::Ready(Some(Err(error)));
+        }
+        if let Some(prefix) = self.prefix.take() {
+            return Poll::Ready(Some(Ok(Frame::data(prefix))));
+        }
+        if let Some(pending) = self.pending.take() {
+            self.credit = std::mem::take(&mut self.pending_credit);
+            return Poll::Ready(Some(Ok(Frame::data(pending))));
+        }
+        match &mut self.kind {
+            Kind::Buffered { data, trailers } => {
+                if let Some(data) = data.take() {
+                    return Poll::Ready(Some(Ok(Frame::data(data))));
+                }
+                Poll::Ready(
+                    trailers
+                        .take()
+                        .map(|trailers| Ok(Frame::trailers(trailers))),
+                )
+            }
+            Kind::H1(source) => Pin::new(source)
+                .poll_frame(cx)
+                .map(|value| value.map(|result| result.map_err(|_| failed()))),
+            Kind::H2 { source, trailers } => {
+                if !*trailers {
+                    match source.poll_data(cx) {
+                        Poll::Pending => return Poll::Pending,
+                        Poll::Ready(Some(Ok(data))) => {
+                            let count = data.len();
+                            self.credit = count;
+                            return Poll::Ready(Some(Ok(Frame::data(data))));
+                        }
+                        Poll::Ready(Some(Err(_))) => return Poll::Ready(Some(Err(failed()))),
+                        Poll::Ready(None) => *trailers = true,
+                    }
+                }
+                source.poll_trailers(cx).map(|result| match result {
+                    Ok(trailers) => trailers.map(|trailers| Ok(Frame::trailers(trailers))),
+                    Err(_) => Some(Err(failed())),
+                })
+            }
+        }
+    }
+    fn is_end_stream(&self) -> bool {
+        if self.prefix.is_some() || self.pending.is_some() {
+            return false;
+        }
+        match &self.kind {
+            Kind::H2 { source, .. } => source.is_end_stream(),
+            Kind::H1(source) => source.is_end_stream(),
+            Kind::Buffered { data, trailers } => {
+                data.as_ref().is_none_or(Bytes::is_empty) && trailers.is_none()
+            }
+        }
+    }
+    fn size_hint(&self) -> SizeHint {
+        SizeHint::new()
+    }
+}
+
+pub(super) struct Prepared {
+    pub(super) source: Source,
+    pub(super) expected: Option<u64>,
+}
+
+pub(super) async fn prepare(
+    mut source: Source,
+    mut transaction: Transaction<'_>,
+    expected: Option<u64>,
+    strip_credentials: bool,
+    headers: &mut HeaderMap,
+) -> io::Result<Prepared> {
+    let mut length = Length::new(expected);
+    let mut trailers = None;
+    while let Some(frame) = timeout(
+        IDLE,
+        futures_util::future::poll_fn(|cx| Pin::new(&mut source).poll_frame(cx)),
+    )
+    .await
+    .map_err(|_| io::ErrorKind::TimedOut)?
+    {
+        let frame = frame?;
+        match frame.into_data() {
+            Ok(mut data) => {
+                length.consume(data.len())?;
+                let count = transaction.remaining().min(data.len());
+                let prefix = data.split_to(count);
+                let result = transaction.push(&prefix);
+                if result.is_err() || !data.is_empty() {
+                    source.rewind(transaction.into_raw().into_bytes(), data)?;
+                    return Ok(Prepared { source, expected });
+                }
+            }
+            Err(frame) => {
+                if let Ok(headers) = frame.into_trailers() {
+                    trailers = Some(h2_headers::trailers(headers, strip_credentials)?);
+                    break;
+                }
+            }
+        }
+    }
+    length.finish()?;
+    let mut result = transaction.finish(trailers.is_some());
+    if result.changed {
+        if let Some(mut fields) = headers::from_map(headers) {
+            result.finalize_headers(&mut fields);
+            if result.changed {
+                *headers = headers::to_map(fields).ok_or_else(failed)?;
+            }
+        } else {
+            result.rollback(Bypass::Budget);
+        }
+    }
+    let expected = if result.changed {
+        Some(result.body.as_ref().len() as u64)
+    } else {
+        expected
+    };
+    Ok(Prepared {
+        source: Source::buffered(result.body.into_bytes(), trailers),
+        expected,
+    })
+}
+fn failed() -> io::Error {
+    io::Error::new(io::ErrorKind::ConnectionAborted, "HTTP stream failed")
+}
+pub(super) struct Length(Option<u64>);
+impl Length {
+    pub(super) fn new(length: Option<u64>) -> Self {
+        Self(length)
+    }
+    pub(super) fn remaining(&self) -> Option<u64> {
+        self.0
+    }
+    pub(super) fn consume(&mut self, count: usize) -> io::Result<()> {
+        if let Some(remaining) = self.0 {
+            self.0 = Some(remaining.checked_sub(count as u64).ok_or_else(failed)?);
+        }
+        Ok(())
+    }
+    pub(super) fn finish(&self) -> io::Result<()> {
+        if self.0.is_some_and(|remaining| remaining != 0) {
+            Err(failed())
+        } else {
+            Ok(())
+        }
+    }
+}
+pub(super) async fn send_data(
+    target: &mut h2::SendStream<Bytes>,
+    mut data: Bytes,
+) -> io::Result<()> {
+    while !data.is_empty() {
+        target.reserve_capacity(data.len().min(16 * 1024));
+        let available = timeout(
+            IDLE,
+            futures_util::future::poll_fn(|cx| target.poll_capacity(cx)),
+        )
+        .await
+        .map_err(|_| io::ErrorKind::TimedOut)?
+        .ok_or_else(failed)?
+        .map_err(|_| failed())?;
+        if available == 0 {
+            continue;
+        }
+        let count = data.len().min(available).min(16 * 1024);
+        target
+            .send_data(data.split_to(count), false)
+            .map_err(|_| failed())?;
+    }
+    Ok(())
+}
+pub(super) fn finish(
+    target: &mut h2::SendStream<Bytes>,
+    trailers: Option<HeaderMap>,
+    strip_credentials: bool,
+) -> io::Result<()> {
+    if let Some(trailers) = trailers {
+        target
+            .send_trailers(h2_headers::trailers(trailers, strip_credentials)?)
+            .map_err(|_| failed())
+    } else {
+        target.send_data(Bytes::new(), true).map_err(|_| failed())
+    }
+}
+pub(super) async fn relay(
+    mut source: Source,
+    mut target: h2::SendStream<Bytes>,
+    expected: Option<u64>,
+    strip_credentials: bool,
+) -> io::Result<()> {
+    let mut length = Length::new(expected);
+    loop {
+        let frame = timeout(
+            IDLE,
+            futures_util::future::poll_fn(|cx| Pin::new(&mut source).poll_frame(cx)),
+        )
+        .await
+        .map_err(|_| io::ErrorKind::TimedOut)?;
+        let Some(frame) = frame else {
+            break;
+        };
+        match frame?.into_data() {
+            Ok(data) => {
+                length.consume(data.len())?;
+                send_data(&mut target, data).await?;
+            }
+            Err(frame) => {
+                if let Ok(trailers) = frame.into_trailers() {
+                    length.finish()?;
+                    return finish(&mut target, Some(trailers), strip_credentials);
+                }
+            }
+        }
+    }
+    length.finish()?;
+    finish(&mut target, None, strip_credentials)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::http_processing::{
+        body::{Budget, MAX_BODY, OriginalRequestMeta, WireBodyMeta},
+        rules::{Phase, RawRule, Rule},
+    };
+    use url::Url;
+
+    fn rules() -> Vec<Rule> {
+        let rule: RawRule =
+            serde_yaml_ng::from_str("{url: '.', action: response-body-set, value: changed}")
+                .unwrap();
+        vec![Rule::compile(rule, &mut 0).unwrap()]
+    }
+    async fn drain(mut source: Source) -> (Vec<u8>, Option<HeaderMap>) {
+        let mut output = Vec::new();
+        let mut trailers = None;
+        while let Some(frame) =
+            futures_util::future::poll_fn(|cx| Pin::new(&mut source).poll_frame(cx)).await
+        {
+            match frame.unwrap().into_data() {
+                Ok(data) => output.extend_from_slice(&data),
+                Err(frame) => trailers = frame.into_trailers().ok(),
+            }
+        }
+        (output, trailers)
+    }
+    #[tokio::test]
+    async fn probe_replays_unknown_oversize_body_and_late_trailers() {
+        let rules = rules();
+        let url = Url::parse("https://a.example/").unwrap();
+        let meta = OriginalRequestMeta::new("GET", &vec![]);
+        let wire = WireBodyMeta::new(&vec![], &meta, Phase::Response, Some(200), None, false);
+        let budget = Budget::default();
+        let payload = Bytes::from(vec![b'a'; MAX_BODY + 500]);
+        let transaction =
+            Transaction::begin(&budget, &rules, &url, Phase::Response, &wire).unwrap();
+        let prepared = prepare(
+            Source::buffered(payload.clone(), None),
+            transaction,
+            None,
+            false,
+            &mut HeaderMap::new(),
+        )
+        .await
+        .unwrap();
+        assert!(budget.used() > MAX_BODY);
+        let (replayed, trailers) = drain(prepared.source).await;
+        assert_eq!(replayed, payload);
+        assert!(trailers.is_none());
+        assert_eq!(budget.used(), 0);
+
+        let mut trailers = HeaderMap::new();
+        trailers.insert("x-final", "kept".parse().unwrap());
+        let transaction =
+            Transaction::begin(&budget, &rules, &url, Phase::Response, &wire).unwrap();
+        let prepared = prepare(
+            Source::buffered(Bytes::from_static(b"original"), Some(trailers)),
+            transaction,
+            None,
+            false,
+            &mut HeaderMap::new(),
+        )
+        .await
+        .unwrap();
+        let (body, trailers) = drain(prepared.source).await;
+        assert_eq!(body, b"original");
+        assert_eq!(trailers.unwrap()["x-final"], "kept");
+        assert_eq!(budget.used(), 0);
+    }
+    #[tokio::test]
+    async fn probe_never_masks_truncated_body_as_rewrite_success() {
+        let rules = rules();
+        let url = Url::parse("https://a.example/").unwrap();
+        let meta = OriginalRequestMeta::new("GET", &vec![]);
+        let wire = WireBodyMeta::new(&vec![], &meta, Phase::Response, Some(200), Some(8), false);
+        let budget = Budget::default();
+        let transaction =
+            Transaction::begin(&budget, &rules, &url, Phase::Response, &wire).unwrap();
+        assert!(
+            prepare(
+                Source::buffered(Bytes::from_static(b"half"), None),
+                transaction,
+                Some(8),
+                false,
+                &mut HeaderMap::new()
+            )
+            .await
+            .is_err()
+        );
+        assert_eq!(budget.used(), 0);
+    }
+}
diff --git a/src/http_processing/h2_h1.rs b/src/http_processing/h2_h1.rs
new file mode 100644
index 0000000..5374b6e
--- /dev/null
+++ b/src/http_processing/h2_h1.rs
@@ -0,0 +1,178 @@
+//! Hyper HTTP/1 bodies over an existing dispatcher stream, with native H2 credit.
+use super::{
+    h2_body::{self, IDLE, Length},
+    h2_headers,
+};
+use bytes::Bytes;
+use hyper::body::{Body, Frame, SizeHint};
+use std::{
+    future::Future,
+    io,
+    pin::Pin,
+    sync::{Arc, Mutex},
+    task::{Context, Poll},
+};
+use tokio::time::{Instant, Sleep, sleep};
+
+#[derive(Clone)]
+pub(super) struct UploadIdle(Arc<Mutex<UploadIdleState>>);
+struct UploadIdleState {
+    sleep: Pin<Box<Sleep>>,
+    finished: bool,
+}
+impl UploadIdle {
+    pub(super) fn new() -> Self {
+        Self(Arc::new(Mutex::new(UploadIdleState {
+            sleep: Box::pin(sleep(IDLE)),
+            finished: false,
+        })))
+    }
+    fn progress(&self) {
+        if let Ok(mut state) = self.0.lock()
+            && !state.finished
+        {
+            state.sleep.as_mut().reset(Instant::now() + IDLE);
+        }
+    }
+    fn finish(&self) {
+        if let Ok(mut state) = self.0.lock()
+            && !state.finished
+        {
+            state.finished = true;
+            state.sleep.as_mut().reset(Instant::now() + IDLE);
+        }
+    }
+    fn poll_expired(&self, cx: &mut Context<'_>) -> Poll<io::Error> {
+        let Ok(mut state) = self.0.lock() else {
+            return Poll::Ready(io::Error::other("HTTP upload clock failed"));
+        };
+        state
+            .sleep
+            .as_mut()
+            .poll(cx)
+            .map(|()| io::ErrorKind::TimedOut.into())
+    }
+    pub(super) async fn wait_response<F, T, E>(&self, response: F) -> io::Result<T>
+    where
+        F: Future<Output = Result<T, E>>,
+    {
+        tokio::pin!(response);
+        // Both polls belong to the existing inline driver owner. Never hold
+        // the clock lock while polling Hyper, which can also poll Upload.
+        futures_util::future::poll_fn(|cx| {
+            if let Poll::Ready(result) = response.as_mut().poll(cx) {
+                return Poll::Ready(result.map_err(|_| {
+                    io::Error::new(io::ErrorKind::ConnectionAborted, "HTTP proxy stream failed")
+                }));
+            }
+            self.poll_expired(cx).map(Err)
+        })
+        .await
+    }
+}
+
+pub(super) struct Upload {
+    source: h2_body::Source,
+    length: Length,
+    done: bool,
+    strip_credentials: bool,
+    idle: UploadIdle,
+}
+impl Upload {
+    pub(super) fn new(
+        source: h2_body::Source,
+        length: Option<u64>,
+        strip_credentials: bool,
+        idle: UploadIdle,
+    ) -> Self {
+        Self {
+            source,
+            length: Length::new(length),
+            done: false,
+            strip_credentials,
+            idle,
+        }
+    }
+    fn stop(&mut self) -> Poll<Option<Result<Frame<Bytes>, io::Error>>> {
+        self.done = true;
+        Poll::Ready(Some(Err(io::Error::new(
+            io::ErrorKind::InvalidData,
+            "HTTP upload failed",
+        ))))
+    }
+}
+impl Body for Upload {
+    type Data = Bytes;
+    type Error = io::Error;
+    fn poll_frame(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Frame<Bytes>, io::Error>>> {
+        if self.done {
+            return Poll::Ready(None);
+        }
+        if self.idle.poll_expired(cx).is_ready() {
+            return self.stop();
+        }
+        match Pin::new(&mut self.source).poll_frame(cx) {
+            Poll::Pending => Poll::Pending,
+            Poll::Ready(Some(Ok(frame))) => match frame.into_data() {
+                Ok(data) => {
+                    if self.length.consume(data.len()).is_err() {
+                        return self.stop();
+                    }
+                    if !data.is_empty() {
+                        self.idle.progress();
+                    }
+                    Poll::Ready(Some(Ok(Frame::data(data))))
+                }
+                Err(frame) => {
+                    if self.length.finish().is_err() {
+                        return self.stop();
+                    }
+                    self.done = true;
+                    self.idle.finish();
+                    Poll::Ready(frame.into_trailers().ok().map(|headers| {
+                        h2_headers::trailers(headers, self.strip_credentials).map(Frame::trailers)
+                    }))
+                }
+            },
+            Poll::Ready(Some(Err(_))) => self.stop(),
+            Poll::Ready(None) => {
+                if self.length.finish().is_err() {
+                    return self.stop();
+                }
+                self.done = true;
+                self.idle.finish();
+                Poll::Ready(None)
+            }
+        }
+    }
+    fn is_end_stream(&self) -> bool {
+        let finished = self.source.is_end_stream()
+            && self
+                .length
+                .remaining()
+                .is_none_or(|remaining| remaining == 0);
+        // Hyper may omit the final poll_frame when this reports EOS. Errors
+        // also set done, and must not refresh the clock as normal completion.
+        if !self.done && finished {
+            self.idle.finish();
+        }
+        self.done || finished
+    }
+    fn size_hint(&self) -> SizeHint {
+        let mut hint = SizeHint::new();
+        if let Some(length) = self.length.remaining() {
+            hint.set_exact(length);
+        }
+        hint
+    }
+}
+pub(super) async fn download(
+    body: h2_body::Source,
+    target: h2::SendStream<Bytes>,
+    expected: Option<u64>,
+) -> io::Result<()> {
+    h2_body::relay(body, target, expected, false).await
+}
diff --git a/src/http_processing/h2_headers.rs b/src/http_processing/h2_headers.rs
new file mode 100644
index 0000000..3463560
--- /dev/null
+++ b/src/http_processing/h2_headers.rs
@@ -0,0 +1,174 @@
+//! Shared bounded HTTP/2 header validation and HTTP/1 hop-field conversion.
+use http::{HeaderMap, HeaderName, Method, StatusCode};
+use std::{collections::HashSet, io};
+const MAX_BYTES: usize = 32 * 1024;
+const MAX_FIELDS: usize = 100;
+pub(super) fn invalid() -> io::Error {
+    io::Error::new(io::ErrorKind::InvalidData, "invalid HTTP headers")
+}
+pub(super) fn check(headers: &HeaderMap) -> io::Result<()> {
+    if headers.len() > MAX_FIELDS {
+        return Err(invalid());
+    }
+    let mut total = 0usize;
+    for (name, value) in headers {
+        total = total
+            .checked_add(name.as_str().len() + value.as_bytes().len() + 32)
+            .filter(|size| *size <= MAX_BYTES)
+            .ok_or_else(invalid)?;
+    }
+    Ok(())
+}
+pub(super) fn request(headers: &HeaderMap) -> io::Result<Option<u64>> {
+    check(headers)?;
+    for name in [
+        "connection",
+        "proxy-connection",
+        "keep-alive",
+        "transfer-encoding",
+        "upgrade",
+    ] {
+        if headers.contains_key(name) {
+            return Err(invalid());
+        }
+    }
+    for value in headers.get_all("te") {
+        if !value.as_bytes().eq_ignore_ascii_case(b"trailers") {
+            return Err(invalid());
+        }
+    }
+    let mut expect = headers.get_all("expect").iter();
+    if let Some(value) = expect.next()
+        && (!value.as_bytes().eq_ignore_ascii_case(b"100-continue") || expect.next().is_some())
+    {
+        return Err(invalid());
+    }
+    length(headers)
+}
+pub(super) fn length(headers: &HeaderMap) -> io::Result<Option<u64>> {
+    let mut values = headers.get_all("content-length").iter();
+    let Some(value) = values.next() else {
+        return Ok(None);
+    };
+    if values.next().is_some()
+        || value.is_empty()
+        || !value.as_bytes().iter().all(u8::is_ascii_digit)
+    {
+        return Err(invalid());
+    }
+    let text = value.to_str().map_err(|_| invalid())?;
+    Ok(Some(text.parse().map_err(|_| invalid())?))
+}
+pub(super) fn response_body(
+    headers: &HeaderMap,
+    status: StatusCode,
+    method: &Method,
+) -> io::Result<Option<u64>> {
+    check(headers)?;
+    let length = length(headers)?;
+    if (status.is_informational() || status == StatusCode::NO_CONTENT) && length.is_some() {
+        return Err(invalid());
+    }
+    if method == Method::HEAD
+        || status.is_informational()
+        || status == StatusCode::NO_CONTENT
+        || status == StatusCode::NOT_MODIFIED
+    {
+        Ok(Some(0))
+    } else {
+        Ok(length)
+    }
+}
+pub(super) fn clean(
+    mut headers: HeaderMap,
+    strip_origin_credentials: bool,
+    request: bool,
+) -> io::Result<HeaderMap> {
+    check(&headers)?;
+    let mut connection = HashSet::new();
+    for value in headers.get_all("connection") {
+        for token in value.to_str().map_err(|_| invalid())?.split(',') {
+            let token = HeaderName::from_bytes(token.trim().as_bytes()).map_err(|_| invalid())?;
+            connection.insert(token);
+        }
+    }
+    for name in connection {
+        headers.remove(name);
+    }
+    for name in [
+        "connection",
+        "proxy-connection",
+        "keep-alive",
+        "proxy-authorization",
+        "proxy-authenticate",
+        "transfer-encoding",
+        "trailer",
+        "upgrade",
+        "host",
+    ] {
+        headers.remove(name);
+    }
+    if !request {
+        headers.remove("te");
+    }
+    if strip_origin_credentials {
+        headers.remove("authorization");
+        headers.remove("cookie");
+    }
+    Ok(headers)
+}
+pub(super) fn trailers(
+    headers: HeaderMap,
+    strip_origin_credentials: bool,
+) -> io::Result<HeaderMap> {
+    check(&headers)?;
+    if headers.keys().any(|name| {
+        matches!(
+            name.as_str(),
+            "authorization"
+                | "proxy-authorization"
+                | "proxy-authenticate"
+                | "host"
+                | "content-length"
+                | "transfer-encoding"
+                | "connection"
+                | "trailer"
+                | "expect"
+                | "content-type"
+                | "content-encoding"
+                | "content-range"
+        )
+    }) {
+        return Err(invalid());
+    }
+    if strip_origin_credentials && headers.contains_key("cookie") {
+        return Err(invalid());
+    }
+    Ok(headers)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn h2_headers_and_trailers_are_bounded_before_conversion() {
+        let mut headers = HeaderMap::new();
+        for _ in 0..101 {
+            headers.append("x-test", "a".parse().unwrap());
+        }
+        assert!(request(&headers).is_err());
+        headers.clear();
+        headers.insert(
+            "x-test",
+            http::HeaderValue::from_bytes(&vec![b'x'; 32 * 1024]).unwrap(),
+        );
+        assert!(check(&headers).is_err());
+        headers.clear();
+        headers.insert("content-length", "2".parse().unwrap());
+        headers.append("content-length", "2".parse().unwrap());
+        assert!(request(&headers).is_err());
+        headers.clear();
+        headers.insert("cookie", "secret".parse().unwrap());
+        assert!(trailers(headers, true).is_err());
+    }
+}
diff --git a/src/http_processing/h2_tests.rs b/src/http_processing/h2_tests.rs
new file mode 100644
index 0000000..7ed804d
--- /dev/null
+++ b/src/http_processing/h2_tests.rs
@@ -0,0 +1,1102 @@
+//! Independent in-memory H2 peers. No host sockets or detached production tasks.
+use super::*;
+use crate::{
+    dispatch::{BoxStream, DatagramTransport, DispatchError},
+    session::{DatagramSession, Destination, InboundKind, InboundMetadata, StreamSession},
+};
+use ::h2 as wire;
+use async_trait::async_trait;
+use bytes::Bytes;
+use http::{HeaderMap, Request, Response, StatusCode};
+use std::{
+    sync::{Arc, Mutex},
+    time::Duration,
+};
+use tokio::{
+    io::{AsyncReadExt, AsyncWriteExt},
+    time::timeout,
+};
+use tokio_util::sync::CancellationToken;
+const PAYLOAD: usize = 96 * 1024;
+
+#[tokio::test]
+async fn h2_rewrite_stages_use_original_url_for_h2_and_h1_origins() {
+    let rules = r#"
+rewrite:
+  enabled: true
+  rules:
+    - {url: '^https://a\.test/upload$', action: replace, replacement: 'https://b.test/rewritten'}
+    - {url: '^https://a\.test/upload$', action: request-header-set, header: X-Request, value: rewritten}
+    - {url: '^https://a\.test/upload$', action: request-header-set, header: Authorization, value: 'Bearer explicit'}
+    - {url: '^https://a\.test/upload$', action: request-header-set, header: Cookie, value: 'new=explicit'}
+    - {url: '^https://a\.test/upload$', action: request-body-replace, search: old, replacement: new}
+    - {url: '^https://a\.test/upload$', action: response-header-remove, header: Server}
+    - url: '^https://a\.test/upload$'
+      action: response-body-json-patch
+      patch:
+        - {op: replace, path: /ads, value: []}
+        - {op: replace, path: /token, value: new}
+"#;
+    for upstream_h2 in [true, false] {
+        let (context, origin) =
+            prepared_origin_rules(upstream_h2, false, false, OriginMode::Rewrite, rules);
+        let cancel = CancellationToken::new();
+        let stop = cancel.clone();
+        let (client, mut server) = tokio::io::duplex(8192);
+        let worker = tokio::spawn(async move {
+            context
+                .serve_h2(&mut server, session(), stop)
+                .await
+                .unwrap();
+        });
+        let (mut sender, connection) = wire::client::handshake(client).await.unwrap();
+        let driver = tokio::spawn(connection);
+        let (response, mut upload) = sender
+            .send_request(
+                Request::builder()
+                    .method("POST")
+                    .uri("https://a.test/upload")
+                    .header("content-length", 11)
+                    .header("authorization", "Bearer original")
+                    .header("cookie", "old=original")
+                    .body(())
+                    .unwrap(),
+                false,
+            )
+            .unwrap();
+        upload
+            .send_data(Bytes::from_static(b"old request"), true)
+            .unwrap();
+        let response = timeout(Duration::from_secs(5), response)
+            .await
+            .unwrap()
+            .unwrap();
+        assert!(!response.headers().contains_key("server"));
+        let expected = response.headers()["content-length"]
+            .to_str()
+            .unwrap()
+            .parse::<usize>()
+            .unwrap();
+        let mut body = response.into_body();
+        let mut bytes = Vec::new();
+        while let Some(frame) = timeout(Duration::from_secs(5), body.data()).await.unwrap() {
+            let frame = frame.unwrap();
+            body.flow_control().release_capacity(frame.len()).unwrap();
+            bytes.extend_from_slice(&frame);
+        }
+        assert_eq!(bytes.len(), expected);
+        assert_eq!(
+            serde_json::from_slice::<serde_json::Value>(&bytes).unwrap(),
+            serde_json::json!({"ads":[],"token":"new"})
+        );
+        assert_eq!(origin.received.lock().unwrap()[0], b"new request");
+        cancel.cancel();
+        timeout(Duration::from_secs(1), worker)
+            .await
+            .unwrap()
+            .unwrap();
+        origin.join().await;
+        driver.abort();
+        let _ = driver.await;
+    }
+}
+#[derive(Clone, Copy)]
+enum OriginMode {
+    None,
+    BeforeUpload,
+    AfterUpload,
+    ShortClose { truncated: bool },
+    Rewrite,
+}
+fn pem(label: &str, bytes: &[u8]) -> String {
+    use base64::Engine as _;
+    format!(
+        "-----BEGIN {label}-----\n{}\n-----END {label}-----\n",
+        base64::engine::general_purpose::STANDARD.encode(bytes)
+    )
+}
+struct Origin {
+    authority: Arc<authority::Authority>,
+    h2: bool,
+    early: bool,
+    truncated: bool,
+    mode: OriginMode,
+    sessions: Mutex<Vec<StreamSession>>,
+    received: Arc<Mutex<Vec<Vec<u8>>>>,
+    tasks: Mutex<Vec<tokio::task::JoinHandle<()>>>,
+}
+#[async_trait]
+impl Dispatcher for Origin {
+    async fn connect_tcp(&self, session: StreamSession) -> Result<BoxStream, DispatchError> {
+        let name = match &session.destination {
+            Destination::Domain { host, .. } => host.clone(),
+            _ => session.sniffed_domain.clone().unwrap(),
+        };
+        let mut config = (*self.authority.server_config(&name).unwrap()).clone();
+        config.alpn_protocols = if self.h2 {
+            vec![b"h2".to_vec()]
+        } else {
+            vec![b"http/1.1".to_vec()]
+        };
+        self.sessions.lock().unwrap().push(session);
+        let h2 = self.h2;
+        let early = self.early;
+        let truncated = self.truncated;
+        let mode = self.mode;
+        let received = self.received.clone();
+        let (client, peer) = tokio::io::duplex(8192);
+        let task = tokio::spawn(async move {
+            let Ok(mut tls) = tokio_rustls::TlsAcceptor::from(Arc::new(config))
+                .accept(peer)
+                .await
+            else {
+                return;
+            };
+            if let OriginMode::ShortClose { truncated } = mode {
+                if let Ok(body) = short_h2_reply_and_close(&mut tls, truncated).await {
+                    received.lock().unwrap().push(body);
+                }
+                // Match an origin that sends one complete response and closes
+                // without GOAWAY or TLS close_notify.
+                return;
+            }
+            if h2 {
+                let mut builder = wire::server::Builder::new();
+                builder
+                    .initial_window_size(8192)
+                    .initial_connection_window_size(16384);
+                let mut connection = builder.handshake::<_, Bytes>(tls).await.unwrap();
+                let (request, mut response) = connection.accept().await.unwrap().unwrap();
+                let exchange = async move {
+                    if matches!(mode, OriginMode::Rewrite) {
+                        assert_eq!(request.uri().path(), "/rewritten");
+                        assert_eq!(request.headers()["x-request"], "rewritten");
+                        assert_eq!(request.headers()["authorization"], "Bearer explicit");
+                        assert_eq!(request.headers()["cookie"], "new=explicit");
+                        let mut body = request.into_body();
+                        let mut bytes = Vec::new();
+                        while let Some(frame) = body.data().await {
+                            let frame = frame.unwrap();
+                            body.flow_control().release_capacity(frame.len()).unwrap();
+                            bytes.extend_from_slice(&frame);
+                        }
+                        assert_eq!(bytes, b"new request");
+                        received.lock().unwrap().push(bytes);
+                        let payload = Bytes::from_static(br#"{"ads":[1],"token":"old"}"#);
+                        let mut outgoing = response
+                            .send_response(
+                                Response::builder()
+                                    .header("content-length", payload.len())
+                                    .header("content-type", "application/json")
+                                    .header("server", "origin")
+                                    .body(())
+                                    .unwrap(),
+                                false,
+                            )
+                            .unwrap();
+                        super::h2_body::send_data(&mut outgoing, payload)
+                            .await
+                            .unwrap();
+                        outgoing.send_data(Bytes::new(), true).unwrap();
+                        return;
+                    }
+                    if matches!(mode, OriginMode::BeforeUpload) {
+                        tokio::time::sleep(Duration::from_secs(31)).await;
+                        return;
+                    }
+                    if early || truncated {
+                        received.lock().unwrap().push(Vec::new());
+                        let mut out = response
+                            .send_response(
+                                Response::builder()
+                                    .status(if early { 413 } else { 200 })
+                                    .header("content-length", PAYLOAD)
+                                    .body(())
+                                    .unwrap(),
+                                false,
+                            )
+                            .unwrap();
+                        super::h2_body::send_data(
+                            &mut out,
+                            Bytes::from(vec![9; if truncated { PAYLOAD / 2 } else { PAYLOAD }]),
+                        )
+                        .await
+                        .unwrap();
+                        out.send_data(Bytes::new(), true).unwrap();
+                        drop(request);
+                        drop(out);
+                        drop(response);
+                        return;
+                    }
+                    assert_eq!(request.uri().path(), "/upload");
+                    let mut body = request.into_body();
+                    let mut bytes = Vec::new();
+                    while let Some(frame) = body.data().await {
+                        let Ok(frame) = frame else {
+                            return;
+                        };
+                        body.flow_control().release_capacity(frame.len()).unwrap();
+                        bytes.extend_from_slice(&frame);
+                    }
+                    if bytes.len() != PAYLOAD {
+                        return;
+                    }
+                    assert!(bytes.iter().all(|b| *b == 7));
+                    received.lock().unwrap().push(bytes);
+                    if matches!(mode, OriginMode::AfterUpload) {
+                        tokio::time::sleep(Duration::from_secs(31)).await;
+                        return;
+                    }
+                    let mut out = response
+                        .send_response(
+                            Response::builder()
+                                .header("content-length", PAYLOAD)
+                                .body(())
+                                .unwrap(),
+                            false,
+                        )
+                        .unwrap();
+                    super::h2_body::send_data(&mut out, Bytes::from(vec![9; PAYLOAD]))
+                        .await
+                        .unwrap();
+                    let mut trailers = HeaderMap::new();
+                    trailers.insert("x-check", "complete".parse().unwrap());
+                    out.send_trailers(trailers).unwrap();
+                };
+                tokio::pin!(exchange);
+                loop {
+                    tokio::select! {biased;()=&mut exchange=>break,next=connection.accept()=>{if next.is_none() { return; }}}
+                }
+                connection.graceful_shutdown();
+                while matches!(connection.accept().await, Some(Ok(_))) {}
+            } else {
+                let mut head = Vec::new();
+                while !head.ends_with(b"\r\n\r\n") {
+                    assert!(head.len() < 32768);
+                    head.push(tls.read_u8().await.unwrap());
+                }
+                let head = String::from_utf8(head).unwrap();
+                if matches!(mode, OriginMode::Rewrite) {
+                    assert!(head.starts_with("POST /rewritten HTTP/1.1\r\n"));
+                    assert!(
+                        head.to_ascii_lowercase()
+                            .contains("x-request: rewritten\r\n")
+                    );
+                    assert!(head.contains("Bearer explicit\r\n"));
+                    assert!(head.contains("new=explicit\r\n"));
+                    assert!(!head.contains("original\r\n"));
+                    let mut body = [0u8; 11];
+                    tls.read_exact(&mut body).await.unwrap();
+                    assert_eq!(&body, b"new request");
+                    received.lock().unwrap().push(body.to_vec());
+                    let payload = br#"{"ads":[1],"token":"old"}"#;
+                    tls.write_all(format!("HTTP/1.1 200 OK\r\nContent-Length: {}\r\nContent-Type: application/json\r\nServer: origin\r\nConnection: close\r\n\r\n", payload.len()).as_bytes()).await.unwrap();
+                    tls.write_all(payload).await.unwrap();
+                    tls.shutdown().await.unwrap();
+                    return;
+                }
+                if matches!(mode, OriginMode::BeforeUpload) {
+                    tokio::time::sleep(Duration::from_secs(31)).await;
+                    return;
+                }
+                if early || truncated {
+                    received.lock().unwrap().push(Vec::new());
+                    let status = if early {
+                        "413 Content Too Large"
+                    } else {
+                        "200 OK"
+                    };
+                    tls.write_all(format!("HTTP/1.1 {status}\r\nContent-Length: {PAYLOAD}\r\nConnection: close\r\n\r\n").as_bytes()).await.unwrap();
+                    let size = if truncated { PAYLOAD / 2 } else { PAYLOAD };
+                    tls.write_all(&vec![9; size]).await.unwrap();
+                    let _ = tls.shutdown().await;
+                    if early {
+                        // Preserve the read half after the final response. A
+                        // peer that drops an unread request would instead reset
+                        // the transport, invalidating its buffered response.
+                        let mut scratch = [0; 4096];
+                        timeout(Duration::from_secs(3), async {
+                            while matches!(tls.read(&mut scratch).await, Ok(n) if n > 0) {}
+                        })
+                        .await
+                        .unwrap();
+                    }
+                    return;
+                }
+                assert!(head.starts_with("POST /upload HTTP/1.1\r\n"));
+                assert!(
+                    head.to_lowercase()
+                        .contains(&format!("content-length: {PAYLOAD}\r\n"))
+                );
+                let mut bytes = vec![0; PAYLOAD];
+                if tls.read_exact(&mut bytes).await.is_err() {
+                    return;
+                }
+                assert!(bytes.iter().all(|b| *b == 7));
+                received.lock().unwrap().push(bytes);
+                if matches!(mode, OriginMode::AfterUpload) {
+                    tokio::time::sleep(Duration::from_secs(31)).await;
+                    return;
+                }
+                tls.write_all(b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\nTrailer: x-check\r\nConnection: close\r\n\r\n").await.unwrap();
+                for _ in 0..PAYLOAD / 4096 {
+                    tls.write_all(b"1000\r\n").await.unwrap();
+                    tls.write_all(&[9; 4096]).await.unwrap();
+                    tls.write_all(b"\r\n").await.unwrap();
+                }
+                tls.write_all(b"0\r\nx-check: complete\r\n\r\n")
+                    .await
+                    .unwrap();
+                tls.shutdown().await.unwrap();
+            }
+        });
+        self.tasks.lock().unwrap().push(task);
+        Ok(Box::new(client))
+    }
+    async fn open_datagram(
+        &self,
+        _: DatagramSession,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        Err(DispatchError::NotAllowed)
+    }
+}
+impl Origin {
+    async fn join(&self) {
+        let tasks = std::mem::take(&mut *self.tasks.lock().unwrap());
+        for task in tasks {
+            timeout(Duration::from_secs(3), task)
+                .await
+                .unwrap()
+                .unwrap();
+        }
+    }
+}
+fn raw_h2_frame(kind: u8, flags: u8, stream: u32, payload: &[u8]) -> Vec<u8> {
+    assert!(payload.len() <= 16 * 1024);
+    let mut frame = (payload.len() as u32).to_be_bytes()[1..].to_vec();
+    frame.extend_from_slice(&[kind, flags]);
+    frame.extend_from_slice(&stream.to_be_bytes());
+    frame.extend_from_slice(payload);
+    frame
+}
+async fn short_h2_reply_and_close<S: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin>(
+    stream: &mut S,
+    truncated: bool,
+) -> std::io::Result<Vec<u8>> {
+    let mut preface = [0; 24];
+    stream.read_exact(&mut preface).await?;
+    if preface != *b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n" {
+        return Err(std::io::Error::other("invalid H2 preface"));
+    }
+    stream
+        .write_all(&raw_h2_frame(4, 0, 0, &[0, 1, 0, 0, 0, 0]))
+        .await?;
+    let mut body = Vec::new();
+    for _ in 0..128 {
+        let mut head = [0; 9];
+        stream.read_exact(&mut head).await?;
+        let size = u32::from_be_bytes([0, head[0], head[1], head[2]]) as usize;
+        if size > 16 * 1024 {
+            return Err(std::io::Error::other("oversized H2 frame"));
+        }
+        let mut frame = vec![0; size];
+        stream.read_exact(&mut frame).await?;
+        let id = u32::from_be_bytes(head[5..9].try_into().unwrap()) & 0x7fff_ffff;
+        if head[3] == 4 && head[4] & 1 == 0 {
+            stream.write_all(&raw_h2_frame(4, 1, 0, &[])).await?;
+        } else if head[3] == 0 && id == 1 {
+            body.extend_from_slice(&frame);
+            if body.len() > 21_504 || frame.iter().any(|byte| *byte != 7) {
+                return Err(std::io::Error::other("incorrect short upload"));
+            }
+            if !frame.is_empty() {
+                let count = (frame.len() as u32).to_be_bytes();
+                stream
+                    .write_all(
+                        &[raw_h2_frame(8, 0, 0, &count), raw_h2_frame(8, 0, 1, &count)].concat(),
+                    )
+                    .await?;
+            }
+        } else if matches!(head[3], 3 | 7) {
+            return Err(std::io::Error::other("upload reset before short response"));
+        }
+        if id == 1 && (matches!(head[3], 0 | 1) && head[4] & 1 != 0) {
+            if body.len() != 21_504 {
+                return Err(std::io::Error::other("incomplete short upload"));
+            }
+            // HPACK: zero table, :status 200, literal content-length 11264.
+            let mut headers = vec![0x20, 0x88];
+            headers.extend_from_slice(&[0x0f, 0x0d, 5]);
+            headers.extend_from_slice(b"11264");
+            let mut reply = raw_h2_frame(1, 4, 1, &headers);
+            let data = [9; 11_264];
+            reply.extend_from_slice(&raw_h2_frame(
+                0,
+                1,
+                1,
+                &data[..if truncated { 5_632 } else { 11_264 }],
+            ));
+            stream.write_all(&reply).await?;
+            stream.flush().await?;
+            return Ok(body);
+        }
+    }
+    Err(std::io::Error::other("short origin frame budget exceeded"))
+}
+fn prepared(h2: bool) -> (HttpContext, Arc<Origin>) {
+    prepared_with(h2, false)
+}
+fn prepared_with(h2: bool, early: bool) -> (HttpContext, Arc<Origin>) {
+    prepared_response(h2, early, false)
+}
+fn prepared_response(h2: bool, early: bool, truncated: bool) -> (HttpContext, Arc<Origin>) {
+    prepared_origin(h2, early, truncated, OriginMode::None)
+}
+fn prepared_origin(
+    h2: bool,
+    early: bool,
+    truncated: bool,
+    mode: OriginMode,
+) -> (HttpContext, Arc<Origin>) {
+    prepared_origin_rules(h2, early, truncated, mode, "")
+}
+fn prepared_origin_rules(
+    h2: bool,
+    early: bool,
+    truncated: bool,
+    mode: OriginMode,
+    rules: &str,
+) -> (HttpContext, Arc<Origin>) {
+    let mut params = rcgen::CertificateParams::default();
+    params.is_ca = rcgen::IsCa::Ca(rcgen::BasicConstraints::Unconstrained);
+    params.key_usages = vec![rcgen::KeyUsagePurpose::KeyCertSign];
+    let key = rcgen::KeyPair::generate().unwrap();
+    let cert = params.self_signed(&key).unwrap();
+    let cert_pem = pem("CERTIFICATE", cert.der());
+    let key_pem = pem("PRIVATE KEY", &key.serialize_der());
+    let authority = authority::Authority::load(&cert_pem, &key_pem).unwrap();
+    let document = super::config::Document::parse(&format!(
+        "mitm:\n  enabled: true\n  domains: [{{pattern: a.test}}, {{pattern: b.test}}]\n{rules}"
+    ))
+    .unwrap();
+    let candidate = document
+        .compile(&std::collections::BTreeMap::new())
+        .unwrap();
+    let material = super::private_context::CaMaterial {
+        certificate: cert_pem,
+        private_key: zeroize::Zeroizing::new(key_pem),
+    };
+    let policy = candidate.bind_ca(Some(&material)).unwrap();
+    let mut roots = rustls::RootCertStore::empty();
+    roots.add(cert.der().clone()).unwrap();
+    let origin = Arc::new(Origin {
+        authority,
+        h2,
+        early,
+        truncated,
+        mode,
+        sessions: Mutex::new(Vec::new()),
+        received: Arc::new(Mutex::new(Vec::new())),
+        tasks: Mutex::new(Vec::new()),
+    });
+    (
+        HttpContext::new(
+            policy,
+            origin.clone(),
+            SecurityContext::with_tls_roots(roots),
+        ),
+        origin,
+    )
+}
+fn session() -> StreamSession {
+    StreamSession {
+        metadata: InboundMetadata::new(443),
+        inbound: InboundKind::Tun,
+        source: "198.18.0.2:30000".parse().unwrap(),
+        destination: Destination::Ip("203.0.113.1:443".parse().unwrap()),
+        sniffed_domain: Some("a.test".into()),
+    }
+}
+async fn join_memory_owner<T>(mut task: tokio::task::JoinHandle<T>, seconds: u64) -> bool {
+    match timeout(Duration::from_secs(seconds), &mut task).await {
+        Ok(result) => result.is_ok(),
+        Err(_) => {
+            task.abort();
+            let _ = task.await;
+            false
+        }
+    }
+}
+#[tokio::test]
+async fn h2_short_upload_preserves_complete_response_after_abrupt_origin_close() {
+    let mut outcomes = Vec::new();
+    for truncated in [false, true] {
+        let (context, origin) =
+            prepared_origin(true, false, false, OriginMode::ShortClose { truncated });
+        let cancel = CancellationToken::new();
+        let stop = cancel.clone();
+        let (client, mut server) = tokio::io::duplex(8192);
+        let worker = tokio::spawn(async move {
+            context
+                .serve_h2(&mut server, session(), stop)
+                .await
+                .unwrap();
+        });
+        let (mut sender, driver) = wire::client::handshake(client).await.unwrap();
+        let driver = tokio::spawn(driver);
+        let (response, mut body) = sender
+            .send_request(
+                Request::builder()
+                    .method("POST")
+                    .uri("https://a.test/upload")
+                    .header("content-length", 21_504)
+                    .body(())
+                    .unwrap(),
+                false,
+            )
+            .unwrap();
+        let upload = async {
+            super::h2_body::send_data(&mut body, Bytes::from_static(&[7; 21_504])).await?;
+            body.send_data(Bytes::new(), true)
+                .map_err(std::io::Error::other)
+        };
+        let download = async {
+            let response = response.await.map_err(std::io::Error::other)?;
+            if response.status() != StatusCode::OK {
+                return Err(std::io::Error::other("wrong short response status"));
+            }
+            let mut body = response.into_body();
+            let mut count = 0;
+            while let Some(frame) = body.data().await {
+                let frame = frame.map_err(std::io::Error::other)?;
+                if frame.iter().any(|byte| *byte != 9) {
+                    return Err(std::io::Error::other("incorrect short response body"));
+                }
+                count += frame.len();
+                body.flow_control()
+                    .release_capacity(frame.len())
+                    .map_err(std::io::Error::other)?;
+            }
+            Ok(count)
+        };
+        let result = timeout(Duration::from_secs(3), async {
+            tokio::join!(upload, download)
+        })
+        .await;
+        cancel.cancel();
+        let worker_joined = join_memory_owner(worker, 1).await;
+        drop(sender);
+        let driver_joined = join_memory_owner(driver, 1).await;
+        let tasks = std::mem::take(&mut *origin.tasks.lock().unwrap());
+        let mut origin_joined = true;
+        for task in tasks {
+            origin_joined &= join_memory_owner(task, 1).await;
+        }
+        let delivered = if truncated {
+            matches!(&result, Ok((Ok(()), Err(_))))
+        } else {
+            matches!(&result, Ok((Ok(()), Ok(11_264))))
+        };
+        let received = origin.received.lock().unwrap();
+        let complete_upload = received.len() == 1 && received[0].len() == 21_504;
+        outcomes.push((
+            truncated,
+            delivered && complete_upload && worker_joined && driver_joined && origin_joined,
+            format!("{result:?}"),
+        ));
+    }
+    assert!(
+        outcomes.iter().all(|(_, passed, _)| *passed),
+        "short origin close changed delivery: {outcomes:?}"
+    );
+}
+#[tokio::test(start_paused = true)]
+async fn h2_continuous_upload_can_outlive_response_idle_for_h2_and_h1_origins() {
+    let mut outcomes = Vec::new();
+    for upstream_h2 in [true, false] {
+        let (context, origin) = prepared(upstream_h2);
+        let cancel = CancellationToken::new();
+        let stop = cancel.clone();
+        let (client, mut server) = tokio::io::duplex(8192);
+        let worker = tokio::spawn(async move {
+            context
+                .serve_h2(&mut server, session(), stop)
+                .await
+                .unwrap();
+        });
+        let (mut sender, driver) = wire::client::handshake(client).await.unwrap();
+        let driver = tokio::spawn(driver);
+        let request = Request::builder()
+            .method("POST")
+            .uri("https://a.test/upload")
+            .header("content-length", PAYLOAD)
+            .body(())
+            .unwrap();
+        let (response, mut body) = sender.send_request(request, false).unwrap();
+        let start = tokio::time::Instant::now();
+        let upload = async {
+            for _ in 0..6 {
+                tokio::time::sleep(Duration::from_secs(8)).await;
+                super::h2_body::send_data(&mut body, Bytes::from_static(&[7; PAYLOAD / 6])).await?;
+            }
+            body.send_data(Bytes::new(), true)
+                .map_err(std::io::Error::other)
+        };
+        let download = async {
+            let response = response.await.map_err(std::io::Error::other)?;
+            let mut body = response.into_body();
+            let mut count = 0;
+            while let Some(frame) = body.data().await {
+                let frame = frame.map_err(std::io::Error::other)?;
+                if frame.iter().any(|byte| *byte != 9) {
+                    return Err(std::io::Error::other("incorrect response body"));
+                }
+                count += frame.len();
+                body.flow_control()
+                    .release_capacity(frame.len())
+                    .map_err(std::io::Error::other)?;
+            }
+            if count != PAYLOAD
+                || body
+                    .trailers()
+                    .await
+                    .map_err(std::io::Error::other)?
+                    .and_then(|trailers| trailers.get("x-check").cloned())
+                    .is_none_or(|value| value != "complete")
+            {
+                return Err(std::io::Error::other(
+                    "incomplete response body or trailers",
+                ));
+            }
+            Ok(())
+        };
+        let result = timeout(Duration::from_secs(70), async {
+            tokio::join!(upload, download)
+        })
+        .await;
+        let elapsed = start.elapsed();
+        cancel.cancel();
+        let worker_joined = join_memory_owner(worker, 1).await;
+        drop(sender);
+        let driver_joined = join_memory_owner(driver, 1).await;
+        let tasks = std::mem::take(&mut *origin.tasks.lock().unwrap());
+        let mut origins_joined = true;
+        for task in tasks {
+            origins_joined &= join_memory_owner(task, 1).await;
+        }
+        let passed = matches!(&result, Ok((Ok(()), Ok(()))))
+            && elapsed >= Duration::from_secs(48)
+            && elapsed < Duration::from_secs(49)
+            && origin.received.lock().unwrap().len() == 1
+            && worker_joined
+            && driver_joined
+            && origins_joined;
+        outcomes.push((upstream_h2, passed, elapsed, format!("{result:?}")));
+    }
+    assert!(
+        outcomes.iter().all(|(_, passed, _, _)| *passed),
+        "continuous upload was cut off before its response: {outcomes:?}"
+    );
+}
+#[tokio::test(start_paused = true)]
+async fn h2_response_wait_stays_bounded_after_upload_and_during_backpressure() {
+    let mut outcomes = Vec::new();
+    for upstream_h2 in [true, false] {
+        for (mode, empty) in [
+            (OriginMode::BeforeUpload, false),
+            (OriginMode::AfterUpload, false),
+            (OriginMode::BeforeUpload, true),
+        ] {
+            let (context, origin) = prepared_origin(upstream_h2, false, false, mode);
+            let cancel = CancellationToken::new();
+            let stop = cancel.clone();
+            let (client, mut server) = tokio::io::duplex(8192);
+            let worker = tokio::spawn(async move {
+                context
+                    .serve_h2(&mut server, session(), stop)
+                    .await
+                    .unwrap();
+            });
+            let (mut sender, driver) = wire::client::handshake(client).await.unwrap();
+            let driver = tokio::spawn(driver);
+            let (response, mut body) = sender
+                .send_request(
+                    Request::builder()
+                        .method("POST")
+                        .uri("https://a.test/upload")
+                        .header("content-length", if empty { 0 } else { PAYLOAD })
+                        .body(())
+                        .unwrap(),
+                    empty,
+                )
+                .unwrap();
+            let start = tokio::time::Instant::now();
+            let upload = async {
+                if empty {
+                    return Ok(());
+                }
+                super::h2_body::send_data(&mut body, Bytes::from_static(&[7; PAYLOAD])).await?;
+                body.send_data(Bytes::new(), true)
+                    .map_err(std::io::Error::other)
+            };
+            let download = async {
+                let result = response.await;
+                (result.is_err(), start.elapsed())
+            };
+            let result = timeout(Duration::from_secs(35), async {
+                tokio::join!(upload, download)
+            })
+            .await;
+            cancel.cancel();
+            let worker_joined = join_memory_owner(worker, 1).await;
+            drop(sender);
+            let driver_joined = join_memory_owner(driver, 1).await;
+            let tasks = std::mem::take(&mut *origin.tasks.lock().unwrap());
+            let mut origins_joined = true;
+            for task in tasks {
+                origins_joined &= join_memory_owner(task, 2).await;
+            }
+            let uploaded = !matches!(mode, OriginMode::AfterUpload)
+                || (matches!(&result, Ok((Ok(()), _)))
+                    && origin.received.lock().unwrap().len() == 1);
+            let bounded = matches!(result,
+                Ok((_, (true, elapsed))) if elapsed >= Duration::from_secs(30)
+                    && elapsed < Duration::from_secs(31));
+            outcomes.push((
+                upstream_h2,
+                empty,
+                bounded && uploaded && worker_joined && driver_joined && origins_joined,
+            ));
+        }
+    }
+    assert!(
+        outcomes.iter().all(|(_, _, passed)| *passed),
+        "unbounded response wait: {outcomes:?}"
+    );
+}
+#[tokio::test]
+async fn h2_streams_large_bodies_and_trailers_through_actual_h2_and_h1_alpn() {
+    for upstream_h2 in [true, false] {
+        let (context, origin) = prepared(upstream_h2);
+        let cancel = CancellationToken::new();
+        let stop = cancel.clone();
+        let (client, mut server) = tokio::io::duplex(8192);
+        let worker = tokio::spawn(async move {
+            context
+                .serve_h2(&mut server, session(), stop)
+                .await
+                .unwrap();
+        });
+        let (mut sender, driver) = wire::client::handshake(client).await.unwrap();
+        let driver = tokio::spawn(driver);
+        let request = Request::builder()
+            .method("POST")
+            .uri("https://a.test/upload")
+            .header("content-length", PAYLOAD)
+            .body(())
+            .unwrap();
+        let (response, mut body) = sender.send_request(request, false).unwrap();
+        let upload = async {
+            super::h2_body::send_data(&mut body, Bytes::from(vec![7; PAYLOAD]))
+                .await
+                .unwrap();
+            body.send_data(Bytes::new(), true).unwrap();
+        };
+        let download = async {
+            let response = response.await.unwrap();
+            assert_eq!(response.status(), StatusCode::OK);
+            let mut body = response.into_body();
+            let mut count = 0;
+            while let Some(frame) = body.data().await {
+                let frame = frame.unwrap();
+                assert!(frame.iter().all(|b| *b == 9));
+                count += frame.len();
+                body.flow_control().release_capacity(frame.len()).unwrap();
+            }
+            assert_eq!(count, PAYLOAD);
+            assert_eq!(
+                body.trailers().await.unwrap().unwrap()["x-check"],
+                "complete"
+            );
+        };
+        timeout(Duration::from_secs(5), async {
+            tokio::join!(upload, download);
+        })
+        .await
+        .unwrap();
+        assert_eq!(origin.received.lock().unwrap().len(), 1);
+        assert_eq!(
+            origin.sessions.lock().unwrap()[0].destination,
+            session().destination
+        );
+        cancel.cancel();
+        timeout(Duration::from_secs(1), worker)
+            .await
+            .unwrap()
+            .unwrap();
+        drop(sender);
+        let _ = timeout(Duration::from_secs(1), driver).await.unwrap();
+        origin.join().await;
+    }
+}
+#[test]
+fn https_authority_permission_and_sni_coalescing_are_per_request() {
+    let (context, _) = prepared(true);
+    for (url, expected) in [
+        ("https://a.test/upload", session().destination),
+        (
+            "https://b.test/upload",
+            Destination::domain("b.test", 443).unwrap(),
+        ),
+    ] {
+        let request::Decision::Forward(target) = context
+            .plan(url.parse().unwrap(), session(), Scheme::Https, true)
+            .unwrap()
+        else {
+            panic!("expected forward")
+        };
+        assert_eq!(target.session.destination, expected);
+        assert_eq!(
+            target.session.metadata.original.unwrap().destination,
+            session().destination
+        );
+    }
+    assert!(
+        context
+            .plan(
+                "https://forbidden.test/upload".parse().unwrap(),
+                session(),
+                Scheme::Https,
+                true
+            )
+            .is_err()
+    );
+    let mut wrong_port = session();
+    wrong_port.destination = Destination::Ip("203.0.113.1:8443".parse().unwrap());
+    let request::Decision::Forward(target) = context
+        .plan(
+            "https://a.test/upload".parse().unwrap(),
+            wrong_port,
+            Scheme::Https,
+            true,
+        )
+        .unwrap()
+    else {
+        panic!()
+    };
+    assert_eq!(
+        target.session.destination,
+        Destination::domain("a.test", 443).unwrap()
+    );
+    assert!(target.session.sniffed_domain.is_none());
+}
+#[tokio::test]
+async fn h2_per_request_authority_and_cancellation_do_not_leave_inline_drivers() {
+    for upstream_h2 in [true, false] {
+        let (context, origin) = prepared(upstream_h2);
+        let cancel = CancellationToken::new();
+        let stop = cancel.clone();
+        let (client, mut server) = tokio::io::duplex(8192);
+        let worker = tokio::spawn(async move {
+            context
+                .serve_h2(&mut server, session(), stop)
+                .await
+                .unwrap();
+        });
+        let (mut sender, driver) = wire::client::handshake(client).await.unwrap();
+        let driver = tokio::spawn(driver);
+        let (forbidden, _) = sender
+            .send_request(
+                Request::builder()
+                    .uri("https://forbidden.test/upload")
+                    .body(())
+                    .unwrap(),
+                true,
+            )
+            .unwrap();
+        assert_eq!(
+            timeout(Duration::from_secs(1), forbidden)
+                .await
+                .unwrap()
+                .unwrap()
+                .status(),
+            StatusCode::FORBIDDEN
+        );
+        assert!(origin.sessions.lock().unwrap().is_empty());
+        let (mut held, _held_upload) = sender
+            .send_request(
+                Request::builder()
+                    .method("POST")
+                    .uri("https://b.test/upload")
+                    .header("content-length", PAYLOAD)
+                    .body(())
+                    .unwrap(),
+                false,
+            )
+            .unwrap();
+        tokio::select! {result=&mut held=>panic!("incomplete body unexpectedly completed: {}",result.is_ok()),()=tokio::time::sleep(Duration::from_millis(20))=>{}}
+        cancel.cancel();
+        timeout(Duration::from_secs(1), worker)
+            .await
+            .unwrap()
+            .unwrap();
+        drop(sender);
+        let _ = timeout(Duration::from_secs(1), driver).await.unwrap();
+        // Upstream fixture expects a complete business body; cancellation is
+        // deliberately observed as EOF/reset instead of normal completion.
+        let tasks = std::mem::take(&mut *origin.tasks.lock().unwrap());
+        for task in tasks {
+            let _ = timeout(Duration::from_secs(1), task).await.unwrap();
+        }
+    }
+}
+
+#[tokio::test]
+async fn h2_early_final_h2_and_h1_finish_large_bodies_without_waiting_for_upload() {
+    for upstream_h2 in [true, false] {
+        let (context, origin) = prepared_with(upstream_h2, true);
+        let cancel = CancellationToken::new();
+        let stop = cancel.clone();
+        let (client, mut server) = tokio::io::duplex(8192);
+        let worker = tokio::spawn(async move {
+            context
+                .serve_h2(&mut server, session(), stop)
+                .await
+                .unwrap();
+        });
+        let mut builder = wire::client::Builder::new();
+        builder
+            .initial_window_size(8192)
+            .initial_connection_window_size(16384);
+        let (mut sender, driver) = builder.handshake::<_, Bytes>(client).await.unwrap();
+        let driver = tokio::spawn(driver);
+        let (first, mut upload) = sender
+            .send_request(
+                Request::builder()
+                    .method("POST")
+                    .uri("https://a.test/upload")
+                    .header("content-length", PAYLOAD)
+                    .body(())
+                    .unwrap(),
+                false,
+            )
+            .unwrap();
+        upload
+            .send_data(Bytes::from(vec![7; PAYLOAD / 2]), false)
+            .unwrap();
+        let first = timeout(Duration::from_secs(1), first)
+            .await
+            .unwrap()
+            .unwrap();
+        assert_eq!(first.status(), StatusCode::PAYLOAD_TOO_LARGE);
+        timeout(
+            Duration::from_secs(2),
+            require_early_body(first.into_body()),
+        )
+        .await
+        .unwrap();
+        sender = sender.ready().await.unwrap();
+        let (second, _) = sender
+            .send_request(
+                Request::builder()
+                    .uri("https://b.test/upload")
+                    .body(())
+                    .unwrap(),
+                true,
+            )
+            .unwrap();
+        let second = timeout(Duration::from_secs(1), second)
+            .await
+            .unwrap()
+            .unwrap();
+        assert_eq!(second.status(), StatusCode::PAYLOAD_TOO_LARGE);
+        timeout(
+            Duration::from_secs(2),
+            require_early_body(second.into_body()),
+        )
+        .await
+        .unwrap();
+        assert_eq!(origin.sessions.lock().unwrap().len(), 2);
+        drop(upload);
+        cancel.cancel();
+        timeout(Duration::from_secs(1), worker)
+            .await
+            .unwrap()
+            .unwrap();
+        drop(sender);
+        let _ = timeout(Duration::from_secs(1), driver).await.unwrap();
+        origin.join().await;
+    }
+}
+
+async fn require_early_body(mut body: wire::RecvStream) {
+    let mut bytes = 0;
+    while let Some(frame) = body.data().await {
+        let frame = frame.unwrap();
+        assert!(frame.iter().all(|byte| *byte == 9));
+        bytes += frame.len();
+        // Keep a real downstream window outstanding while the upstream
+        // final response closes its unread request half.
+        tokio::time::sleep(Duration::from_millis(5)).await;
+        body.flow_control().release_capacity(frame.len()).unwrap();
+    }
+    assert_eq!(bytes, PAYLOAD);
+}
+
+#[tokio::test]
+async fn truncated_h2_and_h1_responses_still_reset_downstream() {
+    for upstream_h2 in [true, false] {
+        let (context, origin) = prepared_response(upstream_h2, false, true);
+        let cancel = CancellationToken::new();
+        let stop = cancel.clone();
+        let (client, mut server) = tokio::io::duplex(8192);
+        let worker = tokio::spawn(async move {
+            context
+                .serve_h2(&mut server, session(), stop)
+                .await
+                .unwrap();
+        });
+        let (mut sender, driver) = wire::client::handshake(client).await.unwrap();
+        let driver = tokio::spawn(driver);
+        let (response, _) = sender
+            .send_request(
+                Request::builder()
+                    .uri("https://a.test/upload")
+                    .body(())
+                    .unwrap(),
+                true,
+            )
+            .unwrap();
+        let response = timeout(Duration::from_secs(1), response)
+            .await
+            .unwrap()
+            .unwrap();
+        assert_eq!(response.status(), StatusCode::OK);
+        let mut body = response.into_body();
+        let rejected = timeout(Duration::from_secs(1), async {
+            let mut received = 0;
+            while let Some(frame) = body.data().await {
+                let Ok(frame) = frame else {
+                    return received < PAYLOAD;
+                };
+                received += frame.len();
+                body.flow_control().release_capacity(frame.len()).unwrap();
+            }
+            false
+        })
+        .await
+        .unwrap();
+        assert!(
+            rejected,
+            "truncated response must not become a successful body"
+        );
+        cancel.cancel();
+        timeout(Duration::from_secs(1), worker)
+            .await
+            .unwrap()
+            .unwrap();
+        drop(sender);
+        let _ = timeout(Duration::from_secs(1), driver).await.unwrap();
+        origin.join().await;
+    }
+}
diff --git a/src/http_processing/headers.rs b/src/http_processing/headers.rs
new file mode 100644
index 0000000..65db41d
--- /dev/null
+++ b/src/http_processing/headers.rs
@@ -0,0 +1,267 @@
+//! Ordered header transactions shared by the HTTP/1 and HTTP/2 adapters.
+use super::rules::{HeaderOperation, Phase, Rule, RuleAction, validate_header_value};
+use std::io;
+use url::Url;
+
+pub(crate) type Fields = Vec<(String, String)>;
+pub(crate) const MAX_FIELDS: usize = 100;
+pub(crate) const MAX_BYTES: usize = 32 * 1024;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum Outcome {
+    Unchanged,
+    Changed,
+    RolledBack,
+}
+
+fn invalid() -> io::Error {
+    io::Error::new(io::ErrorKind::InvalidData, "HTTP header rewrite failed")
+}
+
+pub(crate) fn check(fields: &[(String, String)]) -> io::Result<()> {
+    if fields.len() > MAX_FIELDS {
+        return Err(invalid());
+    }
+    let mut size = 0usize;
+    for (name, value) in fields {
+        http::header::HeaderName::from_bytes(name.as_bytes()).map_err(|_| invalid())?;
+        validate_header_value(value).map_err(|_| invalid())?;
+        size = size
+            .checked_add(name.len() + value.len() + 32)
+            .filter(|size| *size <= MAX_BYTES)
+            .ok_or_else(invalid)?;
+    }
+    Ok(())
+}
+
+/// Cross-origin cleaning precedes the transaction: rollback must not restore
+/// credentials belonging to the original authority.
+pub(crate) fn strip_origin_credentials(fields: &mut Fields) {
+    fields.retain(|(name, _)| {
+        !name.eq_ignore_ascii_case("authorization") && !name.eq_ignore_ascii_case("cookie")
+    });
+}
+
+pub(crate) fn apply(rules: &[Rule], original: &Url, phase: Phase, fields: &mut Fields) -> Outcome {
+    if !rules.iter().any(|rule| {
+        matches!(&rule.action, RuleAction::Header { phase: p, .. } if *p == phase)
+            && rule.matches(original)
+    }) {
+        return Outcome::Unchanged;
+    }
+    if check(fields).is_err() {
+        return Outcome::RolledBack;
+    }
+    let mut candidate = fields.clone();
+    let result = (|| {
+        for rule in rules {
+            let RuleAction::Header {
+                phase: rule_phase,
+                header,
+                operation,
+            } = &rule.action
+            else {
+                continue;
+            };
+            if *rule_phase != phase || !rule.matches(original) {
+                continue;
+            }
+            // Connection nominations remain protocol owned even when the
+            // adapter will subsequently remove the Connection field itself.
+            if fields.iter().any(|(name, value)| {
+                name.eq_ignore_ascii_case("connection")
+                    && value
+                        .split(',')
+                        .any(|token| token.trim().eq_ignore_ascii_case(header))
+            }) {
+                return Err(invalid());
+            }
+            match operation {
+                HeaderOperation::Set(value) => {
+                    candidate.retain(|(name, _)| !name.eq_ignore_ascii_case(header));
+                    append(&mut candidate, header, value)?;
+                }
+                HeaderOperation::Add(value) => append(&mut candidate, header, value)?,
+                HeaderOperation::Remove => {
+                    candidate.retain(|(name, _)| !name.eq_ignore_ascii_case(header));
+                }
+                HeaderOperation::Replace(search) => {
+                    for (name, value) in &mut candidate {
+                        if name.eq_ignore_ascii_case(header) {
+                            let replacement = search.apply(value, MAX_BYTES)?;
+                            validate_header_value(&replacement)?;
+                            *value = replacement;
+                        }
+                    }
+                }
+            }
+            check(&candidate)?;
+        }
+        Ok::<_, io::Error>(())
+    })();
+    if result.is_err() {
+        Outcome::RolledBack
+    } else if candidate == *fields {
+        Outcome::Unchanged
+    } else {
+        *fields = candidate;
+        Outcome::Changed
+    }
+}
+
+pub(crate) fn apply_map(
+    rules: &[Rule],
+    original: &Url,
+    phase: Phase,
+    fields: &mut http::HeaderMap,
+) -> Outcome {
+    if !rules.iter().any(|rule| {
+        matches!(&rule.action, RuleAction::Header { phase: p, .. } if *p == phase)
+            && rule.matches(original)
+    }) {
+        return Outcome::Unchanged;
+    }
+    let Some(mut candidate) = from_map(fields) else {
+        return Outcome::RolledBack;
+    };
+    let outcome = apply(rules, original, phase, &mut candidate);
+    if outcome != Outcome::Changed {
+        return outcome;
+    }
+    let Some(converted) = to_map(candidate) else {
+        return Outcome::RolledBack;
+    };
+    *fields = converted;
+    Outcome::Changed
+}
+
+pub(crate) fn to_map(fields: Fields) -> Option<http::HeaderMap> {
+    let mut converted = http::HeaderMap::with_capacity(fields.len());
+    for (name, value) in fields {
+        converted.append(
+            http::header::HeaderName::from_bytes(name.as_bytes()).ok()?,
+            http::header::HeaderValue::from_bytes(value.as_bytes()).ok()?,
+        );
+    }
+    Some(converted)
+}
+
+pub(crate) fn from_map(fields: &http::HeaderMap) -> Option<Fields> {
+    if fields.len() > MAX_FIELDS {
+        return None;
+    }
+    let mut size = 0usize;
+    let mut result = Vec::with_capacity(fields.len());
+    for (name, value) in fields {
+        size = size.checked_add(name.as_str().len() + value.len() + 32)?;
+        if size > MAX_BYTES {
+            return None;
+        }
+        let value = std::str::from_utf8(value.as_bytes()).ok()?;
+        result.push((name.as_str().to_owned(), value.to_owned()));
+    }
+    Some(result)
+}
+
+fn append(fields: &mut Fields, header: &str, value: &str) -> io::Result<()> {
+    let current: usize = fields
+        .iter()
+        .map(|(name, value)| name.len() + value.len() + 32)
+        .sum();
+    if fields.len() >= MAX_FIELDS || current + header.len() + value.len() + 32 > MAX_BYTES {
+        return Err(invalid());
+    }
+    fields.push((header.to_owned(), value.to_owned()));
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::http_processing::rules::RawRule;
+
+    fn rules(yaml: &str) -> Vec<Rule> {
+        let raw: Vec<RawRule> = serde_yaml_ng::from_str(yaml).unwrap();
+        let mut total = 0;
+        raw.into_iter()
+            .map(|raw| Rule::compile(raw, &mut total).unwrap())
+            .collect()
+    }
+
+    #[test]
+    fn header_transaction_preserves_values_order_and_original_selector() {
+        let rules = rules(
+            r#"
+- {url: '^https://old\.example/', action: response-header-add, header: Set-Cookie, value: c=3}
+- {url: '^https://old\.example/', action: response-header-replace, header: Set-Cookie, search: '=', replacement: ':', occurrences: first}
+- {url: '^https://new\.example/', action: response-header-remove, header: Set-Cookie}
+"#,
+        );
+        let mut fields = vec![
+            ("Set-Cookie".into(), "a=1".into()),
+            ("set-cookie".into(), "b=2".into()),
+        ];
+        assert_eq!(
+            apply(
+                &rules,
+                &Url::parse("https://old.example/a").unwrap(),
+                Phase::Response,
+                &mut fields
+            ),
+            Outcome::Changed
+        );
+        assert_eq!(
+            fields
+                .iter()
+                .map(|(_, value)| value.as_str())
+                .collect::<Vec<_>>(),
+            ["a:1", "b:2", "c:3"]
+        );
+    }
+
+    #[test]
+    fn header_failure_rolls_back_without_restoring_cross_origin_credentials() {
+        let rules = rules(
+            r#"
+- {url: '.', action: request-header-add, header: X-New, value: ok}
+- {url: '.', action: request-header-replace, header: X-Test, search: '(.+)', search-mode: regex, replacement: '$1$1'}
+"#,
+        );
+        let mut fields = vec![
+            ("Authorization".into(), "secret".into()),
+            ("X-Test".into(), "a".repeat(20 * 1024)),
+        ];
+        strip_origin_credentials(&mut fields);
+        let before = fields.clone();
+        assert_eq!(
+            apply(
+                &rules,
+                &Url::parse("https://a.example/").unwrap(),
+                Phase::Request,
+                &mut fields
+            ),
+            Outcome::RolledBack
+        );
+        assert_eq!(fields, before);
+    }
+
+    #[test]
+    fn connection_nominations_cannot_be_edited() {
+        let rules =
+            rules("- {url: '.', action: request-header-set, header: X-Hop, value: changed}");
+        let mut fields = vec![
+            ("Connection".into(), "X-Hop".into()),
+            ("X-Hop".into(), "original".into()),
+        ];
+        assert_eq!(
+            apply(
+                &rules,
+                &Url::parse("http://a.example/").unwrap(),
+                Phase::Request,
+                &mut fields
+            ),
+            Outcome::RolledBack
+        );
+        assert_eq!(fields[1].1, "original");
+    }
+}
diff --git a/src/http_processing/io.rs b/src/http_processing/io.rs
new file mode 100644
index 0000000..fa5df27
--- /dev/null
+++ b/src/http_processing/io.rs
@@ -0,0 +1,85 @@
+//! A borrowed stream bridge and bounded prefix replay; neither owns a task.
+use std::{
+    io,
+    pin::Pin,
+    task::{Context, Poll},
+};
+use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+
+pub(crate) struct Replay<S> {
+    prefix: std::io::Cursor<Vec<u8>>,
+    stream: S,
+}
+impl<S> Replay<S> {
+    pub(crate) fn new(prefix: Vec<u8>, stream: S) -> Self {
+        Self {
+            prefix: std::io::Cursor::new(prefix),
+            stream,
+        }
+    }
+}
+impl<S: AsyncRead + Unpin> AsyncRead for Replay<S> {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        target: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        let position = self.prefix.position() as usize;
+        let remaining = self.prefix.get_ref().len().saturating_sub(position);
+        if remaining > 0 && target.remaining() > 0 {
+            let count = remaining.min(target.remaining());
+            target.put_slice(&self.prefix.get_ref()[position..position + count]);
+            if count == remaining {
+                self.prefix = std::io::Cursor::new(Vec::new());
+            } else {
+                self.prefix.set_position((position + count) as u64);
+            }
+            return Poll::Ready(Ok(()));
+        }
+        Pin::new(&mut self.stream).poll_read(cx, target)
+    }
+}
+impl<S: AsyncWrite + Unpin> AsyncWrite for Replay<S> {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buffer: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        Pin::new(&mut self.stream).poll_write(cx, buffer)
+    }
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.stream).poll_flush(cx)
+    }
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.stream).poll_shutdown(cx)
+    }
+}
+
+pub(crate) struct Joined<R, W> {
+    pub(crate) reader: R,
+    pub(crate) writer: W,
+}
+impl<R: AsyncRead + Unpin, W: Unpin> AsyncRead for Joined<R, W> {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        target: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.reader).poll_read(cx, target)
+    }
+}
+impl<R: Unpin, W: AsyncWrite + Unpin> AsyncWrite for Joined<R, W> {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buffer: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        Pin::new(&mut self.writer).poll_write(cx, buffer)
+    }
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.writer).poll_flush(cx)
+    }
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.writer).poll_shutdown(cx)
+    }
+}
diff --git a/src/http_processing/mitm.rs b/src/http_processing/mitm.rs
new file mode 100644
index 0000000..284ee6d
--- /dev/null
+++ b/src/http_processing/mitm.rs
@@ -0,0 +1,344 @@
+//! Selective business TLS termination. Trust installation belongs to the host.
+use serde::{Deserialize, Deserializer, Serialize};
+use std::{collections::BTreeSet, io};
+
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(deny_unknown_fields, rename_all = "kebab-case")]
+pub(crate) struct RawMitm {
+    #[serde(default)]
+    pub(crate) enabled: bool,
+    #[serde(default, deserialize_with = "non_null_vec")]
+    pub(crate) domains: Vec<RawDomain>,
+    #[serde(default, deserialize_with = "non_null_vec")]
+    pub(crate) exclude_domains: Vec<RawDomain>,
+    #[serde(default = "default_ports", deserialize_with = "non_null_vec")]
+    pub(crate) ports: Vec<u16>,
+}
+
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(deny_unknown_fields, rename_all = "kebab-case")]
+pub(crate) struct RawDomain {
+    pub(crate) pattern: String,
+    #[serde(default = "enabled")]
+    pub(crate) enabled: bool,
+}
+
+fn enabled() -> bool {
+    true
+}
+
+fn non_null_vec<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
+where
+    D: Deserializer<'de>,
+    T: Deserialize<'de>,
+{
+    Option::<Vec<T>>::deserialize(deserializer)?
+        .ok_or_else(|| serde::de::Error::custom("MITM sequence must not be null"))
+}
+fn default_ports() -> Vec<u16> {
+    vec![443]
+}
+
+impl Default for RawMitm {
+    fn default() -> Self {
+        Self {
+            enabled: false,
+            domains: Vec::new(),
+            exclude_domains: Vec::new(),
+            ports: default_ports(),
+        }
+    }
+}
+
+fn invalid() -> io::Error {
+    io::Error::new(io::ErrorKind::InvalidInput, "invalid selective TLS policy")
+}
+
+struct Pattern {
+    name: Box<str>,
+    suffix: bool,
+}
+
+impl Pattern {
+    fn compile(raw: &str) -> io::Result<Self> {
+        let (suffix, raw) = raw.strip_prefix("*.").map_or((false, raw), |s| (true, s));
+        if raw.contains('*') || raw.len() > 253 || raw.parse::<std::net::IpAddr>().is_ok() {
+            return Err(invalid());
+        }
+        let name = crate::routing::normalize_domain_name(raw).map_err(|_| invalid())?;
+        if !matches!(
+            rustls::pki_types::ServerName::try_from(name.as_str()),
+            Ok(rustls::pki_types::ServerName::DnsName(_))
+        ) {
+            return Err(invalid());
+        }
+        Ok(Self {
+            name: name.into(),
+            suffix,
+        })
+    }
+
+    fn matches(&self, name: &str) -> bool {
+        if self.suffix {
+            name.strip_suffix(self.name.as_ref())
+                .is_some_and(|prefix| prefix.len() > 1 && prefix.ends_with('.'))
+        } else {
+            name == self.name.as_ref()
+        }
+    }
+}
+
+fn patterns(raw: &[RawDomain]) -> io::Result<Box<[Pattern]>> {
+    let mut seen = BTreeSet::new();
+    let mut output = Vec::with_capacity(raw.len());
+    for entry in raw {
+        let pattern = Pattern::compile(&entry.pattern)?;
+        if !seen.insert((pattern.name.clone(), pattern.suffix)) {
+            return Err(invalid());
+        }
+        if entry.enabled {
+            output.push(pattern);
+        }
+    }
+    Ok(output.into())
+}
+
+impl RawMitm {
+    pub(crate) fn validate_static(&self) -> io::Result<()> {
+        if self.domains.len() > 64
+            || self.exclude_domains.len() > 64
+            || self.ports.len() > 64
+            || self.ports.contains(&0)
+        {
+            return Err(invalid());
+        }
+        let domains = patterns(&self.domains)?;
+        patterns(&self.exclude_domains)?;
+        if self.enabled && (domains.is_empty() || self.ports.is_empty()) {
+            return Err(invalid());
+        }
+        Ok(())
+    }
+}
+
+#[cfg(feature = "inbound-http")]
+mod enabled {
+    use super::super::{HttpContext, Intercept, Scheme, authority::Authority, io::Replay};
+    use super::{Pattern, RawMitm, invalid, patterns};
+    use crate::{
+        http_processing::private_context::CaMaterial,
+        session::StreamSession,
+        tcp_sniffer::{SniffOutcome, SniffProtocol, TcpSniffer},
+    };
+    use std::{io, sync::Arc, time::Duration};
+    use tokio::io::{AsyncRead, AsyncWrite};
+    use tokio_util::sync::CancellationToken;
+    use url::Url;
+
+    pub(in crate::http_processing) struct Mitm {
+        domains: Box<[Pattern]>,
+        exclusions: Box<[Pattern]>,
+        ports: Box<[u16]>,
+        authority: Arc<Authority>,
+    }
+    impl Mitm {
+        pub(in crate::http_processing) fn compile(
+            raw: RawMitm,
+            ca: Option<&CaMaterial>,
+        ) -> io::Result<Option<Arc<Self>>> {
+            raw.validate_static()?;
+            if !raw.enabled {
+                return Ok(None);
+            }
+            let domains = patterns(&raw.domains)?;
+            let exclusions = patterns(&raw.exclude_domains)?;
+            let ca = ca.ok_or_else(invalid)?;
+            ca.validate_size()?;
+            let authority = Authority::load(&ca.certificate, &ca.private_key)?;
+            let mut ports = raw.ports;
+            ports.sort_unstable();
+            ports.dedup();
+            Ok(Some(Arc::new(Self {
+                domains,
+                exclusions,
+                ports: ports.into(),
+                authority,
+            })))
+        }
+        pub(in crate::http_processing) fn identity(&self) -> [u8; 32] {
+            self.authority.identity()
+        }
+        pub(in crate::http_processing) fn candidate_port(&self, port: u16) -> bool {
+            self.ports.binary_search(&port).is_ok()
+        }
+        pub(in crate::http_processing) fn permits(&self, name: &str, port: u16) -> bool {
+            let Ok(name) = crate::routing::normalize_domain_name(name) else {
+                return false;
+            };
+            self.candidate_port(port)
+                && !self.exclusions.iter().any(|p| p.matches(&name))
+                && self.domains.iter().any(|p| p.matches(&name))
+        }
+        pub(in crate::http_processing) fn permits_url(&self, url: &Url) -> bool {
+            url.scheme() == "https"
+                && url
+                    .host_str()
+                    .zip(url.port_or_known_default())
+                    .is_some_and(|(host, port)| self.permits(host, port))
+        }
+    }
+    impl HttpContext {
+        pub(in crate::http_processing) async fn intercept_tls<
+            S: AsyncRead + AsyncWrite + Unpin + Send,
+        >(
+            &self,
+            stream: &mut S,
+            mut session: StreamSession,
+            cancellation: CancellationToken,
+        ) -> io::Result<Intercept> {
+            let Some(policy) = self.policy().mitm() else {
+                return Ok(Intercept::Transparent { prefix: Vec::new() });
+            };
+            if !policy.candidate_port(session.destination.port()) {
+                return Ok(Intercept::Transparent { prefix: Vec::new() });
+            }
+            let mut sniffer = TcpSniffer::with_protocols(vec![SniffProtocol::Tls]);
+            let outcome = tokio::select! {biased;()=cancellation.cancelled()=>return Ok(Intercept::Handled),result=sniffer.sniff(stream)=>result?};
+            let prefix = sniffer.into_buffered();
+            let SniffOutcome::Matched {
+                protocol: SniffProtocol::Tls,
+                domain,
+            } = outcome
+            else {
+                // Includes both genuine ECH and GREASE. An outer cover name
+                // does not authorize decrypting the hidden target.
+                if self.policy().plain_port(session.destination.port())
+                    && prefix.first().is_some_and(u8::is_ascii_uppercase)
+                {
+                    let mut replay = Replay::new(prefix, stream);
+                    Box::pin(self.serve_h1(&mut replay, session, Scheme::Http, cancellation))
+                        .await?;
+                    return Ok(Intercept::Handled);
+                }
+                return Ok(Intercept::Transparent { prefix });
+            };
+            if !policy.permits(&domain, session.destination.port()) {
+                return Ok(Intercept::Transparent { prefix });
+            }
+            session.capture_original();
+            session.sniffed_domain = Some(domain.clone());
+            let config = policy.authority.server_config(&domain)?;
+            let replay = Replay::new(prefix, stream);
+            let operation = async {
+                let mut tls = tokio::time::timeout(
+                    Duration::from_secs(10),
+                    tokio_rustls::TlsAcceptor::from(config).accept_with(replay, |connection| {
+                        connection.set_buffer_limit(Some(32 * 1024))
+                    }),
+                )
+                .await
+                .map_err(|_| {
+                    io::Error::new(io::ErrorKind::TimedOut, "business TLS handshake timed out")
+                })?
+                .map_err(|_| {
+                    io::Error::new(io::ErrorKind::InvalidData, "business TLS handshake failed")
+                })?;
+                // Keep the unused H1 body/relay state out of an H2 session.
+                if tls.get_ref().1.alpn_protocol() == Some(b"h2") {
+                    self.serve_h2(&mut tls, session, cancellation.clone()).await
+                } else {
+                    Box::pin(self.serve_h1(&mut tls, session, Scheme::Https, cancellation.clone()))
+                        .await
+                }
+            };
+            tokio::select! {biased;()=cancellation.cancelled()=>{},result=operation=>result?}
+            Ok(Intercept::Handled)
+        }
+        pub(in crate::http_processing) fn permits_https(&self, url: &Url) -> bool {
+            self.policy()
+                .mitm()
+                .is_some_and(|policy| policy.permits_url(url))
+        }
+    }
+}
+#[cfg(feature = "inbound-http")]
+pub(in crate::http_processing) use enabled::Mitm;
+
+#[cfg(all(test, feature = "inbound-http"))]
+mod tests {
+    use super::{Pattern, RawMitm};
+    #[test]
+    fn selective_domains_do_not_accept_suffix_confusion_or_ip_literals() {
+        let p = Pattern::compile("*.example.com").unwrap();
+        assert!(p.matches("api.example.com"));
+        assert!(!p.matches("example.com"));
+        assert!(!p.matches("notexample.com"));
+        assert!(!p.matches("api.example.com.evil"));
+        for name in ["*", "a*b.example", "127.0.0.1", "[::1]"] {
+            assert!(Pattern::compile(name).is_err());
+        }
+    }
+
+    #[test]
+    fn static_mitm_validation_needs_no_private_material() {
+        let input = r#"enabled: true
+domains:
+  - pattern: API.Example.COM.
+  - pattern: '*.example.net'
+exclude-domains:
+  - pattern: private.example.net
+"#;
+        let policy: RawMitm = serde_yaml_ng::from_str(input).unwrap();
+        policy.validate_static().unwrap();
+        for input in [
+            "domains: null",
+            "ports: null",
+            "exclude-domains: null",
+            "domains: [{pattern: example.com}, {pattern: EXAMPLE.COM., enabled: false}]",
+            "domains: [{pattern: '*.example.com'}, {pattern: '*.EXAMPLE.COM.'}]",
+            "domains: [{pattern: '*', enabled: false}]",
+            "enabled: true\ndomains: [{pattern: example.com, enabled: false}]",
+            "enabled: true\ndomains: [{pattern: example.com}]\nports: []",
+            "certificate: ignored\nprivate-key: ignored",
+        ] {
+            assert!(
+                serde_yaml_ng::from_str::<RawMitm>(input)
+                    .and_then(|raw| raw.validate_static().map_err(serde::de::Error::custom))
+                    .is_err(),
+                "{input}"
+            );
+        }
+    }
+
+    #[test]
+    fn runtime_mitm_binds_private_identity_and_keeps_existing_authority() {
+        use crate::http_processing::private_context::test_material;
+        let settings: RawMitm = serde_yaml_ng::from_str(
+            "enabled: true\ndomains: [{pattern: '*.example.com'}]\nexclude-domains: [{pattern: private.example.com}]",
+        )
+        .unwrap();
+        assert!(super::enabled::Mitm::compile(settings.clone(), None).is_err());
+        assert!(
+            super::enabled::Mitm::compile(RawMitm::default(), None)
+                .unwrap()
+                .is_none()
+        );
+        let first_material = test_material();
+        let first = super::enabled::Mitm::compile(settings.clone(), Some(&first_material))
+            .unwrap()
+            .unwrap();
+        let first_identity = first.identity();
+        assert_eq!(first_identity, first_material.identity().unwrap());
+        assert!(first.permits("api.example.com", 443));
+        assert!(!first.permits("example.com", 443));
+        assert!(!first.permits("private.example.com", 443));
+        assert!(!first.permits("api.example.com", 8443));
+        drop(first_material);
+        let second = super::enabled::Mitm::compile(settings, Some(&test_material()))
+            .unwrap()
+            .unwrap();
+        assert_ne!(first.identity(), second.identity());
+        assert_eq!(first.identity(), first_identity);
+        assert!(first.permits("api.example.com", 443));
+    }
+}
diff --git a/src/http_processing/mod.rs b/src/http_processing/mod.rs
new file mode 100644
index 0000000..5e17069
--- /dev/null
+++ b/src/http_processing/mod.rs
@@ -0,0 +1,102 @@
+//! Business HTTP processing. Core-owned HTTP never enters this module.
+#[cfg(feature = "inbound-http")]
+mod authority;
+pub(crate) mod body;
+mod body_budget;
+pub(crate) mod config;
+pub(crate) mod headers;
+mod mitm;
+mod numeric_input;
+pub(crate) mod private_context;
+pub(crate) mod providers;
+pub(crate) mod rules;
+pub(crate) use config::{MAX_ADDENDUM, Policy};
+#[cfg(feature = "inbound-http")]
+mod h1;
+#[cfg(feature = "inbound-http")]
+pub(crate) mod h1_body;
+#[cfg(feature = "inbound-http")]
+mod h2;
+#[cfg(feature = "inbound-http")]
+mod h2_body;
+#[cfg(feature = "inbound-http")]
+mod h2_h1;
+#[cfg(feature = "inbound-http")]
+mod h2_headers;
+#[cfg(all(test, feature = "inbound-http"))]
+mod h2_tests;
+#[cfg(feature = "inbound-http")]
+pub(crate) mod io;
+#[cfg(feature = "inbound-http")]
+mod request;
+
+#[cfg(feature = "inbound-http")]
+use crate::{dispatch::Dispatcher, security::SecurityContext};
+#[cfg(feature = "inbound-http")]
+use std::sync::Arc;
+
+/// Fixed-session snapshot. The dispatcher itself owns its resource-generation
+/// lease; no second generation owner or policy-to-runtime cycle is introduced.
+#[cfg(feature = "inbound-http")]
+#[derive(Clone)]
+#[doc(hidden)]
+pub struct HttpContext {
+    policy: Arc<Policy>,
+    dispatcher: Arc<dyn Dispatcher>,
+    security: SecurityContext,
+}
+#[cfg(feature = "inbound-http")]
+impl HttpContext {
+    pub(crate) fn new(
+        policy: Arc<Policy>,
+        dispatcher: Arc<dyn Dispatcher>,
+        security: SecurityContext,
+    ) -> Self {
+        Self {
+            policy,
+            dispatcher,
+            security,
+        }
+    }
+    pub(super) fn policy(&self) -> &Policy {
+        &self.policy
+    }
+    pub(crate) fn dispatcher(&self) -> &Arc<dyn Dispatcher> {
+        &self.dispatcher
+    }
+    pub(super) fn security(&self) -> &SecurityContext {
+        &self.security
+    }
+    pub(crate) fn candidate_port(&self, port: u16) -> bool {
+        self.policy.plain_port(port)
+            || self
+                .policy
+                .mitm()
+                .is_some_and(|policy| policy.candidate_port(port))
+    }
+}
+#[cfg(feature = "inbound-http")]
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(crate) enum Scheme {
+    Http,
+    Https,
+}
+#[cfg(feature = "inbound-http")]
+impl Scheme {
+    fn name(self) -> &'static str {
+        match self {
+            Self::Http => "http",
+            Self::Https => "https",
+        }
+    }
+}
+#[cfg(feature = "inbound-http")]
+pub(crate) enum Intercept {
+    Handled,
+    Transparent { prefix: Vec<u8> },
+}
+
+#[cfg(all(test, feature = "inbound-http"))]
+mod h1_boundary_tests;
+#[cfg(all(test, feature = "inbound-http"))]
+mod tests;
diff --git a/src/http_processing/numeric_input.rs b/src/http_processing/numeric_input.rs
new file mode 100644
index 0000000..06bd7d7
--- /dev/null
+++ b/src/http_processing/numeric_input.rs
@@ -0,0 +1,141 @@
+//! Reject YAML numeric scalars whose conversion would change a patch value.
+//! This streaming pass retains the scalar spelling that serde's f64 visitor
+//! otherwise discards. It runs only on bounded configuration inputs.
+use super::config::invalid;
+use std::io;
+use yaml_rust2::{
+    parser::{Event, Parser},
+    scanner::TScalarStyle,
+};
+
+pub(super) fn validate(input: &[u8]) -> io::Result<()> {
+    let input = std::str::from_utf8(input).map_err(|_| invalid())?;
+    let mut parser = Parser::new_from_str(input);
+    let mut depth = 0usize;
+    loop {
+        let (event, _) = parser.next_token().map_err(|_| invalid())?;
+        match event {
+            Event::MappingStart(..) | Event::SequenceStart(..) => {
+                depth += 1;
+                if depth > 64 {
+                    return Err(invalid());
+                }
+            }
+            Event::MappingEnd | Event::SequenceEnd => depth = depth.saturating_sub(1),
+            Event::Scalar(raw, style, _, tag) => {
+                let tag = tag
+                    .as_ref()
+                    .map(|tag| format!("{}{}", tag.handle, tag.suffix))
+                    .filter(|tag| tag != "!");
+                let forced_float = tag.as_deref() == Some("tag:yaml.org,2002:float");
+                if tag.is_some() && !forced_float || !forced_float && style != TScalarStyle::Plain {
+                    continue;
+                }
+                let value = if forced_float {
+                    raw.parse::<f64>()
+                        .ok()
+                        .map(|value| serde_yaml_ng::Value::Number(value.into()))
+                } else {
+                    serde_yaml_ng::from_str(&raw).ok()
+                };
+                if matches!(value, Some(serde_yaml_ng::Value::String(_)))
+                    && decimal_spelling(&raw)
+                    && !(raw.trim_start_matches(['-', '+']).starts_with('0')
+                        && raw.trim_start_matches(['-', '+']).len() > 1
+                        && !raw.contains(['.', 'e', 'E']))
+                {
+                    return Err(invalid());
+                }
+                if let Some(serde_yaml_ng::Value::Number(number)) = value
+                    && (forced_float || !number.is_i64() && !number.is_u64())
+                {
+                    let converted = serde_json::to_string(&number).map_err(|_| invalid())?;
+                    if decimal(&raw).is_none_or(|original| Some(original) != decimal(&converted)) {
+                        return Err(invalid());
+                    }
+                }
+            }
+            Event::StreamEnd => return Ok(()),
+            _ => {}
+        }
+    }
+}
+
+fn decimal(raw: &str) -> Option<(bool, String, i64)> {
+    let raw = raw.replace('_', "");
+    let negative = raw.starts_with('-');
+    let raw = raw.strip_prefix(['-', '+']).unwrap_or(&raw);
+    let (mantissa, exponent) = match raw.find(['e', 'E']) {
+        Some(at) => (&raw[..at], raw[at + 1..].parse::<i64>().ok()?),
+        None => (raw, 0),
+    };
+    let (integer, fraction) = mantissa.split_once('.').unwrap_or((mantissa, ""));
+    if integer.is_empty() && fraction.is_empty()
+        || !integer
+            .bytes()
+            .chain(fraction.bytes())
+            .all(|v| v.is_ascii_digit())
+    {
+        return None;
+    }
+    let mut digits = format!("{integer}{fraction}");
+    let mut exponent = exponent.checked_sub(i64::try_from(fraction.len()).ok()?)?;
+    let leading = digits.bytes().take_while(|v| *v == b'0').count();
+    digits.drain(..leading);
+    if digits.is_empty() {
+        return Some((false, "0".into(), 0));
+    }
+    while digits.ends_with('0') {
+        digits.pop();
+        exponent = exponent.checked_add(1)?;
+    }
+    Some((negative, digits, exponent))
+}
+
+fn decimal_spelling(raw: &str) -> bool {
+    let raw = raw.replace('_', "");
+    let raw = raw.trim_start_matches(['-', '+']);
+    let (mantissa, exponent) = raw.split_once(['e', 'E']).unwrap_or((raw, "0"));
+    let exponent = exponent.strip_prefix(['-', '+']).unwrap_or(exponent);
+    let (integer, fraction) = mantissa.split_once('.').unwrap_or((mantissa, ""));
+    (!integer.is_empty() || !fraction.is_empty())
+        && integer
+            .bytes()
+            .chain(fraction.bytes())
+            .all(|v| v.is_ascii_digit())
+        && !exponent.is_empty()
+        && exponent.bytes().all(|v| v.is_ascii_digit())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn scalar_conversion_never_silently_rounds_patch_numbers() {
+        for input in [
+            "x: 0.5",
+            "x: 1.0",
+            "x: 1e-6",
+            "x: -0.0",
+            "x: 0.12345678901234568",
+            "x: '0.123456789012345678901'",
+            "x: !!str 0.123456789012345678901",
+            "x: !!float \"0.5\"",
+        ] {
+            assert!(validate(input.as_bytes()).is_ok(), "{input}");
+        }
+        for input in [
+            "x: 0.123456789012345678901",
+            "x: 340282366920938463463374607431768211457",
+            "x: .nan",
+            "x: .inf",
+            "x: !!float \"0.123456789012345678901\"",
+            "x: !!float 9007199254740993",
+            "x: 1e309",
+            "x: 1e9223372036854775808",
+            "x: ! 0.123456789012345678901",
+        ] {
+            assert!(validate(input.as_bytes()).is_err(), "{input}");
+        }
+    }
+}
diff --git a/src/http_processing/private_context.rs b/src/http_processing/private_context.rs
new file mode 100644
index 0000000..9dc23f3
--- /dev/null
+++ b/src/http_processing/private_context.rs
@@ -0,0 +1,225 @@
+//! Private host inputs. These values are never part of a shared HTTP document.
+use serde::Deserialize;
+use std::{
+    fmt,
+    fs::OpenOptions,
+    io::{self, Read},
+    path::Path,
+};
+use zeroize::Zeroizing;
+
+pub(crate) const MAX_CA_PEM_BYTES: usize = 32 * 1024;
+// Account for the worst-case JSON spelling before allocating decoded strings.
+pub(crate) const MAX_CA_INPUT: usize = MAX_CA_PEM_BYTES * 12 + 1024;
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+pub(crate) struct CaMaterial {
+    pub(crate) certificate: String,
+    #[serde(deserialize_with = "private_key")]
+    pub(crate) private_key: Zeroizing<String>,
+}
+
+fn private_key<'de, D>(deserializer: D) -> Result<Zeroizing<String>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    String::deserialize(deserializer).map(Zeroizing::new)
+}
+
+impl fmt::Debug for CaMaterial {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("CaMaterial([redacted])")
+    }
+}
+
+fn invalid() -> io::Error {
+    io::Error::new(io::ErrorKind::InvalidInput, "invalid private HTTP CA input")
+}
+
+impl CaMaterial {
+    #[cfg(any(test, all(target_os = "windows", feature = "windows-uwp")))]
+    pub(crate) fn identity(&self) -> io::Result<[u8; 32]> {
+        use rustls::pki_types::{CertificateDer, pem::PemObject as _};
+        use sha2::{Digest as _, Sha256};
+
+        self.validate_size()?;
+        // A snapshot identity names the public certificate, independently of
+        // its PEM spelling or the HTTP adapter. Runtime binding still checks
+        // certificate validity, CA constraints and the matching private key.
+        let mut certificates = CertificateDer::pem_slice_iter(self.certificate.as_bytes());
+        let certificate = certificates
+            .next()
+            .ok_or_else(invalid)?
+            .map_err(|_| invalid())?;
+        if certificate.as_ref().is_empty() || certificates.next().is_some() {
+            return Err(invalid());
+        }
+        Ok(Sha256::digest(certificate.as_ref()).into())
+    }
+
+    pub(crate) fn validate_size(&self) -> io::Result<()> {
+        if self.certificate.is_empty()
+            || self.certificate.len() > MAX_CA_PEM_BYTES
+            || self.private_key.is_empty()
+            || self.private_key.len() > MAX_CA_PEM_BYTES
+        {
+            return Err(invalid());
+        }
+        Ok(())
+    }
+
+    pub(crate) fn from_json_bytes(bytes: &[u8]) -> io::Result<Self> {
+        if bytes.is_empty() || bytes.len() > MAX_CA_INPUT {
+            return Err(invalid());
+        }
+        let material: Self = serde_json::from_slice(bytes).map_err(|_| invalid())?;
+        material.validate_size()?;
+        Ok(material)
+    }
+
+    /// Reads the foreground host's explicit private input, without resolving
+    /// defaults or environment variables. The caller owns the file lifetime.
+    pub(crate) fn read_file(path: &Path) -> io::Result<Self> {
+        if path.as_os_str().is_empty() || path == Path::new("-") {
+            return Err(invalid());
+        }
+        let mut options = OpenOptions::new();
+        options.read(true);
+        #[cfg(unix)]
+        {
+            use std::os::unix::fs::OpenOptionsExt;
+            // Avoid a path check/open race and reject symlinks, FIFOs and devices
+            // without blocking on an attacker-controlled special file.
+            options.custom_flags(libc::O_NOFOLLOW | libc::O_NONBLOCK | libc::O_CLOEXEC);
+        }
+        let mut file = options.open(path)?;
+        let metadata = file.metadata()?;
+        if !metadata.is_file() || metadata.len() == 0 || metadata.len() > MAX_CA_INPUT as u64 {
+            return Err(invalid());
+        }
+        #[cfg(unix)]
+        {
+            use std::os::unix::fs::MetadataExt;
+            // Unix permissions are checked on the opened inode, not the path.
+            if metadata.uid() != unsafe { libc::geteuid() } || metadata.mode() & 0o077 != 0 {
+                return Err(io::Error::new(
+                    io::ErrorKind::PermissionDenied,
+                    "private HTTP CA file permissions are not restricted",
+                ));
+            }
+        }
+        let mut bytes = Zeroizing::new(Vec::with_capacity(metadata.len() as usize));
+        Read::by_ref(&mut file)
+            .take((MAX_CA_INPUT + 1) as u64)
+            .read_to_end(&mut bytes)?;
+        Self::from_json_bytes(&bytes)
+    }
+}
+
+#[cfg(all(test, feature = "inbound-http"))]
+pub(crate) fn test_material() -> CaMaterial {
+    use base64::Engine as _;
+    use rcgen::{BasicConstraints, CertificateParams, IsCa, KeyPair, KeyUsagePurpose};
+    let mut params = CertificateParams::default();
+    params.is_ca = IsCa::Ca(BasicConstraints::Unconstrained);
+    params.key_usages = vec![KeyUsagePurpose::KeyCertSign];
+    let key = KeyPair::generate().unwrap();
+    let certificate = params.self_signed(&key).unwrap();
+    let pem = |label: &str, bytes: &[u8]| {
+        format!(
+            "-----BEGIN {label}-----\n{}\n-----END {label}-----\n",
+            base64::engine::general_purpose::STANDARD.encode(bytes)
+        )
+    };
+    CaMaterial {
+        certificate: pem("CERTIFICATE", certificate.der().as_ref()),
+        private_key: Zeroizing::new(pem("PRIVATE KEY", &key.serialize_der())),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn ca_identity_is_public_der_and_does_not_require_the_http_adapter() {
+        use sha2::{Digest as _, Sha256};
+
+        let mut material = CaMaterial {
+            certificate: "-----BEGIN CERTIFICATE-----\nAQID\n-----END CERTIFICATE-----\n".into(),
+            private_key: Zeroizing::new("private material".into()),
+        };
+        assert_eq!(
+            material.identity().unwrap(),
+            <[u8; 32]>::from(Sha256::digest([1, 2, 3]))
+        );
+        let identity = material.identity().unwrap();
+        material.certificate = material.certificate.replace('\n', "\r\n");
+        material.private_key = Zeroizing::new("different private material".into());
+        assert_eq!(material.identity().unwrap(), identity);
+        material.certificate.push_str(&material.certificate.clone());
+        assert!(material.identity().is_err());
+    }
+
+    #[cfg(feature = "inbound-http")]
+    #[test]
+    fn ca_identity_matches_runtime_authority_without_weakening_key_validation() {
+        let mut material = test_material();
+        let authority =
+            super::super::authority::Authority::load(&material.certificate, &material.private_key)
+                .unwrap();
+        let identity = material.identity().unwrap();
+        assert_eq!(identity, authority.identity());
+        material.private_key = Zeroizing::new("not a private key".into());
+        assert_eq!(identity, material.identity().unwrap());
+        assert!(
+            super::super::authority::Authority::load(&material.certificate, &material.private_key)
+                .is_err()
+        );
+    }
+
+    #[test]
+    fn private_ca_input_is_strict_bounded_and_redacted() {
+        let material = CaMaterial::from_json_bytes(
+            br#"{"certificate":"public certificate","privateKey":"private material"}"#,
+        )
+        .unwrap();
+        assert_eq!(material.certificate, "public certificate");
+        assert_eq!(material.private_key.as_str(), "private material");
+        let debug = format!("{material:?}");
+        assert!(!debug.contains("public certificate"));
+        assert!(!debug.contains("private material"));
+        for bytes in [
+            br#"{"certificate":"public","privateKey":"secret","unknown":true}"#.as_slice(),
+            br#"{"certificate":"public","privateKey":null}"#,
+            br#"{"certificate":"public","privateKey":""}"#,
+        ] {
+            assert!(CaMaterial::from_json_bytes(bytes).is_err());
+        }
+        let oversized = format!(
+            "{{\"certificate\":\"public\",\"privateKey\":\"{}\"}}",
+            "x".repeat(MAX_CA_PEM_BYTES + 1)
+        );
+        assert!(CaMaterial::from_json_bytes(oversized.as_bytes()).is_err());
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn private_ca_file_requires_owner_only_regular_input() {
+        use std::os::unix::fs::{PermissionsExt, symlink};
+        let directory = tempfile::tempdir().unwrap();
+        let path = directory.path().join("ca.json");
+        std::fs::write(&path, br#"{"certificate":"public","privateKey":"secret"}"#).unwrap();
+        std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600)).unwrap();
+        assert!(CaMaterial::read_file(&path).is_ok());
+        std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o640)).unwrap();
+        assert!(CaMaterial::read_file(&path).is_err());
+        std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600)).unwrap();
+        let link = directory.path().join("link.json");
+        symlink(&path, &link).unwrap();
+        assert!(CaMaterial::read_file(&link).is_err());
+        assert!(CaMaterial::read_file(directory.path()).is_err());
+        assert!(CaMaterial::read_file(Path::new("-")).is_err());
+    }
+}
diff --git a/src/http_processing/providers.rs b/src/http_processing/providers.rs
new file mode 100644
index 0000000..be22f21
--- /dev/null
+++ b/src/http_processing/providers.rs
@@ -0,0 +1,197 @@
+//! Named HTTP-rule resources. Remote content never carries local TLS authority.
+#[path = "providers_store.rs"]
+mod store;
+pub(crate) use store::{DownloadContext, SourceContext, Store};
+
+use super::{
+    config::{MAX_ADDENDUM, compile_rule, invalid, nonnull},
+    rules::{MAX_RULES, RawRule},
+};
+use crate::resource::http::{self, HttpOptions};
+use serde::{Deserialize, Deserializer, Serialize};
+use sha2::{Digest, Sha256};
+use std::{
+    collections::{BTreeMap, BTreeSet},
+    io,
+};
+
+fn interval() -> u64 {
+    86400
+}
+fn optional<'de, D: Deserializer<'de>, T: Deserialize<'de>>(
+    deserializer: D,
+) -> Result<Option<T>, D::Error> {
+    nonnull(deserializer).map(Some)
+}
+fn headers<'de, D: Deserializer<'de>>(
+    deserializer: D,
+) -> Result<BTreeMap<String, Vec<String>>, D::Error> {
+    #[derive(Deserialize)]
+    struct Values(#[serde(deserialize_with = "nonnull")] Vec<String>);
+    let map: BTreeMap<String, Values> = nonnull(deserializer)?;
+    Ok(map
+        .into_iter()
+        .map(|(name, values)| (name, values.0))
+        .collect())
+}
+
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(tag = "type", rename_all = "lowercase", deny_unknown_fields)]
+pub(crate) enum ProviderSpec {
+    File {
+        path: String,
+    },
+    Http {
+        url: String,
+        #[serde(
+            default,
+            deserialize_with = "optional",
+            skip_serializing_if = "Option::is_none"
+        )]
+        path: Option<String>,
+        #[serde(default = "interval")]
+        interval: u64,
+        #[serde(default, deserialize_with = "headers")]
+        header: BTreeMap<String, Vec<String>>,
+    },
+    Inline {
+        #[serde(deserialize_with = "nonnull")]
+        payload: Vec<RawRule>,
+    },
+}
+
+impl ProviderSpec {
+    pub(crate) fn validate(&self) -> io::Result<()> {
+        match self {
+            Self::File { path } => validate_path(path),
+            Self::Inline { payload } => validate_rules(payload),
+            Self::Http {
+                url, path, header, ..
+            } => {
+                super::rules::checked_url(url)?;
+                if let Some(path) = path {
+                    validate_path(path)?;
+                }
+                let mut names = BTreeSet::new();
+                if header.len() > 64 {
+                    return Err(invalid());
+                }
+                for (name, values) in header {
+                    if !names.insert(name.to_ascii_lowercase()) || values.len() > 64 {
+                        return Err(invalid());
+                    }
+                    if values.iter().any(|value| {
+                        value
+                            .chars()
+                            .any(|character| character.is_control() && character != '\t')
+                    }) {
+                        return Err(invalid());
+                    }
+                }
+                let options = self.options()?;
+                let mut names_only = options.clone();
+                names_only.headers = header
+                    .keys()
+                    .map(|name| (name.clone(), String::new()))
+                    .collect();
+                http::validate_options(&names_only).map_err(|_| invalid())?;
+                http::parse_url(url, &options).map_err(|_| invalid())?;
+                http::validate_options(&options).map_err(|_| invalid())
+            }
+        }
+    }
+
+    pub(super) fn options(&self) -> io::Result<HttpOptions> {
+        let Self::Http { header, .. } = self else {
+            return Err(invalid());
+        };
+        Ok(HttpOptions {
+            headers: header
+                .iter()
+                .flat_map(|(name, values)| {
+                    values
+                        .iter()
+                        .map(move |value| (name.to_ascii_lowercase(), value.clone()))
+                })
+                .collect(),
+            size_limit: Some(MAX_ADDENDUM as u64),
+            allow_http: true,
+            allow_ip: true,
+            ..Default::default()
+        })
+    }
+
+    pub(super) fn source_identity(&self) -> io::Result<String> {
+        let Self::Http { url, .. } = self else {
+            return Err(invalid());
+        };
+        http::request_identity(url, &self.options()?).map_err(|_| invalid())
+    }
+}
+
+fn validate_path(path: &str) -> io::Result<()> {
+    if path.is_empty() || path.contains('\0') {
+        return Err(invalid());
+    }
+    Ok(())
+}
+
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub(crate) struct Payload {
+    #[serde(rename = "payload", deserialize_with = "nonnull")]
+    rules: Vec<RawRule>,
+    #[serde(skip)]
+    identity: [u8; 32],
+    #[serde(skip)]
+    input_bytes: usize,
+}
+
+impl Payload {
+    pub(crate) fn parse(input: &[u8]) -> io::Result<Self> {
+        if input.len() > MAX_ADDENDUM {
+            return Err(invalid());
+        }
+        crate::http_processing::numeric_input::validate(input)?;
+        let value = crate::config::yaml::parse_with_budget(input, &mut (MAX_ADDENDUM * 4))
+            .map_err(|_| invalid())?;
+        let mut payload: Self = serde_yaml_ng::from_value(value).map_err(|_| invalid())?;
+        payload.input_bytes = input.len();
+        payload.finish()?;
+        Ok(payload)
+    }
+
+    pub(crate) fn finish(&mut self) -> io::Result<()> {
+        validate_rules(&self.rules)?;
+        let encoded = serde_json::to_vec(&self.rules).map_err(|_| invalid())?;
+        self.identity = Sha256::digest(encoded).into();
+        if self.input_bytes == 0 {
+            self.input_bytes = serde_yaml_ng::to_string(self).map_err(|_| invalid())?.len();
+        }
+        if self.input_bytes > MAX_ADDENDUM {
+            return Err(invalid());
+        }
+        Ok(())
+    }
+
+    pub(crate) fn identity(&self) -> [u8; 32] {
+        self.identity
+    }
+    pub(crate) fn rules(&self) -> &[RawRule] {
+        &self.rules
+    }
+    pub(crate) fn input_bytes(&self) -> usize {
+        self.input_bytes
+    }
+}
+
+fn validate_rules(rules: &[RawRule]) -> io::Result<()> {
+    if rules.len() > MAX_RULES {
+        return Err(invalid());
+    }
+    let mut text = 0;
+    for rule in rules {
+        compile_rule(rule.clone(), &mut text)?;
+    }
+    Ok(())
+}
diff --git a/src/http_processing/providers_cache.rs b/src/http_processing/providers_cache.rs
new file mode 100644
index 0000000..5edf627
--- /dev/null
+++ b/src/http_processing/providers_cache.rs
@@ -0,0 +1,406 @@
+//! Source-bound caches, private staging and rollback across a complete update.
+use super::{DownloadContext, check_cancel, unix_time};
+use crate::{
+    http_processing::{
+        config::{MAX_ADDENDUM, invalid},
+        providers::{Payload, ProviderSpec},
+    },
+    resource::http::{self, DownloadOutcome, DownloadRequest},
+};
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+use std::{
+    fs::{self, OpenOptions},
+    io::{self, Read, Write},
+    path::{Path, PathBuf},
+    sync::{
+        Arc,
+        atomic::{AtomicU64, Ordering},
+    },
+};
+use tokio_util::sync::CancellationToken;
+
+static NEXT_STAGE: AtomicU64 = AtomicU64::new(1);
+
+#[derive(Clone)]
+pub(super) struct CacheEntry {
+    pub(super) source: String,
+    pub(super) path: PathBuf,
+    pub(super) payload: Arc<Payload>,
+    pub(super) checked: u64,
+    metadata: Metadata,
+}
+impl CacheEntry {
+    #[cfg(any(test, all(windows, feature = "windows-uwp")))]
+    pub(super) fn adopt(source: String, path: PathBuf, payload: Arc<Payload>) -> Self {
+        let checked = unix_time();
+        Self {
+            source: source.clone(),
+            path,
+            payload,
+            checked,
+            metadata: Metadata {
+                source,
+                hash: [0; 32],
+                etag: None,
+                checked,
+            },
+        }
+    }
+}
+
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+struct Metadata {
+    source: String,
+    hash: [u8; 32],
+    etag: Option<String>,
+    checked: u64,
+}
+
+pub(super) fn metadata_path(path: &Path) -> PathBuf {
+    let mut name = path.as_os_str().to_os_string();
+    name.push(".http-meta");
+    PathBuf::from(name)
+}
+
+pub(super) fn read_bounded(path: &Path, limit: usize) -> io::Result<Vec<u8>> {
+    let mut options = OpenOptions::new();
+    options.read(true);
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::OpenOptionsExt;
+        options.custom_flags(libc::O_NONBLOCK);
+    }
+    let file = options
+        .open(path)
+        .map_err(|_| io::Error::other("HTTP rewrite resource cannot be opened"))?;
+    let metadata = file.metadata().map_err(|_| invalid())?;
+    if !metadata.is_file() || metadata.len() > limit as u64 {
+        return Err(invalid());
+    }
+    let mut input = Vec::new();
+    input
+        .try_reserve_exact(metadata.len() as usize)
+        .map_err(|_| invalid())?;
+    file.take(limit as u64 + 1)
+        .read_to_end(&mut input)
+        .map_err(|_| io::Error::other("HTTP rewrite resource cannot be read"))?;
+    if input.len() > limit {
+        return Err(invalid());
+    }
+    Ok(input)
+}
+
+fn regular_cache(path: &Path) -> bool {
+    fs::symlink_metadata(path)
+        .is_ok_and(|metadata| metadata.is_file() && !metadata.file_type().is_symlink())
+}
+
+pub(super) fn load_cache(path: &Path, source: &str) -> io::Result<Option<CacheEntry>> {
+    if !regular_cache(path) || !regular_cache(&metadata_path(path)) {
+        return Ok(None);
+    }
+    let loaded = (|| -> io::Result<_> {
+        let metadata: Metadata = serde_json::from_slice(&read_bounded(&metadata_path(path), 4096)?)
+            .map_err(|_| invalid())?;
+        if metadata.source != source {
+            return Ok(None);
+        }
+        let input = read_bounded(path, MAX_ADDENDUM)?;
+        let hash: [u8; 32] = Sha256::digest(&input).into();
+        if hash != metadata.hash {
+            return Ok(None);
+        }
+        let payload = Arc::new(Payload::parse(&input)?);
+        Ok(Some(CacheEntry {
+            source: source.into(),
+            path: path.into(),
+            payload,
+            checked: metadata.checked,
+            metadata,
+        }))
+    })();
+    // An invalid disk cache is unavailable, never an implicit empty payload.
+    Ok(loaded.unwrap_or(None))
+}
+
+struct StageDirectory(Option<PathBuf>);
+impl StageDirectory {
+    fn new(parent: &Path) -> io::Result<Self> {
+        fs::create_dir_all(parent)
+            .map_err(|_| io::Error::other("HTTP rewrite cache directory cannot be created"))?;
+        for _ in 0..8 {
+            let id = NEXT_STAGE.fetch_add(1, Ordering::Relaxed);
+            let path = parent.join(format!(".http-rewrite-{}-{id}", std::process::id()));
+            let mut builder = fs::DirBuilder::new();
+            #[cfg(unix)]
+            {
+                use std::os::unix::fs::DirBuilderExt;
+                builder.mode(0o700);
+            }
+            match builder.create(&path) {
+                Ok(()) => return Ok(Self(Some(path))),
+                Err(error) if error.kind() == io::ErrorKind::AlreadyExists => continue,
+                Err(_) => {
+                    return Err(io::Error::other(
+                        "HTTP rewrite staging directory cannot be created",
+                    ));
+                }
+            }
+        }
+        Err(io::Error::other(
+            "HTTP rewrite staging directory is unavailable",
+        ))
+    }
+    fn path(&self) -> &Path {
+        self.0.as_deref().expect("live staging directory")
+    }
+}
+impl Drop for StageDirectory {
+    fn drop(&mut self) {
+        if let Some(path) = &self.0 {
+            let _ = fs::remove_dir_all(path);
+        }
+    }
+}
+
+struct Replacement {
+    temporary: PathBuf,
+    target: PathBuf,
+    backup: Option<PathBuf>,
+    installed: bool,
+}
+pub(super) struct PendingWrite {
+    directory: StageDirectory,
+    replacements: Vec<Replacement>,
+}
+
+pub(super) async fn prepare_download(
+    spec: &ProviderSpec,
+    path: &Path,
+    source: &str,
+    previous: Option<&CacheEntry>,
+    network: &DownloadContext,
+    cancellation: &CancellationToken,
+    remaining: usize,
+) -> io::Result<(CacheEntry, Option<PendingWrite>)> {
+    check_cancel(cancellation)?;
+    let ProviderSpec::Http { url, .. } = spec else {
+        return Err(invalid());
+    };
+    let directory = StageDirectory::new(path.parent().ok_or_else(invalid)?)?;
+    let temporary = directory.path().join("payload");
+    let mut options = spec.options()?;
+    options.size_limit = Some(remaining as u64);
+    let outcome = http::download(DownloadRequest {
+        security: network.security.clone(),
+        dispatcher: network.dispatcher.clone(),
+        url: url.clone(),
+        etag: previous.and_then(|entry| entry.metadata.etag.clone()),
+        temporary_path: temporary.clone(),
+        timeout: http::DEFAULT_DOWNLOAD_TIMEOUT,
+        cancellation: cancellation.clone(),
+        options,
+    })
+    .await
+    .map_err(|_| io::Error::other("HTTP rewrite resource download failed"))?;
+    check_cancel(cancellation)?;
+    let mut replacements = Vec::new();
+    let (payload, metadata) = match outcome {
+        DownloadOutcome::NotModified { .. } => {
+            let previous = previous.ok_or_else(invalid)?;
+            let mut metadata = previous.metadata.clone();
+            metadata.checked = unix_time();
+            (previous.payload.clone(), metadata)
+        }
+        DownloadOutcome::Downloaded { etag, sha256, .. } => {
+            let input = read_bounded(&temporary, remaining)?;
+            let hash: [u8; 32] = Sha256::digest(&input).into();
+            if sha256 != hash {
+                return Err(invalid());
+            }
+            let payload = Arc::new(Payload::parse(&input)?);
+            private_permissions(&temporary)?;
+            replacements.push(Replacement {
+                temporary,
+                target: path.into(),
+                backup: None,
+                installed: false,
+            });
+            (
+                payload,
+                Metadata {
+                    source: source.into(),
+                    hash,
+                    etag,
+                    checked: unix_time(),
+                },
+            )
+        }
+    };
+    let temporary = directory.path().join("metadata");
+    let mut options = OpenOptions::new();
+    options.create_new(true).write(true);
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::OpenOptionsExt;
+        options.mode(0o600);
+    }
+    let mut file = options
+        .open(&temporary)
+        .map_err(|_| io::Error::other("HTTP rewrite metadata cannot be staged"))?;
+    file.write_all(&serde_json::to_vec(&metadata).map_err(|_| invalid())?)
+        .map_err(|_| io::Error::other("HTTP rewrite metadata cannot be written"))?;
+    file.sync_all()
+        .map_err(|_| io::Error::other("HTTP rewrite metadata cannot be flushed"))?;
+    drop(file);
+    replacements.push(Replacement {
+        temporary,
+        target: metadata_path(path),
+        backup: None,
+        installed: false,
+    });
+    let entry = CacheEntry {
+        source: source.into(),
+        path: path.into(),
+        payload,
+        checked: metadata.checked,
+        metadata,
+    };
+    Ok((
+        entry,
+        Some(PendingWrite {
+            directory,
+            replacements,
+        }),
+    ))
+}
+
+fn private_permissions(path: &Path) -> io::Result<()> {
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        fs::set_permissions(path, fs::Permissions::from_mode(0o600))
+            .map_err(|_| io::Error::other("HTTP rewrite cache permissions cannot be set"))?;
+    }
+    #[cfg(not(unix))]
+    let _ = path;
+    Ok(())
+}
+
+pub(super) fn publish(
+    writes: &mut [PendingWrite],
+    cancellation: &CancellationToken,
+) -> io::Result<()> {
+    let result = (|| -> io::Result<()> {
+        for write in writes.iter_mut() {
+            for (index, replacement) in write.replacements.iter_mut().enumerate() {
+                check_cancel(cancellation)?;
+                match fs::symlink_metadata(&replacement.target) {
+                    Ok(metadata) => {
+                        if !metadata.is_file() || metadata.file_type().is_symlink() {
+                            return Err(invalid());
+                        }
+                        let backup = write.directory.path().join(format!("backup-{index}"));
+                        fs::rename(&replacement.target, &backup).map_err(|_| {
+                            io::Error::other("HTTP rewrite cache cannot be staged for replacement")
+                        })?;
+                        replacement.backup = Some(backup);
+                    }
+                    Err(error) if error.kind() == io::ErrorKind::NotFound => (),
+                    Err(_) => {
+                        return Err(io::Error::other("HTTP rewrite cache target is unavailable"));
+                    }
+                }
+                fs::rename(&replacement.temporary, &replacement.target)
+                    .map_err(|_| io::Error::other("HTTP rewrite cache cannot be published"))?;
+                replacement.installed = true;
+            }
+        }
+        check_cancel(cancellation)
+    })();
+    if let Err(error) = result {
+        let mut rollback_failed = false;
+        for write in writes.iter_mut().rev() {
+            for replacement in write.replacements.iter_mut().rev() {
+                if replacement.installed && fs::remove_file(&replacement.target).is_err() {
+                    rollback_failed = true;
+                }
+                if let Some(backup) = &replacement.backup
+                    && fs::rename(backup, &replacement.target).is_err()
+                {
+                    rollback_failed = true;
+                }
+            }
+            if rollback_failed {
+                write.directory.0 = None;
+            }
+        }
+        return if rollback_failed {
+            Err(io::Error::other(
+                "HTTP rewrite cache publication failed; preserved recovery files",
+            ))
+        } else {
+            Err(error)
+        };
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn failed_multi_cache_publication_restores_payload_metadata_and_cleans_staging() {
+        let root = tempfile::tempdir().unwrap();
+        let first = root.path().join("first.yaml");
+        let first_meta = metadata_path(&first);
+        fs::write(&first, b"previous payload").unwrap();
+        fs::write(&first_meta, b"previous metadata").unwrap();
+        let blocked = root.path().join("second.yaml");
+        fs::create_dir(&blocked).unwrap();
+        let directory = StageDirectory::new(root.path()).unwrap();
+        let input = directory.path().join("new-payload");
+        let metadata = directory.path().join("new-metadata");
+        fs::write(&input, b"candidate payload").unwrap();
+        fs::write(&metadata, b"candidate metadata").unwrap();
+        let first_write = PendingWrite {
+            directory,
+            replacements: vec![
+                Replacement {
+                    temporary: input,
+                    target: first.clone(),
+                    backup: None,
+                    installed: false,
+                },
+                Replacement {
+                    temporary: metadata,
+                    target: first_meta.clone(),
+                    backup: None,
+                    installed: false,
+                },
+            ],
+        };
+        let directory = StageDirectory::new(root.path()).unwrap();
+        let input = directory.path().join("new-payload");
+        fs::write(&input, b"candidate second").unwrap();
+        let second_write = PendingWrite {
+            directory,
+            replacements: vec![Replacement {
+                temporary: input,
+                target: blocked.clone(),
+                backup: None,
+                installed: false,
+            }],
+        };
+        let mut writes = vec![first_write, second_write];
+        assert!(publish(&mut writes, &CancellationToken::new()).is_err());
+        assert_eq!(fs::read(&first).unwrap(), b"previous payload");
+        assert_eq!(fs::read(&first_meta).unwrap(), b"previous metadata");
+        assert!(blocked.is_dir());
+        drop(writes);
+        assert_eq!(fs::read_dir(root.path()).unwrap().count(), 3);
+    }
+}
diff --git a/src/http_processing/providers_store.rs b/src/http_processing/providers_store.rs
new file mode 100644
index 0000000..4f29fbf
--- /dev/null
+++ b/src/http_processing/providers_store.rs
@@ -0,0 +1,509 @@
+//! One-shot preparation and immutable publication of complete HTTP candidates.
+#[path = "providers_cache.rs"]
+mod cache;
+use super::{Payload, ProviderSpec};
+use crate::{
+    dispatch::Dispatcher,
+    http_processing::config::{Document, PolicyCandidate, invalid},
+    resource::paths::{Access, ProviderPaths},
+    security::SecurityContext,
+};
+use cache::{CacheEntry, PendingWrite, load_cache, prepare_download, publish};
+use sha2::{Digest, Sha256};
+use std::{
+    collections::{BTreeMap, BTreeSet},
+    io,
+    path::{Component, Path, PathBuf},
+    sync::Arc,
+    time::{Duration, Instant, SystemTime, UNIX_EPOCH},
+};
+use tokio_util::sync::CancellationToken;
+
+#[derive(Clone, Default)]
+pub(crate) struct SourceContext {
+    pub(crate) base_dir: Option<PathBuf>,
+    pub(crate) data_dir: Option<PathBuf>,
+    pub(crate) config_path: Option<PathBuf>,
+    pub(crate) resource_paths: Arc<ProviderPaths>,
+}
+
+pub(crate) struct DownloadContext {
+    pub(crate) dispatcher: Arc<dyn Dispatcher>,
+    pub(crate) security: SecurityContext,
+}
+
+impl SourceContext {
+    pub(crate) fn identity(&self) -> [u8; 32] {
+        let mut hash = Sha256::new();
+        for path in [&self.base_dir, &self.data_dir] {
+            if let Some(path) = path {
+                let bytes = path.as_os_str().as_encoded_bytes();
+                hash.update([1]);
+                hash.update((bytes.len() as u64).to_be_bytes());
+                hash.update(bytes);
+            } else {
+                hash.update([0]);
+            }
+        }
+        hash.finalize().into()
+    }
+
+    fn preparation_identity(&self) -> [u8; 32] {
+        let mut hash = Sha256::new();
+        hash.update(self.identity());
+        if let Some(path) = &self.config_path {
+            let bytes = path.as_os_str().as_encoded_bytes();
+            hash.update([1]);
+            hash.update((bytes.len() as u64).to_be_bytes());
+            hash.update(bytes);
+        } else {
+            hash.update([0]);
+        }
+        for (path, private) in self.resource_paths.reserved_inputs() {
+            let bytes = path.as_os_str().as_encoded_bytes();
+            hash.update([u8::from(private)]);
+            hash.update((bytes.len() as u64).to_be_bytes());
+            hash.update(bytes);
+        }
+        hash.finalize().into()
+    }
+}
+
+struct Prepared {
+    document: [u8; 32],
+    context: SourceContext,
+    candidate: Arc<PolicyCandidate>,
+}
+
+#[derive(Default)]
+pub(crate) struct Store {
+    entries: BTreeMap<String, CacheEntry>,
+    prepared: Option<Prepared>,
+    retry_after: Option<Instant>,
+    notification: Arc<tokio::sync::Notify>,
+}
+
+impl Store {
+    pub(crate) fn new() -> Self {
+        Self::default()
+    }
+
+    pub(crate) fn notification(&self) -> Arc<tokio::sync::Notify> {
+        self.notification.clone()
+    }
+
+    /// Public refresh/test payloads supply locations, not the foreground's
+    /// private input paths. Keep those inputs protected across such requests.
+    #[cfg(any(feature = "invoke", test))]
+    pub(crate) fn inherit_inputs(&self, context: &mut SourceContext) {
+        if let Some(prepared) = &self.prepared {
+            context.config_path = prepared.context.config_path.clone();
+            context.resource_paths = prepared.context.resource_paths.clone();
+        }
+    }
+
+    /// Restore actual content from a protected snapshot without touching its
+    /// former sources or claiming that a disk validator has been checked.
+    #[cfg(any(test, all(windows, feature = "windows-uwp")))]
+    pub(crate) fn adopt(
+        &mut self,
+        candidate: Arc<PolicyCandidate>,
+        context: &SourceContext,
+    ) -> io::Result<()> {
+        if candidate
+            .source_identity
+            .is_some_and(|identity| identity != context.identity())
+        {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "HTTP snapshot source context does not match",
+            ));
+        }
+        let document = &candidate.document;
+        let paths = resolve_paths(document, context, false)?;
+        let mut entries = BTreeMap::new();
+        for name in document.active_provider_names() {
+            let spec = &document.providers[name];
+            if matches!(spec, ProviderSpec::Http { .. }) {
+                let payload = candidate.payloads.get(name).cloned().ok_or_else(invalid)?;
+                entries.insert(
+                    name.to_owned(),
+                    CacheEntry::adopt(spec.source_identity()?, paths[name].clone(), payload),
+                );
+            }
+        }
+        self.entries = entries;
+        self.prepared = Some(Prepared {
+            document: document.identity(),
+            context: context.clone(),
+            candidate,
+        });
+        self.retry_after = None;
+        self.notification.notify_one();
+        Ok(())
+    }
+
+    /// No disk or network I/O; only return the exact already prepared document
+    /// under the same host-provided path context.
+    pub(crate) fn prepared(
+        &self,
+        document: &Arc<Document>,
+        context: &SourceContext,
+    ) -> io::Result<Option<Arc<PolicyCandidate>>> {
+        Ok(self
+            .prepared
+            .as_ref()
+            .filter(|ready| {
+                ready.document == document.identity()
+                    && ready.context.preparation_identity() == context.preparation_identity()
+            })
+            .map(|ready| ready.candidate.clone()))
+    }
+
+    pub(crate) async fn prepare(
+        &mut self,
+        document: Arc<Document>,
+        context: &SourceContext,
+        network: Option<&DownloadContext>,
+        cancellation: &CancellationToken,
+        force_refresh: bool,
+    ) -> io::Result<Arc<PolicyCandidate>> {
+        check_cancel(cancellation)?;
+        let paths = resolve_paths(&document, context, true)?;
+        if force_refresh {
+            self.retry_after = Some(Instant::now() + Duration::from_secs(60));
+        }
+        let mut contents = BTreeMap::new();
+        let mut entries = BTreeMap::new();
+        let mut writes: Vec<PendingWrite> = Vec::new();
+        let mut input_bytes = document.input_bytes;
+        for name in document.active_provider_names() {
+            check_cancel(cancellation)?;
+            match &document.providers[name] {
+                ProviderSpec::Inline { .. } => (),
+                ProviderSpec::File { .. } => {
+                    let input = cache::read_bounded(
+                        &paths[name],
+                        crate::http_processing::MAX_ADDENDUM.saturating_sub(input_bytes),
+                    )?;
+                    contents.insert(name.to_owned(), Arc::new(Payload::parse(&input)?));
+                }
+                spec @ ProviderSpec::Http { .. } => {
+                    let path = &paths[name];
+                    let source = spec.source_identity()?;
+                    let memory = self
+                        .entries
+                        .get(name)
+                        .filter(|entry| entry.source == source && entry.path == *path)
+                        .cloned();
+                    let cached = if force_refresh || memory.is_none() {
+                        load_cache(path, &source)?
+                    } else {
+                        memory
+                    };
+                    let (entry, write) = match cached {
+                        Some(entry) if !force_refresh => (entry, None),
+                        cached => {
+                            let network = network.ok_or_else(|| {
+                                io::Error::new(
+                                    io::ErrorKind::NotConnected,
+                                    "HTTP rewrite resource requires a download context",
+                                )
+                            })?;
+                            prepare_download(
+                                spec,
+                                path,
+                                &source,
+                                cached.as_ref(),
+                                network,
+                                cancellation,
+                                crate::http_processing::MAX_ADDENDUM.saturating_sub(input_bytes),
+                            )
+                            .await?
+                        }
+                    };
+                    contents.insert(name.to_owned(), entry.payload.clone());
+                    entries.insert(name.to_owned(), entry);
+                    if let Some(write) = write {
+                        writes.push(write);
+                    }
+                }
+            }
+            if let Some(payload) = contents.get(name) {
+                input_bytes = input_bytes
+                    .checked_add(payload.input_bytes())
+                    .ok_or_else(invalid)?;
+                if input_bytes > crate::http_processing::MAX_ADDENDUM {
+                    return Err(invalid());
+                }
+            }
+        }
+        check_cancel(cancellation)?;
+        let candidate = document.compile(&contents)?.bind_source(context.identity());
+        check_cancel(cancellation)?;
+        // No file, metadata, in-memory entry or pending policy is published
+        // before the entire candidate has compiled within aggregate limits.
+        publish(&mut writes, cancellation)?;
+        self.entries = entries;
+        self.prepared = Some(Prepared {
+            document: document.identity(),
+            context: context.clone(),
+            candidate: candidate.clone(),
+        });
+        self.retry_after = None;
+        self.notification.notify_one();
+        Ok(candidate)
+    }
+
+    /// Only HTTP sources have automatic refresh. File sources are deliberately
+    /// not watched. A failed automatic refresh backs off without a busy loop.
+    pub(crate) fn next_due(&self) -> Option<Duration> {
+        let prepared = self.prepared.as_ref()?;
+        let now = unix_time();
+        let due = prepared
+            .candidate
+            .document
+            .active_provider_names()
+            .filter_map(|name| {
+                let ProviderSpec::Http { interval, .. } =
+                    prepared.candidate.document.providers[name]
+                else {
+                    return None;
+                };
+                if interval == 0 {
+                    return None;
+                }
+                let checked = self.entries.get(name)?.checked;
+                Some(Duration::from_secs(
+                    checked.saturating_add(interval).saturating_sub(now),
+                ))
+            })
+            .min()?;
+        Some(self.retry_after.map_or(due, |retry| {
+            due.max(retry.saturating_duration_since(Instant::now()))
+        }))
+    }
+
+    /// A periodic pass refreshes only due HTTP sources. It must not silently
+    /// reread file sources or refresh sources whose interval is zero.
+    pub(crate) async fn refresh_due(
+        &mut self,
+        network: &DownloadContext,
+        cancellation: &CancellationToken,
+    ) -> io::Result<Option<Arc<PolicyCandidate>>> {
+        check_cancel(cancellation)?;
+        if self.next_due().is_none_or(|delay| !delay.is_zero()) {
+            return Ok(None);
+        }
+        let prepared = self.prepared.as_ref().ok_or_else(invalid)?;
+        let document = prepared.candidate.document.clone();
+        let context = prepared.context.clone();
+        self.retry_after = Some(Instant::now() + Duration::from_secs(60));
+        resolve_paths(&document, &context, true)?;
+        let mut contents = prepared.candidate.payloads.clone();
+        let mut entries = self.entries.clone();
+        let mut writes = Vec::new();
+        let now = unix_time();
+        for name in document.active_provider_names() {
+            let spec = &document.providers[name];
+            let ProviderSpec::Http { interval, .. } = spec else {
+                continue;
+            };
+            let previous = entries.get(name).ok_or_else(invalid)?;
+            if *interval == 0 || previous.checked.saturating_add(*interval) > now {
+                continue;
+            }
+            let other_bytes = contents
+                .iter()
+                .filter(|(key, _)| key.as_str() != name)
+                .try_fold(document.input_bytes, |total, (_, payload)| {
+                    total.checked_add(payload.input_bytes()).ok_or_else(invalid)
+                })?;
+            let remaining = crate::http_processing::MAX_ADDENDUM
+                .checked_sub(other_bytes)
+                .ok_or_else(invalid)?;
+            let cached = load_cache(&previous.path, &previous.source)?;
+            let (entry, write) = prepare_download(
+                spec,
+                &previous.path,
+                &previous.source,
+                cached.as_ref(),
+                network,
+                cancellation,
+                remaining,
+            )
+            .await?;
+            contents.insert(name.to_owned(), entry.payload.clone());
+            entries.insert(name.to_owned(), entry);
+            if let Some(write) = write {
+                writes.push(write);
+            }
+        }
+        let candidate = document.compile(&contents)?.bind_source(context.identity());
+        check_cancel(cancellation)?;
+        publish(&mut writes, cancellation)?;
+        self.entries = entries;
+        self.prepared = Some(Prepared {
+            document: document.identity(),
+            context,
+            candidate: candidate.clone(),
+        });
+        self.retry_after = None;
+        self.notification.notify_one();
+        Ok(Some(candidate))
+    }
+}
+
+pub(super) fn unix_time() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_secs()
+}
+pub(super) fn check_cancel(cancellation: &CancellationToken) -> io::Result<()> {
+    if cancellation.is_cancelled() {
+        return Err(io::ErrorKind::Interrupted.into());
+    }
+    Ok(())
+}
+
+fn resolve_paths(
+    document: &Document,
+    context: &SourceContext,
+    canonical: bool,
+) -> io::Result<BTreeMap<String, PathBuf>> {
+    let active: BTreeSet<_> = document.active_provider_names().collect();
+    let mut files = BTreeSet::new();
+    if let Some(path) = &context.config_path {
+        let path = normalize(path)?;
+        files.insert(if canonical {
+            std::fs::canonicalize(&path).unwrap_or(path)
+        } else {
+            path
+        });
+    }
+    let mut paths = BTreeMap::new();
+    let mut caches = Vec::new();
+    for (name, spec) in &document.providers {
+        let required = active.contains(name.as_str());
+        match spec {
+            ProviderSpec::Inline { .. } => (),
+            ProviderSpec::File { path } => {
+                if let Some(path) = resolve(path, context.base_dir.as_deref(), required)? {
+                    context.resource_paths.check_reserved(
+                        &path,
+                        Access::FileRead,
+                        canonical && required,
+                    )?;
+                    files.insert(if canonical && required {
+                        std::fs::canonicalize(&path).unwrap_or_else(|_| path.clone())
+                    } else {
+                        path.clone()
+                    });
+                    paths.insert(name.clone(), path);
+                }
+            }
+            ProviderSpec::Http { path, .. } => {
+                let generated;
+                let path = if let Some(path) = path {
+                    path.as_str()
+                } else {
+                    generated = format!(
+                        "http-rewrite/{}.yaml",
+                        spec.source_identity()?
+                            .trim_start_matches("request-sha256:")
+                    );
+                    generated.as_str()
+                };
+                if let Some(path) = resolve(path, context.data_dir.as_deref(), required)? {
+                    let path = if canonical && required {
+                        canonical_target(&path)?
+                    } else {
+                        path
+                    };
+                    for target in [&path, &cache::metadata_path(&path)] {
+                        context.resource_paths.check_reserved(
+                            target,
+                            Access::CacheWrite,
+                            canonical && required,
+                        )?;
+                    }
+                    caches.push(path.clone());
+                    paths.insert(name.clone(), path);
+                }
+            }
+        }
+    }
+    for path in caches {
+        if !files.insert(path.clone()) || !files.insert(cache::metadata_path(&path)) {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "HTTP rewrite resource paths overlap",
+            ));
+        }
+    }
+    Ok(paths)
+}
+
+fn resolve(raw: &str, base: Option<&Path>, required: bool) -> io::Result<Option<PathBuf>> {
+    let path = Path::new(raw);
+    if path.is_absolute() {
+        return normalize(path).map(Some);
+    }
+    if let Some(base) = base {
+        return normalize(&base.join(path)).map(Some);
+    }
+    if required {
+        Err(io::Error::new(
+            io::ErrorKind::InvalidInput,
+            "relative HTTP resource requires an explicit source directory",
+        ))
+    } else {
+        Ok(None)
+    }
+}
+
+fn normalize(path: &Path) -> io::Result<PathBuf> {
+    if !path.is_absolute() {
+        return Err(invalid());
+    }
+    let mut result = PathBuf::new();
+    for part in path.components() {
+        match part {
+            Component::CurDir => (),
+            Component::ParentDir => {
+                if !result.pop() {
+                    return Err(invalid());
+                }
+            }
+            component => result.push(component.as_os_str()),
+        }
+    }
+    Ok(result)
+}
+
+// Resolve active cache aliases before comparing writable caches against source
+// files. Disabled and unreferenced declarations never call this function.
+fn canonical_target(path: &Path) -> io::Result<PathBuf> {
+    let mut ancestor = path;
+    let mut missing = Vec::new();
+    loop {
+        match std::fs::canonicalize(ancestor) {
+            Ok(mut canonical) => {
+                for component in missing.iter().rev() {
+                    canonical.push(component);
+                }
+                return Ok(canonical);
+            }
+            Err(error) if error.kind() == io::ErrorKind::NotFound => {
+                missing.push(ancestor.file_name().ok_or_else(invalid)?.to_os_string());
+                ancestor = ancestor.parent().ok_or_else(invalid)?;
+            }
+            Err(_) => return Err(io::Error::other("HTTP rewrite cache path is unavailable")),
+        }
+    }
+}
+
+#[cfg(test)]
+#[path = "providers_store_tests.rs"]
+mod tests;
diff --git a/src/http_processing/providers_store_tests.rs b/src/http_processing/providers_store_tests.rs
new file mode 100644
index 0000000..a8e8cd9
--- /dev/null
+++ b/src/http_processing/providers_store_tests.rs
@@ -0,0 +1,414 @@
+//! Resource transactions use in-memory HTTP streams, never host listeners.
+use super::*;
+use crate::{
+    dispatch::{BoxStream, DatagramTransport, DispatchError},
+    http_processing::config::PolicyCandidate,
+    session::{DatagramSession, StreamSession},
+};
+use async_trait::async_trait;
+use std::{
+    collections::VecDeque,
+    sync::{
+        Mutex,
+        atomic::{AtomicUsize, Ordering},
+    },
+};
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+struct Responses {
+    responses: Mutex<VecDeque<Vec<u8>>>,
+    calls: AtomicUsize,
+    requests: Arc<Mutex<Vec<Vec<u8>>>>,
+}
+impl Responses {
+    fn new(responses: impl IntoIterator<Item = Vec<u8>>) -> Arc<Self> {
+        Arc::new(Self {
+            responses: Mutex::new(responses.into_iter().collect()),
+            calls: AtomicUsize::new(0),
+            requests: Arc::new(Mutex::new(Vec::new())),
+        })
+    }
+}
+#[async_trait]
+impl Dispatcher for Responses {
+    async fn connect_tcp(&self, _: StreamSession) -> Result<BoxStream, DispatchError> {
+        self.calls.fetch_add(1, Ordering::Relaxed);
+        let response = self
+            .responses
+            .lock()
+            .unwrap()
+            .pop_front()
+            .ok_or(DispatchError::NotAllowed)?;
+        let requests = self.requests.clone();
+        let (client, mut peer) = tokio::io::duplex(16 * 1024);
+        tokio::spawn(async move {
+            let mut request = Vec::new();
+            let mut byte = [0];
+            while peer.read_exact(&mut byte).await.is_ok() {
+                request.push(byte[0]);
+                if request.ends_with(b"\r\n\r\n") {
+                    break;
+                }
+            }
+            requests.lock().unwrap().push(request);
+            let _ = peer.write_all(&response).await;
+            let _ = peer.shutdown().await;
+        });
+        Ok(Box::new(client))
+    }
+    async fn open_datagram(
+        &self,
+        _: DatagramSession,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        Err(DispatchError::NotAllowed)
+    }
+}
+fn response(status: u16, body: &str) -> Vec<u8> {
+    format!(
+        "HTTP/1.1 {status} fixture\r\nETag: \"fixture\"\r\nContent-Length: {}\r\n\r\n{body}",
+        body.len()
+    )
+    .into_bytes()
+}
+fn document(authorization: &str) -> Arc<Document> {
+    Document::parse(&format!("rewrite-providers:\n  remote:\n    type: http\n    url: http://rules.example.test/rules.yaml\n    path: remote.yaml\n    header: {{Authorization: ['{authorization}']}}\nrewrite: {{enabled: true, rules: [{{rule-set: remote}}]}}\n")).unwrap()
+}
+fn document_with_cache(path: &Path) -> Arc<Document> {
+    let quoted = serde_yaml_ng::to_string(&path.to_string_lossy().as_ref()).unwrap();
+    Document::parse(&format!(
+        "rewrite-providers:\n  remote:\n    type: http\n    url: http://rules.example.test/rules.yaml\n    path: {}\nrewrite: {{enabled: true, rules: [{{rule-set: remote}}]}}\n",
+        quoted.trim_end()
+    ))
+    .unwrap()
+}
+fn network(dispatcher: Arc<Responses>) -> DownloadContext {
+    DownloadContext {
+        dispatcher,
+        security: SecurityContext::new(),
+    }
+}
+
+#[tokio::test]
+async fn http_cache_body_and_metadata_cannot_overwrite_foreground_inputs() {
+    for private in [false, true] {
+        for metadata in [false, true] {
+            let directory = tempfile::tempdir().unwrap();
+            let body = directory
+                .path()
+                .join(if private { "ca.pem" } else { "config.yaml" });
+            let input = if metadata {
+                cache::metadata_path(&body)
+            } else {
+                body.clone()
+            };
+            std::fs::write(&input, b"original foreground input").unwrap();
+            let mut paths = ProviderPaths::default();
+            paths.reserve_inputs([(input.clone(), private)]);
+            let context = SourceContext {
+                data_dir: Some(directory.path().into()),
+                resource_paths: Arc::new(paths),
+                ..Default::default()
+            };
+            let dispatcher = Responses::new([response(200, "payload: []")]);
+            let network = network(dispatcher.clone());
+            let document = document_with_cache(&body);
+            let mut store = Store::new();
+            let error = store
+                .prepare(
+                    document.clone(),
+                    &context,
+                    Some(&network),
+                    &CancellationToken::new(),
+                    false,
+                )
+                .await
+                .err()
+                .unwrap();
+            assert_eq!(error.kind(), io::ErrorKind::PermissionDenied);
+            assert_eq!(dispatcher.calls.load(Ordering::Relaxed), 0);
+            assert_eq!(std::fs::read(&input).unwrap(), b"original foreground input");
+            assert_eq!(std::fs::read_dir(directory.path()).unwrap().count(), 1);
+            assert!(store.prepared(&document, &context).unwrap().is_none());
+        }
+    }
+}
+
+#[tokio::test]
+async fn http_file_resources_keep_public_reads_but_reject_private_inputs() {
+    for private in [false, true] {
+        let directory = tempfile::tempdir().unwrap();
+        let input = directory.path().join("input.yaml");
+        std::fs::write(&input, b"payload: []").unwrap();
+        let mut paths = ProviderPaths::default();
+        paths.reserve_inputs([(input.clone(), private)]);
+        let context = SourceContext {
+            base_dir: Some(directory.path().into()),
+            resource_paths: Arc::new(paths),
+            ..Default::default()
+        };
+        let document = Document::parse("rewrite-providers: {local: {type: file, path: input.yaml}}\nrewrite: {enabled: true, rules: [{rule-set: local}]}\n").unwrap();
+        let mut store = Store::new();
+        let result = store
+            .prepare(document, &context, None, &CancellationToken::new(), false)
+            .await;
+        if private {
+            assert_eq!(
+                result.err().unwrap().kind(),
+                io::ErrorKind::PermissionDenied
+            );
+        } else {
+            assert!(result.is_ok());
+        }
+        assert_eq!(std::fs::read(&input).unwrap(), b"payload: []");
+    }
+}
+
+#[tokio::test]
+async fn absolute_http_cache_paths_work_without_borrowing_another_input_context() {
+    let directory = tempfile::tempdir().unwrap();
+    let external = tempfile::tempdir().unwrap();
+    let input = directory.path().join("config.yaml");
+    std::fs::write(&input, b"original foreground input").unwrap();
+    let mut paths = ProviderPaths::default();
+    paths.reserve_inputs([(input.clone(), false)]);
+    let context = SourceContext {
+        data_dir: Some(directory.path().into()),
+        resource_paths: Arc::new(paths),
+        ..Default::default()
+    };
+    let body = external.path().join("remote.yaml");
+    let document = document_with_cache(&body);
+    let dispatcher = Responses::new([response(200, "payload: []")]);
+    let network = network(dispatcher.clone());
+    let mut store = Store::new();
+    let candidate = store
+        .prepare(
+            document.clone(),
+            &context,
+            Some(&network),
+            &CancellationToken::new(),
+            false,
+        )
+        .await
+        .unwrap();
+    assert!(body.is_file());
+    assert!(cache::metadata_path(&body).is_file());
+    assert!(store.prepared(&document, &context).unwrap().is_some());
+
+    let mut changed = context.clone();
+    let mut paths = ProviderPaths::default();
+    paths.reserve_inputs([(body.clone(), false)]);
+    changed.resource_paths = Arc::new(paths);
+    // The location stays the same for live-update compatibility. Its protected
+    // inputs still distinguish prepared candidates and snapshot adoption.
+    assert_eq!(context.identity(), changed.identity());
+    assert!(store.prepared(&document, &changed).unwrap().is_none());
+    assert!(Store::new().adopt(candidate, &changed).is_err());
+    changed = context.clone();
+    changed.config_path = Some(input.clone());
+    assert!(store.prepared(&document, &changed).unwrap().is_none());
+
+    let mut refresh = SourceContext {
+        data_dir: context.data_dir.clone(),
+        ..Default::default()
+    };
+    store.inherit_inputs(&mut refresh);
+    let error = store
+        .prepare(
+            document_with_cache(&input),
+            &refresh,
+            Some(&network),
+            &CancellationToken::new(),
+            true,
+        )
+        .await
+        .err()
+        .unwrap();
+    assert_eq!(error.kind(), io::ErrorKind::PermissionDenied);
+    assert_eq!(dispatcher.calls.load(Ordering::Relaxed), 1);
+    assert_eq!(std::fs::read(&input).unwrap(), b"original foreground input");
+}
+
+#[cfg(unix)]
+#[tokio::test]
+async fn periodic_http_refresh_rechecks_reserved_input_aliases_before_download() {
+    use std::os::unix::fs::symlink;
+    let directory = tempfile::tempdir().unwrap();
+    let input = directory.path().join("config.yaml");
+    std::fs::write(&input, b"original foreground input").unwrap();
+    let mut paths = ProviderPaths::default();
+    paths.reserve_inputs([(input.clone(), false)]);
+    let context = SourceContext {
+        data_dir: Some(directory.path().into()),
+        resource_paths: Arc::new(paths),
+        ..Default::default()
+    };
+    let body = directory.path().join("remote.yaml");
+    let dispatcher = Responses::new([response(200, "payload: []")]);
+    let network = network(dispatcher.clone());
+    let mut store = Store::new();
+    store
+        .prepare(
+            document_with_cache(&body),
+            &context,
+            Some(&network),
+            &CancellationToken::new(),
+            false,
+        )
+        .await
+        .unwrap();
+    std::fs::remove_file(&body).unwrap();
+    symlink(&input, &body).unwrap();
+    store.entries.get_mut("remote").unwrap().checked = 0;
+    let error = store
+        .refresh_due(&network, &CancellationToken::new())
+        .await
+        .err()
+        .unwrap();
+    assert_eq!(error.kind(), io::ErrorKind::PermissionDenied);
+    assert!(store.next_due().is_some_and(|delay| !delay.is_zero()));
+    assert_eq!(dispatcher.calls.load(Ordering::Relaxed), 1);
+    assert_eq!(std::fs::read(&input).unwrap(), b"original foreground input");
+}
+
+#[tokio::test]
+async fn disabled_resources_and_adopt_do_not_read_source_content() {
+    let document = Document::parse("rewrite-providers: {missing: {type: file, path: missing.yaml}}\nrewrite: {rules: [{rule-set: missing, enabled: false}]}").unwrap();
+    let source = SourceContext::default();
+    let mut store = Store::new();
+    let candidate = store
+        .prepare(
+            document.clone(),
+            &source,
+            None,
+            &CancellationToken::new(),
+            false,
+        )
+        .await
+        .unwrap();
+    assert!(candidate.document.compile(&BTreeMap::new()).is_ok());
+    assert!(store.prepared(&document, &source).unwrap().is_some());
+    let restored = PolicyCandidate::import_snapshot(&candidate.export_snapshot().unwrap()).unwrap();
+    Store::new().adopt(restored.clone(), &source).unwrap();
+    let other = SourceContext {
+        base_dir: Some(PathBuf::from("/different")),
+        ..Default::default()
+    };
+    assert!(Store::new().adopt(restored, &other).is_err());
+    assert!(store.prepared(&document, &other).unwrap().is_none());
+}
+
+#[tokio::test]
+async fn failed_http_update_keeps_complete_candidate_and_both_cache_files() {
+    let directory = tempfile::tempdir().unwrap();
+    let source = SourceContext {
+        data_dir: Some(directory.path().into()),
+        ..Default::default()
+    };
+    let document = document("fixture-old");
+    let dispatcher = Responses::new([
+        response(200, "payload: [{url: '.', action: reject}]"),
+        response(200, "payload: [{url: '[', action: reject}]"),
+    ]);
+    let network = network(dispatcher.clone());
+    let cancel = CancellationToken::new();
+    let mut store = Store::new();
+    let first = store
+        .prepare(document.clone(), &source, Some(&network), &cancel, false)
+        .await
+        .unwrap();
+    let before = std::fs::read(directory.path().join("remote.yaml")).unwrap();
+    let metadata = std::fs::read(directory.path().join("remote.yaml.http-meta")).unwrap();
+    assert!(
+        store
+            .prepare(document.clone(), &source, Some(&network), &cancel, true)
+            .await
+            .is_err()
+    );
+    assert_eq!(
+        store
+            .prepared(&document, &source)
+            .unwrap()
+            .unwrap()
+            .identity(),
+        first.identity()
+    );
+    assert_eq!(
+        std::fs::read(directory.path().join("remote.yaml")).unwrap(),
+        before
+    );
+    assert_eq!(
+        std::fs::read(directory.path().join("remote.yaml.http-meta")).unwrap(),
+        metadata
+    );
+    assert_eq!(dispatcher.calls.load(Ordering::Relaxed), 2);
+    assert!(
+        dispatcher.requests.lock().unwrap()[1]
+            .windows(b"If-None-Match:".len())
+            .any(|slice| slice == b"If-None-Match:")
+    );
+    assert_eq!(std::fs::read_dir(directory.path()).unwrap().count(), 2);
+}
+
+#[tokio::test]
+async fn changed_authentication_cannot_borrow_old_cache_or_validator() {
+    let directory = tempfile::tempdir().unwrap();
+    let source = SourceContext {
+        data_dir: Some(directory.path().into()),
+        ..Default::default()
+    };
+    let old = document("fixture-old");
+    let changed = document("fixture-new");
+    let dispatcher = Responses::new([response(200, "payload: []"), response(304, "")]);
+    let network = network(dispatcher.clone());
+    let cancel = CancellationToken::new();
+    let mut store = Store::new();
+    let previous = store
+        .prepare(old.clone(), &source, Some(&network), &cancel, false)
+        .await
+        .unwrap();
+    assert!(
+        store
+            .prepare(changed.clone(), &source, Some(&network), &cancel, false)
+            .await
+            .is_err()
+    );
+    assert!(store.prepared(&changed, &source).unwrap().is_none());
+    assert_eq!(
+        store.prepared(&old, &source).unwrap().unwrap().identity(),
+        previous.identity()
+    );
+    let requests = dispatcher.requests.lock().unwrap();
+    assert!(
+        !requests[1]
+            .windows(b"If-None-Match:".len())
+            .any(|slice| slice == b"If-None-Match:")
+    );
+}
+
+#[cfg(unix)]
+#[tokio::test]
+async fn disabled_sources_skip_fifo_and_unresolvable_cache_parent_without_io() {
+    use std::{
+        ffi::CString,
+        os::unix::{ffi::OsStrExt, fs::symlink},
+    };
+    let directory = tempfile::tempdir().unwrap();
+    symlink("loop", directory.path().join("loop")).unwrap();
+    let fifo = CString::new(directory.path().join("pipe").as_os_str().as_bytes()).unwrap();
+    assert_eq!(unsafe { libc::mkfifo(fifo.as_ptr(), 0o600) }, 0);
+    let document = Document::parse("rewrite-providers:\n  fifo: {type: file, path: pipe}\n  inaccessible: {type: http, url: 'http://rules.example.test/rules.yaml', path: loop/cache.yaml}\nrewrite:\n  rules: [{rule-set: fifo, enabled: false}, {rule-set: inaccessible, enabled: false}]\n").unwrap();
+    let source = SourceContext {
+        base_dir: Some(directory.path().into()),
+        data_dir: Some(directory.path().into()),
+        config_path: None,
+        ..Default::default()
+    };
+    let mut store = Store::new();
+    let candidate = store
+        .prepare(document, &source, None, &CancellationToken::new(), false)
+        .await
+        .unwrap();
+    assert!(candidate.payloads.is_empty());
+    assert_eq!(std::fs::read_dir(directory.path()).unwrap().count(), 2);
+}
diff --git a/src/http_processing/request.rs b/src/http_processing/request.rs
new file mode 100644
index 0000000..f822dd6
--- /dev/null
+++ b/src/http_processing/request.rs
@@ -0,0 +1,86 @@
+//! Shared request decisions for HTTP/1 and HTTP/2, before any upstream IO.
+use super::{HttpContext, Scheme, config::Action};
+use crate::session::{Destination, StreamSession};
+use std::{io, net::IpAddr};
+use url::Url;
+
+pub(super) struct Target {
+    pub(super) original: Url,
+    pub(super) url: Url,
+    pub(super) session: StreamSession,
+    pub(super) logical_destination: Destination,
+    pub(super) strip_origin_credentials: bool,
+}
+pub(super) enum Decision {
+    Forward(Box<Target>),
+    Redirect { status: u16, url: Url },
+    Reject,
+}
+impl HttpContext {
+    pub(super) fn plan(
+        &self,
+        original: Url,
+        mut session: StreamSession,
+        scheme: Scheme,
+        apply_url_actions: bool,
+    ) -> io::Result<Decision> {
+        // Authorization is per original HTTP authority, before any URL action.
+        // One allowed TLS SNI never grants other authorities on this connection.
+        if scheme == Scheme::Https && !self.permits_https(&original) {
+            return Err(io::Error::new(
+                io::ErrorKind::PermissionDenied,
+                "HTTPS authority is not permitted",
+            ));
+        }
+        let original_matches_tls = scheme != Scheme::Https
+            || (session.sniffed_domain.as_deref().is_some_and(|sni| {
+                original
+                    .host_str()
+                    .is_some_and(|host| host.eq_ignore_ascii_case(sni))
+            }) && original.port_or_known_default() == Some(session.destination.port()));
+        let origin = (
+            original.scheme() == "https",
+            original.host_str().unwrap_or_default().to_owned(),
+            original.port_or_known_default(),
+        );
+        let action = if apply_url_actions {
+            self.policy().evaluate(original.clone())?
+        } else {
+            Action::Forward(original.clone())
+        };
+        let url = match action {
+            Action::Reject => return Ok(Decision::Reject),
+            Action::Redirect { status, url } => return Ok(Decision::Redirect { status, url }),
+            Action::Forward(url) => url,
+        };
+        let strip_origin_credentials = origin.0 != (url.scheme() == "https")
+            || origin.1 != url.host_str().unwrap_or_default()
+            || origin.2 != url.port_or_known_default();
+        let host = url.host_str().ok_or_else(invalid)?.trim_matches(['[', ']']);
+        let port = url.port_or_known_default().ok_or_else(invalid)?;
+        let destination = match host.parse::<IpAddr>() {
+            Ok(ip) => Destination::Ip((ip, port).into()),
+            Err(_) => Destination::domain(host, port)?,
+        };
+        session.capture_original();
+        // A same-origin path/query action must not re-resolve an already
+        // selected TUN address or silently change its CDN endpoint.
+        if strip_origin_credentials || !original_matches_tls {
+            session.destination = destination.clone();
+            session.sniffed_domain = None;
+        } else if scheme == Scheme::Https {
+            // Retain the fixed SNI's selected IP only for its own authority.
+            session.sniffed_domain = Some(host.to_owned());
+        }
+        Ok(Decision::Forward(Box::new(Target {
+            original,
+            url,
+            session,
+            logical_destination: destination,
+            strip_origin_credentials,
+        })))
+    }
+}
+fn invalid() -> io::Error {
+    io::Error::new(io::ErrorKind::InvalidData, "invalid rewritten HTTP target")
+}
diff --git a/src/http_processing/rule_schema.rs b/src/http_processing/rule_schema.rs
new file mode 100644
index 0000000..f5df614
--- /dev/null
+++ b/src/http_processing/rule_schema.rs
@@ -0,0 +1,207 @@
+//! Latest-only, flat HTTP rule input types.
+use serde::{Deserialize, Deserializer, Serialize};
+
+fn present<'de, D: Deserializer<'de>, T: Deserialize<'de>>(
+    deserializer: D,
+) -> Result<Option<T>, D::Error> {
+    Option::<T>::deserialize(deserializer)?
+        .map(Some)
+        .ok_or_else(|| serde::de::Error::custom("null is not an omitted rule parameter"))
+}
+
+fn enabled() -> bool {
+    true
+}
+
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(deny_unknown_fields, rename_all = "kebab-case")]
+pub(crate) struct RawRule {
+    pub(crate) url: String,
+    #[serde(default, rename = "match")]
+    pub(crate) match_kind: MatchKind,
+    pub(crate) action: ActionKind,
+    #[serde(default = "enabled")]
+    pub(crate) enabled: bool,
+    #[serde(
+        default,
+        deserialize_with = "present",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub(crate) name: Option<String>,
+    #[serde(
+        default,
+        deserialize_with = "present",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub(crate) replacement: Option<String>,
+    #[serde(
+        default,
+        deserialize_with = "present",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub(crate) replacement_mode: Option<ReplacementMode>,
+    #[serde(
+        default,
+        deserialize_with = "present",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub(crate) header: Option<String>,
+    #[serde(
+        default,
+        deserialize_with = "present",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub(crate) value: Option<String>,
+    #[serde(
+        default,
+        deserialize_with = "present",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub(crate) search: Option<String>,
+    #[serde(
+        default,
+        deserialize_with = "present",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub(crate) search_mode: Option<SearchMode>,
+    #[serde(
+        default,
+        deserialize_with = "present",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub(crate) occurrences: Option<Occurrences>,
+    #[serde(
+        default,
+        deserialize_with = "present",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub(crate) patch: Option<Vec<PatchOperation>>,
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub(crate) enum MatchKind {
+    #[default]
+    Regex,
+    Exact,
+    Prefix,
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub(crate) enum ReplacementMode {
+    #[default]
+    Match,
+    Url,
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub(crate) enum SearchMode {
+    #[default]
+    Literal,
+    Regex,
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub(crate) enum Occurrences {
+    First,
+    #[default]
+    All,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub(crate) enum ActionKind {
+    Replace,
+    Redirect302,
+    Redirect307,
+    Reject,
+    RequestHeaderSet,
+    RequestHeaderAdd,
+    RequestHeaderRemove,
+    RequestHeaderReplace,
+    ResponseHeaderSet,
+    ResponseHeaderAdd,
+    ResponseHeaderRemove,
+    ResponseHeaderReplace,
+    RequestBodySet,
+    RequestBodyReplace,
+    RequestBodyJsonPatch,
+    ResponseBodySet,
+    ResponseBodyReplace,
+    ResponseBodyJsonPatch,
+}
+
+impl ActionKind {
+    pub(crate) fn is_url(self) -> bool {
+        matches!(
+            self,
+            Self::Replace | Self::Redirect302 | Self::Redirect307 | Self::Reject
+        )
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum Phase {
+    Request,
+    Response,
+}
+
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(tag = "op", deny_unknown_fields, rename_all = "lowercase")]
+pub(crate) enum PatchOperation {
+    Add {
+        path: String,
+        #[serde(deserialize_with = "json_value")]
+        value: serde_json::Value,
+    },
+    Remove {
+        path: String,
+    },
+    Replace {
+        path: String,
+        #[serde(deserialize_with = "json_value")]
+        value: serde_json::Value,
+    },
+    Move {
+        from: String,
+        path: String,
+    },
+    Copy {
+        from: String,
+        path: String,
+    },
+    Test {
+        path: String,
+        #[serde(deserialize_with = "json_value")]
+        value: serde_json::Value,
+    },
+}
+
+// serde_json::Value turns a non-finite floating-point visitor value into
+// JSON null. Reject such YAML numbers before conversion, rather than silently
+// changing their type. Real JSON null remains a supported patch value.
+fn json_value<'de, D: Deserializer<'de>>(deserializer: D) -> Result<serde_json::Value, D::Error> {
+    fn compatible(value: &serde_yaml_ng::Value) -> bool {
+        use serde_yaml_ng::Value;
+        match value {
+            Value::Null | Value::Bool(_) | Value::String(_) => true,
+            Value::Number(number) => number.as_f64().is_some_and(f64::is_finite),
+            Value::Sequence(values) => values.iter().all(compatible),
+            Value::Mapping(values) => values
+                .iter()
+                .all(|(key, value)| matches!(key, Value::String(_)) && compatible(value)),
+            Value::Tagged(_) => false,
+        }
+    }
+    let value = serde_yaml_ng::Value::deserialize(deserializer)?;
+    if !compatible(&value) {
+        return Err(serde::de::Error::custom(
+            "JSON Patch value is not JSON-compatible",
+        ));
+    }
+    serde_yaml_ng::from_value(value)
+        .map_err(|_| serde::de::Error::custom("JSON Patch value is not JSON-compatible"))
+}
diff --git a/src/http_processing/rule_search.rs b/src/http_processing/rule_search.rs
new file mode 100644
index 0000000..f5ddb72
--- /dev/null
+++ b/src/http_processing/rule_search.rs
@@ -0,0 +1,107 @@
+//! Text replacement shared by header and body actions.
+use regex::Regex;
+use std::io;
+
+use super::{
+    MAX_BODY_VALUE, MAX_PATTERN, Occurrences, SearchMode, bounded_regex, invalid, template,
+};
+
+pub(crate) struct Search {
+    pattern: Pattern,
+    occurrences: Occurrences,
+}
+
+enum Pattern {
+    Literal {
+        search: Box<str>,
+        replacement: Box<str>,
+    },
+    Regex {
+        search: Regex,
+        replacement: template::Template,
+    },
+}
+
+impl Search {
+    pub(crate) fn compile(
+        search: String,
+        replacement: String,
+        mode: SearchMode,
+        occurrences: Occurrences,
+    ) -> io::Result<Self> {
+        if search.len() > MAX_PATTERN || replacement.len() > MAX_BODY_VALUE {
+            return Err(invalid());
+        }
+        let pattern = match mode {
+            SearchMode::Literal => {
+                if search.is_empty() {
+                    return Err(invalid());
+                }
+                Pattern::Literal {
+                    search: search.into(),
+                    replacement: replacement.into(),
+                }
+            }
+            SearchMode::Regex => {
+                let search = bounded_regex(&search)?;
+                let replacement = template::Template::compile(&replacement, &search)?;
+                Pattern::Regex {
+                    search,
+                    replacement,
+                }
+            }
+        };
+        Ok(Self {
+            pattern,
+            occurrences,
+        })
+    }
+
+    /// The caller owns the input and output workspace permits. Allocation is
+    /// checked before every append, including unmatched portions and captures.
+    pub(crate) fn apply(&self, input: &str, limit: usize) -> io::Result<String> {
+        let mut out = String::new();
+        self.apply_into(input, &mut out, limit)?;
+        Ok(out)
+    }
+
+    /// Reuse a caller-owned, already charged output workspace. Existing output
+    /// is discarded; callers commit only after this operation succeeds.
+    pub(crate) fn apply_into(&self, input: &str, out: &mut String, limit: usize) -> io::Result<()> {
+        out.clear();
+        if input.len() > limit {
+            return Err(invalid());
+        }
+        let mut end = 0;
+        match &self.pattern {
+            Pattern::Literal {
+                search,
+                replacement,
+            } => {
+                for (start, value) in input.match_indices(search.as_ref()) {
+                    template::append(out, &input[end..start], limit)?;
+                    template::append(out, replacement, limit)?;
+                    end = start + value.len();
+                    if self.occurrences == Occurrences::First {
+                        break;
+                    }
+                }
+            }
+            Pattern::Regex {
+                search,
+                replacement,
+            } => {
+                for captures in search.captures_iter(input) {
+                    let found = captures.get(0).expect("regex always has capture zero");
+                    template::append(out, &input[end..found.start()], limit)?;
+                    replacement.append(&captures, out, limit)?;
+                    end = found.end();
+                    if self.occurrences == Occurrences::First {
+                        break;
+                    }
+                }
+            }
+        }
+        template::append(out, &input[end..], limit)
+    }
+}
diff --git a/src/http_processing/rule_template.rs b/src/http_processing/rule_template.rs
new file mode 100644
index 0000000..633471f
--- /dev/null
+++ b/src/http_processing/rule_template.rs
@@ -0,0 +1,118 @@
+//! Strict, prevalidated replacement templates with bounded expansion.
+use regex::{Captures, Regex};
+use std::io;
+
+use super::invalid;
+
+pub(super) struct Template {
+    parts: Box<[Part]>,
+    captures: bool,
+}
+
+enum Part {
+    Literal(Box<str>),
+    Capture(usize),
+}
+
+impl Template {
+    pub(super) fn compile(input: &str, regex: &Regex) -> io::Result<Self> {
+        let mut parts = Vec::new();
+        let mut literal = String::new();
+        let mut rest = input;
+        let mut captures = false;
+        while let Some(start) = rest.find('$') {
+            if start != 0 {
+                literal.push_str(&rest[..start]);
+            }
+            rest = &rest[start + 1..];
+            if let Some(tail) = rest.strip_prefix('$') {
+                literal.push('$');
+                rest = tail;
+                continue;
+            }
+            let name;
+            if let Some(braced) = rest.strip_prefix('{') {
+                let end = braced.find('}').ok_or_else(invalid)?;
+                name = &braced[..end];
+                rest = &braced[end + 1..];
+            } else {
+                let end = rest.bytes().take_while(u8::is_ascii_digit).count();
+                if end == 0 {
+                    return Err(invalid());
+                }
+                name = &rest[..end];
+                rest = &rest[end..];
+            }
+            if name.is_empty() {
+                return Err(invalid());
+            }
+            let index = if name.bytes().all(|byte| byte.is_ascii_digit()) {
+                name.parse::<usize>().map_err(|_| invalid())?
+            } else {
+                regex
+                    .capture_names()
+                    .position(|entry| entry == Some(name))
+                    .ok_or_else(invalid)?
+            };
+            if index >= regex.captures_len() {
+                return Err(invalid());
+            }
+            if !literal.is_empty() {
+                parts.push(Part::Literal(std::mem::take(&mut literal).into()));
+            }
+            parts.push(Part::Capture(index));
+            captures = true;
+        }
+        literal.push_str(rest);
+        if !literal.is_empty() {
+            parts.push(Part::Literal(literal.into()));
+        }
+        Ok(Self {
+            parts: parts.into(),
+            captures,
+        })
+    }
+
+    pub(super) fn constant(&self, limit: usize) -> io::Result<Option<String>> {
+        if self.captures {
+            return Ok(None);
+        }
+        let mut out = String::new();
+        for part in &self.parts {
+            if let Part::Literal(value) = part {
+                append(&mut out, value, limit)?;
+            }
+        }
+        Ok(Some(out))
+    }
+
+    pub(super) fn append(
+        &self,
+        captures: &Captures<'_>,
+        out: &mut String,
+        limit: usize,
+    ) -> io::Result<()> {
+        for part in &self.parts {
+            match part {
+                Part::Literal(value) => append(out, value, limit)?,
+                Part::Capture(index) => {
+                    if let Some(value) = captures.get(*index) {
+                        append(out, value.as_str(), limit)?;
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+pub(super) fn append(out: &mut String, value: &str, limit: usize) -> io::Result<()> {
+    if value.len() > limit.saturating_sub(out.len()) {
+        return Err(invalid());
+    }
+    out.try_reserve_exact(value.len()).map_err(|_| {
+        io::Error::new(io::ErrorKind::OutOfMemory, "HTTP rewrite allocation failed")
+    })?;
+    out.push_str(value);
+    Ok(())
+}
diff --git a/src/http_processing/rules.rs b/src/http_processing/rules.rs
new file mode 100644
index 0000000..10387f0
--- /dev/null
+++ b/src/http_processing/rules.rs
@@ -0,0 +1,503 @@
+//! The common flat HTTP rule schema and pure, bounded rule compiler.
+use regex::{Regex, RegexBuilder};
+use std::io;
+use url::Url;
+
+#[path = "rule_schema.rs"]
+mod schema;
+pub(crate) use schema::{
+    ActionKind, MatchKind, Occurrences, PatchOperation, Phase, RawRule, ReplacementMode, SearchMode,
+};
+
+#[path = "rule_search.rs"]
+mod search;
+#[path = "rule_template.rs"]
+mod template;
+pub(crate) use search::Search;
+
+pub(crate) const MAX_RULES: usize = 64;
+pub(crate) const MAX_PATTERN: usize = 2048;
+pub(crate) const MAX_RULE_TEXT: usize = 64 * 1024;
+pub(crate) const MAX_URL: usize = 8192;
+pub(crate) const MAX_BODY_VALUE: usize = 256 * 1024;
+
+fn invalid() -> io::Error {
+    io::Error::new(io::ErrorKind::InvalidInput, "invalid HTTP rewrite rule")
+}
+
+pub(crate) struct Rule {
+    pub(crate) name: Option<Box<str>>,
+    pub(crate) enabled: bool,
+    pub(crate) selector: Matcher,
+    pub(crate) action: RuleAction,
+}
+
+pub(crate) enum Matcher {
+    Exact(Box<str>),
+    Prefix(Box<str>),
+    Regex(Regex),
+}
+
+pub(crate) enum RuleAction {
+    Url {
+        kind: ActionKind,
+        replacement: Option<UrlReplacement>,
+    },
+    Header {
+        phase: Phase,
+        header: Box<str>,
+        operation: HeaderOperation,
+    },
+    Body {
+        phase: Phase,
+        operation: BodyOperation,
+    },
+}
+
+pub(crate) enum HeaderOperation {
+    Set(Box<str>),
+    Add(Box<str>),
+    Remove,
+    Replace(Search),
+}
+
+pub(crate) enum BodyOperation {
+    Set(Box<str>),
+    Replace(Search),
+    JsonPatch(Box<[PatchOperation]>),
+}
+
+pub(crate) struct UrlReplacement {
+    mode: ReplacementMode,
+    value: ReplacementValue,
+}
+
+enum ReplacementValue {
+    Literal(Box<str>),
+    Template(template::Template),
+}
+
+pub(crate) enum UrlAction {
+    Forward(Url),
+    Redirect { status: u16, url: Url },
+    Reject,
+}
+
+// Action parameters are mutually exclusive even when explicitly set to an
+// empty value. Missing and null cannot masquerade as one another.
+const REPLACEMENT: u16 = 1;
+const REPLACEMENT_MODE: u16 = 2;
+const HEADER: u16 = 4;
+const VALUE: u16 = 8;
+const SEARCH: u16 = 16;
+const SEARCH_MODE: u16 = 32;
+const OCCURRENCES: u16 = 64;
+const PATCH: u16 = 128;
+
+impl RawRule {
+    fn parameters(&self) -> u16 {
+        let mut mask = 0;
+        for (present, bit) in [
+            (self.replacement.is_some(), REPLACEMENT),
+            (self.replacement_mode.is_some(), REPLACEMENT_MODE),
+            (self.header.is_some(), HEADER),
+            (self.value.is_some(), VALUE),
+            (self.search.is_some(), SEARCH),
+            (self.search_mode.is_some(), SEARCH_MODE),
+            (self.occurrences.is_some(), OCCURRENCES),
+            (self.patch.is_some(), PATCH),
+        ] {
+            if present {
+                mask |= bit;
+            }
+        }
+        mask
+    }
+
+    fn text_size(&self) -> io::Result<usize> {
+        let mut size = self.url.len();
+        for text in [&self.name, &self.header, &self.search] {
+            size = size
+                .checked_add(text.as_ref().map_or(0, String::len))
+                .ok_or_else(invalid)?;
+        }
+        // Body literals belong to the separately bounded body/configuration
+        // workspace, not the 8 KiB URL-result limit.
+        if !matches!(
+            self.action,
+            ActionKind::RequestBodySet
+                | ActionKind::RequestBodyReplace
+                | ActionKind::ResponseBodySet
+                | ActionKind::ResponseBodyReplace
+        ) {
+            for text in [&self.replacement, &self.value] {
+                size = size
+                    .checked_add(text.as_ref().map_or(0, String::len))
+                    .ok_or_else(invalid)?;
+            }
+        }
+        Ok(size)
+    }
+
+    fn compile_search(&mut self) -> io::Result<Search> {
+        Search::compile(
+            self.search.take().ok_or_else(invalid)?,
+            self.replacement.take().ok_or_else(invalid)?,
+            self.search_mode.unwrap_or_default(),
+            self.occurrences.unwrap_or_default(),
+        )
+    }
+}
+
+impl Rule {
+    pub(crate) fn compile(mut raw: RawRule, total_text: &mut usize) -> io::Result<Self> {
+        let next_text = total_text
+            .checked_add(raw.text_size()?)
+            .ok_or_else(invalid)?;
+        if raw.url.len() > MAX_PATTERN
+            || next_text > MAX_RULE_TEXT
+            || raw
+                .search
+                .as_ref()
+                .is_some_and(|value| value.len() > MAX_PATTERN)
+            || raw
+                .value
+                .as_ref()
+                .is_some_and(|value| value.len() > MAX_BODY_VALUE)
+            || raw
+                .replacement
+                .as_ref()
+                .is_some_and(|value| value.len() > MAX_BODY_VALUE)
+        {
+            return Err(invalid());
+        }
+        let selector = match raw.match_kind {
+            MatchKind::Regex => Matcher::Regex(bounded_regex(&raw.url)?),
+            MatchKind::Exact => Matcher::Exact(checked_url(&raw.url)?.as_str().into()),
+            MatchKind::Prefix => Matcher::Prefix(checked_url(&raw.url)?.as_str().into()),
+        };
+        let parameters = raw.parameters();
+        let search_parameters = REPLACEMENT | SEARCH | SEARCH_MODE | OCCURRENCES;
+        let allowed = match raw.action {
+            ActionKind::Replace | ActionKind::Redirect302 | ActionKind::Redirect307 => {
+                REPLACEMENT | REPLACEMENT_MODE
+            }
+            ActionKind::Reject => 0,
+            ActionKind::RequestHeaderSet
+            | ActionKind::RequestHeaderAdd
+            | ActionKind::ResponseHeaderSet
+            | ActionKind::ResponseHeaderAdd => HEADER | VALUE,
+            ActionKind::RequestHeaderRemove | ActionKind::ResponseHeaderRemove => HEADER,
+            ActionKind::RequestHeaderReplace | ActionKind::ResponseHeaderReplace => {
+                HEADER | search_parameters
+            }
+            ActionKind::RequestBodySet | ActionKind::ResponseBodySet => VALUE,
+            ActionKind::RequestBodyReplace | ActionKind::ResponseBodyReplace => search_parameters,
+            ActionKind::RequestBodyJsonPatch | ActionKind::ResponseBodyJsonPatch => PATCH,
+        };
+        if parameters & !allowed != 0 {
+            return Err(invalid());
+        }
+        let phase = match raw.action {
+            ActionKind::ResponseHeaderSet
+            | ActionKind::ResponseHeaderAdd
+            | ActionKind::ResponseHeaderRemove
+            | ActionKind::ResponseHeaderReplace
+            | ActionKind::ResponseBodySet
+            | ActionKind::ResponseBodyReplace
+            | ActionKind::ResponseBodyJsonPatch => Phase::Response,
+            _ => Phase::Request,
+        };
+        let action = if raw.action.is_url() {
+            let replacement = if raw.action == ActionKind::Reject {
+                None
+            } else {
+                let value = raw.replacement.take().ok_or_else(invalid)?;
+                if value.len() > MAX_URL {
+                    return Err(invalid());
+                }
+                let mode = raw.replacement_mode.unwrap_or_default();
+                let value = match &selector {
+                    Matcher::Regex(regex) => {
+                        if value.chars().any(|character| {
+                            character.is_control()
+                                || character.is_whitespace()
+                                || matches!(character, '\\' | '#')
+                        }) {
+                            return Err(invalid());
+                        }
+                        let template = template::Template::compile(&value, regex)?;
+                        if mode == ReplacementMode::Url
+                            && let Some(value) = template.constant(MAX_URL)?
+                        {
+                            checked_url(&value)?;
+                        }
+                        ReplacementValue::Template(template)
+                    }
+                    _ => ReplacementValue::Literal(checked_url(&value)?.as_str().into()),
+                };
+                Some(UrlReplacement { mode, value })
+            };
+            RuleAction::Url {
+                kind: raw.action,
+                replacement,
+            }
+        } else if allowed & HEADER != 0 {
+            let header = raw.header.take().ok_or_else(invalid)?;
+            validate_header_name(&header)?;
+            let operation = match raw.action {
+                ActionKind::RequestHeaderSet | ActionKind::ResponseHeaderSet => {
+                    let value = raw.value.take().ok_or_else(invalid)?;
+                    validate_header_value(&value)?;
+                    HeaderOperation::Set(value.into())
+                }
+                ActionKind::RequestHeaderAdd | ActionKind::ResponseHeaderAdd => {
+                    let value = raw.value.take().ok_or_else(invalid)?;
+                    validate_header_value(&value)?;
+                    HeaderOperation::Add(value.into())
+                }
+                ActionKind::RequestHeaderRemove | ActionKind::ResponseHeaderRemove => {
+                    HeaderOperation::Remove
+                }
+                _ => {
+                    if let Some(value) = &raw.replacement {
+                        validate_header_value(value)?;
+                    }
+                    HeaderOperation::Replace(raw.compile_search()?)
+                }
+            };
+            RuleAction::Header {
+                phase,
+                header: header.to_ascii_lowercase().into(),
+                operation,
+            }
+        } else {
+            let operation = match raw.action {
+                ActionKind::RequestBodySet | ActionKind::ResponseBodySet => {
+                    BodyOperation::Set(raw.value.take().ok_or_else(invalid)?.into())
+                }
+                ActionKind::RequestBodyReplace | ActionKind::ResponseBodyReplace => {
+                    BodyOperation::Replace(raw.compile_search()?)
+                }
+                _ => {
+                    let patch = raw.patch.take().ok_or_else(invalid)?;
+                    validate_patch(&patch)?;
+                    BodyOperation::JsonPatch(patch.into())
+                }
+            };
+            RuleAction::Body { phase, operation }
+        };
+        *total_text = next_text;
+        Ok(Self {
+            name: raw.name.map(String::into_boxed_str),
+            enabled: raw.enabled,
+            selector,
+            action,
+        })
+    }
+
+    pub(crate) fn matches(&self, url: &Url) -> bool {
+        self.enabled
+            && match &self.selector {
+                Matcher::Exact(value) => url.as_str() == value.as_ref(),
+                Matcher::Prefix(value) => url.as_str().starts_with(value.as_ref()),
+                Matcher::Regex(regex) => regex.is_match(url.as_str()),
+            }
+    }
+
+    pub(crate) fn evaluate_url(&self, url: &Url) -> io::Result<Option<UrlAction>> {
+        if url.as_str().len() > MAX_URL {
+            return Err(invalid());
+        }
+        let RuleAction::Url { kind, replacement } = &self.action else {
+            return Ok(None);
+        };
+        if !self.matches(url) {
+            return Ok(None);
+        }
+        if *kind == ActionKind::Reject {
+            return Ok(Some(UrlAction::Reject));
+        }
+        let replacement = replacement.as_ref().expect("compiled URL replacement");
+        let mut out = String::new();
+        match (&self.selector, &replacement.value) {
+            (Matcher::Exact(_), ReplacementValue::Literal(value)) => {
+                template::append(&mut out, value, MAX_URL)?
+            }
+            (Matcher::Prefix(prefix), ReplacementValue::Literal(value)) => {
+                let suffix = &url.as_str()[prefix.len()..];
+                let value = if replacement.mode == ReplacementMode::Match
+                    && !value.contains('?')
+                    && value.ends_with('/')
+                    && suffix.starts_with('/')
+                {
+                    &value[..value.len() - 1]
+                } else {
+                    value.as_ref()
+                };
+                template::append(&mut out, value, MAX_URL)?;
+                if replacement.mode == ReplacementMode::Match {
+                    template::append(&mut out, suffix, MAX_URL)?;
+                }
+            }
+            (Matcher::Regex(regex), ReplacementValue::Template(value)) => {
+                let captures = regex.captures(url.as_str()).expect("matched regex");
+                let found = captures.get(0).expect("regex capture zero");
+                if replacement.mode == ReplacementMode::Match {
+                    template::append(&mut out, &url.as_str()[..found.start()], MAX_URL)?;
+                }
+                value.append(&captures, &mut out, MAX_URL)?;
+                if replacement.mode == ReplacementMode::Match {
+                    template::append(&mut out, &url.as_str()[found.end()..], MAX_URL)?;
+                }
+            }
+            _ => unreachable!("replacement compiled for its selector"),
+        }
+        let target = checked_url(&out)?;
+        Ok(Some(match kind {
+            ActionKind::Replace => UrlAction::Forward(target),
+            ActionKind::Redirect302 => UrlAction::Redirect {
+                status: 302,
+                url: target,
+            },
+            ActionKind::Redirect307 => UrlAction::Redirect {
+                status: 307,
+                url: target,
+            },
+            _ => unreachable!("URL action"),
+        }))
+    }
+}
+
+pub(crate) fn checked_url(raw: &str) -> io::Result<Url> {
+    if raw.len() > MAX_URL
+        || raw.chars().any(|character| {
+            character.is_control() || character.is_whitespace() || character == '\\'
+        })
+    {
+        return Err(invalid());
+    }
+    // Normalization can erase an empty userinfo delimiter; inspect the input
+    // authority before parsing rather than accepting `https://@host/`.
+    if raw.split_once(':').is_some_and(|(_, tail)| {
+        tail.trim_start_matches('/')
+            .split(['/', '?', '#'])
+            .next()
+            .is_some_and(|authority| authority.contains('@'))
+    }) {
+        return Err(invalid());
+    }
+    let url = Url::parse(raw).map_err(|_| invalid())?;
+    if !matches!(url.scheme(), "http" | "https")
+        || url.host_str().is_none()
+        || !url.username().is_empty()
+        || url.password().is_some()
+        || url.fragment().is_some()
+        || url.port() == Some(0)
+        || url.as_str().len() > MAX_URL
+    {
+        return Err(invalid());
+    }
+    Ok(url)
+}
+
+pub(crate) fn offline_url(raw: &str) -> io::Result<Url> {
+    if raw.len() > MAX_URL {
+        return Err(invalid());
+    }
+    let raw = raw.trim();
+    checked_url(raw.split_once('#').map_or(raw, |(url, _)| url))
+}
+
+fn bounded_regex(pattern: &str) -> io::Result<Regex> {
+    if pattern.len() > MAX_PATTERN {
+        return Err(invalid());
+    }
+    RegexBuilder::new(pattern)
+        .size_limit(128 * 1024)
+        .dfa_size_limit(64 * 1024)
+        .build()
+        .map_err(|_| invalid())
+}
+
+pub(crate) fn validate_header_name(name: &str) -> io::Result<()> {
+    if name.is_empty()
+        || !name
+            .bytes()
+            .all(|byte| byte.is_ascii_alphanumeric() || b"!#$%&'*+-.^_`|~".contains(&byte))
+    {
+        return Err(invalid());
+    }
+    if matches!(
+        name.to_ascii_lowercase().as_str(),
+        "host"
+            | "content-length"
+            | "transfer-encoding"
+            | "content-encoding"
+            | "connection"
+            | "upgrade"
+            | "expect"
+            | "trailer"
+            | "te"
+            | "http2-settings"
+            | "keep-alive"
+            | "proxy-connection"
+    ) {
+        return Err(invalid());
+    }
+    Ok(())
+}
+
+pub(crate) fn validate_header_value(value: &str) -> io::Result<()> {
+    if value
+        .bytes()
+        .any(|byte| (byte < 32 && byte != b'\t') || byte == 127)
+    {
+        return Err(invalid());
+    }
+    Ok(())
+}
+
+fn validate_patch(patch: &[PatchOperation]) -> io::Result<()> {
+    let mut bytes = 0;
+    for operation in patch {
+        let (path, from, value) = match operation {
+            PatchOperation::Add { path, value }
+            | PatchOperation::Replace { path, value }
+            | PatchOperation::Test { path, value } => (path, None, Some(value)),
+            PatchOperation::Remove { path } => (path, None, None),
+            PatchOperation::Move { from, path } | PatchOperation::Copy { from, path } => {
+                (path, Some(from), None)
+            }
+        };
+        pointer(path)?;
+        if let Some(from) = from {
+            pointer(from)?;
+        }
+        bytes += path.len() + from.map_or(0, String::len);
+        if let Some(value) = value {
+            bytes += serde_json::to_vec(value).map_err(|_| invalid())?.len();
+        }
+        if bytes > MAX_BODY_VALUE {
+            return Err(invalid());
+        }
+    }
+    Ok(())
+}
+
+fn pointer(value: &str) -> io::Result<()> {
+    if !value.is_empty() && !value.starts_with('/') {
+        return Err(invalid());
+    }
+    let mut bytes = value.bytes();
+    while let Some(byte) = bytes.next() {
+        if byte == b'~' && !matches!(bytes.next(), Some(b'0' | b'1')) {
+            return Err(invalid());
+        }
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+#[path = "rules_tests.rs"]
+mod tests;
diff --git a/src/http_processing/rules_tests.rs b/src/http_processing/rules_tests.rs
new file mode 100644
index 0000000..279ac96
--- /dev/null
+++ b/src/http_processing/rules_tests.rs
@@ -0,0 +1,190 @@
+use super::*;
+
+fn compile(input: &str) -> io::Result<Rule> {
+    let value: serde_yaml_ng::Value = serde_yaml_ng::from_str(input).map_err(|_| invalid())?;
+    let raw = serde_yaml_ng::from_value(value).map_err(|_| invalid())?;
+    Rule::compile(raw, &mut 0)
+}
+
+fn target(rule: &Rule, input: &str) -> String {
+    match rule
+        .evaluate_url(&checked_url(input).unwrap())
+        .unwrap()
+        .unwrap()
+    {
+        UrlAction::Forward(url) | UrlAction::Redirect { url, .. } => url.to_string(),
+        UrlAction::Reject => panic!("unexpected reject"),
+    }
+}
+
+#[test]
+fn flat_rules_keep_defaults_and_reject_action_parameter_confusion() {
+    let rule = compile("{url: '/v1/', action: replace, replacement: '/v2/'}").unwrap();
+    assert!(rule.enabled);
+    assert_eq!(
+        target(&rule, "https://api.example/v1/a/v1/b?q=1"),
+        "https://api.example/v2/a/v1/b?q=1"
+    );
+    for input in [
+        "{url: '.', action: reject, replacement: ''}",
+        "{url: '.', action: reject, replacement-mode: match}",
+        "{url: '.', action: reject, value: null}",
+        "{url: '.', action: reject, enabled: null}",
+        "{url: '.', action: replace}",
+        "{url: '.', action: request-header-remove, header: Server, value: ''}",
+        "{url: '.', action: response-body-set, value: '', search-mode: literal}",
+        "{url: '.', action: request-header-set, header: Host, value: example.com}",
+        "{url: '.', action: response-header-add, header: X-Test, value: \"a\\r\\nb\"}",
+        "{url: '.', action: response-body-replace, search: '', replacement: x}",
+        "{url: '.', action: reject, pattern: '.'}",
+        "{url: '.', match: {type: regex, value: '.'}, action: reject}",
+        "{url: 123, action: reject}",
+        "{url: '.', action: response-body-set, value: true}",
+    ] {
+        assert!(compile(input).is_err(), "accepted invalid rule: {input}");
+    }
+    let disabled = compile("{url: '.', action: reject, enabled: false}").unwrap();
+    assert!(
+        disabled
+            .evaluate_url(&checked_url("https://example.com/").unwrap())
+            .unwrap()
+            .is_none()
+    );
+    assert!(compile("{url: '(', action: reject, enabled: false}").is_err());
+}
+
+#[test]
+fn prefix_normalization_preserves_suffix_and_only_removes_boundary_slash() {
+    let rule = compile("{url: 'HTTPS://API.EXAMPLE:443/v1', match: prefix, action: replace, replacement: 'https://new.example/'}").unwrap();
+    assert_eq!(
+        target(&rule, "https://api.example/v1/item?q=1"),
+        "https://new.example/item?q=1"
+    );
+    assert_eq!(
+        target(&rule, "https://api.example/v10"),
+        "https://new.example/0"
+    );
+    let rule = compile("{url: 'https://api.example/v1/', match: prefix, action: replace, replacement: 'https://new.example'}").unwrap();
+    assert_eq!(
+        target(&rule, "https://api.example/v1/item"),
+        "https://new.example/item"
+    );
+    let query = compile("{url: 'https://api.example/v1', match: prefix, action: replace, replacement: 'https://new.example/?x=/'}").unwrap();
+    assert_eq!(
+        target(&query, "https://api.example/v1/item?q=1"),
+        "https://new.example/?x=//item?q=1"
+    );
+    let whole = compile("{url: 'https://api.example/v1', match: prefix, action: redirect307, replacement-mode: url, replacement: 'https://new.example/'}").unwrap();
+    assert_eq!(
+        target(&whole, "https://api.example/v1/item?q=1"),
+        "https://new.example/"
+    );
+    let literal = compile("{url: 'https://api.example/', match: exact, action: replace, replacement: 'https://new.example/$1'}").unwrap();
+    assert_eq!(
+        target(&literal, "https://api.example/"),
+        "https://new.example/$1"
+    );
+}
+
+#[test]
+fn regex_templates_validate_captures_and_keep_unmatched_parts() {
+    let rule = compile("{url: '/(?P<old>v1)/(x)?', action: replace, replacement: '/${old}/$2$$/'}")
+        .unwrap();
+    assert_eq!(
+        target(&rule, "https://api.example/v1/item"),
+        "https://api.example/v1/$/item"
+    );
+    let whole = compile("{url: '^https://api\\.example/(.*)$', action: replace, replacement-mode: url, replacement: 'https://new.example/$1'}").unwrap();
+    assert_eq!(
+        target(&whole, "https://api.example/a?q=1"),
+        "https://new.example/a?q=1"
+    );
+    for template in ["$name", "$2", "${missing}", "${", "$", "$12", "${}"] {
+        let input = format!("{{url: '(x)', action: replace, replacement: '{template}'}}");
+        assert!(
+            compile(&input).is_err(),
+            "accepted invalid template {template}"
+        );
+    }
+    let bounded = compile("{url: '^(.*)$', action: replace, replacement: '$1$1'}").unwrap();
+    let input = checked_url(&format!("https://example.com/{}", "x".repeat(MAX_URL / 2))).unwrap();
+    assert!(bounded.evaluate_url(&input).is_err());
+    assert!(
+        compile("{url: '.', action: replace, replacement-mode: url, replacement: 'file:///tmp/a'}")
+            .is_err()
+    );
+}
+
+#[test]
+fn url_input_and_rule_targets_have_distinct_fragment_boundaries() {
+    assert_eq!(
+        offline_url(" HTTPS://EXAMPLE.COM:443/a/../b?q=%23#ignored ")
+            .unwrap()
+            .as_str(),
+        "https://example.com/b?q=%23"
+    );
+    for raw in [
+        "https://example.com/#fragment",
+        "https://u:p@example.com/",
+        "https://example.com:0/",
+        "https://example.com/\\x",
+        "https://example.com/ x",
+    ] {
+        assert!(checked_url(raw).is_err());
+    }
+}
+
+#[test]
+fn shared_search_distinguishes_literals_and_local_regex_captures() {
+    let literal = Search::compile(
+        "a".into(),
+        "$1".into(),
+        SearchMode::Literal,
+        Occurrences::All,
+    )
+    .unwrap();
+    assert_eq!(literal.apply("aba", 32).unwrap(), "$1b$1");
+    let regex = Search::compile(
+        "(?P<letter>a)(b)?".into(),
+        "${letter}-$2-$$".into(),
+        SearchMode::Regex,
+        Occurrences::First,
+    )
+    .unwrap();
+    assert_eq!(regex.apply("a ab", 32).unwrap(), "a--$ ab");
+    assert!(Search::compile("x".into(), "$1".into(), SearchMode::Regex, Occurrences::All).is_err());
+    let zero = Search::compile("".into(), "x".into(), SearchMode::Regex, Occurrences::All).unwrap();
+    assert_eq!(zero.apply("ab", 5).unwrap(), "xaxbx");
+    assert!(zero.apply("ab", 4).is_err());
+}
+
+#[test]
+fn body_values_are_not_limited_to_url_size_and_json_patch_is_strict() {
+    let value = "x".repeat(MAX_URL + 1);
+    let input = format!("{{url: '.', action: response-body-set, value: '{value}'}}");
+    assert!(compile(&input).is_ok());
+    let rule = compile("{url: '.', action: response-body-json-patch, patch: [{op: add, path: /flags/0, value: null}, {op: test, path: /enabled, value: false}]}").unwrap();
+    let RuleAction::Body {
+        operation: BodyOperation::JsonPatch(patch),
+        ..
+    } = rule.action
+    else {
+        panic!()
+    };
+    assert!(matches!(
+        &patch[0],
+        PatchOperation::Add {
+            value: serde_json::Value::Null,
+            ..
+        }
+    ));
+    for input in [
+        "{url: '.', action: response-body-json-patch, patch: [{op: remove, path: /x, value: false}]}",
+        "{url: '.', action: response-body-json-patch, patch: [{op: add, path: /x}]}",
+        "{url: '.', action: response-body-json-patch, patch: [{op: move, from: /x, path: /bad~2}]}",
+        "{url: '.', action: response-body-json-patch, patch: null}",
+        "{url: '.', action: response-body-json-patch, patch: [{op: add, path: /x, value: .nan}]}",
+    ] {
+        assert!(compile(input).is_err(), "accepted invalid patch: {input}");
+    }
+}
diff --git a/src/http_processing/tests.rs b/src/http_processing/tests.rs
new file mode 100644
index 0000000..0c2ffd8
--- /dev/null
+++ b/src/http_processing/tests.rs
@@ -0,0 +1,257 @@
+//! No sockets or host peers: adapters use duplex IO and a recording dispatcher.
+use super::*;
+use crate::{
+    dispatch::{BoxStream, DatagramTransport, DispatchError},
+    security::SecurityContext,
+    session::{DatagramSession, Destination, InboundKind, InboundMetadata, StreamSession},
+};
+use async_trait::async_trait;
+use std::{
+    sync::{Arc, Mutex},
+    time::Duration,
+};
+use tokio::{
+    io::{AsyncReadExt, AsyncWriteExt},
+    time::{Instant, timeout},
+};
+use tokio_util::sync::CancellationToken;
+
+#[derive(Default)]
+struct Origin {
+    sessions: Mutex<Vec<StreamSession>>,
+    heads: Arc<Mutex<Vec<String>>>,
+    tasks: Mutex<Vec<tokio::task::JoinHandle<()>>>,
+}
+#[async_trait]
+impl Dispatcher for Origin {
+    async fn connect_tcp(&self, session: StreamSession) -> Result<BoxStream, DispatchError> {
+        self.sessions.lock().unwrap().push(session);
+        let (client, mut server) = tokio::io::duplex(4096);
+        let heads = self.heads.clone();
+        let task = tokio::spawn(async move {
+            let mut bytes = Vec::new();
+            while bytes.len() < 32768 {
+                bytes.push(server.read_u8().await.unwrap());
+                if bytes.ends_with(b"\r\n\r\n") {
+                    break;
+                }
+            }
+            heads
+                .lock()
+                .unwrap()
+                .push(String::from_utf8(bytes).unwrap());
+            server
+                .write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok")
+                .await
+                .unwrap();
+            server.shutdown().await.unwrap();
+        });
+        self.tasks.lock().unwrap().push(task);
+        Ok(Box::new(client))
+    }
+    async fn open_datagram(
+        &self,
+        _: DatagramSession,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        Err(DispatchError::NotAllowed)
+    }
+}
+impl Origin {
+    async fn join(&self) {
+        let tasks = std::mem::take(&mut *self.tasks.lock().unwrap());
+        for task in tasks {
+            task.await.unwrap();
+        }
+    }
+}
+struct Entry(HttpContext);
+#[async_trait]
+impl Dispatcher for Entry {
+    fn http_context(&self) -> Option<HttpContext> {
+        Some(self.0.clone())
+    }
+    async fn connect_tcp(&self, _: StreamSession) -> Result<BoxStream, DispatchError> {
+        panic!("HTTP adapter bypassed its fixed generation")
+    }
+    async fn open_datagram(
+        &self,
+        _: DatagramSession,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        Err(DispatchError::NotAllowed)
+    }
+}
+fn session() -> StreamSession {
+    StreamSession {
+        metadata: InboundMetadata::new(80),
+        inbound: InboundKind::Tun,
+        source: "198.18.0.2:54321".parse().unwrap(),
+        destination: Destination::Ip("203.0.113.1:80".parse().unwrap()),
+        sniffed_domain: Some("stale.invalid".into()),
+    }
+}
+fn context(origin: Arc<Origin>) -> HttpContext {
+    HttpContext::new(Policy::compile("rewrite:\n  enabled: true\n  rules:\n  - {url: '^http://old\\.invalid/(.*)$', action: replace, replacement: 'http://new.invalid:8081/$1'}\n").unwrap(),origin,SecurityContext::new())
+}
+#[tokio::test]
+async fn transparent_h1_routes_only_the_final_target_and_preserves_original_facts() {
+    let origin = Arc::new(Origin::default());
+    let context = context(origin.clone());
+    let (mut client, mut server) = tokio::io::duplex(4096);
+    let task = tokio::spawn(async move {
+        assert!(matches!(
+            context
+                .try_intercept(&mut server, session(), CancellationToken::new())
+                .await
+                .unwrap(),
+            Intercept::Handled
+        ));
+    });
+    client
+        .write_all(b"GET /path?q=1 HTTP/1.1\r\nHost: old.invalid\r\nAuthorization: Bearer private\r\nCookie: private=cookie\r\nConnection: close\r\n\r\n")
+        .await
+        .unwrap();
+    let mut response = String::new();
+    timeout(Duration::from_secs(1), client.read_to_string(&mut response))
+        .await
+        .unwrap()
+        .unwrap();
+    task.await.unwrap();
+    origin.join().await;
+    assert!(response.ends_with("\r\n\r\nok"));
+    let sessions = origin.sessions.lock().unwrap();
+    assert_eq!(sessions.len(), 1);
+    assert_eq!(
+        sessions[0].destination,
+        Destination::domain("new.invalid", 8081).unwrap()
+    );
+    assert!(sessions[0].sniffed_domain.is_none());
+    assert_eq!(
+        sessions[0].metadata.original.as_ref().unwrap().destination,
+        session().destination
+    );
+    assert!(origin.heads.lock().unwrap()[0].starts_with("GET /path?q=1 HTTP/1.1\r\n"));
+    assert!(origin.heads.lock().unwrap()[0].contains("Host: new.invalid:8081\r\n"));
+    assert!(
+        !origin.heads.lock().unwrap()[0]
+            .to_ascii_lowercase()
+            .contains("authorization:")
+    );
+    assert!(
+        !origin.heads.lock().unwrap()[0]
+            .to_ascii_lowercase()
+            .contains("cookie:")
+    );
+}
+#[tokio::test]
+async fn mixed_http_and_connect_use_the_same_context_with_preread_bytes() {
+    for request in [b"GET http://old.invalid/path HTTP/1.1\r\nHost: old.invalid\r\nConnection: close\r\n\r\n".as_slice(),b"GET http://old.invalid/path HTTP/1.0\r\nConnection: close\r\n\r\n".as_slice(),b"CONNECT old.invalid:80 HTTP/1.1\r\nHost: old.invalid:80\r\n\r\nGET /path HTTP/1.1\r\nHost: old.invalid\r\nConnection: close\r\n\r\n"] {
+        let origin=Arc::new(Origin::default());let dispatcher:Arc<dyn Dispatcher>=Arc::new(Entry(context(origin.clone())));
+        let (mut client,server)=tokio::io::duplex(4096);
+        let task=tokio::spawn(async move {crate::inbound::http::server::handle_connection_with_deadline(server,"127.0.0.1:30000".parse().unwrap(),"127.0.0.1:1080".parse().unwrap(),dispatcher,crate::inbound::http::HttpServerConfig::processing(),CancellationToken::new(),Instant::now()+Duration::from_secs(1)).await.unwrap();});
+        client.write_all(request).await.unwrap();let mut response=String::new();timeout(Duration::from_secs(1),client.read_to_string(&mut response)).await.unwrap().unwrap();task.await.unwrap();origin.join().await;
+        assert!(response.ends_with("\r\n\r\nok"));assert_eq!(origin.sessions.lock().unwrap().len(),1);
+        assert_eq!(origin.sessions.lock().unwrap()[0].destination,Destination::domain("new.invalid",8081).unwrap());
+    }
+}
+#[tokio::test]
+async fn local_actions_do_not_connect_or_wait_for_an_unread_expect_body() {
+    for (action, replacement, status) in [
+        ("reject", "", 403),
+        (
+            "redirect302",
+            ", replacement-mode: url, replacement: 'https://new.invalid/path'",
+            302,
+        ),
+        (
+            "redirect307",
+            ", replacement-mode: url, replacement: 'https://new.invalid/path'",
+            307,
+        ),
+    ] {
+        let origin = Arc::new(Origin::default());
+        let context = HttpContext::new(
+            Policy::compile(&format!(
+                "rewrite: {{enabled: true, rules: [{{url: '.', action: {action}{replacement}}}]}}"
+            ))
+            .unwrap(),
+            origin.clone(),
+            SecurityContext::new(),
+        );
+        let (mut client, mut server) = tokio::io::duplex(4096);
+        let task = tokio::spawn(async move {
+            context
+                .try_intercept(&mut server, session(), CancellationToken::new())
+                .await
+                .unwrap();
+        });
+        client.write_all(b"POST /path HTTP/1.1\r\nHost: old.invalid\r\nContent-Length: 1048576\r\nExpect: 100-continue\r\n\r\n").await.unwrap();
+        let mut response = String::new();
+        timeout(Duration::from_secs(1), client.read_to_string(&mut response))
+            .await
+            .unwrap()
+            .unwrap();
+        task.await.unwrap();
+        assert!(response.starts_with(&format!("HTTP/1.1 {status}")));
+        assert!(origin.sessions.lock().unwrap().is_empty());
+    }
+}
+#[tokio::test]
+async fn unclaimed_io_replays_every_byte_and_noncandidate_port_does_not_read() {
+    let origin = Arc::new(Origin::default());
+    let context = context(origin.clone());
+    let (mut client, mut server) = tokio::io::duplex(64);
+    client.write_all(b"\x16\x03\x01binary").await.unwrap();
+    let Intercept::Transparent { prefix } = context
+        .try_intercept(&mut server, session(), CancellationToken::new())
+        .await
+        .unwrap()
+    else {
+        panic!()
+    };
+    let mut replay = io::Replay::new(prefix, &mut server);
+    let mut bytes = [0; 9];
+    replay.read_exact(&mut bytes).await.unwrap();
+    assert_eq!(&bytes, b"\x16\x03\x01binary");
+    let mut no_read = session();
+    no_read.destination = Destination::Ip("203.0.113.1:12345".parse().unwrap());
+    assert!(
+        matches!(timeout(Duration::from_millis(100),context.try_intercept(&mut server,no_read,CancellationToken::new())).await.unwrap().unwrap(),Intercept::Transparent{prefix} if prefix.is_empty())
+    );
+    assert!(origin.sessions.lock().unwrap().is_empty());
+}
+
+#[tokio::test]
+async fn same_origin_path_action_preserves_resolved_transport_and_logical_host() {
+    let origin = Arc::new(Origin::default());
+    let context = HttpContext::new(
+        Policy::compile(
+            "rewrite: {enabled: true, rules: [{url: '.', action: replace, replacement-mode: url, replacement: 'http://old.invalid/new'}]}",
+        )
+        .unwrap(),
+        origin.clone(),
+        SecurityContext::new(),
+    );
+    let (mut client, mut server) = tokio::io::duplex(4096);
+    let task = tokio::spawn(async move {
+        context
+            .try_intercept(&mut server, session(), CancellationToken::new())
+            .await
+            .unwrap();
+    });
+    client.write_all(b"GET /old HTTP/1.1\r\nHost: old.invalid\r\nAuthorization: Bearer original\r\nConnection: close\r\n\r\n").await.unwrap();
+    let mut response = String::new();
+    timeout(Duration::from_secs(1), client.read_to_string(&mut response))
+        .await
+        .unwrap()
+        .unwrap();
+    task.await.unwrap();
+    origin.join().await;
+    assert_eq!(
+        origin.sessions.lock().unwrap()[0].destination,
+        session().destination
+    );
+    let heads = origin.heads.lock().unwrap();
+    assert!(heads[0].starts_with("GET /new HTTP/1.1\r\n"));
+    assert!(heads[0].contains("Host: old.invalid:80\r\n"));
+    assert!(heads[0].contains("Authorization: Bearer original\r\n"));
+}
diff --git a/src/inbound/http/framing.rs b/src/inbound/http/framing.rs
index b7581ee..6346e1d 100644
--- a/src/inbound/http/framing.rs
+++ b/src/inbound/http/framing.rs
@@ -9,19 +9,19 @@ use tokio::time::timeout;
 use super::parser::{RequestHead, is_token_byte, parse_headers};
 use crate::session::Destination;
 
-pub(super) const COPY_BUFFER: usize = 8 * 1024;
+pub(crate) const COPY_BUFFER: usize = 8 * 1024;
 const MAX_CHUNK_LINE: usize = 1024;
 const MAX_TRAILERS: usize = 8 * 1024;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub(super) enum Body {
+pub(crate) enum Body {
     Empty,
     Length(u64),
     Chunked,
     UntilEof,
 }
 
-pub(super) struct RequestPlan {
+pub(crate) struct RequestPlan {
     pub destination: Destination,
     pub head: Vec<u8>,
     pub body: Body,
@@ -31,8 +31,41 @@ pub(super) struct RequestPlan {
 }
 
 impl RequestPlan {
+    pub(crate) fn edit_headers(
+        &mut self,
+        edit: impl FnOnce(&mut Vec<(String, String)>),
+    ) -> io::Result<()> {
+        let bytes = self
+            .head
+            .strip_suffix(b"\r\n\r\n")
+            .ok_or_else(|| invalid("incomplete generated HTTP header"))?;
+        let mut request = super::parser::parse_request_head(bytes, Vec::new())?;
+        edit(&mut request.headers);
+        let keep_alive = self.keep_alive;
+        let blocklist = self.trailer_blocklist.clone();
+        let origin = request.target.clone();
+        *self = Self::for_target(&request, self.destination.clone(), origin, false)?;
+        self.keep_alive = keep_alive;
+        self.trailer_blocklist.extend(blocklist);
+        Ok(())
+    }
     pub fn new(request: &RequestHead) -> io::Result<Self> {
-        let framing = Framing::parse(&request.headers)?;
+        let (destination, origin) = request.forward_target()?;
+        Self::for_target(request, destination, origin, false)
+    }
+    pub(crate) fn for_target(
+        request: &RequestHead,
+        destination: Destination,
+        origin: String,
+        strip_origin_credentials: bool,
+    ) -> io::Result<Self> {
+        let mut framing = Framing::parse(&request.headers)?;
+        if strip_origin_credentials {
+            framing.connection.insert("cookie".into());
+            framing
+                .trailers
+                .retain(|name| !name.eq_ignore_ascii_case("cookie"));
+        }
         let body = framing.body.unwrap_or(Body::Empty);
         if request.version == "HTTP/1.0" && body == Body::Chunked {
             return Err(invalid("HTTP/1.0 cannot use chunked framing"));
@@ -57,9 +90,13 @@ impl RequestPlan {
         {
             return Err(invalid("unsupported HTTP expectation"));
         }
-        let (destination, origin) = request.forward_target()?;
         let mut head = format!("{} {} HTTP/1.1\r\n", request.method, origin).into_bytes();
-        append_headers(&mut head, &request.headers, &framing.connection);
+        append_headers(
+            &mut head,
+            &request.headers,
+            &framing.connection,
+            strip_origin_credentials,
+        );
         append(&mut head, "Host", &destination.authority());
         append_framing(&mut head, &framing);
         if upgrade.is_empty() {
@@ -83,7 +120,7 @@ impl RequestPlan {
 }
 
 #[derive(Debug)]
-pub(super) struct ResponseHead {
+pub(crate) struct ResponseHead {
     pub status: u16,
     line: String,
     headers: Vec<(String, String)>,
@@ -91,6 +128,20 @@ pub(super) struct ResponseHead {
 }
 
 impl ResponseHead {
+    pub(crate) fn headers(&self) -> &Vec<(String, String)> {
+        &self.headers
+    }
+    pub(crate) fn edit_headers(
+        &mut self,
+        edit: impl FnOnce(&mut Vec<(String, String)>),
+    ) -> io::Result<()> {
+        let mut candidate = self.headers.clone();
+        edit(&mut candidate);
+        let framing = Framing::parse(&candidate)?;
+        self.headers = candidate;
+        self.framing = framing;
+        Ok(())
+    }
     pub fn parse(bytes: &[u8]) -> io::Result<Self> {
         let text =
             std::str::from_utf8(bytes).map_err(|_| invalid("invalid response head encoding"))?;
@@ -164,7 +215,7 @@ impl ResponseHead {
             self.line.clone()
         };
         let mut head = format!("{line}\r\n").into_bytes();
-        append_headers(&mut head, &self.headers, &self.framing.connection);
+        append_headers(&mut head, &self.headers, &self.framing.connection, false);
         if !legacy || self.framing.body != Some(Body::Chunked) {
             append_framing(&mut head, &self.framing);
         }
@@ -267,7 +318,7 @@ impl Framing {
     }
 }
 
-pub(super) fn validate_connect(request: &RequestHead) -> io::Result<()> {
+pub(crate) fn validate_connect(request: &RequestHead) -> io::Result<()> {
     let framing = Framing::parse(&request.headers)?;
     let hosts = values(&request.headers, "host").count();
     if !matches!(framing.body, None | Some(Body::Length(0)))
@@ -340,7 +391,7 @@ fn stripped(name: &str, connection: &HashSet<String>) -> bool {
         "transfer-encoding",
     ]
     .contains(&name.as_str())
-        || name.starts_with("x-vole-")
+        || name == "x-vole-measure-diagnostic"
         || connection.contains(&name)
 }
 
@@ -348,8 +399,15 @@ fn append_headers(
     output: &mut Vec<u8>,
     headers: &[(String, String)],
     connection: &HashSet<String>,
+    strip_origin_credentials: bool,
 ) {
     for (name, value) in headers {
+        if strip_origin_credentials
+            && (name.eq_ignore_ascii_case("authorization") || name.eq_ignore_ascii_case("cookie"))
+        {
+            continue;
+        }
+
         if !stripped(name, connection) {
             append(output, name, value);
         }
@@ -370,7 +428,7 @@ fn append_framing(output: &mut Vec<u8>, framing: &Framing) {
 }
 
 /// Consume exactly one head; BufReader retains any body or pipelined request.
-pub(super) async fn read_head<R: AsyncBufRead + Unpin>(
+pub(crate) async fn read_head<R: AsyncBufRead + Unpin>(
     reader: &mut R,
     maximum: usize,
 ) -> io::Result<Vec<u8>> {
@@ -388,7 +446,10 @@ pub(super) async fn read_head<R: AsyncBufRead + Unpin>(
     }
 }
 
-async fn read_line<R: AsyncBufRead + Unpin>(reader: &mut R, maximum: usize) -> io::Result<Vec<u8>> {
+pub(crate) async fn read_line<R: AsyncBufRead + Unpin>(
+    reader: &mut R,
+    maximum: usize,
+) -> io::Result<Vec<u8>> {
     let mut line = Vec::with_capacity(maximum.min(128));
     loop {
         let buffer = reader.fill_buf().await?;
@@ -420,7 +481,7 @@ async fn read_line<R: AsyncBufRead + Unpin>(reader: &mut R, maximum: usize) -> i
     }
 }
 
-pub(super) async fn transfer_body<R, W>(
+pub(crate) async fn transfer_body<R, W>(
     reader: &mut R,
     writer: &mut W,
     body: Body,
@@ -486,7 +547,7 @@ where
     timeout_io(idle, writer.flush()).await
 }
 
-fn forbidden_trailer(name: &str, connection: &HashSet<String>) -> bool {
+pub(crate) fn forbidden_trailer(name: &str, connection: &HashSet<String>) -> bool {
     stripped(name, connection)
         || [
             "authorization",
@@ -499,7 +560,7 @@ fn forbidden_trailer(name: &str, connection: &HashSet<String>) -> bool {
         .any(|field| name.eq_ignore_ascii_case(field))
 }
 
-fn chunk_size(line: &[u8]) -> io::Result<u64> {
+pub(crate) fn chunk_size(line: &[u8]) -> io::Result<u64> {
     let text = line
         .strip_suffix(b"\r\n")
         .ok_or_else(|| invalid("invalid chunk line"))?;
@@ -600,7 +661,7 @@ where
     Ok(())
 }
 
-pub(super) async fn timeout_io<T>(
+pub(crate) async fn timeout_io<T>(
     duration: Duration,
     future: impl std::future::Future<Output = io::Result<T>>,
 ) -> io::Result<T> {
@@ -609,7 +670,7 @@ pub(super) async fn timeout_io<T>(
         .map_err(|_| io::Error::new(io::ErrorKind::TimedOut, "HTTP I/O timed out"))?
 }
 
-pub(super) async fn write_timed<W: AsyncWrite + Unpin>(
+pub(crate) async fn write_timed<W: AsyncWrite + Unpin>(
     writer: &mut W,
     bytes: &[u8],
     idle: Duration,
diff --git a/src/inbound/http/mod.rs b/src/inbound/http/mod.rs
index 689d835..79db0b5 100644
--- a/src/inbound/http/mod.rs
+++ b/src/inbound/http/mod.rs
@@ -1,13 +1,13 @@
 #[cfg(feature = "inbound-http")]
-mod framing;
-mod parser;
+pub(crate) mod framing;
+pub(crate) mod parser;
 #[cfg(feature = "inbound-http")]
-mod server;
+pub(crate) mod server;
 
 #[cfg(all(test, feature = "inbound-http"))]
 mod tests;
 
-pub(crate) use parser::read_request_head;
+pub(crate) use parser::{RequestHead, read_request_head};
 #[cfg(all(feature = "inbound-http", feature = "inbound-socks5"))]
 pub(crate) use server::handle_connection_with_deadline;
 #[cfg(feature = "inbound-http")]
diff --git a/src/inbound/http/parser.rs b/src/inbound/http/parser.rs
index ac61e8f..c9c469d 100644
--- a/src/inbound/http/parser.rs
+++ b/src/inbound/http/parser.rs
@@ -7,7 +7,7 @@ use crate::session::Destination;
 
 use super::super::DEFAULT_HEADER_COUNT_LIMIT;
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct RequestHead {
     pub method: String,
     pub target: String,
@@ -109,7 +109,7 @@ where
     parse_request_head(&input, buffered)
 }
 
-pub(super) fn parse_request_head(input: &[u8], buffered: Vec<u8>) -> io::Result<RequestHead> {
+pub(crate) fn parse_request_head(input: &[u8], buffered: Vec<u8>) -> io::Result<RequestHead> {
     let head =
         std::str::from_utf8(input).map_err(|_| invalid("HTTP request head is not valid UTF-8"))?;
     let mut lines = head.split("\r\n");
@@ -141,7 +141,7 @@ pub(super) fn parse_request_head(input: &[u8], buffered: Vec<u8>) -> io::Result<
     })
 }
 
-pub(super) fn parse_headers<'a>(
+pub(crate) fn parse_headers<'a>(
     lines: impl Iterator<Item = &'a str>,
 ) -> io::Result<Vec<(String, String)>> {
     let mut headers = Vec::new();
diff --git a/src/inbound/http/server.rs b/src/inbound/http/server.rs
index c414d03..1099437 100644
--- a/src/inbound/http/server.rs
+++ b/src/inbound/http/server.rs
@@ -21,7 +21,7 @@ use crate::{
     outbound::{
         MAX_OUTBOUND_DIAGNOSTIC_MESSAGE_BYTES, OutboundDiagnostic, capture_outbound_diagnostic,
     },
-    session::{InboundKind, StreamSession},
+    session::{InboundKind, InboundMetadata, StreamSession},
 };
 
 use super::super::{
@@ -29,9 +29,7 @@ use super::super::{
     listen::{bind_proxy_tcp, bind_tcp},
 };
 use super::{
-    framing::{
-        self, Body, RequestPlan, ResponseHead, read_head, timeout_io, transfer_body, write_timed,
-    },
+    framing::{self, Body, RequestPlan, ResponseHead, read_head, timeout_io, write_timed},
     parser::{RequestHead, parse_request_head},
 };
 
@@ -52,6 +50,18 @@ pub struct HttpServerConfig {
 }
 
 impl HttpServerConfig {
+    pub(crate) fn processing() -> Self {
+        Self {
+            listen: ([127, 0, 0, 1], 0).into(),
+            auth: None,
+            ipv6: false,
+            header_limit: DEFAULT_HEADER_LIMIT,
+            header_timeout: Duration::from_secs(10),
+            connect_timeout: Duration::from_secs(10),
+            body_idle_timeout: Duration::from_secs(30),
+        }
+    }
+
     pub fn loopback(listen: SocketAddr, auth: HttpBasicAuth) -> io::Result<Self> {
         if !listen.ip().is_loopback() {
             return Err(io::Error::new(
@@ -62,6 +72,7 @@ impl HttpServerConfig {
         let mut config = Self::proxy(
             listen.port(),
             ProxyAccess {
+                bind_address: None,
                 allow_lan: false,
                 ipv6: false,
             },
@@ -114,6 +125,7 @@ impl HttpServer {
             bind_proxy_tcp(
                 config.listen.port(),
                 ProxyAccess {
+                    bind_address: None,
                     allow_lan: config.listen.ip().is_unspecified(),
                     ipv6: true,
                 },
@@ -178,19 +190,30 @@ pub(crate) async fn handle_connection(
     cancellation: CancellationToken,
 ) -> io::Result<()> {
     let deadline = Instant::now() + config.header_timeout;
-    handle_connection_with_deadline(inbound, peer, dispatcher, config, cancellation, deadline).await
+    let local_address = inbound.local_addr()?;
+    handle_connection_with_deadline(
+        inbound,
+        peer,
+        local_address,
+        dispatcher,
+        config,
+        cancellation,
+        deadline,
+    )
+    .await
 }
 
 pub(crate) async fn handle_connection_with_deadline<S>(
     inbound: S,
     peer: SocketAddr,
+    local_address: SocketAddr,
     dispatcher: Arc<dyn Dispatcher>,
     config: HttpServerConfig,
     cancellation: CancellationToken,
     deadline: Instant,
 ) -> io::Result<()>
 where
-    S: AsyncRead + AsyncWrite + Unpin,
+    S: AsyncRead + AsyncWrite + Unpin + Send,
 {
     // This cancellation boundary covers every read, write, handshake and tunnel,
     // including error responses to a client that has stopped reading.
@@ -200,7 +223,7 @@ where
         result = async {
             let (read, mut write) = tokio::io::split(inbound);
             let mut reader = BufReader::with_capacity(framing::COPY_BUFFER, read);
-            serve_requests(&mut reader, &mut write, peer, &dispatcher, &config, deadline).await
+            serve_requests(&mut reader, &mut write, peer, local_address, &dispatcher, &config, (deadline,&cancellation)).await
         } => result,
     }
 }
@@ -209,15 +232,17 @@ async fn serve_requests<R, W>(
     reader: &mut R,
     writer: &mut W,
     peer: SocketAddr,
+    local_address: SocketAddr,
     dispatcher: &Arc<dyn Dispatcher>,
     config: &HttpServerConfig,
-    first_deadline: Instant,
+    scope: (Instant, &CancellationToken),
 ) -> io::Result<()>
 where
-    R: AsyncBufRead + Unpin,
-    W: AsyncWrite + Unpin,
+    R: AsyncBufRead + Unpin + Send,
+    W: AsyncWrite + Unpin + Send,
 {
-    let mut deadline = first_deadline;
+    let (mut deadline, cancellation) = scope;
+    let http = dispatcher.http_context();
     loop {
         let request = timeout_at(deadline, async {
             if reader.fill_buf().await?.is_empty() {
@@ -242,14 +267,16 @@ where
                 return Err(error);
             }
         };
-        if config
-            .auth
-            .as_ref()
-            .is_some_and(|auth| !auth.verifies(&request.headers))
-        {
-            write_auth_required(writer).await?;
-            return Ok(());
-        }
+        let user = match &config.auth {
+            Some(auth) => match auth.authenticate_headers(&request.headers) {
+                Some(user) => Some(user),
+                None => {
+                    write_auth_required(writer).await?;
+                    return Ok(());
+                }
+            },
+            None => None,
+        };
         let diagnostic = request.is_connect()
             && config.auth.is_some()
             && config.listen.ip().is_loopback()
@@ -258,6 +285,10 @@ where
         let forward = if request.is_connect() {
             framing::validate_connect(&request)
                 .and_then(|()| request.connect_destination().map(|target| (target, None)))
+        } else if http.is_some() {
+            request
+                .forward_target()
+                .map(|(destination, _)| (destination, None))
         } else {
             RequestPlan::new(&request).map(|plan| (plan.destination.clone(), Some(plan)))
         };
@@ -268,35 +299,169 @@ where
                 return Err(error);
             }
         };
-        let session = StreamSession {
-            inbound: InboundKind::Http,
+        let mut session = StreamSession {
+            metadata: InboundMetadata {
+                local_port: local_address.port(),
+                local_address: Some(local_address),
+                user,
+                ..Default::default()
+            },
+            inbound: if request.is_connect() {
+                InboundKind::Https
+            } else {
+                InboundKind::Http
+            },
             source: peer,
             destination,
             sniffed_domain: None,
         };
-        let outbound = connect(dispatcher, session, config, writer, diagnostic).await?;
-        if let Some(plan) = plan {
-            if !forward_request(reader, writer, outbound, &request, plan, config).await? {
-                return Ok(());
+        if let Some(http) = &http {
+            if !request.is_connect() {
+                if !http
+                    .forward_h1(
+                        reader,
+                        writer,
+                        &request,
+                        session,
+                        crate::http_processing::Scheme::Http,
+                        config,
+                    )
+                    .await?
+                {
+                    return Ok(());
+                }
+                deadline = Instant::now() + config.header_timeout;
+                continue;
             }
-            deadline = Instant::now() + config.header_timeout;
-        } else {
+            if http.candidate_port(session.destination.port()) {
+                write_timed(
+                    writer,
+                    b"HTTP/1.1 200 Connection Established\r\n\r\n",
+                    config.header_timeout,
+                )
+                .await?;
+                let mut io = crate::http_processing::io::Joined {
+                    reader: &mut *reader,
+                    writer: &mut *writer,
+                };
+                let outcome = http
+                    .try_intercept(&mut io, session.clone(), cancellation.clone())
+                    .await?;
+                return match outcome {
+                    crate::http_processing::Intercept::Handled => Ok(()),
+                    crate::http_processing::Intercept::Transparent { prefix } => {
+                        forward_tunnel(
+                            reader,
+                            writer,
+                            prefix,
+                            session,
+                            http.dispatcher(),
+                            config,
+                            true,
+                            diagnostic,
+                        )
+                        .await
+                    }
+                };
+            }
+        }
+        if request.is_connect() {
+            let dispatcher = http.as_ref().map_or(dispatcher, |http| http.dispatcher());
+            return forward_tunnel(
+                reader,
+                writer,
+                Vec::new(),
+                session,
+                dispatcher,
+                config,
+                false,
+                diagnostic,
+            )
+            .await;
+        }
+        let sniff = dispatcher
+            .sniff_plan(peer, &session.destination)
+            .await
+            .map_err(|_| io::Error::other("sniffer rule evaluation failed"))?
+            .filter(|plan| plan.tcp_enabled());
+        if let (Some(forward), Some(sniff)) = (&plan, &sniff) {
+            let _prefix = sniff
+                .sniff(&mut forward.head.as_slice(), &mut session)
+                .await
+                .map_err(|_| io::Error::other("sniffer rule evaluation failed"))?;
+        }
+        let outbound = connect(dispatcher, session, config, writer, diagnostic).await?;
+        let plan = plan.expect("non-CONNECT forwarding has a message plan");
+        if !forward_request(reader, writer, outbound, &request, plan, config).await? {
+            return Ok(());
+        }
+        deadline = Instant::now() + config.header_timeout;
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn forward_tunnel<R: AsyncRead + Unpin, W: AsyncWrite + Unpin>(
+    reader: &mut R,
+    writer: &mut W,
+    prefix: Vec<u8>,
+    mut session: StreamSession,
+    dispatcher: &Arc<dyn Dispatcher>,
+    config: &HttpServerConfig,
+    mut acknowledged: bool,
+    diagnostic: bool,
+) -> io::Result<()> {
+    let mut reader = crate::http_processing::io::Replay::new(prefix, reader);
+    let sniff = dispatcher
+        .sniff_plan(session.source, &session.destination)
+        .await
+        .map_err(|_| io::Error::other("sniffer rule evaluation failed"))?
+        .filter(|plan| plan.tcp_enabled());
+    let prefetched = if let Some(sniff) = sniff {
+        if !acknowledged {
             write_timed(
                 writer,
                 b"HTTP/1.1 200 Connection Established\r\n\r\n",
                 config.header_timeout,
             )
             .await?;
-            let (mut remote_read, mut remote_write) = tokio::io::split(outbound);
-            return relay(reader, writer, &mut remote_read, &mut remote_write).await;
+            acknowledged = true;
         }
+        sniff
+            .sniff(&mut reader, &mut session)
+            .await
+            .map_err(|_| io::Error::other("sniffer rule evaluation failed"))?
+    } else {
+        Vec::new()
+    };
+    let mut outbound = if acknowledged {
+        timeout(config.connect_timeout, dispatcher.connect_tcp(session))
+            .await
+            .map_err(|_| {
+                io::Error::new(io::ErrorKind::TimedOut, "HTTP outbound connect timed out")
+            })?
+            .map_err(dispatch_to_io)?
+    } else {
+        connect(dispatcher, session, config, writer, diagnostic).await?
+    };
+    if !acknowledged {
+        write_timed(
+            writer,
+            b"HTTP/1.1 200 Connection Established\r\n\r\n",
+            config.header_timeout,
+        )
+        .await?;
+    }
+    if !prefetched.is_empty() {
+        write_timed(&mut outbound, &prefetched, config.connect_timeout).await?;
     }
+    let (mut remote_read, mut remote_write) = tokio::io::split(outbound);
+    relay(&mut reader, writer, &mut remote_read, &mut remote_write).await
 }
 
-async fn forward_request<R, W>(
+pub(crate) async fn forward_request<R, W>(
     reader: &mut R,
     writer: &mut W,
-    mut outbound: BoxStream,
+    outbound: BoxStream,
     request: &RequestHead,
     plan: RequestPlan,
     config: &HttpServerConfig,
@@ -305,20 +470,67 @@ where
     R: AsyncBufRead + Unpin,
     W: AsyncWrite + Unpin,
 {
+    forward_request_inner(reader, writer, outbound, request, plan, config, None).await
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(crate) async fn forward_processed<R: AsyncBufRead + Unpin, W: AsyncWrite + Unpin>(
+    reader: &mut R,
+    writer: &mut W,
+    outbound: BoxStream,
+    request: &RequestHead,
+    plan: RequestPlan,
+    config: &HttpServerConfig,
+    processing: &crate::http_processing::h1_body::Message<'_>,
+) -> io::Result<bool> {
+    forward_request_inner(
+        reader,
+        writer,
+        outbound,
+        request,
+        plan,
+        config,
+        Some(processing),
+    )
+    .await
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn forward_request_inner<R: AsyncBufRead + Unpin, W: AsyncWrite + Unpin>(
+    reader: &mut R,
+    writer: &mut W,
+    mut outbound: BoxStream,
+    request: &RequestHead,
+    mut plan: RequestPlan,
+    config: &HttpServerConfig,
+    processing: Option<&crate::http_processing::h1_body::Message<'_>>,
+) -> io::Result<bool> {
+    let upload = match processing {
+        Some(processing) => {
+            processing
+                .request(reader, writer, &mut plan, config)
+                .await?
+        }
+        None => crate::http_processing::h1_body::PreparedBody::original(plan.body),
+    };
     write_timed(&mut outbound, &plan.head, config.connect_timeout).await?;
+    // Some protocol transports accept the head into an internal frame. Empty
+    // requests never poll the body sender, so publish the head before reading.
+    timeout_io(config.connect_timeout, outbound.flush()).await?;
     let (remote_read, mut remote_write) = tokio::io::split(outbound);
     let mut remote_read = BufReader::with_capacity(framing::COPY_BUFFER, remote_read);
-    let mut uploading = Box::pin(transfer_body(
+    let mut uploading = Box::pin(upload.transfer(
         reader,
         &mut remote_write,
-        plan.body,
         config.body_idle_timeout,
         &plan.trailer_blocklist,
         false,
     ));
-    let mut uploaded = false;
+    // Empty bodies are already complete. Reading a ready 101 first must not
+    // turn an otherwise valid Upgrade into an apparent early response.
+    let mut uploaded = matches!(plan.body, Body::Empty | Body::Length(0));
     let mut informational = 0;
-    let response = loop {
+    let mut response = loop {
         let mut reading = Box::pin(async {
             // Waiting for the first response byte may overlap a large upload.
             // Once headers begin, their total read deadline is absolute.
@@ -337,10 +549,15 @@ where
         });
         let response = loop {
             if uploaded {
-                break timeout_io(config.header_timeout, &mut reading).await;
+                // A completed local write does not mean the origin has consumed
+                // the body. Keep its response wait within the body idle budget.
+                break timeout_io(config.body_idle_timeout, &mut reading).await;
             }
             tokio::select! {
                 biased;
+                // Preserve an already available upstream response even when
+                // its request side closed at the same time as our upload.
+                response = &mut reading => break response,
                 result = &mut uploading => {
                     if let Err(error) = result {
                         write_error(writer, if error.kind() == io::ErrorKind::TimedOut { 408 } else { 400 }).await?;
@@ -348,10 +565,9 @@ where
                     }
                     uploaded = true;
                 }
-                response = &mut reading => break response,
             }
         };
-        let response = match response {
+        let mut response = match response {
             Ok(value) => value,
             Err(error) => {
                 write_error(
@@ -375,13 +591,22 @@ where
                     "too many informational responses",
                 ));
             }
-            if request.version == "HTTP/1.1" {
+            if request.version == "HTTP/1.1"
+                && !(processing.is_some_and(|processing| processing.suppress_continue())
+                    && response.status == 100)
+            {
+                if let Some(processing) = processing {
+                    processing.response_headers(&mut response)?;
+                }
                 write_timed(
                     writer,
                     &response.encode(false, false, false),
                     config.header_timeout,
                 )
                 .await?;
+                // A client waiting for 100 cannot produce its body until this
+                // handshake response leaves any downstream transport buffer.
+                timeout_io(config.header_timeout, writer.flush()).await?;
             }
             continue;
         }
@@ -398,16 +623,28 @@ where
                 "invalid HTTP protocol switch",
             ));
         }
+        if let Some(processing) = processing {
+            processing.response_headers(&mut response)?;
+        }
         write_timed(
             writer,
             &response.encode(false, true, false),
             config.header_timeout,
         )
         .await?;
+        timeout_io(config.header_timeout, writer.flush()).await?;
         relay(reader, writer, &mut remote_read, &mut remote_write).await?;
         return Ok(false);
     }
     let body = response.body(&request.method);
+    let download = match processing {
+        Some(processing) => {
+            processing
+                .response(&mut remote_read, &mut response, config)
+                .await?
+        }
+        None => crate::http_processing::h1_body::PreparedBody::original(body),
+    };
     let legacy = request.version == "HTTP/1.0";
     let dechunk = legacy && body == Body::Chunked;
     let keep_alive = plan.keep_alive && uploaded && body != Body::UntilEof && !dechunk;
@@ -417,15 +654,15 @@ where
         config.header_timeout,
     )
     .await?;
-    transfer_body(
-        &mut remote_read,
-        writer,
-        body,
-        config.body_idle_timeout,
-        response.trailer_blocklist(),
-        dechunk,
-    )
-    .await?;
+    download
+        .transfer(
+            &mut remote_read,
+            writer,
+            config.body_idle_timeout,
+            response.trailer_blocklist(),
+            dechunk,
+        )
+        .await?;
     Ok(keep_alive)
 }
 
@@ -541,7 +778,7 @@ fn dispatch_to_io(error: DispatchError) -> io::Error {
         DispatchError::HostUnreachable => io::ErrorKind::HostUnreachable,
         DispatchError::ConnectionRefused => io::ErrorKind::ConnectionRefused,
         DispatchError::TimedOut => io::ErrorKind::TimedOut,
-        DispatchError::Other(_) => io::ErrorKind::Other,
+        DispatchError::Other(_) | DispatchError::RuleEvaluation(_) => io::ErrorKind::Other,
     };
     io::Error::new(kind, error)
 }
@@ -688,12 +925,12 @@ mod tests {
         assert!(!auth.verifies(&[("Proxy-Authorization".to_owned(), "Basic !!!".to_owned(),)]));
         assert_eq!(format!("{auth:?}"), "ProxyCredentials { .. }");
 
-        assert!(HttpBasicAuth::new("", "password").is_err());
-        assert!(HttpBasicAuth::new("user", "").is_err());
+        assert!(HttpBasicAuth::new("", "password").is_ok());
+        assert!(HttpBasicAuth::new("user", "").is_ok());
         assert!(HttpBasicAuth::new("user:name", "password").is_err());
         assert!(HttpBasicAuth::new("u".repeat(255), "p".repeat(255)).is_ok());
-        assert!(HttpBasicAuth::new("u".repeat(256), "password").is_err());
-        assert!(HttpBasicAuth::new("user", "p".repeat(256)).is_err());
+        assert!(HttpBasicAuth::new("u".repeat(256), "password").is_ok());
+        assert!(HttpBasicAuth::new("user", "p".repeat(256)).is_ok());
     }
 
     #[tokio::test]
@@ -880,6 +1117,7 @@ mod tests {
             let config = HttpServerConfig::proxy(
                 0,
                 ProxyAccess {
+                    bind_address: None,
                     allow_lan: shared,
                     ipv6: false,
                 },
@@ -952,3 +1190,290 @@ mod tests {
         task.await.unwrap().unwrap();
     }
 }
+
+#[cfg(test)]
+mod early_final_memory_tests {
+    use super::*;
+    use std::{
+        pin::Pin,
+        task::{Context, Poll},
+    };
+    use tokio::io::{DuplexStream, ReadBuf};
+
+    // A real duplex peer has a complete early response ready while rejecting
+    // subsequent request-body writes. No socket or detached peer is needed.
+    struct ClosedRequestHalf {
+        io: DuplexStream,
+        head_written: bool,
+    }
+    impl AsyncRead for ClosedRequestHalf {
+        fn poll_read(
+            mut self: Pin<&mut Self>,
+            cx: &mut Context<'_>,
+            buf: &mut ReadBuf<'_>,
+        ) -> Poll<io::Result<()>> {
+            Pin::new(&mut self.io).poll_read(cx, buf)
+        }
+    }
+    impl AsyncWrite for ClosedRequestHalf {
+        fn poll_write(
+            mut self: Pin<&mut Self>,
+            cx: &mut Context<'_>,
+            buf: &[u8],
+        ) -> Poll<io::Result<usize>> {
+            if self.head_written {
+                return Poll::Ready(Err(io::ErrorKind::BrokenPipe.into()));
+            }
+            let result = Pin::new(&mut self.io).poll_write(cx, buf);
+            if matches!(result, Poll::Ready(Ok(_))) {
+                self.head_written = true;
+            }
+            result
+        }
+        fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Pin::new(&mut self.io).poll_flush(cx)
+        }
+        fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Pin::new(&mut self.io).poll_shutdown(cx)
+        }
+    }
+    #[tokio::test]
+    async fn ready_final_response_wins_over_simultaneous_upload_failure() {
+        let (outbound, mut peer) = tokio::io::duplex(4096);
+        peer.write_all(b"HTTP/1.1 413 Content Too Large\r\nContent-Length: 3\r\n\r\nbad")
+            .await
+            .unwrap();
+        let request = parse_request_head(
+            b"POST http://origin.test/ HTTP/1.1\r\nHost: origin.test\r\nContent-Length: 6",
+            Vec::new(),
+        )
+        .unwrap();
+        let plan = RequestPlan::new(&request).unwrap();
+        let config = HttpServerConfig::proxy(
+            0,
+            ProxyAccess {
+                bind_address: None,
+                allow_lan: false,
+                ipv6: false,
+            },
+            None,
+        )
+        .unwrap();
+        let mut reader = BufReader::new(b"upload".as_slice());
+        let mut response = Vec::new();
+        let keep_alive = timeout(
+            Duration::from_secs(1),
+            forward_request(
+                &mut reader,
+                &mut response,
+                Box::new(ClosedRequestHalf {
+                    io: outbound,
+                    head_written: false,
+                }),
+                &request,
+                plan,
+                &config,
+            ),
+        )
+        .await
+        .unwrap()
+        .unwrap();
+        assert!(!keep_alive);
+        assert!(response.starts_with(b"HTTP/1.1 413 Content Too Large\r\n"));
+        assert!(response.ends_with(b"\r\n\r\nbad"));
+    }
+    #[tokio::test]
+    async fn ready_upgrade_without_request_body_preserves_the_tunnel() {
+        let (outbound, mut peer) = tokio::io::duplex(4096);
+        peer.write_all(b"HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nUpgrade: websocket\r\n\r\necho").await.unwrap();
+        peer.shutdown().await.unwrap();
+        let request=parse_request_head(b"GET http://origin.test/ HTTP/1.1\r\nHost: origin.test\r\nConnection: Upgrade\r\nUpgrade: websocket",Vec::new()).unwrap();
+        let plan = RequestPlan::new(&request).unwrap();
+        let config = HttpServerConfig::proxy(
+            0,
+            ProxyAccess {
+                bind_address: None,
+                allow_lan: false,
+                ipv6: false,
+            },
+            None,
+        )
+        .unwrap();
+        let mut reader = BufReader::new(b"".as_slice());
+        let mut response = Vec::new();
+        let keep_alive = timeout(
+            Duration::from_secs(1),
+            forward_request(
+                &mut reader,
+                &mut response,
+                Box::new(ClosedRequestHalf {
+                    io: outbound,
+                    head_written: false,
+                }),
+                &request,
+                plan,
+                &config,
+            ),
+        )
+        .await
+        .unwrap()
+        .unwrap();
+        assert!(!keep_alive);
+        assert!(response.starts_with(b"HTTP/1.1 101 Switching Protocols\r\n"));
+        assert!(response.ends_with(b"\r\n\r\necho"));
+    }
+}
+
+#[cfg(test)]
+mod response_deadline_memory_tests {
+    use super::*;
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+    #[tokio::test(start_paused = true)]
+    async fn uploaded_body_allows_first_response_after_header_timeout() {
+        let request = parse_request_head(
+            b"POST http://origin.test/ HTTP/1.1\r\nHost: origin.test\r\nContent-Length: 6\r\nConnection: close",
+            Vec::new(),
+        )
+        .unwrap();
+        let plan = RequestPlan::new(&request).unwrap();
+        let (outbound, peer) = tokio::io::duplex(1024);
+        let forward = tokio::spawn(async move {
+            let mut reader = BufReader::new(b"upload".as_slice());
+            let mut response = Vec::new();
+            let start = Instant::now();
+            let result = forward_request(
+                &mut reader,
+                &mut response,
+                Box::new(outbound),
+                &request,
+                plan,
+                &HttpServerConfig::processing(),
+            )
+            .await;
+            (result, response, start.elapsed())
+        });
+        let peer = tokio::spawn(async move {
+            let mut peer = BufReader::new(peer);
+            read_head(&mut peer, DEFAULT_HEADER_LIMIT).await?;
+            let mut body = [0_u8; 6];
+            peer.read_exact(&mut body).await?;
+            // The entire real upload has reached the peer before this delay.
+            tokio::time::sleep(Duration::from_secs(11)).await;
+            peer.get_mut()
+                .write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok")
+                .await?;
+            peer.get_mut().shutdown().await?;
+            Ok::<_, io::Error>(body)
+        });
+
+        // Join both owners even on the expected RED timeout/BrokenPipe path.
+        let (forward, peer) = tokio::join!(forward, peer);
+        let (result, response, elapsed) = forward.unwrap();
+        assert!(result.is_ok(), "late first response failed: {result:?}");
+        assert!(!result.unwrap());
+        assert_eq!(peer.unwrap().unwrap(), *b"upload");
+        assert!(response.starts_with(b"HTTP/1.1 200 OK\r\n"));
+        assert!(response.ends_with(b"\r\n\r\nok"));
+        assert!(elapsed >= Duration::from_secs(11) && elapsed < Duration::from_secs(12));
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn started_response_head_retains_its_absolute_header_deadline() {
+        let request = parse_request_head(
+            b"POST http://origin.test/ HTTP/1.1\r\nHost: origin.test\r\nContent-Length: 6\r\nConnection: close",
+            Vec::new(),
+        )
+        .unwrap();
+        let plan = RequestPlan::new(&request).unwrap();
+        let (outbound, peer) = tokio::io::duplex(1024);
+        let forward = tokio::spawn(async move {
+            let mut reader = BufReader::new(b"upload".as_slice());
+            let mut response = Vec::new();
+            let start = Instant::now();
+            let result = forward_request(
+                &mut reader,
+                &mut response,
+                Box::new(outbound),
+                &request,
+                plan,
+                &HttpServerConfig::processing(),
+            )
+            .await;
+            (result, response, start.elapsed())
+        });
+        let peer = tokio::spawn(async move {
+            let mut peer = BufReader::new(peer);
+            read_head(&mut peer, DEFAULT_HEADER_LIMIT).await?;
+            let mut body = [0_u8; 6];
+            peer.read_exact(&mut body).await?;
+            tokio::time::sleep(Duration::from_secs(5)).await;
+            peer.get_mut().write_all(b"HTTP/1.1 200").await?;
+            // Keep the real response half open beyond its ten-second header
+            // deadline, without EOF or a failed write causing the outcome.
+            tokio::time::sleep(Duration::from_secs(11)).await;
+            Ok::<_, io::Error>(body)
+        });
+
+        let (forward, peer) = tokio::join!(forward, peer);
+        let (result, response, elapsed) = forward.unwrap();
+        assert_eq!(peer.unwrap().unwrap(), *b"upload");
+        assert_eq!(result.unwrap_err().kind(), io::ErrorKind::TimedOut);
+        assert!(response.starts_with(b"HTTP/1.1 504 Gateway Timeout\r\n"));
+        // First byte at t=5; the unchanged absolute read_head deadline is t=15.
+        assert!(elapsed >= Duration::from_secs(15) && elapsed < Duration::from_secs(16));
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn no_first_response_is_bounded_by_postupload_deadline() {
+        for starts_partial_head in [false, true] {
+            let request = parse_request_head(
+                b"POST http://origin.test/ HTTP/1.1\r\nHost: origin.test\r\nContent-Length: 6\r\nConnection: close",
+                Vec::new(),
+            )
+            .unwrap();
+            let plan = RequestPlan::new(&request).unwrap();
+            let (outbound, peer) = tokio::io::duplex(1024);
+            let forward = tokio::spawn(async move {
+                let mut reader = BufReader::new(b"upload".as_slice());
+                let mut response = Vec::new();
+                let start = Instant::now();
+                let result = forward_request(
+                    &mut reader,
+                    &mut response,
+                    Box::new(outbound),
+                    &request,
+                    plan,
+                    &HttpServerConfig::processing(),
+                )
+                .await;
+                (result, response, start.elapsed())
+            });
+            let peer = tokio::spawn(async move {
+                let mut peer = BufReader::new(peer);
+                read_head(&mut peer, DEFAULT_HEADER_LIMIT).await?;
+                let mut body = [0_u8; 6];
+                peer.read_exact(&mut body).await?;
+                if starts_partial_head {
+                    tokio::time::sleep(Duration::from_secs(29)).await;
+                    peer.get_mut().write_all(b"HTTP/1.1 200").await?;
+                    tokio::time::sleep(Duration::from_secs(2)).await;
+                } else {
+                    tokio::time::sleep(Duration::from_secs(31)).await;
+                }
+                // Keep the response half alive to t=31, beyond the outer deadline.
+                Ok::<_, io::Error>(body)
+            });
+
+            let (forward, peer) = tokio::join!(forward, peer);
+            let (result, response, elapsed) = forward.unwrap();
+            assert_eq!(peer.unwrap().unwrap(), *b"upload");
+            assert_eq!(result.unwrap_err().kind(), io::ErrorKind::TimedOut);
+            assert!(response.starts_with(b"HTTP/1.1 504 Gateway Timeout\r\n"));
+            assert!(
+                elapsed >= Duration::from_secs(30) && elapsed < Duration::from_secs(31),
+                "post-upload deadline differs: partial_head={starts_partial_head}, elapsed={elapsed:?}"
+            );
+        }
+    }
+}
diff --git a/src/inbound/http/tests.rs b/src/inbound/http/tests.rs
index d96b266..1a93c65 100644
--- a/src/inbound/http/tests.rs
+++ b/src/inbound/http/tests.rs
@@ -74,6 +74,7 @@ impl Fixture {
         let mut config = HttpServerConfig::proxy(
             0,
             ProxyAccess {
+                bind_address: None,
                 allow_lan: false,
                 ipv6: false,
             },
@@ -187,6 +188,7 @@ async fn local_no_auth_and_shared_auth_work_on_both_loopback_families() {
             *config = HttpServerConfig::proxy(
                 0,
                 ProxyAccess {
+                    bind_address: None,
                     allow_lan: shared,
                     ipv6: true,
                 },
@@ -341,6 +343,7 @@ async fn keep_alive_requests_reenter_the_real_rule_dispatcher() {
     let config = HttpServerConfig::proxy(
         0,
         ProxyAccess {
+            bind_address: None,
             allow_lan: false,
             ipv6: false,
         },
diff --git a/src/inbound/listen.rs b/src/inbound/listen.rs
index 0e27812..b6c9914 100644
--- a/src/inbound/listen.rs
+++ b/src/inbound/listen.rs
@@ -31,6 +31,11 @@ pub(crate) fn bind_tcp(address: SocketAddr) -> io::Result<TcpListener> {
 }
 
 pub(crate) fn bind_proxy_tcp(port: u16, access: ProxyAccess) -> io::Result<Vec<TcpListener>> {
+    if access.allow_lan
+        && let Some(address) = access.bind_address
+    {
+        return Ok(vec![bind_tcp(SocketAddr::new(address, port))?]);
+    }
     let ipv4 = if access.allow_lan {
         Ipv4Addr::UNSPECIFIED
     } else {
@@ -109,7 +114,15 @@ mod tests {
     async fn policy_binds_loopback_or_wildcard_and_respects_ipv6() {
         for allow_lan in [false, true] {
             for ipv6 in [false, true] {
-                let listeners = bind_proxy_tcp(0, ProxyAccess { allow_lan, ipv6 }).unwrap();
+                let listeners = bind_proxy_tcp(
+                    0,
+                    ProxyAccess {
+                        bind_address: None,
+                        allow_lan,
+                        ipv6,
+                    },
+                )
+                .unwrap();
                 let port = listeners[0].local_addr().unwrap().port();
                 if !ipv6 {
                     assert_eq!(listeners.len(), 1);
@@ -138,6 +151,7 @@ mod tests {
         let error = bind_proxy_tcp(
             port,
             ProxyAccess {
+                bind_address: None,
                 allow_lan: false,
                 ipv6: true,
             },
diff --git a/src/inbound/mixed.rs b/src/inbound/mixed.rs
index 2d923f5..95fe50a 100644
--- a/src/inbound/mixed.rs
+++ b/src/inbound/mixed.rs
@@ -23,6 +23,8 @@ use super::{
 const HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(10);
 
 pub struct MixedServer {
+    connections: crate::config::ConnectionSettings,
+    access_rules: Arc<crate::config::ProxyAccessRules>,
     listeners: Vec<TcpListener>,
     sockets: Vec<Arc<UdpSocket>>,
     http: HttpServerConfig,
@@ -31,6 +33,10 @@ pub struct MixedServer {
 }
 
 impl MixedServer {
+    pub(crate) fn with_connections(mut self, settings: crate::config::ConnectionSettings) -> Self {
+        self.connections = settings;
+        self
+    }
     pub fn bind(config: MixedInboundConfig, dispatcher: Arc<dyn Dispatcher>) -> io::Result<Self> {
         let http = HttpServerConfig::proxy(config.port, config.access, config.auth.clone())?;
         let listeners = bind_proxy_tcp(config.port, config.access)?;
@@ -50,6 +56,8 @@ impl MixedServer {
             dispatcher.clone(),
         );
         Ok(Self {
+            connections: crate::config::ConnectionSettings::default(),
+            access_rules: config.access_rules,
             listeners,
             sockets,
             http,
@@ -101,11 +109,13 @@ impl MixedServer {
                         Ok(value) => value,
                         Err(error) => break Err(error),
                     };
+                    if self.connections.apply(&socket2::SockRef::from(&stream)).is_err() { continue; }
                     let relay = match stream.local_addr() {
                         Ok(address) => address,
                         Err(error) => break Err(error),
                     };
                     let connection = MixedConnection {
+                        access_rules:self.access_rules.clone(),
                         peer,
                         relay,
                         udp: Some(self.sockets[index].clone()),
@@ -129,6 +139,7 @@ impl MixedServer {
 }
 
 struct MixedConnection {
+    access_rules: Arc<crate::config::ProxyAccessRules>,
     peer: SocketAddr,
     relay: SocketAddr,
     udp: Option<Arc<UdpSocket>>,
@@ -142,7 +153,7 @@ struct MixedConnection {
 impl MixedConnection {
     async fn serve<S>(self, stream: S) -> io::Result<()>
     where
-        S: AsyncRead + AsyncWrite + Unpin,
+        S: AsyncRead + AsyncWrite + Unpin + Send,
     {
         let cancellation = self.cancellation.clone();
         tokio::select! {
@@ -152,10 +163,17 @@ impl MixedConnection {
         }
     }
 
-    async fn serve_inner<S>(self, stream: S) -> io::Result<()>
+    async fn serve_inner<S>(mut self, stream: S) -> io::Result<()>
     where
-        S: AsyncRead + AsyncWrite + Unpin,
+        S: AsyncRead + AsyncWrite + Unpin + Send,
     {
+        if !self.access_rules.permits(self.peer.ip()) {
+            return Err(io::ErrorKind::PermissionDenied.into());
+        }
+        if self.access_rules.skips_auth(self.peer.ip()) {
+            self.http.auth = None;
+            self.socks = self.socks.without_auth();
+        }
         // Keep the probed byte in the reader. Both real protocol handlers
         // consume this same reader, so fragmented and pipelined bytes survive.
         let mut stream = BufReader::with_capacity(1, stream);
@@ -182,6 +200,7 @@ impl MixedConnection {
                 handle_connection_with_deadline(
                     stream,
                     self.peer,
+                    self.relay,
                     self.dispatcher,
                     self.http,
                     self.cancellation,
diff --git a/src/inbound/mixed/tests.rs b/src/inbound/mixed/tests.rs
index 3189fc8..781eafe 100644
--- a/src/inbound/mixed/tests.rs
+++ b/src/inbound/mixed/tests.rs
@@ -39,6 +39,7 @@ impl Dispatcher for Peers {
 
 fn connection(peers: Arc<Peers>, auth: Option<ProxyCredentials>) -> MixedConnection {
     let access = ProxyAccess {
+        bind_address: None,
         allow_lan: true,
         ipv6: false,
     };
@@ -53,6 +54,7 @@ fn connection(peers: Arc<Peers>, auth: Option<ProxyCredentials>) -> MixedConnect
         peers.clone(),
     );
     MixedConnection {
+        access_rules: Default::default(),
         peer: "192.0.2.1:20000".parse().unwrap(),
         relay: "192.0.2.2:1080".parse().unwrap(),
         udp: None,
@@ -115,7 +117,7 @@ async fn memory_mixed_protocols_preserve_first_byte_and_pipelined_tunnel_bytes_w
             if socks {
                 InboundKind::Socks5
             } else {
-                InboundKind::Http
+                InboundKind::Https
             }
         );
         assert_eq!(
@@ -252,3 +254,190 @@ async fn memory_mixed_eof_and_cancellation_release_pending_protocol_reads() {
         assert!(peers.sessions.lock().unwrap().is_empty());
     }
 }
+
+#[tokio::test]
+async fn memory_mixed_acl_multiple_users_and_auth_bypass() {
+    for (skip, denied) in [(false, false), (true, false), (true, true)] {
+        let yaml = format!(
+            r#"mixed-port: 1080
+allow-lan: true
+bind-address: 192.0.2.2
+authentication: [first:old, second:pass, first:new]
+lan-allowed-ips: [192.0.2.0/24]
+lan-disallowed-ips: [{}]
+skip-auth-prefixes: [{}]
+"#,
+            if denied {
+                "192.0.2.1/32"
+            } else {
+                "192.0.2.9/32"
+            },
+            if skip {
+                "192.0.2.0/24"
+            } else {
+                "198.51.100.0/24"
+            }
+        );
+        let config = crate::config::Config::parse_yaml(yaml.as_bytes()).unwrap();
+        let crate::config::InboundConfig::Mixed(mixed) = &config.inbounds[0] else {
+            panic!()
+        };
+        assert_eq!(
+            mixed.access.bind_address,
+            Some("192.0.2.2".parse().unwrap())
+        );
+        assert!(mixed.auth.as_ref().unwrap().matches(b"first", b"new"));
+        assert!(!mixed.auth.as_ref().unwrap().matches(b"first", b"old"));
+        let peers = Arc::new(Peers::default());
+        let (upstream, mut remote) = tokio::io::duplex(1024);
+        peers.streams.lock().unwrap().push_back(upstream);
+        let mut connection = connection(peers.clone(), mixed.auth.clone());
+        connection.access_rules = mixed.access_rules.clone();
+        let cancellation = connection.cancellation.clone();
+        let (mut client, inbound) = tokio::io::duplex(1024);
+        let request = format!(
+            "CONNECT 192.0.2.3:80 HTTP/1.1\r\nHost: 192.0.2.3:80\r\n{}\r\n",
+            if skip {
+                "Proxy-Authorization: Basic Y2xhaW1lZDp1bnRydXN0ZWQ=\r\n".into()
+            } else {
+                format!(
+                    "Proxy-Authorization: {}\r\n",
+                    ProxyCredentials::new("second", "pass")
+                        .unwrap()
+                        .authorization_header_value()
+                )
+            }
+        );
+        client.write_all(request.as_bytes()).await.unwrap();
+        let task = tokio::spawn(connection.serve(inbound));
+        if denied {
+            assert!(task.await.unwrap().is_err());
+            assert!(peers.sessions.lock().unwrap().is_empty());
+        } else {
+            exact(&mut client, b"HTTP/1.1 200 Connection Established\r\n\r\n").await;
+            client.write_all(b"body").await.unwrap();
+            exact(&mut remote, b"body").await;
+            cancellation.cancel();
+            task.await.unwrap().unwrap();
+            let sessions = peers.sessions.lock().unwrap();
+            assert_eq!(sessions[0].metadata.local_port, 1080);
+            assert_eq!(sessions[0].inbound, InboundKind::Https);
+            assert_eq!(
+                sessions[0].metadata.user.as_deref(),
+                if skip { None } else { Some("second") }
+            );
+        }
+    }
+}
+
+#[tokio::test]
+async fn ingress_memory_mixed_verified_http_socks_identity_and_unauthenticated_claims() {
+    for (socks, authenticate) in [(false, true), (true, true), (false, false)] {
+        let peers = Arc::new(Peers::default());
+        let (upstream, mut remote) = tokio::io::duplex(1024);
+        peers.streams.lock().unwrap().push_back(upstream);
+        let credentials = ProxyCredentials::new("Alice", "pass").unwrap();
+        let connection = connection(peers.clone(), authenticate.then(|| credentials.clone()));
+        let cancellation = connection.cancellation.clone();
+        let (mut client, inbound) = tokio::io::duplex(1024);
+        let task = tokio::spawn(connection.serve(inbound));
+        if socks {
+            client.write_all(&[5, 1, 2]).await.unwrap();
+            exact(&mut client, &[5, 2]).await;
+            client.write_all(b"\x01\x05Alice\x04pass").await.unwrap();
+            exact(&mut client, &[1, 0]).await;
+            client
+                .write_all(&[5, 1, 0, 1, 192, 0, 2, 3, 0, 80])
+                .await
+                .unwrap();
+            exact(&mut client, &[5, 0, 0, 1, 0, 0, 0, 0, 0, 0]).await;
+        } else {
+            client.write_all(format!("CONNECT 192.0.2.3:80 HTTP/1.1\r\nHost: 192.0.2.3:80\r\nProxy-Authorization: {}\r\n\r\n", credentials.authorization_header_value()).as_bytes()).await.unwrap();
+            exact(&mut client, b"HTTP/1.1 200 Connection Established\r\n\r\n").await;
+        }
+        client.write_all(b"body").await.unwrap();
+        exact(&mut remote, b"body").await;
+        cancellation.cancel();
+        task.await.unwrap().unwrap();
+        let sessions = peers.sessions.lock().unwrap();
+        assert_eq!(
+            sessions[0].inbound,
+            if socks {
+                InboundKind::Socks5
+            } else {
+                InboundKind::Https
+            }
+        );
+        assert_eq!(sessions[0].metadata.local_port, 1080);
+        assert_eq!(
+            sessions[0].metadata.user.as_deref(),
+            authenticate.then_some("Alice")
+        );
+    }
+}
+
+#[tokio::test]
+async fn ingress_memory_http_keepalive_authenticates_each_request() {
+    let peers = Arc::new(Peers::default());
+    let credentials = ProxyCredentials::multiple(vec![
+        ProxyCredentials::new("Alice", "pass").unwrap(),
+        ProxyCredentials::new("Bob", "other").unwrap(),
+    ]);
+    let connection = connection(peers.clone(), Some(credentials));
+    let cancellation = connection.cancellation.clone();
+    let (mut client, inbound) = tokio::io::duplex(2048);
+    let task = tokio::spawn(connection.serve(inbound));
+    for (user, password) in [("Alice", "pass"), ("Bob", "other")] {
+        let (upstream, mut origin) = tokio::io::duplex(2048);
+        peers.streams.lock().unwrap().push_back(upstream);
+        let header = ProxyCredentials::new(user, password)
+            .unwrap()
+            .authorization_header_value();
+        client.write_all(format!("GET http://192.0.2.3/test HTTP/1.1\r\nHost: 192.0.2.3\r\nProxy-Authorization: {header}\r\n\r\n").as_bytes()).await.unwrap();
+        let mut request = Vec::new();
+        while !request.ends_with(b"\r\n\r\n") {
+            request.push(
+                tokio::time::timeout(Duration::from_secs(2), origin.read_u8())
+                    .await
+                    .unwrap()
+                    .unwrap(),
+            );
+        }
+        assert!(
+            !String::from_utf8(request)
+                .unwrap()
+                .to_lowercase()
+                .contains("proxy-authorization")
+        );
+        origin
+            .write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 1\r\n\r\nx")
+            .await
+            .unwrap();
+        let mut response = Vec::new();
+        while !response.ends_with(b"\r\n\r\nx") {
+            response.push(
+                tokio::time::timeout(Duration::from_secs(2), client.read_u8())
+                    .await
+                    .unwrap()
+                    .unwrap(),
+            );
+        }
+    }
+    cancellation.cancel();
+    task.await.unwrap().unwrap();
+    let sessions = peers.sessions.lock().unwrap();
+    assert_eq!(sessions.len(), 2);
+    assert!(
+        sessions
+            .iter()
+            .all(|session| session.inbound == InboundKind::Http
+                && session.metadata.local_port == 1080)
+    );
+    assert_eq!(
+        sessions
+            .iter()
+            .map(|session| session.metadata.user.as_deref())
+            .collect::<Vec<_>>(),
+        [Some("Alice"), Some("Bob")]
+    );
+}
diff --git a/src/inbound/socks5/association.rs b/src/inbound/socks5/association.rs
index cac1bd8..17fe55a 100644
--- a/src/inbound/socks5/association.rs
+++ b/src/inbound/socks5/association.rs
@@ -11,7 +11,7 @@ use tokio::{net::UdpSocket, sync::mpsc, time::Instant};
 use tokio_util::sync::CancellationToken;
 
 use crate::{
-    session::{Datagram, SOCKS5_UDP_PACKET_LIMIT},
+    session::{Datagram, DatagramSession, InboundKind, InboundMetadata, SOCKS5_UDP_PACKET_LIMIT},
     socks5::decode_udp_packet,
 };
 
@@ -41,11 +41,19 @@ impl Entry {
 pub(super) struct Associations(Mutex<HashMap<SocketAddr, Entry>>);
 
 pub(super) struct Lease {
+    pub(super) metadata: InboundMetadata,
     registry: Arc<Associations>,
     pub(super) cancellation: CancellationToken,
     pub(super) source: Arc<Mutex<SocketAddr>>,
 }
 
+impl Lease {
+    pub(super) fn session(&self) -> DatagramSession {
+        DatagramSession::new(InboundKind::Socks5, *self.source.lock().unwrap())
+            .with_metadata(self.metadata.clone())
+    }
+}
+
 impl Drop for Lease {
     fn drop(&mut self) {
         // Serialize removal with UDP learning/replies. A stale generation must
@@ -99,6 +107,7 @@ impl Associations {
         );
         Ok((
             Lease {
+                metadata: InboundMetadata::new(0),
                 registry: self.clone(),
                 cancellation,
                 source: learned_source,
@@ -200,6 +209,46 @@ mod tests {
     use super::*;
     use crate::{session::Destination, socks5::encode_udp_packet};
 
+    #[tokio::test]
+    async fn ingress_udp_lease_retains_verified_user_and_learned_source() {
+        let registry = Arc::new(Associations::default());
+        let credentials = crate::config::ProxyCredentials::new("Alice", "pass").unwrap();
+        let user = credentials.authenticate(b"Alice", b"pass").unwrap();
+        let weak = Arc::downgrade(&user);
+        let (mut lease, mut receiver) = registry
+            .register(
+                "192.0.2.1:1234".parse().unwrap(),
+                0,
+                &CancellationToken::new(),
+            )
+            .unwrap();
+        lease.metadata = InboundMetadata {
+            local_port: 1080,
+            user: Some(user),
+            ..Default::default()
+        };
+        drop(credentials);
+        let source = "192.0.2.1:4321".parse().unwrap();
+        let packet = encode_udp_packet(
+            &Destination::Ip("203.0.113.1:53".parse().unwrap()),
+            b"data",
+            65507,
+        )
+        .unwrap();
+        registry.enqueue(source, &packet, Instant::now());
+        assert_eq!(receiver.recv().await.unwrap().payload.as_ref(), b"data");
+        let session = lease.session();
+        assert_eq!(session.source, source);
+        assert_eq!(session.metadata.local_port, 1080);
+        assert_eq!(session.metadata.user.as_deref(), Some("Alice"));
+        assert!(!format!("{:?}", session.metadata).contains("Alice"));
+        drop(lease);
+        assert!(registry.0.lock().unwrap().is_empty());
+        assert!(weak.upgrade().is_some());
+        drop(session);
+        assert!(weak.upgrade().is_none());
+    }
+
     #[tokio::test]
     async fn bounded_queue_idle_expiry_and_old_generation_cannot_remove_replacement() {
         let registry = Arc::new(Associations::default());
diff --git a/src/inbound/socks5/handshake.rs b/src/inbound/socks5/handshake.rs
index 1bccb9b..427079d 100644
--- a/src/inbound/socks5/handshake.rs
+++ b/src/inbound/socks5/handshake.rs
@@ -1,4 +1,4 @@
-use std::{io, net::SocketAddr};
+use std::{io, net::SocketAddr, sync::Arc};
 
 use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
 
@@ -13,11 +13,17 @@ fn invalid() -> io::Error {
     io::Error::new(io::ErrorKind::InvalidData, "invalid SOCKS5 handshake")
 }
 
+pub(super) struct Negotiated {
+    pub command: u8,
+    pub destination: Destination,
+    pub user: Option<Arc<str>>,
+}
+
 /// Fixed-size, exact reads leave pipelined application bytes in the socket.
 pub(super) async fn negotiate<S>(
     stream: &mut S,
     auth: Option<&ProxyCredentials>,
-) -> io::Result<(u8, Destination)>
+) -> io::Result<Negotiated>
 where
     S: AsyncRead + AsyncWrite + Unpin,
 {
@@ -33,6 +39,7 @@ where
         return Err(invalid());
     }
     stream.write_all(&[VERSION, method]).await?;
+    let mut authenticated_user = None;
     if let Some(auth) = auth {
         let version = stream.read_u8().await?;
         let user_length = stream.read_u8().await? as usize;
@@ -41,8 +48,10 @@ where
         let password_length = stream.read_u8().await? as usize;
         let mut password = [0_u8; 255];
         stream.read_exact(&mut password[..password_length]).await?;
-        let valid =
-            version == 1 && auth.matches(&user[..user_length], &password[..password_length]);
+        authenticated_user = (version == 1)
+            .then(|| auth.authenticate(&user[..user_length], &password[..password_length]))
+            .flatten();
+        let valid = authenticated_user.is_some();
         stream.write_all(&[1, u8::from(!valid)]).await?;
         if !valid {
             return Err(io::Error::new(
@@ -62,7 +71,11 @@ where
         return Err(invalid());
     }
     match socks5::read_destination(stream, header[1] == COMMAND_UDP_ASSOCIATE).await {
-        Ok(destination) => Ok((header[1], destination)),
+        Ok(destination) => Ok(Negotiated {
+            command: header[1],
+            destination,
+            user: authenticated_user,
+        }),
         Err(error) => {
             reply(stream, 8, None).await?;
             Err(error)
@@ -90,6 +103,6 @@ pub(super) fn status(error: &DispatchError) -> u8 {
         DispatchError::HostUnreachable => 4,
         DispatchError::ConnectionRefused => 5,
         DispatchError::TimedOut => 6,
-        DispatchError::Other(_) => 1,
+        DispatchError::Other(_) | DispatchError::RuleEvaluation(_) => 1,
     }
 }
diff --git a/src/inbound/socks5/server.rs b/src/inbound/socks5/server.rs
index 86c340c..ae9d391 100644
--- a/src/inbound/socks5/server.rs
+++ b/src/inbound/socks5/server.rs
@@ -1,7 +1,7 @@
-use std::{io, net::SocketAddr, sync::Arc, time::Duration};
+use std::{collections::VecDeque, io, net::SocketAddr, sync::Arc, time::Duration};
 
 use tokio::{
-    io::{AsyncRead, AsyncReadExt, AsyncWrite, copy_bidirectional_with_sizes},
+    io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt, copy_bidirectional_with_sizes},
     net::{TcpListener, TcpStream, UdpSocket},
     sync::mpsc,
     task::JoinSet,
@@ -14,7 +14,7 @@ use crate::{
     dispatch::{DispatchError, Dispatcher},
     inbound::listen::{bind_proxy_tcp, bind_udp},
     session::{
-        Datagram, DatagramSession, Destination, InboundKind, SOCKS5_UDP_PACKET_LIMIT, StreamSession,
+        Datagram, Destination, InboundKind, InboundMetadata, SOCKS5_UDP_PACKET_LIMIT, StreamSession,
     },
     socks5::{COMMAND_CONNECT, encode_udp_packet},
 };
@@ -135,6 +135,11 @@ pub(crate) struct Socks5Handler {
 pub(crate) const UDP_CLEANUP_INTERVAL: Duration = CLEANUP_INTERVAL;
 
 impl Socks5Handler {
+    pub(crate) fn without_auth(mut self) -> Self {
+        self.config.auth = None;
+        self
+    }
+
     pub(crate) fn new(config: Socks5InboundConfig, dispatcher: Arc<dyn Dispatcher>) -> Self {
         Self {
             config,
@@ -181,7 +186,11 @@ impl Socks5Handler {
         let config = &self.config;
         let dispatcher = self.dispatcher.clone();
         let registry = self.registry.clone();
-        let (command, destination) = timeout_at(
+        let handshake::Negotiated {
+            command,
+            destination,
+            user,
+        } = timeout_at(
             deadline,
             handshake::negotiate(&mut stream, config.auth.as_ref()),
         )
@@ -194,18 +203,43 @@ impl Socks5Handler {
             return Ok(());
         }
         if command == COMMAND_CONNECT {
-            let session = StreamSession {
+            let mut session = StreamSession {
+                metadata: InboundMetadata {
+                    local_port: relay.port(),
+                    local_address: Some(relay),
+                    user,
+                    ..Default::default()
+                },
                 inbound: InboundKind::Socks5,
                 source: peer,
                 destination,
                 sniffed_domain: None,
             };
+            let sniff = dispatcher
+                .sniff_plan(peer, &session.destination)
+                .await
+                .map_err(|_| io::Error::other("sniffer rule evaluation failed"))?
+                .filter(|plan| plan.tcp_enabled());
+            let acknowledged = sniff.is_some();
+            let prefix = if let Some(plan) = sniff {
+                timed(handshake::reply(&mut stream, 0, None)).await?;
+                plan.sniff(&mut stream, &mut session)
+                    .await
+                    .map_err(|_| io::Error::other("sniffer rule evaluation failed"))?
+            } else {
+                Vec::new()
+            };
             let connected = timeout(IO_TIMEOUT, dispatcher.connect_tcp(session))
                 .await
                 .unwrap_or(Err(DispatchError::TimedOut));
             match connected {
                 Ok(mut upstream) => {
-                    timed(handshake::reply(&mut stream, 0, None)).await?;
+                    if !acknowledged {
+                        timed(handshake::reply(&mut stream, 0, None)).await?;
+                    }
+                    if !prefix.is_empty() {
+                        timed(upstream.write_all(&prefix)).await?;
+                    }
                     copy_bidirectional_with_sizes(
                         &mut stream,
                         &mut upstream,
@@ -215,6 +249,9 @@ impl Socks5Handler {
                     .await?;
                 }
                 Err(error) => {
+                    if acknowledged {
+                        return Err(io::Error::other(error));
+                    }
                     timed(handshake::reply(
                         &mut stream,
                         handshake::status(&error),
@@ -240,13 +277,19 @@ impl Socks5Handler {
                 return Ok(());
             }
         };
-        let (lease, receiver) = match registry.register(peer, requested.port(), &cancellation) {
+        let (mut lease, receiver) = match registry.register(peer, requested.port(), &cancellation) {
             Ok(value) => value,
             Err(_) => {
                 timed(handshake::reply(&mut stream, 2, None)).await?;
                 return Ok(());
             }
         };
+        lease.metadata = InboundMetadata {
+            local_port: socket.local_addr()?.port(),
+            local_address: Some(relay),
+            user,
+            ..Default::default()
+        };
         // The accepted socket's concrete local IP is reachable even when the
         // listener was bound to a wildcard. TCP and UDP share this exact port.
         timed(handshake::reply(&mut stream, 0, Some(relay))).await?;
@@ -277,25 +320,42 @@ async fn relay_datagrams(
     let Some(first) = receiver.recv().await else {
         return Ok(());
     };
-    let source = *lease.source.lock().unwrap();
-    let session = DatagramSession::new(InboundKind::Socks5, source);
+    let session = lease.session();
     let response_limit = usize::from(session.max_response_payload_size());
     let mut transport = timeout(IO_TIMEOUT, dispatcher.open_datagram(session))
         .await
         .map_err(|_| io::Error::new(io::ErrorKind::TimedOut, "SOCKS5 UDP open timed out"))?
         .map_err(|_| io::Error::other("SOCKS5 UDP open failed"))?;
-    timeout(IO_TIMEOUT, transport.send(first))
-        .await
-        .map_err(|_| io::ErrorKind::TimedOut)?
-        .map_err(|_| io::Error::other("SOCKS5 UDP send failed"))?;
+    let mut sniff = None;
+    let mut ready = VecDeque::new();
+    let mut pending = None;
+    queue_udp_result(
+        prepare_udp_datagram(first, lease, dispatcher.as_ref(), &mut sniff).await?,
+        &mut pending,
+        &mut ready,
+    )?;
+    let mut sent = false;
     loop {
+        if let Some(prepared) = pending.take().or_else(|| ready.pop_front()) {
+            send_udp_datagram(prepared, lease, dispatcher.as_ref(), transport.as_mut()).await?;
+            sent = true;
+            continue;
+        }
+        let deadline = sniff.as_ref().and_then(UdpSniffState::next_deadline);
         tokio::select! {
+            () = lease.cancellation.cancelled() => return Ok(()),
+            () = wait_sniff_deadline(deadline), if deadline.is_some() => {
+                append_udp_replay(&mut ready, sniff.as_mut().unwrap().expire(Instant::now()))?;
+            }
             datagram = receiver.recv() => {
                 let Some(datagram) = datagram else { return Ok(()); };
-                timeout(IO_TIMEOUT, transport.send(datagram)).await.map_err(|_| io::ErrorKind::TimedOut)?
-                    .map_err(|_| io::Error::other("SOCKS5 UDP send failed"))?;
+                queue_udp_result(
+                    prepare_udp_datagram(datagram, lease, dispatcher.as_ref(), &mut sniff).await?,
+                    &mut pending,
+                    &mut ready,
+                )?;
             }
-            response = transport.receive() => {
+            response = transport.receive(), if sent => {
                 let response = response.map_err(|_| io::Error::other("SOCKS5 UDP receive failed"))?;
                 if response.payload.len() > response_limit { continue; }
                 let Ok(packet) = encode_udp_packet(&response.remote, &response.payload, SOCKS5_UDP_PACKET_LIMIT) else { continue; };
@@ -312,3 +372,109 @@ async fn relay_datagrams(
         }
     }
 }
+
+type PreparedUdp = crate::udp_sniffing::PreparedDatagram<Datagram>;
+type UdpSniffState = crate::udp_sniffing::SniffState<
+    crate::quic_sniffer::QuicSniffer,
+    fn() -> crate::quic_sniffer::QuicSniffer,
+    Datagram,
+>;
+
+async fn wait_sniff_deadline(deadline: Option<Instant>) {
+    match deadline {
+        Some(deadline) => tokio::time::sleep_until(deadline).await,
+        None => std::future::pending().await,
+    }
+}
+
+fn append_udp_replay(
+    ready: &mut VecDeque<PreparedUdp>,
+    mut replay: VecDeque<PreparedUdp>,
+) -> io::Result<()> {
+    if ready
+        .len()
+        .checked_add(replay.len())
+        .is_none_or(|length| length > crate::udp_sniffing::QUIC_SNIFF_READY_DATAGRAM_MAX)
+    {
+        return Err(io::Error::other(
+            "SOCKS5 UDP sniff replay exceeded its bound",
+        ));
+    }
+    ready.append(&mut replay);
+    Ok(())
+}
+
+fn queue_udp_result(
+    result: crate::udp_sniffing::IngressResult<Datagram>,
+    pending: &mut Option<PreparedUdp>,
+    ready: &mut VecDeque<PreparedUdp>,
+) -> io::Result<()> {
+    match result {
+        crate::udp_sniffing::IngressResult::Buffered => Ok(()),
+        crate::udp_sniffing::IngressResult::Forward(datagram) => {
+            // Ordinary UDP retains its original single-packet fast path. The
+            // replay queue is allocated only when QUIC actually buffers bytes.
+            debug_assert!(pending.is_none() && ready.is_empty());
+            *pending = Some(datagram);
+            Ok(())
+        }
+        crate::udp_sniffing::IngressResult::Replay(replay) => append_udp_replay(ready, replay),
+    }
+}
+
+async fn prepare_udp_datagram(
+    datagram: Datagram,
+    lease: &Lease,
+    dispatcher: &dyn Dispatcher,
+    sniff: &mut Option<UdpSniffState>,
+) -> io::Result<crate::udp_sniffing::IngressResult<Datagram>> {
+    let plan = dispatcher
+        .sniff_plan(lease.session().source, &datagram.remote)
+        .await
+        .map_err(|_| io::Error::other("SOCKS5 UDP sniff policy failed"))?;
+    if plan.is_some_and(|plan| plan.quic_enabled()) {
+        let sniff = sniff.get_or_insert_with(|| {
+            UdpSniffState::with_idle_timeout(
+                crate::quic_sniffer::QuicSniffer::new,
+                super::association::IDLE_TIMEOUT,
+            )
+        });
+        Ok(sniff.ingest_datagram(datagram, Instant::now()))
+    } else {
+        Ok(crate::udp_sniffing::IngressResult::Forward(
+            PreparedUdp::without_domain(datagram),
+        ))
+    }
+}
+
+async fn send_udp_datagram(
+    mut prepared: PreparedUdp,
+    lease: &Lease,
+    dispatcher: &dyn Dispatcher,
+    transport: &mut dyn crate::dispatch::DatagramTransport,
+) -> io::Result<()> {
+    if let Some(host) = prepared.sniffed_domain.as_deref()
+        && let Some(plan) = dispatcher
+            .sniff_plan(lease.session().source, &prepared.datagram.remote)
+            .await
+            .map_err(|_| io::Error::other("SOCKS5 UDP sniff policy failed"))?
+        && !plan.accepts(host).map_err(io::Error::other)?
+    {
+        prepared.sniffed_domain = None;
+    }
+    prepared.datagram.sniffed_domain = prepared.sniffed_domain;
+    let send = async {
+        match prepared.flow_id {
+            Some(identity) => {
+                transport
+                    .send_with_flow_id(prepared.datagram, &identity.routing_identity())
+                    .await
+            }
+            None => transport.send(prepared.datagram).await,
+        }
+    };
+    timeout(IO_TIMEOUT, send)
+        .await
+        .map_err(|_| io::ErrorKind::TimedOut)?
+        .map_err(|_| io::Error::other("SOCKS5 UDP send failed"))
+}
diff --git a/src/inbound/socks5/tests.rs b/src/inbound/socks5/tests.rs
index d7680c0..bd277fd 100644
--- a/src/inbound/socks5/tests.rs
+++ b/src/inbound/socks5/tests.rs
@@ -63,6 +63,10 @@ struct Echo {
 
 #[async_trait]
 impl DatagramTransport for Echo {
+    fn supports_shared_destinations(&self) -> bool {
+        false
+    }
+
     async fn send(&mut self, datagram: Datagram) -> Result<(), DispatchError> {
         if self.block_send {
             self.blocked.fetch_add(1, Ordering::SeqCst);
@@ -129,6 +133,7 @@ impl Fixture {
             tag: "socks".into(),
             port: 0,
             access: ProxyAccess {
+                bind_address: None,
                 allow_lan: lan,
                 ipv6,
             },
@@ -137,6 +142,7 @@ impl Fixture {
         #[cfg(feature = "inbound-http")]
         let server = MixedServer::bind(
             MixedInboundConfig {
+                access_rules: Default::default(),
                 tag: config.tag,
                 port: config.port,
                 access: config.access,
@@ -475,6 +481,7 @@ async fn dual_stack_udp_and_tcp_share_port_and_failed_udp_bind_releases_tcp() {
         tag: "test".into(),
         port: address.port(),
         access: ProxyAccess {
+            bind_address: None,
             allow_lan: false,
             ipv6: false,
         },
diff --git a/src/invoke/foreground.rs b/src/invoke/foreground.rs
index ef32736..c9bfa55 100644
--- a/src/invoke/foreground.rs
+++ b/src/invoke/foreground.rs
@@ -1,10 +1,16 @@
 //! Foreground lifecycle is an Invoke operation; CLI transports only options.
-use super::{CoreController, InvokeFailure, invoke_instance_guarded, lock, registry};
+use super::{
+    CoreController, InvokeFailure, StartupConfig, invoke_instance_guarded, lock, registry,
+};
+mod input;
+mod overrides;
+mod reload;
+pub(super) use overrides::ControllerOverrides;
+
 use serde::{Deserialize, Serialize};
 use serde_json::{Value, json};
 use std::{
     ffi::OsString,
-    fmt,
     fs::{self, File, OpenOptions},
     io::{self, Read, Write},
     path::{Component, Path, PathBuf},
@@ -12,26 +18,34 @@ use std::{
         Arc, Mutex,
         atomic::{AtomicU64, Ordering},
     },
-    time::{Duration, Instant},
 };
 use tracing::{
-    Event, Level, Metadata, Subscriber,
-    field::{Field, Visit},
+    Event, Metadata, Subscriber,
     level_filters::LevelFilter,
     span::{Attributes, Id, Record},
     subscriber::Interest,
 };
+use zeroize::Zeroizing;
 
 const HELP: &str = "Vole standalone proxy core\n\
-Usage: vole [-d <data-dir>] [-f <config-file>] [-t] [-v] [-h]\n\
+Usage: vole [-d <data-dir>] [-f <config-file>] [-config <base64>] [-age-secret-key <key>] [-ext-ctl <address>] [-ext-ctl-tls <address>] [-ext-ctl-unix <path>] [-ext-ctl-routing-mark <mark>] [-secret <token>] [-http-config <file>] [-http-ca <file>] [-t] [-v] [-h]\n\
   -d <data-dir>     Data directory (default: home/.config/vole)\n\
   -f <config-file>  Configuration file; - reads stdin (default: <data-dir>/config.yaml)\n\
+  -config <base64>  Base64-encoded configuration; nonempty text takes priority\n\
+  -age-secret-key <key>  AGE identity for an encrypted configuration\n\
+  -ext-ctl <address>  Override the HTTP Controller address when nonempty\n\
+  -ext-ctl-tls <address>  Override the TLS Controller address when nonempty\n\
+  -ext-ctl-unix <path>  Override the Linux Unix Controller path when nonempty\n\
+  -ext-ctl-routing-mark <mark>  Override the Linux management socket mark when nonzero\n\
+  -secret <token>   Override Controller authentication when nonempty\n\
+  -http-config <file>  Explicit HTTP processing addendum (optional)\n\
+  -http-ca <file>   Private CA JSON file for selected HTTPS processing\n\
   -t               Validate configuration and exit\n\
   -v               Print software version and build identity\n\
   -h               Print this help\n";
 
 /// Lossless native paths in Invoke metadata. Ordinary hosts may use a string.
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(untagged)]
 pub enum InvokePath {
     Text(String),
@@ -41,13 +55,13 @@ pub enum InvokePath {
     Windows(WindowsPath),
 }
 #[cfg(unix)]
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(deny_unknown_fields, rename_all = "camelCase")]
 pub struct UnixPath {
     unix_bytes: Vec<u8>,
 }
 #[cfg(windows)]
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(deny_unknown_fields, rename_all = "camelCase")]
 pub struct WindowsPath {
     windows_wide: Vec<u16>,
@@ -78,7 +92,7 @@ impl From<PathBuf> for InvokePath {
     }
 }
 impl InvokePath {
-    fn into_path(self) -> PathBuf {
+    pub(crate) fn into_path(self) -> PathBuf {
         match self {
             Self::Text(value) => PathBuf::from(value),
             #[cfg(unix)]
@@ -102,6 +116,24 @@ pub(super) struct ForegroundPayload {
     data_dir: Option<InvokePath>,
     #[serde(default)]
     config_path: Option<InvokePath>,
+    #[serde(default, deserialize_with = "input::private_text")]
+    config_string: Option<Zeroizing<String>>,
+    #[serde(default, deserialize_with = "input::private_text")]
+    age_secret_key: Option<Zeroizing<String>>,
+    #[serde(default, deserialize_with = "input::private_text")]
+    external_controller: Option<Zeroizing<String>>,
+    #[serde(default, deserialize_with = "input::private_text")]
+    external_controller_tls: Option<Zeroizing<String>>,
+    #[serde(default, deserialize_with = "input::private_text")]
+    external_controller_unix: Option<Zeroizing<String>>,
+    #[serde(default)]
+    external_controller_routing_mark: Option<i64>,
+    #[serde(default, deserialize_with = "input::private_text")]
+    secret: Option<Zeroizing<String>>,
+    #[serde(default)]
+    http_config_path: Option<InvokePath>,
+    #[serde(default)]
+    http_ca_path: Option<InvokePath>,
 }
 #[derive(Deserialize)]
 #[serde(rename_all = "lowercase")]
@@ -134,10 +166,17 @@ fn io_failure(stage: &str, error: io::Error) -> InvokeFailure {
 }
 static FOREGROUND: Mutex<()> = Mutex::new(());
 
+pub(super) fn check_envelope(request: &str) -> Result<(), InvokeFailure> {
+    input::check_envelope(request)
+}
+
 pub(super) fn execute(payload: ForegroundPayload) -> Result<Value, InvokeFailure> {
     if matches!(payload.action, ForegroundAction::Help) {
         return Ok(json!({"output":"","diagnostics":HELP}));
     }
+    if payload.http_ca_path.is_some() && payload.http_config_path.is_none() {
+        return Err(failure("httpCaPath requires httpConfigPath"));
+    }
     let _lease = if matches!(payload.action, ForegroundAction::Run) {
         if tokio::runtime::Handle::try_current().is_ok() {
             return Err(failure(
@@ -155,6 +194,7 @@ pub(super) fn execute(payload: ForegroundPayload) -> Result<Value, InvokeFailure
     } else {
         None
     };
+    let source = input::options(payload.config_string, payload.age_secret_key)?;
     let options = PathOptions {
         data_dir: option_path(payload.data_dir, "VOLE_HOME_DIR"),
         config_file: option_path(payload.config_path, "VOLE_CONFIG_FILE"),
@@ -162,47 +202,170 @@ pub(super) fn execute(payload: ForegroundPayload) -> Result<Value, InvokeFailure
     let cwd = std::env::current_dir().map_err(|e| io_failure("resolve working directory", e))?;
     let paths = Paths::resolve(&options, &cwd, &PathDefaults::environment())
         .map_err(|e| io_failure("resolve paths", e))?;
+    let http_input = payload
+        .http_config_path
+        .map(|path| {
+            let path = path.into_path();
+            if path.as_os_str().is_empty() || path == Path::new("-") {
+                return Err(failure("HTTP configuration requires an explicit file path"));
+            }
+            let path = if path.is_absolute() {
+                path
+            } else {
+                cwd.join(path)
+            };
+            let bytes = read_config_limit(&path, crate::http_processing::MAX_ADDENDUM)
+                .map_err(|error| io_failure("read HTTP configuration", error))?;
+            String::from_utf8(bytes)
+                .map(|yaml| (yaml, path))
+                .map_err(|_| failure("HTTP configuration is not UTF-8"))
+        })
+        .transpose()?;
+    let http_yaml = http_input.as_ref().map(|(yaml, _)| yaml.as_str());
     // Stdin belongs to the foreground request. Default OS Ctrl+C handling is
     // preserved while it is still supplying its bounded configuration input.
-    let stdin = paths
-        .stdin
-        .then(|| read_bounded(io::stdin().lock()))
-        .transpose()
-        .map_err(|e| io_failure("read configuration input", e))?;
+    let input = input::MainInput::read(source.config, source.key, &paths, || {
+        read_bounded(io::stdin().lock())
+    })?;
     if matches!(payload.action, ForegroundAction::Validate) {
-        let config = stdin
-            .map_or_else(|| read_config(&paths.config_file), Ok)
-            .map_err(|e| io_failure("read configuration file", e))?;
-        validate_bytes(config)?;
-        return Ok(json!({"output":"configuration valid\n","diagnostics":""}));
+        let config = Zeroizing::new(input.into_yaml(None)?);
+        validate_yaml(&config, &paths.data_dir, http_yaml)?;
+        let external = http_yaml
+            .filter(|input| !input.is_empty())
+            .map(crate::http_processing::config::Document::parse)
+            .transpose()
+            .map_err(|_| failure("invalid HTTP processing configuration"))?
+            .is_some_and(|document| document.unresolved_count() != 0);
+        return Ok(
+            json!({"output":"configuration valid\n","diagnostics":if external {"HTTP external resources are not validated\n"} else {""}}),
+        );
+    }
+    // Like Mihomo, -t validates the source and returns before run-only overrides.
+    let overrides = ControllerOverrides::read(
+        payload.external_controller,
+        payload.external_controller_tls,
+        payload.external_controller_unix,
+        payload.external_controller_routing_mark,
+        payload.secret,
+    )?;
+    let mut provider_paths = crate::resource::paths::ProviderPaths::from_os_value(
+        std::env::var_os("VOLE_SAFE_PATHS"),
+        &cwd,
+    )
+    .map_err(|error| io_failure("provider path authorization", error))?;
+    let mut reserved = Vec::with_capacity(3);
+    if let Some(path) = input.source_file() {
+        reserved.push((path.to_owned(), false));
+    }
+    if let Some((_, path)) = &http_input {
+        reserved.push((path.clone(), false));
     }
+    if let Some(path) = &payload.http_ca_path {
+        let path = path.clone().into_path();
+        reserved.push((
+            if path.is_absolute() {
+                path
+            } else {
+                cwd.join(path)
+            },
+            true,
+        ));
+    }
+    provider_paths.reserve_inputs(reserved);
+    let provider_paths = Arc::new(provider_paths);
     let dispatch = tracing::Dispatch::new(StderrSubscriber::new());
     let _logging = tracing::dispatcher::set_default(&dispatch);
     let runtime = tokio::runtime::Builder::new_current_thread()
         .enable_all()
         .build()
         .map_err(|e| io_failure("create foreground runtime", e))?;
+    let ca = read_http_ca(payload.http_ca_path, http_yaml, &cwd)?;
     runtime.block_on(async {
-        let signals =
+        let mut signals =
             ShutdownSignals::register().map_err(|e| io_failure("register shutdown signals", e))?;
-        let config = stdin
-            .map_or_else(|| read_config(&paths.config_file), Ok)
-            .map_err(|e| io_failure("read configuration file", e))?;
-        let yaml = String::from_utf8(config).map_err(|_| failure("configuration is not UTF-8"))?;
+        let cancellation = tokio_util::sync::CancellationToken::new();
+        let decoding_cancellation = cancellation.clone();
+        let mut decoding = tokio::task::spawn_blocking(move || input.into_loaded(&decoding_cancellation));
+        let loaded = {
+            let shutdown = signals.wait_shutdown();
+            tokio::pin!(shutdown);
+            tokio::select! {
+                biased;
+                signal = &mut shutdown => {
+                    cancellation.cancel();
+                    let _ = decoding.await.map_err(|_| failure("configuration decoder failed"))?;
+                    signal.map_err(|e| io_failure("shutdown signal", e))?;
+                    return Ok(());
+                }
+                result = &mut decoding => result.map_err(|_| failure("configuration decoder failed"))??,
+            }
+        };
+        let mut yaml = loaded.yaml;
+        let reload = loaded.reload.map(|input| reload::ReloadContext {
+            input, directory: paths.data_dir.clone(), overrides: Arc::new(overrides.clone()),
+        });
         registry()
-            .initialize_path(&paths.data_dir)
+            .initialize_path_with_provider_paths(&paths.data_dir, Some(Arc::new(provider_paths.authorization_only())))
             .map_err(|_| failure("data directory initialization failed"))?;
         let controller = registry().create_instance()?;
         let mut cleanup = ForegroundInstance(Some(controller.clone()));
-        let result = run_controller(controller, yaml, signals.wait()).await;
+        let context = http_input
+            .as_ref()
+            .map(|(_, path)| super::http::HttpContextInput {
+                base_dir: path.parent().map(|path| path.to_owned().into()),
+                ca,
+            });
+        let (http_config_yaml, source_file) = http_input.unzip();
+        let startup = StartupConfig::Input(Box::new(super::http::StartPayload {
+            config_yaml: std::mem::take(&mut *yaml),
+            http_config_yaml,
+            http_context: context,
+            source_file,
+            cancellation: Some(cancellation.clone()),
+            foreground_overrides: overrides,
+            provider_paths: Some(provider_paths.clone()),
+        }));
+        let result = run_controller(controller, startup, signals, cancellation, reload).await;
         let stopped = cleanup.destroy();
         result.and(stopped)
     })?;
     Ok(json!({"output":"","diagnostics":""}))
 }
-fn validate_bytes(bytes: Vec<u8>) -> Result<(), InvokeFailure> {
-    let yaml = String::from_utf8(bytes).map_err(|_| failure("configuration is not UTF-8"))?;
-    super::validate_config(yaml).map_err(|_| failure("invalid configuration"))
+
+fn read_http_ca(
+    path: Option<InvokePath>,
+    http_yaml: Option<&str>,
+    cwd: &Path,
+) -> Result<Option<crate::http_processing::private_context::CaMaterial>, InvokeFailure> {
+    let Some(path) = path else { return Ok(None) };
+    let input = http_yaml.ok_or_else(|| failure("httpCaPath requires httpConfigPath"))?;
+    let enabled = !input.is_empty()
+        && crate::http_processing::config::Document::parse(input)
+            .map_err(|_| failure("invalid HTTP processing configuration"))?
+            .mitm
+            .enabled;
+    if !enabled {
+        return Ok(None);
+    }
+    let path = path.into_path();
+    let path = if path.is_absolute() {
+        path
+    } else {
+        cwd.join(path)
+    };
+    crate::http_processing::private_context::CaMaterial::read_file(&path)
+        .map(Some)
+        .map_err(|_| failure("private HTTP CA input failed"))
+}
+
+fn validate_yaml(yaml: &str, directory: &Path, http: Option<&str>) -> Result<(), InvokeFailure> {
+    let mut config = super::parse_config_yaml_with_directory(yaml, Some(directory))
+        .map_err(|_| failure("invalid configuration"))?;
+    config
+        .set_http_config(http)
+        .map_err(|_| failure("invalid HTTP processing configuration"))?;
+    crate::runtime::PreparedCore::validate_config(config)
+        .map_err(|_| failure("invalid configuration"))
 }
 struct ForegroundInstance(Option<Arc<CoreController>>);
 impl ForegroundInstance {
@@ -223,19 +386,24 @@ impl Drop for ForegroundInstance {
 
 async fn run_controller(
     controller: Arc<CoreController>,
-    yaml: String,
-    shutdown: impl std::future::Future<Output = io::Result<()>>,
+    config: StartupConfig,
+    mut signals: ShutdownSignals,
+    cancellation: tokio_util::sync::CancellationToken,
+    reload: Option<reload::ReloadContext>,
 ) -> Result<(), InvokeFailure> {
-    tokio::pin!(shutdown);
     let starting = controller.clone();
     let dispatch = tracing::dispatcher::get_default(Clone::clone);
     let mut startup = tokio::task::spawn_blocking(move || {
         tracing::dispatcher::with_default(&dispatch, || {
-            invoke_instance_guarded(&starting, || starting.start(yaml))
+            invoke_instance_guarded(&starting, || starting.start_config(config))
         })
     });
-    if !await_startup(&mut startup, shutdown.as_mut()).await? {
-        return Ok(());
+    {
+        let shutdown = signals.wait_shutdown();
+        tokio::pin!(shutdown);
+        if !await_startup(&mut startup, shutdown.as_mut(), Some(&cancellation)).await? {
+            return Ok(());
+        }
     }
     // Copy a completion subscription without holding command admission while
     // waiting. The owner may still getState/stop/destroy through ordinary Invoke.
@@ -255,11 +423,37 @@ async fn run_controller(
             .completion
             .clone()
     };
-    if !*completion.borrow() {
+    while !*completion.borrow() {
         tokio::select! {
             biased;
-            changed=completion.changed()=> { let _=changed; },
-            signal=&mut shutdown=>return signal.map_err(|e|io_failure("shutdown signal",e)),
+            changed = completion.changed() => { let _ = changed; break; },
+            signal = signals.next() => match signal.map_err(|error| io_failure("foreground signal", error))? {
+                SignalEvent::Shutdown => return Ok(()),
+                SignalEvent::Reload => if let Some(reload) = &reload {
+                    let reload_cancel = cancellation.child_token();
+                    let applying = reload.apply(&controller, &reload_cancel);
+                    tokio::pin!(applying);
+                    let result = tokio::select! {
+                        biased;
+                        signal = signals.wait_shutdown() => {
+                            reload_cancel.cancel();
+                            let _ = applying.await;
+                            return signal.map_err(|error| io_failure("shutdown signal", error));
+                        },
+                        changed = completion.changed() => {
+                            let _ = changed;
+                            reload_cancel.cancel();
+                            let _ = applying.await;
+                            break;
+                        },
+                        result = &mut applying => result,
+                    };
+                    if let Err(error) = result {
+                        // The summary is selected locally; never include request/file contents.
+                        let _ = writeln!(io::stderr().lock(), "vole: {}", error.message);
+                    }
+                },
+            },
         }
     }
     // Joining is authoritative, including panics. Preserve its failure before
@@ -280,13 +474,18 @@ async fn run_controller(
 async fn await_startup(
     startup: &mut tokio::task::JoinHandle<Result<(), InvokeFailure>>,
     shutdown: std::pin::Pin<&mut impl std::future::Future<Output = io::Result<()>>>,
+    cancellation: Option<&tokio_util::sync::CancellationToken>,
 ) -> Result<bool, InvokeFailure> {
     tokio::select! {
         biased;
         signal=shutdown=> {
             // Startup is joined even when shutdown arrives first.
-            startup.await.map_err(|_|failure("core startup worker failed"))?
-                .map_err(|_|failure("core startup failed"))?;
+            let cancelled_startup = cancellation.is_some() && !startup.is_finished();
+            if let Some(cancellation) = cancellation { cancellation.cancel(); }
+            let result = startup.await.map_err(|_|failure("core startup worker failed"))?;
+            if !cancelled_startup {
+                result.map_err(|_|failure("core startup failed"))?;
+            }
             signal.map_err(|e|io_failure("shutdown signal",e))?;
             Ok(false)
         }
@@ -389,16 +588,19 @@ fn clean_path(path: &Path) -> PathBuf {
     clean
 }
 fn read_config(path: &Path) -> io::Result<Vec<u8>> {
+    read_config_limit(path, crate::config::MAX_CONFIG_BYTES)
+}
+fn read_config_limit(path: &Path, limit: usize) -> io::Result<Vec<u8>> {
     let metadata = fs::metadata(path)?;
     require_regular(&metadata)?;
-    if metadata.len() > crate::config::MAX_CONFIG_BYTES as u64 {
+    if metadata.len() > limit as u64 {
         return Err(io::Error::new(
             io::ErrorKind::InvalidData,
             "configuration exceeds byte limit",
         ));
     }
     let file = open_regular(path)?;
-    read_bounded(file)
+    read_bounded_limit(file, limit)
 }
 
 fn open_regular(path: &Path) -> io::Result<File> {
@@ -429,7 +631,9 @@ fn require_regular(metadata: &fs::Metadata) -> io::Result<()> {
 }
 
 fn read_bounded(reader: impl Read) -> io::Result<Vec<u8>> {
-    let limit = crate::config::MAX_CONFIG_BYTES;
+    read_bounded_limit(reader, crate::config::MAX_CONFIG_BYTES)
+}
+fn read_bounded_limit(reader: impl Read, limit: usize) -> io::Result<Vec<u8>> {
     let mut config = Vec::new();
     reader.take((limit + 1) as u64).read_to_end(&mut config)?;
     if config.len() > limit {
@@ -441,10 +645,17 @@ fn read_bounded(reader: impl Read) -> io::Result<Vec<u8>> {
     Ok(config)
 }
 
+enum SignalEvent {
+    Shutdown,
+    #[cfg_attr(not(unix), allow(dead_code))]
+    Reload,
+}
+
 #[cfg(unix)]
 struct ShutdownSignals {
     interrupt: tokio::signal::unix::Signal,
     terminate: tokio::signal::unix::Signal,
+    hangup: tokio::signal::unix::Signal,
 }
 
 #[cfg(unix)]
@@ -455,16 +666,28 @@ impl ShutdownSignals {
         Ok(Self {
             interrupt: signal(SignalKind::interrupt())?,
             terminate: signal(SignalKind::terminate())?,
+            hangup: signal(SignalKind::hangup())?,
         })
     }
 
-    async fn wait(mut self) -> io::Result<()> {
+    async fn wait_shutdown(&mut self) -> io::Result<()> {
         let received = tokio::select! {
             received = self.interrupt.recv() => received,
             received = self.terminate.recv() => received,
         };
         received.ok_or_else(|| io::Error::other("shutdown signal stream closed"))
     }
+    async fn next(&mut self) -> io::Result<SignalEvent> {
+        let (received, event) = tokio::select! {
+            biased;
+            received = self.interrupt.recv() => (received, SignalEvent::Shutdown),
+            received = self.terminate.recv() => (received, SignalEvent::Shutdown),
+            received = self.hangup.recv() => (received, SignalEvent::Reload),
+        };
+        received
+            .ok_or_else(|| io::Error::other("foreground signal stream closed"))
+            .map(|()| event)
+    }
 }
 
 #[cfg(windows)]
@@ -482,13 +705,16 @@ impl ShutdownSignals {
         })
     }
 
-    async fn wait(mut self) -> io::Result<()> {
+    async fn wait_shutdown(&mut self) -> io::Result<()> {
         let received = tokio::select! {
             received = self.interrupt.recv() => received,
             received = self.break_signal.recv() => received,
         };
         received.ok_or_else(|| io::Error::other("shutdown signal stream closed"))
     }
+    async fn next(&mut self) -> io::Result<SignalEvent> {
+        self.wait_shutdown().await.map(|()| SignalEvent::Shutdown)
+    }
 }
 
 #[cfg(not(any(unix, windows)))]
@@ -500,49 +726,39 @@ impl ShutdownSignals {
         Err(io::ErrorKind::Unsupported.into())
     }
 
-    async fn wait(self) -> io::Result<()> {
+    async fn wait_shutdown(&mut self) -> io::Result<()> {
+        Err(io::ErrorKind::Unsupported.into())
+    }
+    async fn next(&mut self) -> io::Result<SignalEvent> {
         Err(io::ErrorKind::Unsupported.into())
     }
 }
 
-const LOG_BYTES: usize = 512;
-const LOG_EVENTS_PER_SECOND: u32 = 64;
-
 struct StderrSubscriber {
     next_span: AtomicU64,
-    rate: Mutex<(Instant, u32)>,
 }
 
 impl StderrSubscriber {
     fn new() -> Self {
         Self {
             next_span: AtomicU64::new(1),
-            rate: Mutex::new((Instant::now(), 0)),
         }
     }
 
     fn accepts(metadata: &Metadata<'_>) -> bool {
-        let target = metadata.target();
         metadata.is_event()
-            && *metadata.level() <= Level::INFO
-            && (target == "vole"
-                || target.starts_with("vole::")
-                || target == "vole_netstack"
-                || target.starts_with("vole_netstack::"))
     }
 
-    fn admit(&self) -> bool {
-        let Ok(mut rate) = self.rate.lock() else {
-            return false;
-        };
-        if rate.0.elapsed() >= Duration::from_secs(1) {
-            *rate = (Instant::now(), 0);
-        }
-        if rate.1 >= LOG_EVENTS_PER_SECOND {
-            return false;
+    fn write_event(event: &Event<'_>, output: &mut impl Write) -> io::Result<()> {
+        if Self::accepts(event.metadata()) {
+            writeln!(
+                output,
+                "vole: [{}] {}",
+                event.metadata().level(),
+                crate::logging::format_event(event)
+            )?;
         }
-        rate.1 += 1;
-        true
+        Ok(())
     }
 }
 
@@ -560,7 +776,7 @@ impl Subscriber for StderrSubscriber {
     }
 
     fn max_level_hint(&self) -> Option<LevelFilter> {
-        Some(LevelFilter::INFO)
+        Some(LevelFilter::TRACE)
     }
 
     fn new_span(&self, _attributes: &Attributes<'_>) -> Id {
@@ -578,110 +794,14 @@ impl Subscriber for StderrSubscriber {
     fn exit(&self, _span: &Id) {}
 
     fn event(&self, event: &Event<'_>) {
-        if !Self::accepts(event.metadata()) || !self.admit() {
-            return;
-        }
-        use fmt::Write as _;
-
-        let mut line = LogLine::new();
-        _ = write!(
-            line,
-            "vole: [{}] {}",
-            event.metadata().level(),
-            event.metadata().target()
-        );
-        event.record(&mut NumericFields(&mut line));
-        _ = writeln!(io::stderr().lock(), "{}", line.as_str());
-    }
-}
-
-struct NumericFields<'a>(&'a mut LogLine);
-
-impl Visit for NumericFields<'_> {
-    fn record_u64(&mut self, field: &Field, value: u64) {
-        use fmt::Write as _;
-        if public_numeric_field(field.name()) {
-            _ = write!(self.0, " {}={value}", field.name());
-        }
-    }
-
-    fn record_i64(&mut self, field: &Field, value: i64) {
-        use fmt::Write as _;
-        if public_numeric_field(field.name()) {
-            _ = write!(self.0, " {}={value}", field.name());
-        }
-    }
-
-    fn record_bool(&mut self, field: &Field, value: bool) {
-        use fmt::Write as _;
-        if public_numeric_field(field.name()) {
-            _ = write!(self.0, " {}={value}", field.name());
-        }
-    }
-
-    fn record_debug(&mut self, _field: &Field, _value: &dyn fmt::Debug) {}
-    fn record_str(&mut self, _field: &Field, _value: &str) {}
-}
-
-fn public_numeric_field(name: &str) -> bool {
-    matches!(
-        name,
-        "mtu" | "packet_queue" | "event_queue" | "cancelled" | "panicked" | "dns_hijack" | "ipv6"
-    ) || name.starts_with("current_")
-        || name.starts_with("peak_")
-        || [
-            "_current",
-            "_peak",
-            "_count",
-            "_dropped",
-            "_bytes",
-            "_capacity",
-            "_limit",
-            "_ms",
-            "_seconds",
-        ]
-        .iter()
-        .any(|suffix| name.ends_with(suffix))
-}
-
-struct LogLine {
-    bytes: [u8; LOG_BYTES],
-    len: usize,
-}
-
-impl LogLine {
-    fn new() -> Self {
-        Self {
-            bytes: [0; LOG_BYTES],
-            len: 0,
-        }
-    }
-
-    fn as_str(&self) -> &str {
-        // Writes append complete UTF-8 characters only.
-        std::str::from_utf8(&self.bytes[..self.len]).unwrap_or("")
-    }
-}
-
-impl fmt::Write for LogLine {
-    fn write_str(&mut self, text: &str) -> fmt::Result {
-        for character in text.chars().filter(|character| !character.is_control()) {
-            let mut buffer = [0; 4];
-            let character = character.encode_utf8(&mut buffer);
-            if self.len + character.len() > self.bytes.len() {
-                break;
-            }
-            self.bytes[self.len..self.len + character.len()].copy_from_slice(character.as_bytes());
-            self.len += character.len();
-        }
-        Ok(())
+        _ = Self::write_event(event, &mut io::stderr().lock());
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::io::Cursor;
+    use std::{io::Cursor, time::Duration};
     fn options(data: Option<PathBuf>, config: Option<PathBuf>) -> PathOptions {
         PathOptions {
             data_dir: data,
@@ -797,12 +917,66 @@ mod tests {
         fs::write(&config,"tun: {enable: true, file-descriptor: 2147483647, mtu: 1500}\nproxies: [{name: unused, type: socks5, server: 127.0.0.1, port: 1081}]\nrules: ['GEOSITE,cn,DIRECT','MATCH,unused']").unwrap();
         let payload = ForegroundPayload {
             action: ForegroundAction::Validate,
+            config_string: None,
+            age_secret_key: None,
+            external_controller: None,
+            external_controller_tls: None,
+            external_controller_unix: None,
+            external_controller_routing_mark: None,
+            secret: None,
             data_dir: Some(data.clone().into()),
             config_path: Some(config.into()),
+            http_config_path: None,
+            http_ca_path: None,
         };
         assert_eq!(execute(payload).unwrap()["output"], "configuration valid\n");
         assert!(!data.exists());
     }
+    #[test]
+    #[cfg(feature = "outbound-http")]
+    fn validation_resolves_identity_files_from_data_dir_without_initializing_it() {
+        use base64::Engine as _;
+        let pem = |kind: &str, der: &[u8]| {
+            format!(
+                "-----BEGIN {kind}-----\n{}\n-----END {kind}-----\n",
+                base64::engine::general_purpose::STANDARD.encode(der)
+            )
+        };
+        let directory = tempfile::tempdir().unwrap();
+        let data = directory.path().join("state");
+        fs::create_dir(&data).unwrap();
+        let identity = rcgen::generate_simple_self_signed(vec!["client.invalid".into()]).unwrap();
+        fs::write(
+            data.join("client.crt"),
+            pem("CERTIFICATE", identity.cert.der()),
+        )
+        .unwrap();
+        fs::write(
+            data.join("client.key"),
+            pem("PRIVATE KEY", &identity.signing_key.serialize_der()),
+        )
+        .unwrap();
+        let config = directory.path().join("config.yaml");
+        fs::write(&config, "proxies:\n  - name: edge\n    type: http\n    server: proxy.invalid\n    port: 443\n    tls: true\n    certificate: client.crt\n    private-key: client.key\n").unwrap();
+        let result = execute(ForegroundPayload {
+            action: ForegroundAction::Validate,
+            config_string: None,
+            age_secret_key: None,
+            external_controller: None,
+            external_controller_tls: None,
+            external_controller_unix: None,
+            external_controller_routing_mark: None,
+            secret: None,
+            data_dir: Some(data.clone().into()),
+            config_path: Some(config.into()),
+            http_config_path: None,
+            http_ca_path: None,
+        })
+        .unwrap();
+        assert_eq!(result["output"], "configuration valid\n");
+        assert!(!data.join("geodata").exists() && !data.join("configs").exists());
+    }
+
     #[test]
     fn validation_failures_do_not_echo_config_or_initialize_data() {
         let dir = tempfile::tempdir().unwrap();
@@ -811,20 +985,72 @@ mod tests {
         fs::write(&config, "private-token: super-secret").unwrap();
         let error = execute(ForegroundPayload {
             action: ForegroundAction::Validate,
+            config_string: None,
+            age_secret_key: None,
+            external_controller: None,
+            external_controller_tls: None,
+            external_controller_unix: None,
+            external_controller_routing_mark: None,
+            secret: None,
             data_dir: Some(data.clone().into()),
             config_path: Some(config.into()),
+            http_config_path: None,
+            http_ca_path: None,
         })
         .unwrap_err();
         assert!(!error.message.contains("secret"));
         assert!(!data.exists());
     }
     #[test]
+    fn unused_ca_is_not_read_and_ca_without_http_is_rejected_before_input() {
+        let invalid_path = || Some(InvokePath::Text("\0".to_owned()));
+        assert!(
+            read_http_ca(
+                invalid_path(),
+                Some("mitm: {enabled: false}"),
+                Path::new("/")
+            )
+            .unwrap()
+            .is_none()
+        );
+        assert!(
+            read_http_ca(invalid_path(), Some(""), Path::new("/"))
+                .unwrap()
+                .is_none()
+        );
+        let error = execute(ForegroundPayload {
+            action: ForegroundAction::Validate,
+            config_string: None,
+            age_secret_key: None,
+            external_controller: None,
+            external_controller_tls: None,
+            external_controller_unix: None,
+            external_controller_routing_mark: None,
+            secret: None,
+            data_dir: invalid_path(),
+            config_path: invalid_path(),
+            http_config_path: None,
+            http_ca_path: invalid_path(),
+        })
+        .unwrap_err();
+        assert_eq!(error.message, "httpCaPath requires httpConfigPath");
+    }
+    #[test]
     fn run_admission_rejects_busy_before_reading_input() {
         let _lease = lock(&FOREGROUND);
         let error = execute(ForegroundPayload {
             action: ForegroundAction::Run,
+            config_string: None,
+            age_secret_key: None,
+            external_controller: None,
+            external_controller_tls: None,
+            external_controller_unix: None,
+            external_controller_routing_mark: None,
+            secret: None,
             data_dir: Some(InvokePath::Text("\0".to_owned())),
             config_path: Some(InvokePath::Text("-".to_owned())),
+            http_config_path: None,
+            http_ca_path: None,
         })
         .unwrap_err();
         assert_eq!(error.message, "foreground is already running");
@@ -833,8 +1059,17 @@ mod tests {
     async fn run_rejects_external_tokio_context_before_input() {
         let error = execute(ForegroundPayload {
             action: ForegroundAction::Run,
+            config_string: None,
+            age_secret_key: None,
+            external_controller: None,
+            external_controller_tls: None,
+            external_controller_unix: None,
+            external_controller_routing_mark: None,
+            secret: None,
             data_dir: None,
             config_path: Some(InvokePath::Text("-".to_owned())),
+            http_config_path: None,
+            http_ca_path: None,
         })
         .unwrap_err();
         assert!(error.message.contains("synchronous caller"));
@@ -844,8 +1079,17 @@ mod tests {
     fn help_does_not_read_or_initialize_paths() {
         let result = execute(ForegroundPayload {
             action: ForegroundAction::Help,
+            config_string: None,
+            age_secret_key: None,
+            external_controller: None,
+            external_controller_tls: None,
+            external_controller_unix: None,
+            external_controller_routing_mark: None,
+            secret: None,
             data_dir: Some(InvokePath::Text("\0".to_owned())),
             config_path: Some(InvokePath::Text("\0".to_owned())),
+            http_config_path: None,
+            http_ca_path: None,
         })
         .unwrap();
         assert_eq!(result["diagnostics"], HELP);
@@ -894,7 +1138,7 @@ mod tests {
         });
         let signal = async { Ok(()) };
         tokio::pin!(signal);
-        let wait = await_startup(&mut startup, signal.as_mut());
+        let wait = await_startup(&mut startup, signal.as_mut(), None);
         tokio::pin!(wait);
         assert!(
             tokio::time::timeout(Duration::from_millis(10), wait.as_mut())
@@ -905,12 +1149,35 @@ mod tests {
         assert!(!wait.await.unwrap());
     }
     #[tokio::test]
+    async fn signal_cancels_startup_and_joins_its_cleanup_before_success() {
+        let cancellation = tokio_util::sync::CancellationToken::new();
+        let worker_cancellation = cancellation.clone();
+        let (sent, received) = tokio::sync::oneshot::channel();
+        let mut startup = tokio::spawn(async move {
+            worker_cancellation.cancelled().await;
+            received.await.unwrap();
+            Err(failure("startup cancelled"))
+        });
+        let signal = async { Ok(()) };
+        tokio::pin!(signal);
+        let wait = await_startup(&mut startup, signal.as_mut(), Some(&cancellation));
+        tokio::pin!(wait);
+        assert!(
+            tokio::time::timeout(Duration::from_millis(10), wait.as_mut())
+                .await
+                .is_err()
+        );
+        assert!(cancellation.is_cancelled());
+        sent.send(()).unwrap();
+        assert!(!wait.await.unwrap());
+    }
+    #[tokio::test]
     async fn startup_failure_is_preserved_when_signal_is_ready() {
         let mut startup = tokio::spawn(async { Err(failure("private secret")) });
         let signal = async { Ok(()) };
         tokio::pin!(signal);
         assert_eq!(
-            await_startup(&mut startup, signal.as_mut())
+            await_startup(&mut startup, signal.as_mut(), None)
                 .await
                 .unwrap_err()
                 .message,
@@ -937,13 +1204,135 @@ mod tests {
             .is_some()));
     }
 
+    fn capture_stderr_logs(emit: impl FnOnce()) -> String {
+        struct Capture(Arc<Mutex<Vec<u8>>>);
+        impl Subscriber for Capture {
+            fn enabled(&self, metadata: &Metadata<'_>) -> bool {
+                StderrSubscriber::accepts(metadata)
+            }
+            fn new_span(&self, _: &Attributes<'_>) -> Id {
+                Id::from_u64(1)
+            }
+            fn record(&self, _: &Id, _: &Record<'_>) {}
+            fn record_follows_from(&self, _: &Id, _: &Id) {}
+            fn enter(&self, _: &Id) {}
+            fn exit(&self, _: &Id) {}
+            fn event(&self, event: &Event<'_>) {
+                StderrSubscriber::write_event(event, &mut *self.0.lock().unwrap()).unwrap();
+            }
+        }
+        let output = Arc::new(Mutex::new(Vec::new()));
+        tracing::subscriber::with_default(Capture(output.clone()), emit);
+        let output = output.lock().unwrap().clone();
+        String::from_utf8(output).unwrap()
+    }
+
+    #[test]
+    fn stderr_messages_preserve_long_unicode_and_control_characters() {
+        let message = "😀\n\t".repeat(200);
+        let output = capture_stderr_logs(|| {
+            tracing::info!(target: "external::library", message = message.as_str());
+        });
+        assert!(output.starts_with("vole: [INFO] external::library"));
+        assert!(output.contains(&message));
+    }
+
+    #[test]
+    fn stderr_events_preserve_all_generated_fields() {
+        let output = capture_stderr_logs(|| {
+            tracing::info!(
+                packet_queue_drops = 1_u64,
+                udp_queue_drops = 2_u64,
+                udp_association_queue_drops = 3_u64,
+                udp_response_queue_drops = 4_u64,
+                dns_queue_drops = 5_u64,
+                udp_drops = 6_u64,
+                mtu = 1500_u64,
+                destination = "synthetic destination",
+                uuid = 123_u64,
+                password_bytes = "synthetic credential",
+                "synthetic message"
+            );
+        });
+        for (field, count) in [
+            ("packet_queue_drops", 1),
+            ("udp_queue_drops", 2),
+            ("udp_association_queue_drops", 3),
+            ("udp_response_queue_drops", 4),
+            ("dns_queue_drops", 5),
+            ("udp_drops", 6),
+        ] {
+            assert!(output.contains(&format!(" {field}={count}")));
+        }
+        for content in [
+            "mtu=1500",
+            "synthetic destination",
+            "uuid=123",
+            "synthetic credential",
+            "synthetic message",
+        ] {
+            assert!(output.contains(content));
+        }
+    }
+
     #[test]
-    fn stderr_fields_exclude_targets_and_log_buffer_is_bounded() {
-        assert!(!public_numeric_field("destination"));
-        assert!(!public_numeric_field("uuid"));
-        let mut line = LogLine::new();
-        fmt::Write::write_str(&mut line, &"😀".repeat(200)).unwrap();
-        assert!(line.len <= LOG_BYTES);
-        assert!(!line.as_str().is_empty());
+    fn stderr_events_are_not_rate_limited() {
+        let output = capture_stderr_logs(|| {
+            for sequence in 0..128 {
+                tracing::info!(target: "external", sequence, "complete event");
+            }
+        });
+        assert_eq!(output.lines().count(), 128);
+        assert_eq!(output.matches("complete event").count(), 128);
+    }
+
+    #[test]
+    #[cfg(feature = "inbound-http")]
+    fn explicit_http_file_is_validated_without_initializing_data_or_autoloading() {
+        let root = tempfile::tempdir().unwrap();
+        let data = root.path().join("absent");
+        let main = root.path().join("main.yaml");
+        let http = root.path().join("extra.yaml");
+        fs::write(&main, "rules: ['MATCH,DIRECT']").unwrap();
+        fs::write(
+            &http,
+            "rewrite: {enabled: true, rules: [{url: '.', action: reject}]}",
+        )
+        .unwrap();
+        let result = execute(ForegroundPayload {
+            action: ForegroundAction::Validate,
+            config_string: None,
+            age_secret_key: None,
+            external_controller: None,
+            external_controller_tls: None,
+            external_controller_unix: None,
+            external_controller_routing_mark: None,
+            secret: None,
+            data_dir: Some(data.clone().into()),
+            config_path: Some(main.clone().into()),
+            http_config_path: Some(http.clone().into()),
+            http_ca_path: Some(root.path().join("missing-private-ca.json").into()),
+        })
+        .unwrap();
+        assert_eq!(result["output"], "configuration valid\n");
+        assert!(!data.exists());
+        fs::write(http, "private-secret: private-data").unwrap();
+        let result = execute(ForegroundPayload {
+            action: ForegroundAction::Validate,
+            config_string: None,
+            age_secret_key: None,
+            external_controller: None,
+            external_controller_tls: None,
+            external_controller_unix: None,
+            external_controller_routing_mark: None,
+            secret: None,
+            data_dir: Some(data.clone().into()),
+            config_path: Some(main.clone().into()),
+            http_config_path: None,
+            http_ca_path: None,
+        })
+        .unwrap();
+        assert_eq!(result["output"], "configuration valid\n");
+        assert!(!data.exists());
     }
 }
diff --git a/src/invoke/foreground/input.rs b/src/invoke/foreground/input.rs
new file mode 100644
index 0000000..c76978b
--- /dev/null
+++ b/src/invoke/foreground/input.rs
@@ -0,0 +1,413 @@
+//! Foreground-only bounded source selection and shared AGE decryption.
+use super::{InvokeFailure, Paths, failure, io_failure, read_config};
+use crate::{config::MAX_CONFIG_BYTES, resource::age_provider};
+use base64::{Engine as _, engine::general_purpose::STANDARD};
+use serde::{Deserialize, Deserializer};
+use std::{
+    path::{Path, PathBuf},
+    sync::Arc,
+    time::{Duration, Instant},
+};
+use tokio_util::sync::CancellationToken;
+use zeroize::Zeroizing;
+
+pub(super) const MAX_ENCODED_BYTES: usize = MAX_CONFIG_BYTES.div_ceil(3) * 4;
+const MAX_SECRET_BYTES: usize = 16 * 1024;
+
+pub(super) fn private_text<'de, D: Deserializer<'de>>(
+    deserializer: D,
+) -> Result<Option<Zeroizing<String>>, D::Error> {
+    Option::<String>::deserialize(deserializer).map(|value| value.map(Zeroizing::new))
+}
+
+pub(super) fn option_text(
+    value: Option<Zeroizing<String>>,
+    environment: &str,
+    limit: usize,
+) -> Result<Option<Zeroizing<String>>, InvokeFailure> {
+    let value = match value {
+        Some(value) => Some(value),
+        None => match std::env::var(environment) {
+            Ok(value) => Some(Zeroizing::new(value)),
+            Err(std::env::VarError::NotPresent) => None,
+            Err(std::env::VarError::NotUnicode(value)) => {
+                drop(Zeroizing::new(value.into_encoded_bytes()));
+                return Err(failure("foreground text environment requires UTF-8"));
+            }
+        },
+    };
+    if value.as_ref().is_some_and(|value| value.len() > limit) {
+        return Err(failure("foreground text input exceeds byte limit"));
+    }
+    Ok(value.filter(|value| !value.is_empty()))
+}
+
+pub(super) struct SourceOptions {
+    pub(super) config: Option<Zeroizing<String>>,
+    pub(super) key: Option<Zeroizing<String>>,
+}
+pub(super) fn options(
+    config: Option<Zeroizing<String>>,
+    key: Option<Zeroizing<String>>,
+) -> Result<SourceOptions, InvokeFailure> {
+    Ok(SourceOptions {
+        config: option_text(config, "VOLE_CONFIG_STRING", MAX_ENCODED_BYTES)?,
+        key: option_text(key, "VOLE_AGE_SECRET_KEY", MAX_SECRET_BYTES)?,
+    })
+}
+
+#[derive(Clone, Default)]
+pub(super) struct Decoder {
+    identities: Option<age_provider::Identities>,
+    invalid_identity: bool,
+}
+impl Decoder {
+    fn new(key: Option<Zeroizing<String>>) -> Self {
+        let parsed = key
+            .as_ref()
+            .filter(|value| !value.is_empty())
+            .map(|key| age_provider::Identities::parse(key));
+        drop(key);
+        match parsed {
+            Some(Ok(identities)) => Self {
+                identities: Some(identities),
+                invalid_identity: false,
+            },
+            Some(Err(_)) => Self {
+                identities: None,
+                invalid_identity: true,
+            },
+            None => Self::default(),
+        }
+    }
+    fn decode(
+        &self,
+        bytes: Zeroizing<Vec<u8>>,
+        cancellation: Option<&CancellationToken>,
+    ) -> Result<String, InvokeFailure> {
+        if bytes.starts_with(age_provider::ARMOR_HEADER) && self.invalid_identity {
+            return Err(failure("invalid AGE configuration identity"));
+        }
+        let control = age_provider::DecodeControl::new(
+            cancellation,
+            Instant::now() + Duration::from_secs(30),
+        );
+        let decrypted = match age_provider::decode(
+            &bytes,
+            self.identities.as_ref(),
+            &control,
+            MAX_CONFIG_BYTES,
+        )
+        .map_err(|_| failure("configuration decryption failed"))?
+        {
+            age_provider::Decoded::Plain(_) => None,
+            age_provider::Decoded::Decrypted(plaintext) => Some(plaintext),
+        };
+        let mut plaintext = decrypted.unwrap_or(bytes);
+        String::from_utf8(std::mem::take(&mut *plaintext)).map_err(|error| {
+            drop(Zeroizing::new(error.into_bytes()));
+            failure("configuration is not UTF-8")
+        })
+    }
+}
+
+pub(super) struct MainInput {
+    bytes: Zeroizing<Vec<u8>>,
+    decoder: Decoder,
+    file: Option<PathBuf>,
+}
+pub(super) struct LoadedInput {
+    pub(super) yaml: Zeroizing<String>,
+    pub(super) reload: Option<ReloadInput>,
+}
+#[derive(Clone)]
+#[cfg_attr(not(unix), allow(dead_code))]
+pub(super) enum ReloadInput {
+    File { path: PathBuf, decoder: Decoder },
+    Snapshot(Arc<Zeroizing<String>>),
+}
+impl ReloadInput {
+    pub(super) fn read(
+        &self,
+        cancellation: &CancellationToken,
+    ) -> Result<Zeroizing<String>, InvokeFailure> {
+        if cancellation.is_cancelled() {
+            return Err(failure("configuration reload cancelled"));
+        }
+        match self {
+            Self::File { path, decoder } => {
+                let bytes = read_config(path)
+                    .map_err(|error| io_failure("read configuration file", error))?;
+                decoder
+                    .decode(Zeroizing::new(bytes), Some(cancellation))
+                    .map(Zeroizing::new)
+            }
+            Self::Snapshot(yaml) => Ok(Zeroizing::new(yaml.as_str().to_owned())),
+        }
+    }
+}
+impl MainInput {
+    pub(super) fn source_file(&self) -> Option<&Path> {
+        self.file.as_deref()
+    }
+    pub(super) fn read(
+        config: Option<Zeroizing<String>>,
+        key: Option<Zeroizing<String>>,
+        paths: &Paths,
+        stdin: impl FnOnce() -> std::io::Result<Vec<u8>>,
+    ) -> Result<Self, InvokeFailure> {
+        // The alternative input is never opened, locked or probed.
+        let file = (!paths.stdin && !config.as_ref().is_some_and(|value| !value.is_empty()))
+            .then(|| paths.config_file.clone());
+        let bytes = if let Some(mut encoded) = config.filter(|value| !value.is_empty()) {
+            if encoded.len() > MAX_ENCODED_BYTES {
+                return Err(failure("encoded configuration exceeds byte limit"));
+            }
+            // Go's StdEncoding ignores CR/LF but still requires standard padding.
+            encoded.retain(|character| !matches!(character, '\r' | '\n'));
+            let mut bytes = Zeroizing::new(Vec::new());
+            STANDARD
+                .decode_vec(encoded.as_bytes(), &mut bytes)
+                .map_err(|_| failure("invalid Base64 configuration"))?;
+            drop(encoded);
+            bytes
+        } else {
+            Zeroizing::new(if paths.stdin {
+                stdin().map_err(|error| io_failure("read configuration input", error))?
+            } else {
+                read_config(&paths.config_file)
+                    .map_err(|error| io_failure("read configuration file", error))?
+            })
+        };
+        if bytes.len() > MAX_CONFIG_BYTES {
+            return Err(failure("configuration exceeds byte limit"));
+        }
+        Ok(Self {
+            bytes,
+            decoder: Decoder::new(key),
+            file,
+        })
+    }
+
+    pub(super) fn into_yaml(
+        self,
+        cancellation: Option<&CancellationToken>,
+    ) -> Result<String, InvokeFailure> {
+        self.decoder.decode(self.bytes, cancellation)
+    }
+    pub(super) fn into_loaded(
+        self,
+        cancellation: &CancellationToken,
+    ) -> Result<LoadedInput, InvokeFailure> {
+        let yaml = Zeroizing::new(self.decoder.decode(self.bytes, Some(cancellation))?);
+        #[cfg(unix)]
+        let reload = Some(match self.file {
+            Some(path) => ReloadInput::File {
+                path,
+                decoder: self.decoder,
+            },
+            None => ReloadInput::Snapshot(Arc::new(Zeroizing::new(yaml.as_str().to_owned()))),
+        });
+        #[cfg(not(unix))]
+        let reload = {
+            let _ = (&self.file, &self.decoder);
+            None
+        };
+        Ok(LoadedInput { yaml, reload })
+    }
+}
+
+/// Enforce text limits before creating a potentially escaped JSON String/Value.
+pub(super) fn check_envelope(request: &str) -> Result<(), InvokeFailure> {
+    use serde_json::value::RawValue;
+    let envelope: super::super::RawRequestEnvelope<'_> = serde_json::from_str(request)
+        .map_err(|_| failure("invalid foreground request envelope"))?;
+    if envelope.method.get().len() > 6 * "foreground".len() + 2
+        || !serde_json::from_str::<String>(envelope.method.get())
+            .is_ok_and(|method| method == "foreground")
+    {
+        return Ok(());
+    }
+    #[derive(Deserialize)]
+    #[serde(rename_all = "camelCase")]
+    struct Input<'a> {
+        #[serde(borrow)]
+        config_string: Option<&'a RawValue>,
+        #[serde(borrow)]
+        age_secret_key: Option<&'a RawValue>,
+        #[serde(borrow)]
+        external_controller: Option<&'a RawValue>,
+        #[serde(borrow)]
+        external_controller_tls: Option<&'a RawValue>,
+        #[serde(borrow)]
+        external_controller_unix: Option<&'a RawValue>,
+        #[serde(borrow)]
+        secret: Option<&'a RawValue>,
+    }
+    let input: Input<'_> = serde_json::from_str(envelope.payload.get())
+        .map_err(|_| failure("invalid foreground input"))?;
+    for (raw, limit) in [
+        (input.config_string, MAX_ENCODED_BYTES),
+        (input.age_secret_key, MAX_SECRET_BYTES),
+        (input.external_controller, MAX_CONFIG_BYTES),
+        (input.external_controller_tls, MAX_CONFIG_BYTES),
+        (input.external_controller_unix, MAX_CONFIG_BYTES),
+        (input.secret, MAX_CONFIG_BYTES),
+    ] {
+        if let Some(raw) = raw {
+            super::super::check_json_string_limit(raw.get(), limit)
+                .map_err(|_| failure("foreground text input exceeds limit or is not a string"))?;
+        }
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::PathBuf;
+
+    fn paths(stdin: bool) -> Paths {
+        Paths {
+            data_dir: PathBuf::from("/absent"),
+            config_file: PathBuf::from("/absent/config.yaml"),
+            stdin,
+        }
+    }
+    fn private(value: &str) -> Option<Zeroizing<String>> {
+        Some(Zeroizing::new(value.to_owned()))
+    }
+    #[test]
+    fn base64_has_priority_over_explicit_stdin_and_files() {
+        let encoded = STANDARD.encode(b"rules: ['MATCH,DIRECT']");
+        let encoded = format!("{}\r\n{}", &encoded[..4], &encoded[4..]);
+        for stdin in [false, true] {
+            let input = MainInput::read(private(&encoded), None, &paths(stdin), || {
+                panic!("stdin read")
+            })
+            .unwrap();
+            assert_eq!(input.into_yaml(None).unwrap(), "rules: ['MATCH,DIRECT']");
+        }
+        assert_eq!(
+            MainInput::read(
+                private(""),
+                None,
+                &paths(true),
+                || Ok(b"rules: []".to_vec())
+            )
+            .unwrap()
+            .into_yaml(None)
+            .unwrap(),
+            "rules: []"
+        );
+        for encoded in ["c2VjcmV0=", "c2VjcmV0_", "eA"] {
+            assert!(
+                MainInput::read(private(encoded), None, &paths(true), || panic!(
+                    "stdin read"
+                ))
+                .is_err()
+            );
+        }
+    }
+    #[test]
+    fn foreground_age_reuses_authenticated_official_vectors_and_bounds() {
+        let key = include_str!("../../../tests/fixtures/provider-age/x25519.key");
+        let content = include_bytes!("../../../tests/fixtures/provider-age/x25519.age");
+        let expected = include_str!("../../../tests/fixtures/provider-age/provider.yaml");
+        let input = MainInput::read(
+            private(&STANDARD.encode(content)),
+            private(key),
+            &paths(true),
+            || panic!("stdin read"),
+        )
+        .unwrap();
+        assert_eq!(input.into_yaml(None).unwrap(), expected);
+        let input = MainInput::read(None, None, &paths(true), || Ok(content.to_vec())).unwrap();
+        assert!(input.into_yaml(None).is_err());
+        let input = MainInput::read(
+            None,
+            private("invalid-private-fixture"),
+            &paths(true),
+            || Ok(b"rules: []".to_vec()),
+        )
+        .unwrap();
+        assert_eq!(input.into_yaml(None).unwrap(), "rules: []");
+        let input =
+            MainInput::read(None, private(key), &paths(true), || Ok(content.to_vec())).unwrap();
+        let cancellation = CancellationToken::new();
+        cancellation.cancel();
+        assert!(input.into_yaml(Some(&cancellation)).is_err());
+        let input = MainInput::read(
+            private(&"x".repeat(MAX_ENCODED_BYTES + 1)),
+            None,
+            &paths(true),
+            || panic!("stdin read"),
+        );
+        assert!(input.is_err());
+    }
+    #[test]
+    #[cfg(unix)]
+    fn reload_reuses_snapshot_bytes_and_rereads_only_the_main_file() {
+        let cancellation = CancellationToken::new();
+        let input = MainInput::read(
+            private(&STANDARD.encode(b"rules: ['MATCH,DIRECT']")),
+            None,
+            &paths(true),
+            || panic!("stdin read"),
+        )
+        .unwrap();
+        let loaded = input.into_loaded(&cancellation).unwrap();
+        assert_eq!(
+            *loaded.reload.as_ref().unwrap().read(&cancellation).unwrap(),
+            *loaded.yaml
+        );
+        let directory = tempfile::tempdir().unwrap();
+        let file = directory.path().join("config.yaml");
+        std::fs::write(&file, b"rules: ['MATCH,DIRECT']").unwrap();
+        let mut selected = paths(false);
+        selected.config_file = file.clone();
+        let identity = include_str!("../../../tests/fixtures/provider-age/x25519.key");
+        let loaded = MainInput::read(None, private(identity), &selected, || panic!("stdin read"))
+            .unwrap()
+            .into_loaded(&cancellation)
+            .unwrap();
+        std::fs::write(&file, b"rules: ['MATCH,REJECT']").unwrap();
+        assert_eq!(
+            &**loaded.reload.as_ref().unwrap().read(&cancellation).unwrap(),
+            "rules: ['MATCH,REJECT']"
+        );
+        std::fs::write(
+            &file,
+            include_bytes!("../../../tests/fixtures/provider-age/x25519.age"),
+        )
+        .unwrap();
+        assert_eq!(
+            loaded
+                .reload
+                .as_ref()
+                .unwrap()
+                .read(&cancellation)
+                .unwrap()
+                .as_str(),
+            include_str!("../../../tests/fixtures/provider-age/provider.yaml")
+        );
+        cancellation.cancel();
+        assert!(loaded.reload.as_ref().unwrap().read(&cancellation).is_err());
+    }
+    #[test]
+    fn foreground_envelope_checks_decoded_lengths_without_disclosing_values() {
+        for field in ["configString", "ageSecretKey"] {
+            let bytes = if field == "configString" {
+                MAX_ENCODED_BYTES
+            } else {
+                MAX_SECRET_BYTES
+            };
+            let request =
+                serde_json::json!({"method":"foreground", "payload":{field:"x".repeat(bytes+1)}})
+                    .to_string();
+            assert!(check_envelope(&request).is_err());
+        }
+        let request = r#"{"method":"foreground","payload":{"ageSecretKey":"\u0078\u0078"}}"#;
+        assert!(check_envelope(request).is_ok());
+    }
+}
diff --git a/src/invoke/foreground/overrides.rs b/src/invoke/foreground/overrides.rs
new file mode 100644
index 0000000..31184c9
--- /dev/null
+++ b/src/invoke/foreground/overrides.rs
@@ -0,0 +1,367 @@
+//! Concrete foreground overrides; immutable YAML and native Invoke are unchanged.
+use super::{InvokeFailure, failure, input};
+use crate::config::{Config, ExternalControllerConfig};
+use std::net::SocketAddr;
+use std::sync::Arc;
+use zeroize::{Zeroize, Zeroizing};
+
+#[derive(Clone, Default)]
+pub(in crate::invoke) struct ControllerOverrides {
+    http: Option<SocketAddr>,
+    tls: Option<SocketAddr>,
+    unix: Option<String>,
+    mark: u32,
+    secret: Option<Zeroizing<String>>,
+}
+impl ControllerOverrides {
+    pub(in crate::invoke) fn read(
+        http: Option<Zeroizing<String>>,
+        tls: Option<Zeroizing<String>>,
+        unix: Option<Zeroizing<String>>,
+        mark: Option<i64>,
+        secret: Option<Zeroizing<String>>,
+    ) -> Result<Self, InvokeFailure> {
+        let limit = crate::config::MAX_CONFIG_BYTES;
+        Self::from_values(
+            input::option_text(http, "VOLE_OVERRIDE_EXTERNAL_CONTROLLER", limit)?,
+            input::option_text(tls, "VOLE_OVERRIDE_EXTERNAL_CONTROLLER_TLS", limit)?,
+            input::option_text(secret, "VOLE_OVERRIDE_SECRET", limit)?,
+        )?
+        .with_unix(input::option_text(
+            unix,
+            "VOLE_OVERRIDE_EXTERNAL_CONTROLLER_UNIX",
+            limit,
+        )?)?
+        .with_mark(mark.unwrap_or_else(|| {
+            std::env::var("VOLE_OVERRIDE_EXTERNAL_CONTROLLER_ROUTING_MARK")
+                .ok()
+                .map(|value| environment_mark(&value))
+                .unwrap_or(0)
+        }))
+    }
+    fn from_values(
+        http: Option<Zeroizing<String>>,
+        tls: Option<Zeroizing<String>>,
+        secret: Option<Zeroizing<String>>,
+    ) -> Result<Self, InvokeFailure> {
+        fn listener(value: Option<Zeroizing<String>>) -> Result<Option<SocketAddr>, InvokeFailure> {
+            crate::config::normalize_external_controller(
+                value.map(|mut value| std::mem::take(&mut *value)),
+                None,
+            )
+            .map(|value| value.map(|value| value.listen))
+            .map_err(|_| failure("invalid foreground Controller address"))
+        }
+        Ok(Self {
+            http: listener(http)?,
+            tls: listener(tls)?,
+            unix: None,
+            mark: 0,
+            secret: secret.filter(|value| !value.is_empty()),
+        })
+    }
+    fn with_unix(mut self, value: Option<Zeroizing<String>>) -> Result<Self, InvokeFailure> {
+        self.unix = crate::config::normalize_controller_unix(
+            value.map(|mut value| std::mem::take(&mut *value)),
+        )
+        .map_err(|_| failure("invalid foreground Controller Unix path"))?;
+        Ok(self)
+    }
+    fn with_mark(mut self, value: i64) -> Result<Self, InvokeFailure> {
+        self.mark = crate::config::normalize_controller_mark(value)
+            .map_err(|_| failure("invalid foreground Controller routing mark"))?;
+        Ok(self)
+    }
+    pub(in crate::invoke) fn apply_template(
+        &self,
+        template: &mut crate::config::providers::ProviderTemplate,
+    ) {
+        template.override_controller(
+            self.http,
+            self.tls,
+            self.unix.as_deref(),
+            (self.mark != 0).then_some(self.mark),
+            self.secret.as_ref().map(|value| value.as_str()),
+        );
+    }
+    pub(in crate::invoke) fn apply(&self, config: &mut Config) {
+        if let Some(template) = &mut config.providers {
+            self.apply_template(Arc::make_mut(template));
+        }
+        if (self.http.is_some() || self.tls.is_some() || self.unix.is_some())
+            && config.external_controller.is_none()
+        {
+            config.external_controller = Some(ExternalControllerConfig {
+                http_enabled: false,
+                routing_mark: config
+                    .providers
+                    .as_ref()
+                    .map_or(0, |template| template.controller_routing_mark()),
+                secret: config
+                    .providers
+                    .as_ref()
+                    .and_then(|template| template.controller_secret().map(str::to_owned)),
+                cors: config
+                    .providers
+                    .as_ref()
+                    .map_or_else(Default::default, |template| template.controller_cors()),
+                server_tls: config.tls.server.clone(),
+                ..ExternalControllerConfig::default()
+            });
+        }
+        let Some(controller) = &mut config.external_controller else {
+            return;
+        };
+        if let Some(http) = self.http {
+            controller.listen = http;
+            controller.http_enabled = true;
+        }
+        if let Some(tls) = self.tls {
+            if !controller.http_enabled {
+                controller.listen = tls;
+            }
+            controller.tls_listen = Some(tls);
+        }
+        if let Some(unix) = &self.unix {
+            controller.unix_path = Some(unix.clone());
+        }
+        if self.mark != 0 {
+            controller.routing_mark = self.mark;
+        }
+        if let Some(secret) = &self.secret {
+            if let Some(mut old) = controller.secret.take() {
+                old.zeroize();
+            }
+            controller.secret = Some(secret.as_str().to_owned());
+        }
+    }
+}
+
+// Mihomo's getIntEnv discards Atoi's error, including its saturated range value.
+fn environment_mark(value: &str) -> i64 {
+    match value.parse::<isize>() {
+        Ok(value) => value as i64,
+        Err(error) => match error.kind() {
+            std::num::IntErrorKind::PosOverflow => isize::MAX as i64,
+            std::num::IntErrorKind::NegOverflow => isize::MIN as i64,
+            _ => 0,
+        },
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn text(value: &str) -> Option<Zeroizing<String>> {
+        Some(Zeroizing::new(value.to_owned()))
+    }
+    #[test]
+    fn activating_controller_preserves_validated_secret_cors_and_tls_across_materialization() {
+        let mut config = Config::parse_yaml(
+            br#"
+secret: yaml-token
+external-controller-cors: {allow-origins: ['https://ui.example'], allow-private-network: false}
+tls: {certificate: cert-material, private-key: key-material, client-auth-type: require-any}
+rules: ['MATCH,DIRECT']
+"#,
+        )
+        .unwrap();
+        assert!(config.external_controller.is_none());
+        let tls = config.tls.server.clone();
+        ControllerOverrides::from_values(text("localhost:9000"), None, text(""))
+            .unwrap()
+            .apply(&mut config);
+        let controller = config.external_controller.as_ref().unwrap();
+        assert_eq!(controller.secret.as_deref(), Some("yaml-token"));
+        assert_eq!(controller.cors.allow_origins, ["https://ui.example"]);
+        assert!(!controller.cors.allow_private_network);
+        assert_eq!(controller.server_tls, tls);
+        let materialized = config
+            .providers
+            .as_ref()
+            .unwrap()
+            .materialize(&Default::default())
+            .unwrap();
+        assert_eq!(materialized.external_controller, config.external_controller);
+        ControllerOverrides::from_values(None, None, text("explicit-token"))
+            .unwrap()
+            .apply(&mut config);
+        let materialized = config
+            .providers
+            .as_ref()
+            .unwrap()
+            .materialize(&Default::default())
+            .unwrap();
+        assert_eq!(
+            config
+                .external_controller
+                .as_ref()
+                .unwrap()
+                .secret
+                .as_deref(),
+            Some("explicit-token")
+        );
+        assert_eq!(materialized.external_controller, config.external_controller);
+    }
+
+    #[test]
+    fn mark_override_preserves_zero_yaml_and_materialized_values() {
+        assert_eq!(environment_mark("+42"), 42);
+        assert_eq!(environment_mark("0x2a"), 0);
+        assert_eq!(
+            environment_mark("999999999999999999999999999"),
+            isize::MAX as i64
+        );
+
+        let mut config = Config::parse_yaml(b"external-controller: ':9000'\nexternal-controller-routing-mark: 7\nrules: ['MATCH,DIRECT']\n").unwrap();
+        ControllerOverrides::default()
+            .with_mark(0)
+            .unwrap()
+            .apply(&mut config);
+        assert_eq!(config.external_controller.as_ref().unwrap().routing_mark, 7);
+        ControllerOverrides::default()
+            .with_mark(42)
+            .unwrap()
+            .apply(&mut config);
+        assert_eq!(
+            config.external_controller.as_ref().unwrap().routing_mark,
+            42
+        );
+        assert_eq!(
+            config
+                .providers
+                .as_ref()
+                .unwrap()
+                .materialize(&Default::default())
+                .unwrap()
+                .external_controller,
+            config.external_controller
+        );
+        assert!(ControllerOverrides::default().with_mark(i64::MAX).is_err());
+
+        let mut inactive =
+            Config::parse_yaml(b"external-controller-routing-mark: -1\nrules: ['MATCH,DIRECT']\n")
+                .unwrap();
+        assert!(inactive.external_controller.is_none());
+        ControllerOverrides::from_values(text("localhost:9000"), None, None)
+            .unwrap()
+            .with_mark(0)
+            .unwrap()
+            .apply(&mut inactive);
+        assert_eq!(
+            inactive.external_controller.as_ref().unwrap().routing_mark,
+            u32::MAX
+        );
+        assert_eq!(
+            inactive
+                .providers
+                .as_ref()
+                .unwrap()
+                .materialize(&Default::default())
+                .unwrap()
+                .external_controller,
+            inactive.external_controller
+        );
+    }
+    #[test]
+    fn unix_override_survives_materialization_without_creating_a_network_listener() {
+        let mut config =
+            Config::parse_yaml(b"secret: yaml-token\nrules: ['MATCH,DIRECT']\n").unwrap();
+        ControllerOverrides::default()
+            .with_unix(text("local.sock"))
+            .unwrap()
+            .apply(&mut config);
+        let controller = config.external_controller.as_ref().unwrap();
+        assert_eq!(controller.unix_path.as_deref(), Some("local.sock"));
+        assert!(!controller.http_enabled);
+        assert!(controller.tls_listen.is_none());
+        let expected = controller.clone();
+        let fresh = config
+            .providers
+            .as_ref()
+            .unwrap()
+            .materialize(&Default::default())
+            .unwrap();
+        assert_eq!(fresh.external_controller, Some(expected));
+        ControllerOverrides::default()
+            .with_unix(text(""))
+            .unwrap()
+            .apply(&mut config);
+        assert_eq!(
+            config.external_controller.unwrap().unix_path.as_deref(),
+            Some("local.sock")
+        );
+        assert!(
+            ControllerOverrides::default()
+                .with_unix(text("bad\0path"))
+                .is_err()
+        );
+    }
+    #[test]
+    fn concrete_overrides_preserve_yaml_and_only_replace_nonempty_values() {
+        let mut config = Config::parse_yaml(b"external-controller: localhost:9000\nexternal-controller-tls: ':9443'\nsecret: yaml-token\n").unwrap();
+        ControllerOverrides::from_values(text(""), text(""), text(""))
+            .unwrap()
+            .apply(&mut config);
+        let controller = config.external_controller.as_ref().unwrap();
+        assert_eq!(controller.listen, "127.0.0.1:9000".parse().unwrap());
+        assert_eq!(controller.tls_listen, Some("[::]:9443".parse().unwrap()));
+        assert_eq!(controller.secret.as_deref(), Some("yaml-token"));
+        ControllerOverrides::from_values(text("[::1]:9100"), None, text("runtime-token"))
+            .unwrap()
+            .apply(&mut config);
+        let controller = config.external_controller.as_ref().unwrap();
+        assert_eq!(controller.listen, "[::1]:9100".parse().unwrap());
+        assert_eq!(controller.tls_listen, Some("[::]:9443".parse().unwrap()));
+        assert_eq!(controller.secret.as_deref(), Some("runtime-token"));
+        let mut absent = Config::parse_yaml(b"rules: ['MATCH,DIRECT']").unwrap();
+        ControllerOverrides::from_values(None, None, text("unused-token"))
+            .unwrap()
+            .apply(&mut absent);
+        assert!(absent.external_controller.is_none());
+        ControllerOverrides::from_values(None, text("localhost:9443"), text("tls-token"))
+            .unwrap()
+            .apply(&mut absent);
+        let controller = absent.external_controller.unwrap();
+        assert!(!controller.http_enabled);
+        assert_eq!(
+            controller.tls_listen,
+            Some("127.0.0.1:9443".parse().unwrap())
+        );
+        assert_eq!(controller.secret.as_deref(), Some("tls-token"));
+    }
+    #[test]
+    fn concrete_overrides_survive_provider_materialization_and_content_updates() {
+        use crate::config::providers::{ProviderContent, ProviderContents};
+        let mut config = Config::parse_yaml(b"proxy-providers: {nodes: {type: inline, payload: [{name: edge, type: direct}]}}\nproxy-groups: [{name: choice, type: select, use: [nodes]}]\nrules: ['MATCH,choice']\n").unwrap();
+        ControllerOverrides::from_values(
+            text("localhost:9000"),
+            text("[::1]:9443"),
+            text("private-token"),
+        )
+        .unwrap()
+        .apply(&mut config);
+        let expected = config.external_controller.clone();
+        let template = config.providers.unwrap();
+        let materialized = template.materialize(&ProviderContents::new()).unwrap();
+        assert_eq!(materialized.external_controller, expected);
+        let mut contents = ProviderContents::new();
+        contents.insert(
+            "proxies/nodes".into(),
+            ProviderContent::Proxies(vec![
+                serde_yaml_ng::from_str("{name: next, type: direct}").unwrap(),
+            ]),
+        );
+        let updated = template.materialize(&contents).unwrap();
+        assert_eq!(updated.external_controller, expected);
+        assert!(updated.proxies.iter().any(|node| node.tag == "next"));
+    }
+    #[test]
+    fn concrete_override_addresses_reuse_the_existing_controller_parser() {
+        assert!(
+            ControllerOverrides::from_values(text("private-fixture.invalid:80"), None, None)
+                .is_err()
+        );
+        assert!(ControllerOverrides::from_values(None, text("127.0.0.1:65536"), None).is_err());
+    }
+}
diff --git a/src/invoke/foreground/reload.rs b/src/invoke/foreground/reload.rs
new file mode 100644
index 0000000..c46e9e0
--- /dev/null
+++ b/src/invoke/foreground/reload.rs
@@ -0,0 +1,75 @@
+//! SIGHUP uses the existing bounded candidate worker and never reconnects a session.
+use super::{
+    ControllerOverrides, CoreController, InvokeFailure, failure, input::ReloadInput, lock,
+};
+use crate::{
+    config::providers::ProviderTemplate,
+    resource::config_apply::{ConfigApplyHandle, ConfigUpdate},
+};
+use std::{path::PathBuf, sync::Arc};
+use tokio_util::sync::CancellationToken;
+
+pub(super) struct ReloadContext {
+    pub(super) input: ReloadInput,
+    pub(super) directory: PathBuf,
+    pub(super) overrides: Arc<ControllerOverrides>,
+}
+impl ReloadContext {
+    fn handle(controller: &CoreController) -> Result<ConfigApplyHandle, InvokeFailure> {
+        let _command = controller.try_command()?;
+        let inner = lock(&controller.inner);
+        if controller
+            .tombstoned
+            .load(std::sync::atomic::Ordering::Acquire)
+            || inner.lifecycle.state() != crate::LifecycleState::Running
+        {
+            return Err(failure("foreground runtime is stopped"));
+        }
+        inner
+            .engine
+            .as_ref()
+            .and_then(|engine| engine.config_apply.clone())
+            .ok_or_else(|| failure("runtime does not support configuration application"))
+    }
+    pub(super) async fn apply(
+        &self,
+        controller: &CoreController,
+        cancellation: &CancellationToken,
+    ) -> Result<(), InvokeFailure> {
+        let handle = Self::handle(controller)?;
+        let admission = handle
+            .try_admit()
+            .map_err(|error| failure(error.message()))?;
+        let source = self.input.clone();
+        let directory = self.directory.clone();
+        let overrides = self.overrides.clone();
+        let preparation_cancel = cancellation.clone();
+        let template = tokio::task::spawn_blocking(move || {
+            let yaml = source.read(&preparation_cancel)?;
+            let mut template = ProviderTemplate::update_yaml(yaml.as_bytes(), &directory)
+                .map_err(|_| failure("invalid configuration candidate"))?;
+            if preparation_cancel.is_cancelled() {
+                return Err(failure("configuration reload cancelled"));
+            }
+            overrides.apply_template(Arc::make_mut(&mut template));
+            Ok(template)
+        })
+        .await
+        .map_err(|_| failure("configuration reload worker failed"))??;
+        if cancellation.is_cancelled() {
+            return Err(failure("configuration reload cancelled"));
+        }
+        let pending = admission
+            .submit(ConfigUpdate::ReplaceTemplate(template))
+            .map_err(|error| failure(error.message()))?;
+        let operation = pending.cancellation();
+        let waiting = pending.wait();
+        tokio::pin!(waiting);
+        let result = tokio::select! {
+            biased;
+            () = cancellation.cancelled() => { operation.cancel(); waiting.await },
+            result = &mut waiting => result,
+        };
+        result.map_err(|error| failure(error.message()))
+    }
+}
diff --git a/src/invoke/http.rs b/src/invoke/http.rs
new file mode 100644
index 0000000..3c4bec0
--- /dev/null
+++ b/src/invoke/http.rs
@@ -0,0 +1,703 @@
+//! HTTP resource ownership shared by foreground and native Invoke adapters.
+use super::{InvokeFailure, InvokePath, lock, registry};
+use crate::{
+    config::Config,
+    dialer::Dialer,
+    http_processing::{
+        Policy,
+        config::{Document, PolicyCandidate},
+        private_context::CaMaterial,
+        providers::{DownloadContext, SourceContext, Store},
+    },
+};
+use serde::Deserialize;
+use std::{io, path::PathBuf, sync::Arc};
+use tokio_util::sync::CancellationToken;
+#[path = "http_test.rs"]
+mod evaluation;
+pub(super) use evaluation::{TestPayload, evaluate};
+
+pub(super) fn check_envelope(input: &str) -> Result<(), InvokeFailure> {
+    use serde_json::value::RawValue;
+    #[derive(Deserialize)]
+    struct Envelope<'a> {
+        #[serde(borrow)]
+        method: &'a RawValue,
+        #[serde(borrow)]
+        payload: &'a RawValue,
+    }
+    #[derive(Deserialize)]
+    #[serde(rename_all = "camelCase")]
+    struct Input<'a> {
+        #[serde(borrow)]
+        config_yaml: Option<&'a RawValue>,
+        #[serde(borrow)]
+        http_config_yaml: Option<&'a RawValue>,
+        #[serde(borrow)]
+        http_context: Option<&'a RawValue>,
+        #[serde(borrow)]
+        request: Option<&'a RawValue>,
+        #[serde(borrow)]
+        response: Option<&'a RawValue>,
+        #[serde(borrow)]
+        url: Option<&'a RawValue>,
+    }
+    #[derive(Deserialize)]
+    struct Context<'a> {
+        #[serde(borrow)]
+        ca: Option<&'a RawValue>,
+    }
+    #[derive(Deserialize)]
+    #[serde(rename_all = "camelCase")]
+    struct Ca<'a> {
+        #[serde(borrow)]
+        certificate: &'a RawValue,
+        #[serde(borrow)]
+        private_key: &'a RawValue,
+    }
+    #[derive(Deserialize)]
+    #[serde(rename_all = "camelCase")]
+    struct Sample<'a> {
+        #[serde(borrow)]
+        body_base64: Option<&'a RawValue>,
+        #[serde(borrow)]
+        headers: Option<&'a RawValue>,
+        #[serde(borrow)]
+        method: Option<&'a RawValue>,
+        #[serde(borrow)]
+        status: Option<&'a RawValue>,
+    }
+    let invalid = |_| InvokeFailure::invalid_request("invalid HTTP input envelope");
+    let envelope: Envelope<'_> = serde_json::from_str(input).map_err(invalid)?;
+    if envelope.method.get().len() > 256 {
+        return Err(InvokeFailure::invalid_request("invalid method"));
+    }
+    let method: String = serde_json::from_str(envelope.method.get()).map_err(invalid)?;
+    if !matches!(
+        method.as_str(),
+        "start" | "reconnect" | "validateConfig" | "refreshHttpProviders" | "testHttp"
+    ) {
+        return Ok(());
+    }
+    if input.len().saturating_sub(envelope.payload.get().len()) > 64 * 1024 {
+        return Err(InvokeFailure::invalid_request(
+            "HTTP envelope overhead exceeds limit",
+        ));
+    }
+    let input: Input<'_> = serde_json::from_str(envelope.payload.get()).map_err(invalid)?;
+    let known: usize = [
+        input.config_yaml,
+        input.http_config_yaml,
+        input.http_context,
+        input.request,
+        input.response,
+        input.url,
+    ]
+    .into_iter()
+    .flatten()
+    .map(|raw| raw.get().len())
+    .sum();
+    if envelope.payload.get().len().saturating_sub(known) > 64 * 1024 {
+        return Err(InvokeFailure::invalid_request(
+            "HTTP payload overhead exceeds limit",
+        ));
+    }
+    if let Some(raw) = input.url {
+        super::check_json_string_limit(raw.get(), crate::http_processing::rules::MAX_URL)?;
+    }
+    if let Some(raw) = input.config_yaml {
+        super::check_json_string_limit(raw.get(), crate::config::MAX_CONFIG_BYTES)?;
+    }
+    if let Some(raw) = input.http_config_yaml {
+        super::check_json_string_limit(raw.get(), crate::http_processing::MAX_ADDENDUM)?;
+    }
+    if let Some(raw) = input.http_context {
+        if raw.get().len()
+            > super::MAX_ERROR_BYTES
+                + super::MAX_ERROR_BYTES
+                + crate::http_processing::private_context::MAX_CA_INPUT
+        {
+            return Err(InvokeFailure::invalid_request(
+                "HTTP context exceeds input limit",
+            ));
+        }
+        let context: Context<'_> = serde_json::from_str(raw.get()).map_err(invalid)?;
+        if let Some(raw) = context.ca {
+            if !matches!(method.as_str(), "start" | "reconnect") {
+                return Err(InvokeFailure::invalid_request(
+                    "this operation does not accept CA material",
+                ));
+            }
+            let ca: Ca<'_> = serde_json::from_str(raw.get()).map_err(invalid)?;
+            for raw in [ca.certificate, ca.private_key] {
+                super::check_json_string_limit(
+                    raw.get(),
+                    crate::http_processing::private_context::MAX_CA_PEM_BYTES,
+                )?;
+            }
+        }
+    }
+    for raw in [input.request, input.response].into_iter().flatten() {
+        let sample: Sample<'_> = serde_json::from_str(raw.get()).map_err(invalid)?;
+        let known: usize = [
+            sample.body_base64,
+            sample.headers,
+            sample.method,
+            sample.status,
+        ]
+        .into_iter()
+        .flatten()
+        .map(|raw| raw.get().len())
+        .sum();
+        if raw.get().len().saturating_sub(known) > 4096
+            || sample.status.is_some_and(|raw| raw.get().len() > 8)
+        {
+            return Err(InvokeFailure::invalid_request(
+                "HTTP sample overhead exceeds limit",
+            ));
+        }
+        if let Some(raw) = sample.method {
+            super::check_json_string_limit(raw.get(), 64)?;
+        }
+        if let Some(raw) = sample.body_base64 {
+            super::check_json_string_limit(
+                raw.get(),
+                crate::http_processing::body::MAX_BODY.div_ceil(3) * 4,
+            )?;
+        }
+        if sample.headers.is_some_and(|headers| {
+            headers.get().len() > 6 * crate::http_processing::headers::MAX_BYTES + 4096
+        }) {
+            return Err(InvokeFailure::invalid_request(
+                "HTTP sample headers exceed input limit",
+            ));
+        }
+    }
+    Ok(())
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+pub(crate) struct HttpContextInput {
+    pub(crate) base_dir: Option<InvokePath>,
+    pub(crate) ca: Option<CaMaterial>,
+}
+impl std::fmt::Debug for HttpContextInput {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("HttpContextInput").finish_non_exhaustive()
+    }
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+pub(super) struct StartPayload {
+    pub(super) config_yaml: String,
+    pub(super) http_config_yaml: Option<String>,
+    pub(super) http_context: Option<HttpContextInput>,
+    #[serde(skip)]
+    pub(super) source_file: Option<PathBuf>,
+    #[serde(skip)]
+    pub(super) cancellation: Option<CancellationToken>,
+    #[serde(skip)]
+    pub(super) foreground_overrides: super::foreground::ControllerOverrides,
+    #[serde(skip)]
+    pub(super) provider_paths: Option<Arc<crate::resource::paths::ProviderPaths>>,
+}
+
+pub(crate) fn source_context(
+    context: Option<HttpContextInput>,
+    data_dir: PathBuf,
+    config_path: Option<PathBuf>,
+) -> io::Result<(SourceContext, Option<CaMaterial>)> {
+    let (base_dir, ca) = context.map_or((None, None), |context| {
+        (context.base_dir.map(InvokePath::into_path), context.ca)
+    });
+    if base_dir.as_ref().is_some_and(|path| !path.is_absolute()) {
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidInput,
+            "HTTP baseDir must be absolute",
+        ));
+    }
+    Ok((
+        SourceContext {
+            base_dir,
+            data_dir: Some(data_dir),
+            config_path,
+            ..Default::default()
+        },
+        ca,
+    ))
+}
+
+pub(crate) fn download_context(config: &Config, dialer: Dialer) -> DownloadContext {
+    DownloadContext {
+        dispatcher: Arc::new(crate::outbound::ConnectorDispatcher::new(Arc::new(
+            crate::outbound::NamedDirectOutbound::new(dialer),
+        ))),
+        security: crate::security::SecurityContext::load(&config.tls),
+    }
+}
+
+pub(crate) async fn prepare_candidate(
+    input: &str,
+    context: SourceContext,
+    download: Option<&DownloadContext>,
+    store: &tokio::sync::Mutex<Store>,
+    force: bool,
+) -> io::Result<Arc<PolicyCandidate>> {
+    prepare_cancelled(
+        input,
+        context,
+        download,
+        store,
+        force,
+        &CancellationToken::new(),
+    )
+    .await
+}
+
+async fn prepare_cancelled(
+    input: &str,
+    context: SourceContext,
+    download: Option<&DownloadContext>,
+    store: &tokio::sync::Mutex<Store>,
+    force: bool,
+    cancellation: &CancellationToken,
+) -> io::Result<Arc<PolicyCandidate>> {
+    let document = Document::parse(input)?;
+    let mut store = store.try_lock().map_err(|_| {
+        io::Error::new(
+            io::ErrorKind::WouldBlock,
+            "HTTP resource preparation is busy",
+        )
+    })?;
+    let operation_cancel = cancellation.child_token();
+    let preparation = store.prepare(document, &context, download, &operation_cancel, force);
+    tokio::pin!(preparation);
+    tokio::select! { biased;
+        () = cancellation.cancelled() => {
+            operation_cancel.cancel(); let _ = preparation.await;
+            Err(io::ErrorKind::Interrupted.into())
+        },
+        () = tokio::time::sleep(std::time::Duration::from_secs(90)) => {
+            operation_cancel.cancel(); let _ = preparation.await;
+            Err(io::ErrorKind::TimedOut.into())
+        },
+        result = &mut preparation => result,
+    }
+}
+
+pub(super) fn runtime_store() -> Result<Arc<tokio::sync::Mutex<Store>>, InvokeFailure> {
+    lock(&registry().runtime_data)
+        .as_ref()
+        .map(|data| data.http.clone())
+        .ok_or_else(|| {
+            InvokeFailure::invalid_state("call initialize before preparing HTTP resources")
+        })
+}
+
+pub(super) async fn attach(
+    config: &mut Config,
+    input: Option<&str>,
+    context: Option<HttpContextInput>,
+    config_path: Option<PathBuf>,
+    resource_paths: Option<Arc<crate::resource::paths::ProviderPaths>>,
+    cancellation: Option<&CancellationToken>,
+) -> Result<(), InvokeFailure> {
+    let Some(input) = input else {
+        if context.is_some() {
+            return Err(InvokeFailure::invalid_request(
+                "httpContext requires httpConfigYaml",
+            ));
+        }
+        config.set_http_policy(None).map_err(InvokeFailure::from)?;
+        return Ok(());
+    };
+    if input.is_empty() {
+        config.set_http_policy(None).map_err(InvokeFailure::from)?;
+        return Ok(());
+    }
+    let directory = registry().data_directory()?;
+    let (mut source, ca) = source_context(context, directory.root().to_owned(), config_path)
+        .map_err(InvokeFailure::from)?;
+    source.resource_paths = resource_paths
+        .or_else(|| registry().provider_paths())
+        .unwrap_or_default();
+    let dialer = {
+        let platform = lock(&registry().platform);
+        #[cfg(target_os = "android")]
+        let dialer = platform
+            .android_protector
+            .clone()
+            .map_or_else(Dialer::default, |protector| {
+                Dialer::default().with_protector(protector)
+            });
+        #[cfg(not(target_os = "android"))]
+        let dialer = {
+            let _ = &platform;
+            Dialer::default()
+        };
+        dialer.with_dns_sources(registry().dns_sources()?)
+    };
+    let network = download_context(config, dialer);
+    let store = runtime_store()?;
+    let token = cancellation.cloned().unwrap_or_default();
+    let candidate = prepare_cancelled(input, source, Some(&network), store.as_ref(), false, &token)
+        .await
+        .map_err(|_| InvokeFailure::new("HTTP resource preparation failed"))?;
+    let policy = candidate
+        .bind_ca(ca.as_ref())
+        .map_err(|_| InvokeFailure::new("HTTP private context is invalid or missing"))?;
+    config
+        .set_http_policy(Some(policy))
+        .map_err(InvokeFailure::from)
+}
+
+pub(super) fn parse_reconnect(
+    payload: StartPayload,
+    apply: &crate::resource::config_apply::ConfigApplyHandle,
+) -> Result<Config, InvokeFailure> {
+    let mut config = super::parse_config_yaml(&payload.config_yaml)?;
+    if let (Some(template), Some(paths)) = (&mut config.providers, &payload.provider_paths) {
+        Arc::make_mut(template).resource_paths = paths.clone();
+    }
+    let Some(input) = payload.http_config_yaml.as_deref() else {
+        if payload.http_context.is_some() {
+            return Err(InvokeFailure::invalid_request(
+                "httpContext requires httpConfigYaml",
+            ));
+        }
+        return Ok(config);
+    };
+    let directory = registry().data_directory()?;
+    let (mut context, ca) = source_context(
+        payload.http_context,
+        directory.root().to_owned(),
+        payload.source_file,
+    )
+    .map_err(InvokeFailure::from)?;
+    context.resource_paths = registry().provider_paths().unwrap_or_default();
+    let store = runtime_store()?;
+    let context = reconnect_source_context(
+        context,
+        payload.provider_paths,
+        &*store
+            .try_lock()
+            .map_err(|_| InvokeFailure::new("HTTP resource preparation is busy"))?,
+    );
+    if let Some(template) = &mut config.providers {
+        Arc::make_mut(template).resource_paths = context.resource_paths.clone();
+    }
+    if input.is_empty() {
+        return Ok(config);
+    }
+    // The old engine still owns the physical-network protection and Stop
+    // barrier. Preparation must finish there before we stop that engine.
+    let admission = apply
+        .try_admit()
+        .map_err(|error| InvokeFailure::new(error.message()))?;
+    let document = Document::parse(input)
+        .map_err(|_| InvokeFailure::new("invalid HTTP processing configuration"))?;
+    let (send, receive) = std::sync::mpsc::sync_channel(1);
+    admission
+        .submit(crate::resource::config_apply::ConfigUpdate::RefreshHttp {
+            document,
+            context,
+            store: runtime_store()?,
+            force: false,
+            security: Some(crate::security::SecurityContext::load(&config.tls)),
+            reply: Some(send),
+        })
+        .map_err(|error| InvokeFailure::new(error.message()))?
+        .wait_blocking()
+        .map_err(|error| InvokeFailure::new(error.message()))?;
+    let candidate = receive
+        .try_recv()
+        .map_err(|_| InvokeFailure::new("HTTP resource preparation did not return a candidate"))?;
+    let policy = candidate
+        .bind_ca(ca.as_ref())
+        .map_err(|_| InvokeFailure::new("HTTP private context is invalid or missing"))?;
+    config
+        .set_http_policy(Some(policy))
+        .map_err(InvokeFailure::from)?;
+    Ok(config)
+}
+
+fn reconnect_source_context(
+    mut context: SourceContext,
+    resource_paths: Option<Arc<crate::resource::paths::ProviderPaths>>,
+    store: &Store,
+) -> SourceContext {
+    if let Some(paths) = resource_paths {
+        context.resource_paths = paths;
+    } else {
+        // Public reconnect requests have no foreground-only path metadata.
+        // They still belong to the existing session and its original inputs.
+        store.inherit_inputs(&mut context);
+    }
+    context
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+pub(super) struct ResourcePayload {
+    http_config_yaml: String,
+    http_context: Option<HttpContextInput>,
+}
+
+enum RefreshAdmission<'a> {
+    Instance(Arc<super::CoreController>),
+    Idle(IdleRefreshLease<'a>),
+}
+struct IdleRefreshLease<'a>(&'a super::RuntimeRegistry);
+impl Drop for IdleRefreshLease<'_> {
+    fn drop(&mut self) {
+        lock(&self.0.inner).idle_http_refresh = false;
+    }
+}
+fn admit_refresh(registry: &super::RuntimeRegistry) -> Result<RefreshAdmission<'_>, InvokeFailure> {
+    let mut inner = lock(&registry.inner);
+    if inner.idle_http_refresh {
+        return Err(InvokeFailure::invalid_state(
+            "HTTP resource preparation is busy",
+        ));
+    }
+    if let Some(controller) = &inner.instance {
+        return Ok(RefreshAdmission::Instance(controller.clone()));
+    }
+    // Creation and idle preparation share this registry admission. Do not
+    // hold the registry lock across filesystem or network work.
+    inner.idle_http_refresh = true;
+    Ok(RefreshAdmission::Idle(IdleRefreshLease(registry)))
+}
+
+pub(super) fn refresh(payload: ResourcePayload) -> Result<serde_json::Value, InvokeFailure> {
+    match admit_refresh(registry())? {
+        RefreshAdmission::Instance(controller) => {
+            super::invoke_instance_guarded(&controller, || {
+                let _command = controller.try_command()?;
+                refresh_owned(payload, Some(&controller))
+            })
+        }
+        RefreshAdmission::Idle(_lease) => refresh_owned(payload, None),
+    }
+}
+
+fn refresh_owned(
+    payload: ResourcePayload,
+    controller: Option<&super::CoreController>,
+) -> Result<serde_json::Value, InvokeFailure> {
+    let directory = registry().data_directory()?;
+    let (mut context, ca) = source_context(payload.http_context, directory.root().to_owned(), None)
+        .map_err(InvokeFailure::from)?;
+    if ca.is_some() {
+        return Err(InvokeFailure::invalid_request(
+            "this operation does not accept CA material",
+        ));
+    }
+    runtime_store()?
+        .try_lock()
+        .map_err(|_| InvokeFailure::new("HTTP resource preparation is busy"))?
+        .inherit_inputs(&mut context);
+    if let Some(controller) = controller {
+        let apply = {
+            let mut inner = lock(&controller.inner);
+            super::refresh_runtime_status(&mut inner);
+            if inner.lifecycle.state() == crate::LifecycleState::Running {
+                Some(
+                    inner
+                        .engine
+                        .as_ref()
+                        .and_then(|engine| engine.config_apply.clone())
+                        .ok_or_else(|| {
+                            InvokeFailure::invalid_state("runtime cannot refresh HTTP resources")
+                        })?,
+                )
+            } else if inner.lifecycle.state() == crate::LifecycleState::Stopped {
+                None
+            } else {
+                return Err(InvokeFailure::invalid_state(
+                    "HTTP resources cannot refresh during a lifecycle transition",
+                ));
+            }
+        };
+        if let Some(apply) = apply {
+            let admission = apply
+                .try_admit()
+                .map_err(|error| InvokeFailure::new(error.message()))?;
+            let document = Document::parse(&payload.http_config_yaml)
+                .map_err(|_| InvokeFailure::new("invalid HTTP processing configuration"))?;
+            admission
+                .submit(crate::resource::config_apply::ConfigUpdate::RefreshHttp {
+                    document,
+                    context,
+                    store: runtime_store()?,
+                    force: true,
+                    security: None,
+                    reply: None,
+                })
+                .map_err(|error| InvokeFailure::new(error.message()))?
+                .wait_blocking()
+                .map_err(|error| InvokeFailure::new(error.message()))?;
+            return Ok(serde_json::json!({"resourcesReady": true, "applied": false}));
+        }
+    }
+    #[cfg(all(windows, feature = "windows-uwp"))]
+    return Err(InvokeFailure::invalid_state(
+        "HTTP resource refresh requires a bound Session Host",
+    ));
+    #[cfg(not(all(windows, feature = "windows-uwp")))]
+    refresh_idle(payload.http_config_yaml, context)
+}
+
+#[cfg(not(all(windows, feature = "windows-uwp")))]
+fn refresh_idle(input: String, context: SourceContext) -> Result<serde_json::Value, InvokeFailure> {
+    let runtime = tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .map_err(InvokeFailure::from)?;
+    let config = super::parse_config_yaml("rules: ['MATCH,DIRECT']")?;
+    #[cfg(target_os = "android")]
+    let dialer = lock(&registry().platform)
+        .android_protector
+        .clone()
+        .map_or_else(Dialer::default, |protector| {
+            Dialer::default().with_protector(protector)
+        });
+    #[cfg(not(target_os = "android"))]
+    let dialer = Dialer::default();
+    let network = download_context(&config, dialer.with_dns_sources(registry().dns_sources()?));
+    let store = runtime_store()?;
+    let result = runtime.block_on(prepare_candidate(
+        &input,
+        context,
+        Some(&network),
+        store.as_ref(),
+        true,
+    ));
+    runtime.shutdown_timeout(std::time::Duration::from_millis(100));
+    let _candidate = result.map_err(|_| InvokeFailure::new("HTTP resource preparation failed"))?;
+    Ok(serde_json::json!({"resourcesReady": true, "applied": false}))
+}
+
+pub(crate) async fn maintenance(
+    store: Arc<tokio::sync::Mutex<Store>>,
+    download_context: impl Fn() -> DownloadContext,
+    cancellation: CancellationToken,
+) -> io::Result<()> {
+    loop {
+        let (due, notification) = match store.try_lock() {
+            Ok(store) => (store.next_due(), store.notification()),
+            Err(_) => {
+                tokio::select! { biased;
+                    () = cancellation.cancelled() => return Ok(()),
+                    () = tokio::time::sleep(std::time::Duration::from_secs(1)) => {}
+                }
+                continue;
+            }
+        };
+        // No polling timer when there is no scheduled HTTP source. A bounded
+        // notification also notices explicit preparation of a new document.
+        tokio::select! { biased;
+            () = cancellation.cancelled() => return Ok(()),
+            () = notification.notified() => continue,
+            () = async { match due { Some(delay) => tokio::time::sleep(delay).await, None => std::future::pending().await } } => {}
+        }
+        let Ok(mut store) = store.try_lock() else {
+            continue;
+        };
+        if store.next_due().is_some_and(|due| due.is_zero()) {
+            // Failed updates keep the last complete candidate; the store owns
+            // retry backoff. Awaiting this work preserves the Stop barrier.
+            let network = download_context();
+            let _ = store.refresh_due(&network, &cancellation).await;
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[tokio::test]
+    async fn public_reconnect_retains_foreground_inputs_without_changing_start_context() {
+        use crate::resource::paths::{Access, ProviderPaths};
+        let root = tempfile::tempdir().unwrap();
+        let main = root.path().join("config.yaml");
+        let ca = root.path().join("ca.json");
+        std::fs::write(&main, b"original config").unwrap();
+        std::fs::write(&ca, b"original CA").unwrap();
+        let mut paths = ProviderPaths::default();
+        paths.reserve_inputs([(main.clone(), false), (ca.clone(), true)]);
+        let context = SourceContext {
+            data_dir: Some(root.path().into()),
+            config_path: Some(root.path().join("http.yaml")),
+            resource_paths: Arc::new(paths),
+            ..Default::default()
+        };
+        let document = Document::parse("rewrite: {rules: []}").unwrap();
+        let mut store = Store::new();
+        store
+            .prepare(document, &context, None, &CancellationToken::new(), false)
+            .await
+            .unwrap();
+        let (fresh, _) = source_context(None, root.path().into(), None).unwrap();
+        assert!(
+            fresh
+                .resource_paths
+                .check_reserved(&main, Access::CacheWrite, true)
+                .is_ok()
+        );
+        let reconnect = reconnect_source_context(fresh.clone(), None, &store);
+        assert_eq!(reconnect.config_path, context.config_path);
+        for input in [&main, &ca] {
+            let path = serde_yaml_ng::to_string(&input.to_string_lossy().as_ref()).unwrap();
+            let document = Document::parse(&format!("rewrite-providers:\n  remote:\n    type: http\n    url: http://rules.example.test/rules.yaml\n    path: {}\nrewrite: {{enabled: true, rules: [{{rule-set: remote}}]}}\n", path.trim_end())).unwrap();
+            let error = store
+                .prepare(document, &reconnect, None, &CancellationToken::new(), false)
+                .await
+                .err()
+                .unwrap();
+            assert_eq!(error.kind(), io::ErrorKind::PermissionDenied);
+        }
+        assert_eq!(std::fs::read(&main).unwrap(), b"original config");
+        assert_eq!(std::fs::read(&ca).unwrap(), b"original CA");
+        // An explicitly supplied internal context starts a new input scope;
+        // public reconnect alone cannot discard the foreground reservations.
+        let explicit = reconnect_source_context(fresh, Some(Arc::default()), &store);
+        assert!(
+            explicit
+                .resource_paths
+                .check_reserved(&main, Access::CacheWrite, true)
+                .is_ok()
+        );
+    }
+
+    #[test]
+    fn idle_refresh_admission_blocks_instance_creation_until_release() {
+        let registry = super::super::RuntimeRegistry::default();
+        let admission = admit_refresh(&registry).unwrap();
+        assert!(matches!(&admission, RefreshAdmission::Idle(_)));
+        assert!(registry.create_instance().is_err());
+        assert!(admit_refresh(&registry).is_err());
+        drop(admission);
+        let controller = registry.create_instance().unwrap();
+        let RefreshAdmission::Instance(admitted) = admit_refresh(&registry).unwrap() else {
+            panic!("existing instance owns resource preparation");
+        };
+        assert!(Arc::ptr_eq(&controller, &admitted));
+    }
+
+    #[test]
+    fn private_material_is_bounded_before_value_deserialization() {
+        let oversized = serde_json::json!({
+            "method":"start", "instanceId":"1", "payload":{
+                "configYaml":"rules: ['MATCH,DIRECT']", "httpContext":{"ca":{
+                    "certificate":"public", "privateKey":"x".repeat(crate::http_processing::private_context::MAX_CA_PEM_BYTES + 1)
+                }}
+            }
+        }).to_string();
+        assert!(check_envelope(&oversized).is_err());
+        let validation = r#"{"method":"validateConfig","payload":{"configYaml":"","httpContext":{"ca":{"certificate":"public","privateKey":"secret"}}}}"#;
+        assert!(check_envelope(validation).is_err());
+    }
+}
diff --git a/src/invoke/http_test.rs b/src/invoke/http_test.rs
new file mode 100644
index 0000000..3ab98a2
--- /dev/null
+++ b/src/invoke/http_test.rs
@@ -0,0 +1,292 @@
+//! Offline execution uses only explicit samples and prepared immutable content.
+use super::*;
+use crate::http_processing::{
+    body::{self, OriginalRequestMeta, Transaction, WireBodyMeta},
+    headers::{self, Fields},
+    rules::{Phase, RuleAction, UrlAction},
+};
+use base64::{Engine as _, engine::general_purpose::STANDARD};
+use serde_json::{Value, json};
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+pub(crate) struct TestPayload {
+    http_config_yaml: String,
+    http_context: Option<HttpContextInput>,
+    url: String,
+    request: Option<RequestSample>,
+    response: Option<ResponseSample>,
+}
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+struct RequestSample {
+    #[serde(default = "get")]
+    method: String,
+    #[serde(default)]
+    headers: Vec<[String; 2]>,
+    body_base64: Option<String>,
+}
+fn get() -> String {
+    "GET".into()
+}
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+struct ResponseSample {
+    status: u16,
+    #[serde(default)]
+    headers: Vec<[String; 2]>,
+    body_base64: Option<String>,
+}
+
+pub(crate) fn evaluate(payload: TestPayload) -> Result<Value, InvokeFailure> {
+    let document = Document::parse(&payload.http_config_yaml)
+        .map_err(|_| InvokeFailure::new("invalid HTTP processing configuration"))?;
+    let (base, ca) = payload
+        .http_context
+        .map_or((None, None), |input| (input.base_dir, input.ca));
+    if ca.is_some() {
+        return Err(InvokeFailure::invalid_request(
+            "testHttp does not accept CA material",
+        ));
+    }
+    let base_dir = base.map(InvokePath::into_path);
+    if base_dir.as_ref().is_some_and(|path| !path.is_absolute()) {
+        return Err(InvokeFailure::invalid_request(
+            "HTTP baseDir must be absolute",
+        ));
+    }
+    let initialized = lock(&registry().runtime_data)
+        .as_ref()
+        .map(|data| (data.directory.root().to_owned(), data.http.clone()));
+    let mut context = SourceContext {
+        base_dir,
+        data_dir: initialized.as_ref().map(|(root, _)| root.clone()),
+        config_path: None,
+        ..Default::default()
+    };
+    let candidate = if document.unresolved_count() == 0 {
+        Some(
+            document
+                .compile(&std::collections::BTreeMap::new())
+                .map_err(InvokeFailure::from)?,
+        )
+    } else if let Some((_, store)) = initialized {
+        let store = store
+            .try_lock()
+            .map_err(|_| InvokeFailure::new("HTTP resource preparation is busy"))?;
+        store.inherit_inputs(&mut context);
+        store
+            .prepared(&document, &context)
+            .map_err(InvokeFailure::from)?
+    } else {
+        None
+    };
+    let original = crate::http_processing::rules::offline_url(&payload.url)
+        .map_err(|_| InvokeFailure::new("invalid HTTP test URL"))?;
+    let Some(candidate) = candidate else {
+        return Ok(
+            json!({"resourcesReady":false,"outcome":"unprepared","originalUrl":original.as_str(),"httpsReady":false}),
+        );
+    };
+    // Static binding intentionally omits CA: offline work never issues a leaf.
+    let policy = Policy::for_evaluation(candidate.clone());
+    let mut target = original.clone();
+    let mut local = false;
+    let mut url_stage = json!({"outcome":"unchanged"});
+    let rules = policy.all_rules();
+    for (index, rule) in rules.iter().enumerate() {
+        match rule.evaluate_url(&original) {
+            Ok(Some(action)) => {
+                url_stage = match action {
+                    UrlAction::Forward(url) => {
+                        target = url;
+                        json!({"outcome":"forward"})
+                    }
+                    UrlAction::Redirect { status, url } => {
+                        target = url;
+                        local = true;
+                        json!({"outcome":"redirect","status":status})
+                    }
+                    UrlAction::Reject => {
+                        local = true;
+                        json!({"outcome":"reject","status":403})
+                    }
+                };
+                url_stage["source"] = serde_json::to_value(candidate.origin(index))
+                    .map_err(|_| InvokeFailure::new("HTTP result encoding failed"))?;
+                break;
+            }
+            Err(_) => {
+                local = true;
+                url_stage = json!({"outcome":"failed","status":502});
+                break;
+            }
+            Ok(None) => {}
+        }
+    }
+    let request_headers = payload
+        .request
+        .as_ref()
+        .map(|sample| fields(&sample.headers))
+        .unwrap_or_default();
+    headers::check(&request_headers)
+        .map_err(|_| InvokeFailure::new("invalid HTTP request sample headers"))?;
+    let method = payload
+        .request
+        .as_ref()
+        .map_or("GET", |sample| sample.method.as_str());
+    http::Method::from_bytes(method.as_bytes())
+        .map_err(|_| InvokeFailure::new("invalid HTTP sample method"))?;
+    let request_meta = OriginalRequestMeta::new(method, &request_headers);
+    let mut stages = Vec::new();
+    if !local {
+        if let Some(sample) = payload.request {
+            let cross_origin = original.origin() != target.origin();
+            stages.push(sample_stage(
+                &policy,
+                &original,
+                Phase::Request,
+                fields(&sample.headers),
+                sample.body_base64,
+                &request_meta,
+                None,
+                cross_origin,
+            )?);
+        } else {
+            stages.push(selected(&policy, &original, Phase::Request));
+        }
+        if let Some(sample) = payload.response {
+            if !(100..600).contains(&sample.status) {
+                return Err(InvokeFailure::new("invalid HTTP sample status"));
+            }
+            stages.push(sample_stage(
+                &policy,
+                &original,
+                Phase::Response,
+                fields(&sample.headers),
+                sample.body_base64,
+                &request_meta,
+                Some(sample.status),
+                false,
+            )?);
+        } else {
+            stages.push(selected(&policy, &original, Phase::Response));
+        }
+    }
+    Ok(
+        json!({"resourcesReady":true,"httpsReady":false,"rewriteEnabled":document.rewrite.enabled,"mitmEnabled":document.mitm.enabled,"originalUrl":original.as_str(),"targetUrl":target.as_str(),"url":url_stage,"stages":stages}),
+    )
+}
+
+fn fields(input: &[[String; 2]]) -> Fields {
+    input
+        .iter()
+        .map(|pair| (pair[0].clone(), pair[1].clone()))
+        .collect()
+}
+fn selected(policy: &Policy, original: &url::Url, phase: Phase) -> Value {
+    let selected: Vec<_> = policy.all_rules().iter().enumerate().filter_map(|(index, rule)| {
+        let matches_phase = matches!(&rule.action, RuleAction::Header{phase:p,..}|RuleAction::Body{phase:p,..} if *p==phase);
+        (matches_phase && rule.matches(original)).then(|| json!({"source":policy.candidate().and_then(|candidate| candidate.origin(index)),"name":rule.name,"outcome":"selected"}))
+    }).collect();
+    json!({"phase":if phase==Phase::Request {"request"} else {"response"},"rules":selected})
+}
+#[allow(clippy::too_many_arguments)]
+fn sample_stage(
+    policy: &Policy,
+    original: &url::Url,
+    phase: Phase,
+    mut output: Fields,
+    body: Option<String>,
+    request: &OriginalRequestMeta,
+    status: Option<u16>,
+    cross_origin: bool,
+) -> Result<Value, InvokeFailure> {
+    headers::check(&output).map_err(|_| InvokeFailure::new("invalid HTTP sample headers"))?;
+    let wire_fields = output.clone();
+    if cross_origin {
+        headers::strip_origin_credentials(&mut output);
+    }
+    let header_outcome = headers::apply(policy.all_rules(), original, phase, &mut output);
+    let mut result = selected(policy, original, phase);
+    result["headersOutcome"] = json!(format!("{header_outcome:?}"));
+    if let Some(encoded) = body {
+        if encoded.len() > body::MAX_BODY.div_ceil(3) * 4 {
+            return Err(InvokeFailure::new("HTTP sample body exceeds limit"));
+        }
+        let bytes = STANDARD
+            .decode(encoded)
+            .map_err(|_| InvokeFailure::new("invalid HTTP bodyBase64"))?;
+        let wire = WireBodyMeta::new(
+            &wire_fields,
+            request,
+            phase,
+            status,
+            Some(bytes.len() as u64),
+            status == Some(101),
+        );
+        match Transaction::begin(
+            policy.body_budget(),
+            policy.all_rules(),
+            original,
+            phase,
+            &wire,
+        ) {
+            Ok(mut transaction) => {
+                transaction
+                    .push(&bytes)
+                    .map_err(|_| InvokeFailure::new("HTTP sample body exceeds limit"))?;
+                let mut body = transaction.finish(false);
+                body.finalize_headers(&mut output);
+                result["bodyOutcome"] = json!(if body.changed {
+                    "changed"
+                } else if body.bypass.is_some() {
+                    "bypassed"
+                } else {
+                    "unchanged"
+                });
+                result["bodyBase64"] = json!(STANDARD.encode(body.body.as_ref()));
+                if let Some(reason) = body.bypass {
+                    result["bypassReason"] = json!(format!("{reason:?}"));
+                }
+            }
+            Err(reason) => {
+                result["bodyOutcome"] = json!("bypassed");
+                result["bypassReason"] = json!(format!("{reason:?}"));
+                result["bodyBase64"] = json!(STANDARD.encode(bytes));
+            }
+        }
+    } else {
+        result["bodyOutcome"] = json!("not-provided");
+    }
+    result["headers"] = json!(output);
+    Ok(result)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn run(input: Value) -> Value {
+        evaluate(serde_json::from_value(input).unwrap()).unwrap()
+    }
+    #[test]
+    fn offline_pipeline_uses_original_url_and_preserves_header_values() {
+        let input = json!({"httpConfigYaml": "rewrite: {enabled: false, rules: [{url: 'http://old.example/a', match: exact, action: replace, replacement: 'http://new.example/b'}, {url: 'http://old.example/a', match: exact, action: request-header-set, header: X-Test, value: selected}]}","url":" http://old.example/a#fragment ","request":{"headers":[["Authorization","old-secret"],["Cookie","old-cookie"]]}});
+        let result = run(input);
+        assert_eq!(result["targetUrl"], "http://new.example/b");
+        assert_eq!(result["rewriteEnabled"], false);
+        assert_eq!(
+            result["stages"][0]["headers"],
+            json!([["x-test", "selected"]])
+        );
+        assert_eq!(result["httpsReady"], false);
+    }
+    #[test]
+    fn unprepared_external_rules_are_distinct_from_no_match() {
+        let result = run(
+            json!({"httpConfigYaml":"rewrite-providers: {missing: {type: file, path: no-io.yaml}}\nrewrite: {rules: [{rule-set: missing}]}","url":"https://example.com/"}),
+        );
+        assert_eq!(result["resourcesReady"], false);
+        assert_eq!(result["outcome"], "unprepared");
+    }
+}
diff --git a/src/invoke/measure_delay.rs b/src/invoke/measure_delay.rs
index f8db44f..7675323 100644
--- a/src/invoke/measure_delay.rs
+++ b/src/invoke/measure_delay.rs
@@ -2,35 +2,38 @@
 
 use std::{
     future::Future,
-    io,
-    net::{IpAddr, Ipv4Addr, SocketAddr},
     panic::AssertUnwindSafe,
     sync::{
         Arc,
         atomic::{AtomicBool, Ordering},
     },
-    time::{Duration, Instant},
+    time::Duration,
 };
 
 use futures_util::{FutureExt, StreamExt, stream};
-use rustls::{ClientConfig, RootCertStore, client::Resumption, pki_types::ServerName};
 use serde::{Deserialize, Serialize};
-use tokio::io::{AsyncReadExt, AsyncWriteExt};
-use tokio_rustls::TlsConnector;
-use url::{Host, Url};
 
 use crate::{
     ResourceLimits,
     config::MeasureConfig,
     dialer::{Dialer, SystemResolver},
-    dispatch::{BoxStream, DispatchError, Dispatcher},
-    inbound::DEFAULT_HEADER_LIMIT,
-    outbound::{OutboundDiagnostic, capture_outbound_diagnostic},
+    dispatch::Dispatcher,
     runtime::PreparedMeasurement,
-    session::{Destination, InboundKind, StreamSession},
 };
 
 use super::{InvokeFailure, registry};
+use crate::resource::probe::Target;
+#[cfg(test)]
+use crate::resource::probe::{parse_status, probe_once, read_response_status};
+#[cfg(test)]
+use crate::{
+    dispatch::BoxStream,
+    session::{Destination, InboundKind},
+};
+#[cfg(test)]
+use std::io;
+#[cfg(test)]
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
 
 const MIN_TIMEOUT_SECONDS: u32 = 1;
 const MAX_TIMEOUT_SECONDS: u32 = 30;
@@ -57,27 +60,6 @@ pub(super) struct MeasureDelayResult {
     error: String,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum TargetScheme {
-    Http,
-    Https,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-enum TargetHost {
-    Domain(String),
-    Ip(IpAddr),
-}
-
-#[derive(Debug, Clone)]
-struct Target {
-    scheme: TargetScheme,
-    destination: Destination,
-    authority: String,
-    origin_form: String,
-    tls_server_name: String,
-}
-
 struct MeasureRequest {
     config_yamls: Vec<String>,
     timeout: Duration,
@@ -141,7 +123,7 @@ impl MeasureRequest {
         Ok(Self {
             config_yamls: payload.config_yamls,
             timeout: Duration::from_secs(u64::from(payload.timeout)),
-            target: Target::parse(&payload.url)?,
+            target: Target::parse(&payload.url).map_err(InvokeFailure::from)?,
         })
     }
 }
@@ -168,75 +150,6 @@ impl MeasureDelayResult {
     }
 }
 
-impl Target {
-    fn parse(raw: &str) -> Result<Self, InvokeFailure> {
-        let url = Url::parse(raw)
-            .map_err(|_| InvokeFailure::invalid_request("url is not a valid absolute URL"))?;
-        let scheme = match url.scheme() {
-            "http" => TargetScheme::Http,
-            "https" => TargetScheme::Https,
-            _ => {
-                return Err(InvokeFailure::invalid_request(
-                    "url scheme must be http or https",
-                ));
-            }
-        };
-        if !url.username().is_empty() || url.password().is_some() || url.fragment().is_some() {
-            return Err(InvokeFailure::invalid_request(
-                "url must not contain authentication or a fragment",
-            ));
-        }
-        let host = match url.host() {
-            Some(Host::Domain(domain)) => {
-                if domain.len() > u8::MAX as usize {
-                    return Err(InvokeFailure::invalid_request("url host is too long"));
-                }
-                TargetHost::Domain(domain.to_owned())
-            }
-            Some(Host::Ipv4(address)) => TargetHost::Ip(IpAddr::V4(address)),
-            Some(Host::Ipv6(address)) => TargetHost::Ip(IpAddr::V6(address)),
-            None => return Err(InvokeFailure::invalid_request("url must contain a host")),
-        };
-        let port = url
-            .port_or_known_default()
-            .ok_or_else(|| InvokeFailure::invalid_request("url must contain a port"))?;
-        let destination = match &host {
-            TargetHost::Domain(domain) => {
-                Destination::domain(domain.clone(), port).map_err(InvokeFailure::invalid_request)?
-            }
-            TargetHost::Ip(address) => Destination::Ip(SocketAddr::new(*address, port)),
-        };
-        let authority = authority(&host, port);
-        let mut origin_form = url.path().to_owned();
-        if origin_form.is_empty() {
-            origin_form.push('/');
-        }
-        if let Some(query) = url.query() {
-            origin_form.push('?');
-            origin_form.push_str(query);
-        }
-        let tls_server_name = match &host {
-            TargetHost::Domain(domain) => domain.clone(),
-            TargetHost::Ip(address) => address.to_string(),
-        };
-        Ok(Self {
-            scheme,
-            destination,
-            authority,
-            origin_form,
-            tls_server_name,
-        })
-    }
-}
-
-fn authority(host: &TargetHost, port: u16) -> String {
-    match host {
-        TargetHost::Domain(domain) => format!("{domain}:{port}"),
-        TargetHost::Ip(IpAddr::V4(address)) => format!("{address}:{port}"),
-        TargetHost::Ip(IpAddr::V6(address)) => format!("[{address}]:{port}"),
-    }
-}
-
 async fn run_batch(request: MeasureRequest) -> Vec<MeasureDelayResult> {
     let MeasureRequest {
         config_yamls,
@@ -275,7 +188,14 @@ async fn measure_one(
     target: &Target,
     timeout: Duration,
 ) -> Result<u64, InvokeFailure> {
-    let config = MeasureConfig::parse_yaml(config_yaml.as_bytes()).map_err(InvokeFailure::from)?;
+    let directory = super::registry().data_directory().ok();
+    let config = match directory {
+        Some(directory) => {
+            MeasureConfig::parse_yaml_with_directory(config_yaml.as_bytes(), Some(directory.root()))
+        }
+        None => MeasureConfig::parse_yaml(config_yaml.as_bytes()),
+    }
+    .map_err(InvokeFailure::from)?;
     drop(config_yaml);
     let prepared =
         PreparedMeasurement::prepare_config(config, &SystemResolver, ResourceLimits::default())
@@ -284,7 +204,7 @@ async fn measure_one(
     let runtime = prepared
         .into_runtime(Dialer::default())
         .map_err(InvokeFailure::from)?;
-    let result = run_probe(target, runtime.dispatcher(), timeout).await;
+    let result = run_probe(target, runtime.dispatcher(), timeout, runtime.security()).await;
     runtime.shutdown().await;
     result
 }
@@ -293,170 +213,19 @@ async fn run_probe(
     target: &Target,
     dispatcher: Arc<dyn Dispatcher>,
     timeout: Duration,
+    security: &crate::security::SecurityContext,
 ) -> Result<u64, InvokeFailure> {
-    let connector = (target.scheme == TargetScheme::Https)
-        .then(build_tls_connector)
-        .transpose()
-        .map_err(InvokeFailure::from)?;
-    let started = Instant::now();
-    match tokio::time::timeout(timeout, probe_once(target, dispatcher, connector.as_ref())).await {
-        Ok(Ok(())) => u64::try_from(started.elapsed().as_millis())
-            .map_err(|_| InvokeFailure::internal("measureDelay duration overflow")),
-        Ok(Err(error)) => Err(InvokeFailure::new(format!(
-            "measureDelay probe failed: {error}"
-        ))),
-        Err(_) => Err(InvokeFailure::new(format!(
-            "measureDelay timed out after {} seconds",
-            timeout.as_secs()
-        ))),
-    }
-}
-
-fn build_tls_connector() -> io::Result<TlsConnector> {
-    let provider = Arc::new(rustls::crypto::ring::default_provider());
-    let roots: RootCertStore = webpki_roots::TLS_SERVER_ROOTS.iter().cloned().collect();
-    let mut config = ClientConfig::builder_with_provider(provider)
-        .with_safe_default_protocol_versions()
-        .map_err(io::Error::other)?
-        .with_root_certificates(Arc::new(roots))
-        .with_no_client_auth();
-    config.alpn_protocols = vec![b"http/1.1".to_vec()];
-    config.resumption = Resumption::disabled();
-    Ok(TlsConnector::from(Arc::new(config)))
-}
-
-async fn probe_once(
-    target: &Target,
-    dispatcher: Arc<dyn Dispatcher>,
-    tls_connector: Option<&TlsConnector>,
-) -> io::Result<()> {
-    let session = StreamSession {
-        inbound: InboundKind::InternalMeasure,
-        source: SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 0),
-        destination: target.destination.clone(),
-        sniffed_domain: None,
-    };
-    let (stream, diagnostic) = capture_outbound_diagnostic(dispatcher.connect_tcp(session)).await;
-    let stream = stream.map_err(|error| outbound_connect_error(error, diagnostic.as_ref()))?;
-    let stream = if target.scheme == TargetScheme::Https {
-        let connector = tls_connector
-            .ok_or_else(|| io::Error::other("HTTPS probe is missing its TLS connector"))?;
-        connect_target_tls(connector, stream, &target.tls_server_name).await?
-    } else {
-        stream
-    };
-    send_head_and_read_response(stream, &target.origin_form, &target.authority).await
-}
-
-fn outbound_connect_error(
-    error: DispatchError,
-    diagnostic: Option<&OutboundDiagnostic>,
-) -> io::Error {
-    let diagnostic = diagnostic.map_or_else(String::new, |diagnostic| {
-        format!(
-            " (Vole outbound stage={} kind={} error={:?})",
-            diagnostic.stage(),
-            diagnostic.kind(),
-            diagnostic.message()
-        )
-    });
-    io::Error::other(format!("outbound connect failed: {error}{diagnostic}"))
-}
-
-async fn connect_target_tls(
-    connector: &TlsConnector,
-    stream: BoxStream,
-    server_name: &str,
-) -> io::Result<BoxStream> {
-    let server_name = ServerName::try_from(server_name.to_owned())
-        .map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error))?;
-    connector
-        .connect(server_name, stream)
-        .await
-        .map(|stream| Box::new(stream) as BoxStream)
-        .map_err(io::Error::other)
-}
-
-async fn send_head_and_read_response(
-    mut stream: BoxStream,
-    request_target: &str,
-    authority: &str,
-) -> io::Result<()> {
-    stream
-        .write_all(
-            format!(
-                "HEAD {request_target} HTTP/1.1\r\nHost: {authority}\r\nAccept: */*\r\nUser-Agent: Vole/{}\r\nConnection: close\r\n\r\n",
-                env!("CARGO_PKG_VERSION")
-            )
-            .as_bytes(),
-        )
-        .await?;
-    stream.flush().await?;
-    read_response_status(&mut stream).await.map(drop)
-}
-
-async fn read_response_status<R>(reader: &mut R) -> io::Result<u16>
-where
-    R: tokio::io::AsyncRead + Unpin + ?Sized,
-{
-    let mut input = Vec::with_capacity(1024);
-    let mut total_read = 0_usize;
-    loop {
-        if let Some(end) = input.windows(4).position(|window| window == b"\r\n\r\n") {
-            let status = parse_status(&input[..end])?;
-            if (100..200).contains(&status) && status != 101 {
-                input.drain(..end + 4);
-                continue;
-            }
-            return Ok(status);
-        }
-        if total_read >= DEFAULT_HEADER_LIMIT {
-            return Err(io::Error::new(
-                io::ErrorKind::FileTooLarge,
-                "HTTP response heads exceed their aggregate limit",
-            ));
-        }
-        let mut chunk = [0_u8; 1024];
-        let remaining = DEFAULT_HEADER_LIMIT - total_read;
-        let max_read = remaining.min(chunk.len());
-        let length = reader.read(&mut chunk[..max_read]).await?;
-        if length == 0 {
-            return Err(io::Error::new(
-                io::ErrorKind::UnexpectedEof,
-                "HTTP connection closed before the response head",
-            ));
-        }
-        total_read += length;
-        input.extend_from_slice(&chunk[..length]);
-    }
-}
-
-fn parse_status(head: &[u8]) -> io::Result<u16> {
-    let line_end = head
-        .windows(2)
-        .position(|window| window == b"\r\n")
-        .unwrap_or(head.len());
-    let line = &head[..line_end];
-    let mut fields = line.splitn(3, |byte| *byte == b' ');
-    let version = fields.next().unwrap_or_default();
-    let status = fields.next().unwrap_or_default();
-    if (version != b"HTTP/1.0" && version != b"HTTP/1.1")
-        || status.len() != 3
-        || !status.iter().all(u8::is_ascii_digit)
-    {
-        return Err(invalid_data("invalid HTTP response status line"));
-    }
-    let status = u16::from(status[0] - b'0') * 100
-        + u16::from(status[1] - b'0') * 10
-        + u16::from(status[2] - b'0');
-    if !(100..=599).contains(&status) {
-        return Err(invalid_data("HTTP response status is out of range"));
-    }
-    Ok(status)
-}
-
-fn invalid_data(message: &'static str) -> io::Error {
-    io::Error::new(io::ErrorKind::InvalidData, message)
+    crate::resource::probe::probe(
+        target,
+        dispatcher,
+        timeout,
+        false,
+        &[],
+        &tokio_util::sync::CancellationToken::new(),
+        security,
+    )
+    .await
+    .map_err(InvokeFailure::from)
 }
 
 fn truncate_utf8(value: &str, maximum: usize) -> String {
@@ -672,7 +441,7 @@ mod tests {
         probe_once(
             &Target::parse("http://example.test/path?q=1").unwrap(),
             dispatcher.clone(),
-            None,
+            &crate::security::SecurityContext::new(),
         )
         .await
         .unwrap();
diff --git a/src/invoke/mod.rs b/src/invoke/mod.rs
index 4b4a7d3..8f5514f 100644
--- a/src/invoke/mod.rs
+++ b/src/invoke/mod.rs
@@ -28,6 +28,7 @@ use crate::{
     data_dir::DataDirectory,
     dialer::{Dialer, SocketProtector, SystemResolver},
     geodata::{GeoDataManager, GeoDataStatus, GeoResourceState},
+    resource::config_apply::{ConfigApplyHandle, ConfigUpdate},
     runtime::PreparedCore,
 };
 
@@ -61,13 +62,12 @@ type InvokeTun = (TunFd, TunFraming, u16);
 type InvokeTun = ();
 
 mod foreground;
+pub(crate) mod http;
 mod measure_delay;
 pub use foreground::InvokePath;
 
-// A measureDelay request may inline five independently valid 256 KiB YAML
-// documents. JSON escaping can double common YAML bytes such as backslashes,
-// quotes, and newlines, so the wire envelope needs a larger aggregate bound.
-pub(crate) const MAX_INVOKE_BYTES: usize = 3 * 1024 * 1024;
+// Five YAML documents, worst-case JSON escaping, and a bounded envelope.
+pub(crate) const MAX_INVOKE_BYTES: usize = 30 * crate::config::MAX_CONFIG_BYTES + 64 * 1024;
 const MAX_ERROR_BYTES: usize = 4096;
 static REGISTRY: OnceLock<RuntimeRegistry> = OnceLock::new();
 
@@ -78,6 +78,7 @@ thread_local! {
 #[derive(Default)]
 struct RegistryInner {
     instance: Option<Arc<CoreController>>,
+    idle_http_refresh: bool,
 }
 
 #[derive(Default)]
@@ -97,6 +98,9 @@ struct RuntimeRegistry {
 struct RuntimeData {
     directory: Arc<DataDirectory>,
     geodata: Arc<GeoDataManager>,
+    dns_sources: Arc<crate::dns::source::NetworkSources>,
+    http: Arc<tokio::sync::Mutex<crate::http_processing::providers::Store>>,
+    provider_paths: Arc<crate::resource::paths::ProviderPaths>,
 }
 
 impl Default for RuntimeRegistry {
@@ -130,6 +134,13 @@ impl CoreController {
     }
 }
 
+enum StartupConfig {
+    #[cfg(test)]
+    Yaml(String),
+    Input(Box<http::StartPayload>),
+    Resolved(Box<crate::runtime::RecoverySnapshot>),
+}
+
 #[derive(Default)]
 struct CoreInner {
     lifecycle: Lifecycle,
@@ -137,7 +148,7 @@ struct CoreInner {
     engine: Option<Engine>,
     last_error: String,
     tun_lease: Option<TunLease>,
-    apple_tun_allocator_relief: Option<AppleTunAllocatorRelief>,
+    tun_allocator_relief: Option<TunAllocatorRelief>,
 }
 
 struct PreparedState {
@@ -149,6 +160,7 @@ struct Engine {
     stop: Option<oneshot::Sender<()>>,
     thread: Option<thread::JoinHandle<io::Result<()>>>,
     completion: tokio::sync::watch::Receiver<bool>,
+    config_apply: Option<ConfigApplyHandle>,
 }
 
 struct EngineCompletion(tokio::sync::watch::Sender<bool>);
@@ -174,43 +186,46 @@ impl Drop for TunLease {
 }
 
 #[derive(Clone)]
-struct AppleTunAllocatorRelief {
-    state: Arc<AppleTunAllocatorReliefState>,
+struct TunAllocatorRelief {
+    state: Arc<TunAllocatorReliefState>,
 }
 
-struct AppleTunAllocatorReliefState {
+struct TunAllocatorReliefState {
     relieved: AtomicBool,
 }
 
-impl AppleTunAllocatorRelief {
+impl TunAllocatorRelief {
     fn new(has_tun: bool) -> Option<Self> {
-        #[cfg(any(target_os = "ios", target_os = "tvos"))]
         if has_tun {
-            return Some(Self {
-                state: Arc::new(AppleTunAllocatorReliefState {
+            Some(Self {
+                state: Arc::new(TunAllocatorReliefState {
                     relieved: AtomicBool::new(false),
                 }),
-            });
+            })
+        } else {
+            None
         }
-        let _ = has_tun;
-        None
     }
 
     fn relieve(&self) {
-        if !self.state.relieved.swap(true, Ordering::AcqRel) {
-            relieve_apple_tun_allocator();
-        }
+        self.state.relieve_with(relieve_tun_allocator);
     }
 }
 
-impl Drop for AppleTunAllocatorReliefState {
-    fn drop(&mut self) {
+impl TunAllocatorReliefState {
+    fn relieve_with(&self, relief: impl FnOnce()) {
         if !self.relieved.swap(true, Ordering::AcqRel) {
-            relieve_apple_tun_allocator();
+            relief();
         }
     }
 }
 
+impl Drop for TunAllocatorReliefState {
+    fn drop(&mut self) {
+        self.relieve_with(relieve_tun_allocator);
+    }
+}
+
 /// Makes an admitted destroy request a terminal registry barrier even when
 /// synchronous stop reports an error or unwinds. Per-instance busy rejection
 /// happens before this guard is created and therefore keeps the instance live.
@@ -347,7 +362,7 @@ impl From<io::Error> for InvokeFailure {
     }
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Deserialize)]
 #[serde(deny_unknown_fields)]
 struct RequestEnvelope {
     method: String,
@@ -369,10 +384,25 @@ where
     String::deserialize(deserializer).map(Some)
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Deserialize)]
 #[serde(deny_unknown_fields, rename_all = "camelCase")]
 struct ConfigYamlPayload {
     config_yaml: String,
+    #[serde(default)]
+    http_config_yaml: Option<String>,
+    #[serde(default)]
+    http_context: Option<http::HttpContextInput>,
+}
+impl std::fmt::Debug for ConfigYamlPayload {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ConfigYamlPayload")
+            .field("config_bytes", &self.config_yaml.len())
+            .field(
+                "http_config_bytes",
+                &self.http_config_yaml.as_ref().map(String::len),
+            )
+            .finish_non_exhaustive()
+    }
 }
 
 #[derive(Debug, Deserialize)]
@@ -426,6 +456,13 @@ impl RuntimeRegistry {
     }
 
     fn initialize_path(&self, path: &Path) -> Result<Arc<DataDirectory>, InvokeFailure> {
+        self.initialize_path_with_provider_paths(path, None)
+    }
+    fn initialize_path_with_provider_paths(
+        &self,
+        path: &Path,
+        provider_paths: Option<Arc<crate::resource::paths::ProviderPaths>>,
+    ) -> Result<Arc<DataDirectory>, InvokeFailure> {
         let initialized = Arc::new(DataDirectory::initialize(path).map_err(|error| {
             InvokeFailure::new(format!("failed to initialize dataDir: {error}"))
         })?);
@@ -437,6 +474,14 @@ impl RuntimeRegistry {
         let mut current = lock(&self.runtime_data);
         if let Some(current) = current.as_ref() {
             if current.directory.root() == initialized.root() {
+                if provider_paths
+                    .as_ref()
+                    .is_some_and(|next| next.as_ref() != current.provider_paths.as_ref())
+                {
+                    return Err(InvokeFailure::invalid_state(
+                        "provider path authorization is already initialized differently",
+                    ));
+                }
                 return Ok(current.directory.clone());
             }
             return Err(InvokeFailure::invalid_state(
@@ -445,11 +490,21 @@ impl RuntimeRegistry {
         }
         *current = Some(RuntimeData {
             directory: initialized.clone(),
+            provider_paths: provider_paths.unwrap_or_default(),
             geodata,
+            dns_sources: Arc::new(crate::dns::source::NetworkSources::default()),
+            http: Arc::new(tokio::sync::Mutex::new(
+                crate::http_processing::providers::Store::new(),
+            )),
         });
         Ok(initialized)
     }
 
+    fn provider_paths(&self) -> Option<Arc<crate::resource::paths::ProviderPaths>> {
+        lock(&self.runtime_data)
+            .as_ref()
+            .map(|data| data.provider_paths.clone())
+    }
     fn data_directory(&self) -> Result<Arc<DataDirectory>, InvokeFailure> {
         lock(&self.runtime_data)
             .as_ref()
@@ -472,8 +527,19 @@ impl RuntimeRegistry {
             })
     }
 
+    fn dns_sources(&self) -> Result<Arc<crate::dns::source::NetworkSources>, InvokeFailure> {
+        lock(&self.runtime_data)
+            .as_ref()
+            .map(|data| data.dns_sources.clone())
+            .ok_or_else(|| InvokeFailure::invalid_state("Vole dataDir is not initialized"))
+    }
     fn create_instance(&self) -> Result<Arc<CoreController>, InvokeFailure> {
         let mut inner = lock(&self.inner);
+        if inner.idle_http_refresh {
+            return Err(InvokeFailure::invalid_state(
+                "HTTP resource preparation is busy",
+            ));
+        }
         if inner.instance.is_some() {
             return Err(InvokeFailure::invalid_state(
                 "a public lifecycle instance already exists; destroy it before creating another",
@@ -606,6 +672,23 @@ pub fn invoke_bytes(request: &[u8]) -> Vec<u8> {
     invoke_bytes_admitted(request)
 }
 
+/// Executes an owned JSON request through the same dispatcher. The CLI uses
+/// this to clear and release serialized configuration/key text before a long
+/// foreground session; borrowed FFI callers retain ownership of their input.
+pub fn invoke_owned_bytes(request: Vec<u8>) -> Vec<u8> {
+    let request = zeroize::Zeroizing::new(request);
+    if is_runtime_thread() {
+        return runtime_thread_response();
+    }
+    #[cfg(any(target_os = "ios", target_os = "tvos", target_os = "macos"))]
+    let _logging = crate::platform::apple_logging::enter();
+    invoke_guarded(move || {
+        let decoded = decode_request(&request)?;
+        drop(request);
+        dispatch_request(decoded)
+    })
+}
+
 /// Shared byte-oriented dispatcher used by C and Android JNI.
 /// It intentionally returns bytes so JNI never routes arbitrary JSON through
 /// Modified UTF-8 strings.
@@ -653,7 +736,257 @@ fn invoke_instance_guarded<T>(
     }
 }
 
+// Borrow the envelope to enforce the small network-metadata admission bound
+// before materializing its JSON Value. Other methods retain their own schema.
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct RawRequestEnvelope<'a> {
+    #[serde(borrow)]
+    method: &'a serde_json::value::RawValue,
+    #[serde(borrow)]
+    payload: &'a serde_json::value::RawValue,
+    #[serde(rename = "instanceId", default, borrow)]
+    _instance_id: Option<&'a serde_json::value::RawValue>,
+}
+
+fn check_dns_network_envelope(request: &str) -> Result<(), InvokeFailure> {
+    let raw: RawRequestEnvelope<'_> =
+        serde_json::from_str(request).map_err(InvokeFailure::invalid_request)?;
+    // An ASCII method's JSON spelling can use at most six bytes per letter.
+    // Decode only that bounded scalar; never search request/config contents.
+    if raw.method.get().len() > 6 * "updateDnsNetwork".len() + 2 {
+        return Ok(());
+    }
+    let is_update = serde_json::from_str::<String>(raw.method.get())
+        .is_ok_and(|method| method == "updateDnsNetwork");
+    if !is_update {
+        return Ok(());
+    }
+    let bytes = raw.payload.get().len();
+    if bytes > crate::dns::source::MAX_METADATA_BYTES {
+        return Err(InvokeFailure::invalid_request(
+            "DNS network metadata exceeds 64 KiB",
+        ));
+    }
+    const MAX_DNS_ENVELOPE_OVERHEAD: usize = 64 * 1024;
+    if request.len() - bytes > MAX_DNS_ENVELOPE_OVERHEAD {
+        return Err(InvokeFailure::invalid_request(
+            "DNS network envelope overhead exceeds 64 KiB",
+        ));
+    }
+    Ok(())
+}
+
+// Admit configuration work before allocating a JSON Value or decoded YAML.
+// Both Controller and Invoke use the one runtime candidate worker.
+fn dispatch_config_update(request: &str) -> Result<Option<InvokeResponse>, InvokeFailure> {
+    let raw: RawRequestEnvelope<'_> = serde_json::from_str(request)
+        .map_err(|_| InvokeFailure::invalid_request("invalid request envelope"))?;
+    if raw.method.get().len() > 6 * "updateConfig".len() + 2
+        || !serde_json::from_str::<String>(raw.method.get())
+            .is_ok_and(|method| method == "updateConfig")
+    {
+        return Ok(None);
+    }
+    if request.len() - raw.payload.get().len() > 64 * 1024 {
+        return Err(InvokeFailure::invalid_request(
+            "configuration envelope overhead exceeds 64 KiB",
+        ));
+    }
+    let id = raw._instance_id.ok_or_else(|| {
+        InvokeFailure::invalid_request("instanceId is required for method `updateConfig`")
+    })?;
+    if id.get().len() > 128 {
+        return Err(InvokeFailure::invalid_request("invalid instanceId"));
+    }
+    let id: String = serde_json::from_str(id.get())
+        .map_err(|_| InvokeFailure::invalid_request("invalid instanceId"))?;
+    let controller = registry().instance(&id)?;
+    invoke_instance_guarded(&controller, || {
+        let _command = controller.try_command()?;
+        let apply = {
+            let mut inner = lock(&controller.inner);
+            refresh_runtime_status(&mut inner);
+            if inner.lifecycle.state() != LifecycleState::Running {
+                return Err(InvokeFailure::invalid_state(
+                    "instance must be running before updateConfig",
+                ));
+            }
+            inner
+                .engine
+                .as_ref()
+                .and_then(|engine| engine.config_apply.clone())
+                .ok_or_else(|| {
+                    InvokeFailure::invalid_state(
+                        "runtime does not support configuration application",
+                    )
+                })?
+        };
+        let admission = apply
+            .try_admit()
+            .map_err(|e| InvokeFailure::new(e.message()))?;
+        let input = decode_update_input(raw.payload.get())?;
+        let base_dir = input
+            .http_context
+            .map(|context| {
+                if context.ca.is_some() {
+                    return Err(InvokeFailure::invalid_request(
+                        "updateConfig does not accept CA material",
+                    ));
+                }
+                let base = context.base_dir.map(InvokePath::into_path);
+                if base.as_ref().is_some_and(|path| !path.is_absolute()) {
+                    return Err(InvokeFailure::invalid_request(
+                        "HTTP baseDir must be absolute",
+                    ));
+                }
+                Ok(base)
+            })
+            .transpose()?;
+        if input.http_config_yaml.is_none() && base_dir.is_some() {
+            return Err(InvokeFailure::invalid_request(
+                "httpContext requires httpConfigYaml",
+            ));
+        }
+        let update = match input.http_config_yaml {
+            Some(http) => ConfigUpdate::ReplaceWithHttp {
+                yaml: input.config_yaml,
+                http,
+                base_dir,
+            },
+            None => ConfigUpdate::Replace(input.config_yaml),
+        };
+        admission
+            .submit(update)
+            .map_err(|e| InvokeFailure::new(e.message()))?
+            .wait_blocking()
+            .map_err(|e| InvokeFailure::new(e.message()))?;
+        Ok(Some(InvokeResponse::success(json!({}))))
+    })
+}
+
+fn decode_update_input(payload: &str) -> Result<ConfigYamlPayload, InvokeFailure> {
+    #[derive(Deserialize)]
+    #[serde(deny_unknown_fields)]
+    struct RawConfig<'a> {
+        #[serde(rename = "configYaml", borrow)]
+        yaml: &'a serde_json::value::RawValue,
+        #[serde(rename = "httpConfigYaml", default, borrow)]
+        http: Option<&'a serde_json::value::RawValue>,
+        #[serde(rename = "httpContext", default, borrow)]
+        context: Option<&'a serde_json::value::RawValue>,
+    }
+    let raw: RawConfig<'_> = serde_json::from_str(payload)
+        .map_err(|_| InvokeFailure::invalid_request("invalid configuration update payload"))?;
+    check_json_string_limit(raw.yaml.get(), crate::config::MAX_CONFIG_BYTES)?;
+    if let Some(http) = raw.http {
+        check_json_string_limit(http.get(), crate::http_processing::MAX_ADDENDUM)?;
+    }
+    if raw.context.is_some_and(|raw| raw.get().len() > 8192) {
+        return Err(InvokeFailure::invalid_request(
+            "HTTP context exceeds input limit",
+        ));
+    }
+    Ok(ConfigYamlPayload {
+        config_yaml: serde_json::from_str(raw.yaml.get())
+            .map_err(|_| InvokeFailure::invalid_request("invalid configYaml string"))?,
+        http_config_yaml: raw
+            .http
+            .map(|http| serde_json::from_str(http.get()))
+            .transpose()
+            .map_err(|_| InvokeFailure::invalid_request("invalid httpConfigYaml string"))?,
+        http_context: raw
+            .context
+            .map(|raw| serde_json::from_str(raw.get()))
+            .transpose()
+            .map_err(|_| InvokeFailure::invalid_request("invalid HTTP context"))?,
+    })
+}
+#[cfg(test)]
+fn decode_update_yaml(payload: &str) -> Result<String, InvokeFailure> {
+    decode_update_input(payload).map(|input| input.config_yaml)
+}
+
+// RawValue validates JSON syntax without decoding strings. Count decoded UTF-8
+// first, including surrogate pairs, so escaped input cannot allocate >8 MiB.
+fn check_json_string_limit(raw: &str, limit: usize) -> Result<(), InvokeFailure> {
+    let bad = || InvokeFailure::invalid_request("configYaml must be a valid string");
+    let bytes = raw.as_bytes();
+    if bytes.len() < 2 || bytes[0] != b'"' || *bytes.last().unwrap() != b'"' {
+        return Err(bad());
+    }
+    let hex = |slice: &[u8]| -> Option<u16> {
+        slice.iter().try_fold(0_u16, |n, c| {
+            let digit = match c {
+                b'0'..=b'9' => c - b'0',
+                b'a'..=b'f' => c - b'a' + 10,
+                b'A'..=b'F' => c - b'A' + 10,
+                _ => return None,
+            };
+            Some((n << 4) | u16::from(digit))
+        })
+    };
+    let mut i = 1;
+    let mut decoded = 0;
+    while i < bytes.len() - 1 {
+        let width = if bytes[i] != b'\\' {
+            i += 1;
+            1
+        } else {
+            i += 1;
+            match bytes.get(i).copied().ok_or_else(bad)? {
+                b'"' | b'\\' | b'/' | b'b' | b'f' | b'n' | b'r' | b't' => {
+                    i += 1;
+                    1
+                }
+                b'u' => {
+                    let code = hex(bytes.get(i + 1..i + 5).ok_or_else(bad)?).ok_or_else(bad)?;
+                    i += 5;
+                    match code {
+                        0..=0x7f => 1,
+                        0x80..=0x7ff => 2,
+                        0xd800..=0xdbff => {
+                            if bytes.get(i..i + 2) != Some(b"\\u") {
+                                return Err(bad());
+                            }
+                            let low =
+                                hex(bytes.get(i + 2..i + 6).ok_or_else(bad)?).ok_or_else(bad)?;
+                            if !(0xdc00..=0xdfff).contains(&low) {
+                                return Err(bad());
+                            }
+                            i += 6;
+                            4
+                        }
+                        0xdc00..=0xdfff => return Err(bad()),
+                        _ => 3,
+                    }
+                }
+                _ => return Err(bad()),
+            }
+        };
+        decoded += width;
+        if decoded > limit {
+            return Err(InvokeFailure::invalid_request(
+                "configuration string exceeds its input limit",
+            ));
+        }
+    }
+    if i != bytes.len() - 1 {
+        return Err(bad());
+    }
+    Ok(())
+}
+
+enum DecodedRequest {
+    Complete(InvokeResponse),
+    Envelope(RequestEnvelope),
+}
+
 fn dispatch_bytes(request: &[u8]) -> Result<InvokeResponse, InvokeFailure> {
+    dispatch_request(decode_request(request)?)
+}
+
+fn decode_request(request: &[u8]) -> Result<DecodedRequest, InvokeFailure> {
     if request.len() > MAX_INVOKE_BYTES {
         return Err(InvokeFailure::invalid_request(format!(
             "Invoke envelope exceeds the {MAX_INVOKE_BYTES}-byte limit"
@@ -661,12 +994,26 @@ fn dispatch_bytes(request: &[u8]) -> Result<InvokeResponse, InvokeFailure> {
     }
     let request = str::from_utf8(request)
         .map_err(|_| InvokeFailure::invalid_request("request is not valid UTF-8"))?;
+    check_dns_network_envelope(request)?;
+    http::check_envelope(request)?;
+    foreground::check_envelope(request)?;
+    if let Some(response) = dispatch_config_update(request)? {
+        return Ok(DecodedRequest::Complete(response));
+    }
     let envelope: RequestEnvelope =
         serde_json::from_str(request).map_err(InvokeFailure::invalid_request)?;
     if !envelope.payload.is_object() {
         return Err(InvokeFailure::invalid_request("payload must be an object"));
     }
 
+    Ok(DecodedRequest::Envelope(envelope))
+}
+
+fn dispatch_request(request: DecodedRequest) -> Result<InvokeResponse, InvokeFailure> {
+    let envelope = match request {
+        DecodedRequest::Complete(response) => return Ok(response),
+        DecodedRequest::Envelope(envelope) => envelope,
+    };
     let data = match envelope.method.as_str() {
         "initialize" => {
             require_instance_omitted(&envelope)?;
@@ -674,6 +1021,20 @@ fn dispatch_bytes(request: &[u8]) -> Result<InvokeResponse, InvokeFailure> {
             let directory = registry().initialize_data_directory(&payload.data_dir)?;
             json!({"dataDir": directory.root().to_string_lossy()})
         }
+        "updateDnsNetwork" => {
+            require_instance_omitted(&envelope)?;
+            crate::dns::source::check_metadata_size(&envelope.payload)
+                .map_err(InvokeFailure::from)?;
+            let update: crate::dns::source::DnsNetworkUpdate = decode_payload(envelope.payload)?;
+            let sources = registry().dns_sources()?;
+            let runtime = tokio::runtime::Builder::new_current_thread()
+                .build()
+                .map_err(InvokeFailure::from)?;
+            runtime
+                .block_on(sources.replace(update))
+                .map_err(InvokeFailure::from)?;
+            json!({})
+        }
         "createInstance" => {
             require_instance_omitted(&envelope)?;
             let _: EmptyPayload = decode_payload(envelope.payload)?;
@@ -690,8 +1051,32 @@ fn dispatch_bytes(request: &[u8]) -> Result<InvokeResponse, InvokeFailure> {
         "validateConfig" => {
             require_instance_omitted(&envelope)?;
             let payload: ConfigYamlPayload = decode_payload(envelope.payload)?;
-            validate_config(payload.config_yaml)?;
-            json!({})
+            if let Some(context) = payload.http_context {
+                if context.ca.is_some() {
+                    return Err(InvokeFailure::invalid_request(
+                        "validateConfig does not accept CA material",
+                    ));
+                }
+                if context
+                    .base_dir
+                    .map(InvokePath::into_path)
+                    .is_some_and(|path| !path.is_absolute())
+                {
+                    return Err(InvokeFailure::invalid_request(
+                        "HTTP baseDir must be absolute",
+                    ));
+                }
+            }
+            let resources_ready = payload
+                .http_config_yaml
+                .as_deref()
+                .filter(|input| !input.is_empty())
+                .map(crate::http_processing::config::Document::parse)
+                .transpose()
+                .map_err(|_| InvokeFailure::new("invalid HTTP processing configuration"))?
+                .is_none_or(|document| document.unresolved_count() == 0);
+            validate_config_with_http(payload.config_yaml, payload.http_config_yaml)?;
+            json!({"httpResourcesValidated":resources_ready,"httpsReady":false})
         }
         "measureDelay" => {
             require_instance_omitted(&envelope)?;
@@ -699,14 +1084,27 @@ fn dispatch_bytes(request: &[u8]) -> Result<InvokeResponse, InvokeFailure> {
             let results = measure_delay::measure_delay(payload)?;
             json!({"results": results})
         }
-        "start" => {
+        "start" | "reconnect" => {
             let controller = require_instance(&envelope)?;
-            let payload: ConfigYamlPayload = decode_payload(envelope.payload)?;
+            let reconnect = envelope.method == "reconnect";
+            let payload: http::StartPayload = decode_payload(envelope.payload)?;
             invoke_instance_guarded(&controller, || {
-                controller.start(payload.config_yaml)?;
+                if reconnect {
+                    controller.reconnect(payload)?;
+                } else {
+                    controller.start_config(StartupConfig::Input(Box::new(payload)))?;
+                }
                 Ok(json!({}))
             })?
         }
+        "refreshHttpProviders" => {
+            require_instance_omitted(&envelope)?;
+            http::refresh(decode_payload(envelope.payload)?)?
+        }
+        "testHttp" => {
+            require_instance_omitted(&envelope)?;
+            http::evaluate(decode_payload::<http::TestPayload>(envelope.payload)?)?
+        }
         "foreground" => {
             require_instance_omitted(&envelope)?;
             let payload: foreground::ForegroundPayload = decode_payload(envelope.payload)?;
@@ -798,7 +1196,7 @@ impl CoreController {
         Ok(())
     }
 
-    fn prepare_locked(&self, config_yaml: String) -> Result<(), InvokeFailure> {
+    fn prepare_locked(&self, input: StartupConfig) -> Result<(), InvokeFailure> {
         {
             let mut inner = lock(&self.inner);
             refresh_runtime_status(&mut inner);
@@ -813,8 +1211,25 @@ impl CoreController {
         // protect controller for a configuration that actually contains TUN;
         // non-TUN configurations do not depend on controller registration.
         let _data_directory = registry().data_directory()?;
-        let config = parse_config_yaml(&config_yaml)?;
-        drop(config_yaml);
+        let (mut config, http_input, resolved_cache) = match input {
+            #[cfg(test)]
+            StartupConfig::Yaml(yaml) => (parse_config_yaml(&yaml)?, None, None),
+            StartupConfig::Input(mut payload) => {
+                let mut config = parse_config_yaml(&payload.config_yaml)?;
+                if let (Some(template), Some(paths)) =
+                    (&mut config.providers, payload.provider_paths.clone())
+                {
+                    Arc::make_mut(template).resource_paths = paths;
+                }
+                std::mem::take(&mut payload.foreground_overrides).apply(&mut config);
+                (config, Some(payload), None)
+            }
+            StartupConfig::Resolved(snapshot) => {
+                (snapshot.config, None, Some(snapshot.provider_cache))
+            }
+        };
+        let dispatch = crate::logging::dispatch(config.log_level);
+        let _logging = tracing::dispatcher::set_default(&dispatch);
         let has_tun = config
             .inbounds
             .iter()
@@ -827,7 +1242,10 @@ impl CoreController {
             tun_lease,
             protector,
         } = acquisition;
-        let allocator_relief = AppleTunAllocatorRelief::new(has_tun);
+        if has_tun {
+            crate::platform::process_memory::configure_allocator();
+        }
+        let allocator_relief = TunAllocatorRelief::new(has_tun);
         {
             let mut inner = lock(&self.inner);
             inner.last_error.clear();
@@ -836,7 +1254,7 @@ impl CoreController {
                 .transition(LifecycleState::Preparing)
                 .map_err(InvokeFailure::from)?;
             inner.tun_lease = tun_lease;
-            inner.apple_tun_allocator_relief = allocator_relief;
+            inner.tun_allocator_relief = allocator_relief;
         }
 
         let prepared = (|| {
@@ -847,14 +1265,48 @@ impl CoreController {
                 .enable_time()
                 .build()
                 .map_err(InvokeFailure::from)?;
-            let prepared = runtime
-                .block_on(PreparedCore::prepare_config(
-                    config,
-                    geodata_manager,
-                    &SystemResolver,
-                    limits,
-                ))
-                .map_err(InvokeFailure::from);
+            let prepared = runtime.block_on(async {
+                let cancellation = http_input
+                    .as_ref()
+                    .and_then(|input| input.cancellation.clone());
+                if let Some(input) = http_input {
+                    http::attach(
+                        &mut config,
+                        input.http_config_yaml.as_deref(),
+                        input.http_context,
+                        input.source_file,
+                        input.provider_paths,
+                        input.cancellation.as_ref(),
+                    )
+                    .await?;
+                }
+                let prepared = match resolved_cache {
+                    Some(cache) => {
+                        PreparedCore::prepare_resolved(
+                            config,
+                            cache,
+                            geodata_manager,
+                            &SystemResolver,
+                            limits,
+                        )
+                        .await
+                    }
+                    None => {
+                        PreparedCore::prepare_config(
+                            config,
+                            geodata_manager,
+                            &SystemResolver,
+                            limits,
+                        )
+                        .await
+                    }
+                }
+                .map_err(InvokeFailure::from)?;
+                if cancellation.is_some_and(|token| token.is_cancelled()) {
+                    return Err(InvokeFailure::new("core preparation was cancelled"));
+                }
+                Ok(prepared)
+            });
             // Bootstrap DNS runs on the runtime-shared bounded worker. Keep a
             // finite shutdown boundary so future prepare-only tasks cannot
             // turn Runtime::drop into an unbounded synchronous wait.
@@ -875,7 +1327,7 @@ impl CoreController {
                     .map_err(InvokeFailure::from)
                 {
                     Ok(()) => {
-                        observe_apple_tun_memory(has_tun, "prepare-complete");
+                        observe_tun_memory(has_tun, "prepare-complete");
                         Ok(())
                     }
                     Err(error) => reset_failed_operation(&mut inner, "prepare-transition-failed")
@@ -886,9 +1338,9 @@ impl CoreController {
         }
     }
 
-    fn start(&self, config_yaml: String) -> Result<(), InvokeFailure> {
+    fn start_config(&self, config: StartupConfig) -> Result<(), InvokeFailure> {
         let _command = self.try_command()?;
-        self.prepare_locked(config_yaml)?;
+        self.prepare_locked(config)?;
         let result = self.start_prepared_locked();
         if result.is_err() {
             reset_failed_operation(&mut lock(&self.inner), "start-failed")?;
@@ -896,6 +1348,64 @@ impl CoreController {
         result
     }
 
+    fn reconnect(&self, input: http::StartPayload) -> Result<(), InvokeFailure> {
+        let _command = self.try_command()?;
+        let apply = {
+            let mut inner = lock(&self.inner);
+            refresh_runtime_status(&mut inner);
+            if inner.lifecycle.state() != LifecycleState::Running {
+                return Err(InvokeFailure::invalid_state(
+                    "instance must be running before reconnect",
+                ));
+            }
+            inner
+                .engine
+                .as_ref()
+                .and_then(|engine| engine.config_apply.clone())
+                .ok_or_else(|| {
+                    InvokeFailure::invalid_state("runtime cannot capture a recovery snapshot")
+                })?
+        };
+        // Resolve external sources while the old engine and its platform lease
+        // are still usable. GeoData registration and TUN binding happen only
+        // after the synchronous old-engine stop barrier.
+        let config = http::parse_reconnect(input, &apply)?;
+        let manager = registry().geodata_manager()?;
+        let runtime = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .map_err(InvokeFailure::from)?;
+        let next = runtime.block_on(PreparedCore::resolve_config(config, &manager));
+        runtime.shutdown_timeout(Duration::from_millis(100));
+        let (config, provider_cache) = next.map_err(InvokeFailure::from)?;
+        let next = Box::new(crate::runtime::RecoverySnapshot {
+            config,
+            provider_cache,
+        });
+        let previous = apply
+            .recovery_snapshot()
+            .map_err(|error| InvokeFailure::new(error.message()))?;
+        self.stop_locked()?;
+        let result = self
+            .prepare_locked(StartupConfig::Resolved(next))
+            .and_then(|()| self.start_prepared_locked());
+        if let Err(error) = result {
+            reset_failed_operation(&mut lock(&self.inner), "reconnect-failed")?;
+            if self
+                .prepare_locked(StartupConfig::Resolved(previous))
+                .and_then(|()| self.start_prepared_locked())
+                .is_err()
+            {
+                reset_failed_operation(&mut lock(&self.inner), "reconnect-recovery-failed")?;
+                return Err(InvokeFailure::new(
+                    "reconnect failed and previous session could not be restored",
+                ));
+            }
+            return Err(error);
+        }
+        Ok(())
+    }
+
     fn start_prepared_locked(&self) -> Result<(), InvokeFailure> {
         let (prepared, tun, has_tun, allocator_relief) = {
             let mut inner = lock(&self.inner);
@@ -921,7 +1431,7 @@ impl CoreController {
                 .lifecycle
                 .transition(LifecycleState::Starting)
                 .map_err(InvokeFailure::from)?;
-            let allocator_relief = inner.apple_tun_allocator_relief.clone();
+            let allocator_relief = inner.tun_allocator_relief.clone();
             (prepared, tun, has_tun, allocator_relief)
         };
 
@@ -930,7 +1440,8 @@ impl CoreController {
             .clone()
             .map_or_else(Dialer::default, |protector| {
                 Dialer::default().with_protector(protector)
-            });
+            })
+            .with_dns_sources(registry().dns_sources()?);
         let (stop_tx, stop_rx) = oneshot::channel();
         let (startup_tx, startup_rx) = std::sync::mpsc::sync_channel(1);
         let (completed_tx, completed_rx) = tokio::sync::watch::channel(false);
@@ -940,7 +1451,7 @@ impl CoreController {
             has_tun,
             allocator_relief,
         };
-        let dispatch = tracing::dispatcher::get_default(Clone::clone);
+        let dispatch = crate::logging::dispatch(prepared.core.log_level());
         let spawned = thread::Builder::new()
             .name(format!("vole-runtime-{instance_id}"))
             .spawn(crate::resources::observation::inherit_thread(move || {
@@ -961,10 +1472,12 @@ impl CoreController {
             stop: Some(stop_tx),
             thread: Some(runtime_thread),
             completion: completed_rx,
+            config_apply: None,
         };
 
         match startup_rx.recv_timeout(Duration::from_secs(10)) {
-            Ok(Ok(())) => {
+            Ok(Ok(config_apply)) => {
+                engine.config_apply = config_apply;
                 let mut inner = lock(&self.inner);
                 if let Err(error) = inner
                     .lifecycle
@@ -978,7 +1491,7 @@ impl CoreController {
                         .and(Err(error));
                 }
                 inner.engine = Some(engine);
-                observe_apple_tun_memory(has_tun, "start-complete");
+                observe_tun_memory(has_tun, "start-complete");
                 Ok(())
             }
             Ok(Err(error)) => {
@@ -1018,7 +1531,7 @@ impl CoreController {
                 LifecycleState::Stopped => {
                     let had_tun = inner.tun_lease.is_some();
                     inner.last_error.clear();
-                    observe_apple_tun_memory(had_tun, "stop-complete");
+                    observe_tun_memory(had_tun, "stop-complete");
                     clear_instance_leases(&mut inner);
                     return Ok(());
                 }
@@ -1030,7 +1543,7 @@ impl CoreController {
                         .lifecycle
                         .transition(LifecycleState::Stopped)
                         .map_err(InvokeFailure::from);
-                    observe_apple_tun_memory(had_tun, "stop-complete");
+                    observe_tun_memory(had_tun, "stop-complete");
                     clear_instance_leases(&mut inner);
                     return transitioned;
                 }
@@ -1135,7 +1648,7 @@ impl CoreController {
         let mut inner = lock(&self.inner);
         inner.lifecycle = Lifecycle::default();
         inner.engine = None;
-        observe_apple_tun_memory(had_tun, "panic-recovery");
+        observe_tun_memory(had_tun, "panic-recovery");
         clear_instance_leases(&mut inner);
         Ok(())
     }
@@ -1144,20 +1657,17 @@ impl CoreController {
 fn clear_instance_leases(inner: &mut CoreInner) {
     // Prepared-only paths own the final allocator-relief handle here. Running
     // paths share it with the engine, whose completion performs relief first.
-    inner.apple_tun_allocator_relief = None;
+    inner.tun_allocator_relief = None;
     inner.tun_lease = None;
 }
 
-fn observe_apple_tun_memory(has_tun: bool, stage: &'static str) {
-    #[cfg(any(target_os = "ios", target_os = "tvos"))]
+fn observe_tun_memory(has_tun: bool, stage: &'static str) {
     if has_tun {
         crate::platform::process_memory::observe(stage);
     }
-    let _ = (has_tun, stage);
 }
 
-fn relieve_apple_tun_allocator() {
-    #[cfg(any(target_os = "ios", target_os = "tvos"))]
+fn relieve_tun_allocator() {
     crate::platform::process_memory::relieve_allocator_pressure();
 }
 
@@ -1168,23 +1678,48 @@ pub(crate) fn replace_android_socket_protector(
     registry().replace_android_socket_protector(protector)
 }
 
-fn validate_config(config_yaml: String) -> Result<(), InvokeFailure> {
-    let config = parse_config_yaml(&config_yaml)?;
+fn validate_config_with_http(
+    config_yaml: String,
+    http_config_yaml: Option<String>,
+) -> Result<(), InvokeFailure> {
+    let config = parse_config_yaml_with_http(&config_yaml, http_config_yaml.as_deref())?;
     drop(config_yaml);
     PreparedCore::validate_config(config).map_err(InvokeFailure::from)
 }
 
 fn parse_config_yaml(config_yaml: &str) -> Result<Config, InvokeFailure> {
+    parse_config_yaml_with_http(config_yaml, None)
+}
+fn parse_config_yaml_with_http(
+    config_yaml: &str,
+    http: Option<&str>,
+) -> Result<Config, InvokeFailure> {
+    let directory = registry().data_directory().ok();
+    let mut config =
+        parse_config_yaml_with_directory(config_yaml, directory.as_ref().map(|dir| dir.root()))?;
+    if let (Some(template), Some(paths)) = (&mut config.providers, registry().provider_paths()) {
+        Arc::make_mut(template).resource_paths = paths;
+    }
+    config.set_http_config(http).map_err(InvokeFailure::from)?;
+    Ok(config)
+}
+
+fn parse_config_yaml_with_directory(
+    config_yaml: &str,
+    directory: Option<&Path>,
+) -> Result<Config, InvokeFailure> {
     if config_yaml.is_empty() {
         return Err(InvokeFailure::invalid_request("configYaml is empty"));
     }
-    Config::parse_yaml(config_yaml.as_bytes()).map_err(InvokeFailure::from)
+    Config::parse_yaml_with_directory(config_yaml.as_bytes(), directory)
+        .map_err(InvokeFailure::from)
 }
 
 fn geodata_status_data(status: GeoDataStatus) -> Value {
     json!({
         "geosite": geodata_resource_data(status.geosite),
         "geoip": geodata_resource_data(status.geoip),
+        "asn": geodata_resource_data(status.asn),
     })
 }
 
@@ -1246,7 +1781,7 @@ fn acquire_start_tun(
 struct EngineContext {
     instance_id: u64,
     has_tun: bool,
-    allocator_relief: Option<AppleTunAllocatorRelief>,
+    allocator_relief: Option<TunAllocatorRelief>,
 }
 
 fn run_engine(
@@ -1255,7 +1790,7 @@ fn run_engine(
     tun: Option<InvokeTun>,
     dialer: Dialer,
     stop: oneshot::Receiver<()>,
-    startup: SyncSender<Result<(), InvokeFailure>>,
+    startup: SyncSender<Result<Option<ConfigApplyHandle>, InvokeFailure>>,
 ) -> io::Result<()> {
     let EngineContext {
         instance_id,
@@ -1264,7 +1799,7 @@ fn run_engine(
     } = context;
     tracing::info!(instance_id, has_tun, "Vole runtime engine starting");
     let result = run_engine_inner(instance_id, has_tun, prepared, tun, dialer, stop, startup);
-    observe_apple_tun_memory(has_tun, "stop-complete");
+    observe_tun_memory(has_tun, "stop-complete");
     if let Some(relief) = allocator_relief {
         relief.relieve();
     }
@@ -1288,7 +1823,7 @@ fn run_engine_inner(
     tun: Option<InvokeTun>,
     dialer: Dialer,
     stop: oneshot::Receiver<()>,
-    startup: SyncSender<Result<(), InvokeFailure>>,
+    startup: SyncSender<Result<Option<ConfigApplyHandle>, InvokeFailure>>,
 ) -> io::Result<()> {
     let runtime = match engine_runtime_builder().enable_io().enable_time().build() {
         Ok(runtime) => runtime,
@@ -1312,10 +1847,24 @@ fn run_engine_inner(
                 Err(error) => Err(io::Error::other(error)),
             },
             None if has_tun => {
-                let config = prepared.tun_config().expect("validated TUN configuration");
-                match TunIo::open(&config.device, config.mtu) {
-                    Ok(tun) => prepared.start_tun(tun, dialer).await,
-                    Err(error) => Err(io::Error::other(error)),
+                #[cfg(target_os = "linux")]
+                {
+                    prepared.start_native_tun(dialer).await
+                }
+                #[cfg(not(target_os = "linux"))]
+                {
+                    let config = prepared.tun_config().expect("validated TUN configuration");
+                    if config.auto_route || config.auto_detect_interface {
+                        Err(io::Error::new(
+                            io::ErrorKind::Unsupported,
+                            "automatic TUN networking is only available on Linux",
+                        ))
+                    } else {
+                        match TunIo::open(&config.device, config.mtu) {
+                            Ok(tun) => prepared.start_tun(tun, dialer).await,
+                            Err(error) => Err(io::Error::other(error)),
+                        }
+                    }
                 }
             }
             None => prepared.start_local(dialer).await,
@@ -1341,7 +1890,7 @@ fn run_engine_inner(
             debug_assert!(tun.is_none());
             prepared.start_local(dialer).await
         };
-        let running = match started {
+        let mut running = match started {
             Ok(running) => running,
             Err(error) => {
                 let kind = error.kind();
@@ -1350,8 +1899,11 @@ fn run_engine_inner(
                 return Err(io::Error::new(kind, message));
             }
         };
+        running.maintain_http(
+            http::runtime_store().map_err(|_| io::Error::other("HTTP runtime store is missing"))?,
+        );
         tracing::info!(instance_id, has_tun, "Vole runtime engine started");
-        if startup.send(Ok(())).is_err() {
+        if startup.send(Ok(running.config_apply_handle())).is_err() {
             return running.stop().await;
         }
         running
@@ -1360,10 +1912,10 @@ fn run_engine_inner(
     })
 }
 
-async fn wait_for_engine_shutdown(stop: oneshot::Receiver<()>, has_tun: bool) -> io::Result<()> {
-    #[cfg(any(target_os = "ios", target_os = "tvos"))]
-    let mut stop = stop;
-    #[cfg(any(target_os = "ios", target_os = "tvos"))]
+async fn wait_for_engine_shutdown(
+    mut stop: oneshot::Receiver<()>,
+    has_tun: bool,
+) -> io::Result<()> {
     if has_tun {
         let interval = crate::platform::process_memory::TELEMETRY_INTERVAL;
         let first_tick = tokio::time::Instant::now() + interval;
@@ -1372,11 +1924,10 @@ async fn wait_for_engine_shutdown(stop: oneshot::Receiver<()>, has_tun: bool) ->
         loop {
             tokio::select! {
                 _ = &mut stop => return Ok(()),
-                _ = telemetry.tick() => observe_apple_tun_memory(true, "running"),
+                _ = telemetry.tick() => observe_tun_memory(true, "running"),
             }
         }
     }
-    let _ = has_tun;
     let _ = stop.await;
     Ok(())
 }
@@ -1427,7 +1978,7 @@ fn reset_failed_operation(
         }
         LifecycleState::Stopped => {}
     }
-    observe_apple_tun_memory(had_tun, telemetry_stage);
+    observe_tun_memory(had_tun, telemetry_stage);
     clear_instance_leases(inner);
     Ok(())
 }
@@ -1460,6 +2011,36 @@ fn bounded_error(mut message: String) -> String {
 
 #[cfg(test)]
 mod tests {
+    #[test]
+    fn owned_invoke_uses_the_shared_strict_and_runtime_thread_boundaries() {
+        let version = br#"{"method":"version","payload":{}}"#;
+        assert_eq!(
+            super::invoke_bytes(version),
+            super::invoke_owned_bytes(version.to_vec())
+        );
+        for invalid in [
+            br#"{"method":"version","payload":{},"extra":true}"#.as_slice(),
+            br#"{"method":"version","payload":{"secret":"private-fixture"}}"#,
+            br#"{"method":"foreground","payload":{"action":"help","extra":true}}"#,
+        ] {
+            assert_eq!(
+                super::invoke_bytes(invalid),
+                super::invoke_owned_bytes(invalid.to_vec())
+            );
+        }
+        let oversized_key = serde_json::json!({"method":"foreground","payload":{"action":"help","ageSecretKey":"x".repeat(16 * 1024 + 1)}}).to_string();
+        assert_eq!(
+            super::invoke_bytes(oversized_key.as_bytes()),
+            super::invoke_owned_bytes(oversized_key.into_bytes())
+        );
+        super::IS_RUNTIME_THREAD.with(|flag| {
+            let old = flag.replace(true);
+            let response = super::invoke_owned_bytes(version.to_vec());
+            flag.set(old);
+            assert_eq!(response, super::runtime_thread_response());
+        });
+    }
+
     use std::{
         io::{Read, Write},
         net::{TcpListener, TcpStream},
@@ -1477,6 +2058,42 @@ mod tests {
 
     static TEST_LOCK: Mutex<()> = Mutex::new(());
 
+    #[test]
+    fn allocator_relief_requires_tun() {
+        assert!(TunAllocatorRelief::new(false).is_none());
+        let relief = TunAllocatorRelief::new(true).expect("TUN owns allocator relief");
+        // Claim with a pure hook so this regression never trims the test
+        // process's allocator as a side effect of dropping the handle.
+        relief.state.relieve_with(|| {});
+    }
+
+    #[test]
+    fn shared_allocator_relief_is_claimed_exactly_once() {
+        let state = Arc::new(TunAllocatorReliefState {
+            relieved: AtomicBool::new(false),
+        });
+        let calls = Arc::new(std::sync::atomic::AtomicUsize::new(0));
+        let attempts: Vec<_> = (0..8)
+            .map(|_| {
+                let state = state.clone();
+                let calls = calls.clone();
+                thread::spawn(move || {
+                    state.relieve_with(|| {
+                        calls.fetch_add(1, Ordering::Relaxed);
+                    });
+                })
+            })
+            .collect();
+        for attempt in attempts {
+            attempt.join().unwrap();
+        }
+        state.relieve_with(|| {
+            calls.fetch_add(1, Ordering::Relaxed);
+        });
+        assert_eq!(calls.load(Ordering::Relaxed), 1);
+        assert!(state.relieved.load(Ordering::Relaxed));
+    }
+
     struct TestDataDirectory {
         _temporary: tempfile::TempDir,
     }
@@ -1525,7 +2142,7 @@ mod tests {
         let controller = registry().instance(instance_id).unwrap();
         let payload: ConfigYamlPayload = decode_payload(payload).unwrap();
         let _command = controller.try_command().unwrap();
-        let result = controller.prepare_locked(payload.config_yaml);
+        let result = controller.prepare_locked(StartupConfig::Yaml(payload.config_yaml));
         json!({"success": result.is_ok()})
     }
 
@@ -1980,6 +2597,171 @@ rules:
         assert_failure(&oversized_json);
     }
 
+    #[test]
+    fn update_config_invoke_shares_admission_and_keeps_lifecycle_command_serial() {
+        let _guard = TEST_LOCK.lock().unwrap();
+        reset_registry();
+        let id = create_instance();
+        let controller = registry().instance(&id).unwrap();
+        assert_failure(&request(
+            "updateConfig",
+            Some(&id),
+            json!({"configYaml":"rules: [MATCH,DIRECT]"}),
+        ));
+        let (handle, mut receiver) =
+            ConfigApplyHandle::channel(tokio_util::sync::CancellationToken::new());
+        let (_sent, completion) = tokio::sync::watch::channel(false);
+        {
+            let mut inner = lock(&controller.inner);
+            for state in [
+                LifecycleState::Preparing,
+                LifecycleState::Prepared,
+                LifecycleState::Starting,
+                LifecycleState::Running,
+            ] {
+                inner.lifecycle.transition(state).unwrap();
+            }
+            inner.engine = Some(Engine {
+                stop: None,
+                thread: None,
+                completion,
+                config_apply: Some(handle.clone()),
+            });
+        }
+        let occupied = handle.try_admit().unwrap();
+        let busy = request(
+            "updateConfig",
+            Some(&id),
+            json!({"extra":"invalid schema must not be decoded"}),
+        );
+        assert_eq!(busy["error"], "configuration application is busy");
+        drop(occupied);
+        let id2 = id.clone();
+        let caller = thread::spawn(move || {
+            request(
+                "updateConfig",
+                Some(&id2),
+                json!({"configYaml":"rules: [MATCH,DIRECT]"}),
+            )
+        });
+        let mut candidate = receiver.blocking_recv().unwrap();
+        assert!(
+            matches!(candidate.take_update(), ConfigUpdate::Replace(yaml) if yaml == "rules: [MATCH,DIRECT]")
+        );
+        let stopped = request("stop", Some(&id), json!({}));
+        assert_failure(&stopped);
+        assert!(stopped["error"].as_str().unwrap().contains("busy"));
+        candidate.complete(Ok(()));
+        assert_eq!(caller.join().unwrap()["success"], true);
+        destroy_instance(&id);
+        assert_registry_is_idle();
+    }
+
+    #[test]
+    fn update_config_raw_string_budget_and_strict_shape_precede_decoding() {
+        for value in ["", "plain", "界", "\\", "\n", "😀"] {
+            let encoded = serde_json::to_string(value).unwrap();
+            assert!(check_json_string_limit(&encoded, value.len()).is_ok());
+            if !value.is_empty() {
+                assert!(check_json_string_limit(&encoded, value.len() - 1).is_err());
+            }
+            assert_eq!(
+                decode_update_yaml(&format!(r#"{{"configYaml":{encoded}}}"#)).unwrap(),
+                value
+            );
+        }
+        assert!(check_json_string_limit(r#""\u754c""#, 3).is_ok());
+        assert!(check_json_string_limit(r#""\uD83D\uDE00""#, 4).is_ok());
+        assert!(check_json_string_limit(r#""\uD83D\uDE00""#, 3).is_err());
+        for invalid in [r#""\uD800""#, r#""\uDC00""#, "null", "1"] {
+            assert!(check_json_string_limit(invalid, 32).is_err());
+        }
+        for payload in [
+            r#"{"configYaml":"a","extra":1}"#,
+            r#"{"configYaml":"a","configYaml":"b"}"#,
+            r#"{"configYaml":null}"#,
+            "{}",
+        ] {
+            assert!(decode_update_yaml(payload).is_err());
+        }
+        let max = crate::config::MAX_CONFIG_BYTES;
+        let escaped = format!(r#"{{"configYaml":"{}"}}"#, r"\u0061".repeat(max + 1));
+        assert!(decode_update_yaml(&escaped).is_err());
+        // A raw input of arbitrary JSON shape cannot bypass method matching.
+        assert!(
+            dispatch_config_update(r#"{"method":"version","payload":{}}"#)
+                .unwrap()
+                .is_none()
+        );
+        assert!(dispatch_config_update(r#"{"method":"updateConfig","payload":{}}"#).is_err());
+    }
+
+    #[test]
+    fn update_dns_network_raw_admission_is_bounded_before_value_or_registry_work() {
+        let padded = format!(
+            "{{{}\"generation\":1,\"system\":[],\"dhcp\":[]}}",
+            " ".repeat(crate::dns::source::MAX_METADATA_BYTES)
+        );
+        for method in ["updateDnsNetwork", r"\u0075pdateDnsNetwork"] {
+            let envelope = format!(r#"{{"payload":{padded},"method":"{method}"}}"#);
+            let response = invoke(&envelope);
+            assert_failure(&response);
+            assert_eq!(
+                response["error"],
+                "invalid request: DNS network metadata exceeds 64 KiB"
+            );
+        }
+        let overhead = format!(
+            r#"{{"method":"updateDnsNetwork","payload":{{}},"instanceId":"{}"}}"#,
+            "x".repeat(64 * 1024)
+        );
+        assert!(check_dns_network_envelope(&overhead).is_err());
+        let unrelated = json!({"method":"validateConfig","payload":{"configYaml":"updateDnsNetwork".repeat(8192)}}).to_string();
+        assert!(check_dns_network_envelope(&unrelated).is_ok());
+    }
+
+    #[test]
+    fn update_dns_network_is_runtime_local_strict_and_monotonic() {
+        let _guard = TEST_LOCK.lock().unwrap();
+        reset_registry();
+        let payload = json!({"generation":1,"system":[{"address":"203.0.113.53","interface":"physical0"}],"dhcp":[]});
+        assert_failure(&request("updateDnsNetwork", None, payload.clone()));
+        let _data = initialize_test_data_directory();
+        assert_eq!(
+            request("updateDnsNetwork", None, payload.clone())["success"],
+            true
+        );
+        assert_eq!(
+            request("updateDnsNetwork", None, payload.clone())["success"],
+            true
+        );
+        assert_failure(&request("updateDnsNetwork", Some("1"), payload));
+        assert_failure(&request(
+            "updateDnsNetwork",
+            None,
+            json!({"generation":1,"system":[],"dhcp":[]}),
+        ));
+        assert_eq!(
+            request(
+                "updateDnsNetwork",
+                None,
+                json!({"generation":2,"system":[],"dhcp":[]})
+            )["success"],
+            true
+        );
+        assert_failure(&request(
+            "updateDnsNetwork",
+            None,
+            json!({"generation":1,"system":[],"dhcp":[]}),
+        ));
+        assert_failure(&request(
+            "updateDnsNetwork",
+            None,
+            json!({"generation":3,"system":[],"dhcp":[],"extra":true}),
+        ));
+        reset_registry();
+    }
+
     #[test]
     fn start_accepts_only_config_yaml_and_removed_prepare_is_unknown() {
         let _guard = TEST_LOCK.lock().unwrap();
@@ -2514,6 +3296,7 @@ rules:
                 stop: Some(stop),
                 thread: Some(worker),
                 completion,
+                config_apply: None,
             });
         }
         let result = invoke_instance_guarded(&controller, || {
@@ -2570,6 +3353,7 @@ rules:
             stop: None,
             thread: Some(worker),
             completion: received,
+            config_apply: None,
         };
         assert!(engine.stop().is_err());
     }
@@ -2586,4 +3370,26 @@ rules:
         let platform = lock(&registry().platform);
         assert_eq!(platform.tun_owner, None);
     }
+
+    #[test]
+    fn update_http_addendum_preserves_optional_clear_and_its_separate_byte_limit() {
+        let input = decode_update_input(
+            r#"{"configYaml":"rules: ['MATCH,DIRECT']","httpConfigYaml":"rewrite: []"}"#,
+        )
+        .unwrap();
+        assert_eq!(input.http_config_yaml.as_deref(), Some("rewrite: []"));
+        assert_eq!(
+            decode_update_input(r#"{"configYaml":"x","httpConfigYaml":""}"#)
+                .unwrap()
+                .http_config_yaml
+                .as_deref(),
+            Some("")
+        );
+        assert!(decode_update_input(r#"{"configYaml":"x","httpConfigYaml":1}"#).is_err());
+        let input = format!(
+            r#"{{"configYaml":"x","httpConfigYaml":"{}"}}"#,
+            "x".repeat(crate::http_processing::MAX_ADDENDUM + 1)
+        );
+        assert!(decode_update_input(&input).is_err());
+    }
 }
diff --git a/src/lib.rs b/src/lib.rs
index a798664..89660fa 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -18,52 +18,65 @@ pub mod error;
 #[cfg(feature = "ffi")]
 pub mod ffi;
 pub mod geodata;
+#[doc(hidden)]
+pub mod http_processing;
 pub mod inbound;
 #[cfg(feature = "invoke")]
 pub mod invoke;
 pub mod lifecycle;
 pub mod limits;
+#[cfg(any(
+    feature = "invoke",
+    feature = "inbound-http",
+    feature = "inbound-socks5",
+    test
+))]
+mod logging;
 pub mod outbound;
 pub mod packet;
 pub mod platform;
-#[cfg(any(feature = "tun", test))]
+mod process;
+#[cfg(any(feature = "tun", feature = "inbound-socks5", test))]
 mod quic_sniffer;
+pub(crate) mod resource;
 pub mod resources;
 pub mod routing;
 #[cfg(all(
     any(
+        feature = "outbound-http",
         feature = "outbound-anytls",
         feature = "outbound-socks5",
         feature = "outbound-shadowsocks",
         feature = "outbound-vless",
         feature = "outbound-trojan",
+        feature = "outbound-trusttunnel",
+        feature = "outbound-mieru",
+        feature = "outbound-masque",
         feature = "outbound-vmess",
         feature = "outbound-hysteria2",
-        feature = "outbound-tuic"
+        feature = "outbound-tuic",
+        feature = "outbound-wireguard"
     ),
     any(feature = "invoke", test)
 ))]
 mod runtime;
-#[cfg(any(
-    feature = "outbound-anytls",
-    feature = "outbound-vless",
-    feature = "stream-transport",
-    feature = "outbound-hysteria2",
-    feature = "outbound-tuic",
-    feature = "shadow-tls-v3"
-))]
 pub mod security;
 pub mod session;
+#[doc(hidden)]
+pub mod sniffing;
 #[cfg(any(
+    feature = "sing-mux",
     feature = "inbound-socks5",
+    feature = "outbound-mieru",
+    feature = "outbound-http",
     feature = "outbound-anytls",
     feature = "outbound-shadowsocks",
     feature = "outbound-socks5",
     feature = "outbound-trojan",
+    feature = "outbound-tuic",
     feature = "outbound-vless"
 ))]
 mod socks5;
-#[cfg(any(feature = "tun", test))]
 mod tcp_sniffer;
 #[cfg(any(
     feature = "inbound-http",
@@ -86,6 +99,8 @@ pub mod transport;
     )
 ))]
 mod tun_runtime;
+#[cfg(any(feature = "tun", feature = "inbound-socks5", test))]
+mod udp_sniffing;
 #[cfg(all(windows, feature = "windows-uwp"))]
 #[doc(hidden)]
 pub mod windows;
@@ -103,3 +118,6 @@ pub const ENGINE: &str = "rust";
 /// Implementation identity embedded in every native artifact.
 pub const BUILD_IDENTITY: &str =
     concat!("Vole;engine=rust;coreVersion=", env!("CARGO_PKG_VERSION"));
+
+mod connections;
+mod memory;
diff --git a/src/limits.rs b/src/limits.rs
index cbbec42..a4e5892 100644
--- a/src/limits.rs
+++ b/src/limits.rs
@@ -20,16 +20,26 @@ pub const XHTTP_CUSTOM_HEADERS: usize = 100;
 pub const XHTTP_PADDING_BYTES: usize = 4096;
 pub const XHTTP_POST_BYTES: usize = 16 * 1024 * 1024;
 pub const XHTTP_PACKET_BATCH_BYTES: usize = 64 * 1024;
+/// One HTTP/1 packet-up backing, including the in-flight body.
+pub const XHTTP_H1_PACKET_BATCH_BYTES: usize = 48 * 1024;
+/// One ordinary single-response H3 packet-up backing.
+pub const XHTTP_H3_SERIAL_PACKET_BATCH_BYTES: usize = 48 * 1024;
+/// One shared H3 packet-up backing, including the in-flight HTTP body.
+pub const XHTTP_H3_PACKET_BATCH_BYTES: usize = 128 * 1024;
 pub const XHTTP_REQUEST_BYTES: usize = 16 * 1024;
 pub const XHTTP_REQUEST_HEADERS: usize = 128;
 pub const XHTTP_IDLE_ENTRIES: usize = 64;
 pub const XHTTP_IDLE_H1_CONNECTIONS: usize = 4;
+pub const XHTTP_ACTIVE_H2_LEASES: usize = 4;
+pub const XHTTP_ACTIVE_H3_LEASES: usize = 4;
 pub const XHTTP_BODY_QUEUE: usize = 2;
 pub const XHTTP_BODY_CHUNK: usize = 16 * 1024;
 pub const XHTTP_H3_UNI_STREAMS: usize = 8;
 pub const XHTTP_H3_STREAM_WINDOW: usize = 64 * 1024;
 pub const XHTTP_H3_CONNECTION_WINDOW: usize = 128 * 1024;
 pub const XHTTP_H3_SEND_WINDOW: usize = 64 * 1024;
+/// Retained writes after a qualified physical connection's first local mux UDP association.
+pub const XHTTP_H3_UDP_SEND_WINDOW: usize = 192 * 1024;
 pub const SING_MUX_IDLE_CONNECTIONS: usize = 16;
 pub const SING_MUX_COMMAND_QUEUE: usize = 16;
 pub const SING_MUX_CHUNK: usize = 16 * 1024;
@@ -42,22 +52,23 @@ pub const YAMUX_CONNECTION_WINDOW: usize = YAMUX_CONNECTION_ADMISSIONS * 256 * 1
 /// Hysteria2 per-packet, per-association and per-connection retained bounds.
 pub const HY2_UDP_PAYLOAD: usize = 4096;
 pub const HY2_UDP_QUEUE: usize = 32;
+pub const HY2_SUBMISSION_QUEUE: usize = 32;
+pub const HY2_AUTH_SESSIONS: usize = 2;
 pub const HY2_PENDING_PACKETS: usize = 64;
 pub const HY2_PENDING_BYTES: usize = 256 * 1024;
 pub const HY2_FRAGMENT_TTL_SECONDS: usize = 5;
 pub const HY2_PATH_RETIRE_SECONDS: usize = 1;
 pub const HY2_QUIC_PAYLOAD: usize = 1400;
 pub const HY2_UNI_STREAMS: usize = 8;
-pub const HY2_STREAM_WINDOW: usize = 256 * 1024;
-pub const HY2_CONNECTION_WINDOW: usize = 1024 * 1024;
-pub const HY2_DATAGRAM_BUFFER: usize = 256 * 1024;
+pub const HY2_SEND_WINDOW: usize = 1024 * 1024;
+pub const HY2_DATAGRAM_SEND_BUFFER: usize = 4 * 1024 * 1024;
+pub const HY2_DATAGRAM_RECEIVE_BUFFER: usize = 2 * 1024 * 1024;
 pub const HY2_AUTH_HEADERS: usize = 16384;
 pub const HY2_RESPONSE_MESSAGE: usize = 2048;
 pub const HY2_RESPONSE_PADDING: usize = 4096;
 pub const TUIC_QUIC_PAYLOAD: usize = 1400;
-pub const TUIC_UNI_STREAMS: usize = 32;
-pub const TUIC_STREAM_WINDOW: usize = 256 * 1024;
-pub const TUIC_CONNECTION_WINDOW: usize = 1024 * 1024;
+pub const TUIC_CONTROL_READERS: usize = 32;
+pub const TUIC_SEND_WINDOW: usize = 1024 * 1024;
 pub const TUIC_DATAGRAM_BUFFER: usize = 256 * 1024;
 pub const TUIC_UDP_QUEUE: usize = 32;
 pub const TUIC_PENDING_PACKETS: usize = 64;
@@ -65,14 +76,11 @@ pub const TUIC_PENDING_BYTES: usize = 256 * 1024;
 pub const TUIC_FRAGMENT_TTL_SECONDS: usize = 5;
 pub const TUIC_FIN_GRACE_SECONDS: usize = 5;
 
-/// Historical iOS TUN footprint target retained for best-effort telemetry.
-///
-/// Crossing this value never changes a runtime lifecycle result.
-pub const IOS_TUN_PEAK_OBSERVATION_TARGET_BYTES: u64 = 45 * 1024 * 1024;
+/// Process observation ceiling, never lifecycle admission.
+pub const MEMORY_OBSERVATION_CEILING_BYTES: u64 = 45 * 1024 * 1024;
 
-/// Historical iOS TUN start-footprint target retained for best-effort
-/// telemetry. Crossing this value never prevents the runtime from starting.
-pub const IOS_TUN_START_OBSERVATION_TARGET_BYTES: u64 = 35 * 1024 * 1024;
+/// 1 Gbps process observation threshold, never lifecycle admission.
+pub const MEMORY_OBSERVATION_1GBPS_BYTES: u64 = 43 * 1024 * 1024;
 
 /// Fixed stack used by each bootstrap resolver worker.
 pub(crate) const DNS_WORKER_STACK_BYTES: usize = 512 * 1024;
@@ -82,7 +90,7 @@ pub(crate) const MAX_DNS_WORKERS: usize = 4;
 /// Unfinished physical socket setup jobs per lifecycle owner, shared by TCP
 /// and UDP. Callers wait for submission capacity; established connections are
 /// not counted and receive no business-concurrency quota.
-pub(crate) const MAX_SOCKET_INITIALIZATIONS: usize = 64;
+pub(crate) const MAX_SOCKET_INITIALIZATIONS: usize = 4;
 
 /// Retained-memory, queue and per-object safety boundaries.
 ///
@@ -100,7 +108,8 @@ pub struct ResourceLimits {
     /// Maximum raw IP packet accepted by a TUN netstack.
     pub tun_max_datagram_size: usize,
     pub tcp_buffer_per_direction: usize,
-    /// Retained A/AAAA cache entries. A and AAAA share this one capacity.
+    /// Explicit low-level DNS constructor override. Production sessions use
+    /// dns.cache-max-size for the shared typed/opaque result capacity instead.
     pub dns_address_cache_entries: usize,
     /// Retained address-to-domain hints used by redir-host routing.
     pub dns_redir_host_entries: usize,
@@ -128,7 +137,7 @@ impl Default for ResourceLimits {
             dns_address_cache_entries: 256,
             dns_redir_host_entries: 256,
             tun_udp_association_queue_capacity: 64,
-            tun_udp_response_queue_capacity: 4_096,
+            tun_udp_response_queue_capacity: 256,
             tun_dns_response_queue_capacity: 128,
             tls_buffer_limit: 64 * 1024,
             xhttp_send_buffer_size: 64 * 1024,
@@ -240,7 +249,7 @@ mod tests {
         assert_eq!(limits.dns_address_cache_entries, 256);
         assert_eq!(limits.dns_redir_host_entries, 256);
         assert_eq!(limits.tun_udp_association_queue_capacity, 64);
-        assert_eq!(limits.tun_udp_response_queue_capacity, 4_096);
+        assert_eq!(limits.tun_udp_response_queue_capacity, 256);
         assert_eq!(limits.tun_dns_response_queue_capacity, 128);
         assert_eq!(limits.tls_buffer_limit, 64 * 1024);
         assert_eq!(limits.xhttp_send_buffer_size, 64 * 1024);
diff --git a/src/logging.rs b/src/logging.rs
new file mode 100644
index 0000000..c26b817
--- /dev/null
+++ b/src/logging.rs
@@ -0,0 +1,428 @@
+//! Session-local levels and complete event payloads with bounded subscriptions.
+
+use crate::config::LogLevel;
+use std::{
+    fmt::Write as _,
+    sync::{
+        Arc, Mutex,
+        atomic::{AtomicU8, Ordering},
+    },
+};
+use tokio::sync::broadcast;
+use tracing::{
+    Dispatch, Event, Metadata, Subscriber,
+    field::{Field, Visit},
+    level_filters::LevelFilter,
+    span::{Attributes, Id, Record},
+    subscriber::Interest,
+};
+use tracing_core::span::Current;
+
+const LOG_CAPACITY: usize = 64;
+
+pub(crate) fn dispatch(level: LogLevel) -> Dispatch {
+    let (inner, logs) = tracing::dispatcher::get_default(|current| {
+        if let Some(filtered) = current.downcast_ref::<Filtered>() {
+            (filtered.inner.clone(), filtered.logs.clone())
+        } else {
+            (current.clone(), Arc::new(RuntimeLog::new(level)))
+        }
+    });
+    Dispatch::new(Filtered { inner, logs })
+}
+
+pub(crate) fn current() -> Option<Arc<RuntimeLog>> {
+    tracing::dispatcher::get_default(|current| {
+        current.downcast_ref::<Filtered>().map(|f| f.logs.clone())
+    })
+}
+
+fn number(level: LogLevel) -> u8 {
+    match level {
+        LogLevel::Silent => 0,
+        LogLevel::Error => 1,
+        LogLevel::Warning => 2,
+        LogLevel::Info => 3,
+        LogLevel::Debug => 4,
+    }
+}
+fn event_number(level: &tracing::Level) -> u8 {
+    match *level {
+        tracing::Level::ERROR => 1,
+        tracing::Level::WARN => 2,
+        tracing::Level::INFO => 3,
+        _ => 4,
+    }
+}
+pub(crate) struct RuntimeLog {
+    level: AtomicU8,
+    channel: Mutex<Option<broadcast::Sender<Arc<LogEvent>>>>,
+}
+impl RuntimeLog {
+    pub(crate) fn new(level: LogLevel) -> Self {
+        let logs = Self {
+            level: AtomicU8::new(0),
+            channel: Mutex::new(None),
+        };
+        logs.set_level(level);
+        logs
+    }
+    pub(crate) fn set_level(&self, level: LogLevel) {
+        self.level.store(number(level), Ordering::Relaxed);
+    }
+    pub(crate) fn level(&self) -> LogLevel {
+        match self.level.load(Ordering::Relaxed) {
+            0 => LogLevel::Silent,
+            1 => LogLevel::Error,
+            2 => LogLevel::Warning,
+            3 => LogLevel::Info,
+            _ => LogLevel::Debug,
+        }
+    }
+    fn enabled(&self, metadata: &Metadata<'_>) -> bool {
+        event_number(metadata.level()) <= number(self.level())
+    }
+    fn has_subscribers(&self) -> bool {
+        self.channel
+            .lock()
+            .unwrap()
+            .as_ref()
+            .is_some_and(|sender| sender.receiver_count() != 0)
+    }
+    pub(crate) fn subscribe(self: &Arc<Self>) -> LogSubscription {
+        let mut channel = self.channel.lock().unwrap();
+        let receiver = channel
+            .get_or_insert_with(|| broadcast::channel(LOG_CAPACITY).0)
+            .subscribe();
+        LogSubscription {
+            logs: self.clone(),
+            receiver: Some(receiver),
+        }
+    }
+    fn event(&self, event: &Event<'_>) {
+        if !self.has_subscribers() {
+            return;
+        }
+        let value = Arc::new(LogEvent {
+            level: event_number(event.metadata().level()),
+            payload: format_event(event),
+            time: time::OffsetDateTime::now_utc(),
+        });
+        if let Some(sender) = self.channel.lock().unwrap().as_ref() {
+            let _ = sender.send(value);
+        }
+    }
+}
+pub(crate) struct LogSubscription {
+    logs: Arc<RuntimeLog>,
+    receiver: Option<broadcast::Receiver<Arc<LogEvent>>>,
+}
+impl LogSubscription {
+    pub(crate) async fn recv(&mut self) -> Option<Arc<LogEvent>> {
+        loop {
+            match self.receiver.as_mut()?.recv().await {
+                Ok(event) => return Some(event),
+                Err(broadcast::error::RecvError::Lagged(_)) => continue,
+                Err(broadcast::error::RecvError::Closed) => return None,
+            }
+        }
+    }
+}
+impl Drop for LogSubscription {
+    fn drop(&mut self) {
+        self.receiver.take();
+        let mut channel = self.logs.channel.lock().unwrap();
+        if channel
+            .as_ref()
+            .is_some_and(|sender| sender.receiver_count() == 0)
+        {
+            *channel = None;
+        }
+    }
+}
+pub(crate) struct LogEvent {
+    level: u8,
+    payload: String,
+    time: time::OffsetDateTime,
+}
+impl LogEvent {
+    pub(crate) fn matches(&self, level: LogLevel) -> bool {
+        self.level <= number(level)
+    }
+    pub(crate) fn json(&self, structured: bool) -> serde_json::Value {
+        let level = match self.level {
+            1 => "error",
+            2 => "warning",
+            3 => "info",
+            _ => "debug",
+        };
+        if structured {
+            serde_json::json!({"time":format!("{:02}:{:02}:{:02}",self.time.hour(),self.time.minute(),self.time.second()),"level":if level == "warning" { "warn" } else { level },"message":self.payload,"fields":[]})
+        } else {
+            serde_json::json!({"type":level,"payload":self.payload})
+        }
+    }
+}
+pub(crate) fn format_event(event: &Event<'_>) -> String {
+    let mut fields = EventFields {
+        payload: event.metadata().target().to_owned(),
+    };
+    event.record(&mut fields);
+    fields.payload
+}
+
+struct EventFields {
+    payload: String,
+}
+impl Visit for EventFields {
+    fn record_str(&mut self, field: &Field, value: &str) {
+        let _ = write!(self.payload, " {}={value}", field.name());
+    }
+
+    fn record_debug(&mut self, field: &Field, value: &dyn std::fmt::Debug) {
+        let _ = write!(self.payload, " {}={value:?}", field.name());
+    }
+}
+struct Filtered {
+    inner: Dispatch,
+    logs: Arc<RuntimeLog>,
+}
+impl Subscriber for Filtered {
+    fn enabled(&self, metadata: &Metadata<'_>) -> bool {
+        self.logs.enabled(metadata) && (self.inner.enabled(metadata) || self.logs.has_subscribers())
+    }
+    fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest {
+        let _ = self.inner.register_callsite(metadata);
+        Interest::sometimes()
+    }
+    fn max_level_hint(&self) -> Option<LevelFilter> {
+        Some(LevelFilter::TRACE)
+    }
+    fn new_span(&self, attrs: &Attributes<'_>) -> Id {
+        self.inner.new_span(attrs)
+    }
+    fn record(&self, span: &Id, values: &Record<'_>) {
+        self.inner.record(span, values);
+    }
+    fn record_follows_from(&self, span: &Id, follows: &Id) {
+        self.inner.record_follows_from(span, follows);
+    }
+    fn event(&self, event: &Event<'_>) {
+        if self.logs.enabled(event.metadata()) {
+            if self.inner.enabled(event.metadata()) {
+                self.inner.event(event);
+            }
+            self.logs.event(event);
+        }
+    }
+    fn enter(&self, span: &Id) {
+        self.inner.enter(span);
+    }
+    fn exit(&self, span: &Id) {
+        self.inner.exit(span);
+    }
+    fn clone_span(&self, span: &Id) -> Id {
+        self.inner.clone_span(span)
+    }
+    fn try_close(&self, span: Id) -> bool {
+        self.inner.try_close(span)
+    }
+    fn current_span(&self) -> Current {
+        self.inner.current_span()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::{
+        Arc,
+        atomic::{AtomicUsize, Ordering},
+    };
+    use tracing::instrument::WithSubscriber;
+
+    struct Counter(Arc<AtomicUsize>);
+    impl Subscriber for Counter {
+        fn enabled(&self, _: &Metadata<'_>) -> bool {
+            true
+        }
+        fn new_span(&self, _: &Attributes<'_>) -> Id {
+            Id::from_u64(1)
+        }
+        fn record(&self, _: &Id, _: &Record<'_>) {}
+        fn record_follows_from(&self, _: &Id, _: &Id) {}
+        fn event(&self, _: &Event<'_>) {
+            self.0.fetch_add(1, Ordering::Relaxed);
+        }
+        fn enter(&self, _: &Id) {}
+        fn exit(&self, _: &Id) {}
+    }
+
+    #[tokio::test]
+    async fn runtime_level_follows_spawned_work_without_changing_host_logging() {
+        for (level, expected) in [
+            (LogLevel::Info, 3),
+            (LogLevel::Warning, 2),
+            (LogLevel::Error, 1),
+            (LogLevel::Silent, 0),
+            (LogLevel::Debug, 5),
+        ] {
+            let count = Arc::new(AtomicUsize::new(0));
+            let host = Dispatch::new(Counter(count.clone()));
+            let filtered = tracing::dispatcher::with_default(&host, || dispatch(level));
+            async {
+                crate::resources::observation::spawn(async {
+                    tracing::trace!(target:"external", "trace");
+                    tracing::debug!("debug");
+                    tracing::info!("info");
+                    tracing::warn!("warning");
+                    tracing::error!("error");
+                })
+                .await
+                .unwrap();
+            }
+            .with_subscriber(filtered)
+            .await;
+            assert_eq!(count.load(Ordering::Relaxed), expected);
+            tracing::dispatcher::with_default(&host, || {
+                tracing::debug!("host logging remains active")
+            });
+            assert_eq!(count.load(Ordering::Relaxed), expected + 1);
+        }
+    }
+
+    #[test]
+    fn controller_without_subscribers_does_not_format_event_fields() {
+        struct FormattingProbe(Arc<AtomicUsize>);
+        impl std::fmt::Debug for FormattingProbe {
+            fn fmt(&self, output: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                self.0.fetch_add(1, Ordering::Relaxed);
+                output.write_str("synthetic field")
+            }
+        }
+        let formats = Arc::new(AtomicUsize::new(0));
+        let host_events = Arc::new(AtomicUsize::new(0));
+        let logs = Arc::new(RuntimeLog::new(LogLevel::Info));
+        let filtered = Dispatch::new(Filtered {
+            inner: Dispatch::new(Counter(host_events.clone())),
+            logs: logs.clone(),
+        });
+        tracing::dispatcher::with_default(&filtered, || {
+            tracing::info!(target: "external", data = ?FormattingProbe(formats.clone()));
+        });
+        assert_eq!(host_events.load(Ordering::Relaxed), 1);
+        assert_eq!(formats.load(Ordering::Relaxed), 0);
+        assert!(logs.channel.lock().unwrap().is_none());
+    }
+
+    #[test]
+    fn controller_logs_preserve_complete_events_without_content_or_rate_filters() {
+        let logs = Arc::new(RuntimeLog::new(LogLevel::Info));
+        let filtered = Dispatch::new(Filtered {
+            inner: Dispatch::none(),
+            logs: logs.clone(),
+        });
+        assert!(!logs.has_subscribers());
+        tracing::dispatcher::with_default(&filtered, || {
+            tracing::info!(target:"vole::controller", bytes=1, secret="never-publish", "private target");
+        });
+        assert!(logs.channel.lock().unwrap().is_none());
+        let mut subscription = logs.subscribe();
+        const TARGET: &str = concat!(
+            "external::",
+            "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz",
+            "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz",
+        );
+        let message = "完整信息😀\n\t".repeat(200);
+        let error = std::io::Error::other("synthetic error details");
+        tracing::dispatcher::with_default(&filtered, || {
+            tracing::info!(target: TARGET,
+                bytes = 17_u64,
+                unknown_count = -9_i64,
+                ratio = 1.25_f64,
+                active = true,
+                destination = "synthetic.invalid",
+                token = "synthetic-token",
+                details = ?vec![1, 2, 3],
+                error = &error as &(dyn std::error::Error + 'static),
+                "{message}"
+            );
+        });
+        let event = subscription.receiver.as_mut().unwrap().try_recv().unwrap();
+        let value = event.json(false);
+        let payload = value["payload"].as_str().unwrap();
+        assert!(payload.starts_with(TARGET));
+        for content in [
+            "bytes=17",
+            "unknown_count=-9",
+            "ratio=1.25",
+            "active=true",
+            "synthetic.invalid",
+            "synthetic-token",
+            "[1, 2, 3]",
+            "synthetic error details",
+            "destination",
+            "error",
+        ] {
+            assert!(payload.contains(content), "missing {content}");
+        }
+        assert!(payload.contains(&message));
+        assert_eq!(event.json(true)["message"], payload);
+        logs.set_level(LogLevel::Error);
+        tracing::dispatcher::with_default(
+            &filtered,
+            || tracing::info!(target:"vole::controller",bytes=3),
+        );
+        assert!(subscription.receiver.as_mut().unwrap().try_recv().is_err());
+        logs.set_level(LogLevel::Debug);
+        tracing::dispatcher::with_default(
+            &filtered,
+            || tracing::debug!(target:"vole::controller",bytes=4),
+        );
+        assert!(
+            subscription
+                .receiver
+                .as_mut()
+                .unwrap()
+                .try_recv()
+                .unwrap()
+                .payload
+                .contains("bytes=4")
+        );
+        for _ in 0..128 {
+            tracing::dispatcher::with_default(
+                &filtered,
+                || tracing::info!(target:"external",bytes=1),
+            );
+            assert!(subscription.receiver.as_mut().unwrap().try_recv().is_ok());
+        }
+        for _ in 0..128 {
+            tracing::dispatcher::with_default(
+                &filtered,
+                || tracing::info!(target:"external",bytes=1),
+            );
+        }
+        assert_eq!(
+            logs.channel.lock().unwrap().as_ref().unwrap().len(),
+            LOG_CAPACITY
+        );
+        assert!(matches!(
+            subscription.receiver.as_mut().unwrap().try_recv(),
+            Err(broadcast::error::TryRecvError::Lagged(64))
+        ));
+        drop(subscription);
+        assert!(logs.channel.lock().unwrap().is_none());
+    }
+
+    #[test]
+    fn nested_runtime_dispatch_reuses_one_log_bus_and_mutable_filter() {
+        let filtered = dispatch(LogLevel::Warning);
+        let first = tracing::dispatcher::with_default(&filtered, || current().unwrap());
+        let nested = tracing::dispatcher::with_default(&filtered, || dispatch(LogLevel::Debug));
+        let next = tracing::dispatcher::with_default(&nested, || current().unwrap());
+        assert!(Arc::ptr_eq(&first, &next));
+        assert_eq!(next.level(), LogLevel::Warning);
+        next.set_level(LogLevel::Debug);
+        assert_eq!(first.level(), LogLevel::Debug);
+    }
+}
diff --git a/src/memory.rs b/src/memory.rs
new file mode 100644
index 0000000..d357859
--- /dev/null
+++ b/src/memory.rs
@@ -0,0 +1,105 @@
+//! Current-process memory only, sampled on an explicit Controller request.
+
+/// Resident bytes, or unavailable. No process enumeration or retained history.
+pub(crate) fn resident_bytes() -> Option<u64> {
+    platform_resident_bytes()
+}
+
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn platform_resident_bytes() -> Option<u64> {
+    use std::io::Read;
+    let mut data = String::new();
+    std::fs::File::open("/proc/self/status")
+        .ok()?
+        .take(16 * 1024)
+        .read_to_string(&mut data)
+        .ok()?;
+    let line = data.lines().find_map(|line| line.strip_prefix("VmRSS:"))?;
+    let mut fields = line.split_whitespace();
+    let bytes = fields.next()?.parse::<u64>().ok()?.checked_mul(1024)?;
+    (fields.next()? == "kB").then_some(bytes)
+}
+
+#[cfg(target_vendor = "apple")]
+fn platform_resident_bytes() -> Option<u64> {
+    // MACH_TASK_BASIC_INFO is the public 64-bit ABI on all Apple targets.
+    #[repr(C)]
+    struct BasicInfo {
+        virtual_size: u64,
+        resident_size: u64,
+        resident_size_max: u64,
+        user_time: [i32; 2],
+        system_time: [i32; 2],
+        policy: i32,
+        suspend_count: i32,
+    }
+    unsafe extern "C" {
+        static mach_task_self_: libc::mach_port_t;
+    }
+    let mut info = std::mem::MaybeUninit::<BasicInfo>::zeroed();
+    let expected = (std::mem::size_of::<BasicInfo>() / std::mem::size_of::<u32>()) as u32;
+    let mut count = expected;
+    // SAFETY: our own task port, correctly sized/aligned writable ABI storage.
+    let result =
+        unsafe { libc::task_info(mach_task_self_, 20, info.as_mut_ptr().cast(), &mut count) };
+    if result != 0 || count != expected {
+        return None;
+    }
+    // SAFETY: successful task_info initialized the full verified ABI structure.
+    Some(unsafe { info.assume_init() }.resident_size)
+}
+
+#[cfg(windows)]
+fn platform_resident_bytes() -> Option<u64> {
+    use std::ffi::c_void;
+    #[repr(C)]
+    struct Counters {
+        size: u32,
+        page_fault_count: u32,
+        peak_working_set: usize,
+        working_set: usize,
+        quota_peak_paged_pool: usize,
+        quota_paged_pool: usize,
+        quota_peak_non_paged_pool: usize,
+        quota_non_paged_pool: usize,
+        pagefile: usize,
+        peak_pagefile: usize,
+    }
+    #[link(name = "kernel32")]
+    unsafe extern "system" {
+        fn GetCurrentProcess() -> *mut c_void;
+        fn K32GetProcessMemoryInfo(process: *mut c_void, counters: *mut Counters, size: u32)
+        -> i32;
+    }
+    let mut counters = std::mem::MaybeUninit::<Counters>::zeroed();
+    let size = std::mem::size_of::<Counters>() as u32;
+    // SAFETY: own pseudo-handle; the API writes to the supplied sized structure.
+    unsafe { (*counters.as_mut_ptr()).size = size };
+    // SAFETY: no external PID or handle lifetime; valid initialized ABI storage.
+    let result =
+        unsafe { K32GetProcessMemoryInfo(GetCurrentProcess(), counters.as_mut_ptr(), size) };
+    if result == 0 {
+        return None;
+    }
+    // SAFETY: the successful API call populated this structure.
+    u64::try_from(unsafe { counters.assume_init() }.working_set).ok()
+}
+
+#[cfg(not(any(
+    target_os = "linux",
+    target_os = "android",
+    target_vendor = "apple",
+    windows
+)))]
+fn platform_resident_bytes() -> Option<u64> {
+    None
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    #[cfg(any(target_os = "linux", target_vendor = "apple"))]
+    fn current_process_has_resident_memory() {
+        assert!(super::resident_bytes().is_some_and(|bytes| bytes > 0));
+    }
+}
diff --git a/src/outbound/anytls/client.rs b/src/outbound/anytls/client.rs
index b722aed..5dba0c6 100644
--- a/src/outbound/anytls/client.rs
+++ b/src/outbound/anytls/client.rs
@@ -26,9 +26,6 @@ use super::{
 };
 use crate::outbound::uot::UotTransport;
 
-const IDLE_CHECK_INTERVAL: Duration = Duration::from_secs(30);
-const IDLE_TIMEOUT: Duration = Duration::from_secs(30);
-
 #[async_trait]
 pub(crate) trait SessionDialer: Send + Sync {
     async fn connect(
@@ -56,6 +53,7 @@ pub(crate) struct AnyTlsClient {
     state: Mutex<ClientState>,
     cancellation: CancellationToken,
     tasks: TaskTracker,
+    options: crate::config::AnyTlsSessionOptions,
 }
 
 impl std::fmt::Debug for AnyTlsClient {
@@ -75,11 +73,33 @@ impl std::fmt::Debug for AnyTlsClient {
 }
 
 impl AnyTlsClient {
+    #[cfg(test)]
     pub(crate) fn new(
         dialer: Arc<dyn SessionDialer>,
         password: &str,
         stream_buffer_capacity: usize,
     ) -> io::Result<Arc<Self>> {
+        Self::with_options(dialer, password, stream_buffer_capacity, Default::default())
+    }
+
+    pub(crate) fn with_options(
+        dialer: Arc<dyn SessionDialer>,
+        password: &str,
+        stream_buffer_capacity: usize,
+        options: crate::config::AnyTlsSessionOptions,
+    ) -> io::Result<Arc<Self>> {
+        if options.check_interval.is_zero()
+            || std::time::Instant::now()
+                .checked_add(options.check_interval)
+                .is_none()
+            || options.client_metadata.contains('\n')
+            || options.client_metadata.len() > usize::from(u16::MAX) - 80
+        {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "invalid AnyTLS session options",
+            ));
+        }
         if password.is_empty() || password.len() > 1_024 {
             return Err(io::Error::new(
                 io::ErrorKind::InvalidInput,
@@ -105,6 +125,7 @@ impl AnyTlsClient {
             state: Mutex::new(ClientState::default()),
             cancellation: CancellationToken::new(),
             tasks: TaskTracker::new(),
+            options,
         });
         Ok(client)
     }
@@ -153,6 +174,7 @@ impl AnyTlsClient {
                     padding_snapshot,
                     self.padding.clone(),
                     target,
+                    &self.options.client_metadata,
                     self.max_stream_chunk,
                     self.incoming_capacity,
                     &self.cancellation,
@@ -212,6 +234,9 @@ impl AnyTlsClient {
     }
 
     fn take_idle(&self) -> Option<Arc<Session>> {
+        if self.options.disable_reuse {
+            return None;
+        }
         let mut state = self
             .state
             .lock()
@@ -234,7 +259,7 @@ impl AnyTlsClient {
                 .state
                 .lock()
                 .unwrap_or_else(std::sync::PoisonError::into_inner);
-            if state.closed || session.is_closed() {
+            if state.closed || session.is_closed() || self.options.disable_reuse {
                 close = true;
             } else if state.sessions.contains_key(&session.sequence()) {
                 state
@@ -292,7 +317,7 @@ impl AnyTlsClient {
         if state.closed {
             return Err(DispatchError::Other("AnyTLS client is closed".to_owned()));
         }
-        if !state.cleanup_started {
+        if !self.options.disable_reuse && !state.cleanup_started {
             // Graph construction must not leave a task behind on a later
             // constructor/bind failure. Start only when traffic first uses
             // this node, under the same lock as the shutdown admission gate.
@@ -301,6 +326,7 @@ impl AnyTlsClient {
                 .spawn(crate::resources::observation::task(cleanup_idle(
                     Arc::downgrade(self),
                     self.cancellation.clone(),
+                    self.options.check_interval,
                 )));
         }
         Ok(())
@@ -312,8 +338,16 @@ impl AnyTlsClient {
             .lock()
             .unwrap_or_else(std::sync::PoisonError::into_inner);
         let mut expired_sequences = Vec::new();
-        for (&sequence, &idle_since) in &state.idle {
-            if now.duration_since(idle_since) >= IDLE_TIMEOUT {
+        let mut retained = 0_usize;
+        for (&sequence, idle_since) in state.idle.iter_mut().rev() {
+            // The newest sessions are considered first. Only already idle
+            // sessions count toward the minimum; this never opens a socket.
+            if now.saturating_duration_since(*idle_since) <= self.options.idle_timeout {
+                retained += 1;
+            } else if retained < self.options.min_idle {
+                *idle_since = now;
+                retained += 1;
+            } else {
                 expired_sequences.push(sequence);
             }
         }
@@ -341,8 +375,12 @@ impl Drop for AnyTlsClient {
     }
 }
 
-async fn cleanup_idle(client: Weak<AnyTlsClient>, cancellation: CancellationToken) {
-    let mut interval = tokio::time::interval(IDLE_CHECK_INTERVAL);
+async fn cleanup_idle(
+    client: Weak<AnyTlsClient>,
+    cancellation: CancellationToken,
+    period: Duration,
+) {
+    let mut interval = tokio::time::interval(period);
     interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
     interval.tick().await;
     loop {
@@ -567,6 +605,7 @@ mod tests {
 
     fn stream_session() -> StreamSession {
         StreamSession {
+            metadata: Default::default(),
             inbound: InboundKind::Http,
             source: "127.0.0.1:12000".parse().unwrap(),
             destination: Destination::domain("target.example", 443).unwrap(),
@@ -645,7 +684,7 @@ mod tests {
         }
         let first = DuplexDialer::new(ServerMode::V2);
         let second = DuplexDialer::new(ServerMode::V2);
-        let selection = Arc::new(AtomicUsize::new(0));
+        let selection = Arc::new(crate::routing::GroupSelection::new(0));
         let group = Arc::new(SelectUpstream::new(
             selection.clone(),
             vec![
@@ -655,6 +694,7 @@ mod tests {
         ));
         let client = AnyTlsClient::new(
             Arc::new(GroupDialer(UpstreamPath::Group {
+                server: crate::session::Destination::domain("server.example", 443).unwrap(),
                 group,
                 endpoint: None,
                 dialer: Dialer::default(),
@@ -701,6 +741,125 @@ mod tests {
         client.shutdown().await;
     }
 
+    #[tokio::test]
+    async fn idle_minimum_keeps_newest_existing_sessions_without_dialing() {
+        let dialer = DuplexDialer::new(ServerMode::V2);
+        let client = AnyTlsClient::with_options(
+            dialer.clone(),
+            "password",
+            1024,
+            crate::config::AnyTlsSessionOptions {
+                min_idle: 1,
+                idle_timeout: Duration::from_secs(6),
+                ..Default::default()
+            },
+        )
+        .unwrap();
+        let mut streams = Vec::new();
+        for _ in 0..3 {
+            let mut stream = open_stream(&client).await.unwrap();
+            wait_until_ready(&mut stream).await;
+            streams.push(stream);
+        }
+        for stream in &mut streams {
+            stream.shutdown().await.unwrap();
+        }
+        let now = tokio::time::Instant::now() + Duration::from_secs(7);
+        let expired = client.expire_idle(now);
+        assert_eq!(
+            expired.iter().map(|s| s.sequence()).collect::<Vec<_>>(),
+            [2, 1]
+        );
+        {
+            let state = client.state.lock().unwrap();
+            assert_eq!(state.idle.keys().copied().collect::<Vec<_>>(), [3]);
+            assert_eq!(state.idle[&3], now);
+        }
+        for session in expired {
+            session.begin_shutdown();
+        }
+        let mut reused = open_stream(&client).await.unwrap();
+        assert_eq!(dialer.connection_count(), 3);
+        reused.shutdown().await.unwrap();
+        client.shutdown().await;
+        assert!(client.tasks.is_empty());
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn configured_idle_check_interval_drives_actual_session_reaping() {
+        for seconds in [11_u64, 17] {
+            let config = crate::config::Config::parse_yaml(
+                format!(
+                    "mixed-port: 1080\nproxies: [{{name: node, type: anytls, server: tls.example, port: 443, password: fixture, idle-session-check-interval: {seconds}, idle-session-timeout: 6}}]"
+                )
+                .as_bytes(),
+            )
+            .unwrap();
+            let crate::config::ProxyProtocol::AnyTls(node) = &config.proxies[0].protocol else {
+                panic!("expected AnyTLS");
+            };
+            let dialer = DuplexDialer::new(ServerMode::V2);
+            let client = AnyTlsClient::with_options(
+                dialer.clone(),
+                &node.password,
+                1024,
+                node.session.clone(),
+            )
+            .unwrap();
+            let mut stream = open_stream(&client).await.unwrap();
+            wait_until_ready(&mut stream).await;
+            stream.shutdown().await.unwrap();
+            let session = client.state.lock().unwrap().sessions[&1].clone();
+            tokio::time::advance(Duration::from_secs(seconds - 1)).await;
+            tokio::task::yield_now().await;
+            assert!(
+                !session.is_closed(),
+                "the expired idle session must wait for the configured check"
+            );
+            tokio::time::advance(Duration::from_secs(1)).await;
+            for _ in 0..8 {
+                tokio::task::yield_now().await;
+            }
+            assert!(
+                session.is_closed(),
+                "the scheduled worker closes the session"
+            );
+            let mut fresh = open_stream(&client).await.unwrap();
+            wait_until_ready(&mut fresh).await;
+            assert_eq!(dialer.connection_count(), 2);
+            fresh.shutdown().await.unwrap();
+            client.shutdown().await;
+            assert!(client.tasks.is_empty());
+        }
+    }
+
+    #[tokio::test]
+    async fn disabled_reuse_closes_sessions_and_never_starts_idle_worker() {
+        let dialer = DuplexDialer::new(ServerMode::V2);
+        let client = AnyTlsClient::with_options(
+            dialer.clone(),
+            "password",
+            1024,
+            crate::config::AnyTlsSessionOptions {
+                disable_reuse: true,
+                ..Default::default()
+            },
+        )
+        .unwrap();
+        for _ in 0..2 {
+            let mut stream = open_stream(&client).await.unwrap();
+            wait_until_ready(&mut stream).await;
+            stream.shutdown().await.unwrap();
+            let state = client.state.lock().unwrap();
+            assert!(state.idle.is_empty());
+            assert!(!state.cleanup_started);
+        }
+        assert_eq!(dialer.connection_count(), 2);
+        client.shutdown().await;
+        assert!(client.tasks.is_empty());
+        assert!(client.state.lock().unwrap().sessions.is_empty());
+    }
+
     #[test]
     fn unused_client_needs_no_runtime_and_leaves_no_background_task() {
         let client =
@@ -726,7 +885,12 @@ mod tests {
                 .expire_idle(idle_since + Duration::from_secs(29))
                 .is_empty()
         );
-        let expired = client.expire_idle(idle_since + Duration::from_secs(30));
+        assert!(
+            client
+                .expire_idle(idle_since + Duration::from_secs(30))
+                .is_empty()
+        );
+        let expired = client.expire_idle(idle_since + Duration::from_secs(31));
         assert_eq!(expired.len(), 1);
         for session in expired {
             session.begin_shutdown();
@@ -736,7 +900,7 @@ mod tests {
         fresh.shutdown().await.unwrap();
         client.shutdown().await;
         assert!(client.tasks.is_empty());
-        assert_eq!(IDLE_CHECK_INTERVAL, Duration::from_secs(30));
+        assert_eq!(client.options.check_interval, Duration::from_secs(30));
     }
 
     #[tokio::test]
diff --git a/src/outbound/anytls/mod.rs b/src/outbound/anytls/mod.rs
index 689fcb5..a2a4847 100644
--- a/src/outbound/anytls/mod.rs
+++ b/src/outbound/anytls/mod.rs
@@ -24,6 +24,13 @@ pub use stream::AnyTlsStream;
 #[async_trait]
 pub trait AnyTlsTlsConnector: Send + Sync {
     async fn connect(&self, stream: BoxStream) -> io::Result<BoxStream>;
+    async fn connect_with_context(
+        &self,
+        stream: BoxStream,
+        _context: &EstablishContext,
+    ) -> io::Result<BoxStream> {
+        self.connect(stream).await
+    }
 }
 
 #[async_trait]
@@ -31,6 +38,27 @@ impl AnyTlsTlsConnector for crate::security::StandardTlsClient {
     async fn connect(&self, stream: BoxStream) -> io::Result<BoxStream> {
         crate::security::StandardTlsClient::connect(self, stream).await
     }
+    async fn connect_with_context(
+        &self,
+        stream: BoxStream,
+        context: &EstablishContext,
+    ) -> io::Result<BoxStream> {
+        crate::security::StandardTlsClient::connect_with_context(self, stream, context).await
+    }
+}
+
+#[async_trait]
+impl AnyTlsTlsConnector for crate::security::SecurityClient {
+    async fn connect(&self, stream: BoxStream) -> io::Result<BoxStream> {
+        crate::security::SecurityClient::connect(self, stream).await
+    }
+    async fn connect_with_context(
+        &self,
+        stream: BoxStream,
+        context: &EstablishContext,
+    ) -> io::Result<BoxStream> {
+        crate::security::SecurityClient::connect_with_context(self, stream, context).await
+    }
 }
 
 struct OutboundSessionDialer {
@@ -51,7 +79,10 @@ impl SessionDialer for OutboundSessionDialer {
             .connect_server(session, &self.server, context)
             .await?;
         context
-            .run_io("AnyTLS TLS handshake", self.tls.connect(raw.io))
+            .run_io(
+                "AnyTLS TLS handshake",
+                self.tls.connect_with_context(raw.io, context),
+            )
             .await
     }
 }
@@ -100,6 +131,24 @@ impl AnyTlsOutbound {
         password: impl Into<String>,
         tls: Arc<dyn AnyTlsTlsConnector>,
         stream_buffer_capacity: usize,
+    ) -> io::Result<Self> {
+        Self::with_session_options(
+            server,
+            upstream,
+            password,
+            tls,
+            stream_buffer_capacity,
+            crate::config::AnyTlsSessionOptions::default(),
+        )
+    }
+
+    pub fn with_session_options(
+        server: Destination,
+        upstream: UpstreamPath,
+        password: impl Into<String>,
+        tls: Arc<dyn AnyTlsTlsConnector>,
+        stream_buffer_capacity: usize,
+        options: crate::config::AnyTlsSessionOptions,
     ) -> io::Result<Self> {
         if server.port() == 0 {
             return Err(io::Error::new(
@@ -114,7 +163,7 @@ impl AnyTlsOutbound {
         });
         let password = password.into();
         Ok(Self {
-            client: AnyTlsClient::new(dialer, &password, stream_buffer_capacity)?,
+            client: AnyTlsClient::with_options(dialer, &password, stream_buffer_capacity, options)?,
         })
     }
 
@@ -157,6 +206,7 @@ impl OutboundConnector for AnyTlsOutbound {
         context: &EstablishContext,
     ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
         let stream_session = StreamSession {
+            metadata: request.session.metadata.clone(),
             inbound: request.session.inbound,
             source: request.session.source,
             destination: magic_destination(),
diff --git a/src/outbound/anytls/session.rs b/src/outbound/anytls/session.rs
index fd75526..b01a3db 100644
--- a/src/outbound/anytls/session.rs
+++ b/src/outbound/anytls/session.rs
@@ -165,6 +165,7 @@ impl Session {
         padding_snapshot: Arc<PaddingScheme>,
         client_padding: Arc<ArcSwap<PaddingScheme>>,
         target: &Destination,
+        client_metadata: &str,
         max_stream_chunk: usize,
         incoming_capacity: usize,
         parent_cancellation: &CancellationToken,
@@ -177,7 +178,7 @@ impl Session {
         transport.write_all(&authentication).await?;
         transport.flush().await?;
 
-        let first_batch = first_stream_batch(&padding_snapshot, target)?;
+        let first_batch = first_stream_batch(&padding_snapshot, target, client_metadata)?;
         write_packet(&mut transport, &padding_snapshot, 1, &first_batch).await?;
 
         let (writer, writer_receiver) = mpsc::channel(WRITER_QUEUE_CAPACITY);
@@ -814,8 +815,15 @@ fn make_active_stream(
     )
 }
 
-fn first_stream_batch(padding: &PaddingScheme, target: &Destination) -> io::Result<Bytes> {
-    let settings = format!("v=2\npadding-md5={}", padding.md5_hex());
+fn first_stream_batch(
+    padding: &PaddingScheme,
+    target: &Destination,
+    client_metadata: &str,
+) -> io::Result<Bytes> {
+    let settings = format!(
+        "v=2\nclient={client_metadata}\npadding-md5={}",
+        padding.md5_hex()
+    );
     let target = encoded_target(target)?;
     encode_batch(&[
         Frame::with_payload(Command::Settings, 0, Bytes::from(settings))?,
@@ -939,6 +947,7 @@ mod tests {
                 padding.clone(),
                 Arc::new(ArcSwap::new(padding)),
                 &Destination::domain("target.example", 443).unwrap(),
+                "",
                 1024,
                 1,
                 &CancellationToken::new(),
@@ -999,7 +1008,7 @@ mod tests {
     async fn initial_batches_keep_settings_before_stream_open_and_target() {
         let target = Destination::domain("target.example", 443).unwrap();
         let padding = PaddingScheme::default_scheme();
-        let batch = first_stream_batch(&padding, &target).unwrap();
+        let batch = first_stream_batch(&padding, &target, "test=metadata").unwrap();
         let mut input = std::io::Cursor::new(batch);
         let settings = read_frame(&mut input).await.unwrap();
         let syn = read_frame(&mut input).await.unwrap();
@@ -1008,7 +1017,11 @@ mod tests {
         assert_eq!(settings.stream_id, 0);
         assert_eq!(
             settings.payload.as_ref(),
-            format!("v=2\npadding-md5={}", padding.md5_hex()).as_bytes()
+            format!(
+                "v=2\nclient=test=metadata\npadding-md5={}",
+                padding.md5_hex()
+            )
+            .as_bytes()
         );
         assert_eq!(syn, Frame::empty(Command::Syn, 1));
         assert_eq!(target_frame.command, Command::Push);
diff --git a/src/outbound/connector.rs b/src/outbound/connector.rs
index ac845ba..3752b86 100644
--- a/src/outbound/connector.rs
+++ b/src/outbound/connector.rs
@@ -1,13 +1,13 @@
+use crate::routing::GroupSelection;
+#[cfg(test)]
+use std::sync::atomic::{AtomicUsize, Ordering};
 use std::{
     collections::HashMap,
     fmt::{self, Write as _},
     future::Future,
     io,
-    net::IpAddr,
-    sync::{
-        Arc, Mutex,
-        atomic::{AtomicUsize, Ordering},
-    },
+    net::{IpAddr, SocketAddr},
+    sync::{Arc, Mutex},
     time::Duration,
 };
 
@@ -210,9 +210,15 @@ pub struct EstablishContext {
     deadline: Instant,
     resolution: ResolutionContext,
     selections: Arc<Mutex<SelectionSnapshot>>,
+    inbound: crate::session::InboundMetadata,
+    source: Option<SocketAddr>,
+    #[cfg(all(target_os = "linux", feature = "sing-mux"))]
+    tcp_control: Option<crate::dialer::tcp_control::Capture>,
+    #[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+    h3_udp: Option<crate::transport::xhttp::UdpAssociationCapture>,
 }
 
-type SelectionSnapshot = HashMap<usize, (Arc<AtomicUsize>, usize)>;
+type SelectionSnapshot = HashMap<usize, (Arc<GroupSelection>, usize)>;
 
 impl EstablishContext {
     #[must_use]
@@ -226,9 +232,128 @@ impl EstablishContext {
             deadline: inherited_deadline(Instant::now() + duration),
             resolution,
             selections: Arc::new(Mutex::new(HashMap::new())),
+            inbound: Default::default(),
+            source: None,
+            #[cfg(all(target_os = "linux", feature = "sing-mux"))]
+            tcp_control: None,
+            #[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+            h3_udp: None,
         }
     }
 
+    #[cfg(any(feature = "outbound-wireguard", feature = "outbound-masque"))]
+    pub(crate) fn with_metadata(mut self, metadata: &crate::session::InboundMetadata) -> Self {
+        self.inbound = metadata.clone();
+        self
+    }
+
+    #[cfg(all(target_os = "linux", feature = "sing-mux"))]
+    pub(crate) fn capture_tcp_control(&self, capture: crate::dialer::tcp_control::Capture) -> Self {
+        let mut context = self.clone();
+        context.tcp_control = Some(capture);
+        context
+    }
+
+    #[cfg(all(target_os = "linux", feature = "sing-mux"))]
+    fn without_tcp_control(&self) -> Self {
+        let mut context = self.clone();
+        if let Some(capture) = context.tcp_control.take() {
+            capture.report(None);
+        }
+        context
+    }
+
+    #[cfg(feature = "outbound-vless")]
+    pub(crate) fn captures_tcp_control(&self) -> bool {
+        #[cfg(all(target_os = "linux", feature = "sing-mux"))]
+        {
+            self.tcp_control.is_some()
+        }
+        #[cfg(not(all(target_os = "linux", feature = "sing-mux")))]
+        {
+            false
+        }
+    }
+
+    #[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+    pub(crate) fn capture_h3_udp(
+        &self,
+        capture: crate::transport::xhttp::UdpAssociationCapture,
+    ) -> Self {
+        let mut context = self.clone();
+        context.h3_udp = Some(capture);
+        context
+    }
+    #[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+    pub(crate) fn h3_udp_capture(&self) -> Option<&crate::transport::xhttp::UdpAssociationCapture> {
+        self.h3_udp.as_ref()
+    }
+    #[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+    fn without_h3_udp(&self) -> Self {
+        let mut context = self.clone();
+        context.h3_udp = None;
+        context
+    }
+
+    /// MASQUE's positive timeout owns shared creation independently of a
+    /// waiting caller. Preserve its selected upstreams and inbound identity.
+    #[cfg(feature = "outbound-masque")]
+    pub(crate) fn masque_handshake(&self, seconds: i64) -> Self {
+        // Go's time.Duration multiplication wraps at signed nanoseconds.
+        let nanos = seconds.wrapping_mul(1_000_000_000);
+        let now = Instant::now();
+        Self {
+            deadline: if nanos > 0 {
+                now + Duration::from_nanos(nanos as u64)
+            } else {
+                now
+            },
+            resolution: self.resolution.clone(),
+            selections: Arc::new(Mutex::new(
+                self.selections
+                    .lock()
+                    .unwrap_or_else(std::sync::PoisonError::into_inner)
+                    .clone(),
+            )),
+            inbound: self.inbound.clone(),
+            source: self.source,
+            #[cfg(all(target_os = "linux", feature = "sing-mux"))]
+            tcp_control: None,
+            #[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+            h3_udp: None,
+        }
+    }
+
+    /// A positive Hysteria2 timeout belongs to its shared offer, not to the
+    /// first caller waiting for it. Preserve already selected upstreams.
+    #[cfg(feature = "outbound-hysteria2")]
+    pub(crate) fn hysteria2_handshake(&self, timeout: Duration) -> Result<Self, DispatchError> {
+        Ok(Self {
+            deadline: Instant::now()
+                .checked_add(timeout)
+                .ok_or(DispatchError::TimedOut)?,
+            resolution: self.resolution.clone(),
+            selections: Arc::new(Mutex::new(
+                self.selections
+                    .lock()
+                    .unwrap_or_else(std::sync::PoisonError::into_inner)
+                    .clone(),
+            )),
+            inbound: self.inbound.clone(),
+            source: self.source,
+            #[cfg(all(target_os = "linux", feature = "sing-mux"))]
+            tcp_control: None,
+            #[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+            h3_udp: None,
+        })
+    }
+
+    #[cfg(feature = "outbound-wireguard")]
+    pub(crate) fn capped_by(mut self, deadline: Instant) -> Self {
+        self.deadline = self.deadline.min(inherited_deadline(deadline));
+        self
+    }
+
     #[must_use]
     pub const fn deadline(&self) -> Instant {
         self.deadline
@@ -248,11 +373,17 @@ impl EstablishContext {
     /// Only for a new physical path of an already authenticated session, never
     /// for extending an in-progress setup. Freeze its group choices and give
     /// this socket's complete upstream establishment a new absolute deadline.
-    #[cfg(feature = "outbound-hysteria2")]
+    #[cfg(any(test, feature = "outbound-hysteria2", feature = "outbound-wireguard"))]
     pub(crate) fn authenticated_continuation(&self) -> Self {
         Self {
             deadline: Instant::now() + DEFAULT_ESTABLISH_TIMEOUT,
             resolution: self.resolution.clone(),
+            inbound: self.inbound.clone(),
+            source: self.source,
+            #[cfg(all(target_os = "linux", feature = "sing-mux"))]
+            tcp_control: None,
+            #[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+            h3_udp: None,
             selections: Arc::new(Mutex::new(
                 self.selections
                     .lock()
@@ -265,7 +396,8 @@ impl EstablishContext {
     /// One read per group for the entire setup, including both legs of a
     /// SOCKS5 UDP association. Retaining the atomic prevents address reuse;
     /// unrelated groups are not an atomic cross-group snapshot.
-    fn selected_member(&self, selection: &Arc<AtomicUsize>) -> usize {
+    fn selected_member(&self, selection: &Arc<GroupSelection>, destination: &Destination) -> usize {
+        selection.touch();
         let key = Arc::as_ptr(selection) as usize;
         let mut selections = self
             .selections
@@ -273,10 +405,25 @@ impl EstablishContext {
             .unwrap_or_else(std::sync::PoisonError::into_inner);
         selections
             .entry(key)
-            .or_insert_with(|| (selection.clone(), selection.load(Ordering::Acquire)))
+            .or_insert_with(|| {
+                (
+                    selection.clone(),
+                    selection.choose_for(
+                        self.source,
+                        Some(destination),
+                        self.inbound.user.as_deref(),
+                    ),
+                )
+            })
             .1
     }
 
+    fn report_group_outcome(&self, success: bool) {
+        for (selection, _) in self.selections.lock().unwrap().values() {
+            selection.outcome(success);
+        }
+    }
+
     pub async fn run<T, F>(&self, operation: &'static str, future: F) -> Result<T, DispatchError>
     where
         F: Future<Output = Result<T, DispatchError>>,
@@ -352,6 +499,7 @@ impl std::fmt::Debug for ConnectedStream {
 pub struct DatagramRequest {
     pub session: DatagramSession,
     budget: crate::dispatch::DatagramBudget,
+    udp_receive_buffer_size: Option<usize>,
 }
 
 impl DatagramRequest {
@@ -361,6 +509,7 @@ impl DatagramRequest {
         Self {
             session,
             budget: crate::dispatch::DatagramBudget::new(u16::MAX, max_response_payload_size),
+            udp_receive_buffer_size: None,
         }
     }
 
@@ -374,6 +523,7 @@ impl DatagramRequest {
         Self {
             session: self.session.clone(),
             budget: crate::dispatch::DatagramBudget::new(self.budget.transmit(), maximum),
+            udp_receive_buffer_size: self.udp_receive_buffer_size,
         }
     }
 
@@ -386,9 +536,30 @@ impl DatagramRequest {
         Self {
             session: self.session.clone(),
             budget,
+            udp_receive_buffer_size: self.udp_receive_buffer_size,
         }
     }
 
+    /// Best-effort hint for a locally owned physical UDP socket.
+    /// This is independent of logical payload and receive credit limits.
+    #[cfg(any(
+        feature = "outbound-mieru",
+        feature = "outbound-hysteria2",
+        feature = "outbound-tuic",
+        feature = "outbound-masque",
+        feature = "outbound-wireguard"
+    ))]
+    pub(crate) fn with_udp_receive_buffer_size(&self, size: usize) -> Self {
+        let mut request = self.clone();
+        request.udp_receive_buffer_size = Some(size);
+        request
+    }
+
+    pub(crate) fn udp_socket_options(&self) -> crate::dialer::UdpSocketOptions {
+        crate::dialer::UdpSocketOptions {
+            receive_buffer: self.udp_receive_buffer_size,
+        }
+    }
     /// Budget the wire envelope independently in each direction. A larger
     /// requested envelope can never increase a lower transport's real cap.
     pub fn with_envelope(&self, transmit: usize, receive: usize) -> Self {
@@ -438,8 +609,9 @@ pub trait OutboundConnector: Send + Sync {
 /// never a registry of all nodes, so a validated DAG cannot form an Arc cycle.
 /// The atomic is shared with the route/Controller view of the same group.
 pub struct SelectUpstream {
-    selection: Arc<AtomicUsize>,
+    selection: Arc<GroupSelection>,
     members: Box<[SelectUpstreamMember]>,
+    disable_udp: bool,
 }
 
 pub(crate) enum SelectUpstreamMember {
@@ -447,20 +619,51 @@ pub(crate) enum SelectUpstreamMember {
     Group(Arc<SelectUpstream>),
     Direct,
     Reject,
+    Control,
 }
 
 impl SelectUpstream {
-    pub(crate) fn new(selection: Arc<AtomicUsize>, members: Vec<SelectUpstreamMember>) -> Self {
+    pub(crate) fn new(selection: Arc<GroupSelection>, members: Vec<SelectUpstreamMember>) -> Self {
         Self {
             selection,
             members: members.into_boxed_slice(),
+            disable_udp: false,
         }
     }
 
-    fn resolve(&self, context: &EstablishContext) -> Result<&SelectUpstreamMember, DispatchError> {
+    pub(crate) fn with_udp_disabled(mut self, disabled: bool) -> Self {
+        self.disable_udp = disabled;
+        self
+    }
+    fn check_udp(
+        &self,
+        context: &EstablishContext,
+        destination: &Destination,
+    ) -> Result<(), DispatchError> {
         let mut group = self;
         loop {
-            let selected = context.selected_member(&group.selection);
+            if group.disable_udp {
+                return Err(DispatchError::NotAllowed);
+            }
+            match group
+                .members
+                .get(context.selected_member(&group.selection, destination))
+            {
+                Some(SelectUpstreamMember::Group(next)) => group = next,
+                Some(_) => return Ok(()),
+                None => return Err(DispatchError::NotAllowed),
+            }
+        }
+    }
+
+    fn resolve(
+        &self,
+        context: &EstablishContext,
+        destination: &Destination,
+    ) -> Result<&SelectUpstreamMember, DispatchError> {
+        let mut group = self;
+        loop {
+            let selected = context.selected_member(&group.selection, destination);
             match group.members.get(selected) {
                 Some(SelectUpstreamMember::Group(next)) => group = next,
                 Some(leaf) => return Ok(leaf),
@@ -474,14 +677,45 @@ impl SelectUpstream {
     }
 }
 
+async fn connect_direct_server(
+    dialer: &Dialer,
+    endpoint: &ResolvedEndpoint,
+    context: &EstablishContext,
+) -> Result<ConnectedStream, DispatchError> {
+    let stream = context
+        .run_io("physical proxy-server connect", async {
+            #[cfg(all(target_os = "linux", feature = "sing-mux"))]
+            if context.tcp_control.is_some() {
+                return dialer
+                    .connect_server_tcp_controlled(endpoint, context.deadline())
+                    .await;
+            }
+            dialer
+                .connect_server_tcp(endpoint, context.deadline())
+                .await
+        })
+        .await?;
+    #[cfg(all(target_os = "linux", feature = "sing-mux"))]
+    if let Some(capture) = &context.tcp_control {
+        capture.report(stream.control);
+    }
+    Ok(ConnectedStream {
+        io: stream.io,
+        effective_peer: Destination::Ip(stream.address),
+    })
+}
+
 enum ResolvedUpstream<'a> {
     Direct(&'a ResolvedEndpoint, &'a Dialer),
+    LazyDirect(&'a Dialer),
     Proxy(&'a Arc<dyn OutboundConnector>),
 }
 
 /// The path used by one configured proxy to reach its own server.
 #[derive(Clone)]
 pub enum UpstreamPath {
+    /// Physical endpoint resolution belongs to the current runtime DNS role.
+    LazyDirect { dialer: Dialer },
     /// The physical first hop. Its endpoint was resolved during prepare.
     Direct {
         endpoint: ResolvedEndpoint,
@@ -493,6 +727,7 @@ pub enum UpstreamPath {
     /// A runtime select group. DIRECT is relative to this node's prepared
     /// server, not the business destination or the ordinary routing engine.
     Group {
+        server: Destination,
         group: Arc<SelectUpstream>,
         endpoint: Option<ResolvedEndpoint>,
         dialer: Dialer,
@@ -507,6 +742,7 @@ impl std::fmt::Debug for UpstreamPath {
                 .field("endpoint", endpoint)
                 .field("dialer", dialer)
                 .finish(),
+            Self::LazyDirect { .. } => formatter.write_str("LazyDirectUpstream(..)"),
             Self::Proxy(_) => formatter.write_str("ProxyUpstream(..)"),
             Self::Group { .. } => formatter.write_str("GroupUpstream(..)"),
         }
@@ -514,6 +750,41 @@ impl std::fmt::Debug for UpstreamPath {
 }
 
 impl UpstreamPath {
+    /// A multi-endpoint node shares the declared graph, while each
+    /// physical peer has its own server and may refresh a previously pinned IP.
+    #[cfg(any(
+        feature = "outbound-wireguard",
+        feature = "outbound-mieru",
+        feature = "outbound-hysteria2"
+    ))]
+    pub(crate) fn for_server(&self, server: &Destination, refresh: bool) -> Self {
+        match self {
+            Self::Direct { endpoint, dialer }
+                if refresh || validate_prepared_endpoint(server, endpoint).is_err() =>
+            {
+                Self::LazyDirect {
+                    dialer: dialer.clone(),
+                }
+            }
+            Self::Group {
+                server: original,
+                group,
+                endpoint,
+                dialer,
+            } => Self::Group {
+                server: server.clone(),
+                group: group.clone(),
+                endpoint: if refresh || original != server {
+                    None
+                } else {
+                    endpoint.clone()
+                },
+                dialer: dialer.clone(),
+            },
+            _ => self.clone(),
+        }
+    }
+
     #[must_use]
     pub const fn direct(endpoint: ResolvedEndpoint, dialer: Dialer) -> Self {
         Self::Direct { endpoint, dialer }
@@ -524,30 +795,52 @@ impl UpstreamPath {
         Self::Proxy(connector)
     }
 
+    /// Structural proof for one private VLESS leg; never resolves a group.
+    #[cfg(feature = "outbound-vless")]
+    pub(crate) fn static_h2_dialer(&self, server: &Destination) -> Option<&Dialer> {
+        let Destination::Ip(address) = server else {
+            return None;
+        };
+        let dialer = match self {
+            Self::LazyDirect { dialer } => dialer,
+            Self::Direct { endpoint, dialer }
+                if endpoint.port == address.port()
+                    && endpoint.logical_host.parse::<IpAddr>().ok() == Some(address.ip())
+                    && endpoint.addresses.as_slice() == std::slice::from_ref(address) =>
+            {
+                dialer
+            }
+            _ => return None,
+        };
+        dialer.permits_static_h2_reuse().then_some(dialer)
+    }
+
     pub(crate) fn is_direct(&self, context: &EstablishContext) -> Result<bool, DispatchError> {
         Ok(matches!(
             self.resolve(context)?,
-            ResolvedUpstream::Direct(..)
+            ResolvedUpstream::Direct(..) | ResolvedUpstream::LazyDirect(..)
         ))
     }
 
     fn resolve(&self, context: &EstablishContext) -> Result<ResolvedUpstream<'_>, DispatchError> {
         match self {
             Self::Direct { endpoint, dialer } => Ok(ResolvedUpstream::Direct(endpoint, dialer)),
+            Self::LazyDirect { dialer } => Ok(ResolvedUpstream::LazyDirect(dialer)),
             Self::Proxy(connector) => Ok(ResolvedUpstream::Proxy(connector)),
             Self::Group {
                 group,
                 endpoint,
                 dialer,
-            } => match group.resolve(context)? {
+                server,
+            } => match group.resolve(context, server)? {
                 SelectUpstreamMember::Proxy(connector) => Ok(ResolvedUpstream::Proxy(connector)),
                 SelectUpstreamMember::Direct => endpoint
                     .as_ref()
                     .map(|endpoint| ResolvedUpstream::Direct(endpoint, dialer))
-                    .ok_or_else(|| {
-                        DispatchError::Other("DIRECT upstream has no prepared endpoint".to_owned())
-                    }),
-                SelectUpstreamMember::Reject => Err(DispatchError::NotAllowed),
+                    .map_or_else(|| Ok(ResolvedUpstream::LazyDirect(dialer)), Ok),
+                SelectUpstreamMember::Reject | SelectUpstreamMember::Control => {
+                    Err(DispatchError::NotAllowed)
+                }
                 SelectUpstreamMember::Group(_) => {
                     unreachable!("upstream resolution returns a leaf")
                 }
@@ -565,17 +858,31 @@ impl UpstreamPath {
         match self.resolve(context)? {
             ResolvedUpstream::Direct(endpoint, dialer) => {
                 validate_prepared_endpoint(server, endpoint)?;
-                let stream = context
-                    .run_io("physical proxy-server connect", dialer.connect(endpoint))
+                connect_direct_server(dialer, endpoint, context).await
+            }
+            ResolvedUpstream::LazyDirect(dialer) => {
+                let endpoint = context
+                    .resolution
+                    .clone()
+                    .with_ip_version(dialer.ip_version())
+                    .with_physical_dialer(dialer)
+                    .resolve_proxy(server, context.deadline)
                     .await?;
-                let effective_peer =
-                    Destination::Ip(stream.peer_addr().map_err(DispatchError::from)?);
-                Ok(ConnectedStream {
-                    io: Box::new(stream),
-                    effective_peer,
-                })
+                connect_direct_server(dialer, &endpoint, context).await
+            }
+            ResolvedUpstream::Proxy(connector) => {
+                #[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+                let unbound = context.without_h3_udp();
+                #[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+                let context = &unbound;
+                #[cfg(all(target_os = "linux", feature = "sing-mux"))]
+                if context.tcp_control.is_some() {
+                    return connector
+                        .connect_stream(session, &context.without_tcp_control())
+                        .await;
+                }
+                connector.connect_stream(session, context).await
             }
-            ResolvedUpstream::Proxy(connector) => connector.connect_stream(session, context).await,
         }
     }
 
@@ -584,32 +891,119 @@ impl UpstreamPath {
         request: DatagramRequest,
         context: &EstablishContext,
     ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        if let Self::Group { group, server, .. } = self {
+            group.check_udp(context, server)?;
+        }
         match self.resolve(context)? {
-            ResolvedUpstream::Direct(_, dialer) => {
+            ResolvedUpstream::Direct(_, dialer) | ResolvedUpstream::LazyDirect(dialer) => {
                 let direct = DirectOutbound::new(dialer.clone());
                 OutboundConnector::open_datagram(&direct, request, context).await
             }
-            ResolvedUpstream::Proxy(connector) => connector.open_datagram(request, context).await,
+            ResolvedUpstream::Proxy(connector) => {
+                #[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+                let unbound = context.without_h3_udp();
+                #[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+                let context = &unbound;
+                connector.open_datagram(request, context).await
+            }
         }
     }
 
-    /// Pins a native UDP proxy server without performing DNS after prepare.
+    /// Pins a native UDP server using the node resolver when first needed.
     /// Resolving here and opening IO below share the context's group snapshot.
     #[cfg(any(
+        feature = "outbound-vmess",
+        feature = "outbound-vless",
+        feature = "outbound-hysteria2",
+        feature = "outbound-tuic",
+        feature = "outbound-trusttunnel",
+        feature = "outbound-mieru",
+        feature = "outbound-masque"
+    ))]
+    pub(crate) async fn datagram_server(
+        &self,
+        server: &Destination,
+        context: &EstablishContext,
+    ) -> Result<Destination, DispatchError> {
+        self.resolve_datagram_server(server, context, false).await
+    }
+
+    /// Only SS2022/WireGuard use IP4P when resolving their native UDP server.
+    #[cfg(any(feature = "outbound-shadowsocks", feature = "outbound-wireguard"))]
+    pub(crate) async fn ip4p_datagram_server(
+        &self,
+        server: &Destination,
+        context: &EstablishContext,
+    ) -> Result<Destination, DispatchError> {
+        self.resolve_datagram_server(server, context, true).await
+    }
+
+    #[cfg(feature = "outbound-socks5")]
+    pub(crate) fn ip4p_datagram_relay(
+        &self,
+        relay: Destination,
+        context: &EstablishContext,
+    ) -> Result<Destination, DispatchError> {
+        Ok(match (self.resolve(context)?, relay) {
+            (
+                ResolvedUpstream::Direct(_, dialer) | ResolvedUpstream::LazyDirect(dialer),
+                Destination::Ip(address),
+            ) => Destination::Ip(
+                dialer
+                    .connected_address(address)
+                    .map_err(DispatchError::from)?,
+            ),
+            (_, relay) => relay,
+        })
+    }
+
+    #[cfg(any(
+        feature = "outbound-vmess",
         feature = "outbound-shadowsocks",
         feature = "outbound-vless",
         feature = "outbound-hysteria2",
-        feature = "outbound-tuic"
+        feature = "outbound-tuic",
+        feature = "outbound-trusttunnel",
+        feature = "outbound-mieru",
+        feature = "outbound-masque",
+        feature = "outbound-wireguard"
     ))]
-    pub(crate) fn datagram_server(
+    async fn resolve_datagram_server(
         &self,
         server: &Destination,
         context: &EstablishContext,
+        ip4p: bool,
     ) -> Result<Destination, DispatchError> {
         match self.resolve(context)? {
-            ResolvedUpstream::Direct(endpoint, _) => {
+            ResolvedUpstream::Direct(endpoint, dialer) => {
                 validate_prepared_endpoint(server, endpoint)?;
-                endpoint
+                if ip4p {
+                    dialer
+                        .validate_connected_endpoint(endpoint)
+                        .map_err(DispatchError::from)?;
+                }
+                let addresses = if ip4p {
+                    dialer.ordered_connected_addresses(&endpoint.addresses)
+                } else {
+                    dialer.ordered_addresses(&endpoint.addresses)
+                };
+                addresses
+                    .first()
+                    .copied()
+                    .map(Destination::Ip)
+                    .ok_or(DispatchError::HostUnreachable)
+            }
+            ResolvedUpstream::LazyDirect(dialer) => {
+                let mut resolution = context
+                    .resolution
+                    .clone()
+                    .with_ip_version(dialer.ip_version());
+                if ip4p {
+                    resolution = resolution.with_physical_dialer(dialer);
+                }
+                resolution
+                    .resolve_proxy(server, context.deadline)
+                    .await?
                     .addresses
                     .first()
                     .copied()
@@ -621,6 +1015,38 @@ impl UpstreamPath {
     }
 }
 
+pub(crate) struct IpVersionConnector {
+    pub inner: Arc<dyn OutboundConnector>,
+    pub version: crate::config::IpVersion,
+}
+#[async_trait]
+impl OutboundConnector for IpVersionConnector {
+    async fn connect_stream(
+        &self,
+        session: StreamSession,
+        context: &EstablishContext,
+    ) -> Result<ConnectedStream, DispatchError> {
+        let mut context = context.clone();
+        context.resolution = context.resolution.with_ip_version(self.version);
+        self.inner.connect_stream(session, &context).await
+    }
+    async fn open_datagram(
+        &self,
+        request: DatagramRequest,
+        context: &EstablishContext,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        let mut context = context.clone();
+        context.resolution = context.resolution.with_ip_version(self.version);
+        self.inner.open_datagram(request, &context).await
+    }
+    fn begin_shutdown(&self) {
+        self.inner.begin_shutdown();
+    }
+    async fn shutdown(&self) {
+        self.inner.shutdown().await;
+    }
+}
+
 /// Creates the logical server destination retained by proxy connectors.
 pub fn server_destination(address: &str, port: u16) -> io::Result<Destination> {
     if let Ok(address) = address.parse::<IpAddr>() {
@@ -697,18 +1123,32 @@ impl ConnectorDispatcher {
         self
     }
 
-    fn context(&self) -> EstablishContext {
-        EstablishContext::with_resolution(DEFAULT_ESTABLISH_TIMEOUT, self.resolution.clone())
+    fn context(
+        &self,
+        source: SocketAddr,
+        metadata: &crate::session::InboundMetadata,
+    ) -> EstablishContext {
+        let mut context =
+            EstablishContext::with_resolution(DEFAULT_ESTABLISH_TIMEOUT, self.resolution.clone());
+        context.inbound = metadata.clone();
+        context.source = Some(source);
+        context
     }
 }
 
 #[async_trait]
 impl Dispatcher for ConnectorDispatcher {
+    fn supports_udp(&self) -> bool {
+        self.allow_udp
+    }
+
     async fn connect_tcp(&self, session: StreamSession) -> Result<BoxStream, DispatchError> {
-        self.inner
-            .connect_stream(session, &self.context())
-            .await
-            .map(|connected| connected.io)
+        let context = self.context(session.source, &session.metadata);
+        let result = self.inner.connect_stream(session, &context).await;
+        if !matches!(result, Err(DispatchError::NotAllowed)) {
+            context.report_group_outcome(result.is_ok());
+        }
+        result.map(|connected| connected.io)
     }
 
     async fn open_datagram(
@@ -718,8 +1158,9 @@ impl Dispatcher for ConnectorDispatcher {
         if !self.allow_udp {
             return Err(DispatchError::NotAllowed);
         }
+        let context = self.context(session.source, &session.metadata);
         self.inner
-            .open_datagram(DatagramRequest::new(session), &self.context())
+            .open_datagram(DatagramRequest::new(session), &context)
             .await
     }
 }
@@ -739,12 +1180,7 @@ mod tests {
     #[cfg(feature = "outbound-hysteria2")]
     #[tokio::test]
     async fn authenticated_continuation_keeps_group_choice_but_has_a_new_io_deadline() {
-        #[cfg(feature = "interop-test")]
-        let _case = crate::resources::case_events::Case::new(
-            "HYSTERIA2-UNIT",
-            "authenticated_continuation_keeps_group_choice_but_has_a_new_io_deadline",
-        );
-        let selection = Arc::new(AtomicUsize::new(0));
+        let selection = Arc::new(GroupSelection::new(0));
         let path = selected_path(
             selection.clone(),
             vec![
@@ -847,6 +1283,10 @@ mod tests {
 
     #[async_trait]
     impl DatagramTransport for MarkedDatagrams {
+        fn supports_shared_destinations(&self) -> bool {
+            false
+        }
+
         async fn send(&mut self, _datagram: Datagram) -> Result<(), DispatchError> {
             self.sends.fetch_add(1, Ordering::Relaxed);
             Ok(())
@@ -862,6 +1302,7 @@ mod tests {
 
     fn test_session() -> StreamSession {
         StreamSession {
+            metadata: Default::default(),
             inbound: InboundKind::Http,
             source: "127.0.0.1:10000".parse().unwrap(),
             destination: Destination::domain("business.invalid", 443).unwrap(),
@@ -878,16 +1319,220 @@ mod tests {
     }
 
     fn selected_path(
-        selection: Arc<AtomicUsize>,
+        selection: Arc<GroupSelection>,
         members: Vec<SelectUpstreamMember>,
     ) -> UpstreamPath {
         UpstreamPath::Group {
+            server: Destination::domain("server.example", 443).unwrap(),
             group: Arc::new(SelectUpstream::new(selection, members)),
             endpoint: None,
             dialer: Dialer::default(),
         }
     }
 
+    #[tokio::test]
+    async fn ingress_sticky_upstream_keeps_source_ip_and_authenticated_user_precedence() {
+        struct Carrier(UpstreamPath);
+        #[async_trait]
+        impl OutboundConnector for Carrier {
+            async fn connect_stream(
+                &self,
+                session: StreamSession,
+                context: &EstablishContext,
+            ) -> Result<ConnectedStream, DispatchError> {
+                assert_eq!(context.source, Some(session.source));
+                self.0
+                    .connect_server(
+                        session,
+                        &Destination::domain("server.example", 443).unwrap(),
+                        context,
+                    )
+                    .await
+            }
+            async fn open_datagram(
+                &self,
+                request: DatagramRequest,
+                context: &EstablishContext,
+            ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+                assert_eq!(context.source, Some(request.session.source));
+                let continuation = context.authenticated_continuation();
+                assert_eq!(continuation.source, context.source);
+                #[cfg(feature = "outbound-hysteria2")]
+                assert_eq!(
+                    context.hysteria2_handshake(Duration::from_secs(1))?.source,
+                    context.source
+                );
+                #[cfg(feature = "outbound-masque")]
+                assert_eq!(context.masque_handshake(1).source, context.source);
+                self.0.open_datagram(request, &continuation).await
+            }
+        }
+
+        for hash_key in ["", "in-user"] {
+            let config = crate::config::Config::parse_yaml(
+                format!(
+                    "mixed-port: 1080\nproxy-groups:\n  - {{name: balance, type: load-balance, strategy: sticky-sessions, hash-key: '{hash_key}', proxies: [DIRECT,REJECT]}}\n"
+                )
+                .as_bytes(),
+            )
+            .unwrap();
+            let selection = Arc::new(GroupSelection::new(0));
+            selection.configure_balance(&config.proxy_groups[0]);
+            let server = Destination::domain("server.example", 443).unwrap();
+            let sources: [SocketAddr; 3] = [
+                "198.51.100.1:10000".parse().unwrap(),
+                "198.51.100.2:10000".parse().unwrap(),
+                "198.51.100.1:20000".parse().unwrap(),
+            ];
+            // Pin two address keys to different members without depending on
+            // the strategy's random first choice. Restore health afterwards.
+            for (index, source) in sources[..2].iter().enumerate() {
+                let mut healthy = [None; 2];
+                healthy[index] = Some(10);
+                selection.balance_health(&healthy);
+                assert_eq!(
+                    selection.choose_for(Some(*source), Some(&server), None),
+                    index
+                );
+            }
+            selection.balance_health(&[Some(10), Some(10)]);
+            let path = selected_path(
+                selection.clone(),
+                [1, 2]
+                    .map(|marker| {
+                        SelectUpstreamMember::Proxy(Arc::new(MarkedConnector {
+                            marker,
+                            ..Default::default()
+                        }))
+                    })
+                    .into(),
+            );
+            let dispatcher = ConnectorDispatcher::new(Arc::new(Carrier(path)));
+            for (source, expected) in sources.into_iter().zip([1, 2, 1]) {
+                let mut session = test_session();
+                session.source = source;
+                let mut stream = dispatcher.connect_tcp(session).await.unwrap();
+                assert_eq!(stream.read_u8().await.unwrap(), expected);
+                let mut udp = dispatcher
+                    .open_datagram(DatagramSession::new(InboundKind::Socks5, source))
+                    .await
+                    .unwrap();
+                assert_eq!(udp.receive().await.unwrap().payload[0], expected);
+            }
+            if hash_key == "in-user" {
+                selection.balance_health(&[None, Some(10)]);
+                assert_eq!(
+                    selection.choose_for(Some(sources[0]), Some(&server), Some("verified")),
+                    1
+                );
+                selection.balance_health(&[Some(10), Some(10)]);
+                for source in sources {
+                    let mut session = test_session();
+                    session.source = source;
+                    session.metadata.user = Some(Arc::from("verified"));
+                    let udp_session = DatagramSession::new(InboundKind::Socks5, source)
+                        .with_metadata(session.metadata.clone());
+                    let mut stream = dispatcher.connect_tcp(session).await.unwrap();
+                    assert_eq!(stream.read_u8().await.unwrap(), 2);
+                    let mut udp = dispatcher.open_datagram(udp_session).await.unwrap();
+                    assert_eq!(udp.receive().await.unwrap().payload[0], 2);
+                }
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn ingress_connector_dispatcher_preserves_user_for_dialer_proxy_and_continuations() {
+        struct Carrier {
+            path: UpstreamPath,
+            user: Arc<str>,
+        }
+        #[async_trait]
+        impl OutboundConnector for Carrier {
+            async fn connect_stream(
+                &self,
+                session: StreamSession,
+                context: &EstablishContext,
+            ) -> Result<ConnectedStream, DispatchError> {
+                assert_eq!(context.inbound.user.as_deref(), Some(self.user.as_ref()));
+                assert_eq!(session.metadata, context.inbound);
+                self.path
+                    .connect_server(
+                        session,
+                        &Destination::domain("server.example", 443).unwrap(),
+                        context,
+                    )
+                    .await
+            }
+            async fn open_datagram(
+                &self,
+                request: DatagramRequest,
+                context: &EstablishContext,
+            ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+                assert_eq!(context.inbound, request.session.metadata);
+                let continuation = context.authenticated_continuation();
+                assert_eq!(continuation.inbound, context.inbound);
+                self.path.open_datagram(request, &continuation).await
+            }
+        }
+        let config = crate::config::Config::parse_yaml(
+            br#"
+mixed-port: 1080
+proxies:
+  - {name: a, type: socks5, server: 192.0.2.10, port: 1080, udp: true}
+  - {name: b, type: socks5, server: 192.0.2.11, port: 1080, udp: true}
+proxy-groups:
+  - {name: balance, type: load-balance, proxies: [a,b], hash-key: in-user}
+"#,
+        )
+        .unwrap();
+        let selection = Arc::new(GroupSelection::new(0));
+        selection.configure_balance(&config.proxy_groups[0]);
+        let server = Destination::domain("server.example", 443).unwrap();
+        let fallback = selection.choose_for(None, Some(&server), None);
+        let user: Arc<str> = Arc::from(
+            (0..256)
+                .map(|i| format!("verified-{i}"))
+                .find(|user| selection.choose_for(None, Some(&server), Some(user)) != fallback)
+                .unwrap(),
+        );
+        let expected = selection.choose_for(None, Some(&server), Some(&user)) as u8 + 1;
+        let path = selected_path(
+            selection,
+            vec![
+                SelectUpstreamMember::Proxy(Arc::new(MarkedConnector {
+                    marker: 1,
+                    ..Default::default()
+                })),
+                SelectUpstreamMember::Proxy(Arc::new(MarkedConnector {
+                    marker: 2,
+                    ..Default::default()
+                })),
+            ],
+        );
+        let dispatcher = ConnectorDispatcher::new(Arc::new(Carrier {
+            path,
+            user: user.clone(),
+        }));
+        let metadata = crate::session::InboundMetadata {
+            local_port: 1080,
+            user: Some(user),
+            ..Default::default()
+        };
+        let mut session = test_session();
+        session.metadata = metadata.clone();
+        let mut stream = dispatcher.connect_tcp(session).await.unwrap();
+        assert_eq!(stream.read_u8().await.unwrap(), expected);
+        let mut udp = dispatcher
+            .open_datagram(
+                DatagramSession::new(InboundKind::Socks5, test_session().source)
+                    .with_metadata(metadata),
+            )
+            .await
+            .unwrap();
+        assert_eq!(udp.receive().await.unwrap().payload[0], expected);
+    }
+
     #[tokio::test]
     async fn group_upstream_pins_nested_choices_and_preserves_metadata_budget_and_deadline() {
         let first = Arc::new(MarkedConnector {
@@ -898,7 +1543,7 @@ mod tests {
             marker: 2,
             ..Default::default()
         });
-        let selection = Arc::new(AtomicUsize::new(0));
+        let selection = Arc::new(GroupSelection::new(0));
         let nested = Arc::new(SelectUpstream::new(
             selection.clone(),
             vec![
@@ -906,7 +1551,7 @@ mod tests {
                 SelectUpstreamMember::Proxy(second.clone()),
             ],
         ));
-        let outer_selection = Arc::new(AtomicUsize::new(0));
+        let outer_selection = Arc::new(GroupSelection::new(0));
         let path = selected_path(
             outer_selection.clone(),
             vec![
@@ -966,7 +1611,7 @@ mod tests {
             marker: 2,
             ..Default::default()
         });
-        let selection = Arc::new(AtomicUsize::new(0));
+        let selection = Arc::new(GroupSelection::new(0));
         let path = selected_path(
             selection.clone(),
             vec![
@@ -1015,7 +1660,7 @@ mod tests {
             gate: Some(Arc::new(Semaphore::new(0))),
             ..Default::default()
         });
-        let selection = Arc::new(AtomicUsize::new(0));
+        let selection = Arc::new(GroupSelection::new(0));
         let connector_weak = Arc::downgrade(&connector);
         let selection_weak = Arc::downgrade(&selection);
         let path = selected_path(selection, vec![SelectUpstreamMember::Proxy(connector)]);
@@ -1035,8 +1680,9 @@ mod tests {
     async fn upstream_direct_connects_prepared_node_server_and_reject_never_falls_back() {
         let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
         let address = listener.local_addr().unwrap();
-        let selection = Arc::new(AtomicUsize::new(0));
+        let selection = Arc::new(GroupSelection::new(0));
         let path = UpstreamPath::Group {
+            server: Destination::domain("server.example", 443).unwrap(),
             group: Arc::new(SelectUpstream::new(
                 selection.clone(),
                 vec![SelectUpstreamMember::Direct, SelectUpstreamMember::Reject],
@@ -1102,8 +1748,9 @@ mod tests {
         let address = listener.local_addr().unwrap();
         let protector = Arc::new(RejectProtector(AtomicUsize::new(0)));
         let path = UpstreamPath::Group {
+            server: Destination::domain("server.example", 443).unwrap(),
             group: Arc::new(SelectUpstream::new(
-                Arc::new(AtomicUsize::new(0)),
+                Arc::new(GroupSelection::new(0)),
                 vec![SelectUpstreamMember::Direct],
             )),
             endpoint: Some(ResolvedEndpoint {
@@ -1140,7 +1787,7 @@ mod tests {
             reject_udp: true,
             ..Default::default()
         });
-        let selection = Arc::new(AtomicUsize::new(0));
+        let selection = Arc::new(GroupSelection::new(0));
         let path = selected_path(
             selection.clone(),
             vec![
@@ -1216,6 +1863,26 @@ mod tests {
             "127.0.0.1:10000".parse().unwrap(),
         );
         let request = DatagramRequest::new(session);
+        assert_eq!(request.udp_socket_options().receive_buffer, None);
+        #[cfg(any(
+            feature = "outbound-mieru",
+            feature = "outbound-hysteria2",
+            feature = "outbound-tuic",
+            feature = "outbound-masque"
+        ))]
+        {
+            let request = request.with_udp_receive_buffer_size(512 * 1024);
+            for adjusted in [
+                request.with_budget(crate::dispatch::DatagramBudget::new(1_200, 1_400)),
+                request.with_max_response_payload_size(1_714),
+                request.with_envelope(32, 64),
+            ] {
+                assert_eq!(
+                    adjusted.udp_socket_options().receive_buffer,
+                    Some(512 * 1024)
+                );
+            }
+        }
         assert_eq!(request.max_response_payload_size(), 1_452);
         assert_eq!(
             request
@@ -1289,4 +1956,87 @@ mod tests {
         assert_eq!(diagnostic.kind(), "timed_out");
         assert_eq!(diagnostic.message(), "outbound setup deadline expired");
     }
+    #[cfg(any(feature = "outbound-shadowsocks", feature = "outbound-wireguard"))]
+    #[tokio::test]
+    async fn ip4p_udp_node_endpoint_retains_chain_identity_and_uses_actual_reply_peer() {
+        let encoded: std::net::SocketAddr = "[2001:0::1bb:c000:201]:8443".parse().unwrap();
+        let server = Destination::Ip(encoded);
+        let endpoint = ResolvedEndpoint {
+            logical_host: encoded.ip().to_string(),
+            port: encoded.port(),
+            addresses: vec![encoded],
+        };
+        let dialer = Dialer::default()
+            .with_ipv6(false)
+            .with_ip_version(crate::config::IpVersion::Ipv4)
+            .with_connections(crate::config::ConnectionSettings {
+                dialer_ip4p_convert: true,
+                ..Default::default()
+            });
+        let path = UpstreamPath::direct(endpoint.clone(), dialer);
+        let context = EstablishContext::default();
+        let actual = path.ip4p_datagram_server(&server, &context).await.unwrap();
+        assert_eq!(actual, Destination::Ip("192.0.2.1:443".parse().unwrap()));
+        assert_eq!(server, Destination::Ip(encoded));
+        assert_eq!(endpoint.logical_host, encoded.ip().to_string());
+        assert_eq!(endpoint.port, 8443);
+        let remote = UpstreamPath::proxy(Arc::new(UnreachableConnector));
+        assert_eq!(
+            remote
+                .ip4p_datagram_server(&server, &context)
+                .await
+                .unwrap(),
+            server
+        );
+        #[cfg(feature = "outbound-socks5")]
+        {
+            assert_eq!(
+                path.ip4p_datagram_relay(server.clone(), &context).unwrap(),
+                actual
+            );
+            assert_eq!(
+                remote
+                    .ip4p_datagram_relay(server.clone(), &context)
+                    .unwrap(),
+                server
+            );
+        }
+    }
+    #[cfg(all(target_os = "linux", feature = "sing-mux"))]
+    #[tokio::test]
+    async fn brutal_capture_does_not_cross_a_proxy_hop() {
+        struct Check;
+        #[async_trait]
+        impl OutboundConnector for Check {
+            async fn connect_stream(
+                &self,
+                session: StreamSession,
+                context: &EstablishContext,
+            ) -> Result<ConnectedStream, DispatchError> {
+                assert!(context.tcp_control.is_none());
+                let (io, _) = tokio::io::duplex(1);
+                Ok(ConnectedStream {
+                    io: Box::new(io),
+                    effective_peer: session.destination,
+                })
+            }
+            async fn open_datagram(
+                &self,
+                _: DatagramRequest,
+                _: &EstablishContext,
+            ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+                panic!("no datagram IO in physical TCP policy test")
+            }
+        }
+        let capture = crate::dialer::tcp_control::Capture::default();
+        let context = EstablishContext::default().capture_tcp_control(capture.clone());
+        let path = UpstreamPath::proxy(Arc::new(Check));
+        let server = Destination::domain("proxy.invalid", 443).unwrap();
+        let io = path
+            .connect_server(test_session(), &server, &context)
+            .await
+            .unwrap();
+        assert!(capture.finish().is_none());
+        assert_eq!(io.effective_peer, server);
+    }
 }
diff --git a/src/outbound/control.rs b/src/outbound/control.rs
new file mode 100644
index 0000000..02acb31
--- /dev/null
+++ b/src/outbound/control.rs
@@ -0,0 +1,61 @@
+//! A routing-only node has no stream or datagram transport to return.
+use async_trait::async_trait;
+
+use super::{ConnectedStream, DatagramRequest, EstablishContext, OutboundConnector};
+use crate::{
+    dispatch::{DatagramTransport, DispatchError},
+    session::StreamSession,
+};
+
+pub(crate) struct RuleControlConnector;
+#[async_trait]
+impl OutboundConnector for RuleControlConnector {
+    async fn connect_stream(
+        &self,
+        _session: StreamSession,
+        _context: &EstablishContext,
+    ) -> Result<ConnectedStream, DispatchError> {
+        Err(DispatchError::NotAllowed)
+    }
+    async fn open_datagram(
+        &self,
+        _request: DatagramRequest,
+        _context: &EstablishContext,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        Err(DispatchError::NotAllowed)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::session::{DatagramSession, Destination, InboundKind};
+
+    #[tokio::test]
+    async fn routing_only_controls_never_return_successful_io() {
+        let context = EstablishContext::default();
+        let session = StreamSession {
+            metadata: Default::default(),
+            inbound: InboundKind::Tun,
+            source: "192.0.2.2:10000".parse().unwrap(),
+            destination: Destination::Ip("198.51.100.1:443".parse().unwrap()),
+            sniffed_domain: None,
+        };
+        assert!(matches!(
+            RuleControlConnector.connect_stream(session, &context).await,
+            Err(DispatchError::NotAllowed)
+        ));
+        assert!(matches!(
+            RuleControlConnector
+                .open_datagram(
+                    DatagramRequest::new(DatagramSession::new(
+                        InboundKind::Tun,
+                        "192.0.2.2:10000".parse().unwrap()
+                    )),
+                    &context,
+                )
+                .await,
+            Err(DispatchError::NotAllowed)
+        ));
+    }
+}
diff --git a/src/outbound/direct.rs b/src/outbound/direct.rs
index cc91539..8c27788 100644
--- a/src/outbound/direct.rs
+++ b/src/outbound/direct.rs
@@ -1,10 +1,13 @@
-use std::{future::Future, io, net::SocketAddr, pin::Pin};
+use std::{
+    io,
+    net::SocketAddr,
+    sync::Arc,
+    task::{Context, Poll},
+};
 
 use crate::dialer::PhysicalDatagram as UdpSocket;
 use async_trait::async_trait;
 use bytes::Bytes;
-use futures_util::future::select_all;
-use tokio::io::ReadBuf;
 
 use crate::{
     dialer::Dialer,
@@ -78,6 +81,7 @@ impl OutboundConnector for DirectOutbound {
             Box::new(DirectDatagramTransport::new(
                 self.dialer.clone(),
                 usize::from(request.max_response_payload_size()),
+                request.udp_socket_options(),
             )),
             request.budget(),
         ))
@@ -86,9 +90,11 @@ impl OutboundConnector for DirectOutbound {
 
 struct DirectDatagramTransport {
     dialer: Dialer,
-    sockets: Vec<(UdpSocketClass, UdpSocket)>,
+    sockets: Vec<(UdpSocketClass, Arc<UdpSocket>)>,
     max_response_payload_size: usize,
+    socket_options: crate::dialer::UdpSocketOptions,
     receive_buffer: Vec<u8>,
+    receive_cursor: usize,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -98,19 +104,18 @@ struct UdpSocketClass {
 }
 
 impl DirectDatagramTransport {
-    fn new(dialer: Dialer, max_response_payload_size: usize) -> Self {
-        // `recv_from` is allowed to truncate a datagram to the supplied
-        // buffer without reporting the original length. One sentinel byte is
-        // enough to distinguish an allowed maximum-size payload from every
-        // oversized payload while preserving a hard allocation ceiling.
-        let receive_buffer_size = max_response_payload_size
-            .checked_add(1)
-            .expect("direct UDP response ceiling fits usize");
+    fn new(
+        dialer: Dialer,
+        max_response_payload_size: usize,
+        socket_options: crate::dialer::UdpSocketOptions,
+    ) -> Self {
         Self {
             dialer,
             sockets: Vec::with_capacity(4),
             max_response_payload_size,
-            receive_buffer: vec![0; receive_buffer_size],
+            socket_options,
+            receive_buffer: Vec::new(),
+            receive_cursor: 0,
         }
     }
 
@@ -124,10 +129,10 @@ impl DirectDatagramTransport {
         }
         let socket = self
             .dialer
-            .bind_udp_for(address)
+            .bind_udp_for_with_options(address, self.socket_options)
             .await
             .map_err(DispatchError::from)?;
-        self.sockets.push((class, socket));
+        self.sockets.push((class, Arc::new(socket)));
         Ok(&self
             .sockets
             .last()
@@ -135,65 +140,102 @@ impl DirectDatagramTransport {
             .1)
     }
 
-    async fn receive_from_ready_socket(&mut self) -> Result<Datagram, DispatchError> {
-        loop {
-            if self.sockets.is_empty() {
-                return Err(DispatchError::Other(
-                    "direct UDP receive requested before the first datagram".to_owned(),
-                ));
-            }
-            // A single physical socket has only this reader. Poll it directly
-            // instead of rebuilding boxed readiness waiters after cancellation.
-            if self.sockets.len() == 1 {
-                let socket = &self.sockets[0].1;
-                let mut receive_buffer = ReadBuf::new(&mut self.receive_buffer);
-                let remote = std::future::poll_fn(|context| {
-                    socket.poll_recv_from(context, &mut receive_buffer)
-                })
-                .await
-                .map_err(DispatchError::from)?;
-                if receive_buffer.filled().len() > self.max_response_payload_size {
-                    continue;
+    async fn send_on(
+        socket: &UdpSocket,
+        payload: &[u8],
+        address: SocketAddr,
+    ) -> Result<(), DispatchError> {
+        let written = socket
+            .send_to(payload, address)
+            .await
+            .map_err(DispatchError::from)?;
+        if written != payload.len() {
+            return Err(DispatchError::Other(
+                "direct UDP socket truncated a datagram".to_owned(),
+            ));
+        }
+        Ok(())
+    }
+
+    fn poll_sockets(
+        sockets: &[(UdpSocketClass, Arc<UdpSocket>)],
+        max_payload: usize,
+        cursor: &mut usize,
+        context: &mut Context<'_>,
+        scratch: &mut Vec<u8>,
+    ) -> Poll<Result<Datagram, DispatchError>> {
+        if sockets.is_empty() {
+            return Poll::Ready(Err(DispatchError::Other(
+                "direct UDP receive requested before the first datagram".to_owned(),
+            )));
+        }
+        for _ in 0..crate::limits::IO_POLL_BUDGET {
+            let mut retry = false;
+            for offset in 0..sockets.len() {
+                let index = (*cursor + offset) % sockets.len();
+                let socket = &sockets[index].1;
+                match socket.poll_recv_ready(context) {
+                    Poll::Pending => continue,
+                    Poll::Ready(Err(error)) => return Poll::Ready(Err(error.into())),
+                    Poll::Ready(Ok(())) => {}
                 }
-                return Ok(Datagram {
-                    remote: Destination::Ip(remote),
-                    payload: Bytes::copy_from_slice(receive_buffer.filled()),
-                    sniffed_domain: None,
-                });
-            }
-            let readiness: Vec<Pin<Box<dyn Future<Output = io::Result<usize>> + Send + '_>>> = self
-                .sockets
-                .iter()
-                .enumerate()
-                .map(|(index, (_, socket))| {
-                    Box::pin(async move { socket.readable().await.map(|()| index) })
-                        as Pin<Box<dyn Future<Output = io::Result<usize>> + Send + '_>>
-                })
-                .collect();
-            let (selected, _, _) = select_all(readiness).await;
-            let selected = selected.map_err(DispatchError::from)?;
-            let socket = &self.sockets[selected].1;
-            match socket.try_recv_from(&mut self.receive_buffer) {
-                // A UDP datagram is indivisible. Never turn an oversized
-                // response into a shorter, apparently valid datagram for the
-                // SOCKS5 client or TUN netstack.
-                Ok((length, _)) if length > self.max_response_payload_size => continue,
-                Ok((length, remote)) => {
-                    return Ok(Datagram {
-                        remote: Destination::Ip(remote),
-                        payload: Bytes::copy_from_slice(&self.receive_buffer[..length]),
-                        sniffed_domain: None,
-                    });
+                // Allocate only once a socket is readable. The extra byte
+                // detects oversized datagrams rather than delivering a prefix.
+                let required = max_payload + 1;
+                if scratch.len() < required {
+                    scratch.reserve_exact(required - scratch.len());
+                    scratch.resize(required, 0);
                 }
-                Err(error) if error.kind() == io::ErrorKind::WouldBlock => continue,
-                Err(error) => return Err(DispatchError::from(error)),
+                match socket.try_recv_from(&mut scratch[..required]) {
+                    Ok((length, remote)) if length <= max_payload => {
+                        *cursor = (index + 1) % sockets.len();
+                        return Poll::Ready(Ok(Datagram {
+                            remote: Destination::Ip(remote),
+                            payload: Bytes::copy_from_slice(&scratch[..length]),
+                            sniffed_domain: None,
+                        }));
+                    }
+                    Ok(_) => retry = true,
+                    Err(error) if error.kind() == io::ErrorKind::WouldBlock => retry = true,
+                    Err(error) => return Poll::Ready(Err(error.into())),
+                }
+            }
+            if !retry {
+                return Poll::Pending;
             }
         }
+        context.waker().wake_by_ref();
+        Poll::Pending
     }
 }
 
 #[async_trait]
 impl DatagramTransport for DirectDatagramTransport {
+    fn supports_shared_destinations(&self) -> bool {
+        // Unconnected sockets preserve each send target and actual reply source.
+        true
+    }
+
+    #[cfg(all(
+        target_os = "linux",
+        any(feature = "outbound-tuic", feature = "quinn-h3-transport")
+    ))]
+    async fn lease_quic_socket(
+        &mut self,
+        peer: SocketAddr,
+    ) -> Result<Option<crate::transport::quic::PhysicalQuicLease>, DispatchError> {
+        // Only a fresh single-peer endpoint may take the lease. Do not expose
+        // a socket already used by connectionless/shared business datagrams.
+        if !self.sockets.is_empty() {
+            return Err(DispatchError::NotAllowed);
+        }
+        self.socket_for(peer).await?;
+        Ok(Some(crate::transport::quic::PhysicalQuicLease {
+            socket: self.sockets[0].1.clone(),
+            settings: self.dialer.connections().quic,
+        }))
+    }
+
     fn payload_budget(&self, peer: &Destination) -> crate::dispatch::DatagramBudget {
         let wire_limit = if matches!(peer, Destination::Ip(address) if address.is_ipv6()) {
             65_527
@@ -206,25 +248,65 @@ impl DatagramTransport for DirectDatagramTransport {
         )
     }
 
+    fn send_owned(
+        &mut self,
+        datagram: Datagram,
+    ) -> Result<crate::dispatch::OwnedDatagramSend, Datagram> {
+        let Destination::Ip(address) = &datagram.remote else {
+            return Err(datagram);
+        };
+        let address = *address;
+        let class = UdpSocketClass {
+            ipv6: address.is_ipv6(),
+            loopback: address.ip().is_loopback(),
+        };
+        let Some((_, socket)) = self.sockets.iter().find(|(key, _)| *key == class) else {
+            // The first ordinary send owns protected initialization.
+            return Err(datagram);
+        };
+        let socket = socket.clone();
+        Ok(Box::pin(async move {
+            Self::send_on(&socket, &datagram.payload, address).await
+        }))
+    }
+
     async fn send(&mut self, datagram: Datagram) -> Result<(), DispatchError> {
         let Destination::Ip(address) = datagram.remote else {
             return Err(DispatchError::HostUnreachable);
         };
         let socket = self.socket_for(address).await?;
-        let written = socket
-            .send_to(&datagram.payload, address)
-            .await
-            .map_err(DispatchError::from)?;
-        if written != datagram.payload.len() {
-            return Err(DispatchError::Other(
-                "direct UDP socket truncated a datagram".to_owned(),
-            ));
-        }
-        Ok(())
+        Self::send_on(socket, &datagram.payload, address).await
+    }
+
+    fn supports_poll_receive(&self) -> bool {
+        true
+    }
+
+    fn poll_receive(
+        &mut self,
+        context: &mut Context<'_>,
+        scratch: &mut Vec<u8>,
+    ) -> Poll<Result<Datagram, DispatchError>> {
+        Self::poll_sockets(
+            &self.sockets,
+            self.max_response_payload_size,
+            &mut self.receive_cursor,
+            context,
+            scratch,
+        )
     }
 
     async fn receive(&mut self) -> Result<Datagram, DispatchError> {
-        self.receive_from_ready_socket().await
+        std::future::poll_fn(|context| {
+            Self::poll_sockets(
+                &self.sockets,
+                self.max_response_payload_size,
+                &mut self.receive_cursor,
+                context,
+                &mut self.receive_buffer,
+            )
+        })
+        .await
     }
 
     async fn close(&mut self) -> Result<(), DispatchError> {
@@ -265,6 +347,7 @@ mod tests {
         let destination = listener.local_addr().unwrap();
         let outbound = DirectOutbound::new(Dialer::default());
         let session = StreamSession {
+            metadata: Default::default(),
             inbound: InboundKind::Http,
             source: "127.0.0.1:10000".parse().unwrap(),
             destination: Destination::Ip(destination),
@@ -305,7 +388,7 @@ mod tests {
     async fn direct_udp_drops_an_oversized_response_without_truncating_it() {
         let remote = UdpSocket::bind("127.0.0.1:0").await.unwrap();
         let destination = remote.local_addr().unwrap();
-        let mut transport = DirectDatagramTransport::new(Dialer::default(), 4);
+        let mut transport = DirectDatagramTransport::new(Dialer::default(), 4, Default::default());
         transport
             .send(Datagram {
                 remote: Destination::Ip(destination),
diff --git a/src/outbound/dns.rs b/src/outbound/dns.rs
new file mode 100644
index 0000000..86927f7
--- /dev/null
+++ b/src/outbound/dns.rs
@@ -0,0 +1,362 @@
+//! A functional DNS route reusing the running session's resolver.
+use std::{
+    io,
+    pin::Pin,
+    sync::{Arc, Mutex, Weak},
+    task::{Context, Poll},
+};
+
+use async_trait::async_trait;
+use bytes::Bytes;
+use tokio::{
+    io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt, DuplexStream, ReadBuf},
+    sync::mpsc,
+    task::JoinHandle,
+    time::Instant,
+};
+use tokio_util::{sync::CancellationToken, task::TaskTracker};
+
+use crate::{
+    dispatch::{BoxStream, DatagramBudget, DatagramTransport, DispatchError},
+    dns::{
+        MAX_MESSAGE_SIZE,
+        runtime::{DnsWireResponse, RuntimeDns, RuntimeDnsError},
+    },
+    session::{Datagram, Destination, StreamSession},
+};
+
+use super::{ConnectedStream, DatagramRequest, EstablishContext, OutboundConnector};
+
+const TCP_DNS_DUPLEX_CAPACITY: usize = 8 * 1024;
+const DATAGRAM_QUEUE_CAPACITY: usize = 1;
+
+/// Also implemented by the router's DNS seam, so TUN hijacking and named
+/// functional DNS routes share the framing and cancellation implementation.
+#[async_trait]
+pub(crate) trait DnsExchange: Send + Sync {
+    async fn exchange(&self, query: &[u8]) -> Result<DnsWireResponse, DispatchError>;
+}
+
+struct RuntimeExchange(Weak<RuntimeDns>);
+
+#[async_trait]
+impl DnsExchange for RuntimeExchange {
+    async fn exchange(&self, query: &[u8]) -> Result<DnsWireResponse, DispatchError> {
+        let dns = self.0.upgrade().ok_or(DispatchError::HostUnreachable)?;
+        dns.exchange_retained(query)
+            .await
+            .map_err(|error| match error {
+                RuntimeDnsError::RuleEvaluation(failure) => DispatchError::RuleEvaluation(failure),
+                _ => DispatchError::HostUnreachable,
+            })
+    }
+}
+
+#[derive(Default)]
+pub(crate) struct DnsOutbound {
+    admission: Mutex<()>,
+    cancel: CancellationToken,
+    tasks: TaskTracker,
+}
+
+impl DnsOutbound {
+    fn exchange(context: &EstablishContext) -> Result<Arc<dyn DnsExchange>, DispatchError> {
+        if context.deadline() <= Instant::now() {
+            return Err(DispatchError::TimedOut);
+        }
+        let dns = context
+            .resolution()
+            .runtime_dns()
+            .filter(|dns| dns.is_enabled())
+            .ok_or(DispatchError::HostUnreachable)?;
+        Ok(Arc::new(RuntimeExchange(Arc::downgrade(&dns))))
+    }
+}
+
+#[async_trait]
+impl OutboundConnector for DnsOutbound {
+    async fn connect_stream(
+        &self,
+        session: StreamSession,
+        context: &EstablishContext,
+    ) -> Result<ConnectedStream, DispatchError> {
+        let exchange = Self::exchange(context)?;
+        let _admission = self
+            .admission
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
+        if self.cancel.is_cancelled() {
+            return Err(DispatchError::NotAllowed);
+        }
+        Ok(ConnectedStream {
+            io: dns_tcp_stream(exchange, self.cancel.child_token(), Some(&self.tasks)),
+            effective_peer: session.destination,
+        })
+    }
+
+    async fn open_datagram(
+        &self,
+        request: DatagramRequest,
+        context: &EstablishContext,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        let exchange = Self::exchange(context)?;
+        let _admission = self
+            .admission
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
+        if self.cancel.is_cancelled() {
+            return Err(DispatchError::NotAllowed);
+        }
+        let cancel = self.cancel.child_token();
+        let (queries, receiver) = mpsc::channel(DATAGRAM_QUEUE_CAPACITY);
+        let (sender, responses) = mpsc::channel(DATAGRAM_QUEUE_CAPACITY);
+        let response_limit = usize::from(request.max_response_payload_size()).min(MAX_MESSAGE_SIZE);
+        let worker = self
+            .tasks
+            .spawn(crate::resources::observation::task(dns_datagrams(
+                exchange,
+                receiver,
+                sender,
+                cancel.clone(),
+                response_limit,
+            )));
+        Ok(crate::dispatch::bound_datagram(
+            Box::new(DnsDatagram {
+                queries,
+                responses,
+                cancel,
+                worker: Some(worker),
+                response_limit: response_limit as u16,
+            }),
+            request.budget(),
+        ))
+    }
+
+    fn begin_shutdown(&self) {
+        let _admission = self
+            .admission
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
+        self.cancel.cancel();
+        self.tasks.close();
+    }
+
+    async fn shutdown(&self) {
+        self.begin_shutdown();
+        self.tasks.wait().await;
+    }
+}
+
+/// The stream owns its worker handle; an abandoned inbound cannot detach a DNS
+/// exchange. The optional tracker additionally joins named-node work at Stop.
+pub(crate) fn dns_tcp_stream(
+    exchange: Arc<dyn DnsExchange>,
+    cancel: CancellationToken,
+    tasks: Option<&TaskTracker>,
+) -> BoxStream {
+    let (client, server) = tokio::io::duplex(TCP_DNS_DUPLEX_CAPACITY);
+    let relay = crate::resources::observation::task(dns_tcp_relay(server, exchange, cancel));
+    let relay = match tasks {
+        Some(tasks) => tasks.spawn(relay),
+        None => tokio::spawn(relay),
+    };
+    Box::new(DnsTcpStream {
+        inner: client,
+        relay,
+    })
+}
+
+async fn dns_tcp_relay(
+    mut server: DuplexStream,
+    exchange: Arc<dyn DnsExchange>,
+    cancel: CancellationToken,
+) {
+    let mut query = vec![0_u8; MAX_MESSAGE_SIZE];
+    let mut length = [0_u8; 2];
+    loop {
+        let read = tokio::select! { biased;
+            () = cancel.cancelled() => break,
+            read = server.read_exact(&mut length) => read,
+        };
+        if read.is_err() {
+            break;
+        }
+        let length = usize::from(u16::from_be_bytes(length));
+        if !(1..=MAX_MESSAGE_SIZE).contains(&length) {
+            break;
+        }
+        let read = tokio::select! { biased;
+            () = cancel.cancelled() => break,
+            read = server.read_exact(&mut query[..length]) => read,
+        };
+        if read.is_err() {
+            break;
+        }
+        let response = tokio::select! { biased;
+            () = cancel.cancelled() => break,
+            response = exchange.exchange(&query[..length]) => response,
+        };
+        let Ok(response) = response else { break };
+        if response.wire().is_empty() || response.wire().len() > MAX_MESSAGE_SIZE {
+            break;
+        }
+        let write = async {
+            server
+                .write_all(&(response.wire().len() as u16).to_be_bytes())
+                .await?;
+            server.write_all(response.wire()).await
+        };
+        let written = tokio::select! { biased;
+            () = cancel.cancelled() => break,
+            written = write => written,
+        };
+        if written.is_err() {
+            break;
+        }
+    }
+    let _ = server.shutdown().await;
+}
+
+struct DnsTcpStream {
+    inner: DuplexStream,
+    relay: JoinHandle<()>,
+}
+
+impl AsyncRead for DnsTcpStream {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        context: &mut Context<'_>,
+        buffer: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.inner).poll_read(context, buffer)
+    }
+}
+
+impl AsyncWrite for DnsTcpStream {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        context: &mut Context<'_>,
+        input: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        Pin::new(&mut self.inner).poll_write(context, input)
+    }
+    fn poll_flush(mut self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.inner).poll_flush(context)
+    }
+    fn poll_shutdown(mut self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.inner).poll_shutdown(context)
+    }
+}
+
+impl Drop for DnsTcpStream {
+    fn drop(&mut self) {
+        self.relay.abort();
+    }
+}
+
+struct DnsPacket {
+    remote: Destination,
+    response: DnsWireResponse,
+}
+
+impl DnsPacket {
+    fn into_datagram(self) -> Datagram {
+        Datagram {
+            remote: self.remote,
+            payload: Bytes::from(self.response.into_wire()),
+            sniffed_domain: None,
+        }
+    }
+}
+
+async fn dns_datagrams(
+    exchange: Arc<dyn DnsExchange>,
+    mut queries: mpsc::Receiver<Datagram>,
+    responses: mpsc::Sender<DnsPacket>,
+    cancel: CancellationToken,
+    response_limit: usize,
+) {
+    loop {
+        let query = tokio::select! { biased;
+            () = cancel.cancelled() => break,
+            query = queries.recv() => match query { Some(query) => query, None => break },
+        };
+        let result = tokio::select! { biased;
+            () = cancel.cancelled() => break,
+            result = exchange.exchange(&query.payload) => result,
+        };
+        let Ok(response) = result else { continue };
+        if response.wire().is_empty() || response.wire().len() > response_limit {
+            continue;
+        }
+        let response = DnsPacket {
+            remote: query.remote,
+            response,
+        };
+        tokio::select! { biased;
+            () = cancel.cancelled() => break,
+            sent = responses.send(response) => if sent.is_err() { break },
+        }
+    }
+}
+
+struct DnsDatagram {
+    queries: mpsc::Sender<Datagram>,
+    responses: mpsc::Receiver<DnsPacket>,
+    cancel: CancellationToken,
+    worker: Option<JoinHandle<()>>,
+    response_limit: u16,
+}
+
+#[async_trait]
+impl DatagramTransport for DnsDatagram {
+    fn supports_shared_destinations(&self) -> bool {
+        true
+    }
+
+    fn payload_budget(&self, _peer: &Destination) -> DatagramBudget {
+        DatagramBudget::new(MAX_MESSAGE_SIZE as u16, self.response_limit)
+    }
+
+    async fn send(&mut self, packet: Datagram) -> Result<(), DispatchError> {
+        if self.cancel.is_cancelled() {
+            return Err(DispatchError::NotAllowed);
+        }
+        if packet.payload.len() > MAX_MESSAGE_SIZE {
+            return Ok(());
+        }
+        match self.queries.try_send(packet) {
+            Ok(()) | Err(mpsc::error::TrySendError::Full(_)) => Ok(()),
+            Err(mpsc::error::TrySendError::Closed(_)) => Err(DispatchError::NotAllowed),
+        }
+    }
+
+    async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+        tokio::select! { biased;
+            () = self.cancel.cancelled() => Err(DispatchError::NotAllowed),
+            response = self.responses.recv() => response.map(DnsPacket::into_datagram).ok_or(DispatchError::NotAllowed),
+        }
+    }
+
+    async fn close(&mut self) -> Result<(), DispatchError> {
+        self.cancel.cancel();
+        self.responses.close();
+        if let Some(worker) = self.worker.take() {
+            let _ = worker.await;
+        }
+        Ok(())
+    }
+}
+
+impl Drop for DnsDatagram {
+    fn drop(&mut self) {
+        self.cancel.cancel();
+        if let Some(worker) = &self.worker {
+            worker.abort();
+        }
+    }
+}
+
+#[cfg(test)]
+#[path = "dns_tests.rs"]
+mod tests;
diff --git a/src/outbound/dns_tests.rs b/src/outbound/dns_tests.rs
new file mode 100644
index 0000000..6a14342
--- /dev/null
+++ b/src/outbound/dns_tests.rs
@@ -0,0 +1,206 @@
+use super::*;
+use crate::{
+    config::Config,
+    dispatch::Dispatcher,
+    dns::resolution::ResolutionContext,
+    dns::{QueryType, RecordData, build_query, parse_response},
+    session::{DatagramSession, InboundKind, InboundMetadata},
+};
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::time::Duration;
+
+#[derive(Default)]
+struct NoNetwork(AtomicUsize);
+
+#[async_trait]
+impl Dispatcher for NoNetwork {
+    async fn connect_tcp(&self, _: StreamSession) -> Result<BoxStream, DispatchError> {
+        self.0.fetch_add(1, Ordering::Relaxed);
+        Err(DispatchError::NotAllowed)
+    }
+    async fn open_datagram(
+        &self,
+        _: DatagramSession,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        self.0.fetch_add(1, Ordering::Relaxed);
+        Err(DispatchError::NotAllowed)
+    }
+}
+
+fn context() -> (Arc<RuntimeDns>, EstablishContext, Arc<NoNetwork>) {
+    let config = Config::parse_yaml(
+        br#"
+hosts: {unit.test: 192.0.2.8}
+dns:
+  enable: true
+  use-system-hosts: false
+  nameserver: [192.0.2.53]
+"#,
+    )
+    .unwrap();
+    let no_network = Arc::new(NoNetwork::default());
+    let dns = Arc::new(RuntimeDns::new(&config.dns, no_network.clone()));
+    let resolution = ResolutionContext::runtime(false);
+    resolution.bind_runtime(Some(&dns)).unwrap();
+    (
+        dns,
+        EstablishContext::with_resolution(Duration::from_secs(10), resolution),
+        no_network,
+    )
+}
+
+fn session() -> StreamSession {
+    StreamSession {
+        metadata: InboundMetadata::new(8053),
+        inbound: InboundKind::Tun,
+        source: "192.0.2.10:12345".parse().unwrap(),
+        destination: Destination::domain("functional.test", 8053).unwrap(),
+        sniffed_domain: None,
+    }
+}
+
+fn request() -> DatagramRequest {
+    DatagramRequest::new(DatagramSession::new(
+        InboundKind::InternalDns,
+        "192.0.2.10:12345".parse().unwrap(),
+    ))
+}
+
+fn assert_response(wire: &[u8], id: u16) {
+    let response = parse_response(wire).unwrap();
+    assert_eq!(response.id, id);
+    assert_eq!(response.question.name, "unit.test");
+    assert_eq!(
+        response.answers[0].data,
+        RecordData::A("192.0.2.8".parse().unwrap())
+    );
+}
+
+#[tokio::test]
+async fn named_dns_tcp_reuses_runtime_dns_and_keeps_framing_after_half_close() {
+    let (_dns, context, no_network) = context();
+    let node = DnsOutbound::default();
+    let connected = node.connect_stream(session(), &context).await.unwrap();
+    assert_eq!(connected.effective_peer, session().destination);
+    let mut stream = connected.io;
+    for id in [7, 8] {
+        let query = build_query(id, "unit.test", QueryType::A).unwrap();
+        stream
+            .write_all(&(query.len() as u16).to_be_bytes())
+            .await
+            .unwrap();
+        stream.write_all(&query).await.unwrap();
+        if id == 8 {
+            stream.shutdown().await.unwrap();
+        }
+        let length = usize::from(stream.read_u16().await.unwrap());
+        let mut response = vec![0; length];
+        stream.read_exact(&mut response).await.unwrap();
+        assert_response(&response, id);
+    }
+    assert_eq!(stream.read(&mut [0]).await.unwrap(), 0);
+    node.shutdown().await;
+    assert_eq!(no_network.0.load(Ordering::Relaxed), 0);
+}
+
+#[tokio::test]
+async fn named_dns_udp_preserves_original_peer_and_uses_shared_engine() {
+    let (_dns, context, no_network) = context();
+    let node = DnsOutbound::default();
+    let mut transport = node.open_datagram(request(), &context).await.unwrap();
+    for id in [11, 12] {
+        let remote = Destination::domain(format!("peer-{id}.test"), 8053).unwrap();
+        transport
+            .send(Datagram {
+                remote: remote.clone(),
+                payload: Bytes::from(build_query(id, "unit.test", QueryType::A).unwrap()),
+                sniffed_domain: None,
+            })
+            .await
+            .unwrap();
+        let response = transport.receive().await.unwrap();
+        assert_eq!(response.remote, remote);
+        assert_response(&response.payload, id);
+    }
+    transport.close().await.unwrap();
+    node.shutdown().await;
+    assert_eq!(no_network.0.load(Ordering::Relaxed), 0);
+}
+
+#[tokio::test]
+async fn named_dns_stop_cancels_idle_relays_and_closes_admission() {
+    let (_dns, context, no_network) = context();
+    let node = DnsOutbound::default();
+    let mut stream = node.connect_stream(session(), &context).await.unwrap().io;
+    let mut transport = node.open_datagram(request(), &context).await.unwrap();
+    let mut byte = [0];
+    let read = stream.read(&mut byte);
+    tokio::pin!(read);
+    assert!(futures_util::poll!(&mut read).is_pending());
+    node.begin_shutdown();
+    assert_eq!(read.await.unwrap(), 0);
+    assert!(transport.receive().await.is_err());
+    assert!(node.connect_stream(session(), &context).await.is_err());
+    assert!(node.open_datagram(request(), &context).await.is_err());
+    tokio::time::timeout(Duration::from_secs(1), node.shutdown())
+        .await
+        .unwrap();
+    assert_eq!(no_network.0.load(Ordering::Relaxed), 0);
+}
+
+#[tokio::test]
+async fn named_dns_requires_the_running_session_resolver() {
+    let node = DnsOutbound::default();
+    assert!(
+        node.connect_stream(session(), &EstablishContext::default())
+            .await
+            .is_err()
+    );
+    assert!(
+        node.open_datagram(request(), &EstablishContext::default())
+            .await
+            .is_err()
+    );
+}
+
+#[tokio::test(start_paused = true)]
+async fn dns_reserved_reject_tokens_never_reach_the_physical_dispatcher() {
+    for (token, transport) in [("REJECT", "tcp"), ("REJECT", "udp"), ("REJECT-DROP", "udp")] {
+        let config = Config::parse_yaml(format!("dns:\n  enable: true\n  use-system-hosts: false\n  nameserver: ['{transport}://192.0.2.53#{token}']\n").as_bytes()).unwrap();
+        let no_network = Arc::new(NoNetwork::default());
+        let dns = RuntimeDns::new(&config.dns, no_network.clone());
+        let query = build_query(21, "rejected.test", QueryType::A).unwrap();
+        let before = Instant::now();
+        let response = dns.exchange(&query).await.unwrap();
+        assert_eq!(parse_response(&response).unwrap().rcode, 2);
+        assert_eq!(no_network.0.load(Ordering::Relaxed), 0);
+        assert_eq!(Instant::now(), before);
+        dns.shutdown().await;
+    }
+}
+
+#[tokio::test(start_paused = true)]
+async fn dns_drop_tcp_wait_is_cancelled_by_its_resolver_stop_owner() {
+    let config = Config::parse_yaml(
+        br#"
+dns:
+  enable: true
+  use-system-hosts: false
+  nameserver: ['tcp://192.0.2.53#REJECT-DROP']
+"#,
+    )
+    .unwrap();
+    let no_network = Arc::new(NoNetwork::default());
+    let dns = RuntimeDns::new(&config.dns, no_network.clone());
+    let query = build_query(22, "rejected.test", QueryType::A).unwrap();
+    let exchange = dns.exchange(&query);
+    tokio::pin!(exchange);
+    assert!(futures_util::poll!(&mut exchange).is_pending());
+    let stopped = Instant::now();
+    dns.begin_shutdown();
+    let response = exchange.await.unwrap();
+    assert_eq!(parse_response(&response).unwrap().rcode, 2);
+    assert_eq!(Instant::now(), stopped);
+    assert_eq!(no_network.0.load(Ordering::Relaxed), 0);
+    dns.shutdown().await;
+}
diff --git a/src/outbound/http.rs b/src/outbound/http.rs
new file mode 100644
index 0000000..60a5ac9
--- /dev/null
+++ b/src/outbound/http.rs
@@ -0,0 +1,230 @@
+//! HTTP/1.1 CONNECT over a shared plain or TLS upstream stream.
+use crate::{
+    config::HttpOutboundConfig,
+    dispatch::{BoxStream, DatagramTransport, DispatchError},
+    outbound::{
+        ConnectedStream, DatagramRequest, EstablishContext, OutboundConnector, UpstreamPath,
+        server_destination,
+    },
+    security::{SecurityContext, StandardTlsClient, TlsClientIdentity, TlsClientOptions},
+    session::{Destination, StreamSession},
+};
+use async_trait::async_trait;
+use std::{collections::BTreeMap, io};
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+pub struct HttpOutbound {
+    server: Destination,
+    upstream: UpstreamPath,
+    tls: Option<StandardTlsClient>,
+    headers: BTreeMap<String, String>,
+    authorization: Option<String>,
+}
+impl HttpOutbound {
+    pub(crate) fn with_shared_security(
+        config: &HttpOutboundConfig,
+        upstream: UpstreamPath,
+        security: &SecurityContext,
+        sessions: usize,
+        buffer_limit: usize,
+    ) -> io::Result<Self> {
+        let tls = config
+            .tls
+            .as_ref()
+            .map(|config| {
+                StandardTlsClient::with_options(
+                    security,
+                    &config.server_name,
+                    TlsClientOptions {
+                        alpn: config.alpn.clone(),
+                        certificate: config.certificate.clone(),
+                        identity: config
+                            .identity
+                            .as_ref()
+                            .map(|identity| TlsClientIdentity::from_config(identity, security))
+                            .transpose()?,
+                        ..Default::default()
+                    },
+                    sessions,
+                    buffer_limit,
+                )
+            })
+            .transpose()?;
+        Ok(Self {
+            server: server_destination(&config.address, config.port)?,
+            upstream,
+            tls,
+            headers: config.headers.clone(),
+            authorization: config
+                .auth
+                .as_ref()
+                .map(|auth| auth.authorization_header_value()),
+        })
+    }
+}
+async fn handshake(
+    mut stream: BoxStream,
+    target: &Destination,
+    headers: &BTreeMap<String, String>,
+    authorization: Option<&str>,
+) -> io::Result<BoxStream> {
+    let authority = match target {
+        Destination::Ip(address) => address.to_string(),
+        Destination::Domain { host, port } => format!("{host}:{port}"),
+    };
+    let mut fields = BTreeMap::from([
+        ("host".to_owned(), authority.clone()),
+        ("proxy-connection".into(), "Keep-Alive".into()),
+        (
+            "user-agent".into(),
+            concat!("Vole/", env!("CARGO_PKG_VERSION")).into(),
+        ),
+    ]);
+    for (name, value) in headers {
+        fields.insert(name.to_ascii_lowercase(), value.clone());
+    }
+    if let Some(value) = authorization {
+        fields.insert("proxy-authorization".into(), value.into());
+    }
+    let mut request = format!("CONNECT {authority} HTTP/1.1\r\n");
+    for (name, value) in fields {
+        request.push_str(&format!("{name}: {value}\r\n"));
+    }
+    request.push_str("\r\n");
+    stream.write_all(request.as_bytes()).await?;
+    stream.flush().await?;
+    let mut total = 0;
+    loop {
+        let mut head = Vec::new();
+        // Exact reads preserve application bytes coalesced with the response.
+        while !head.ends_with(b"\r\n\r\n") {
+            if total >= 32 * 1024 {
+                return Err(io::Error::new(
+                    io::ErrorKind::InvalidData,
+                    "HTTP CONNECT response too large",
+                ));
+            }
+            head.push(stream.read_u8().await?);
+            total += 1;
+        }
+        let status = crate::resource::probe::parse_status(&head)?;
+        if (100..200).contains(&status) && status != 101 {
+            continue;
+        }
+        if status != 200 {
+            // A remote rejection is a failed proxy connection. PermissionDenied
+            // becomes NotAllowed, which group health excludes as a local policy.
+            return Err(io::Error::new(
+                io::ErrorKind::ConnectionRefused,
+                "HTTP CONNECT was rejected",
+            ));
+        }
+        return Ok(stream);
+    }
+}
+#[async_trait]
+impl OutboundConnector for HttpOutbound {
+    async fn connect_stream(
+        &self,
+        session: StreamSession,
+        context: &EstablishContext,
+    ) -> Result<ConnectedStream, DispatchError> {
+        if tokio::time::Instant::now() >= context.deadline() {
+            return Err(DispatchError::TimedOut);
+        }
+        let target = session.destination.clone();
+        let raw = self
+            .upstream
+            .connect_server(session, &self.server, context)
+            .await?;
+        let io = match &self.tls {
+            Some(tls) => {
+                context
+                    .run_io("HTTP proxy TLS", tls.connect(raw.io))
+                    .await?
+            }
+            None => raw.io,
+        };
+        let io = context
+            .run_io(
+                "HTTP CONNECT",
+                handshake(io, &target, &self.headers, self.authorization.as_deref()),
+            )
+            .await?;
+        Ok(ConnectedStream {
+            io,
+            effective_peer: target,
+        })
+    }
+    async fn open_datagram(
+        &self,
+        _: DatagramRequest,
+        _: &EstablishContext,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        Err(DispatchError::NotAllowed)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[tokio::test(start_paused = true)]
+    async fn stalled_connect_obeys_deadline_and_releases_stream() {
+        let (client, mut peer) = tokio::io::duplex(4096);
+        let context = EstablishContext::with_timeout(std::time::Duration::from_secs(1));
+        let result = context
+            .run_io(
+                "HTTP CONNECT",
+                handshake(
+                    Box::new(client),
+                    &Destination::Ip("192.0.2.1:443".parse().unwrap()),
+                    &BTreeMap::new(),
+                    None,
+                ),
+            )
+            .await;
+        assert!(matches!(result, Err(DispatchError::TimedOut)));
+        let mut request = Vec::new();
+        peer.read_to_end(&mut request).await.unwrap();
+        assert!(request.ends_with(b"\r\n\r\n"));
+    }
+    #[tokio::test]
+    async fn connect_auth_and_prebuffer_are_preserved() {
+        for status in [200, 407, 503] {
+            let (client, mut peer) = tokio::io::duplex(4096);
+            let remote = tokio::spawn(async move {
+                let mut request = Vec::new();
+                while !request.ends_with(b"\r\n\r\n") {
+                    request.push(peer.read_u8().await.unwrap());
+                }
+                let text = String::from_utf8(request).unwrap();
+                assert!(text.starts_with("CONNECT example.com:443 HTTP/1.1\r\n"));
+                assert!(text.contains("proxy-authorization: Basic dTpw\r\n"));
+                assert!(text.contains("x-proxy: custom\r\n"));
+                peer.write_all(format!("HTTP/1.1 {status} Status\r\n\r\nfirst-byte").as_bytes())
+                    .await
+                    .unwrap();
+            });
+            let result = handshake(
+                Box::new(client),
+                &Destination::Domain {
+                    host: "example.com".into(),
+                    port: 443,
+                },
+                &BTreeMap::from([("X-Proxy".into(), "custom".into())]),
+                Some("Basic dTpw"),
+            )
+            .await;
+            if status == 200 {
+                let mut bytes = [0; 10];
+                result.unwrap().read_exact(&mut bytes).await.unwrap();
+                assert_eq!(&bytes, b"first-byte");
+            } else {
+                assert_eq!(
+                    result.err().unwrap().kind(),
+                    io::ErrorKind::ConnectionRefused
+                );
+            }
+            remote.await.unwrap();
+        }
+    }
+}
diff --git a/src/outbound/hysteria2/bandwidth.rs b/src/outbound/hysteria2/bandwidth.rs
index eee9887..72e95b5 100644
--- a/src/outbound/hysteria2/bandwidth.rs
+++ b/src/outbound/hysteria2/bandwidth.rs
@@ -5,7 +5,7 @@ use crate::{
 use async_trait::async_trait;
 use quinn_proto::{
     RttEstimator,
-    congestion::{BbrConfig, Controller, ControllerFactory},
+    congestion::{Controller, ControllerFactory, CubicConfig},
 };
 use std::{
     io,
@@ -57,24 +57,31 @@ impl Bucket {
     }
 }
 
-/// Rate zero uses Quinn BBR. A positive negotiated rate installs Brutal's
+/// Rate zero uses official Quinn CUBIC. A positive negotiated rate installs Brutal's
 /// fixed-rate window policy and a separate wire-byte pacer. Quinn's own cwnd
 /// pacer is retained, but is not relied on as a configured bandwidth limit.
 pub(super) struct Bandwidth {
     pub rate: AtomicU64,
     ratio: AtomicU64,
+    pacer: Arc<Pacer>,
+}
+#[derive(Default)]
+pub(super) struct Pacer {
     bucket: Mutex<Bucket>,
 }
 impl Default for Bandwidth {
     fn default() -> Self {
+        Self::with_pacer(Arc::new(Pacer::default()))
+    }
+}
+impl Bandwidth {
+    pub fn with_pacer(pacer: Arc<Pacer>) -> Self {
         Self {
             rate: AtomicU64::new(0),
             ratio: AtomicU64::new(1_000_000),
-            bucket: Mutex::new(Bucket::default()),
+            pacer,
         }
     }
-}
-impl Bandwidth {
     pub fn wrap(
         self: &Arc<Self>,
         inner: Box<dyn DatagramTransport>,
@@ -93,10 +100,14 @@ impl Bandwidth {
     }
     pub async fn pace(&self, bytes: usize, mtu: u16) {
         loop {
-            let delay = self.bucket.lock().unwrap().claim(
+            let rate = self.compensated();
+            if rate == 0 {
+                return;
+            }
+            let delay = self.pacer.bucket.lock().unwrap().claim(
                 tokio::time::Instant::now().into_std(),
                 bytes,
-                self.compensated(),
+                rate,
                 mtu,
             );
             if delay.is_zero() {
@@ -114,9 +125,36 @@ struct Paced {
 }
 #[async_trait]
 impl DatagramTransport for Paced {
+    fn supports_shared_destinations(&self) -> bool {
+        self.inner.supports_shared_destinations()
+    }
+
+    fn supports_poll_receive(&self) -> bool {
+        self.inner.supports_poll_receive()
+    }
+    fn poll_receive(
+        &mut self,
+        context: &mut std::task::Context<'_>,
+        scratch: &mut Vec<u8>,
+    ) -> std::task::Poll<Result<Datagram, DispatchError>> {
+        self.inner.poll_receive(context, scratch)
+    }
     fn payload_budget(&self, peer: &Destination) -> DatagramBudget {
         self.inner.payload_budget(peer)
     }
+    fn send_owned(
+        &mut self,
+        packet: Datagram,
+    ) -> Result<crate::dispatch::OwnedDatagramSend, Datagram> {
+        let bytes = packet.payload.len();
+        let send = self.inner.send_owned(packet)?;
+        let bandwidth = self.bandwidth.clone();
+        let mtu = self.mtu;
+        Ok(Box::pin(async move {
+            bandwidth.pace(bytes, mtu).await;
+            send.await
+        }))
+    }
     async fn send(&mut self, packet: Datagram) -> Result<(), DispatchError> {
         self.bandwidth.pace(packet.payload.len(), self.mtu).await;
         self.inner.send(packet).await
@@ -131,7 +169,7 @@ impl DatagramTransport for Paced {
 impl ControllerFactory for Bandwidth {
     fn build(self: Arc<Self>, now: Instant, mtu: u16) -> Box<dyn Controller> {
         Box::new(Switchable {
-            bbr: Arc::new(BbrConfig::default()).build(now, mtu),
+            automatic: Arc::new(CubicConfig::default()).build(now, mtu),
             shared: self,
             start: now,
             slots: [Slot::default(); 5],
@@ -147,7 +185,7 @@ struct Slot {
     lost: u64,
 }
 struct Switchable {
-    bbr: Box<dyn Controller>,
+    automatic: Box<dyn Controller>,
     shared: Arc<Bandwidth>,
     start: Instant,
     slots: [Slot; 5],
@@ -187,7 +225,7 @@ impl Switchable {
 }
 impl Controller for Switchable {
     fn on_sent(&mut self, now: Instant, bytes: u64, packet: u64) {
-        self.bbr.on_sent(now, bytes, packet);
+        self.automatic.on_sent(now, bytes, packet);
     }
     fn on_ack(
         &mut self,
@@ -197,24 +235,25 @@ impl Controller for Switchable {
         limited: bool,
         rtt: &RttEstimator,
     ) {
-        self.bbr.on_ack(now, sent, bytes, limited, rtt);
+        self.automatic.on_ack(now, sent, bytes, limited, rtt);
         self.rtt = rtt.get();
         self.sample(now, u64::from(bytes > 0), 0);
     }
     fn on_end_acks(&mut self, now: Instant, flight: u64, limited: bool, largest: Option<u64>) {
-        self.bbr.on_end_acks(now, flight, limited, largest);
+        self.automatic.on_end_acks(now, flight, limited, largest);
     }
     fn on_congestion_event(&mut self, now: Instant, sent: Instant, persistent: bool, lost: u64) {
-        self.bbr.on_congestion_event(now, sent, persistent, lost);
+        self.automatic
+            .on_congestion_event(now, sent, persistent, lost);
         self.sample(now, 0, lost.div_ceil(u64::from(self.mtu)));
     }
     fn on_mtu_update(&mut self, mtu: u16) {
         self.mtu = mtu;
-        self.bbr.on_mtu_update(mtu);
+        self.automatic.on_mtu_update(mtu);
     }
     fn window(&self) -> u64 {
         if self.shared.rate.load(Ordering::Relaxed) == 0 {
-            return self.bbr.window();
+            return self.automatic.window();
         }
         // Keep enough flight space for Quinn's delayed ACKs at very low RTT.
         // The independent wire pacer, not this floor, enforces the exact rate.
@@ -223,11 +262,11 @@ impl Controller for Switchable {
             .max(u64::from(self.mtu) * 2)
     }
     fn initial_window(&self) -> u64 {
-        self.bbr.initial_window()
+        self.automatic.initial_window()
     }
     fn clone_box(&self) -> Box<dyn Controller> {
         Box::new(Self {
-            bbr: self.bbr.clone_box(),
+            automatic: self.automatic.clone_box(),
             shared: self.shared.clone(),
             start: self.start,
             slots: self.slots,
@@ -262,13 +301,29 @@ pub(super) fn negotiate(up: u64, server: &[u8]) -> io::Result<u64> {
 
 #[cfg(test)]
 mod tests {
+    #[tokio::test(start_paused = true)]
+    async fn sibling_connections_share_one_wire_credit_bucket() {
+        let pacer = std::sync::Arc::new(super::Pacer::default());
+        let first = super::Bandwidth::with_pacer(pacer.clone());
+        let second = super::Bandwidth::with_pacer(pacer.clone());
+        for connection in [&first, &second] {
+            connection
+                .rate
+                .store(125000, std::sync::atomic::Ordering::Relaxed);
+            for _ in 0..5 {
+                connection.pace(1400, 1400).await;
+            }
+        }
+        // An automatic connection must not reset the fixed-rate budget.
+        super::Bandwidth::with_pacer(pacer).pace(1400, 1400).await;
+        let mut pending = Box::pin(first.pace(1400, 1400));
+        assert!(futures_util::poll!(pending.as_mut()).is_pending());
+        tokio::time::advance(std::time::Duration::from_millis(12)).await;
+        assert!(futures_util::poll!(pending.as_mut()).is_ready());
+    }
+
     #[test]
     fn pacer_limits_actual_bytes_after_one_bounded_burst() {
-        #[cfg(feature = "interop-test")]
-        let _case = crate::resources::case_events::Case::new(
-            "HYSTERIA2-UNIT",
-            "pacer_limits_actual_bytes_after_one_bounded_burst",
-        );
         use std::time::{Duration, Instant};
         let now = Instant::now();
         let mut bucket = super::Bucket::default();
@@ -290,11 +345,6 @@ mod tests {
     }
     #[test]
     fn bandwidth_negotiation_obeys_auto_and_the_lower_positive_limit() {
-        #[cfg(feature = "interop-test")]
-        let _case = crate::resources::case_events::Case::new(
-            "HYSTERIA2-UNIT",
-            "bandwidth_negotiation_obeys_auto_and_the_lower_positive_limit",
-        );
         for (up, response, expected) in [
             (0, "0", 0),
             (0, "100000", 0),
diff --git a/src/outbound/hysteria2/datagram.rs b/src/outbound/hysteria2/datagram.rs
index 7931b91..6f7e44d 100644
--- a/src/outbound/hysteria2/datagram.rs
+++ b/src/outbound/hysteria2/datagram.rs
@@ -26,10 +26,16 @@ const PENDING_PACKETS: usize = crate::limits::HY2_PENDING_PACKETS;
 const PENDING_BYTES: usize = crate::limits::HY2_PENDING_BYTES;
 const TTL: Duration = Duration::from_secs(crate::limits::HY2_FRAGMENT_TTL_SECONDS as u64);
 
-#[derive(Default)]
 pub(super) struct Registry {
     next: AtomicU32,
     entries: Mutex<HashMap<u32, Registration>>,
+    outgoing: mpsc::Sender<Submission>,
+}
+pub(super) struct Submission {
+    session: u32,
+    packet: u16,
+    datagram: Datagram,
+    mtu: u16,
 }
 struct Registration {
     sender: mpsc::Sender<Datagram>,
@@ -38,6 +44,17 @@ struct Registration {
 }
 
 impl Registry {
+    pub fn new() -> (Self, mpsc::Receiver<Submission>) {
+        let (outgoing, submissions) = mpsc::channel(crate::limits::HY2_SUBMISSION_QUEUE);
+        (
+            Self {
+                next: AtomicU32::new(0),
+                entries: Mutex::new(HashMap::new()),
+                outgoing,
+            },
+            submissions,
+        )
+    }
     pub fn open(
         self: &Arc<Self>,
         connection: quinn::Connection,
@@ -114,6 +131,12 @@ impl Drop for Transport {
 
 #[async_trait]
 impl DatagramTransport for Transport {
+    fn supports_shared_destinations(&self) -> bool {
+        // A session ID owns a multi-target UDP socket, not one destination.
+        // Each complete message carries the reply source for demultiplexing.
+        true
+    }
+
     fn payload_budget(&self, peer: &Destination) -> DatagramBudget {
         let space = self.message_budget().saturating_sub(header(peer).len());
         DatagramBudget::new((space * 255).min(MAX_PAYLOAD) as u16, MAX_PAYLOAD as u16)
@@ -123,30 +146,28 @@ impl DatagramTransport for Transport {
         if self.closed || self.cancel.is_cancelled() {
             return Err(DispatchError::NotAllowed);
         }
-        if datagram.payload.len() > usize::from(self.payload_budget(&datagram.remote).transmit()) {
+        if datagram.remote.port() == 0
+            || self.message_budget() <= header(&datagram.remote).len()
+            || datagram.payload.len()
+                > usize::from(self.payload_budget(&datagram.remote).transmit())
+        {
             return Err(io::Error::new(
                 io::ErrorKind::InvalidInput,
                 "Hysteria2 datagram exceeds payload budget",
             )
             .into());
         }
-        let packets = encode(
-            self.id,
-            self.packet,
-            &datagram.remote,
-            &datagram.payload,
-            self.message_budget(),
-        )?;
+        let permit = tokio::select! {biased;
+            () = self.cancel.cancelled() => return Err(DispatchError::NotAllowed),
+            permit = self.registry.outgoing.reserve() => permit.map_err(|_| DispatchError::ConnectionRefused)?,
+        };
+        permit.send(Submission {
+            session: self.id,
+            packet: self.packet,
+            datagram,
+            mtu: self.mtu,
+        });
         self.packet = self.packet.wrapping_add(1);
-        for (index, packet) in packets.into_iter().enumerate() {
-            tokio::select! {biased;
-                () = self.cancel.cancelled() => return Err(DispatchError::NotAllowed),
-                result = self.connection.send_datagram_wait(packet) => result.map_err(|_| DispatchError::ConnectionRefused)?,
-            }
-            if (index + 1) % crate::limits::IO_POLL_BUDGET == 0 {
-                tokio::task::yield_now().await;
-            }
-        }
         Ok(())
     }
     async fn receive(&mut self) -> Result<Datagram, DispatchError> {
@@ -164,6 +185,52 @@ impl DatagramTransport for Transport {
     }
 }
 
+/// Driven beside receive in the connection's existing owner. Queue raw payloads
+/// so only this one active message retains encoded fragments under backpressure.
+pub(super) async fn transmit(
+    connection: &quinn::Connection,
+    registry: &Registry,
+    mut submissions: mpsc::Receiver<Submission>,
+) -> Result<(), DispatchError> {
+    let mut processed = 0;
+    while let Some(submission) = submissions.recv().await {
+        if registry
+            .entries
+            .lock()
+            .unwrap()
+            .contains_key(&submission.session)
+        {
+            let mtu = connection
+                .max_datagram_size()
+                .unwrap_or(0)
+                .min(usize::from(submission.mtu));
+            // A path/peer limit can shrink after admission. Drop the whole
+            // message instead of truncating or closing sibling associations.
+            if let Ok(packets) = encode(
+                submission.session,
+                submission.packet,
+                &submission.datagram.remote,
+                &submission.datagram.payload,
+                mtu,
+            ) {
+                for packet in packets {
+                    match connection.send_datagram_wait(packet).await {
+                        Ok(()) => {}
+                        Err(quinn::SendDatagramError::TooLarge) => break,
+                        Err(_) => return Err(DispatchError::ConnectionRefused),
+                    }
+                    processed += 1;
+                    if processed == crate::limits::IO_POLL_BUDGET {
+                        processed = 0;
+                        tokio::task::yield_now().await;
+                    }
+                }
+            }
+        }
+    }
+    Err(DispatchError::ConnectionRefused)
+}
+
 fn header(peer: &Destination) -> Vec<u8> {
     let address = peer.authority();
     let mut header = vec![0; 8];
@@ -304,7 +371,15 @@ impl Reassembly {
         }
         if !self.packets.contains_key(&key) {
             if self.packets.len() >= PENDING_PACKETS {
-                return None;
+                // Keep the same bound while making progress after UDP loss.
+                // Otherwise one missing fragment per slot rejects every new
+                // packet until the full TTL expires.
+                let oldest = self
+                    .packets
+                    .iter()
+                    .min_by_key(|(_, packet)| packet.expires)
+                    .map(|(key, _)| *key)?;
+                self.remove(&oldest);
             }
             self.packets.insert(
                 key,
@@ -408,11 +483,6 @@ mod tests {
 
     #[test]
     fn udp_wire_round_trips_at_budget_and_bounds_malformed_fragments() {
-        #[cfg(feature = "interop-test")]
-        let _case = crate::resources::case_events::Case::new(
-            "HYSTERIA2-UNIT",
-            "udp_wire_round_trips_at_budget_and_bounds_malformed_fragments",
-        );
         let peer = Destination::domain("x", 1).unwrap();
         let literal = Bytes::from_static(b"\0\0\0\x01\0\x02\0\x01\x03x:1payload");
         assert_eq!(
@@ -454,12 +524,53 @@ mod tests {
     }
 
     #[test]
-    fn udp_reassembly_isolates_sources_duplicates_counts_bytes_and_expiry() {
-        #[cfg(feature = "interop-test")]
-        let _case = crate::resources::case_events::Case::new(
-            "HYSTERIA2-UNIT",
-            "udp_reassembly_isolates_sources_duplicates_counts_bytes_and_expiry",
+    fn udp_missing_fragments_cannot_block_fresh_complete_packets_until_expiry() {
+        let now = Instant::now();
+        let peer = Destination::domain("x", 1).unwrap();
+        let mut state = Reassembly::default();
+        // Missing suffixes fill the existing global capacity. UDP loss must
+        // not make every subsequent fragmented packet wait the whole TTL.
+        for session in 0..PENDING_PACKETS as u32 {
+            let frames = encode(session, 1, &peer, &[7; 128], 96).unwrap();
+            assert!(
+                state
+                    .push(
+                        decode(frames[0].clone()).unwrap(),
+                        now + Duration::from_nanos(u64::from(session)),
+                        4096
+                    )
+                    .is_none()
+            );
+        }
+        assert_eq!(state.packets.len(), PENDING_PACKETS);
+        let frames = encode(100, 3, &peer, &[9; 128], 96).unwrap();
+        assert!(
+            state
+                .push(
+                    decode(frames[0].clone()).unwrap(),
+                    now + Duration::from_millis(1),
+                    4096
+                )
+                .is_none()
         );
+        let delivered = state
+            .push(
+                decode(frames[1].clone()).unwrap(),
+                now + Duration::from_millis(2),
+                4096,
+            )
+            .expect("fresh complete packet must displace an old missing fragment");
+        assert_eq!(delivered.payload, [9; 128][..]);
+        assert_eq!(state.packets.len(), PENDING_PACKETS - 1);
+        assert!(!state.packets.contains_key(&(0, 1)));
+        assert!(state.bytes <= PENDING_BYTES);
+        state.expire(now + TTL + Duration::from_secs(1), |_| true);
+        assert!(state.packets.is_empty());
+        assert_eq!(state.bytes, 0);
+    }
+
+    #[test]
+    fn udp_reassembly_isolates_sources_duplicates_counts_bytes_and_expiry() {
         let now = Instant::now();
         let peer = Destination::domain("x", 1).unwrap();
         let frames = encode(1, 2, &peer, &[5; 100], 64).unwrap();
@@ -560,7 +671,9 @@ mod tests {
                 .is_none()
         );
         assert_eq!(state.packets.len(), 64);
-        state.expire(now + Duration::from_secs(4), |session| session != 0);
+        assert!(state.packets.contains_key(&(65, 9)));
+        assert_eq!(state.bytes, 63 * 4096 + 1);
+        state.expire(now + Duration::from_secs(4), |session| session != 65);
         assert_eq!(state.packets.len(), 63);
         assert_eq!(state.bytes, 63 * 4096);
         state.expire(now + TTL, |_| true);
diff --git a/src/outbound/hysteria2/gecko.rs b/src/outbound/hysteria2/gecko.rs
new file mode 100644
index 0000000..9d5b2d9
--- /dev/null
+++ b/src/outbound/hysteria2/gecko.rs
@@ -0,0 +1,427 @@
+//! Public Gecko framing over the existing Salamander transport. QUIC remains
+//! the authentication layer. Reassembly is local to one immutable peer.
+use crate::{
+    config::Hysteria2Gecko,
+    dispatch::{DatagramBudget, DatagramTransport, DispatchError},
+    session::{Datagram, Destination},
+};
+use async_trait::async_trait;
+use bytes::Bytes;
+use std::{
+    io,
+    task::{Context, Poll},
+    time::Duration,
+};
+use tokio::time::Instant;
+const HEADER: usize = 5;
+const PENDING: usize = 8;
+const TTL: Duration = Duration::from_secs(8);
+struct Entry {
+    id: u8,
+    total: u8,
+    chunks: [Option<Bytes>; 8],
+    bytes: usize,
+    deadline: Instant,
+}
+struct Gecko {
+    inner: Box<dyn DatagramTransport>,
+    options: Hysteria2Gecko,
+    peer: Destination,
+    limit: u16,
+    next: u8,
+    pending: Vec<Entry>,
+    closed: bool,
+}
+pub(super) fn wrap(
+    inner: Box<dyn DatagramTransport>,
+    options: Hysteria2Gecko,
+    peer: Destination,
+    limit: u16,
+) -> Box<dyn DatagramTransport> {
+    Box::new(Gecko {
+        inner: super::salamander::wrap(inner, &options.password),
+        options,
+        peer,
+        limit,
+        next: rand::random(),
+        pending: Vec::new(),
+        closed: false,
+    })
+}
+fn invalid() -> DispatchError {
+    io::Error::new(io::ErrorKind::InvalidData, "invalid Gecko packet boundary").into()
+}
+impl Gecko {
+    fn accept(&mut self, mut packet: Datagram) -> Option<Datagram> {
+        let now = Instant::now();
+        self.pending.retain(|entry| entry.deadline > now);
+        if self.closed
+            || packet.remote != self.peer
+            || packet.payload.is_empty()
+            || packet.payload.len()
+                > usize::from(self.inner.payload_budget(&packet.remote).receive())
+        {
+            return None;
+        }
+        if packet.payload[0] & 0x80 == 0 {
+            return (packet.payload.len() <= usize::from(self.limit)).then_some(packet);
+        }
+        let b = &packet.payload;
+        if b.len() < HEADER {
+            return None;
+        }
+        let (id, index, total) = (b[1], b[2] >> 4, b[2] & 15);
+        let start = HEADER + usize::from(u16::from_be_bytes([b[3], b[4]]));
+        if !(2..=8).contains(&total) || index >= total || start > b.len() {
+            return None;
+        }
+        let chunk = &b[start..];
+        if chunk.len() > usize::from(self.limit) {
+            return None;
+        }
+        let pos = if let Some(pos) = self.pending.iter().position(|entry| entry.id == id) {
+            pos
+        } else {
+            if self.pending.len() == PENDING {
+                let pos = self
+                    .pending
+                    .iter()
+                    .enumerate()
+                    .min_by_key(|(_, entry)| entry.deadline)
+                    .unwrap()
+                    .0;
+                self.pending.swap_remove(pos);
+            }
+            self.pending.push(Entry {
+                id,
+                total,
+                chunks: std::array::from_fn(|_| None),
+                bytes: 0,
+                deadline: now + TTL,
+            });
+            self.pending.len() - 1
+        };
+        let entry = &mut self.pending[pos];
+        if entry.total != total || entry.chunks[usize::from(index)].is_some() {
+            return None;
+        }
+        if entry.bytes + chunk.len() > usize::from(self.limit) {
+            self.pending.swap_remove(pos);
+            return None;
+        }
+        // Copy the validated chunk so random padding does not remain retained.
+        entry.chunks[usize::from(index)] = Some(Bytes::copy_from_slice(chunk));
+        entry.bytes += chunk.len();
+        if !entry.chunks[..usize::from(total)]
+            .iter()
+            .all(Option::is_some)
+        {
+            return None;
+        }
+        let entry = self.pending.swap_remove(pos);
+        let mut payload = Vec::with_capacity(entry.bytes);
+        for bytes in entry.chunks.into_iter().take(usize::from(total)) {
+            payload.extend_from_slice(&bytes.unwrap());
+        }
+        if payload.first().is_none_or(|byte| byte & 0x80 == 0) {
+            return None;
+        }
+        packet.payload = payload.into();
+        Some(packet)
+    }
+}
+#[async_trait]
+impl DatagramTransport for Gecko {
+    fn supports_shared_destinations(&self) -> bool {
+        // Fragment IDs and reassembly belong to the immutable QUIC peer.
+        false
+    }
+
+    fn payload_budget(&self, peer: &Destination) -> DatagramBudget {
+        self.inner
+            .payload_budget(peer)
+            .intersect(DatagramBudget::new(self.limit, self.limit))
+    }
+    fn supports_poll_receive(&self) -> bool {
+        self.inner.supports_poll_receive()
+    }
+    fn poll_receive(
+        &mut self,
+        cx: &mut Context<'_>,
+        scratch: &mut Vec<u8>,
+    ) -> Poll<Result<Datagram, DispatchError>> {
+        if self.closed {
+            return Poll::Ready(Err(invalid()));
+        }
+        for _ in 0..crate::limits::IO_POLL_BUDGET {
+            let packet = std::task::ready!(self.inner.poll_receive(cx, scratch))?;
+            if let Some(packet) = self.accept(packet) {
+                return Poll::Ready(Ok(packet));
+            }
+        }
+        cx.waker().wake_by_ref();
+        Poll::Pending
+    }
+    fn send_owned(
+        &mut self,
+        packet: Datagram,
+    ) -> Result<crate::dispatch::OwnedDatagramSend, Datagram> {
+        if self.closed
+            || packet.remote != self.peer
+            || packet.payload.is_empty()
+            || packet.payload[0] & 0x80 != 0
+            || packet.payload.len() > usize::from(self.payload_budget(&packet.remote).transmit())
+        {
+            return Err(packet);
+        }
+        self.inner.send_owned(packet)
+    }
+    async fn send(&mut self, packet: Datagram) -> Result<(), DispatchError> {
+        if self.closed
+            || packet.remote != self.peer
+            || packet.payload.is_empty()
+            || packet.payload.len() > usize::from(self.payload_budget(&packet.remote).transmit())
+        {
+            return Err(invalid());
+        }
+        if packet.payload[0] & 0x80 == 0 {
+            return self.inner.send(packet).await;
+        }
+        // max-packet-size controls padding, as in the reference. A small
+        // configured maximum cannot reduce the mandatory header/chunk length.
+        let wire = usize::from(self.inner.payload_budget(&packet.remote).transmit());
+        let capacity = wire
+            .checked_sub(HEADER)
+            .filter(|n| *n > 0)
+            .ok_or_else(invalid)?;
+        let choices: Vec<_> = (2..=8)
+            .filter(|count| {
+                packet.payload.len() - (count - 1) * (packet.payload.len() / count) <= capacity
+            })
+            .collect();
+        if choices.is_empty() {
+            return Err(invalid());
+        }
+        let count = choices[rand::random_range(0..choices.len())];
+        let chunk = packet.payload.len() / count;
+        self.next = self.next.wrapping_add(1);
+        let id = self.next;
+        for index in 0..count {
+            let start = index * chunk;
+            let end = if index + 1 == count {
+                packet.payload.len()
+            } else {
+                start + chunk
+            };
+            let bytes = &packet.payload[start..end];
+            let base = usize::from(super::salamander::OVERHEAD) + HEADER + bytes.len();
+            let high = usize::from(self.options.max_packet_size)
+                .min(wire + usize::from(super::salamander::OVERHEAD));
+            let low = usize::from(self.options.min_packet_size).max(base);
+            let padding = if low > high {
+                0
+            } else {
+                rand::random_range(low..=high) - base
+            };
+            let mut frame = vec![0u8; HEADER + padding + bytes.len()];
+            frame[0] = 0x80;
+            frame[1] = id;
+            frame[2] = ((index as u8) << 4) | (count as u8);
+            frame[3..5].copy_from_slice(&(padding as u16).to_be_bytes());
+            rand::fill(&mut frame[HEADER..HEADER + padding]);
+            frame[HEADER + padding..].copy_from_slice(bytes);
+            self.inner
+                .send(Datagram {
+                    remote: packet.remote.clone(),
+                    payload: frame.into(),
+                    sniffed_domain: None,
+                })
+                .await?;
+        }
+        Ok(())
+    }
+    async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+        if self.closed {
+            return Err(invalid());
+        }
+        loop {
+            for _ in 0..crate::limits::IO_POLL_BUDGET {
+                let packet = self.inner.receive().await?;
+                if let Some(packet) = self.accept(packet) {
+                    return Ok(packet);
+                }
+            }
+            tokio::task::yield_now().await;
+        }
+    }
+    async fn close(&mut self) -> Result<(), DispatchError> {
+        if self.closed {
+            return Ok(());
+        }
+        self.closed = true;
+        self.pending.clear();
+        self.inner.close().await
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::{
+        Arc,
+        atomic::{AtomicBool, Ordering},
+    };
+    use tokio::sync::mpsc;
+    struct Packets {
+        send: mpsc::Sender<Datagram>,
+        receive: mpsc::Receiver<Datagram>,
+        closed: Arc<AtomicBool>,
+    }
+    #[async_trait]
+    impl DatagramTransport for Packets {
+        fn supports_shared_destinations(&self) -> bool {
+            false
+        }
+
+        fn payload_budget(&self, _: &Destination) -> DatagramBudget {
+            DatagramBudget::new(2048, 2048)
+        }
+        async fn send(&mut self, packet: Datagram) -> Result<(), DispatchError> {
+            self.send.send(packet).await.map_err(|_| invalid())
+        }
+        async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+            self.receive.recv().await.ok_or_else(invalid)
+        }
+        async fn close(&mut self) -> Result<(), DispatchError> {
+            self.closed.store(true, Ordering::Release);
+            Ok(())
+        }
+    }
+    fn setup() -> (
+        Gecko,
+        mpsc::Receiver<Datagram>,
+        mpsc::Sender<Datagram>,
+        Arc<AtomicBool>,
+    ) {
+        let (send, sent) = mpsc::channel(16);
+        let (reply, receive) = mpsc::channel(16);
+        let closed = Arc::new(AtomicBool::new(false));
+        let options = Hysteria2Gecko {
+            password: "wire fixture".into(),
+            min_packet_size: 512,
+            max_packet_size: 1200,
+        };
+        (
+            Gecko {
+                inner: super::super::salamander::wrap(
+                    Box::new(Packets {
+                        send,
+                        receive,
+                        closed: closed.clone(),
+                    }),
+                    &options.password,
+                ),
+                options,
+                peer: Destination::Ip("192.0.2.1:443".parse().unwrap()),
+                limit: 1400,
+                next: 0,
+                pending: Vec::new(),
+                closed: false,
+            },
+            sent,
+            reply,
+            closed,
+        )
+    }
+    #[tokio::test]
+    async fn gecko_memory_wire_reassembles_reordered_long_headers_and_preserves_short_headers() {
+        let (mut gecko, mut sent, reply, closed) = setup();
+        assert!(!gecko.supports_shared_destinations());
+        assert!(
+            gecko
+                .send(Datagram {
+                    remote: Destination::Ip("192.0.2.2:443".parse().unwrap()),
+                    payload: Bytes::from_static(&[0x40, 1]),
+                    sniffed_domain: None,
+                })
+                .await
+                .is_err()
+        );
+        assert!(sent.try_recv().is_err());
+        let mut plain = vec![7; 1400];
+        plain[0] = 0xc0;
+        gecko
+            .send(Datagram {
+                remote: gecko.peer.clone(),
+                payload: plain.clone().into(),
+                sniffed_domain: None,
+            })
+            .await
+            .unwrap();
+        let mut fragments = Vec::new();
+        while let Ok(packet) = sent.try_recv() {
+            assert!((512..=1200).contains(&packet.payload.len()));
+            fragments.push(packet);
+        }
+        assert!((2..=8).contains(&fragments.len()));
+        let mut wrong = fragments[0].clone();
+        wrong.remote = Destination::Ip("192.0.2.2:443".parse().unwrap());
+        reply.send(wrong).await.unwrap();
+        for fragment in fragments.into_iter().rev() {
+            reply.send(fragment).await.unwrap();
+        }
+        assert_eq!(gecko.receive().await.unwrap().payload, plain);
+        let short = Bytes::from_static(&[0x40, 1, 2, 3]);
+        gecko
+            .send(Datagram {
+                remote: gecko.peer.clone(),
+                payload: short.clone(),
+                sniffed_domain: None,
+            })
+            .await
+            .unwrap();
+        let packet = sent.recv().await.unwrap();
+        assert_eq!(packet.payload.len(), short.len() + 8);
+        reply.send(packet).await.unwrap();
+        assert_eq!(gecko.receive().await.unwrap().payload, short);
+        gecko.close().await.unwrap();
+        assert!(closed.load(Ordering::Acquire));
+        assert!(gecko.receive().await.is_err());
+        assert!(
+            gecko
+                .send(Datagram {
+                    remote: gecko.peer.clone(),
+                    payload: Bytes::from_static(&[0x40]),
+                    sniffed_domain: None
+                })
+                .await
+                .is_err()
+        );
+    }
+    #[tokio::test(start_paused = true)]
+    async fn gecko_memory_slow_partial_input_and_expiry_have_local_bounds() {
+        let (mut gecko, _, _, _) = setup();
+        for id in 0..32 {
+            let mut frame = vec![0x80, id, 2, 0, 0];
+            frame.extend_from_slice(&[1; 700]);
+            assert!(
+                gecko
+                    .accept(Datagram {
+                        remote: gecko.peer.clone(),
+                        payload: frame.into(),
+                        sniffed_domain: None
+                    })
+                    .is_none()
+            );
+            assert!(gecko.pending.len() <= 8);
+            assert!(gecko.pending.iter().map(|entry| entry.bytes).sum::<usize>() <= 8 * 1400);
+        }
+        tokio::time::advance(TTL + Duration::from_secs(1)).await;
+        let _ = gecko.accept(Datagram {
+            remote: gecko.peer.clone(),
+            payload: Bytes::from_static(&[0x40]),
+            sniffed_domain: None,
+        });
+        assert!(gecko.pending.is_empty());
+    }
+}
diff --git a/src/outbound/hysteria2/mod.rs b/src/outbound/hysteria2/mod.rs
index ceb9f69..4de1380 100644
--- a/src/outbound/hysteria2/mod.rs
+++ b/src/outbound/hysteria2/mod.rs
@@ -1,8 +1,10 @@
 //! Hysteria2 over the shared, protected QUIC transport.
 mod bandwidth;
 mod datagram;
+mod gecko;
 mod outbound;
 mod paths;
+mod realm;
 mod salamander;
 mod socket;
 mod stream;
diff --git a/src/outbound/hysteria2/outbound.rs b/src/outbound/hysteria2/outbound.rs
index e7d612a..d6b138b 100644
--- a/src/outbound/hysteria2/outbound.rs
+++ b/src/outbound/hysteria2/outbound.rs
@@ -16,24 +16,28 @@ use crate::{
 use async_trait::async_trait;
 use bytes::Bytes;
 use std::{
+    collections::hash_map::DefaultHasher,
+    hash::{Hash, Hasher},
     io,
     sync::{Arc, Mutex},
     time::Duration,
 };
 use tokio::{
     io::AsyncWriteExt,
-    sync::{Mutex as AsyncMutex, oneshot},
+    sync::{Mutex as AsyncMutex, watch},
 };
 use tokio_util::{sync::CancellationToken, task::TaskTracker};
 
-/// A node owns its authenticated connection and every driver used by that
-/// connection. Individual streams never own the shared cancellation token.
+/// A node owns its authenticated sessions and all their drivers. Individual
+/// streams never own a shared session's cancellation token.
 pub struct Hysteria2Outbound {
     config: Arc<Hysteria2OutboundConfig>,
     server: Destination,
     upstream: UpstreamPath,
-    tls: Arc<rustls::ClientConfig>,
-    current: AsyncMutex<Option<Arc<Session>>>,
+    tls: StandardTlsClient,
+    realm_tls: Option<StandardTlsClient>,
+    current: Box<[AsyncMutex<Option<Arc<Handshake>>>]>,
+    pacer: Arc<super::bandwidth::Pacer>,
     cancel: CancellationToken,
     admission: Mutex<()>,
     tasks: TaskTracker,
@@ -48,6 +52,76 @@ struct Session {
     bandwidth: Arc<super::bandwidth::Bandwidth>,
 }
 
+#[derive(Clone)]
+enum Ready {
+    Pending,
+    Open(Arc<Session>),
+    Failed(Arc<DispatchError>),
+}
+
+/// A slot retains its offer even when every waiting call has gone away. The
+/// driver owns publication and holds no Handshake Arc, so there is no cycle.
+struct Handshake {
+    cancel: CancellationToken,
+    ready: watch::Receiver<Ready>,
+}
+
+impl Handshake {
+    fn initializing(&self) -> bool {
+        matches!(*self.ready.borrow(), Ready::Pending)
+    }
+
+    fn finished(&self) -> bool {
+        matches!(*self.ready.borrow(), Ready::Failed(_))
+    }
+
+    async fn wait_ready(&self) -> Result<Arc<Session>, DispatchError> {
+        let mut ready = self.ready.clone();
+        loop {
+            let state = ready.borrow_and_update().clone();
+            match state {
+                Ready::Open(session) => {
+                    if session.cancel.is_cancelled() || session.connection.close_reason().is_some()
+                    {
+                        return Err(DispatchError::ConnectionRefused);
+                    }
+                    return Ok(session);
+                }
+                Ready::Failed(error) => return Err(copy_failure(&error)),
+                Ready::Pending => {}
+            }
+            if ready.changed().await.is_err() {
+                return Err(DispatchError::ConnectionRefused);
+            }
+        }
+    }
+}
+
+struct CreationGuard<'a> {
+    handshake: &'a Handshake,
+    armed: bool,
+}
+
+impl Drop for CreationGuard<'_> {
+    fn drop(&mut self) {
+        if self.armed && self.handshake.initializing() {
+            self.handshake.cancel.cancel();
+        }
+    }
+}
+
+fn copy_failure(error: &DispatchError) -> DispatchError {
+    match error {
+        DispatchError::NotAllowed => DispatchError::NotAllowed,
+        DispatchError::RuleEvaluation(failure) => DispatchError::RuleEvaluation(*failure),
+        DispatchError::NetworkUnreachable => DispatchError::NetworkUnreachable,
+        DispatchError::HostUnreachable => DispatchError::HostUnreachable,
+        DispatchError::ConnectionRefused => DispatchError::ConnectionRefused,
+        DispatchError::TimedOut => DispatchError::TimedOut,
+        DispatchError::Other(message) => DispatchError::Other(message.clone()),
+    }
+}
+
 impl std::fmt::Debug for Hysteria2Outbound {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("Hysteria2Outbound").finish_non_exhaustive()
@@ -58,15 +132,21 @@ impl Hysteria2Outbound {
     /// Test-only controller/path evidence; no configuration or traffic addresses.
     #[cfg(feature = "interop-test")]
     pub async fn congestion_observation(&self) -> Option<(u64, quinn::ConnectionStats)> {
-        self.current.lock().await.as_ref().map(|session| {
-            (
-                session
-                    .bandwidth
-                    .rate
-                    .load(std::sync::atomic::Ordering::Relaxed),
-                session.connection.stats(),
-            )
-        })
+        for slot in &self.current {
+            let slot = slot.lock().await;
+            if let Some(handshake) = slot.as_ref()
+                && let Ready::Open(session) = &*handshake.ready.borrow()
+            {
+                return Some((
+                    session
+                        .bandwidth
+                        .rate
+                        .load(std::sync::atomic::Ordering::Relaxed),
+                    session.connection.stats(),
+                ));
+            }
+        }
+        None
     }
     pub fn new_with_path(
         config: &Hysteria2OutboundConfig,
@@ -92,6 +172,7 @@ impl Hysteria2Outbound {
             security,
             &config.tls.server_name,
             TlsClientOptions {
+                ech: config.tls.ech.clone(),
                 versions: TlsVersions::Tls13,
                 alpn: config.tls.alpn.clone(),
                 certificate: config.tls.certificate.clone(),
@@ -99,23 +180,55 @@ impl Hysteria2Outbound {
                     .tls
                     .identity
                     .as_ref()
-                    .map(|identity| {
-                        TlsClientIdentity::from_pem(&identity.certificate, &identity.private_key)
-                    })
+                    .map(|identity| TlsClientIdentity::from_config(identity, security))
                     .transpose()?,
                 ..Default::default()
             },
             resumption_sessions,
             buffer_limit,
-        )?
-        .quic_config()?
-        .0;
+        )?;
+        let realm_tls = config
+            .realm
+            .as_ref()
+            .and_then(|options| options.tls.as_ref())
+            .map(|policy| {
+                StandardTlsClient::with_options(
+                    security,
+                    &policy.server_name,
+                    TlsClientOptions {
+                        versions: TlsVersions::Tls12And13,
+                        alpn: policy.alpn.clone(),
+                        certificate: policy.certificate.clone(),
+                        identity: policy
+                            .identity
+                            .as_ref()
+                            .map(|identity| TlsClientIdentity::from_config(identity, security))
+                            .transpose()?,
+                        ..Default::default()
+                    },
+                    0,
+                    buffer_limit,
+                )
+            })
+            .transpose()?;
+        // Spread UDP receive/forward work across a small lazy pool. A one-byte
+        // receive declaration cannot be divided.
+        let count = if config.down != 1 {
+            crate::limits::HY2_AUTH_SESSIONS
+        } else {
+            1
+        };
         Ok(Self {
             config: Arc::new(config.clone()),
             server: server_destination(&config.address, config.port)?,
             upstream,
             tls,
-            current: AsyncMutex::new(None),
+            realm_tls,
+            current: (0..count)
+                .map(|_| AsyncMutex::new(None))
+                .collect::<Vec<_>>()
+                .into_boxed_slice(),
+            pacer: Arc::new(super::bandwidth::Pacer::default()),
             cancel: CancellationToken::new(),
             admission: Mutex::new(()),
             tasks: TaskTracker::new(),
@@ -131,39 +244,90 @@ impl Hysteria2Outbound {
             return Err(DispatchError::TimedOut);
         }
         let _waiter = observation::track(ResourceKind::Waiter);
+        let mut hash = DefaultHasher::new();
+        datagram.source.hash(&mut hash);
+        let index = (hash.finish() % self.current.len() as u64) as usize;
         tokio::select! {biased;
             () = self.cancel.cancelled() => Err(DispatchError::NotAllowed),
             result = context.run("Hysteria2 session", async {
-                let mut current = self.current.lock().await;
-                if let Some(session) = current.as_ref().filter(|session|
-                    !session.cancel.is_cancelled() && session.connection.close_reason().is_none()) {
-                    return Ok(session.clone());
-                }
-                current.take();
-                let (ready, reply) = oneshot::channel();
-                let cancel = self.cancel.child_token();
-                let guard = cancel.clone().drop_guard();
-                {
-                    let _admission = self.admission.lock().unwrap();
-                    if self.cancel.is_cancelled() { return Err(DispatchError::NotAllowed); }
-                    let config = self.config.clone();
-                    let upstream = self.upstream.clone();
-                    let server = self.server.clone();
-                    let tls = self.tls.clone();
-                    let context = context.clone();
-                    let task = observation::track(ResourceKind::Task);
-                    self.tasks.spawn(observation::bind(async move {
-                        let _task = task;
-                        drive(config, upstream, server, tls, datagram, context, cancel, ready).await;
-                    }));
-                }
-                let session = reply.await.map_err(|_| DispatchError::ConnectionRefused)??;
-                guard.disarm();
-                *current = Some(session.clone());
-                Ok(session)
+                let mut current = self.current[index].lock().await;
+                // A failed offer becomes replaceable only after its driver has
+                // finished cleanup. Repeated calls cannot stack retiring tasks.
+                let (handshake, created) = match current.as_ref().filter(|offer| !offer.finished()) {
+                    Some(handshake) => (handshake.clone(), false),
+                    None => {
+                        let handshake = self.start_handshake(index, datagram, context)?;
+                        *current = Some(handshake.clone());
+                        (handshake, true)
+                    }
+                };
+                let independent = !self.config.handshake_timeout.is_zero();
+                // Default offers retain the creator's serialization and
+                // cancellation semantics. Positive timeouts share a pending
+                // offer without keeping its first waiter or the slot lock.
+                if independent { drop(current); }
+                let mut guard = CreationGuard {
+                    handshake: &handshake,
+                    armed: created && !independent,
+                };
+                let result = handshake.wait_ready().await;
+                guard.armed = false;
+                result
             }) => result,
         }
     }
+
+    fn start_handshake(
+        &self,
+        index: usize,
+        datagram: DatagramSession,
+        context: &EstablishContext,
+    ) -> Result<Arc<Handshake>, DispatchError> {
+        let _admission = self.admission.lock().unwrap();
+        if self.cancel.is_cancelled() {
+            return Err(DispatchError::NotAllowed);
+        }
+        let context = if self.config.handshake_timeout.is_zero() {
+            context.clone()
+        } else {
+            context.hysteria2_handshake(self.config.handshake_timeout)?
+        };
+        let cancel = self.cancel.child_token();
+        let (ready, receive) = watch::channel(Ready::Pending);
+        let handshake = Arc::new(Handshake {
+            cancel: cancel.clone(),
+            ready: receive,
+        });
+        let config = self.config.clone();
+        let upstream = self.upstream.clone();
+        let server = self.server.clone();
+        let tls = self.tls.clone();
+        let realm_tls = self.realm_tls.clone();
+        let bandwidth = Arc::new(super::bandwidth::Bandwidth::with_pacer(self.pacer.clone()));
+        let count = self.current.len() as u64;
+        let receive_rate =
+            self.config.down / count + u64::from((index as u64) < self.config.down % count);
+        let task = observation::track(ResourceKind::Task);
+        self.tasks.spawn(observation::bind(async move {
+            let _task = task;
+            drive(
+                config,
+                upstream,
+                server,
+                tls,
+                realm_tls,
+                datagram,
+                context,
+                cancel,
+                ready,
+                bandwidth,
+                receive_rate,
+                count as usize,
+            )
+            .await;
+        }));
+        Ok(handshake)
+    }
 }
 
 #[async_trait]
@@ -176,7 +340,8 @@ impl OutboundConnector for Hysteria2Outbound {
         let request = super::wire::tcp_request(&session.destination)?;
         let shared = self
             .session(
-                DatagramSession::new(session.inbound, session.source),
+                DatagramSession::new(session.inbound, session.source)
+                    .with_metadata(session.metadata.clone()),
                 context,
             )
             .await?;
@@ -186,7 +351,7 @@ impl OutboundConnector for Hysteria2Outbound {
                 let (mut send, recv) = shared.connection.open_bi().await.map_err(failure)?;
                 tokio::io::AsyncWriteExt::write_all(&mut send, &request).await?;
                 send.flush().await?;
-                let stream = super::stream::TcpStream::new(recv, send, context.deadline());
+                let stream = super::stream::TcpStream::new(recv, send);
                 Ok(ConnectedStream {
                     io: Box::new(OwnedStream::new(Box::new(stream), shared.cancel.child_token())),
                     effective_peer: session.destination,
@@ -221,7 +386,9 @@ impl OutboundConnector for Hysteria2Outbound {
     async fn shutdown(&self) {
         self.begin_shutdown();
         self.tasks.wait().await;
-        self.current.lock().await.take();
+        for slot in &self.current {
+            slot.lock().await.take();
+        }
     }
 }
 
@@ -236,21 +403,31 @@ async fn drive(
     config: Arc<Hysteria2OutboundConfig>,
     upstream: UpstreamPath,
     server: Destination,
-    tls: Arc<rustls::ClientConfig>,
+    tls: StandardTlsClient,
+    realm_tls: Option<StandardTlsClient>,
     datagram: DatagramSession,
     context: EstablishContext,
     cancel: CancellationToken,
-    ready: oneshot::Sender<Result<Arc<Session>, DispatchError>>,
+    ready: watch::Sender<Ready>,
+    bandwidth: Arc<super::bandwidth::Bandwidth>,
+    receive_rate: u64,
+    session_count: usize,
 ) {
     let runtime = Arc::new(OwnedRuntime::new(CancellationToken::new()));
-    let mut ready = Some(ready);
     let mut endpoint = None;
     let mut paths = None;
-    let datagrams = Arc::new(super::datagram::Registry::default());
-    let bandwidth = Arc::new(super::bandwidth::Bandwidth::default());
+    let mut realm_pending = super::realm::Pending::default();
+    let (datagrams, submissions) = super::datagram::Registry::new();
+    let datagrams = Arc::new(datagrams);
     let _pool = observation::track(ResourceKind::Pool);
+    let established = CancellationToken::new();
+    let deadline = context.deadline();
     let operation = async {
         let _handshake = observation::track(ResourceKind::Handshake);
+        let (tls, _) = tls
+            .quic_config_with_context(&context)
+            .await
+            .map_err(failure)?;
         let (path, socket) = super::paths::Paths::open(
             config.clone(),
             upstream,
@@ -258,23 +435,33 @@ async fn drive(
             datagram,
             context,
             bandwidth.clone(),
+            super::paths::RealmSetup {
+                tls: realm_tls.as_ref(),
+                pending: &mut realm_pending,
+            },
         )
         .await?;
         let peer = path.peer;
         let mtu = path.mtu;
         paths = Some(path);
         let mut limits = quinn::TransportConfig::default();
+        quic::configure_receive_windows(
+            &mut limits,
+            config.stream_window,
+            config.connection_window,
+            quic::RECEIVE_WINDOW_POLICY,
+        )?;
         limits
             .initial_mtu(mtu)
             .min_mtu(mtu)
             .mtu_discovery_config(None)
             .max_concurrent_bidi_streams(0_u8.into())
             .max_concurrent_uni_streams((crate::limits::HY2_UNI_STREAMS as u32).into())
-            .stream_receive_window((crate::limits::HY2_STREAM_WINDOW as u32).into())
-            .receive_window((crate::limits::HY2_CONNECTION_WINDOW as u32).into())
-            .send_window(crate::limits::HY2_CONNECTION_WINDOW as u64)
-            .datagram_receive_buffer_size(Some(crate::limits::HY2_DATAGRAM_BUFFER))
-            .datagram_send_buffer_size(crate::limits::HY2_DATAGRAM_BUFFER)
+            .send_window((crate::limits::HY2_SEND_WINDOW / session_count) as u64)
+            .datagram_receive_buffer_size(Some(
+                crate::limits::HY2_DATAGRAM_RECEIVE_BUFFER / session_count,
+            ))
+            .datagram_send_buffer_size(crate::limits::HY2_DATAGRAM_SEND_BUFFER / session_count)
             .max_idle_timeout(Some(Duration::from_secs(30).try_into().map_err(failure)?))
             .keep_alive_interval(Some(Duration::from_secs(10)))
             .congestion_controller_factory(bandwidth.clone());
@@ -306,7 +493,7 @@ async fn drive(
                 "Hysteria-Auth",
                 http::HeaderValue::from_bytes(config.password.as_bytes()).map_err(failure)?,
             )
-            .header("Hysteria-CC-RX", config.down.to_string())
+            .header("Hysteria-CC-RX", receive_rate.to_string())
             .header("Hysteria-Padding", "padding")
             .body(())
             .map_err(failure)?;
@@ -346,15 +533,16 @@ async fn drive(
             #[cfg(feature = "interop-test")]
             bandwidth: bandwidth.clone(),
         });
-        ready
-            .take()
-            .unwrap()
-            .send(Ok(session))
-            .map_err(|_| DispatchError::ConnectionRefused)?;
+        if tokio::time::Instant::now() >= deadline {
+            return Err(DispatchError::TimedOut);
+        }
+        established.cancel();
+        ready.send_replace(Ready::Open(session));
         tokio::select! {
             _ = connection.closed() => {},
             _ = control.wait_idle() => {},
             _ = super::datagram::receive(&connection, &datagrams) => {},
+            _ = super::datagram::transmit(&connection, &datagrams, submissions) => {},
             _ = paths.as_mut().unwrap().hopping(endpoint.as_ref().unwrap()) => {},
         }
         drop(requests);
@@ -362,25 +550,198 @@ async fn drive(
     };
     let result = tokio::select! {biased;
         () = cancel.cancelled() => Err(DispatchError::NotAllowed),
+        () = async { tokio::select! { biased; () = established.cancelled() => std::future::pending::<()>().await, () = tokio::time::sleep_until(deadline) => {} } } => Err(DispatchError::TimedOut),
         result = operation => result,
     };
     cancel.cancel();
     datagrams.close();
-    if let Some(ready) = ready {
-        let _ = ready.send(Err(result
-            .err()
-            .unwrap_or(DispatchError::ConnectionRefused)));
-    }
     if let Some(endpoint) = endpoint {
         endpoint.close(0_u8.into(), b"");
         let _ = tokio::time::timeout(quic::CLOSE_TIMEOUT, endpoint.wait_idle()).await;
     }
     runtime.stop().await;
+    realm_pending.stop().await;
     if let Some(mut paths) = paths {
         paths.stop().await;
     }
+    ready.send_replace(Ready::Failed(Arc::new(
+        result.err().unwrap_or(DispatchError::ConnectionRefused),
+    )));
 }
 
 fn failure(_: impl std::fmt::Display) -> io::Error {
     io::Error::other("Hysteria2 QUIC exchange failed")
 }
+
+#[cfg(test)]
+mod shared_handshake_memory_tests {
+    use super::*;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+    use tokio::{sync::Notify, time::Instant};
+
+    #[derive(Default)]
+    struct PendingUpstream {
+        entered: Notify,
+        fail: Notify,
+        calls: AtomicUsize,
+        active: AtomicUsize,
+        deadline: Mutex<Option<Instant>>,
+    }
+
+    struct Active<'a>(&'a AtomicUsize);
+
+    impl Drop for Active<'_> {
+        fn drop(&mut self) {
+            self.0.fetch_sub(1, Ordering::Relaxed);
+        }
+    }
+
+    #[async_trait]
+    impl OutboundConnector for PendingUpstream {
+        async fn connect_stream(
+            &self,
+            _session: StreamSession,
+            _context: &EstablishContext,
+        ) -> Result<ConnectedStream, DispatchError> {
+            panic!("memory fixture does not create a stream")
+        }
+
+        async fn open_datagram(
+            &self,
+            _request: DatagramRequest,
+            context: &EstablishContext,
+        ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+            self.calls.fetch_add(1, Ordering::Relaxed);
+            self.active.fetch_add(1, Ordering::Relaxed);
+            let _active = Active(&self.active);
+            *self.deadline.lock().unwrap() = Some(context.deadline());
+            self.entered.notify_one();
+            // Stop before creating any socket, QUIC endpoint or peer. The
+            // actual production owner/driver/cancellation path remains in use.
+            self.fail.notified().await;
+            Err(DispatchError::ConnectionRefused)
+        }
+    }
+
+    fn outbound(seconds: u64, upstream: Arc<PendingUpstream>) -> Hysteria2Outbound {
+        let config = crate::config::Config::parse_yaml(
+            format!(
+                "proxies: [{{name: synthetic, type: hysteria2, server: 192.0.2.10, port: 443, password: synthetic, handshake-timeout: {seconds}}}]"
+            )
+            .as_bytes(),
+        )
+        .unwrap();
+        let crate::config::ProxyProtocol::Hysteria2(config) = &config.proxies[0].protocol else {
+            panic!("Hysteria2 configuration")
+        };
+        Hysteria2Outbound::new_with_path(config, UpstreamPath::proxy(upstream)).unwrap()
+    }
+
+    fn datagram() -> DatagramSession {
+        DatagramSession::new(
+            crate::session::InboundKind::Tun,
+            "192.0.2.1:1000".parse().unwrap(),
+        )
+    }
+
+    async fn current(outbound: &Hysteria2Outbound) -> Arc<Handshake> {
+        for slot in &outbound.current {
+            if let Some(handshake) = slot.lock().await.as_ref() {
+                return handshake.clone();
+            }
+        }
+        panic!("an offer was admitted")
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn positive_offer_survives_waiter_timeout_and_last_waiter_drop() {
+        let upstream = Arc::new(PendingUpstream::default());
+        let outbound = outbound(5, upstream.clone());
+        let short = EstablishContext::with_timeout(Duration::from_millis(10));
+        let long = EstablishContext::with_timeout(Duration::from_secs(10));
+        let mut creator = Box::pin(outbound.session(datagram(), &short));
+        assert!(futures_util::poll!(creator.as_mut()).is_pending());
+        upstream.entered.notified().await;
+        let handshake = current(&outbound).await;
+        let weak = Arc::downgrade(&handshake);
+        let mut waiter = Box::pin(outbound.session(datagram(), &long));
+        assert!(futures_util::poll!(waiter.as_mut()).is_pending());
+        tokio::time::advance(Duration::from_millis(50)).await;
+        assert!(matches!(creator.await, Err(DispatchError::TimedOut)));
+        assert!(!handshake.cancel.is_cancelled());
+        assert!(futures_util::poll!(waiter.as_mut()).is_pending());
+        drop(waiter);
+        assert!(!handshake.cancel.is_cancelled());
+        assert!(handshake.initializing());
+        assert_eq!(upstream.calls.load(Ordering::Relaxed), 1);
+        assert_eq!(upstream.active.load(Ordering::Relaxed), 1);
+        assert!(*upstream.deadline.lock().unwrap().as_ref().unwrap() > short.deadline());
+        outbound.shutdown().await;
+        assert!(handshake.finished());
+        assert_eq!(upstream.active.load(Ordering::Relaxed), 0);
+        assert!(outbound.tasks.is_empty());
+        drop(handshake);
+        assert!(weak.upgrade().is_none());
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn default_offer_keeps_creator_cancellation_and_one_serialized_attempt() {
+        let upstream = Arc::new(PendingUpstream::default());
+        let outbound = outbound(0, upstream.clone());
+        let context = EstablishContext::with_timeout(Duration::from_secs(5));
+        let mut creator = Box::pin(outbound.session(datagram(), &context));
+        assert!(futures_util::poll!(creator.as_mut()).is_pending());
+        upstream.entered.notified().await;
+        let mut waiter = Box::pin(outbound.session(datagram(), &context));
+        assert!(futures_util::poll!(waiter.as_mut()).is_pending());
+        drop(waiter);
+        assert_eq!(upstream.active.load(Ordering::Relaxed), 1);
+        assert_eq!(upstream.calls.load(Ordering::Relaxed), 1);
+        assert_eq!(*upstream.deadline.lock().unwrap(), Some(context.deadline()));
+        drop(creator);
+        outbound.shutdown().await;
+        assert_eq!(upstream.active.load(Ordering::Relaxed), 0);
+        assert!(outbound.tasks.is_empty());
+        for slot in &outbound.current {
+            assert!(slot.lock().await.is_none());
+        }
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn failed_offer_finishes_before_one_replacement_and_stop_joins_it() {
+        for deadline_failure in [false, true] {
+            let upstream = Arc::new(PendingUpstream::default());
+            let outbound = outbound(1, upstream.clone());
+            let context = EstablishContext::with_timeout(Duration::from_secs(10));
+            let mut first = Box::pin(outbound.session(datagram(), &context));
+            assert!(futures_util::poll!(first.as_mut()).is_pending());
+            upstream.entered.notified().await;
+            let old = current(&outbound).await;
+            if deadline_failure {
+                tokio::time::advance(Duration::from_secs(1)).await;
+                assert!(matches!(first.await, Err(DispatchError::TimedOut)));
+            } else {
+                upstream.fail.notify_one();
+                assert!(matches!(first.await, Err(DispatchError::ConnectionRefused)));
+            }
+            assert!(old.finished());
+            assert_eq!(upstream.active.load(Ordering::Relaxed), 0);
+            let mut retry = Box::pin(outbound.session(datagram(), &context));
+            assert!(futures_util::poll!(retry.as_mut()).is_pending());
+            upstream.entered.notified().await;
+            let next = current(&outbound).await;
+            assert!(!Arc::ptr_eq(&old, &next));
+            assert_eq!(upstream.calls.load(Ordering::Relaxed), 2);
+            assert_eq!(upstream.active.load(Ordering::Relaxed), 1);
+            outbound.shutdown().await;
+            assert!(matches!(retry.await, Err(DispatchError::NotAllowed)));
+            assert!(next.finished());
+            assert_eq!(upstream.active.load(Ordering::Relaxed), 0);
+            assert!(outbound.tasks.is_empty());
+            assert!(matches!(
+                outbound.session(datagram(), &context).await,
+                Err(DispatchError::NotAllowed)
+            ));
+        }
+    }
+}
diff --git a/src/outbound/hysteria2/paths.rs b/src/outbound/hysteria2/paths.rs
index dd95189..8d6b1e7 100644
--- a/src/outbound/hysteria2/paths.rs
+++ b/src/outbound/hysteria2/paths.rs
@@ -2,8 +2,9 @@
 use super::{bandwidth::Bandwidth, salamander, socket::WindowSocket};
 use crate::{
     config::Hysteria2OutboundConfig,
-    dispatch::{DatagramBudget, DispatchError},
+    dispatch::{DatagramBudget, DatagramTransport, DispatchError},
     outbound::{DatagramRequest, EstablishContext, UpstreamPath},
+    security::StandardTlsClient,
     session::{DatagramSession, Destination},
     transport::quic::{self, DatagramDriver, DatagramSocket},
 };
@@ -13,6 +14,12 @@ use tokio::time::Instant;
 const QUIC_PAYLOAD: u16 = crate::limits::HY2_QUIC_PAYLOAD as u16;
 const RETIRE_AFTER: Duration = Duration::from_secs(crate::limits::HY2_PATH_RETIRE_SECONDS as u64);
 
+/// Borrow Realm preparation state without moving its cancellation/Stop owner.
+pub(super) struct RealmSetup<'a> {
+    pub tls: Option<&'a StandardTlsClient>,
+    pub pending: &'a mut super::realm::Pending,
+}
+
 pub(super) struct Paths {
     config: Arc<Hysteria2OutboundConfig>,
     upstream: UpstreamPath,
@@ -33,9 +40,14 @@ impl Paths {
         datagram: DatagramSession,
         context: EstablishContext,
         bandwidth: Arc<Bandwidth>,
+        realm: RealmSetup<'_>,
     ) -> Result<(Self, Arc<WindowSocket>), DispatchError> {
-        let destination = upstream.datagram_server(server, &context)?;
-        let peer = context.resolve_ip(&destination).await?;
+        let peer = if config.realm.is_some() {
+            SocketAddr::from(([0, 0, 0, 0], config.port))
+        } else {
+            let destination = upstream.datagram_server(server, &context).await?;
+            context.resolve_ip(&destination).await?
+        };
         let mut paths = Self {
             config,
             upstream,
@@ -48,7 +60,24 @@ impl Paths {
             retiring: None,
             current_socket: None,
         };
-        let (socket, driver) = paths.attach(&paths.context).await?;
+        let (socket, driver) = if let Some(options) = &paths.config.realm {
+            let wire_mtu = paths.wire_mtu();
+            let (raw, peer) = realm
+                .pending
+                .open(
+                    options,
+                    realm.tls,
+                    &paths.upstream,
+                    &paths.datagram,
+                    &paths.context,
+                    DatagramBudget::new(wire_mtu, wire_mtu),
+                )
+                .await?;
+            paths.peer = peer;
+            paths.attach_transport(raw, peer)?
+        } else {
+            paths.attach(&paths.context).await?
+        };
         paths.current = Some(driver);
         paths.mtu = socket.budget().quic_payload_limit()?;
         paths.current_socket = Some(socket.clone());
@@ -71,18 +100,39 @@ impl Paths {
         &self,
         context: &EstablishContext,
     ) -> Result<(Arc<DatagramSocket>, DatagramDriver), DispatchError> {
-        let wire_mtu = QUIC_PAYLOAD
-            + if self.config.obfs_password.is_some() {
-                salamander::OVERHEAD
-            } else {
-                0
-            };
+        let wire_mtu = self.wire_mtu();
         let request = DatagramRequest::new(self.datagram.clone())
-            .with_budget(DatagramBudget::new(wire_mtu, wire_mtu));
+            .with_budget(DatagramBudget::new(wire_mtu, wire_mtu))
+            .with_udp_receive_buffer_size(2 * 1024 * 1024);
         let raw = self.upstream.open_datagram(request, context).await?;
-        // Pace the encrypted wire packet, including the optional salt.
-        let raw = self.bandwidth.wrap(raw, wire_mtu);
-        let raw = if let Some(password) = &self.config.obfs_password {
+        self.attach_transport(raw, self.physical_peer())
+    }
+    fn wire_mtu(&self) -> u16 {
+        if let Some(gecko) = &self.config.gecko {
+            (QUIC_PAYLOAD + salamander::OVERHEAD).max(gecko.max_packet_size)
+        } else {
+            QUIC_PAYLOAD
+                + if self.config.obfs_password.is_some() {
+                    salamander::OVERHEAD
+                } else {
+                    0
+                }
+        }
+    }
+    fn attach_transport(
+        &self,
+        raw: Box<dyn DatagramTransport>,
+        physical_peer: SocketAddr,
+    ) -> Result<(Arc<DatagramSocket>, DatagramDriver), DispatchError> {
+        let raw = self.bandwidth.wrap(raw, self.wire_mtu());
+        let raw = if let Some(options) = &self.config.gecko {
+            super::gecko::wrap(
+                raw,
+                options.clone(),
+                Destination::Ip(physical_peer),
+                QUIC_PAYLOAD,
+            )
+        } else if let Some(password) = &self.config.obfs_password {
             salamander::wrap(raw, password)
         } else {
             raw
@@ -90,7 +140,7 @@ impl Paths {
         Ok(quic::attach_mapped(
             raw,
             self.peer,
-            self.physical_peer(),
+            physical_peer,
             DatagramBudget::new(QUIC_PAYLOAD, QUIC_PAYLOAD),
         )?)
     }
diff --git a/src/outbound/hysteria2/realm.rs b/src/outbound/hysteria2/realm.rs
new file mode 100644
index 0000000..eb08d61
--- /dev/null
+++ b/src/outbound/hysteria2/realm.rs
@@ -0,0 +1,398 @@
+//! Client-only Realm setup. The owning Hysteria driver retains every UDP
+//! candidate across cancellation and closes them before its Stop barrier.
+mod http;
+mod wire;
+use crate::{
+    config::Hysteria2Realm,
+    dispatch::{DatagramBudget, DatagramTransport, DispatchError},
+    outbound::{DatagramRequest, EstablishContext, UpstreamPath},
+    security::StandardTlsClient,
+    session::{Datagram, DatagramSession, Destination},
+};
+use bytes::Bytes;
+use futures_util::{StreamExt, stream::FuturesUnordered};
+use std::{io, net::SocketAddr, time::Duration};
+use tokio::time::{Instant, timeout};
+pub(super) fn fail() -> io::Error {
+    io::Error::other("Hysteria2 Realm exchange failed")
+}
+struct Candidate {
+    transport: Box<dyn DatagramTransport>,
+    ipv6: bool,
+    mapped: Vec<SocketAddr>,
+}
+#[derive(Default)]
+pub(super) struct Pending {
+    candidates: Vec<Option<Candidate>>,
+}
+impl Pending {
+    pub async fn stop(&mut self) {
+        for entry in &mut self.candidates {
+            if let Some(candidate) = entry.as_mut() {
+                let _ = timeout(Duration::from_secs(1), candidate.transport.close()).await;
+            }
+            entry.take();
+        }
+        self.candidates.clear();
+    }
+    pub async fn open(
+        &mut self,
+        options: &Hysteria2Realm,
+        tls: Option<&StandardTlsClient>,
+        upstream: &UpstreamPath,
+        datagram: &DatagramSession,
+        context: &EstablishContext,
+        budget: DatagramBudget,
+    ) -> Result<(Box<dyn DatagramTransport>, SocketAddr), DispatchError> {
+        let mut servers = Vec::new();
+        for server in &options.stun_servers {
+            let resolved = upstream
+                .for_server(server, false)
+                .datagram_server(server, context)
+                .await?;
+            let address = context.resolve_ip(&resolved).await?;
+            if !servers.contains(&address) {
+                servers.push(address);
+            }
+        }
+        for ipv6 in [false, true] {
+            if !servers.iter().any(|server| server.is_ipv6() == ipv6) {
+                continue;
+            }
+            let raw = upstream
+                .open_datagram(
+                    DatagramRequest::new(datagram.clone())
+                        .with_budget(budget)
+                        .with_udp_receive_buffer_size(2 * 1024 * 1024),
+                    context,
+                )
+                .await?;
+            self.candidates.push(Some(Candidate {
+                transport: raw,
+                ipv6,
+                mapped: Vec::new(),
+            }));
+        }
+        // At most two borrowed futures; no detached DNS/STUN or punch workers.
+        let discovery = self.candidates.iter_mut().map(|entry| {
+            let servers = &servers;
+            async move {
+                let entry = entry.as_mut().unwrap();
+                let family: Vec<_> = servers
+                    .iter()
+                    .copied()
+                    .filter(|server| server.is_ipv6() == entry.ipv6)
+                    .collect();
+                if let Ok(mapped) = discover(&mut *entry.transport, &family).await {
+                    entry.mapped = mapped;
+                }
+            }
+        });
+        futures_util::future::join_all(discovery).await;
+        let addresses: Vec<_> = self
+            .candidates
+            .iter()
+            .flatten()
+            .flat_map(|entry| entry.mapped.iter().copied())
+            .collect();
+        if addresses.is_empty() {
+            return Err(fail().into());
+        }
+        let metadata = wire::Metadata {
+            nonce: rand::random(),
+            key: rand::random(),
+        };
+        let (peers, metadata) = http::connect(
+            options, tls, upstream, datagram, context, &addresses, &metadata,
+        )
+        .await?;
+        let mut futures = FuturesUnordered::new();
+        for (index, entry) in self.candidates.iter_mut().enumerate() {
+            let entry = entry.as_mut().unwrap();
+            if entry.mapped.is_empty() {
+                continue;
+            }
+            let candidates = candidates(&peers, entry.ipv6)?;
+            let meta = metadata.clone();
+            futures.push(async move {
+                (
+                    index,
+                    punch(&mut *entry.transport, &candidates, &meta).await,
+                )
+            });
+        }
+        let mut winner = None;
+        while let Some((index, result)) = futures.next().await {
+            if let Ok(peer) = result {
+                winner = Some((index, peer));
+                break;
+            }
+        }
+        drop(futures);
+        let (index, peer) = winner.ok_or_else(fail)?;
+        // Leave the winner in Pending until every await is complete. Even a
+        // cancellation during loser cleanup retains all resources for Stop.
+        for (other, entry) in self.candidates.iter_mut().enumerate() {
+            if other == index {
+                continue;
+            }
+            if let Some(candidate) = entry.as_mut() {
+                let _ = timeout(Duration::from_secs(1), candidate.transport.close()).await;
+            }
+            entry.take();
+        }
+        let candidate = self.candidates[index].take().unwrap();
+        self.candidates.clear();
+        Ok((candidate.transport, peer))
+    }
+}
+struct Request {
+    server: SocketAddr,
+    id: [u8; 12],
+    done: bool,
+}
+async fn discover(
+    transport: &mut dyn DatagramTransport,
+    servers: &[SocketAddr],
+) -> Result<Vec<SocketAddr>, DispatchError> {
+    let mut requests: Vec<_> = servers
+        .iter()
+        .map(|server| Request {
+            server: *server,
+            id: rand::random(),
+            done: false,
+        })
+        .collect();
+    let mut addresses = Vec::new();
+    for duration in [
+        Duration::from_millis(500),
+        Duration::from_secs(2),
+        Duration::from_secs(4),
+    ] {
+        if requests.iter().all(|request| request.done) {
+            break;
+        }
+        let mut sent = false;
+        for request in &requests {
+            if !request.done {
+                sent |= transport
+                    .send(Datagram {
+                        remote: Destination::Ip(request.server),
+                        payload: wire::stun_request(request.id).into(),
+                        sniffed_domain: None,
+                    })
+                    .await
+                    .is_ok();
+            }
+        }
+        if !sent {
+            continue;
+        }
+        let deadline = Instant::now() + duration;
+        loop {
+            let packet = tokio::select! {()=tokio::time::sleep_until(deadline)=>break,packet=transport.receive()=>packet?};
+            tokio::task::yield_now().await;
+            if packet.payload.len() > 1500 {
+                continue;
+            }
+            let Destination::Ip(source) = packet.remote else {
+                continue;
+            };
+            for request in &mut requests {
+                if request.done || request.server != source {
+                    continue;
+                }
+                if let Some(address) = wire::stun_response(&packet.payload, &request.id)
+                    && address.is_ipv6() == source.is_ipv6()
+                {
+                    request.done = true;
+                    if !addresses.contains(&address) {
+                        addresses.push(address);
+                    }
+                    break;
+                }
+            }
+            if requests.iter().all(|request| request.done) {
+                break;
+            }
+            tokio::task::yield_now().await;
+        }
+    }
+    if addresses.is_empty() {
+        Err(fail().into())
+    } else {
+        Ok(addresses)
+    }
+}
+fn candidates(peers: &[SocketAddr], ipv6: bool) -> Result<Vec<SocketAddr>, DispatchError> {
+    let mut out = Vec::new();
+    for peer in peers.iter().filter(|peer| peer.is_ipv6() == ipv6) {
+        if !out.contains(peer) {
+            out.push(*peer);
+        }
+    }
+    let originals = out.clone();
+    // Match the reference's small, predictable symmetric-NAT port expansion;
+    // cap the entire attempt before sending, never an unbounded subnet scan.
+    let mut hosts = Vec::new();
+    if !ipv6 {
+        for peer in &originals {
+            if hosts.contains(&peer.ip()) {
+                continue;
+            }
+            hosts.push(peer.ip());
+            let mut ports: Vec<_> = originals
+                .iter()
+                .filter(|other| other.ip() == peer.ip())
+                .map(SocketAddr::port)
+                .collect();
+            ports.sort_unstable();
+            ports.dedup();
+            if ports.len() < 2 || ports.windows(2).any(|pair| pair[1] - pair[0] > 4) {
+                continue;
+            }
+            let end = ports[ports.len() - 1].saturating_add(4);
+            let mut added = 0;
+            for port in ports[0]..=end {
+                let candidate = SocketAddr::new(peer.ip(), port);
+                if !out.contains(&candidate) {
+                    out.push(candidate);
+                    added += 1;
+                    if added == 32 {
+                        break;
+                    }
+                }
+                if out.len() > 128 {
+                    return Err(fail().into());
+                }
+            }
+        }
+    }
+    Ok(out)
+}
+async fn punch(
+    transport: &mut dyn DatagramTransport,
+    peers: &[SocketAddr],
+    metadata: &wire::Metadata,
+) -> Result<SocketAddr, DispatchError> {
+    if peers.is_empty() {
+        return Err(fail().into());
+    }
+    let deadline = Instant::now() + Duration::from_secs(10);
+    let mut next = Instant::now();
+    loop {
+        if Instant::now() >= deadline {
+            return Err(DispatchError::TimedOut);
+        }
+        if Instant::now() >= next {
+            for peer in peers {
+                let packet = Datagram {
+                    remote: Destination::Ip(*peer),
+                    payload: Bytes::from(wire::encode(1, metadata)),
+                    sniffed_domain: None,
+                };
+                let _ = transport.send(packet).await;
+            }
+            next = Instant::now() + Duration::from_millis(100);
+        }
+        let packet = tokio::select! {()=tokio::time::sleep_until(next.min(deadline))=>continue,packet=transport.receive()=>packet?};
+        tokio::task::yield_now().await;
+        let Destination::Ip(peer) = packet.remote else {
+            continue;
+        };
+        if peer.is_ipv6() != peers[0].is_ipv6()
+            || peer.port() == 0
+            || peer.ip().is_unspecified()
+            || peer.ip().is_multicast()
+        {
+            continue;
+        }
+        if let Some(kind) = wire::decode(&packet.payload, metadata) {
+            if kind == 1 {
+                transport
+                    .send(Datagram {
+                        remote: Destination::Ip(peer),
+                        payload: Bytes::from(wire::encode(2, metadata)),
+                        sniffed_domain: None,
+                    })
+                    .await?;
+            }
+            return Ok(peer);
+        }
+        tokio::task::yield_now().await;
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn realm_candidates_keep_family_and_bound_predictable_port_probes() {
+        let peers = [
+            "192.0.2.1:40000".parse().unwrap(),
+            "192.0.2.1:40002".parse().unwrap(),
+            "[2001:db8::1]:40003".parse().unwrap(),
+        ];
+        let v4 = candidates(&peers, false).unwrap();
+        assert!(v4.contains(&"192.0.2.1:40006".parse().unwrap()));
+        assert!(v4.iter().all(SocketAddr::is_ipv4));
+        assert!(v4.len() <= 128);
+        assert_eq!(candidates(&peers, true).unwrap(), vec![peers[2]]);
+    }
+}
+
+#[cfg(test)]
+mod cancellation_tests {
+    use super::*;
+    use std::sync::{
+        Arc,
+        atomic::{AtomicUsize, Ordering},
+    };
+    struct Waiting(Arc<AtomicUsize>);
+    #[async_trait::async_trait]
+    impl DatagramTransport for Waiting {
+        fn supports_shared_destinations(&self) -> bool {
+            false
+        }
+
+        async fn send(&mut self, _: Datagram) -> Result<(), DispatchError> {
+            Ok(())
+        }
+        async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+            std::future::pending().await
+        }
+        async fn close(&mut self) -> Result<(), DispatchError> {
+            self.0.fetch_add(1, Ordering::AcqRel);
+            Ok(())
+        }
+    }
+    #[tokio::test]
+    async fn realm_cancelled_discovery_keeps_candidates_for_synchronous_cleanup() {
+        let closed = Arc::new(AtomicUsize::new(0));
+        let mut pending = Pending::default();
+        for ipv6 in [false, true] {
+            pending.candidates.push(Some(Candidate {
+                transport: Box::new(Waiting(closed.clone())),
+                ipv6,
+                mapped: Vec::new(),
+            }));
+        }
+        let servers = ["192.0.2.1:3478".parse().unwrap()];
+        {
+            let candidate = pending.candidates[0].as_mut().unwrap();
+            assert!(
+                timeout(
+                    Duration::from_millis(1),
+                    discover(&mut *candidate.transport, &servers)
+                )
+                .await
+                .is_err()
+            );
+        }
+        assert_eq!(pending.candidates.iter().flatten().count(), 2);
+        pending.stop().await;
+        assert_eq!(closed.load(Ordering::Acquire), 2);
+        assert!(pending.candidates.is_empty());
+        pending.stop().await;
+        assert_eq!(closed.load(Ordering::Acquire), 2);
+    }
+}
diff --git a/src/outbound/hysteria2/realm/http.rs b/src/outbound/hysteria2/realm/http.rs
new file mode 100644
index 0000000..1118cb6
--- /dev/null
+++ b/src/outbound/hysteria2/realm/http.rs
@@ -0,0 +1,319 @@
+//! One bounded control POST over caller-owned IO. The HTTP driver is polled
+//! inline with the exchange: dropping setup cannot detach a connection task.
+use super::{fail, wire};
+use crate::{
+    config::Hysteria2Realm,
+    dispatch::{BoxStream, DispatchError},
+    outbound::{EstablishContext, UpstreamPath},
+    security::StandardTlsClient,
+    session::{DatagramSession, StreamSession},
+};
+use bytes::Bytes;
+use hyper::body::{Body, Frame, SizeHint};
+use std::{
+    future::Future,
+    io,
+    net::SocketAddr,
+    pin::Pin,
+    task::{Context, Poll},
+};
+const BODY_LIMIT: usize = 16 * 1024;
+struct JsonBody(Option<Bytes>);
+impl Body for JsonBody {
+    type Data = Bytes;
+    type Error = io::Error;
+    fn poll_frame(
+        mut self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+    ) -> Poll<Option<io::Result<Frame<Bytes>>>> {
+        Poll::Ready(self.0.take().map(|bytes| Ok(Frame::data(bytes))))
+    }
+    fn is_end_stream(&self) -> bool {
+        self.0.is_none()
+    }
+    fn size_hint(&self) -> SizeHint {
+        SizeHint::with_exact(self.0.as_ref().map_or(0, |b| b.len() as u64))
+    }
+}
+#[derive(serde::Deserialize)]
+struct Answer {
+    addresses: Vec<SocketAddr>,
+    nonce: String,
+    obfs: String,
+}
+async fn driven<T>(
+    driver: impl Future<Output = io::Result<()>>,
+    exchange: impl Future<Output = io::Result<T>>,
+) -> io::Result<T> {
+    tokio::pin!(driver, exchange);
+    let mut done = false;
+    loop {
+        tokio::select! {
+            result=&mut exchange=>return result,
+            result=&mut driver,if !done=>{result?;done=true;}
+        }
+    }
+}
+async fn h1(io: BoxStream, mut request: http::Request<Bytes>) -> io::Result<Vec<u8>> {
+    let (mut sender, driver) = hyper::client::conn::http1::Builder::new()
+        .max_headers(100)
+        .max_buf_size(16 * 1024)
+        .handshake(hyper_util::rt::TokioIo::new(io))
+        .await
+        .map_err(|_| fail())?;
+    let authority = request
+        .uri()
+        .authority()
+        .ok_or_else(fail)?
+        .as_str()
+        .to_owned();
+    request
+        .headers_mut()
+        .insert(http::header::HOST, authority.parse().map_err(|_| fail())?);
+    request.headers_mut().insert(
+        http::header::CONNECTION,
+        http::HeaderValue::from_static("close"),
+    );
+    *request.uri_mut() = request
+        .uri()
+        .path_and_query()
+        .ok_or_else(fail)?
+        .as_str()
+        .parse()
+        .map_err(|_| fail())?;
+    let exchange = async {
+        let response = sender
+            .send_request(request.map(|bytes| JsonBody(Some(bytes))))
+            .await
+            .map_err(|_| fail())?;
+        if !response.status().is_success() {
+            return Err(fail());
+        }
+        let mut body = response.into_body();
+        let mut bytes = Vec::new();
+        while let Some(frame) = std::future::poll_fn(|cx| Pin::new(&mut body).poll_frame(cx)).await
+        {
+            let frame = frame.map_err(|_| fail())?;
+            if let Ok(data) = frame.into_data() {
+                if bytes.len() + data.len() > BODY_LIMIT {
+                    return Err(fail());
+                }
+                bytes.extend_from_slice(&data);
+            }
+        }
+        Ok(bytes)
+    };
+    driven(async { driver.await.map_err(|_| fail()) }, exchange).await
+}
+async fn h2(io: BoxStream, request: http::Request<Bytes>) -> io::Result<Vec<u8>> {
+    let (sender, driver) = h2::client::Builder::new()
+        .max_header_list_size(16 * 1024)
+        .initial_window_size(16 * 1024)
+        .initial_connection_window_size(32 * 1024)
+        .handshake(io)
+        .await
+        .map_err(|_| fail())?;
+    let (parts, body) = request.into_parts();
+    let exchange = async {
+        let mut sender = sender.ready().await.map_err(|_| fail())?;
+        let (response, mut send) = sender
+            .send_request(http::Request::from_parts(parts, ()), false)
+            .map_err(|_| fail())?;
+        send.send_data(body, true).map_err(|_| fail())?;
+        let response = response.await.map_err(|_| fail())?;
+        if !response.status().is_success() {
+            return Err(fail());
+        }
+        let mut body = response.into_body();
+        let mut bytes = Vec::new();
+        while let Some(data) = body.data().await {
+            let data = data.map_err(|_| fail())?;
+            if bytes.len() + data.len() > BODY_LIMIT {
+                return Err(fail());
+            }
+            bytes.extend_from_slice(&data);
+            body.flow_control()
+                .release_capacity(data.len())
+                .map_err(|_| fail())?;
+        }
+        Ok(bytes)
+    };
+    driven(async { driver.await.map_err(|_| fail()) }, exchange).await
+}
+pub(super) async fn connect(
+    options: &Hysteria2Realm,
+    tls: Option<&StandardTlsClient>,
+    upstream: &UpstreamPath,
+    datagram: &DatagramSession,
+    context: &EstablishContext,
+    addresses: &[SocketAddr],
+    metadata: &wire::Metadata,
+) -> Result<(Vec<SocketAddr>, wire::Metadata), DispatchError> {
+    let mut url = url::Url::parse(&options.server_url).map_err(|_| fail())?;
+    let base = url.path().trim_end_matches('/').to_owned();
+    url.set_path(&format!(
+        "{base}/v1/{}/connect",
+        percent_segment(&options.realm_id)
+    ));
+    // Url::set_path preserves valid percent escapes; credentials/query are
+    // already rejected by normalization and never become error text.
+    let server = crate::outbound::server_destination(
+        url.host_str().ok_or_else(fail)?.trim_matches(['[', ']']),
+        url.port_or_known_default().ok_or_else(fail)?,
+    )?;
+    let session = StreamSession {
+        inbound: datagram.inbound,
+        source: datagram.source,
+        destination: server.clone(),
+        sniffed_domain: None,
+        metadata: datagram.metadata.clone(),
+    };
+    let raw = upstream
+        .for_server(&server, false)
+        .connect_server(session, &server, context)
+        .await?
+        .io;
+    let (raw, alpn) = if let Some(tls) = tls {
+        tls.connect_negotiated(raw).await?
+    } else {
+        (raw, None)
+    };
+    let body=serde_json::to_vec(&serde_json::json!({"addresses":addresses,"nonce":wire::hex(&metadata.nonce),"obfs":wire::hex(&metadata.key)})).map_err(|_|fail())?;
+    if body.len() > BODY_LIMIT {
+        return Err(fail().into());
+    }
+    let mut builder = http::Request::builder()
+        .method("POST")
+        .uri(url.as_str())
+        .header("Content-Type", "application/json")
+        .header("Content-Length", body.len());
+    if !options.token.is_empty() {
+        builder = builder.header("Authorization", format!("Bearer {}", options.token));
+    }
+    let request = builder.body(Bytes::from(body)).map_err(|_| fail())?;
+    let bytes = match alpn.as_deref() {
+        Some(b"h2") => h2(raw, request).await?,
+        None | Some(b"http/1.1") => h1(raw, request).await?,
+        _ => return Err(fail().into()),
+    };
+    let answer: Answer = serde_json::from_slice(&bytes).map_err(|_| fail())?;
+    if answer.addresses.is_empty()
+        || answer.addresses.len() > 32
+        || answer
+            .addresses
+            .iter()
+            .any(|addr| addr.port() == 0 || addr.ip().is_unspecified() || addr.ip().is_multicast())
+    {
+        return Err(fail().into());
+    }
+    let metadata = wire::Metadata {
+        nonce: wire::unhex(&answer.nonce).ok_or_else(fail)?,
+        key: wire::unhex(&answer.obfs).ok_or_else(fail)?,
+    };
+    Ok((answer.addresses, metadata))
+}
+fn percent_segment(value: &str) -> String {
+    let mut out = String::new();
+    for byte in value.bytes() {
+        if byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_' | b'.' | b'~') {
+            out.push(byte as char);
+        } else {
+            out.push('%');
+            out.push_str(&format!("{byte:02X}"));
+        }
+    }
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::time::Duration;
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+    fn request() -> http::Request<Bytes> {
+        http::Request::builder()
+            .method("POST")
+            .uri("http://192.0.2.1/v1/zone/connect")
+            .header("Content-Length", 2)
+            .body(Bytes::from_static(b"{}"))
+            .unwrap()
+    }
+    async fn fixture(body: Vec<u8>) -> io::Result<Vec<u8>> {
+        let (client, mut server) = tokio::io::duplex(4096);
+        let peer = tokio::spawn(async move {
+            let mut request = Vec::new();
+            let mut one = [0; 1];
+            while !request.ends_with(b"\r\n\r\n") {
+                server.read_exact(&mut one).await.unwrap();
+                request.push(one[0]);
+                assert!(request.len() <= 16 * 1024);
+            }
+            let mut bytes = [0; 2];
+            server.read_exact(&mut bytes).await.unwrap();
+            assert_eq!(&bytes, b"{}");
+            let head = format!(
+                "HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
+                body.len()
+            );
+            if server.write_all(head.as_bytes()).await.is_ok() {
+                let _ = server.write_all(&body).await;
+            }
+            let _ = server.shutdown().await;
+        });
+        let result = h1(Box::new(client), request()).await;
+        peer.await.unwrap();
+        result
+    }
+    #[tokio::test]
+    async fn realm_memory_http_control_body_limits_and_cancellation_close_inline_driver() {
+        assert_eq!(fixture(b"answer".to_vec()).await.unwrap(), b"answer");
+        assert!(fixture(vec![0; BODY_LIMIT + 1]).await.is_err());
+        let (client, mut server) = tokio::io::duplex(4096);
+        let peer = tokio::spawn(async move {
+            let mut bytes = Vec::new();
+            server.read_to_end(&mut bytes).await.unwrap();
+            assert!(bytes.starts_with(b"POST "));
+        });
+        assert!(
+            tokio::time::timeout(Duration::from_millis(5), h1(Box::new(client), request()))
+                .await
+                .is_err()
+        );
+        tokio::time::timeout(Duration::from_secs(1), peer)
+            .await
+            .unwrap()
+            .unwrap();
+    }
+    #[tokio::test]
+    async fn realm_memory_h2_control_consumes_body_and_releases_its_driver() {
+        let (client, server) = tokio::io::duplex(4096);
+        let peer = tokio::spawn(async move {
+            let mut connection = h2::server::handshake(server).await.unwrap();
+            let (request, mut response) = connection.accept().await.unwrap().unwrap();
+            let exchange = async {
+                let mut receive = request.into_body();
+                let upload = receive.data().await.unwrap().unwrap();
+                assert_eq!(upload, b"{}".as_slice());
+                receive
+                    .flow_control()
+                    .release_capacity(upload.len())
+                    .unwrap();
+                let mut send = response
+                    .send_response(http::Response::new(()), false)
+                    .unwrap();
+                send.send_data(Bytes::from_static(b"answer"), true).unwrap();
+            };
+            let driver = async { while connection.accept().await.is_some() {} };
+            tokio::pin!(exchange, driver);
+            let mut submitted = false;
+            loop {
+                tokio::select! {()=&mut exchange,if !submitted=>submitted=true,()=&mut driver=>break}
+            }
+        });
+        assert_eq!(h2(Box::new(client), request()).await.unwrap(), b"answer");
+        tokio::time::timeout(Duration::from_secs(1), peer)
+            .await
+            .unwrap()
+            .unwrap();
+    }
+}
diff --git a/src/outbound/hysteria2/realm/wire.rs b/src/outbound/hysteria2/realm/wire.rs
new file mode 100644
index 0000000..e396f36
--- /dev/null
+++ b/src/outbound/hysteria2/realm/wire.rs
@@ -0,0 +1,183 @@
+//! Public RFC5389 XOR-MAPPED-ADDRESS and Hysteria Realm punch wire.
+use sha2::{Digest, Sha256};
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
+const COOKIE: [u8; 4] = [0x21, 0x12, 0xa4, 0x42];
+pub(super) fn stun_request(id: [u8; 12]) -> Vec<u8> {
+    let mut out = vec![0, 1, 0, 0];
+    out.extend_from_slice(&COOKIE);
+    out.extend_from_slice(&id);
+    out
+}
+pub(super) fn stun_response(bytes: &[u8], id: &[u8; 12]) -> Option<SocketAddr> {
+    if bytes.len() < 20 || bytes[..2] != [1, 1] || bytes[4..8] != COOKIE || bytes[8..20] != *id {
+        return None;
+    }
+    let length = usize::from(u16::from_be_bytes(bytes[2..4].try_into().ok()?));
+    if length % 4 != 0 || 20 + length > bytes.len() {
+        return None;
+    }
+    let mut body = &bytes[20..20 + length];
+    while body.len() >= 4 {
+        let kind = u16::from_be_bytes(body[..2].try_into().ok()?);
+        let len = usize::from(u16::from_be_bytes(body[2..4].try_into().ok()?));
+        let padded = (len + 3) & !3;
+        if 4 + padded > body.len() {
+            return None;
+        }
+        let value = &body[4..4 + len];
+        body = &body[4 + padded..];
+        if kind != 0x20 {
+            continue;
+        }
+        if value.len() < 4 {
+            return None;
+        }
+        let port = u16::from_be_bytes(value[2..4].try_into().ok()?) ^ 0x2112;
+        let mut key = [0u8; 16];
+        key[..4].copy_from_slice(&COOKIE);
+        key[4..].copy_from_slice(id);
+        let ip = match (value[1], value.len()) {
+            (1, 8) => {
+                let b: [u8; 4] = std::array::from_fn(|n| value[4 + n] ^ key[n]);
+                IpAddr::V4(Ipv4Addr::from(b))
+            }
+            (2, 20) => {
+                let b: [u8; 16] = std::array::from_fn(|n| value[4 + n] ^ key[n]);
+                IpAddr::V6(Ipv6Addr::from(b))
+            }
+            _ => return None,
+        };
+        return (port != 0 && !ip.is_unspecified() && !ip.is_multicast())
+            .then_some(SocketAddr::new(ip, port));
+    }
+    None
+}
+#[derive(Clone)]
+pub(super) struct Metadata {
+    pub nonce: [u8; 16],
+    pub key: [u8; 32],
+}
+fn mask(bytes: &mut [u8], salt: &[u8], key: &[u8; 32]) {
+    let mut hash = Sha256::new();
+    hash.update(key);
+    hash.update(salt);
+    let hash = hash.finalize();
+    for (n, b) in bytes.iter_mut().enumerate() {
+        *b ^= hash[n % 32];
+    }
+}
+pub(super) fn encode(kind: u8, meta: &Metadata) -> Vec<u8> {
+    let padding = rand::random_range(0..=1024);
+    let mut out = vec![0; 8 + 25 + padding];
+    rand::fill(out.as_mut_slice());
+    out[8..16].copy_from_slice(b"HYRLMv1\0");
+    out[16] = kind;
+    out[17..33].copy_from_slice(&meta.nonce);
+    let (salt, body) = out.split_at_mut(8);
+    mask(body, salt, &meta.key);
+    out
+}
+pub(super) fn decode(bytes: &[u8], meta: &Metadata) -> Option<u8> {
+    if !(33..=1057).contains(&bytes.len()) {
+        return None;
+    }
+    // Only the fixed header is needed; random padding never allocates.
+    let mut body: [u8; 25] = bytes[8..33].try_into().ok()?;
+    mask(&mut body, &bytes[..8], &meta.key);
+    (body[..8] == *b"HYRLMv1\0" && matches!(body[8], 1 | 2) && body[9..25] == meta.nonce)
+        .then_some(body[8])
+}
+pub(super) fn hex(bytes: &[u8]) -> String {
+    const H: &[u8; 16] = b"0123456789abcdef";
+    let mut out = String::with_capacity(bytes.len() * 2);
+    for b in bytes {
+        out.push(H[usize::from(b >> 4)] as char);
+        out.push(H[usize::from(b & 15)] as char);
+    }
+    out
+}
+pub(super) fn unhex<const N: usize>(value: &str) -> Option<[u8; N]> {
+    if value.len() != 2 * N {
+        return None;
+    }
+    let mut out = [0u8; N];
+    for (n, b) in value.as_bytes().as_chunks::<2>().0.iter().enumerate() {
+        fn digit(b: u8) -> Option<u8> {
+            match b {
+                b'0'..=b'9' => Some(b - b'0'),
+                b'a'..=b'f' => Some(b - b'a' + 10),
+                b'A'..=b'F' => Some(b - b'A' + 10),
+                _ => None,
+            }
+        }
+        out[n] = (digit(b[0])? << 4) | digit(b[1])?;
+    }
+    Some(out)
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn realm_stun_matches_transaction_and_checked_ipv4_ipv6_attributes() {
+        let id = [7; 12];
+        for address in [
+            "192.0.2.10:40000".parse::<SocketAddr>().unwrap(),
+            "[2001:db8::1]:40001".parse().unwrap(),
+        ] {
+            let mut bytes = stun_request(id);
+            bytes[..2].copy_from_slice(&[1, 1]);
+            let mut attr = vec![0, 0x20, 0, 0, 0, if address.is_ipv4() { 1 } else { 2 }];
+            attr.extend_from_slice(&(address.port() ^ 0x2112).to_be_bytes());
+            let ip = match address.ip() {
+                IpAddr::V4(ip) => ip.octets().to_vec(),
+                IpAddr::V6(ip) => ip.octets().to_vec(),
+            };
+            let mut key = COOKIE.to_vec();
+            key.extend_from_slice(&id);
+            for (n, b) in ip.iter().enumerate() {
+                attr.push(*b ^ key[n]);
+            }
+            let len = (attr.len() - 4) as u16;
+            attr[2..4].copy_from_slice(&len.to_be_bytes());
+            bytes[2..4].copy_from_slice(&(attr.len() as u16).to_be_bytes());
+            bytes.extend(attr);
+            assert_eq!(stun_response(&bytes, &id), Some(address));
+            assert_eq!(stun_response(&bytes, &[8; 12]), None);
+            for n in 0..bytes.len() {
+                assert_eq!(stun_response(&bytes[..n], &id), None);
+            }
+        }
+    }
+    #[test]
+    fn realm_punch_has_bounded_padding_and_checks_magic_nonce_key() {
+        let meta = Metadata {
+            nonce: [3; 16],
+            key: [9; 32],
+        };
+        for kind in [1, 2] {
+            let bytes = encode(kind, &meta);
+            assert!((33..=1057).contains(&bytes.len()));
+            assert_eq!(decode(&bytes, &meta), Some(kind));
+            assert_eq!(
+                decode(
+                    &bytes,
+                    &Metadata {
+                        nonce: [4; 16],
+                        key: [9; 32]
+                    }
+                ),
+                None
+            );
+            assert_eq!(
+                decode(
+                    &bytes,
+                    &Metadata {
+                        nonce: [3; 16],
+                        key: [8; 32]
+                    }
+                ),
+                None
+            );
+        }
+    }
+}
diff --git a/src/outbound/hysteria2/salamander.rs b/src/outbound/hysteria2/salamander.rs
index 78ab08e..17fbcb5 100644
--- a/src/outbound/hysteria2/salamander.rs
+++ b/src/outbound/hysteria2/salamander.rs
@@ -52,9 +52,52 @@ fn decode(password: &[u8], wire: Bytes) -> Option<Bytes> {
 
 #[async_trait]
 impl DatagramTransport for Salamander {
+    fn supports_shared_destinations(&self) -> bool {
+        self.inner.supports_shared_destinations()
+    }
+
+    fn supports_poll_receive(&self) -> bool {
+        self.inner.supports_poll_receive()
+    }
+    fn poll_receive(
+        &mut self,
+        context: &mut std::task::Context<'_>,
+        scratch: &mut Vec<u8>,
+    ) -> std::task::Poll<Result<Datagram, DispatchError>> {
+        for _ in 0..crate::limits::IO_POLL_BUDGET {
+            let mut packet = std::task::ready!(self.inner.poll_receive(context, scratch))?;
+            let maximum = self.inner.payload_budget(&packet.remote).receive();
+            if packet.payload.len() > usize::from(maximum) {
+                continue;
+            }
+            if let Some(payload) = decode(&self.password, packet.payload) {
+                packet.payload = payload;
+                return std::task::Poll::Ready(Ok(packet));
+            }
+        }
+        context.waker().wake_by_ref();
+        std::task::Poll::Pending
+    }
     fn payload_budget(&self, peer: &Destination) -> DatagramBudget {
         self.inner.payload_budget(peer).subtract_overhead(8, 8)
     }
+    fn send_owned(
+        &mut self,
+        packet: Datagram,
+    ) -> Result<crate::dispatch::OwnedDatagramSend, Datagram> {
+        if packet.payload.is_empty()
+            || packet.payload.len() > usize::from(self.payload_budget(&packet.remote).transmit())
+        {
+            return Err(packet);
+        }
+        let mut encoded = packet;
+        let plain = std::mem::take(&mut encoded.payload);
+        encoded.payload = encode(&self.password, rand::random(), &plain);
+        self.inner.send_owned(encoded).map_err(|mut packet| {
+            packet.payload = plain;
+            packet
+        })
+    }
     async fn send(&mut self, mut packet: Datagram) -> Result<(), DispatchError> {
         if packet.payload.is_empty()
             || packet.payload.len() > usize::from(self.payload_budget(&packet.remote).transmit())
@@ -88,13 +131,165 @@ impl DatagramTransport for Salamander {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::{
+        sync::atomic::{AtomicBool, Ordering},
+        task::{Context, Poll},
+    };
+    use tokio::sync::mpsc;
+
+    struct Packets {
+        shared: bool,
+        first: Destination,
+        send: mpsc::Sender<Datagram>,
+        receive: mpsc::Receiver<Datagram>,
+        closed: Arc<AtomicBool>,
+    }
+
+    #[async_trait]
+    impl DatagramTransport for Packets {
+        fn supports_shared_destinations(&self) -> bool {
+            self.shared
+        }
+
+        fn payload_budget(&self, _: &Destination) -> DatagramBudget {
+            DatagramBudget::new(2048, 2048)
+        }
+
+        fn supports_poll_receive(&self) -> bool {
+            true
+        }
+
+        fn poll_receive(
+            &mut self,
+            cx: &mut Context<'_>,
+            _: &mut Vec<u8>,
+        ) -> Poll<Result<Datagram, DispatchError>> {
+            if self.closed.load(Ordering::Acquire) {
+                return Poll::Ready(Err(DispatchError::NotAllowed));
+            }
+            self.receive
+                .poll_recv(cx)
+                .map(|packet| packet.ok_or(DispatchError::NotAllowed))
+        }
+
+        fn send_owned(
+            &mut self,
+            packet: Datagram,
+        ) -> Result<crate::dispatch::OwnedDatagramSend, Datagram> {
+            if self.closed.load(Ordering::Acquire) || (!self.shared && packet.remote != self.first)
+            {
+                return Err(packet);
+            }
+            let send = self.send.clone();
+            Ok(Box::pin(async move {
+                send.send(packet)
+                    .await
+                    .map_err(|_| DispatchError::NotAllowed)
+            }))
+        }
+
+        async fn send(&mut self, packet: Datagram) -> Result<(), DispatchError> {
+            self.send_owned(packet)
+                .map_err(|_| DispatchError::NotAllowed)?
+                .await
+        }
+
+        async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+            std::future::poll_fn(|cx| self.poll_receive(cx, &mut Vec::new())).await
+        }
+
+        async fn close(&mut self) -> Result<(), DispatchError> {
+            self.closed.store(true, Ordering::Release);
+            Ok(())
+        }
+    }
+
+    #[tokio::test]
+    async fn salamander_memory_and_pacer_preserve_address_sharing_owned_send_and_close() {
+        for shared in [false, true] {
+            let (send, mut sent) = mpsc::channel(4);
+            let (reply, receive) = mpsc::channel(4);
+            let closed = Arc::new(AtomicBool::new(false));
+            let first = Destination::Ip("192.0.2.1:443".parse().unwrap());
+            let second = Destination::Ip("[2001:db8::2]:8443".parse().unwrap());
+            let mut wrapped = Arc::new(super::super::bandwidth::Bandwidth::default()).wrap(
+                wrap(
+                    Box::new(Packets {
+                        shared,
+                        first: first.clone(),
+                        send,
+                        receive,
+                        closed: closed.clone(),
+                    }),
+                    "memory-obfs",
+                ),
+                1400,
+            );
+            assert_eq!(wrapped.supports_shared_destinations(), shared);
+            assert!(wrapped.supports_poll_receive());
+            assert_eq!(
+                wrapped.payload_budget(&first),
+                DatagramBudget::new(2040, 2040)
+            );
+            for (index, remote) in [first.clone(), second.clone()].into_iter().enumerate() {
+                let packet = Datagram {
+                    remote: remote.clone(),
+                    payload: Bytes::from_static(b"addressed QUIC payload"),
+                    sniffed_domain: None,
+                };
+                if !shared && index == 1 {
+                    assert!(wrapped.send(packet).await.is_err());
+                    assert!(sent.try_recv().is_err());
+                    continue;
+                }
+                if index == 0 {
+                    wrapped.send(packet.clone()).await.unwrap();
+                } else {
+                    wrapped
+                        .send_owned(packet.clone())
+                        .expect("owned send supported")
+                        .await
+                        .unwrap();
+                }
+                let wire = sent.recv().await.unwrap();
+                assert_eq!(wire.remote, remote);
+                assert_eq!(
+                    wire.payload.len(),
+                    packet.payload.len() + usize::from(OVERHEAD)
+                );
+                assert_eq!(
+                    decode(b"memory-obfs", wire.payload.clone()).unwrap(),
+                    packet.payload
+                );
+                reply.send(wire).await.unwrap();
+                let received = if index == 0 {
+                    std::future::poll_fn(|cx| wrapped.poll_receive(cx, &mut Vec::new()))
+                        .await
+                        .unwrap()
+                } else {
+                    wrapped.receive().await.unwrap()
+                };
+                assert_eq!(received.remote, remote);
+                assert_eq!(received.payload, packet.payload);
+            }
+            wrapped.close().await.unwrap();
+            assert!(closed.load(Ordering::Acquire));
+            assert!(
+                wrapped
+                    .send(Datagram {
+                        remote: first,
+                        payload: Bytes::from_static(b"closed"),
+                        sniffed_domain: None
+                    })
+                    .await
+                    .is_err()
+            );
+            assert!(wrapped.receive().await.is_err());
+        }
+    }
+
     #[test]
     fn salamander_matches_independent_blake2b256_vector_and_rejects_short_packets() {
-        #[cfg(feature = "interop-test")]
-        let _case = crate::resources::case_events::Case::new(
-            "HYSTERIA2-UNIT",
-            "salamander_matches_independent_blake2b256_vector_and_rejects_short_packets",
-        );
         // Python hashlib.blake2b(digest_size=32), password || salt; not a
         // truncated BLAKE2b-512 and not a keyed BLAKE2 MAC.
         let literal = "0001020304050607c4df23f89a88b3e3c7615199d4aaa6d88c9d92aa39a1914b372f674df11d4745e4ff03d8baa893c3";
diff --git a/src/outbound/hysteria2/socket.rs b/src/outbound/hysteria2/socket.rs
index 3d7b5a2..bd29dbb 100644
--- a/src/outbound/hysteria2/socket.rs
+++ b/src/outbound/hysteria2/socket.rs
@@ -138,11 +138,6 @@ mod tests {
     }
     #[tokio::test]
     async fn a_new_path_packet_does_not_end_the_old_receive_window() {
-        #[cfg(feature = "interop-test")]
-        let _case = crate::resources::case_events::Case::new(
-            "HYSTERIA2-UNIT",
-            "a_new_path_packet_does_not_end_the_old_receive_window",
-        );
         let (old_tx, old) = memory_socket();
         let (new_tx, new) = memory_socket();
         let socket = WindowSocket::new(new, Some(old));
diff --git a/src/outbound/hysteria2/stream.rs b/src/outbound/hysteria2/stream.rs
index fd98a3c..20c38b1 100644
--- a/src/outbound/hysteria2/stream.rs
+++ b/src/outbound/hysteria2/stream.rs
@@ -36,12 +36,12 @@ pub(super) struct TcpStream<R, W> {
 }
 
 impl<R: AsyncRead + Unpin + Send + 'static, W> TcpStream<R, W> {
-    pub fn new(mut reader: R, writer: W, deadline: tokio::time::Instant) -> Self {
+    pub fn new(mut reader: R, writer: W) -> Self {
         Self {
             response: Some(Box::pin(async move {
-                tokio::time::timeout_at(deadline, super::wire::tcp_response(&mut reader))
-                    .await
-                    .map_err(|_| io::Error::from(io::ErrorKind::TimedOut))??;
+                // Setup has already committed the request. A peer can defer
+                // success until origin data arrives, beyond the setup budget.
+                super::wire::tcp_response(&mut reader).await?;
                 Ok(reader)
             })),
             reader: None,
@@ -102,8 +102,8 @@ impl<R: Unpin, W: AsyncWrite + Unpin> AsyncWrite for TcpStream<R, W> {
         cx: &mut Context<'_>,
         bytes: &[u8],
     ) -> Poll<io::Result<usize>> {
-        // Opportunistically consume an already available response/failure and
-        // enforce the original deadline, but never wait for target-first data.
+        // Consume an available response/failure without blocking client-first
+        // upload or imposing a setup deadline on an established stream.
         self.wakeups.writer.register(cx.waker());
         if let Poll::Ready(Err(error)) = self.poll_response() {
             return Poll::Ready(Err(error));
@@ -140,20 +140,37 @@ mod tests {
     use super::*;
     use tokio::io::{AsyncReadExt, AsyncWriteExt};
 
+    #[tokio::test(start_paused = true)]
+    async fn admitted_upload_survives_setup_deadline_before_delayed_response() {
+        let (client, mut peer) = tokio::io::duplex(128);
+        let (reader, writer) = tokio::io::split(client);
+        let stream = TcpStream::new(reader, writer);
+        let (mut reader, mut writer) = tokio::io::split(stream);
+        let reading = tokio::spawn(async move {
+            let mut reply = [0; 5];
+            reader.read_exact(&mut reply).await.unwrap();
+            reply
+        });
+        writer.write_all(b"start").await.unwrap();
+        let mut request = [0; 5];
+        peer.read_exact(&mut request).await.unwrap();
+        assert_eq!(&request, b"start");
+        // A Mihomo peer may defer success until the origin has response data.
+        // Established upload must remain writable beyond its setup budget.
+        tokio::time::advance(std::time::Duration::from_secs(11)).await;
+        writer.write_all(b"tail!").await.unwrap();
+        peer.read_exact(&mut request).await.unwrap();
+        assert_eq!(&request, b"tail!");
+        peer.write_all(b"\0\0\0reply").await.unwrap();
+        assert_eq!(&reading.await.unwrap(), b"reply");
+        writer.shutdown().await.unwrap();
+    }
+
     #[tokio::test]
     async fn a_client_first_write_does_not_steal_a_pending_read_wakeup() {
-        #[cfg(feature = "interop-test")]
-        let _case = crate::resources::case_events::Case::new(
-            "HYSTERIA2-UNIT",
-            "a_client_first_write_does_not_steal_a_pending_read_wakeup",
-        );
         let (client, mut peer) = tokio::io::duplex(128);
         let (reader, writer) = tokio::io::split(client);
-        let stream = TcpStream::new(
-            reader,
-            writer,
-            tokio::time::Instant::now() + std::time::Duration::from_secs(1),
-        );
+        let stream = TcpStream::new(reader, writer);
         let (mut reader, mut writer) = tokio::io::split(stream);
         let reading = tokio::spawn(async move { reader.read_u8().await });
         tokio::time::sleep(std::time::Duration::from_millis(10)).await;
@@ -172,18 +189,9 @@ mod tests {
 
     #[tokio::test]
     async fn application_eof_closes_both_directions_without_consuming_a_tail() {
-        #[cfg(feature = "interop-test")]
-        let _case = crate::resources::case_events::Case::new(
-            "HYSTERIA2-UNIT",
-            "application_eof_closes_both_directions_without_consuming_a_tail",
-        );
         let (client, mut peer) = tokio::io::duplex(128);
         let (reader, writer) = tokio::io::split(client);
-        let mut stream = TcpStream::new(
-            reader,
-            writer,
-            tokio::time::Instant::now() + std::time::Duration::from_secs(1),
-        );
+        let mut stream = TcpStream::new(reader, writer);
         peer.write_all(b"\0\0\0hello").await.unwrap();
         let mut hello = [0; 5];
         stream.read_exact(&mut hello).await.unwrap();
@@ -202,18 +210,9 @@ mod tests {
 
     #[tokio::test]
     async fn shutdown_wakes_an_already_pending_logical_reader() {
-        #[cfg(feature = "interop-test")]
-        let _case = crate::resources::case_events::Case::new(
-            "HYSTERIA2-UNIT",
-            "shutdown_wakes_an_already_pending_logical_reader",
-        );
         let (client, mut peer) = tokio::io::duplex(128);
         let (reader, writer) = tokio::io::split(client);
-        let mut stream = TcpStream::new(
-            reader,
-            writer,
-            tokio::time::Instant::now() + std::time::Duration::from_secs(1),
-        );
+        let mut stream = TcpStream::new(reader, writer);
         peer.write_all(b"\0\0\0a").await.unwrap();
         assert_eq!(stream.read_u8().await.unwrap(), b'a');
         let (mut reader, mut writer) = tokio::io::split(stream);
diff --git a/src/outbound/hysteria2/wire.rs b/src/outbound/hysteria2/wire.rs
index 98bf9da..51225d9 100644
--- a/src/outbound/hysteria2/wire.rs
+++ b/src/outbound/hysteria2/wire.rs
@@ -61,11 +61,6 @@ mod tests {
 
     #[tokio::test]
     async fn tcp_wire_matches_the_protocol_and_preserves_server_first_bytes() {
-        #[cfg(feature = "interop-test")]
-        let _case = crate::resources::case_events::Case::new(
-            "HYSTERIA2-UNIT",
-            "tcp_wire_matches_the_protocol_and_preserves_server_first_bytes",
-        );
         let destination = Destination::domain("x", 1).unwrap();
         assert_eq!(tcp_request(&destination).unwrap(), b"\x44\x01\x03x:1\x00");
         let mut response = &b"\0\x02ok\x03padserver-first"[..];
diff --git a/src/outbound/masque/datagram.rs b/src/outbound/masque/datagram.rs
new file mode 100644
index 0000000..4cba7c9
--- /dev/null
+++ b/src/outbound/masque/datagram.rs
@@ -0,0 +1,316 @@
+//! Logical UDP leases share the node's existing bounded raw-IP packet path.
+use super::ip::Engine;
+use crate::{
+    dispatch::{DatagramBudget, DatagramTransport, DispatchError},
+    dns::resolution::ResolutionContext,
+    outbound::DEFAULT_ESTABLISH_TIMEOUT,
+    resources::observation::{self, ResourceKind},
+    session::{Datagram, Destination},
+};
+use async_trait::async_trait;
+use bytes::Bytes;
+use std::{
+    collections::HashMap,
+    net::SocketAddr,
+    sync::{Arc, Mutex, Weak},
+};
+use tokio::{sync::mpsc, time::Instant};
+use vole_netstack::{Packet, UdpDatagram, encode_udp_packet_into};
+
+const FIRST_PORT: u16 = 1024;
+const RESPONSE_QUEUE: usize = 64;
+
+struct Entry {
+    id: u64,
+    slot: Weak<Slot>,
+}
+struct State {
+    next_port: u16,
+    next_id: u64,
+    entries: HashMap<u16, Entry>,
+}
+impl Default for State {
+    fn default() -> Self {
+        Self {
+            next_port: 49152,
+            next_id: 0,
+            entries: HashMap::new(),
+        }
+    }
+}
+
+#[derive(Default)]
+pub(super) struct Registry(Mutex<State>);
+
+struct Slot {
+    port: u16,
+    id: u64,
+    registry: Arc<Registry>,
+    sender: mpsc::Sender<Datagram>,
+    maximum: u16,
+    _observation: observation::Guard,
+}
+impl Registry {
+    fn open(
+        self: &Arc<Self>,
+        maximum: u16,
+    ) -> Result<(Arc<Slot>, mpsc::Receiver<Datagram>), DispatchError> {
+        let mut state = self.0.lock().unwrap();
+        for _ in FIRST_PORT..=u16::MAX {
+            let port = state.next_port;
+            state.next_port = if port == u16::MAX {
+                FIRST_PORT
+            } else {
+                port + 1
+            };
+            if state
+                .entries
+                .get(&port)
+                .is_some_and(|entry| entry.slot.strong_count() > 0)
+            {
+                continue;
+            }
+            state.next_id = state.next_id.checked_add(1).ok_or_else(|| {
+                DispatchError::Other("MASQUE UDP lease identifiers exhausted".into())
+            })?;
+            let id = state.next_id;
+            let (sender, receiver) = mpsc::channel(RESPONSE_QUEUE);
+            let slot = Arc::new(Slot {
+                port,
+                id,
+                registry: self.clone(),
+                sender,
+                maximum,
+                _observation: observation::track(ResourceKind::Association),
+            });
+            state.entries.insert(
+                port,
+                Entry {
+                    id,
+                    slot: Arc::downgrade(&slot),
+                },
+            );
+            return Ok((slot, receiver));
+        }
+        Err(DispatchError::Other(
+            "MASQUE UDP source ports exhausted".into(),
+        ))
+    }
+
+    pub fn deliver(&self, source: SocketAddr, destination: SocketAddr, payload: &[u8]) {
+        let slot = self
+            .0
+            .lock()
+            .unwrap()
+            .entries
+            .get(&destination.port())
+            .and_then(|entry| entry.slot.upgrade());
+        let Some(slot) = slot.filter(|slot| payload.len() <= usize::from(slot.maximum)) else {
+            return;
+        };
+        // Reserve before copying: a slow consumer drops this UDP reply without
+        // allocating another packet or blocking TCP/control ingress.
+        if let Ok(permit) = slot.sender.try_reserve() {
+            permit.send(Datagram {
+                remote: Destination::Ip(source),
+                payload: Bytes::copy_from_slice(payload),
+                sniffed_domain: None,
+            });
+        }
+    }
+}
+impl Drop for Slot {
+    fn drop(&mut self) {
+        let mut state = self.registry.0.lock().unwrap();
+        if state
+            .entries
+            .get(&self.port)
+            .is_some_and(|entry| entry.id == self.id)
+        {
+            state.entries.remove(&self.port);
+        }
+        if state.entries.capacity() > state.entries.len().saturating_mul(4).max(64) {
+            state.entries.shrink_to_fit();
+        }
+    }
+}
+
+pub(super) struct Datagrams {
+    engine: Arc<Engine>,
+    slot: Option<Arc<Slot>>,
+    receiver: mpsc::Receiver<Datagram>,
+    resolution: ResolutionContext,
+    budget: DatagramBudget,
+    frame: Vec<u8>,
+}
+impl Datagrams {
+    pub fn new(
+        engine: Arc<Engine>,
+        budget: DatagramBudget,
+        resolution: ResolutionContext,
+    ) -> Result<Self, DispatchError> {
+        if engine.cancel.is_cancelled() {
+            return Err(DispatchError::ConnectionRefused);
+        }
+        let maximum = engine
+            .client
+            .prefixes()
+            .map(|prefix| {
+                let (overhead, wire_limit) = if prefix.address.is_ipv4() {
+                    (28, 65507)
+                } else {
+                    (48, 65527)
+                };
+                engine
+                    .client
+                    .receive_packet_limit
+                    .saturating_sub(overhead)
+                    .min(wire_limit)
+            })
+            .max()
+            .unwrap_or(0)
+            .min(usize::from(budget.receive()));
+        let (slot, receiver) = engine
+            .registry
+            .open(u16::try_from(maximum).expect("UDP wire limit fits u16"))?;
+        if engine.cancel.is_cancelled() {
+            return Err(DispatchError::ConnectionRefused);
+        }
+        Ok(Self {
+            engine,
+            slot: Some(slot),
+            receiver,
+            resolution,
+            budget,
+            frame: Vec::new(),
+        })
+    }
+
+    fn port(&self) -> Result<u16, DispatchError> {
+        self.slot
+            .as_ref()
+            .map(|slot| slot.port)
+            .ok_or(DispatchError::ConnectionRefused)
+    }
+}
+#[async_trait]
+impl DatagramTransport for Datagrams {
+    fn supports_shared_destinations(&self) -> bool {
+        // One inner source-port lease can address multiple IP destinations;
+        // the shared IP tunnel already owns the physical transport.
+        true
+    }
+    fn payload_budget(&self, peer: &Destination) -> DatagramBudget {
+        let overhead = match peer {
+            Destination::Ip(peer) if peer.is_ipv4() => 28,
+            Destination::Ip(_) => 48,
+            Destination::Domain { .. } if self.engine.client.has_ipv6() => 48,
+            Destination::Domain { .. } => 28,
+        };
+        let wire_maximum = if overhead == 28 { 65507 } else { 65527 };
+        let cap = |limit: usize| {
+            u16::try_from(limit.saturating_sub(overhead).min(wire_maximum))
+                .expect("UDP wire limit fits u16")
+        };
+        self.budget.intersect(DatagramBudget::new(
+            cap(self.engine.mtu),
+            cap(self.engine.client.receive_packet_limit),
+        ))
+    }
+
+    async fn send(&mut self, datagram: Datagram) -> Result<(), DispatchError> {
+        let port = self.port()?;
+        if datagram.payload.len() > usize::from(self.budget.transmit()) {
+            return Err(DispatchError::Other(
+                "MASQUE datagram exceeds transmit budget".into(),
+            ));
+        }
+        let deadline = Instant::now() + DEFAULT_ESTABLISH_TIMEOUT;
+        let cancellation = self.engine.cancel.clone();
+        let operation = async {
+            let destination = self
+                .engine
+                .resolve(&datagram.remote, &self.resolution, deadline)
+                .await?;
+            if datagram.payload.len()
+                > usize::from(
+                    self.payload_budget(&Destination::Ip(destination))
+                        .transmit(),
+                )
+            {
+                return Err(DispatchError::Other(
+                    "MASQUE datagram exceeds transmit budget".into(),
+                ));
+            }
+            let source = SocketAddr::new(self.engine.local(destination.ip())?, port);
+            encode_udp_packet_into(
+                &UdpDatagram::new(source, destination, datagram.payload),
+                self.engine.mtu,
+                &mut self.frame,
+            )
+            .map_err(|_| DispatchError::Other("invalid MASQUE datagram".into()))?;
+            let packet = Packet::new(Bytes::copy_from_slice(&self.frame));
+            self.engine
+                .tx
+                .send(packet)
+                .await
+                .map_err(|_| DispatchError::ConnectionRefused)
+        };
+        tokio::select! {biased;
+            ()=cancellation.cancelled()=>Err(DispatchError::ConnectionRefused),
+            result=tokio::time::timeout_at(deadline,operation)=>result.map_err(|_|DispatchError::TimedOut)?,
+        }
+    }
+
+    async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+        self.port()?;
+        tokio::select! {biased;
+            ()=self.engine.cancel.cancelled()=>Err(DispatchError::ConnectionRefused),
+            datagram=self.receiver.recv()=>datagram.ok_or(DispatchError::ConnectionRefused),
+        }
+    }
+
+    async fn close(&mut self) -> Result<(), DispatchError> {
+        self.slot.take();
+        self.receiver.close();
+        while self.receiver.try_recv().is_ok() {}
+        self.frame = Vec::new();
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn masque_udp_leases_bound_replies_without_retaining_closed_ports() {
+        let registry = Arc::new(Registry::default());
+        let (first, mut receiver) = registry.open(4).unwrap();
+        let (second, mut other) = registry.open(4).unwrap();
+        assert_ne!(first.port, second.port);
+        let remote = "192.0.2.1:53".parse().unwrap();
+        let destination = SocketAddr::new("10.0.0.2".parse().unwrap(), first.port);
+        registry.deliver(remote, destination, b"oversized");
+        assert!(receiver.try_recv().is_err());
+        for value in 0..=RESPONSE_QUEUE {
+            registry.deliver(remote, destination, &[u8::try_from(value).unwrap()]);
+        }
+        for value in 0..RESPONSE_QUEUE {
+            let datagram = receiver.try_recv().unwrap();
+            assert_eq!(datagram.remote, Destination::Ip(remote));
+            assert_eq!(&datagram.payload[..], &[u8::try_from(value).unwrap()]);
+        }
+        assert!(receiver.try_recv().is_err());
+        assert!(other.try_recv().is_err());
+        registry.deliver(remote, destination, b"back");
+        assert_eq!(&receiver.try_recv().unwrap().payload[..], b"back");
+        let port = first.port;
+        drop(first);
+        assert!(!registry.0.lock().unwrap().entries.contains_key(&port));
+        registry.deliver(remote, destination, b"late");
+        assert!(receiver.try_recv().is_err());
+        drop(second);
+        assert!(registry.0.lock().unwrap().entries.is_empty());
+    }
+}
diff --git a/src/outbound/masque/h2_output_batch_memory_tests.rs b/src/outbound/masque/h2_output_batch_memory_tests.rs
new file mode 100644
index 0000000..28a8007
--- /dev/null
+++ b/src/outbound/masque/h2_output_batch_memory_tests.rs
@@ -0,0 +1,257 @@
+//! Real pump/codec bytes over memory IO; existing Grpc/Writes fixtures guard
+//! the supplied-IO receipt implementation, which this candidate does not change.
+use super::*;
+use std::{
+    pin::Pin,
+    sync::Mutex as SyncMutex,
+    task::{Context, Poll, Waker},
+};
+use vole_netstack::{UdpDatagram, encode_udp_packet_into, parse_udp_packet_view};
+
+#[derive(Default)]
+struct Observed {
+    writes: Vec<Vec<u8>>,
+    flushed: usize,
+    blocked: bool,
+    fail: bool,
+    waker: Option<Waker>,
+}
+#[derive(Clone, Default)]
+struct Writer(Arc<SyncMutex<Observed>>);
+impl tokio::io::AsyncWrite for Writer {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+        input: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        self.0.lock().unwrap().writes.push(input.to_vec());
+        Poll::Ready(Ok(input.len()))
+    }
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let mut state = self.0.lock().unwrap();
+        if state.blocked {
+            state.waker = Some(cx.waker().clone());
+            return Poll::Pending;
+        }
+        if state.fail {
+            return Poll::Ready(Err(io::ErrorKind::BrokenPipe.into()));
+        }
+        state.flushed += 1;
+        Poll::Ready(Ok(()))
+    }
+    fn poll_shutdown(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+}
+
+fn parts() -> ClientNetStackParts {
+    NetStack::start_client(
+        NetStackConfig {
+            mtu: 65535,
+            ..Default::default()
+        },
+        ClientConfig {
+            prefixes: [
+                Some(ClientPrefix {
+                    address: "192.0.2.2".parse().unwrap(),
+                    prefix_len: 32,
+                }),
+                Some(ClientPrefix {
+                    address: "fd00::2".parse().unwrap(),
+                    prefix_len: 128,
+                }),
+            ],
+            receive_packet_limit: MAX_RECEIVE_PACKET_SIZE,
+            path_mtu_discovery: true,
+        },
+    )
+    .unwrap()
+}
+fn packet(id: u8, length: usize, ipv6: bool) -> Packet {
+    let (source, destination) = if ipv6 {
+        ("fd00::2", "fd00::3")
+    } else {
+        ("192.0.2.2", "198.51.100.1")
+    };
+    let mut raw = Vec::new();
+    encode_udp_packet_into(
+        &UdpDatagram::new(
+            SocketAddr::new(source.parse().unwrap(), 40000 + u16::from(id)),
+            SocketAddr::new(destination.parse().unwrap(), 50000 + u16::from(id)),
+            Bytes::from(vec![id; length]),
+        ),
+        65535,
+        &mut raw,
+    )
+    .unwrap();
+    Packet::new(raw)
+}
+fn decoded(writes: &[Vec<u8>]) -> Vec<Vec<Bytes>> {
+    writes
+        .iter()
+        .map(|wire| {
+            let mut decoder = codec::CapsuleDecoder::new(MAX_RECEIVE_PACKET_SIZE);
+            let mut input = wire.as_slice();
+            let mut packets = Vec::new();
+            while !input.is_empty() {
+                let (consumed, capsule) = decoder.feed(input).unwrap();
+                assert!(consumed > 0);
+                input = &input[consumed..];
+                if let Some(capsule) = capsule {
+                    assert_eq!(capsule.kind, codec::DATAGRAM);
+                    packets.push(capsule.value);
+                }
+            }
+            decoder.finish().unwrap();
+            packets
+        })
+        .collect()
+}
+fn assert_packets(actual: &[Bytes], expected: &[Packet]) {
+    assert_eq!(actual.len(), expected.len());
+    for (actual, expected) in actual.iter().zip(expected) {
+        let original = parse_udp_packet_view(expected.data()).unwrap();
+        let view = parse_udp_packet_view(actual).unwrap();
+        assert_eq!(view.source, original.source);
+        assert_eq!(view.destination, original.destination);
+        assert_eq!(view.payload, original.payload);
+        let offset = if actual[0] >> 4 == 4 { 8 } else { 7 };
+        assert_eq!(actual[offset], expected.data()[offset] - 1);
+        assert_eq!(expected.data()[offset], 64);
+    }
+}
+async fn ready(input: &[Packet], fail_flush: bool) -> (io::Result<()>, Writer) {
+    let parts = parts();
+    let (tx, output) = mpsc::channel(input.len().max(1));
+    for packet in input {
+        tx.try_send(packet.clone()).unwrap();
+    }
+    drop(tx);
+    let writer = Writer::default();
+    writer.0.lock().unwrap().fail = fail_flush;
+    let result = pump_h2_output(parts.packet_stream, output, writer.clone()).await;
+    parts.control.stop().await;
+    (result, writer)
+}
+
+#[tokio::test]
+async fn ready_capsules_coalesce_and_flush_the_last_short_prefix_before_channel_end() {
+    let input: Vec<_> = (1..=17).map(|id| packet(id, 32, id % 2 == 0)).collect();
+    let (result, writer) = ready(&input, false).await;
+    assert_eq!(result.unwrap_err().kind(), io::ErrorKind::ConnectionAborted);
+    let state = writer.0.lock().unwrap();
+    let groups = decoded(&state.writes);
+    assert!(
+        groups.len() < input.len(),
+        "ready packets were still flushed one-by-one"
+    );
+    assert!(groups.iter().all(|group| group.len() <= 16));
+    assert!(state.writes.iter().all(|wire| wire.len() <= 16 * 1024));
+    assert_eq!(groups.last().unwrap().len(), 1);
+    assert_eq!(state.flushed, groups.len());
+    let actual: Vec<_> = groups.into_iter().flatten().collect();
+    assert_packets(&actual, &input);
+}
+
+#[tokio::test]
+async fn byte_spill_and_large_capsule_keep_order_and_apply_one_router_hop() {
+    let input = [
+        packet(1, 64, false),
+        packet(2, 9000, true),
+        packet(3, 9000, false),
+        packet(4, 20000, true),
+        packet(5, 64, false),
+    ];
+    let (result, writer) = ready(&input, false).await;
+    assert_eq!(result.unwrap_err().kind(), io::ErrorKind::ConnectionAborted);
+    let state = writer.0.lock().unwrap();
+    let groups = decoded(&state.writes);
+    assert!(groups.iter().any(|group| group.len() > 1));
+    for (wire, group) in state.writes.iter().zip(&groups) {
+        if wire.len() > 16 * 1024 {
+            assert_eq!(group.len(), 1, "large capsule was aggregated or rejected");
+            assert_eq!(
+                parse_udp_packet_view(&group[0]).unwrap().payload.len(),
+                20000
+            );
+        }
+    }
+    assert_eq!(state.flushed, groups.len());
+    let actual: Vec<_> = groups.into_iter().flatten().collect();
+    assert_packets(&actual, &input);
+}
+
+#[tokio::test]
+async fn pending_flush_holds_the_next_batch_and_flush_error_precedes_channel_end() {
+    let parts = parts();
+    let (tx, output) = mpsc::channel(4);
+    let first = packet(1, 32, false);
+    let second = packet(2, 32, true);
+    tx.try_send(first.clone()).unwrap();
+    let writer = Writer::default();
+    writer.0.lock().unwrap().blocked = true;
+    let mut pump = Box::pin(pump_h2_output(parts.packet_stream, output, writer.clone()));
+    assert!(futures_util::poll!(pump.as_mut()).is_pending());
+    assert_eq!(
+        writer.0.lock().unwrap().writes.len(),
+        1,
+        "single packet waited for a batch"
+    );
+    assert_eq!(writer.0.lock().unwrap().flushed, 0);
+    tx.try_send(second.clone()).unwrap();
+    let capacity = tx.capacity();
+    assert!(futures_util::poll!(pump.as_mut()).is_pending());
+    assert_eq!(
+        tx.capacity(),
+        capacity,
+        "prefetched another batch while flush was pending"
+    );
+    assert_eq!(writer.0.lock().unwrap().writes.len(), 1);
+    let wake = {
+        let mut state = writer.0.lock().unwrap();
+        state.blocked = false;
+        state.waker.take()
+    };
+    if let Some(wake) = wake {
+        wake.wake();
+    }
+    assert!(futures_util::poll!(pump.as_mut()).is_pending());
+    drop(tx);
+    assert_eq!(
+        pump.as_mut().await.unwrap_err().kind(),
+        io::ErrorKind::ConnectionAborted
+    );
+    drop(pump);
+    parts.control.stop().await;
+    {
+        let state = writer.0.lock().unwrap();
+        let actual: Vec<_> = decoded(&state.writes).into_iter().flatten().collect();
+        assert_packets(&actual, &[first.clone(), second]);
+        assert_eq!(state.flushed, 2);
+    }
+    let (result, writer) = ready(&[first], true).await;
+    assert_eq!(result.unwrap_err().kind(), io::ErrorKind::BrokenPipe);
+    assert_eq!(writer.0.lock().unwrap().flushed, 0);
+}
+
+#[tokio::test]
+async fn single_ready_poll_does_not_consume_a_later_udp_packet() {
+    use futures_util::FutureExt;
+    let mut parts = parts();
+    let (tx, mut output) = mpsc::channel(1);
+    assert!(
+        next_h2_output(&mut parts.packet_stream, &mut output)
+            .now_or_never()
+            .is_none()
+    );
+    let expected = packet(1, 32, false);
+    tx.try_send(expected.clone()).unwrap();
+    assert_eq!(
+        next_h2_output(&mut parts.packet_stream, &mut output)
+            .await
+            .unwrap(),
+        expected
+    );
+    drop(tx);
+    parts.control.stop().await;
+}
diff --git a/src/outbound/masque/ip.rs b/src/outbound/masque/ip.rs
new file mode 100644
index 0000000..6e9cb1e
--- /dev/null
+++ b/src/outbound/masque/ip.rs
@@ -0,0 +1,976 @@
+use super::{ConnectionFactory, datagram::Registry, packet, resolver};
+use crate::{
+    config::{MasqueNetwork, MasqueOutboundConfig},
+    dispatch::DispatchError,
+    dns::resolution::ResolutionContext,
+    outbound::EstablishContext,
+    resources::observation,
+    security::SecurityContext,
+    session::{Destination, StreamSession},
+    transport::{GrpcPool, h3_connect, masque_codec as codec},
+};
+use bytes::Bytes;
+use std::{
+    io,
+    net::{IpAddr, SocketAddr},
+    sync::{Arc, OnceLock},
+};
+use tokio::{
+    io::{AsyncReadExt, AsyncWriteExt},
+    sync::{Mutex as AsyncMutex, mpsc, watch},
+    task::JoinHandle,
+    time::Instant,
+};
+use tokio_util::sync::CancellationToken;
+use vole_netstack::{
+    ClientConfig, ClientNetStackParts, ClientPrefix, MAX_RECEIVE_PACKET_SIZE, NetStack,
+    NetStackConfig, NetStackControl, Packet, PacketSink, PacketStream, TcpConnector,
+};
+
+const CONTROL_ENTRIES: usize = 8192;
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum Ready {
+    Pending,
+    Open,
+    Failed,
+}
+
+pub(super) struct Engine {
+    pub config: Arc<MasqueOutboundConfig>,
+    pub security: SecurityContext,
+    pub resolution: ResolutionContext,
+    pub remote: OnceLock<Arc<crate::dns::runtime::RuntimeDns>>,
+    pub client: ClientConfig,
+    pub mtu: usize,
+    pub cancel: CancellationToken,
+    pub tcp: TcpConnector,
+    pub tx: mpsc::Sender<Packet>,
+    pub registry: Arc<Registry>,
+    ready: watch::Receiver<Ready>,
+    control: NetStackControl,
+    job: AsyncMutex<Option<JoinHandle<()>>>,
+    stop: AsyncMutex<()>,
+}
+impl Engine {
+    #[allow(clippy::too_many_arguments)]
+    pub fn start(
+        config: Arc<MasqueOutboundConfig>,
+        factory: Arc<ConnectionFactory>,
+        pool: Arc<h3_connect::Pool>,
+        h2_pool: Arc<GrpcPool>,
+        security: SecurityContext,
+        session: StreamSession,
+        context: EstablishContext,
+        cancel: CancellationToken,
+    ) -> Result<Arc<Self>, DispatchError> {
+        let mtu = usize::try_from(config.mtu).map_err(|_| DispatchError::HostUnreachable)?;
+        let client = ClientConfig {
+            prefixes: config.local_prefixes.map(|prefix| {
+                prefix.map(|(address, prefix_len)| ClientPrefix {
+                    address,
+                    prefix_len,
+                })
+            }),
+            receive_packet_limit: MAX_RECEIVE_PACKET_SIZE,
+            path_mtu_discovery: true,
+        }
+        .validate(mtu)
+        .map_err(|_| DispatchError::Other("invalid MASQUE IP stack".into()))?;
+        let ClientNetStackParts {
+            packet_sink,
+            packet_stream,
+            tcp_connector,
+            control,
+            ..
+        } = NetStack::start_client(
+            NetStackConfig {
+                mtu,
+                packet_queue: 32,
+                tcp_send_buffer: if config.network == MasqueNetwork::H2 {
+                    64 * 1024
+                } else {
+                    NetStackConfig::default().tcp_send_buffer
+                },
+                ..Default::default()
+            },
+            client,
+        )
+        .map_err(|_| DispatchError::Other("MASQUE IP stack initialization failed".into()))?;
+        let (tx, output) = mpsc::channel(32);
+        let (ready_sender, ready) = watch::channel(Ready::Pending);
+        let registry = Arc::new(Registry::default());
+        let engine = Arc::new(Self {
+            config: config.clone(),
+            security,
+            resolution: context.resolution(),
+            remote: OnceLock::new(),
+            client,
+            mtu,
+            cancel: cancel.clone(),
+            tcp: tcp_connector,
+            tx,
+            registry: registry.clone(),
+            ready,
+            control: control.clone(),
+            job: AsyncMutex::new(None),
+            stop: AsyncMutex::new(()),
+        });
+        let tcp = engine.tcp.clone();
+        // The worker owns endpoint handles, never its Engine Arc. Publication
+        // precedes authentication, so Stop owns setup as well as packet I/O.
+        *engine.job.try_lock().unwrap() = Some(observation::spawn(async move {
+            let result = tokio::select! {biased;
+                ()=cancel.cancelled()=>Err(closed()),
+                result=run(config,factory,pool,h2_pool,session,context,client,tcp,packet_sink,packet_stream,output,registry,&ready_sender)=>result,
+            };
+            let _ = result;
+            ready_sender.send_replace(Ready::Failed);
+            cancel.cancel();
+            control.stop().await;
+        }));
+        Ok(engine)
+    }
+    pub async fn wait_ready(&self, context: &EstablishContext) -> Result<(), DispatchError> {
+        let mut ready = self.ready.clone();
+        context.run("MASQUE IP handshake",async {
+            loop {
+                match *ready.borrow_and_update() {
+                    Ready::Open=>return Ok(()),
+                    Ready::Failed=>return Err(DispatchError::ConnectionRefused),
+                    Ready::Pending=>{},
+                }
+                tokio::select! {biased;
+                    ()=self.cancel.cancelled()=>return Err(DispatchError::ConnectionRefused),
+                    result=ready.changed()=>if result.is_err(){return Err(DispatchError::ConnectionRefused);},
+                }
+            }
+        }).await
+    }
+    pub(super) fn initializing(&self) -> bool {
+        *self.ready.borrow() == Ready::Pending
+    }
+    #[cfg(test)]
+    pub(super) async fn job_is_joined(&self) -> bool {
+        self.job.lock().await.is_none()
+    }
+    pub fn local(&self, destination: IpAddr) -> Result<IpAddr, DispatchError> {
+        self.client
+            .source_for(destination)
+            .map_err(DispatchError::from)
+    }
+    pub async fn resolve(
+        self: &Arc<Self>,
+        target: &Destination,
+        resolution: &ResolutionContext,
+        deadline: Instant,
+    ) -> Result<SocketAddr, DispatchError> {
+        resolver::resolve_ip(self, target, resolution, deadline).await
+    }
+    pub async fn stop(&self) {
+        let _stop = self.stop.lock().await;
+        self.cancel.cancel();
+        if let Some(remote) = self.remote.get() {
+            remote.begin_shutdown();
+            remote.shutdown().await;
+        }
+        let mut job = self.job.lock().await;
+        if let Some(job) = job.as_mut() {
+            let _ = job.await;
+        }
+        job.take();
+        self.control.stop().await;
+    }
+}
+impl Drop for Engine {
+    fn drop(&mut self) {
+        self.cancel.cancel();
+        self.control.cancel();
+        if let Some(remote) = self.remote.get() {
+            remote.begin_shutdown();
+        }
+        if let Some(job) = self.job.get_mut().take() {
+            job.abort();
+        }
+    }
+}
+
+fn h2_request(uri: &str) -> io::Result<http::Request<()>> {
+    // Url normalizes explicit default ports away. Preserve the raw authority
+    // so http://host:80 stays :80 while an omitted port always uses :443.
+    let raw = uri
+        .split_once("://")
+        .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "invalid MASQUE URI"))?
+        .1
+        .split(['/', '?', '#'])
+        .next()
+        .unwrap_or_default();
+    let raw = raw.rsplit('@').next().unwrap_or_default();
+    let authority: http::uri::Authority = raw
+        .parse()
+        .map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "invalid MASQUE authority"))?;
+    let authority = if authority.port().is_some() {
+        authority.to_string()
+    } else {
+        format!("{}:443", authority.host())
+    };
+    http::Request::builder()
+        .method(http::Method::CONNECT)
+        .uri(
+            http::Uri::builder()
+                .authority(authority)
+                .build()
+                .map_err(|_| {
+                    io::Error::new(io::ErrorKind::InvalidInput, "invalid MASQUE authority")
+                })?,
+        )
+        .header("cf-connect-proto", "cf-connect-ip")
+        .header("pq-enabled", "false")
+        .header("user-agent", "")
+        .body(())
+        .map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "invalid MASQUE request"))
+}
+
+fn request(uri: &str) -> io::Result<http::Request<()>> {
+    let mut url = url::Url::parse(uri)
+        .map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "invalid MASQUE URI"))?;
+    url.set_fragment(None);
+    // URL userinfo is not an authority or an authentication header here.
+    let _ = url.set_username("");
+    let _ = url.set_password(None);
+    let mut request = http::Request::builder()
+        .method(http::Method::CONNECT)
+        .uri(url.as_str())
+        .header("capsule-protocol", "?1")
+        .header("user-agent", "")
+        .body(())
+        .map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "invalid MASQUE request"))?;
+    request
+        .extensions_mut()
+        .insert(crate::transport::quiche_h3::Protocol::CF_CONNECT_IP);
+    Ok(request)
+}
+fn routes() -> io::Result<Bytes> {
+    let mut routes = Vec::with_capacity(44);
+    routes.push(4);
+    routes.extend_from_slice(&[0; 4]);
+    routes.extend_from_slice(&[255; 4]);
+    routes.push(0);
+    routes.push(6);
+    routes.extend_from_slice(&[0; 16]);
+    routes.extend_from_slice(&[255; 16]);
+    routes.push(0);
+    codec::encode_capsule(codec::ROUTE_ADVERTISEMENT, &routes, MAX_RECEIVE_PACKET_SIZE)
+}
+#[allow(clippy::too_many_arguments)]
+async fn run(
+    config: Arc<MasqueOutboundConfig>,
+    factory: Arc<ConnectionFactory>,
+    pool: Arc<h3_connect::Pool>,
+    h2_pool: Arc<GrpcPool>,
+    session: StreamSession,
+    context: EstablishContext,
+    client: ClientConfig,
+    tcp: TcpConnector,
+    sink: PacketSink,
+    packets: PacketStream,
+    output: mpsc::Receiver<Packet>,
+    registry: Arc<Registry>,
+    ready: &watch::Sender<Ready>,
+) -> io::Result<()> {
+    enum Tunnel {
+        H2(crate::dispatch::BoxStream),
+        H3(h3_connect::IpConnect),
+    }
+    let tunnel = tokio::time::timeout_at(context.deadline(), async {
+        let setup = context.clone();
+        if config.network == MasqueNetwork::H2 {
+            let request = h2_request(&config.uri)?;
+            let io = h2_pool
+                .open_connect_admitted(request, context.deadline(), move || async move {
+                    factory.connect_h2(session, &setup).await
+                })
+                .await?;
+            return Ok(Tunnel::H2(io));
+        }
+        let request = request(&config.uri)?;
+        let mut tunnel = pool
+            .open_ip_connect(request, context.deadline(), move || async move {
+                factory.connect(session, &setup).await
+            })
+            .await?;
+        tunnel.capsules.write_all(&routes()?).await?;
+        tunnel.capsules.flush().await?;
+        if client.has_ipv6() {
+            tunnel
+                .datagrams
+                .wait_packet_budget(1280, context.deadline())
+                .await?;
+        }
+        Ok::<_, io::Error>(Tunnel::H3(tunnel))
+    })
+    .await
+    .map_err(|_| io::Error::from(io::ErrorKind::TimedOut))??;
+    if Instant::now() >= context.deadline() {
+        return Err(io::ErrorKind::TimedOut.into());
+    }
+    if let Tunnel::H3(tunnel) = &tunnel {
+        let configured = usize::try_from(config.mtu)
+            .map_err(|_| io::Error::from(io::ErrorKind::InvalidInput))?;
+        // Only peer-negotiated transmit capacity seeds the TCP device MTU.
+        // The independent full-IP receive allocation bound stays unchanged.
+        // Ready cannot expose a connector until its first SYN will use the
+        // actual budget rather than continually requiring software splitting.
+        tcp.set_initial_mtu(
+            configured.min(tunnel.datagrams.packet_budget()),
+            context.deadline(),
+        )
+        .await?;
+    }
+    ready.send_replace(Ready::Open);
+    match tunnel {
+        Tunnel::H2(io) => {
+            let (read, write) = tokio::io::split(io);
+            tokio::try_join!(
+                pump_h2_output(packets, output, write),
+                pump_capsules(read, &sink, &registry, &client, true)
+            )?;
+        }
+        Tunnel::H3(tunnel) => {
+            tokio::try_join!(
+                pump_output(packets, output, &tunnel.datagrams, &sink),
+                pump_input(&tunnel.datagrams, &sink, &registry, &client),
+                pump_capsules(tunnel.capsules, &sink, &registry, &client, false),
+            )?;
+        }
+    }
+    Err(closed())
+}
+async fn next_h2_output(
+    packets: &mut PacketStream,
+    udp: &mut mpsc::Receiver<Packet>,
+) -> Option<Packet> {
+    tokio::select! {
+        packet = packets.recv() => packet,
+        packet = udp.recv() => packet,
+    }
+}
+
+async fn pump_h2_output<W: tokio::io::AsyncWrite + Unpin>(
+    mut packets: PacketStream,
+    mut udp: mpsc::Receiver<Packet>,
+    mut writer: W,
+) -> io::Result<()> {
+    use futures_util::FutureExt;
+
+    const PACKETS: usize = 16;
+    const BYTES: usize = crate::transport::STREAM_CHUNK_BYTES;
+    // One aggregate backing and at most one encoded spill per H2 IP tunnel.
+    // The Plain writer and its supplied-IO flush confirmation stay unchanged.
+    let mut batch = Vec::with_capacity(BYTES);
+    let mut spill: Option<Bytes> = None;
+    loop {
+        batch.clear();
+        let mut taken = 0;
+        let mut terminal = None;
+        if let Some(capsule) = spill.take() {
+            if capsule.len() > BYTES {
+                // Legal large capsules retain the original independent path.
+                writer.write_all(&capsule).await?;
+                writer.flush().await?;
+                continue;
+            }
+            batch.extend_from_slice(&capsule);
+            taken = 1;
+        }
+        while taken < PACKETS {
+            let next = if taken == 0 {
+                Some(next_h2_output(&mut packets, &mut udp).await)
+            } else {
+                // A single poll can be Pending due to readiness or coop budget.
+                // Never wait for another packet just to fill this batch.
+                next_h2_output(&mut packets, &mut udp).now_or_never()
+            };
+            let Some(next) = next else { break };
+            let Some(packet) = next else {
+                terminal = Some(closed());
+                break;
+            };
+            taken += 1; // Invalid packets also consume this batch's bounded scan.
+            let Some(bytes) = packet::outgoing(packet.into_bytes()) else {
+                continue;
+            };
+            match codec::try_append_capsule(
+                codec::DATAGRAM,
+                &bytes,
+                MAX_RECEIVE_PACKET_SIZE,
+                &mut batch,
+                BYTES,
+            ) {
+                Ok(true) => {}
+                Ok(false) => {
+                    // Outgoing/TTL adjustment has already happened exactly once.
+                    spill = Some(codec::encode_capsule(
+                        codec::DATAGRAM,
+                        &bytes,
+                        MAX_RECEIVE_PACKET_SIZE,
+                    )?);
+                    break;
+                }
+                Err(error) => {
+                    terminal = Some(error);
+                    break;
+                }
+            }
+        }
+        if !batch.is_empty() {
+            writer.write_all(&batch).await?;
+            writer.flush().await?;
+        }
+        if let Some(error) = terminal {
+            return Err(error);
+        }
+    }
+}
+// Static dispatch keeps the actual IP sender unchanged and permits an
+// in-memory test of a path-budget change without fake host sockets.
+trait IpPacketSender: Sync {
+    fn packet_budget(&self) -> usize;
+    fn send_packet<'a>(
+        &'a self,
+        packet: &'a [u8],
+    ) -> impl std::future::Future<Output = Result<(), h3_connect::IpDatagramSendError>> + Send + 'a;
+}
+impl IpPacketSender for h3_connect::IpDatagrams {
+    fn packet_budget(&self) -> usize {
+        self.packet_budget()
+    }
+    fn send_packet<'a>(
+        &'a self,
+        packet: &'a [u8],
+    ) -> impl std::future::Future<Output = Result<(), h3_connect::IpDatagramSendError>> + Send + 'a
+    {
+        self.send(packet)
+    }
+}
+async fn pump_output<D: IpPacketSender>(
+    mut packets: PacketStream,
+    mut udp: mpsc::Receiver<Packet>,
+    datagrams: &D,
+    sink: &PacketSink,
+) -> io::Result<()> {
+    loop {
+        let packet = tokio::select! {
+            packet=packets.recv()=>packet.ok_or_else(closed)?,
+            packet=udp.recv()=>packet.ok_or_else(closed)?,
+        };
+        let bytes = packet.into_bytes();
+        let maximum = datagrams.packet_budget();
+        if bytes.len() > maximum {
+            if let Some(feedback) = vole_netstack::build_packet_too_big(&bytes, maximum) {
+                sink.send(feedback).await.map_err(|_| closed())?;
+            }
+            continue;
+        }
+        if let Some(bytes) = packet::outgoing(bytes) {
+            match datagrams.send_packet(&bytes).await {
+                Ok(()) => {}
+                Err(h3_connect::IpDatagramSendError::TooLarge { packet_budget }) => {
+                    // A post-ready path change affects this packet. Do not
+                    // turn IPv6 rediscovery timeout into failure of every
+                    // stream (including independent IPv4 siblings).
+                    if let Some(feedback) =
+                        vole_netstack::build_packet_too_big(&bytes, packet_budget)
+                    {
+                        sink.send(feedback).await.map_err(|_| closed())?;
+                    }
+                }
+                Err(h3_connect::IpDatagramSendError::Closed) => return Err(closed()),
+            }
+        }
+    }
+}
+async fn deliver(
+    bytes: Bytes,
+    sink: &PacketSink,
+    registry: &Registry,
+    client: &ClientConfig,
+) -> io::Result<()> {
+    if !packet::incoming(&bytes, client) {
+        return Ok(());
+    }
+    if let Some(udp) = vole_netstack::parse_udp_packet_view(&bytes) {
+        registry.deliver(udp.source, udp.destination, udp.payload);
+    } else {
+        sink.send(Packet::new(bytes)).await.map_err(|_| closed())?;
+    }
+    Ok(())
+}
+async fn pump_input(
+    datagrams: &h3_connect::IpDatagrams,
+    sink: &PacketSink,
+    registry: &Registry,
+    client: &ClientConfig,
+) -> io::Result<()> {
+    loop {
+        deliver(datagrams.receive().await?, sink, registry, client).await?;
+    }
+}
+async fn pump_capsules<R: tokio::io::AsyncRead + Unpin>(
+    mut stream: R,
+    sink: &PacketSink,
+    registry: &Registry,
+    client: &ClientConfig,
+    h2: bool,
+) -> io::Result<()> {
+    let mut decoder = codec::CapsuleDecoder::new(MAX_RECEIVE_PACKET_SIZE);
+    let mut chunk = [0u8; crate::transport::STREAM_CHUNK_BYTES];
+    loop {
+        let len = stream.read(&mut chunk).await?;
+        if len == 0 {
+            decoder.finish()?;
+            return Err(closed());
+        }
+        let mut input = &chunk[..len];
+        while !input.is_empty() {
+            let (consumed, capsule) = decoder.feed(input)?;
+            if consumed == 0 {
+                return Err(closed());
+            }
+            input = &input[consumed..];
+            let Some(capsule) = capsule else { continue };
+            match capsule.kind {
+                codec::DATAGRAM if h2 => deliver(capsule.value, sink, registry, client).await?,
+                codec::ADDRESS_ASSIGN | codec::ADDRESS_REQUEST if !h2 => {
+                    codec::parse_addresses(capsule.kind, &capsule.value, CONTROL_ENTRIES)?;
+                }
+                codec::ROUTE_ADVERTISEMENT if !h2 => {
+                    codec::parse_routes(&capsule.value, CONTROL_ENTRIES)?;
+                }
+                _ => {}
+            }
+        }
+    }
+}
+fn closed() -> io::Error {
+    io::Error::new(io::ErrorKind::ConnectionAborted, "MASQUE IP tunnel stopped")
+}
+
+#[cfg(test)]
+#[path = "h2_output_batch_memory_tests.rs"]
+mod h2_output_batch_memory_tests;
+
+#[cfg(test)]
+pub(super) mod tests {
+    use super::*;
+    pub(crate) fn test_config() -> Arc<MasqueOutboundConfig> {
+        Arc::new(MasqueOutboundConfig {
+            address: "example.invalid".into(),
+            port: 443,
+            private_key: String::new(),
+            public_key: String::new(),
+            server_name: "example.invalid".into(),
+            network: MasqueNetwork::H2,
+            ip: "192.0.2.2".into(),
+            ipv6: String::new(),
+            uri: "https://example.invalid".into(),
+            mtu: 1280,
+            udp: true,
+            handshake_timeout: 0,
+            skip_cert_verify: false,
+            name_cert_verify: String::new(),
+            congestion_controller: String::new(),
+            ip_stack: crate::config::MasqueIpStackOptions {
+                mode: "auto".into(),
+                congestion_controller: String::new(),
+            },
+            remote_dns_resolve: false,
+            dns: Vec::new(),
+            local_prefixes: [Some((IpAddr::from([192, 0, 2, 2]), 32)), None],
+        })
+    }
+    #[test]
+    fn masque_ip_request_and_full_routes_use_cf_wire_contract() {
+        let request = request("https://example.invalid:443/tunnel?x=1#ignored").unwrap();
+        assert_eq!(request.method(), http::Method::CONNECT);
+        assert_eq!(
+            request.uri().path_and_query().unwrap().as_str(),
+            "/tunnel?x=1"
+        );
+        assert_eq!(request.headers()["capsule-protocol"], "?1");
+        assert_eq!(
+            request
+                .extensions()
+                .get::<crate::transport::quiche_h3::Protocol>(),
+            Some(&crate::transport::quiche_h3::Protocol::CF_CONNECT_IP)
+        );
+        let frame = routes().unwrap();
+        let mut decoder = codec::CapsuleDecoder::new(256);
+        let (_, capsule) = decoder.feed(&frame).unwrap();
+        let routes = codec::parse_routes(&capsule.unwrap().value, 2).unwrap();
+        assert_eq!(routes.len(), 2);
+        assert!(routes.iter().all(|route| route.protocol == 0));
+        assert_eq!(routes[0].start, IpAddr::from([0, 0, 0, 0]));
+        assert_eq!(routes[0].end, IpAddr::from([255, 255, 255, 255]));
+        assert!(routes[1].start.is_ipv6());
+    }
+
+    #[tokio::test]
+    async fn masque_ip_cancelled_stop_keeps_the_join_barrier() {
+        let client = ClientConfig {
+            prefixes: [
+                Some(ClientPrefix {
+                    address: IpAddr::from([192, 0, 2, 2]),
+                    prefix_len: 32,
+                }),
+                None,
+            ],
+            receive_packet_limit: MAX_RECEIVE_PACKET_SIZE,
+            path_mtu_discovery: true,
+        };
+        let parts = NetStack::start_client(NetStackConfig::default(), client).unwrap();
+        let (tx, _output) = mpsc::channel(1);
+        let (_, ready) = watch::channel(Ready::Pending);
+        let (release, work) = tokio::sync::oneshot::channel();
+        let job = tokio::spawn(async move {
+            let _ = work.await;
+        });
+        let engine = Engine {
+            config: test_config(),
+            security: SecurityContext::default(),
+            resolution: ResolutionContext::default(),
+            remote: OnceLock::new(),
+            client,
+            mtu: 1500,
+            cancel: CancellationToken::new(),
+            tcp: parts.tcp_connector,
+            tx,
+            registry: Arc::new(Registry::default()),
+            ready,
+            control: parts.control,
+            job: AsyncMutex::new(Some(job)),
+            stop: AsyncMutex::new(()),
+        };
+        let mut first = Box::pin(engine.stop());
+        assert!(futures_util::poll!(first.as_mut()).is_pending());
+        assert!(engine.cancel.is_cancelled());
+        drop(first);
+        assert!(engine.job.try_lock().unwrap().is_some());
+        release.send(()).unwrap();
+        engine.stop().await;
+        assert!(engine.job.try_lock().unwrap().is_none());
+    }
+
+    #[tokio::test]
+    async fn masque_ip_memory_shared_udp_leases_cancel_and_close_independently() {
+        use crate::{
+            dispatch::{DatagramBudget, DatagramTransport},
+            resources::observation::{ResourceKind, ResourceProbe},
+            session::Datagram,
+        };
+        use vole_netstack::{UdpDatagram, encode_udp_packet_into, parse_udp_packet_view};
+
+        fn reply(engine: &Engine, packet: Packet, remote: SocketAddr, payload: &[u8]) -> u16 {
+            let sent = parse_udp_packet_view(packet.data()).unwrap();
+            assert_eq!(sent.destination, remote);
+            assert_eq!(sent.payload, payload);
+            assert_eq!(sent.source.ip(), engine.local(remote.ip()).unwrap());
+            let port = sent.source.port();
+            let mut raw = Vec::new();
+            encode_udp_packet_into(
+                &UdpDatagram::new(remote, sent.source, Bytes::copy_from_slice(payload)),
+                engine.mtu,
+                &mut raw,
+            )
+            .unwrap();
+            assert!(packet::incoming(&raw, &engine.client));
+            let response = parse_udp_packet_view(&raw).unwrap();
+            engine
+                .registry
+                .deliver(response.source, response.destination, response.payload);
+            port
+        }
+
+        let probe = ResourceProbe::default();
+        probe
+            .scope(async {
+                let client = ClientConfig {
+                    prefixes: [
+                        Some(ClientPrefix {
+                            address: "192.0.2.2".parse().unwrap(),
+                            prefix_len: 32,
+                        }),
+                        Some(ClientPrefix {
+                            address: "fd00::2".parse().unwrap(),
+                            prefix_len: 128,
+                        }),
+                    ],
+                    receive_packet_limit: MAX_RECEIVE_PACKET_SIZE,
+                    path_mtu_discovery: true,
+                };
+                let parts = NetStack::start_client(NetStackConfig::default(), client).unwrap();
+                // One packet slot makes cancellation at the actual raw-IP handoff observable.
+                let (tx, mut output) = mpsc::channel(1);
+                let (_, ready) = watch::channel(Ready::Open);
+                let engine = Arc::new(Engine {
+                    config: test_config(),
+                    security: SecurityContext::default(),
+                    resolution: ResolutionContext::default(),
+                    remote: OnceLock::new(),
+                    client,
+                    mtu: 1500,
+                    cancel: CancellationToken::new(),
+                    tcp: parts.tcp_connector,
+                    tx,
+                    registry: Arc::new(Registry::default()),
+                    ready,
+                    control: parts.control,
+                    job: AsyncMutex::new(None),
+                    stop: AsyncMutex::new(()),
+                });
+                let open = || {
+                    super::super::datagram::Datagrams::new(
+                        engine.clone(),
+                        DatagramBudget::new(1200, 1200),
+                        ResolutionContext::default(),
+                    )
+                    .unwrap()
+                };
+                let mut shared = open();
+                let mut sibling = open();
+                assert!(shared.supports_shared_destinations());
+                assert_eq!(probe.snapshot().current(ResourceKind::Association), 2);
+                let mut waiting = Box::pin(shared.receive());
+                assert!(futures_util::poll!(waiting.as_mut()).is_pending());
+                drop(waiting);
+                let targets: [SocketAddr; 3] = [
+                    "198.51.100.1:53".parse().unwrap(),
+                    "198.51.100.2:443".parse().unwrap(),
+                    "[2001:db8::1]:443".parse().unwrap(),
+                ];
+                let datagram = |remote, payload| Datagram {
+                    remote: Destination::Ip(remote),
+                    payload: Bytes::from_static(payload),
+                    sniffed_domain: None,
+                };
+                shared.send(datagram(targets[0], b"first")).await.unwrap();
+                let mut cancelled = Box::pin(shared.send(datagram(targets[1], b"cancelled")));
+                assert!(futures_util::poll!(cancelled.as_mut()).is_pending());
+                drop(cancelled);
+                let port = reply(&engine, output.recv().await.unwrap(), targets[0], b"first");
+                assert!(
+                    output.try_recv().is_err(),
+                    "cancelled handoff submitted an extra packet"
+                );
+                assert_eq!(shared.receive().await.unwrap().payload.as_ref(), b"first");
+                for target in targets {
+                    shared.send(datagram(target, b"shared")).await.unwrap();
+                    assert_eq!(
+                        reply(&engine, output.recv().await.unwrap(), target, b"shared"),
+                        port
+                    );
+                    let response = shared.receive().await.unwrap();
+                    assert_eq!(response.remote, Destination::Ip(target));
+                    assert_eq!(response.payload.as_ref(), b"shared");
+                }
+                sibling
+                    .send(datagram(targets[0], b"sibling"))
+                    .await
+                    .unwrap();
+                let other_port = reply(
+                    &engine,
+                    output.recv().await.unwrap(),
+                    targets[0],
+                    b"sibling",
+                );
+                assert_ne!(port, other_port);
+                assert_eq!(
+                    sibling.receive().await.unwrap().payload.as_ref(),
+                    b"sibling"
+                );
+                shared.close().await.unwrap();
+                assert_eq!(probe.snapshot().current(ResourceKind::Association), 1);
+                assert!(shared.send(datagram(targets[0], b"closed")).await.is_err());
+                assert!(shared.receive().await.is_err());
+                engine.registry.deliver(
+                    targets[0],
+                    SocketAddr::new(client.prefixes[0].unwrap().address, port),
+                    b"late",
+                );
+                let mut rebuilt = open();
+                let mut waiting = Box::pin(rebuilt.receive());
+                assert!(futures_util::poll!(waiting.as_mut()).is_pending());
+                drop(waiting);
+                rebuilt
+                    .send(datagram(targets[0], b"rebuilt"))
+                    .await
+                    .unwrap();
+                let rebuilt_port = reply(
+                    &engine,
+                    output.recv().await.unwrap(),
+                    targets[0],
+                    b"rebuilt",
+                );
+                assert_ne!(port, rebuilt_port);
+                assert_eq!(
+                    rebuilt.receive().await.unwrap().payload.as_ref(),
+                    b"rebuilt"
+                );
+                sibling
+                    .send(datagram(targets[0], b"still-live"))
+                    .await
+                    .unwrap();
+                assert_eq!(
+                    reply(
+                        &engine,
+                        output.recv().await.unwrap(),
+                        targets[0],
+                        b"still-live"
+                    ),
+                    other_port
+                );
+                assert_eq!(
+                    sibling.receive().await.unwrap().payload.as_ref(),
+                    b"still-live"
+                );
+                engine.stop().await;
+                assert!(sibling.receive().await.is_err());
+                assert!(
+                    rebuilt
+                        .send(datagram(targets[0], b"stopped"))
+                        .await
+                        .is_err()
+                );
+                sibling.close().await.unwrap();
+                rebuilt.close().await.unwrap();
+                drop((shared, sibling, rebuilt, output, engine));
+                assert!(probe.snapshot().is_idle());
+            })
+            .await;
+    }
+
+    #[test]
+    fn masque_h2_authority_and_headers_preserve_mode_contract() {
+        for (uri, authority) in [
+            ("https://example.invalid/path?x=1", "example.invalid:443"),
+            ("http://example.invalid:80/path", "example.invalid:80"),
+            ("http://example.invalid/path", "example.invalid:443"),
+            ("https://[2001:db8::1]/path", "[2001:db8::1]:443"),
+        ] {
+            let request = h2_request(uri).unwrap();
+            assert_eq!(request.uri().authority().unwrap().as_str(), authority);
+            assert!(request.uri().scheme().is_none());
+            assert!(request.uri().path_and_query().is_none());
+            assert_eq!(request.headers()["cf-connect-proto"], "cf-connect-ip");
+            assert_eq!(request.headers()["pq-enabled"], "false");
+            assert!(request.headers().get("capsule-protocol").is_none());
+            assert!(
+                request
+                    .extensions()
+                    .get::<crate::transport::quiche_h3::Protocol>()
+                    .is_none()
+            );
+        }
+    }
+}
+
+#[cfg(test)]
+mod runtime_budget_tests {
+    use super::*;
+    use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+    struct Sender {
+        budget: AtomicUsize,
+        shrink: AtomicBool,
+        sent: AtomicUsize,
+        changed: tokio::sync::Notify,
+    }
+    impl IpPacketSender for Sender {
+        fn packet_budget(&self) -> usize {
+            self.budget.load(Ordering::Acquire)
+        }
+        async fn send_packet<'a>(
+            &'a self,
+            packet: &'a [u8],
+        ) -> Result<(), h3_connect::IpDatagramSendError> {
+            if self.shrink.swap(false, Ordering::AcqRel) {
+                self.budget.store(1200, Ordering::Release);
+                return Err(h3_connect::IpDatagramSendError::TooLarge {
+                    packet_budget: 1200,
+                });
+            }
+            assert_eq!(packet[0] >> 4, 4);
+            self.sent.fetch_add(1, Ordering::AcqRel);
+            self.changed.notify_one();
+            Ok(())
+        }
+    }
+    #[tokio::test]
+    async fn masque_runtime_ipv6_budget_shrink_does_not_stall_or_close_ipv4_sibling() {
+        for shrink_on_send in [false, true] {
+            let client = ClientConfig {
+                prefixes: [
+                    Some(ClientPrefix {
+                        address: "192.0.2.2".parse().unwrap(),
+                        prefix_len: 32,
+                    }),
+                    Some(ClientPrefix {
+                        address: "fd00::2".parse().unwrap(),
+                        prefix_len: 128,
+                    }),
+                ],
+                receive_packet_limit: MAX_RECEIVE_PACKET_SIZE,
+                path_mtu_discovery: true,
+            };
+            let parts = NetStack::start_client(
+                NetStackConfig {
+                    mtu: 1500,
+                    ..Default::default()
+                },
+                client,
+            )
+            .unwrap();
+            let (input, output) = mpsc::channel(2);
+            let sender = Arc::new(Sender {
+                budget: AtomicUsize::new(if shrink_on_send { 1400 } else { 1200 }),
+                shrink: AtomicBool::new(shrink_on_send),
+                sent: AtomicUsize::new(0),
+                changed: tokio::sync::Notify::new(),
+            });
+            let active = sender.clone();
+            let cancel = CancellationToken::new();
+            let stop = cancel.clone();
+            let sink = parts.packet_sink;
+            let driver = tokio::spawn(async move {
+                tokio::select! {()=stop.cancelled()=>{},_=pump_output(parts.packet_stream,output,&*active,&sink)=>{}}
+            });
+            for (source, destination, length) in [
+                ("[fd00::2]:20000", "[2001:db8::1]:30000", 1300),
+                ("192.0.2.2:20001", "198.51.100.1:30001", 10),
+            ] {
+                let mut bytes = Vec::new();
+                vole_netstack::encode_udp_packet_into(
+                    &vole_netstack::UdpDatagram::new(
+                        source.parse().unwrap(),
+                        destination.parse().unwrap(),
+                        Bytes::from(vec![0u8; length]),
+                    ),
+                    1500,
+                    &mut bytes,
+                )
+                .unwrap();
+                input.send(Packet::new(bytes)).await.unwrap();
+            }
+            tokio::time::timeout(std::time::Duration::from_secs(1), async {
+                while sender.sent.load(Ordering::Acquire) == 0 {
+                    sender.changed.notified().await;
+                }
+            })
+            .await
+            .expect("IPv6 shrink blocked an unrelated IPv4 packet");
+            assert!(!driver.is_finished());
+            assert_eq!(sender.sent.load(Ordering::Acquire), 1);
+            cancel.cancel();
+            driver.await.unwrap();
+            parts.control.stop().await;
+        }
+    }
+}
diff --git a/src/outbound/masque/mod.rs b/src/outbound/masque/mod.rs
new file mode 100644
index 0000000..b9cde3e
--- /dev/null
+++ b/src/outbound/masque/mod.rs
@@ -0,0 +1,529 @@
+//! Cloudflare MASQUE CONNECT-IP and L4 CONNECT over controlled transports.
+mod datagram;
+mod ip;
+mod packet;
+mod resolver;
+use crate::{
+    config::{MasqueNetwork, MasqueOutboundConfig},
+    dispatch::{DatagramBudget, DatagramTransport, DispatchError},
+    outbound::{
+        ConnectedStream, DatagramRequest, EstablishContext, OutboundConnector, UpstreamPath,
+        server_destination,
+    },
+    security::{SecurityContext, masque::MasqueTls},
+    session::{DatagramSession, Destination, StreamSession},
+    transport::{GrpcPool, h3_connect, quiche_h3},
+};
+use async_trait::async_trait;
+use std::{
+    io,
+    sync::{Arc, Mutex, OnceLock},
+};
+use tokio::sync::Mutex as AsyncMutex;
+use tokio_util::{sync::CancellationToken, task::TaskTracker};
+
+pub(super) struct ConnectionFactory {
+    server: Destination,
+    server_name: String,
+    upstream: UpstreamPath,
+    tls: MasqueTls,
+    udp_receive_buffer_size: Option<usize>,
+}
+impl ConnectionFactory {
+    pub(super) async fn connect_h2(
+        &self,
+        session: StreamSession,
+        context: &EstablishContext,
+    ) -> io::Result<crate::dispatch::BoxStream> {
+        let raw = self
+            .upstream
+            .connect_server(session, &self.server, context)
+            .await
+            .map_err(io::Error::other)?;
+        let name = rustls::pki_types::ServerName::try_from(self.server_name.clone())
+            .map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "invalid MASQUE SNI"))?;
+        let io = context
+            .run_io(
+                "MASQUE H2 TLS",
+                tokio_rustls::TlsConnector::from(self.tls.config(false)?).connect(name, raw.io),
+            )
+            .await
+            .map_err(io::Error::other)?;
+        if io.get_ref().1.alpn_protocol() != Some(b"h2") {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidData,
+                "MASQUE requires H2 ALPN",
+            ));
+        }
+        Ok(Box::new(io))
+    }
+    pub(super) async fn connect(
+        &self,
+        session: StreamSession,
+        context: &EstablishContext,
+    ) -> io::Result<h3_connect::QuicTransport> {
+        let tls = self.tls.quiche_config(self.server_name.clone())?;
+        let server = self
+            .upstream
+            .datagram_server(&self.server, context)
+            .await
+            .map_err(io::Error::other)?;
+        let peer = context
+            .resolve_ip(&server)
+            .await
+            .map_err(io::Error::other)?;
+        let budget = DatagramBudget::new(1400, 1400);
+        let request = DatagramRequest::new(
+            DatagramSession::new(session.inbound, session.source).with_metadata(session.metadata),
+        )
+        .with_budget(budget);
+        let request = if let Some(size) = self.udp_receive_buffer_size {
+            request.with_udp_receive_buffer_size(size)
+        } else {
+            request
+        };
+        let transport = self
+            .upstream
+            .open_datagram(request, context)
+            .await
+            .map_err(io::Error::other)?;
+        Ok(h3_connect::QuicTransport {
+            transport,
+            peer,
+            budget,
+            tls,
+            server_name: self.server_name.clone(),
+        })
+    }
+}
+
+pub struct MasqueOutbound {
+    connection: Arc<ConnectionFactory>,
+    pool: Arc<h3_connect::Pool>,
+    h2_pool: Arc<GrpcPool>,
+    config: Arc<MasqueOutboundConfig>,
+    security: SecurityContext,
+    remote: OnceLock<Arc<crate::dns::runtime::RuntimeDns>>,
+    current: AsyncMutex<Option<Arc<ip::Engine>>>,
+    cancel: CancellationToken,
+    admission: Mutex<()>,
+    retired: TaskTracker,
+}
+impl MasqueOutbound {
+    pub(crate) fn with_shared_security(
+        config: &MasqueOutboundConfig,
+        upstream: UpstreamPath,
+        security: &SecurityContext,
+    ) -> io::Result<Self> {
+        let tls = MasqueTls::new(
+            &config.private_key,
+            &config.public_key,
+            config.skip_cert_verify,
+            security,
+        )?;
+        let congestion = (config.network != MasqueNetwork::H2)
+            .then(|| quiche_h3::congestion_controller(&config.congestion_controller))
+            .flatten();
+        let pool = if config.network == MasqueNetwork::H3L4Proxy {
+            h3_connect::Pool::masque_l4(congestion)
+        } else {
+            h3_connect::Pool::masque_ip(congestion)
+        };
+        Ok(Self {
+            connection: Arc::new(ConnectionFactory {
+                server: server_destination(&config.address, config.port)?,
+                server_name: config.server_name.clone(),
+                upstream,
+                tls,
+                udp_receive_buffer_size: (config.network == MasqueNetwork::Quic)
+                    .then_some(512 * 1024),
+            }),
+            pool: Arc::new(pool),
+            h2_pool: Arc::new(GrpcPool::masque_ip()),
+            config: Arc::new(config.clone()),
+            security: security.clone(),
+            remote: OnceLock::new(),
+            current: AsyncMutex::new(None),
+            cancel: CancellationToken::new(),
+            admission: Mutex::new(()),
+            retired: TaskTracker::new(),
+        })
+    }
+    async fn engine(
+        &self,
+        session: StreamSession,
+        context: &EstablishContext,
+    ) -> Result<Arc<ip::Engine>, DispatchError> {
+        let (engine, created) = tokio::select! { biased;
+            ()=self.cancel.cancelled()=>return Err(DispatchError::NotAllowed),
+            result=context.run("MASQUE IP initialize",async {
+                let mut current=self.current.lock().await;
+                let _admission=self.admission.lock().unwrap();
+                if self.cancel.is_cancelled() { return Err(DispatchError::NotAllowed); }
+                if let Some(engine)=current.as_ref().filter(|engine|!engine.cancel.is_cancelled()) {return Ok((engine.clone(),false));}
+                if let Some(old)=current.take() {self.retired.spawn(crate::resources::observation::task(async move{old.stop().await;}));}
+                let setup = context.clone().with_metadata(&session.metadata);
+                let setup = if self.config.handshake_timeout > 0 {
+                    setup.masque_handshake(self.config.handshake_timeout)
+                } else { setup };
+                let engine=ip::Engine::start(self.config.clone(),self.connection.clone(),self.pool.clone(),self.h2_pool.clone(),self.security.clone(),session,setup,self.cancel.child_token())?;
+                *current=Some(engine.clone());
+                Ok((engine,true))
+            })=>result?,
+        };
+        let mut creator = CreationGuard {
+            engine: &engine,
+            armed: created && self.config.handshake_timeout == 0,
+        };
+        engine.wait_ready(context).await?;
+        creator.armed = false;
+        drop(creator);
+        Ok(engine)
+    }
+}
+
+struct CreationGuard<'a> {
+    engine: &'a ip::Engine,
+    armed: bool,
+}
+impl Drop for CreationGuard<'_> {
+    fn drop(&mut self) {
+        if self.armed && self.engine.initializing() {
+            self.engine.cancel.cancel();
+        }
+    }
+}
+
+pub(super) async fn connect_l4_literal(
+    factory: Arc<ConnectionFactory>,
+    pool: Arc<h3_connect::Pool>,
+    session: StreamSession,
+    context: &EstablishContext,
+) -> Result<crate::dispatch::BoxStream, DispatchError> {
+    if !matches!(session.destination, Destination::Ip(_)) {
+        return Err(DispatchError::HostUnreachable);
+    }
+    let request = connect_request(&session.destination)?;
+    let setup = context.clone();
+    context
+        .run_io(
+            "MASQUE L4 CONNECT",
+            pool.open_connect(request, context.deadline(), None, move || async move {
+                factory.connect(session, &setup).await
+            }),
+        )
+        .await
+}
+
+fn connect_request(target: &Destination) -> io::Result<http::Request<()>> {
+    let authority = match target {
+        Destination::Ip(address) => address.to_string(),
+        Destination::Domain { host, port } => format!("{host}:{port}"),
+    };
+    let uri = http::Uri::builder()
+        .authority(authority)
+        .build()
+        .map_err(|_| {
+            io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "invalid MASQUE CONNECT authority",
+            )
+        })?;
+    http::Request::builder()
+        .method(http::Method::CONNECT)
+        .uri(uri)
+        .body(())
+        .map_err(|_| {
+            io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "invalid MASQUE CONNECT request",
+            )
+        })
+}
+
+#[async_trait]
+impl OutboundConnector for MasqueOutbound {
+    async fn connect_stream(
+        &self,
+        session: StreamSession,
+        context: &EstablishContext,
+    ) -> Result<ConnectedStream, DispatchError> {
+        if self.config.network != MasqueNetwork::H3L4Proxy {
+            let engine = self.engine(session.clone(), context).await?;
+            let remote = engine
+                .resolve(
+                    &session.destination,
+                    &context.resolution(),
+                    context.deadline(),
+                )
+                .await?;
+            let io = tokio::select! {biased;
+                ()=engine.cancel.cancelled()=>return Err(DispatchError::ConnectionRefused),
+                result=context.run_io("MASQUE IP TCP",engine.tcp.connect(remote,context.deadline()))=>result?,
+            };
+            return Ok(ConnectedStream {
+                io: Box::new(crate::outbound::owned_stream::OwnedStream::new(
+                    Box::new(io),
+                    engine.cancel.child_token(),
+                )),
+                effective_peer: Destination::Ip(remote),
+            });
+        }
+        let resolution = context.resolution();
+        let remote = resolver::resolve_l4(
+            resolver::L4DnsContext {
+                remote: &self.remote,
+                nameservers: &self.config.dns,
+                factory: &self.connection,
+                pool: &self.pool,
+                cancel: &self.cancel,
+                security: &self.security,
+                bootstrap: &resolution,
+            },
+            &session.destination,
+            context.deadline(),
+        )
+        .await?;
+        let target = Destination::Ip(remote);
+        let mut session = session;
+        session.destination = target.clone();
+        let io = tokio::select! { biased;
+            ()=self.cancel.cancelled()=>return Err(DispatchError::NotAllowed),
+            io=connect_l4_literal(self.connection.clone(),self.pool.clone(),session,context)=>io?,
+        };
+        Ok(ConnectedStream {
+            io,
+            effective_peer: target,
+        })
+    }
+    async fn open_datagram(
+        &self,
+        request: DatagramRequest,
+        context: &EstablishContext,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        if self.config.network == MasqueNetwork::H3L4Proxy || !self.config.udp {
+            return Err(DispatchError::NotAllowed);
+        }
+        let session = StreamSession {
+            metadata: request.session.metadata.clone(),
+            inbound: request.session.inbound,
+            source: request.session.source,
+            destination: self.connection.server.clone(),
+            sniffed_domain: None,
+        };
+        let engine = self.engine(session, context).await?;
+        Ok(Box::new(datagram::Datagrams::new(
+            engine,
+            request.budget(),
+            context.resolution(),
+        )?))
+    }
+    fn begin_shutdown(&self) {
+        let _admission = self.admission.lock().unwrap();
+        self.cancel.cancel();
+        self.retired.close();
+        self.pool.begin_shutdown();
+        self.h2_pool.begin_shutdown();
+        if let Some(remote) = self.remote.get() {
+            remote.begin_shutdown();
+        }
+    }
+    async fn shutdown(&self) {
+        self.begin_shutdown();
+        if let Some(remote) = self.remote.get() {
+            remote.shutdown().await;
+        }
+        self.retired.wait().await;
+        let mut current = self.current.lock().await;
+        if let Some(engine) = current.as_ref() {
+            engine.stop().await;
+        }
+        current.take();
+        self.pool.shutdown().await;
+        self.h2_pool.shutdown().await;
+    }
+}
+impl Drop for MasqueOutbound {
+    fn drop(&mut self) {
+        self.cancel.cancel();
+        self.pool.begin_shutdown();
+        self.h2_pool.begin_shutdown();
+        if let Some(remote) = self.remote.get() {
+            remote.begin_shutdown();
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+    use tokio::time::{Duration, Instant};
+
+    #[derive(Default)]
+    struct PendingUpstream {
+        entered: tokio::sync::Notify,
+        calls: AtomicUsize,
+        deadline: Mutex<Option<Instant>>,
+        datagram_requests: Mutex<Vec<(DatagramBudget, Option<usize>)>>,
+        reject_stream: bool,
+    }
+    #[async_trait]
+    impl OutboundConnector for PendingUpstream {
+        async fn connect_stream(
+            &self,
+            _session: StreamSession,
+            context: &EstablishContext,
+        ) -> Result<ConnectedStream, DispatchError> {
+            self.calls.fetch_add(1, Ordering::Relaxed);
+            *self.deadline.lock().unwrap() = Some(context.deadline());
+            self.entered.notify_one();
+            if self.reject_stream {
+                return Err(DispatchError::NotAllowed);
+            }
+            std::future::pending().await
+        }
+        async fn open_datagram(
+            &self,
+            request: DatagramRequest,
+            _context: &EstablishContext,
+        ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+            self.calls.fetch_add(1, Ordering::Relaxed);
+            self.datagram_requests.lock().unwrap().push((
+                request.budget(),
+                request.udp_socket_options().receive_buffer,
+            ));
+            Err(DispatchError::NotAllowed)
+        }
+    }
+    fn outbound(seconds: i64, upstream: Arc<PendingUpstream>) -> MasqueOutbound {
+        outbound_network(seconds, upstream, MasqueNetwork::H2)
+    }
+    fn outbound_network(
+        seconds: i64,
+        upstream: Arc<PendingUpstream>,
+        network: MasqueNetwork,
+    ) -> MasqueOutbound {
+        use base64::Engine;
+        let group =
+            boring::ec::EcGroup::from_curve_name(boring::nid::Nid::X9_62_PRIME256V1).unwrap();
+        let key = boring::ec::EcKey::generate(&group).unwrap();
+        let public = boring::pkey::PKey::from_ec_key(key.clone()).unwrap();
+        let mut config = (*ip::tests::test_config()).clone();
+        config.private_key =
+            base64::engine::general_purpose::STANDARD.encode(key.private_key_to_der().unwrap());
+        config.public_key =
+            base64::engine::general_purpose::STANDARD.encode(public.public_key_to_der().unwrap());
+        config.handshake_timeout = seconds;
+        config.network = network;
+        MasqueOutbound::with_shared_security(
+            &config,
+            UpstreamPath::proxy(upstream),
+            &SecurityContext::default(),
+        )
+        .unwrap()
+    }
+    fn session() -> StreamSession {
+        StreamSession {
+            inbound: crate::session::InboundKind::Socks5,
+            source: "192.0.2.1:1000".parse().unwrap(),
+            destination: Destination::Ip("192.0.2.10:443".parse().unwrap()),
+            sniffed_domain: None,
+            metadata: Default::default(),
+        }
+    }
+    #[tokio::test]
+    async fn masque_memory_physical_receive_hint_is_ip_only_on_real_upstream_request() {
+        for (network, hint) in [
+            (MasqueNetwork::Quic, Some(512 * 1024)),
+            (MasqueNetwork::H3L4Proxy, None),
+            (MasqueNetwork::H2, None),
+        ] {
+            let upstream = Arc::new(PendingUpstream {
+                reject_stream: true,
+                ..Default::default()
+            });
+            let mut outbound = outbound_network(0, upstream.clone(), network);
+            let factory = Arc::get_mut(&mut outbound.connection).unwrap();
+            // Keep endpoint resolution pure memory; the mock rejects acquisition.
+            factory.server = Destination::Ip("192.0.2.10:443".parse().unwrap());
+            let context = EstablishContext::default();
+            let rejected = if network == MasqueNetwork::H2 {
+                factory.connect_h2(session(), &context).await.is_err()
+            } else {
+                factory.connect(session(), &context).await.is_err()
+            };
+            assert!(rejected);
+            assert_eq!(upstream.calls.load(Ordering::Relaxed), 1);
+            if network == MasqueNetwork::H2 {
+                assert!(upstream.datagram_requests.lock().unwrap().is_empty());
+            } else {
+                assert_eq!(
+                    *upstream.datagram_requests.lock().unwrap(),
+                    vec![(DatagramBudget::new(1400, 1400), hint)]
+                );
+            }
+            outbound.shutdown().await;
+        }
+    }
+    #[tokio::test]
+    async fn masque_memory_invalid_quic_tls_does_not_acquire_upstream() {
+        let upstream = Arc::new(PendingUpstream::default());
+        let mut outbound = outbound(0, upstream.clone());
+        let factory = Arc::get_mut(&mut outbound.connection).unwrap();
+        factory.server = Destination::Ip("192.0.2.10:443".parse().unwrap());
+        // Config host validation permits this name, while the native TLS
+        // policy rejects an all-numeric final DNS label.
+        factory.server_name = "abc.123".into();
+        assert!(
+            factory
+                .connect(session(), &EstablishContext::default())
+                .await
+                .is_err()
+        );
+        assert_eq!(upstream.calls.load(Ordering::Relaxed), 0);
+        outbound.shutdown().await;
+    }
+    #[tokio::test(start_paused = true)]
+    async fn masque_shared_creation_cancellation_has_one_owned_attempt() {
+        for seconds in [0, 5] {
+            let upstream = Arc::new(PendingUpstream::default());
+            let outbound = outbound(seconds, upstream.clone());
+            let context = EstablishContext::with_timeout(Duration::from_millis(10));
+            let waiting = EstablishContext::with_timeout(Duration::from_secs(10));
+            let mut creator = Box::pin(outbound.engine(session(), &context));
+            assert!(futures_util::poll!(creator.as_mut()).is_pending());
+            upstream.entered.notified().await;
+            let engine = outbound.current.lock().await.as_ref().unwrap().clone();
+            let mut waiter = Box::pin(outbound.engine(session(), &waiting));
+            assert!(futures_util::poll!(waiter.as_mut()).is_pending());
+            assert_eq!(upstream.calls.load(Ordering::Relaxed), 1);
+            if seconds == 0 {
+                drop(waiter);
+                assert!(!engine.cancel.is_cancelled());
+                drop(creator);
+                assert!(engine.cancel.is_cancelled());
+            } else {
+                drop(creator);
+                tokio::time::advance(Duration::from_millis(50)).await;
+                assert!(!engine.cancel.is_cancelled());
+                assert!(futures_util::poll!(waiter.as_mut()).is_pending());
+                assert!(*upstream.deadline.lock().unwrap().as_ref().unwrap() > context.deadline());
+                drop(waiter);
+                tokio::time::advance(Duration::from_secs(5)).await;
+                assert!(engine.wait_ready(&waiting).await.is_err());
+                assert!(engine.cancel.is_cancelled());
+            }
+            outbound.shutdown().await;
+            assert!(engine.cancel.is_cancelled());
+            assert!(engine.job_is_joined().await);
+            assert!(outbound.current.lock().await.is_none());
+        }
+    }
+    #[test]
+    fn masque_handshake_duration_wrap_is_expired_not_a_new_schema_rejection() {
+        let context = EstablishContext::with_timeout(Duration::from_millis(1));
+        assert!(context.masque_handshake(i64::MAX).deadline() <= Instant::now());
+        assert!(context.masque_handshake(5).deadline() > context.deadline());
+    }
+}
diff --git a/src/outbound/masque/packet.rs b/src/outbound/masque/packet.rs
new file mode 100644
index 0000000..7b52c8b
--- /dev/null
+++ b/src/outbound/masque/packet.rs
@@ -0,0 +1,263 @@
+//! Bounded raw-IP validation at the CONNECT-IP packet boundary.
+use bytes::{Bytes, BytesMut};
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
+use vole_netstack::{ClientConfig, MAX_RECEIVE_PACKET_SIZE};
+
+struct IpPacket<'a> {
+    source: IpAddr,
+    destination: IpAddr,
+    protocol: u8,
+    header_len: usize,
+    payload: &'a [u8],
+    fragmented: bool,
+}
+
+/// One router hop. Shared input is copied only when mutation requires it.
+pub(super) fn outgoing(raw: Bytes) -> Option<Bytes> {
+    let packet = parse(&raw)?;
+    let header_len = packet.header_len;
+    let offset = if packet.source.is_ipv4() { 8 } else { 7 };
+    if raw[offset] <= 1 {
+        return None;
+    }
+    let mut raw = raw
+        .try_into_mut()
+        .unwrap_or_else(|bytes| BytesMut::from(bytes.as_ref()));
+    raw[offset] -= 1;
+    if offset == 8 {
+        raw[10..12].fill(0);
+        let checksum = checksum(&raw[..header_len]);
+        raw[10..12].copy_from_slice(&checksum.to_be_bytes());
+    }
+    Some(raw.freeze())
+}
+
+pub(super) fn incoming(raw: &[u8], client: &ClientConfig) -> bool {
+    if raw.len() > client.receive_packet_limit {
+        return false;
+    }
+    let Some(packet) = parse(raw) else {
+        return false;
+    };
+    if !client.contains_address(packet.destination) {
+        return false;
+    }
+    if packet.protocol == 17 {
+        return !packet.fragmented && valid_udp(&packet);
+    }
+    // The active TCP stack validates TCP checksum and state itself. ICMP PMTU
+    // parsing similarly verifies its own message and quoted active tuple.
+    true
+}
+
+fn parse(raw: &[u8]) -> Option<IpPacket<'_>> {
+    if raw.len() > MAX_RECEIVE_PACKET_SIZE {
+        return None;
+    }
+    match raw.first()? >> 4 {
+        4 => {
+            if raw.len() < 20 {
+                return None;
+            }
+            let header_len = usize::from(raw[0] & 15) * 4;
+            if header_len < 20
+                || header_len > raw.len()
+                || usize::from(u16::from_be_bytes([raw[2], raw[3]])) != raw.len()
+                || checksum(&raw[..header_len]) != 0
+            {
+                return None;
+            }
+            let source = Ipv4Addr::from(<[u8; 4]>::try_from(&raw[12..16]).ok()?);
+            let destination = Ipv4Addr::from(<[u8; 4]>::try_from(&raw[16..20]).ok()?);
+            Some(IpPacket {
+                source: source.into(),
+                destination: destination.into(),
+                protocol: raw[9],
+                header_len,
+                payload: &raw[header_len..],
+                fragmented: u16::from_be_bytes([raw[6], raw[7]]) & 0x3fff != 0,
+            })
+        }
+        6 => {
+            if raw.len() < 40 || 40 + usize::from(u16::from_be_bytes([raw[4], raw[5]])) != raw.len()
+            {
+                return None;
+            }
+            let source = Ipv6Addr::from(<[u8; 16]>::try_from(&raw[8..24]).ok()?);
+            let destination = Ipv6Addr::from(<[u8; 16]>::try_from(&raw[24..40]).ok()?);
+            if source.to_ipv4_mapped().is_some() || destination.to_ipv4_mapped().is_some() {
+                return None;
+            }
+            Some(IpPacket {
+                source: source.into(),
+                destination: destination.into(),
+                protocol: raw[6],
+                header_len: 40,
+                payload: &raw[40..],
+                // A Fragment header is not a direct UDP packet. The current
+                // raw-client router has no IPv6 extension-header UDP decoder.
+                fragmented: raw[6] == 44,
+            })
+        }
+        _ => None,
+    }
+}
+
+fn valid_udp(ip: &IpPacket<'_>) -> bool {
+    let udp = ip.payload;
+    if udp.len() < 8 || usize::from(u16::from_be_bytes([udp[4], udp[5]])) != udp.len() {
+        return false;
+    }
+    let advertised = u16::from_be_bytes([udp[6], udp[7]]);
+    if advertised == 0 {
+        return ip.source.is_ipv4();
+    }
+    let mut sum = 0;
+    match (ip.source, ip.destination) {
+        (IpAddr::V4(source), IpAddr::V4(destination)) => {
+            add(&mut sum, &source.octets());
+            add(&mut sum, &destination.octets());
+            add(&mut sum, &[0, 17]);
+            add(&mut sum, &u16::try_from(udp.len()).unwrap().to_be_bytes());
+        }
+        (IpAddr::V6(source), IpAddr::V6(destination)) => {
+            add(&mut sum, &source.octets());
+            add(&mut sum, &destination.octets());
+            add(&mut sum, &u32::try_from(udp.len()).unwrap().to_be_bytes());
+            add(&mut sum, &[0, 0, 0, 17]);
+        }
+        _ => return false,
+    }
+    add(&mut sum, udp);
+    finish(sum) == 0
+}
+
+fn add(sum: &mut u32, bytes: &[u8]) {
+    let (words, remainder) = bytes.as_chunks::<2>();
+    for word in words {
+        *sum += u32::from(u16::from_be_bytes([word[0], word[1]]));
+    }
+    if let Some(last) = remainder.first() {
+        *sum += u32::from(*last) << 8;
+    }
+}
+
+fn finish(mut sum: u32) -> u16 {
+    while sum >> 16 != 0 {
+        sum = (sum & 65535) + (sum >> 16);
+    }
+    !u16::try_from(sum).expect("folded checksum fits u16")
+}
+
+fn checksum(bytes: &[u8]) -> u16 {
+    let mut sum = 0;
+    add(&mut sum, bytes);
+    finish(sum)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use vole_netstack::{ClientPrefix, UdpDatagram, encode_udp_packet_into, parse_udp_packet_view};
+
+    fn client() -> ClientConfig {
+        ClientConfig {
+            prefixes: [
+                Some(ClientPrefix {
+                    address: "10.0.0.2".parse().unwrap(),
+                    prefix_len: 24,
+                }),
+                Some(ClientPrefix {
+                    address: "fd00::2".parse().unwrap(),
+                    prefix_len: 64,
+                }),
+            ],
+            receive_packet_limit: 65575,
+            path_mtu_discovery: true,
+        }
+        .validate(1280)
+        .unwrap()
+    }
+
+    fn udp(ipv6: bool) -> Bytes {
+        let (source, destination) = if ipv6 {
+            ("[2001:db8::1]:53", "[fd00::2]:12345")
+        } else {
+            ("192.0.2.1:53", "10.0.0.2:12345")
+        };
+        let mut bytes = Vec::new();
+        encode_udp_packet_into(
+            &UdpDatagram::new(
+                source.parse().unwrap(),
+                destination.parse().unwrap(),
+                Bytes::from_static(b"reply"),
+            ),
+            1500,
+            &mut bytes,
+        )
+        .unwrap();
+        bytes.into()
+    }
+
+    #[test]
+    fn masque_ip_packets_validate_udp_and_preserve_checksums_across_one_hop() {
+        for ipv6 in [false, true] {
+            let raw = udp(ipv6);
+            assert!(incoming(&raw, &client()));
+            let original = raw.clone();
+            let decremented = outgoing(raw).unwrap();
+            assert!(incoming(&decremented, &client()));
+            let view = parse_udp_packet_view(&decremented).unwrap();
+            assert_eq!(view.payload, b"reply");
+            let offset = if ipv6 { 7 } else { 8 };
+            assert_eq!(decremented[offset], original[offset] - 1);
+            assert_eq!(
+                original[offset], 64,
+                "mutating a shared packet changed its owner"
+            );
+            let mut corrupt = original.to_vec();
+            *corrupt.last_mut().unwrap() ^= 1;
+            assert!(!incoming(&corrupt, &client()));
+            assert!(!incoming(&original[..original.len() - 1], &client()));
+            let mut exhausted = original.to_vec();
+            exhausted[offset] = 1;
+            if !ipv6 {
+                exhausted[10..12].fill(0);
+                let value = checksum(&exhausted[..20]);
+                exhausted[10..12].copy_from_slice(&value.to_be_bytes());
+            }
+            assert!(outgoing(exhausted.into()).is_none());
+        }
+    }
+
+    #[test]
+    fn masque_ip_ingress_enforces_local_destination_udp_family_and_receive_budget() {
+        for ipv6 in [false, true] {
+            let original = udp(ipv6);
+            let mut no_udp_checksum = original.to_vec();
+            let udp_offset = if ipv6 { 40 } else { 20 };
+            no_udp_checksum[udp_offset + 6..udp_offset + 8].fill(0);
+            assert_eq!(incoming(&no_udp_checksum, &client()), !ipv6);
+            let limited = ClientConfig {
+                receive_packet_limit: original.len() - 1,
+                ..client()
+            };
+            assert!(!incoming(&original, &limited));
+            let mut other_client = client();
+            other_client.prefixes = [
+                Some(ClientPrefix {
+                    address: if ipv6 { "fd00::3" } else { "10.0.0.3" }.parse().unwrap(),
+                    prefix_len: if ipv6 { 64 } else { 24 },
+                }),
+                None,
+            ];
+            assert!(!incoming(&original, &other_client));
+        }
+        let mut fragment = udp(false).to_vec();
+        fragment[6] = 0x20;
+        fragment[10..12].fill(0);
+        let value = checksum(&fragment[..20]);
+        fragment[10..12].copy_from_slice(&value.to_be_bytes());
+        assert!(!incoming(&fragment, &client()));
+    }
+}
diff --git a/src/outbound/masque/resolver.rs b/src/outbound/masque/resolver.rs
new file mode 100644
index 0000000..6beb5ec
--- /dev/null
+++ b/src/outbound/masque/resolver.rs
@@ -0,0 +1,371 @@
+//! Private node DNS owns no strong link back to its outbound or IP engine.
+use super::{ConnectionFactory, datagram::Datagrams, ip::Engine};
+use crate::{
+    config::{DnsConfig, DnsNameserver},
+    dispatch::{BoxStream, DatagramBudget, DatagramTransport, DispatchError, Dispatcher},
+    dns::{resolution::ResolutionContext, runtime::RuntimeDns},
+    outbound::{DEFAULT_ESTABLISH_TIMEOUT, EstablishContext, owned_stream::OwnedStream},
+    security::SecurityContext,
+    session::{DatagramSession, Destination, StreamSession},
+    transport::h3_connect,
+};
+use async_trait::async_trait;
+use std::{
+    net::SocketAddr,
+    sync::{Arc, OnceLock, Weak},
+};
+use tokio::time::Instant;
+use tokio_util::sync::CancellationToken;
+
+fn configuration(nameservers: &[DnsNameserver], ipv6: bool) -> DnsConfig {
+    let mut config = DnsConfig {
+        enable: true,
+        ipv6,
+        nameservers: nameservers.to_vec(),
+        use_hosts: false,
+        use_system_hosts: false,
+        ..Default::default()
+    };
+    config.hosts.clear();
+    config.default_nameservers.clear();
+    config
+}
+
+async fn resolve_published_dns(
+    dns: &RuntimeDns,
+    cancel: &CancellationToken,
+    resolution: &ResolutionContext,
+    target: &Destination,
+    deadline: Instant,
+    ipv4: bool,
+    ipv6: bool,
+) -> Result<SocketAddr, DispatchError> {
+    // Stop can precede publication in OnceLock while its constructor runs.
+    // A published resolver must observe cancellation before opening a driver.
+    if cancel.is_cancelled() {
+        dns.begin_shutdown();
+        return Err(DispatchError::ConnectionRefused);
+    }
+    let result = resolution
+        .resolve_node_local(target, deadline, dns, ipv4, ipv6)
+        .await;
+    // A cache hit can complete without yielding to the outer cancellation arm.
+    if cancel.is_cancelled() {
+        dns.begin_shutdown();
+        return Err(DispatchError::ConnectionRefused);
+    }
+    result
+}
+
+pub(super) async fn resolve_ip(
+    engine: &Arc<Engine>,
+    target: &Destination,
+    resolution: &ResolutionContext,
+    deadline: Instant,
+) -> Result<SocketAddr, DispatchError> {
+    let ipv4 = engine
+        .client
+        .prefixes()
+        .any(|prefix| prefix.address.is_ipv4());
+    let ipv6 = engine.client.has_ipv6();
+    tokio::select! {
+        biased;
+        () = engine.cancel.cancelled() => Err(DispatchError::ConnectionRefused),
+        result = async {
+            if engine.config.dns.is_empty() || matches!(target, Destination::Ip(_)) {
+                return resolution.resolve_local_family(target, deadline, ipv4, ipv6).await;
+            }
+            let dns = engine.remote.get_or_init(|| {
+                RuntimeDns::new_for_masque_node(
+                    &configuration(&engine.config.dns, ipv6 && resolution.ipv6_allowed()),
+                    Arc::new(IpDns { engine: Arc::downgrade(engine) }),
+                    engine.resolution.clone(),
+                    engine.security.clone(),
+                )
+            });
+            resolve_published_dns(dns, &engine.cancel, resolution, target, deadline, ipv4, ipv6).await
+        } => result,
+    }
+}
+
+struct IpDns {
+    engine: Weak<Engine>,
+}
+
+#[async_trait]
+impl Dispatcher for IpDns {
+    async fn connect_tcp(&self, session: StreamSession) -> Result<BoxStream, DispatchError> {
+        let engine = self
+            .engine
+            .upgrade()
+            .ok_or(DispatchError::ConnectionRefused)?;
+        let Destination::Ip(remote) = session.destination else {
+            return Err(DispatchError::HostUnreachable);
+        };
+        let context =
+            EstablishContext::with_resolution(DEFAULT_ESTABLISH_TIMEOUT, engine.resolution.clone())
+                .with_metadata(&session.metadata);
+        let stream = tokio::select! {
+            biased;
+            () = engine.cancel.cancelled() => return Err(DispatchError::ConnectionRefused),
+            result = context.run_io("MASQUE DNS TCP", engine.tcp.connect(remote, context.deadline())) => result?,
+        };
+        Ok(Box::new(OwnedStream::new(
+            Box::new(stream),
+            engine.cancel.child_token(),
+        )))
+    }
+
+    async fn open_datagram(
+        &self,
+        session: DatagramSession,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        let engine = self
+            .engine
+            .upgrade()
+            .ok_or(DispatchError::ConnectionRefused)?;
+        if !engine.config.udp {
+            return Err(DispatchError::NotAllowed);
+        }
+        let resolution = engine.resolution.clone();
+        Ok(Box::new(Datagrams::new(
+            engine,
+            DatagramBudget::new(u16::MAX, session.max_response_payload_size()),
+            resolution,
+        )?))
+    }
+}
+
+pub(super) struct L4DnsContext<'a> {
+    pub remote: &'a OnceLock<Arc<RuntimeDns>>,
+    pub nameservers: &'a [DnsNameserver],
+    pub factory: &'a Arc<ConnectionFactory>,
+    pub pool: &'a Arc<h3_connect::Pool>,
+    pub cancel: &'a CancellationToken,
+    pub security: &'a SecurityContext,
+    pub bootstrap: &'a ResolutionContext,
+}
+
+pub(super) async fn resolve_l4(
+    context: L4DnsContext<'_>,
+    target: &Destination,
+    deadline: Instant,
+) -> Result<SocketAddr, DispatchError> {
+    tokio::select! {
+        biased;
+        () = context.cancel.cancelled() => Err(DispatchError::ConnectionRefused),
+        result = async {
+            if context.nameservers.is_empty() || matches!(target, Destination::Ip(_)) {
+                return context.bootstrap.resolve_local_family(target, deadline, true, true).await;
+            }
+            let dns = context.remote.get_or_init(|| {
+                RuntimeDns::new_for_masque_node(
+                    &configuration(context.nameservers, context.bootstrap.ipv6_allowed()),
+                    Arc::new(L4Dns {
+                        factory: Arc::downgrade(context.factory),
+                        pool: Arc::downgrade(context.pool),
+                        cancel: context.cancel.clone(),
+                        bootstrap: context.bootstrap.clone(),
+                    }),
+                    context.bootstrap.clone(),
+                    context.security.clone(),
+                )
+            });
+            resolve_published_dns(dns, context.cancel, context.bootstrap, target, deadline, true, true).await
+        } => result,
+    }
+}
+
+struct L4Dns {
+    factory: Weak<ConnectionFactory>,
+    pool: Weak<h3_connect::Pool>,
+    cancel: CancellationToken,
+    bootstrap: ResolutionContext,
+}
+
+#[async_trait]
+impl Dispatcher for L4Dns {
+    async fn connect_tcp(&self, session: StreamSession) -> Result<BoxStream, DispatchError> {
+        if !matches!(session.destination, Destination::Ip(_)) {
+            return Err(DispatchError::HostUnreachable);
+        }
+        let factory = self
+            .factory
+            .upgrade()
+            .ok_or(DispatchError::ConnectionRefused)?;
+        let pool = self
+            .pool
+            .upgrade()
+            .ok_or(DispatchError::ConnectionRefused)?;
+        let context =
+            EstablishContext::with_resolution(DEFAULT_ESTABLISH_TIMEOUT, self.bootstrap.clone())
+                .with_metadata(&session.metadata);
+        let stream = tokio::select! {
+            biased;
+            () = self.cancel.cancelled() => return Err(DispatchError::ConnectionRefused),
+            result = super::connect_l4_literal(factory, pool, session, &context) => result?,
+        };
+        Ok(Box::new(OwnedStream::new(
+            stream,
+            self.cancel.child_token(),
+        )))
+    }
+
+    async fn open_datagram(
+        &self,
+        _session: DatagramSession,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        Err(DispatchError::NotAllowed)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        config::{DnsRoute, DnsTransport},
+        session::Datagram,
+    };
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    #[derive(Default)]
+    struct MemoryDns {
+        calls: AtomicUsize,
+    }
+
+    #[async_trait]
+    impl Dispatcher for MemoryDns {
+        async fn connect_tcp(&self, _: StreamSession) -> Result<BoxStream, DispatchError> {
+            Err(DispatchError::NotAllowed)
+        }
+
+        async fn open_datagram(
+            &self,
+            _: DatagramSession,
+        ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+            self.calls.fetch_add(1, Ordering::Relaxed);
+            Ok(Box::new(MemoryReply(None)))
+        }
+    }
+
+    struct MemoryReply(Option<Datagram>);
+
+    #[async_trait]
+    impl DatagramTransport for MemoryReply {
+        fn supports_shared_destinations(&self) -> bool {
+            true
+        }
+        async fn send(&mut self, datagram: Datagram) -> Result<(), DispatchError> {
+            // RuntimeDns generates this bounded, uncompressed A question.
+            let end = 12
+                + datagram.payload[12..]
+                    .iter()
+                    .position(|byte| *byte == 0)
+                    .unwrap()
+                + 5;
+            let mut response = datagram.payload[..end].to_vec();
+            response[2..4].copy_from_slice(&0x8180_u16.to_be_bytes());
+            response[6..8].copy_from_slice(&1_u16.to_be_bytes());
+            response[10..12].fill(0);
+            response
+                .extend_from_slice(&[0xc0, 0x0c, 0, 1, 0, 1, 0, 0, 0, 60, 0, 4, 203, 0, 113, 1]);
+            self.0 = Some(Datagram {
+                payload: response.into(),
+                ..datagram
+            });
+            Ok(())
+        }
+
+        async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+            self.0.take().ok_or(DispatchError::HostUnreachable)
+        }
+    }
+
+    fn private_dns(dispatcher: Arc<MemoryDns>) -> Arc<RuntimeDns> {
+        let nameserver = DnsNameserver {
+            transport: DnsTransport::Udp,
+            address: "192.0.2.53".parse::<std::net::IpAddr>().unwrap().into(),
+            port: 53,
+            route: DnsRoute::Direct,
+            path: None,
+            http_auth: None,
+            options: Default::default(),
+        };
+        RuntimeDns::new_for_masque_node(
+            &configuration(&[nameserver], false),
+            dispatcher,
+            ResolutionContext::default(),
+            SecurityContext::new(),
+        )
+    }
+
+    fn target() -> Destination {
+        Destination::Domain {
+            host: "cached.example".into(),
+            port: 443,
+        }
+    }
+
+    #[tokio::test]
+    async fn masque_private_dns_rejects_late_publication_after_stop() {
+        let dispatcher = Arc::new(MemoryDns::default());
+        let remote = OnceLock::new();
+        let cancel = CancellationToken::new();
+        let dns = remote.get_or_init(|| {
+            // Stop saw an empty OnceLock while this constructor was running.
+            cancel.cancel();
+            private_dns(dispatcher.clone())
+        });
+        let result = resolve_published_dns(
+            dns,
+            &cancel,
+            &ResolutionContext::default(),
+            &target(),
+            Instant::now() + std::time::Duration::from_secs(1),
+            true,
+            false,
+        )
+        .await;
+        assert!(matches!(result, Err(DispatchError::ConnectionRefused)));
+        assert_eq!(dispatcher.calls.load(Ordering::Relaxed), 0);
+        dns.shutdown().await;
+    }
+
+    #[tokio::test]
+    async fn masque_private_dns_rejects_cached_lookup_after_stop() {
+        let dispatcher = Arc::new(MemoryDns::default());
+        let remote = OnceLock::new();
+        let cancel = CancellationToken::new();
+        let dns = remote.get_or_init(|| private_dns(dispatcher.clone()));
+        let resolution = ResolutionContext::default();
+        for _ in 0..2 {
+            let address = resolve_published_dns(
+                dns,
+                &cancel,
+                &resolution,
+                &target(),
+                Instant::now() + std::time::Duration::from_secs(1),
+                true,
+                false,
+            )
+            .await
+            .unwrap();
+            assert_eq!(address, "203.0.113.1:443".parse().unwrap());
+        }
+        assert_eq!(dispatcher.calls.load(Ordering::Relaxed), 1);
+        cancel.cancel();
+        let result = resolve_published_dns(
+            dns,
+            &cancel,
+            &resolution,
+            &target(),
+            Instant::now() + std::time::Duration::from_secs(1),
+            true,
+            false,
+        )
+        .await;
+        assert!(matches!(result, Err(DispatchError::ConnectionRefused)));
+        assert_eq!(dispatcher.calls.load(Ordering::Relaxed), 1);
+        dns.shutdown().await;
+    }
+}
diff --git a/src/outbound/mieru/crypto.rs b/src/outbound/mieru/crypto.rs
new file mode 100644
index 0000000..bf507a1
--- /dev/null
+++ b/src/outbound/mieru/crypto.rs
@@ -0,0 +1,375 @@
+//! Mieru v3 wire cryptography, implemented from the public protocol specification.
+//! https://github.com/enfein/mieru/blob/v3.38.1/docs/protocol.md
+//! This module contains no translated Go implementation.
+use boring::aead::{AeadCtx, Algorithm};
+use chacha20poly1305::{AeadInOut, KeyInit, Tag, XChaCha20Poly1305, XNonce};
+use sha2::{Digest, Sha256};
+use std::{fmt, io, num::NonZeroU32, sync::Arc};
+use zeroize::Zeroizing;
+
+pub(crate) const NONCE_LEN: usize = 24;
+pub(crate) const TAG_LEN: usize = 16;
+
+/// One immutable, physical-carrier key. Both directions share it, with separate nonce state.
+/// The dependency's zeroize feature erases its key when the final owner is dropped.
+pub(crate) struct Key(XChaCha20Poly1305);
+
+impl Key {
+    fn seal(&self, nonce: &XNonce, plaintext: &mut [u8]) -> io::Result<[u8; TAG_LEN]> {
+        self.0
+            .encrypt_inout_detached(nonce, b"", plaintext.into())
+            .map(Into::into)
+            .map_err(|_| io::Error::other("Mieru encryption failed"))
+    }
+
+    fn open(&self, nonce: &XNonce, ciphertext: &mut [u8], tag: [u8; TAG_LEN]) -> io::Result<()> {
+        self.0
+            .decrypt_inout_detached(nonce, b"", ciphertext.into(), &Tag::from(tag))
+            .map_err(|_| io::Error::new(io::ErrorKind::InvalidData, "Mieru authentication failed"))
+    }
+}
+
+impl fmt::Debug for Key {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("MieruKey(..)")
+    }
+}
+
+/// Select the current rounded two-minute epoch once, when creating a physical carrier.
+pub(crate) fn derive_key(username: &str, password: &str, unix_secs: u64) -> Key {
+    let material = key_material(username, password, unix_secs);
+    Key(XChaCha20Poly1305::new_from_slice(material.as_ref()).expect("32-byte Mieru key"))
+}
+
+fn key_material(username: &str, password: &str, unix_secs: u64) -> Zeroizing<[u8; 32]> {
+    let password_hash: Zeroizing<[u8; 32]> = Zeroizing::new(
+        Sha256::new()
+            .chain_update(password.as_bytes())
+            .chain_update([0])
+            .chain_update(username.as_bytes())
+            .finalize()
+            .into(),
+    );
+    // Use a wider intermediate; the protocol stores the rounded epoch as a uint64.
+    let rounded = ((u128::from(unix_secs) + 60) / 120 * 120) as u64;
+    let salt = Sha256::digest(rounded.to_be_bytes());
+    let mut material = Zeroizing::new([0; 32]);
+    ring::pbkdf2::derive(
+        ring::pbkdf2::PBKDF2_HMAC_SHA256,
+        NonZeroU32::new(64).expect("nonzero Mieru iteration count"),
+        &salt,
+        password_hash.as_ref(),
+        material.as_mut(),
+    );
+    material
+}
+
+/// Apply the authenticated user's lookup hint after generating or transforming the nonce.
+/// Randomness and future traffic-pattern policy belong to the physical carrier's creator.
+pub(crate) fn make_client_nonce(username: &str, mut random: [u8; NONCE_LEN]) -> [u8; NONCE_LEN] {
+    let hint = Sha256::new()
+        .chain_update(username.as_bytes())
+        .chain_update(&random[..16])
+        .finalize();
+    random[20..].copy_from_slice(&hint[..4]);
+    random
+}
+
+/// Derive one UDP physical-carrier key; the temporary material is erased after
+/// the two independently owned packet ciphers have copied it during setup.
+pub(super) fn derive_packet_key(
+    username: &str,
+    password: &str,
+    unix_secs: u64,
+) -> Zeroizing<[u8; 32]> {
+    key_material(username, password, unix_secs)
+}
+
+/// Stateless UDP encryption with an explicit nonce and a setup-selected backend.
+/// Backend selection is independent of low-entropy wire encoding.
+pub(super) enum PacketCipher {
+    Native(AeadCtx),
+    Rust(Key),
+}
+
+impl PacketCipher {
+    pub(super) fn new(key: &[u8; 32], low_entropy: bool) -> io::Result<Self> {
+        if low_entropy {
+            Ok(Self::Rust(Key(XChaCha20Poly1305::new(&(*key).into()))))
+        } else {
+            AeadCtx::new(&Algorithm::xchacha20_poly1305(), key, TAG_LEN)
+                .map(Self::Native)
+                .map_err(io::Error::other)
+        }
+    }
+
+    pub(super) fn seal(
+        &mut self,
+        nonce: [u8; NONCE_LEN],
+        plaintext: &mut [u8],
+    ) -> io::Result<[u8; TAG_LEN]> {
+        match self {
+            Self::Rust(key) => key.seal(&nonce.into(), plaintext),
+            Self::Native(context) => {
+                let mut tag = [0; TAG_LEN];
+                context
+                    .seal_in_place_mut(&nonce, plaintext, &mut tag, b"")
+                    .map_err(|_| io::Error::other("Mieru encryption failed"))?;
+                Ok(tag)
+            }
+        }
+    }
+
+    pub(super) fn open(
+        &mut self,
+        nonce: [u8; NONCE_LEN],
+        ciphertext: &mut [u8],
+        tag: [u8; TAG_LEN],
+    ) -> io::Result<()> {
+        match self {
+            Self::Rust(key) => key.open(&nonce.into(), ciphertext, tag),
+            Self::Native(context) => context
+                .open_in_place_mut(&nonce, ciphertext, &tag, b"")
+                .map_err(|_| {
+                    io::Error::new(io::ErrorKind::InvalidData, "Mieru authentication failed")
+                }),
+        }
+    }
+}
+
+/// A single TCP direction; deliberately not Clone so a used nonce cursor cannot be forked.
+pub(super) struct ImplicitCipher {
+    key: Arc<Key>,
+    nonce: [u8; NONCE_LEN],
+    used: bool,
+    exhausted: bool,
+}
+
+impl ImplicitCipher {
+    pub(super) fn new(key: Arc<Key>, nonce: [u8; NONCE_LEN]) -> Self {
+        Self {
+            key,
+            nonce,
+            used: false,
+            exhausted: false,
+        }
+    }
+
+    fn next_nonce(&mut self) -> io::Result<XNonce> {
+        if self.exhausted {
+            return Err(io::Error::other("Mieru nonce exhausted"));
+        }
+        if self.used {
+            let mut overflow = true;
+            for byte in self.nonce.iter_mut().rev() {
+                let (next, carry) = byte.overflowing_add(1);
+                *byte = next;
+                if !carry {
+                    overflow = false;
+                    break;
+                }
+            }
+            if overflow {
+                self.exhausted = true;
+                return Err(io::Error::other("Mieru nonce exhausted"));
+            }
+        }
+        self.used = true;
+        Ok(self.nonce.into())
+    }
+
+    pub(super) fn seal(&mut self, plaintext: &mut [u8]) -> io::Result<[u8; TAG_LEN]> {
+        let nonce = self.next_nonce()?;
+        self.key.seal(&nonce, plaintext)
+    }
+
+    pub(super) fn open(&mut self, ciphertext: &mut [u8], tag: [u8; TAG_LEN]) -> io::Result<()> {
+        let nonce = self.next_nonce()?;
+        self.key.open(&nonce, ciphertext, tag)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn hex(input: &str) -> Vec<u8> {
+        assert_eq!(input.len() % 2, 0, "fixture contains a partial byte");
+        input
+            .as_bytes()
+            .chunks_exact(2)
+            .map(|pair| {
+                let digit = |byte: u8| match byte {
+                    b'0'..=b'9' => byte - b'0',
+                    b'a'..=b'f' => byte - b'a' + 10,
+                    _ => panic!("invalid fixture hex"),
+                };
+                digit(pair[0]) * 16 + digit(pair[1])
+            })
+            .collect()
+    }
+
+    #[test]
+    fn protocol_kdf_and_user_hint_vectors() {
+        // Independently generated with Python hashlib SHA256/PBKDF2, using protocol inputs.
+        assert_eq!(
+            &key_material("vole", "fixture-password", 1_700_000_000)[..],
+            hex("0f3c9ee5bf9ea6a8cde5563da147adaa7a00dde4e3ee8dc267524f13738ba3c8")
+        );
+        assert_eq!(
+            &key_material("vole", "fixture-password", 59)[..],
+            hex("0d03d2861c28e529babee004fa2d8e9c9e1796e73a49dbc260f246cc600b3090")
+        );
+        assert_eq!(
+            &key_material("vole", "fixture-password", 60)[..],
+            hex("d04f1135685786b90cf5ecad72803e7c9f359f69e8a16caf8bca58e9113c3d04")
+        );
+        let nonce = make_client_nonce("vole", std::array::from_fn(|index| index as u8));
+        assert_eq!(
+            nonce.as_slice(),
+            hex("000102030405060708090a0b0c0d0e0f101112135b65f257")
+        );
+        let debug = format!("{:?}", derive_key("vole", "fixture-password", 60));
+        assert_eq!(debug, "MieruKey(..)");
+    }
+
+    #[test]
+    fn udp_native_matches_reference_wire_and_rejects_bad_tags() {
+        use super::super::wire::{
+            DataKind, DataMetadata, METADATA_LEN, Metadata, PACKET_HEADER_LEN, PacketDecoder,
+            PacketEncoder, Padding, SessionKind, SessionMetadata,
+        };
+        use bytes::Bytes;
+
+        const TIME: u64 = 1_700_000_000;
+        let material = derive_packet_key("vole", "fixture-password", TIME);
+        let reference = derive_key("vole", "fixture-password", TIME);
+        for low_entropy in [false, true] {
+            let mut encoder = PacketEncoder::new(&material, low_entropy).unwrap();
+            let mut decoder = PacketDecoder::new(&material, low_entropy).unwrap();
+            for nonce in [[0; NONCE_LEN], [0xff; NONCE_LEN]] {
+                for payload in [b"".as_slice(), b"native/reference UDP body".as_slice()] {
+                    let metadata = if payload.is_empty() {
+                        Metadata::Session(SessionMetadata {
+                            kind: SessionKind::OpenResponse,
+                            session_id: 7,
+                            sequence: 0,
+                            status: 0,
+                        })
+                    } else {
+                        Metadata::Data(DataMetadata {
+                            kind: DataKind::ServerData,
+                            session_id: 7,
+                            sequence: 1,
+                            unack_sequence: 2,
+                            window: 16,
+                            fragment: 0,
+                        })
+                    };
+                    let mut native_wire = Vec::new();
+                    encoder
+                        .encode_frame(
+                            metadata,
+                            payload,
+                            Padding::default(),
+                            nonce,
+                            TIME,
+                            &mut native_wire,
+                        )
+                        .unwrap();
+                    assert_eq!(
+                        native_wire.len(),
+                        PACKET_HEADER_LEN
+                            + payload.len()
+                            + if payload.is_empty() { 0 } else { TAG_LEN }
+                    );
+                    let mut plain_header: [u8; METADATA_LEN] = native_wire
+                        [NONCE_LEN..NONCE_LEN + METADATA_LEN]
+                        .try_into()
+                        .unwrap();
+                    reference
+                        .open(
+                            &nonce.into(),
+                            &mut plain_header,
+                            native_wire[NONCE_LEN + METADATA_LEN..PACKET_HEADER_LEN]
+                                .try_into()
+                                .unwrap(),
+                        )
+                        .unwrap();
+                    let header_tag = reference.seal(&nonce.into(), &mut plain_header).unwrap();
+                    let mut reference_wire = nonce.to_vec();
+                    reference_wire.extend_from_slice(&plain_header);
+                    reference_wire.extend_from_slice(&header_tag);
+                    if !payload.is_empty() {
+                        let mut body = payload.to_vec();
+                        let body_tag = reference.seal(&nonce.into(), &mut body).unwrap();
+                        reference_wire.extend_from_slice(&body);
+                        reference_wire.extend_from_slice(&body_tag);
+                    }
+                    assert_eq!(native_wire, reference_wire);
+                    let received = decoder
+                        .decode_frame(Bytes::from(reference_wire.clone()), TIME)
+                        .unwrap();
+                    assert_eq!(received.metadata, metadata);
+                    assert_eq!(received.payload.as_ref(), payload);
+
+                    let mut bad_tag = reference_wire.clone();
+                    bad_tag[PACKET_HEADER_LEN - 1] ^= 1;
+                    assert_eq!(
+                        decoder
+                            .decode_frame(Bytes::from(bad_tag), TIME)
+                            .unwrap_err()
+                            .kind(),
+                        io::ErrorKind::InvalidData
+                    );
+                    let mut bad_nonce = reference_wire.clone();
+                    bad_nonce[0] ^= 1;
+                    assert_eq!(
+                        decoder
+                            .decode_frame(Bytes::from(bad_nonce), TIME)
+                            .unwrap_err()
+                            .kind(),
+                        io::ErrorKind::InvalidData
+                    );
+                    if !payload.is_empty() {
+                        let mut bad_body_tag = reference_wire.clone();
+                        *bad_body_tag.last_mut().unwrap() ^= 1;
+                        assert_eq!(
+                            decoder
+                                .decode_frame(Bytes::from(bad_body_tag), TIME)
+                                .unwrap_err()
+                                .kind(),
+                            io::ErrorKind::InvalidData
+                        );
+                    }
+                    // Packet authentication failure never poisons the fixed-key UDP context.
+                    assert_eq!(
+                        decoder
+                            .decode_frame(Bytes::from(reference_wire), TIME)
+                            .unwrap()
+                            .payload
+                            .as_ref(),
+                        payload
+                    );
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn big_endian_nonce_carry_and_exhaustion() {
+        let key = Arc::new(derive_key("vole", "fixture-password", 60));
+        let mut nonce = [0; NONCE_LEN];
+        nonce[22] = 0x12;
+        nonce[23] = 0xff;
+        let mut cipher = ImplicitCipher::new(key.clone(), nonce);
+        assert_eq!(cipher.next_nonce().unwrap().as_slice(), nonce);
+        nonce[22] = 0x13;
+        nonce[23] = 0;
+        assert_eq!(cipher.next_nonce().unwrap().as_slice(), nonce);
+        let mut exhausted = ImplicitCipher::new(key, [0xff; NONCE_LEN]);
+        exhausted.next_nonce().unwrap();
+        assert!(exhausted.next_nonce().is_err());
+        assert!(exhausted.next_nonce().is_err());
+    }
+}
diff --git a/src/outbound/mieru/low_entropy.rs b/src/outbound/mieru/low_entropy.rs
new file mode 100644
index 0000000..19254d1
--- /dev/null
+++ b/src/outbound/mieru/low_entropy.rs
@@ -0,0 +1,870 @@
+//! In-place bit packing for Mieru's low-entropy body representation.
+//! The AEAD tag stays outside this representation. Metadata describes the
+//! number of source bytes, a repeated half-mask, and per-chunk rotation.
+use super::wire::{LowEntropyEncoding, MAX_DATA_PAYLOAD};
+use std::io;
+
+// Keep tiny bodies on the original per-bit path; no public configuration.
+const PLANNED_SOURCE_MIN: usize = 32;
+
+fn invalid() -> io::Error {
+    io::Error::new(io::ErrorKind::InvalidData, "invalid Mieru low-entropy body")
+}
+
+impl LowEntropyEncoding {
+    pub(super) fn source_bytes(self) -> io::Result<usize> {
+        match self.mode {
+            1..=4 => Ok(usize::from(self.mode) + 3),
+            _ => Err(invalid()),
+        }
+    }
+
+    fn validate(self) -> io::Result<usize> {
+        let count = self.source_bytes()?;
+        if self.half_mask.count_ones() != (count * 4) as u32
+            || !(self.rotation <= 15 || (self.rotation.is_multiple_of(16) && self.rotation <= 240))
+            || self.padding_bit > 1
+        {
+            return Err(invalid());
+        }
+        Ok(count)
+    }
+
+    pub(super) fn encoded_len(self, source_len: usize) -> io::Result<usize> {
+        let count = self.validate()?;
+        let len = source_len
+            .div_ceil(count)
+            .checked_mul(8)
+            .ok_or_else(invalid)?;
+        if source_len > MAX_DATA_PAYLOAD || len > usize::from(u16::MAX) {
+            return Err(invalid());
+        }
+        Ok(len)
+    }
+
+    fn mask(self, chunk: usize) -> u64 {
+        let mask = u64::from(self.half_mask) * 0x1_0000_0001;
+        let chunk = (chunk % 64) as u32;
+        if self.rotation <= 15 {
+            mask.rotate_right(chunk * u32::from(self.rotation))
+        } else {
+            mask.rotate_left(chunk * u32::from(self.rotation / 16))
+        }
+    }
+
+    /// The source begins at offset zero. Working backward leaves unread
+    /// source chunks intact while expanding them into the existing buffer.
+    pub(super) fn expand(self, body: &mut [u8], source_len: usize) -> io::Result<()> {
+        let encoded_len = self.encoded_len(source_len)?;
+        if body.len() != encoded_len {
+            return Err(invalid());
+        }
+        let count = self.source_bytes()?;
+        let plan = (source_len >= PLANNED_SOURCE_MIN).then(|| PackingPlan::new(self.half_mask));
+        let mut chunks = source_len.div_ceil(count);
+        while chunks != 0 {
+            #[cfg(all(
+                target_arch = "aarch64",
+                target_feature = "neon",
+                target_endian = "little"
+            ))]
+            if let Some(plan) = &plan {
+                // The highest partial chunk stays scalar. Read both complete
+                // source chunks before either overlapping in-place store.
+                if chunks >= 2 && chunks * count <= source_len {
+                    let lower = chunks - 2;
+                    let higher = chunks - 1;
+                    let source = [lower, higher].map(|chunk| {
+                        let offset = chunk * count;
+                        body[offset..offset + count]
+                            .iter()
+                            .fold(0u64, |word, byte| word << 8 | u64::from(*byte))
+                    });
+                    let right = [
+                        packing_phase(self.rotation, lower),
+                        packing_phase(self.rotation, higher),
+                    ];
+                    let mut encoded = plan.deposit_pair_neon(source, right);
+                    if self.padding_bit == 1 {
+                        encoded[0] |= !self.mask(lower);
+                        encoded[1] |= !self.mask(higher);
+                    }
+                    body[higher * 8..higher * 8 + 8].copy_from_slice(&encoded[1].to_be_bytes());
+                    body[lower * 8..lower * 8 + 8].copy_from_slice(&encoded[0].to_be_bytes());
+                    chunks -= 2;
+                    continue;
+                }
+            }
+            chunks -= 1;
+            let chunk = chunks;
+            let offset = chunk * count;
+            let len = (source_len - offset).min(count);
+            let source = body[offset..offset + len]
+                .iter()
+                .fold(0u64, |word, byte| word << 8 | u64::from(*byte));
+            let mask = self.mask(chunk);
+            let mut encoded = match &plan {
+                Some(plan) => plan.deposit(source, packing_phase(self.rotation, chunk)),
+                None => deposit(source, mask),
+            };
+            if self.padding_bit == 1 {
+                // A partial final source chunk has fewer data bits than its
+                // mask. Those remaining positions are uniform padding too.
+                let data_mask = if len == count {
+                    mask
+                } else {
+                    match &plan {
+                        Some(plan) => plan
+                            .deposit((1u64 << (len * 8)) - 1, packing_phase(self.rotation, chunk)),
+                        None => deposit((1u64 << (len * 8)) - 1, mask),
+                    }
+                };
+                encoded |= !data_mask;
+            }
+            body[chunk * 8..chunk * 8 + 8].copy_from_slice(&encoded.to_be_bytes());
+        }
+        Ok(())
+    }
+
+    /// Compact authenticated-length ciphertext before AEAD verification.
+    /// Every non-data bit must have the polarity inferred from the first chunk.
+    pub(super) fn compact(self, body: &mut [u8], source_len: usize) -> io::Result<()> {
+        if body.len() != self.encoded_len(source_len)? {
+            return Err(invalid());
+        }
+        let count = self.source_bytes()?;
+        let plan = (source_len >= PLANNED_SOURCE_MIN).then(|| PackingPlan::new(self.half_mask));
+        let mut polarity = None;
+        for chunk in 0..source_len.div_ceil(count) {
+            let offset = chunk * count;
+            let len = (source_len - offset).min(count);
+            let word = u64::from_be_bytes(body[chunk * 8..chunk * 8 + 8].try_into().unwrap());
+            let mask = self.mask(chunk);
+            let data_mask = if len == count {
+                mask
+            } else {
+                match &plan {
+                    Some(plan) => {
+                        plan.deposit((1u64 << (len * 8)) - 1, packing_phase(self.rotation, chunk))
+                    }
+                    None => deposit((1u64 << (len * 8)) - 1, mask),
+                }
+            };
+            let padding_mask = !data_mask;
+            let padding = word & padding_mask;
+            let bit = if padding == 0 {
+                false
+            } else if padding == padding_mask {
+                true
+            } else {
+                return Err(invalid());
+            };
+            if polarity.is_some_and(|previous| previous != bit) {
+                return Err(invalid());
+            }
+            polarity = Some(bit);
+            let decoded = match &plan {
+                Some(plan) => plan.extract(word, packing_phase(self.rotation, chunk)),
+                None => extract(word, mask),
+            }
+            .to_be_bytes();
+            body[offset..offset + len].copy_from_slice(&decoded[8 - len..]);
+        }
+        Ok(())
+    }
+}
+
+// Per-frame stable bit-movement plan. A repeated half-mask has period at most
+// 32; a packed k-bit rotation lets this one plan serve every phase. These
+// fixed scalars/arrays own no heap and are never cached across frame calls.
+#[derive(Clone, Copy)]
+struct PackingPlan {
+    moves: [u64; 6],
+    mask: u64,
+    // prefix_ones[r] is popcount(mask & low_bits(r)), for 0 <= r < 32.
+    prefix_ones: [u8; 32],
+    source_bits: u8,
+}
+
+fn low_bits(n: u32) -> u64 {
+    (1u64 << n) - 1
+}
+
+impl PackingPlan {
+    fn new(half_mask: u32) -> Self {
+        let mask = u64::from(half_mask) | (u64::from(half_mask) << 32);
+        let mut moves = [0u64; 6];
+        let mut m = mask;
+        let mut holes = (!m) << 1;
+        for (i, movement) in moves.iter_mut().enumerate() {
+            let mut p = holes ^ (holes << 1);
+            p ^= p << 2;
+            p ^= p << 4;
+            p ^= p << 8;
+            p ^= p << 16;
+            p ^= p << 32;
+            *movement = p & m;
+            m = (m ^ *movement) | (*movement >> (1u32 << i));
+            holes &= !p;
+        }
+        let mut prefix_ones = [0u8; 32];
+        let mut count = 0u8;
+        for (bit, prefix) in prefix_ones.iter_mut().enumerate() {
+            *prefix = count;
+            count += ((half_mask >> bit) & 1) as u8;
+        }
+        Self {
+            moves,
+            mask,
+            prefix_ones,
+            source_bits: mask.count_ones() as u8,
+        }
+    }
+
+    #[inline]
+    fn extract_base(&self, mut word: u64) -> u64 {
+        word &= self.mask;
+        for (i, movement) in self.moves.iter().enumerate() {
+            let value = word & *movement;
+            word = (word ^ value) | (value >> (1u32 << i));
+        }
+        word
+    }
+
+    #[inline]
+    fn deposit_base(&self, mut word: u64) -> u64 {
+        word &= low_bits(u32::from(self.source_bits));
+        for (i, movement) in self.moves.iter().enumerate().rev() {
+            let distance = 1u32 << i;
+            let value = word & (*movement >> distance);
+            word = (word ^ value) | (value << distance);
+        }
+        word & self.mask
+    }
+
+    #[cfg(all(
+        target_arch = "aarch64",
+        target_feature = "neon",
+        target_endian = "little"
+    ))]
+    #[inline]
+    fn deposit_pair_neon(&self, words: [u64; 2], right: [u32; 2]) -> [u64; 2] {
+        use core::arch::aarch64::{
+            vandq_u64, vdupq_n_s64, vdupq_n_u64, veorq_u64, vgetq_lane_u64, vorrq_u64,
+            vsetq_lane_u64, vshlq_u64,
+        };
+
+        let width = u32::from(self.source_bits);
+        let packed = [0usize, 1].map(|lane| {
+            let wrap = u32::from(self.prefix_ones[right[lane] as usize]);
+            let word = words[lane] & low_bits(width);
+            ((word << wrap) | (word >> (width - wrap))) & low_bits(width)
+        });
+        // SAFETY: this helper is compiled only with AArch64 NEON enabled.
+        // All lanes are the valid constants 0/1; only local integers enter
+        // the vector operations, with no body pointers or memory accesses.
+        unsafe {
+            let mut words = vsetq_lane_u64::<1>(packed[1], vdupq_n_u64(packed[0]));
+            words = vandq_u64(words, vdupq_n_u64(low_bits(width)));
+            for (i, movement) in self.moves.iter().enumerate().rev() {
+                let distance = 1u32 << i;
+                let value = vandq_u64(words, vdupq_n_u64(*movement >> distance));
+                words = vorrq_u64(
+                    veorq_u64(words, value),
+                    vshlq_u64(value, vdupq_n_s64(i64::from(distance))),
+                );
+            }
+            words = vandq_u64(words, vdupq_n_u64(self.mask));
+            [
+                vgetq_lane_u64::<0>(words).rotate_right(right[0]),
+                vgetq_lane_u64::<1>(words).rotate_right(right[1]),
+            ]
+        }
+    }
+
+    #[inline]
+    fn deposit(&self, word: u64, right: u32) -> u64 {
+        let width = u32::from(self.source_bits);
+        let wrap = u32::from(self.prefix_ones[right as usize]);
+        let word = word & low_bits(width);
+        // Width is 32/40/48/56; wrap=0 is valid without a shift by 64.
+        let packed = ((word << wrap) | (word >> (width - wrap))) & low_bits(width);
+        self.deposit_base(packed).rotate_right(right)
+    }
+
+    #[inline]
+    fn extract(&self, word: u64, right: u32) -> u64 {
+        let width = u32::from(self.source_bits);
+        let wrap = u32::from(self.prefix_ones[right as usize]);
+        let packed = self.extract_base(word.rotate_left(right));
+        ((packed >> wrap) | (packed << (width - wrap))) & low_bits(width)
+    }
+}
+
+#[inline]
+fn packing_phase(rotation: u8, chunk: usize) -> u32 {
+    let step = if rotation <= 15 {
+        rotation
+    } else {
+        rotation / 16
+    };
+    let right = ((chunk as u32 & 31) * u32::from(step)) & 31;
+    if rotation <= 15 {
+        right
+    } else {
+        0u32.wrapping_sub(right) & 31
+    }
+}
+
+fn deposit(mut source: u64, mut positions: u64) -> u64 {
+    let mut result = 0;
+    while positions != 0 {
+        let position = positions.isolate_lowest_one();
+        if source & 1 != 0 {
+            result |= position;
+        }
+        source >>= 1;
+        positions &= positions - 1;
+    }
+    result
+}
+
+fn extract(source: u64, mut positions: u64) -> u64 {
+    let mut result = 0;
+    let mut bit = 1;
+    while positions != 0 {
+        let position = positions.isolate_lowest_one();
+        if source & position != 0 {
+            result |= bit;
+        }
+        bit <<= 1;
+        positions &= positions - 1;
+    }
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn hex(value: &str) -> Vec<u8> {
+        value
+            .as_bytes()
+            .chunks_exact(2)
+            .map(|pair| {
+                let digit = |byte: u8| match byte {
+                    b'0'..=b'9' => byte - b'0',
+                    b'a'..=b'f' => byte - b'a' + 10,
+                    _ => panic!("invalid vector"),
+                };
+                digit(pair[0]) * 16 + digit(pair[1])
+            })
+            .collect()
+    }
+
+    #[test]
+    fn mieru_low_entropy_independent_bit_position_vectors() {
+        // Independently enumerated bit positions, including partial source
+        // chunks and a rotated 40-bit mask. These are ciphertext-body inputs.
+        for (input, mode, mask, rotation, expected) in [
+            (
+                "12345678",
+                1,
+                0x0f0f0f0f,
+                0,
+                ["0102030405060708", "f1f2f3f4f5f6f7f8"],
+            ),
+            (
+                "123456",
+                1,
+                0x0f0f0f0f,
+                0,
+                ["0000010203040506", "fffff1f2f3f4f5f6"],
+            ),
+            (
+                "001122334455667788",
+                2,
+                0x00fffff0,
+                3,
+                [
+                    "000011200023344000000aac000cef10",
+                    "ff00112fff23344fffffeaadffecef11",
+                ],
+            ),
+        ] {
+            let source = hex(input);
+            for padding_bit in 0..=1 {
+                let encoding = LowEntropyEncoding {
+                    mode,
+                    half_mask: mask,
+                    rotation,
+                    padding_bit,
+                };
+                let mut body = vec![0; encoding.encoded_len(source.len()).unwrap()];
+                body[..source.len()].copy_from_slice(&source);
+                encoding.expand(&mut body, source.len()).unwrap();
+                assert_eq!(body, hex(expected[usize::from(padding_bit)]));
+                encoding.compact(&mut body, source.len()).unwrap();
+                assert_eq!(&body[..source.len()], source);
+            }
+        }
+    }
+
+    #[test]
+    fn mieru_low_entropy_rejects_nonuniform_padding_and_keeps_wire_bounds() {
+        let encoding = LowEntropyEncoding {
+            mode: 1,
+            half_mask: 0x0f0f0f0f,
+            rotation: 16,
+            padding_bit: 0,
+        };
+        let mut body = vec![0; encoding.encoded_len(7).unwrap()];
+        body[..7].copy_from_slice(b"example");
+        encoding.expand(&mut body, 7).unwrap();
+        let mask = encoding.mask(1);
+        let unused = !deposit((1u64 << 24) - 1, mask);
+        let position = unused & unused.wrapping_neg();
+        let word = u64::from_be_bytes(body[8..16].try_into().unwrap()) | position;
+        body[8..16].copy_from_slice(&word.to_be_bytes());
+        assert!(encoding.compact(&mut body, 7).is_err());
+        assert_eq!(encoding.encoded_len(32764).unwrap(), 65528);
+        assert!(encoding.encoded_len(32765).is_err());
+        assert!(
+            LowEntropyEncoding {
+                rotation: 17,
+                ..encoding
+            }
+            .encoded_len(1)
+            .is_err()
+        );
+        assert!(
+            LowEntropyEncoding {
+                half_mask: 1,
+                ..encoding
+            }
+            .encoded_len(1)
+            .is_err()
+        );
+    }
+    // Frozen pre-plan codec bodies from 17eb, using the unchanged private
+    // per-bit deposit/extract oracle. Test-only: never a runtime second codec.
+    fn bit_oracle_expand(
+        e: LowEntropyEncoding,
+        body: &mut [u8],
+        source_len: usize,
+    ) -> io::Result<()> {
+        let encoded_len = e.encoded_len(source_len)?;
+        if body.len() != encoded_len {
+            return Err(invalid());
+        }
+        let count = e.source_bytes()?;
+        for chunk in (0..source_len.div_ceil(count)).rev() {
+            let offset = chunk * count;
+            let len = (source_len - offset).min(count);
+            let source = body[offset..offset + len]
+                .iter()
+                .fold(0u64, |word, byte| word << 8 | u64::from(*byte));
+            let mask = e.mask(chunk);
+            let mut encoded = deposit(source, mask);
+            if e.padding_bit == 1 {
+                // A partial final source chunk has fewer data bits than its
+                // mask. Those remaining positions are uniform padding too.
+                let data_mask = if len == count {
+                    mask
+                } else {
+                    deposit((1u64 << (len * 8)) - 1, mask)
+                };
+                encoded |= !data_mask;
+            }
+            body[chunk * 8..chunk * 8 + 8].copy_from_slice(&encoded.to_be_bytes());
+        }
+        Ok(())
+    }
+    fn bit_oracle_compact(
+        e: LowEntropyEncoding,
+        body: &mut [u8],
+        source_len: usize,
+    ) -> io::Result<()> {
+        if body.len() != e.encoded_len(source_len)? {
+            return Err(invalid());
+        }
+        let count = e.source_bytes()?;
+        let mut polarity = None;
+        for chunk in 0..source_len.div_ceil(count) {
+            let offset = chunk * count;
+            let len = (source_len - offset).min(count);
+            let word = u64::from_be_bytes(body[chunk * 8..chunk * 8 + 8].try_into().unwrap());
+            let mask = e.mask(chunk);
+            let data_mask = if len == count {
+                mask
+            } else {
+                deposit((1u64 << (len * 8)) - 1, mask)
+            };
+            let padding_mask = !data_mask;
+            let padding = word & padding_mask;
+            let bit = if padding == 0 {
+                false
+            } else if padding == padding_mask {
+                true
+            } else {
+                return Err(invalid());
+            };
+            if polarity.is_some_and(|previous| previous != bit) {
+                return Err(invalid());
+            }
+            polarity = Some(bit);
+            let decoded = extract(word, mask).to_be_bytes();
+            body[offset..offset + len].copy_from_slice(&decoded[8 - len..]);
+        }
+        Ok(())
+    }
+
+    fn planned_test_next(state: &mut u64) -> u64 {
+        *state ^= *state << 13;
+        *state ^= *state >> 7;
+        *state ^= *state << 17;
+        *state
+    }
+    fn planned_test_payload(len: usize, salt: u64) -> Vec<u8> {
+        let mut state = salt | 1;
+        (0..len)
+            .map(|_| planned_test_next(&mut state) as u8)
+            .collect()
+    }
+    fn planned_test_masks(mode: u8) -> Vec<u32> {
+        let ones = (u32::from(mode) + 3) * 4;
+        let low = (1u32 << ones) - 1;
+        let mut masks = vec![low, low << (32 - ones)];
+        let mut spread = 0;
+        for i in 0..ones {
+            spread |= 1u32 << ((i * 17) & 31);
+        }
+        masks.push(spread);
+        let mut state = 0x9e37_79b9_7f4a_7c15u64 ^ u64::from(mode);
+        for _ in 0..8 {
+            let mut order = [0u8; 32];
+            for (i, bit) in order.iter_mut().enumerate() {
+                *bit = i as u8;
+            }
+            for i in (1..order.len()).rev() {
+                let other = planned_test_next(&mut state) as usize % (i + 1);
+                order.swap(i, other);
+            }
+            masks.push(
+                order[..ones as usize]
+                    .iter()
+                    .fold(0u32, |mask, bit| mask | (1u32 << u32::from(*bit))),
+            );
+        }
+        masks.sort_unstable();
+        masks.dedup();
+        masks
+    }
+    fn planned_test_rotations() -> Vec<u8> {
+        (0..=15).chain((1..=15).map(|r| r * 16)).collect()
+    }
+    fn planned_test_compare(e: LowEntropyEncoding, source: &[u8]) {
+        let mut original = vec![0u8; e.encoded_len(source.len()).unwrap()];
+        original[..source.len()].copy_from_slice(source);
+        let mut planned = original.clone();
+        bit_oracle_expand(e, &mut original, source.len()).unwrap();
+        e.expand(&mut planned, source.len()).unwrap();
+        assert_eq!(
+            planned,
+            original,
+            "mode={} rotation={} pad={} bytes={}",
+            e.mode,
+            e.rotation,
+            e.padding_bit,
+            source.len()
+        );
+        // Cross-decode, so a matching encoder/decoder defect cannot self-hide.
+        bit_oracle_compact(e, &mut planned, source.len()).unwrap();
+        e.compact(&mut original, source.len()).unwrap();
+        assert_eq!(&planned[..source.len()], source);
+        assert_eq!(&original[..source.len()], source);
+    }
+
+    #[test]
+    fn mieru_low_entropy_planned_codec_matches_bit_oracle_across_modes_masks_rotations() {
+        for mode in 1..=4 {
+            let count = usize::from(mode) + 3;
+            for half_mask in planned_test_masks(mode) {
+                for rotation in planned_test_rotations() {
+                    for padding_bit in 0..=1 {
+                        let encoding = LowEntropyEncoding {
+                            mode,
+                            half_mask,
+                            rotation,
+                            padding_bit,
+                        };
+                        // Cover all 32 phases and the repeat with real frame APIs.
+                        planned_test_compare(
+                            encoding,
+                            &planned_test_payload(count * 33, u64::from(half_mask)),
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn mieru_low_entropy_plan_threshold_partial_and_protocol_boundaries() {
+        for mode in 1..=4 {
+            let count = usize::from(mode) + 3;
+            let half_mask = ((1u32 << ((u32::from(mode) + 3) * 4)) - 1).rotate_left(11);
+            for rotation in planned_test_rotations() {
+                for padding_bit in 0..=1 {
+                    let encoding = LowEntropyEncoding {
+                        mode,
+                        half_mask,
+                        rotation,
+                        padding_bit,
+                    };
+                    for len in 0..=PLANNED_SOURCE_MIN + count {
+                        planned_test_compare(encoding, &planned_test_payload(len, len as u64 + 5));
+                    }
+                    for tail in 0..count {
+                        let len = count * 32 + tail;
+                        planned_test_compare(encoding, &planned_test_payload(len, tail as u64 + 9));
+                    }
+                }
+            }
+            let limit = if mode == 1 { 32764 } else { MAX_DATA_PAYLOAD };
+            for rotation in [0, 7, 16, 240] {
+                for padding_bit in 0..=1 {
+                    let encoding = LowEntropyEncoding {
+                        mode,
+                        half_mask,
+                        rotation,
+                        padding_bit,
+                    };
+                    for len in [limit - 1, limit] {
+                        planned_test_compare(encoding, &planned_test_payload(len, len as u64));
+                    }
+                    for len in [limit + 1, MAX_DATA_PAYLOAD + 1] {
+                        assert!(encoding.expand(&mut [], len).is_err());
+                        assert!(encoding.compact(&mut [], len).is_err());
+                    }
+                }
+            }
+        }
+        let valid = LowEntropyEncoding {
+            mode: 1,
+            half_mask: 0x0f0f0f0f,
+            rotation: 7,
+            padding_bit: 0,
+        };
+        for invalid in [
+            LowEntropyEncoding { mode: 0, ..valid },
+            LowEntropyEncoding { mode: 5, ..valid },
+            LowEntropyEncoding {
+                half_mask: 1,
+                ..valid
+            },
+            LowEntropyEncoding {
+                rotation: 17,
+                ..valid
+            },
+            LowEntropyEncoding {
+                rotation: 255,
+                ..valid
+            },
+            LowEntropyEncoding {
+                padding_bit: 2,
+                ..valid
+            },
+        ] {
+            for len in [0, 1, 31, 32, 33] {
+                assert!(invalid.expand(&mut [], len).is_err());
+                assert!(invalid.compact(&mut [], len).is_err());
+            }
+        }
+        for len in [31, 32, 33] {
+            let exact = valid.encoded_len(len).unwrap();
+            for malformed in [exact - 1, exact + 1] {
+                assert!(valid.expand(&mut vec![0; malformed], len).is_err());
+                assert!(valid.compact(&mut vec![0; malformed], len).is_err());
+            }
+        }
+    }
+
+    #[test]
+    fn mieru_low_entropy_planned_padding_rejects_every_nondata_bit() {
+        for mode in 1..=4 {
+            let count = usize::from(mode) + 3;
+            let half_mask = ((1u32 << ((u32::from(mode) + 3) * 4)) - 1).rotate_left(11);
+            for rotation in planned_test_rotations() {
+                for padding_bit in 0..=1 {
+                    let encoding = LowEntropyEncoding {
+                        mode,
+                        half_mask,
+                        rotation,
+                        padding_bit,
+                    };
+                    let len = count * 32 + 1;
+                    let mut good = vec![0; encoding.encoded_len(len).unwrap()];
+                    good[..len].copy_from_slice(&planned_test_payload(len, 91));
+                    bit_oracle_expand(encoding, &mut good, len).unwrap();
+                    for chunk in [0usize, 31, 32] {
+                        let data_len = if chunk == 32 { 1 } else { count };
+                        // Unchanged per-bit oracle defines every actual data position.
+                        let data_mask = deposit((1u64 << (data_len * 8)) - 1, encoding.mask(chunk));
+                        let offset = chunk * 8;
+                        let original_word =
+                            u64::from_be_bytes(good[offset..offset + 8].try_into().unwrap());
+                        for bit in 0..64 {
+                            if data_mask & (1u64 << bit) != 0 {
+                                continue;
+                            }
+                            let mut bad = good.clone();
+                            bad[offset..offset + 8]
+                                .copy_from_slice(&(original_word ^ (1u64 << bit)).to_be_bytes());
+                            assert!(bit_oracle_compact(encoding, &mut bad.clone(), len).is_err());
+                            assert!(encoding.compact(&mut bad, len).is_err());
+                        }
+                        // An internally uniform later chunk still cannot change frame polarity.
+                        if chunk != 0 {
+                            let mut bad = good.clone();
+                            bad[offset..offset + 8]
+                                .copy_from_slice(&(original_word ^ !data_mask).to_be_bytes());
+                            assert!(bit_oracle_compact(encoding, &mut bad.clone(), len).is_err());
+                            assert!(encoding.compact(&mut bad, len).is_err());
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn mieru_low_entropy_planned_codec_independent_golden_vectors() {
+        for padding_bit in 0..=1 {
+            let encoding = LowEntropyEncoding {
+                mode: 1,
+                half_mask: 0x0f0f0f0f,
+                rotation: 0,
+                padding_bit,
+            };
+            let mut source = hex("12345678").repeat(8);
+            let full = if padding_bit == 0 {
+                "0102030405060708"
+            } else {
+                "f1f2f3f4f5f6f7f8"
+            };
+            let mut expected = hex(full).repeat(8);
+            // Both threshold/full and a partial tail are independently enumerated.
+            for tail in [false, true] {
+                if tail {
+                    source.push(0x12);
+                    expected.extend(hex(if padding_bit == 0 {
+                        "0000000000000102"
+                    } else {
+                        "fffffffffffff1f2"
+                    }));
+                }
+                let mut body = vec![0; encoding.encoded_len(source.len()).unwrap()];
+                body[..source.len()].copy_from_slice(&source);
+                encoding.expand(&mut body, source.len()).unwrap();
+                assert_eq!(body, expected);
+                encoding.compact(&mut body, source.len()).unwrap();
+                assert_eq!(&body[..source.len()], &source);
+            }
+            // Existing rotated40 golden is placed after one full phase cycle.
+            let encoding = LowEntropyEncoding {
+                mode: 2,
+                half_mask: 0x00fffff0,
+                rotation: 3,
+                padding_bit,
+            };
+            let mut source = vec![0; 5 * 32];
+            source.extend(hex("001122334455667788"));
+            let mut expected = Vec::new();
+            let base = u64::from(encoding.half_mask) * 0x1_0000_0001;
+            for chunk in 0..32 {
+                let word = if padding_bit == 0 {
+                    0
+                } else {
+                    !base.rotate_right(chunk * 3)
+                };
+                expected.extend_from_slice(&word.to_be_bytes());
+            }
+            expected.extend(hex(if padding_bit == 0 {
+                "000011200023344000000aac000cef10"
+            } else {
+                "ff00112fff23344fffffeaadffecef11"
+            }));
+            let mut body = vec![0; encoding.encoded_len(source.len()).unwrap()];
+            body[..source.len()].copy_from_slice(&source);
+            encoding.expand(&mut body, source.len()).unwrap();
+            assert_eq!(body, expected);
+            encoding.compact(&mut body, source.len()).unwrap();
+            assert_eq!(&body[..source.len()], &source);
+        }
+    }
+
+    #[cfg(all(
+        target_arch = "aarch64",
+        target_feature = "neon",
+        target_endian = "little"
+    ))]
+    #[test]
+    fn mieru_low_entropy_neon_expand_pairs_tails_unaligned_canaries_match_frozen_oracle() {
+        for mode in 1..=4 {
+            let count = usize::from(mode) + 3;
+            let half_mask = ((1u32 << ((u32::from(mode) + 3) * 4)) - 1).rotate_left(11);
+            for rotation in planned_test_rotations() {
+                for padding_bit in 0..=1 {
+                    let encoding = LowEntropyEncoding {
+                        mode,
+                        half_mask,
+                        rotation,
+                        padding_bit,
+                    };
+                    // Threshold, odd/even pairs and the phase31->0 pair boundary.
+                    for full_chunks in [8usize, 9, 31, 32, 33, 34] {
+                        for tail in 0..count {
+                            let len = full_chunks * count + tail;
+                            let encoded_len = encoding.encoded_len(len).unwrap();
+                            let source = planned_test_payload(
+                                len,
+                                (u64::from(mode) << 48)
+                                    ^ ((full_chunks as u64) << 24)
+                                    ^ ((tail as u64) << 8)
+                                    ^ u64::from(rotation),
+                            );
+                            for residue in [1usize, 3, 7] {
+                                let mut actual = vec![0xa5; encoded_len + 32];
+                                let start = (1..=16)
+                                    .find(|offset| {
+                                        (actual.as_ptr() as usize + *offset) & 15 == residue
+                                    })
+                                    .unwrap();
+                                assert_eq!((actual.as_ptr() as usize + start) & 15, residue);
+                                let end = start + encoded_len;
+                                actual[start..start + len].copy_from_slice(&source);
+                                let mut expected = actual.clone();
+                                bit_oracle_expand(encoding, &mut expected[start..end], len)
+                                    .unwrap();
+                                encoding.expand(&mut actual[start..end], len).unwrap();
+                                assert_eq!(
+                                    actual, expected,
+                                    "mode={mode} rotation={rotation} pad={padding_bit} chunks={full_chunks} tail={tail} residue={residue}"
+                                );
+                                assert!(actual[..start].iter().all(|byte| *byte == 0xa5));
+                                assert!(actual[end..].iter().all(|byte| *byte == 0xa5));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn mieru_low_entropy_plan_stays_stack_bounded() {
+        assert!(std::mem::size_of::<PackingPlan>() <= 100);
+        assert!(std::mem::size_of::<Option<PackingPlan>>() <= 112);
+    }
+}
diff --git a/src/outbound/mieru/mod.rs b/src/outbound/mieru/mod.rs
new file mode 100644
index 0000000..72a2c62
--- /dev/null
+++ b/src/outbound/mieru/mod.rs
@@ -0,0 +1,141 @@
+//! Native Mieru client. Carriers use only the shared configured upstream path.
+mod crypto;
+mod low_entropy;
+mod packet;
+pub(crate) mod pattern;
+mod reliability;
+mod stream;
+mod tcp;
+mod udp;
+mod wire;
+use crate::{
+    config::{MieruHandshake, MieruOutboundConfig},
+    dispatch::{BoxStream, DatagramTransport, DispatchError},
+    outbound::{
+        ConnectedStream, DatagramRequest, EstablishContext, OutboundConnector, UpstreamPath,
+    },
+    session::{Destination, StreamSession},
+};
+use async_trait::async_trait;
+use std::{
+    io,
+    net::{Ipv4Addr, SocketAddr},
+};
+
+pub struct MieruOutbound {
+    client: tcp::Client,
+    udp: bool,
+    handshake: MieruHandshake,
+}
+impl std::fmt::Debug for MieruOutbound {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("MieruOutbound")
+            .field("udp", &self.udp)
+            .finish_non_exhaustive()
+    }
+}
+impl MieruOutbound {
+    pub fn new(
+        config: &MieruOutboundConfig,
+        upstream: UpstreamPath,
+        stream_buffer_capacity: usize,
+    ) -> io::Result<Self> {
+        Ok(Self {
+            client: tcp::Client::new(config, upstream, stream_buffer_capacity)?,
+            udp: config.udp,
+            handshake: config.handshake_mode,
+        })
+    }
+    async fn connect(
+        &self,
+        session: StreamSession,
+        business: tcp::Business,
+        datagram_receive_budget: Option<u16>,
+        context: &EstablishContext,
+    ) -> io::Result<BoxStream> {
+        let target = session.destination.clone();
+        let raw = self
+            .client
+            .open(session, business, datagram_receive_budget, context)
+            .await?;
+        let command = business.command();
+        let stream: BoxStream = match self.handshake {
+            MieruHandshake::Standard => {
+                Box::new(stream::Stream::standard(raw, &target, command, context.deadline()).await?)
+            }
+            MieruHandshake::NoWait => Box::new(stream::Stream::no_wait(raw, &target, command)?),
+        };
+        Ok(stream)
+    }
+}
+#[async_trait]
+impl OutboundConnector for MieruOutbound {
+    async fn connect_stream(
+        &self,
+        session: StreamSession,
+        context: &EstablishContext,
+    ) -> Result<ConnectedStream, DispatchError> {
+        let target = session.destination.clone();
+        let io = context
+            .run_io(
+                "Mieru business connection",
+                self.connect(session, tcp::Business::TcpConnect, None, context),
+            )
+            .await?;
+        Ok(ConnectedStream {
+            io,
+            effective_peer: target,
+        })
+    }
+    async fn open_datagram(
+        &self,
+        request: DatagramRequest,
+        context: &EstablishContext,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        if !self.udp {
+            return Err(DispatchError::NotAllowed);
+        }
+        // The official UDP associate server ignores this target. Each packet
+        // supplies its own destination inside the shared SOCKS UDP envelope.
+        let session = StreamSession {
+            metadata: request.session.metadata.clone(),
+            inbound: request.session.inbound,
+            source: request.session.source,
+            destination: Destination::Ip(SocketAddr::from((Ipv4Addr::UNSPECIFIED, 0))),
+            sniffed_domain: None,
+        };
+        let io = context
+            .run_io(
+                "Mieru UDP associate",
+                self.connect(
+                    session,
+                    tcp::Business::UdpAssociate,
+                    Some(request.budget().receive()),
+                    context,
+                ),
+            )
+            .await?;
+        let transport = packet::PacketTransport::new(
+            io,
+            &request,
+            context,
+            self.client.cancellation(),
+            |reader| self.client.spawn(reader),
+        )?
+        .with_queued_sends(self.client.queues_datagrams());
+        Ok(crate::dispatch::bound_datagram(
+            Box::new(transport),
+            request.budget(),
+        ))
+    }
+    fn begin_shutdown(&self) {
+        self.client.begin_shutdown();
+    }
+    async fn shutdown(&self) {
+        self.client.shutdown().await;
+    }
+}
+#[cfg(test)]
+mod packet_routing_tests;
+#[cfg(test)]
+mod tests;
diff --git a/src/outbound/mieru/packet.rs b/src/outbound/mieru/packet.rs
new file mode 100644
index 0000000..6477842
--- /dev/null
+++ b/src/outbound/mieru/packet.rs
@@ -0,0 +1,267 @@
+//! SOCKS UDP datagrams carried inside Mieru's packet-over-stream envelope.
+use crate::{
+    dispatch::{BoxStream, DatagramBudget, DatagramTransport, DispatchError},
+    dns::resolution::ResolutionContext,
+    outbound::{DEFAULT_ESTABLISH_TIMEOUT, DatagramRequest, EstablishContext},
+    resources::observation::{self, ResourceKind},
+    session::{Datagram, Destination},
+    socks5,
+};
+use async_trait::async_trait;
+use bytes::Bytes;
+use futures_util::future::BoxFuture;
+use std::{
+    io,
+    sync::{
+        Arc,
+        atomic::{AtomicBool, Ordering},
+    },
+    task::{Context, Poll},
+};
+use tokio::{
+    io::{AsyncRead, AsyncReadExt, AsyncWriteExt, WriteHalf},
+    task::JoinHandle,
+    time::Instant,
+};
+use tokio_util::sync::CancellationToken;
+
+#[path = "packet_response.rs"]
+mod response_slot;
+
+pub(super) struct PacketTransport {
+    writer: Option<WriteHalf<BoxStream>>,
+    responses: response_slot::Receiver<io::Result<Datagram>>,
+    cancel: CancellationToken,
+    reader: Option<JoinHandle<()>>,
+    alive: Arc<AtomicBool>,
+    resolution: ResolutionContext,
+    budget: DatagramBudget,
+    closed: bool,
+    flush_packets: bool,
+    _observation: observation::Guard,
+}
+impl PacketTransport {
+    pub fn new<F>(
+        io: BoxStream,
+        request: &DatagramRequest,
+        context: &EstablishContext,
+        parent: CancellationToken,
+        spawn: F,
+    ) -> io::Result<Self>
+    where
+        F: FnOnce(BoxFuture<'static, ()>) -> io::Result<JoinHandle<()>>,
+    {
+        if parent.is_cancelled() {
+            return Err(io::ErrorKind::ConnectionAborted.into());
+        }
+        let cancel = parent.child_token();
+        let (read, writer) = tokio::io::split(io);
+        let (send, responses) = response_slot::channel();
+        let alive = Arc::new(AtomicBool::new(true));
+        let life = ReaderLife(alive.clone());
+        let reader = spawn(Box::pin(read_loop(
+            read,
+            send,
+            request.budget().receive(),
+            cancel.clone(),
+            life,
+        )))?;
+        Ok(Self {
+            writer: Some(writer),
+            responses,
+            cancel,
+            reader: Some(reader),
+            alive,
+            resolution: context.resolution(),
+            budget: request.budget(),
+            closed: false,
+            flush_packets: true,
+            _observation: observation::track(ResourceKind::Association),
+        })
+    }
+    pub(super) fn with_queued_sends(mut self, queued: bool) -> Self {
+        self.flush_packets = !queued;
+        self
+    }
+    fn poll_response(
+        &mut self,
+        context: &mut Context<'_>,
+    ) -> Poll<Result<Datagram, DispatchError>> {
+        if self.closed || self.cancel.is_cancelled() {
+            return Poll::Ready(Err(DispatchError::NotAllowed));
+        }
+        // The reader owns the sole sender. Parent cancellation stops that reader,
+        // whose sender drop wakes poll_recv; no receive-side cancellation future
+        // or additional queue is needed. Keep queued codec errors after reader
+        // exit: alive is a send gate, not permission to discard a final response.
+        match self.responses.poll_recv(context) {
+            Poll::Pending => Poll::Pending,
+            Poll::Ready(Some(result)) => Poll::Ready(result.map_err(DispatchError::from)),
+            Poll::Ready(None) => {
+                Poll::Ready(Err(io::Error::from(io::ErrorKind::UnexpectedEof).into()))
+            }
+        }
+    }
+    fn check(&self) -> Result<(), DispatchError> {
+        if self.closed || self.cancel.is_cancelled() || !self.alive.load(Ordering::Acquire) {
+            Err(DispatchError::NotAllowed)
+        } else {
+            Ok(())
+        }
+    }
+}
+struct ReaderLife(Arc<AtomicBool>);
+impl Drop for ReaderLife {
+    fn drop(&mut self) {
+        self.0.store(false, Ordering::Release);
+    }
+}
+struct SendGuard<'a> {
+    writer: &'a mut Option<WriteHalf<BoxStream>>,
+    cancel: CancellationToken,
+    committed: bool,
+}
+impl Drop for SendGuard<'_> {
+    fn drop(&mut self) {
+        if !self.committed {
+            self.cancel.cancel();
+            self.writer.take();
+        }
+    }
+}
+#[async_trait]
+impl DatagramTransport for PacketTransport {
+    fn supports_shared_destinations(&self) -> bool {
+        // Every packet carries its own SOCKS address inside the associate stream.
+        true
+    }
+
+    fn payload_budget(&self, remote: &Destination) -> DatagramBudget {
+        let overhead = 3 + socks5::encoded_address_size(remote)
+            .unwrap_or(usize::from(socks5::MAX_UDP_HEADER_SIZE));
+        let transmit = usize::from(self.budget.transmit())
+            .min(usize::from(u16::MAX).saturating_sub(overhead)) as u16;
+        DatagramBudget::new(transmit, self.budget.receive())
+    }
+    async fn send(&mut self, datagram: Datagram) -> Result<(), DispatchError> {
+        self.check()?;
+        if datagram.payload.len() > usize::from(self.payload_budget(&datagram.remote).transmit()) {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Mieru UDP payload exceeds send budget",
+            )
+            .into());
+        }
+        let remote = tokio::select! {biased;()=self.cancel.cancelled()=>return Err(DispatchError::NotAllowed),result=self.resolution.resolve_ip(&datagram.remote,Instant::now()+DEFAULT_ESTABLISH_TIMEOUT)=>result?};
+        let body = socks5::encode_udp_packet(
+            &Destination::Ip(remote),
+            &datagram.payload,
+            usize::from(u16::MAX),
+        )
+        .map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "invalid Mieru UDP packet"))?;
+        let mut packet = Vec::with_capacity(body.len() + 4);
+        packet.push(0);
+        packet.extend_from_slice(&(body.len() as u16).to_be_bytes());
+        packet.extend_from_slice(&body);
+        packet.push(255);
+        let flush_packets = self.flush_packets;
+        let mut guard = SendGuard {
+            writer: &mut self.writer,
+            cancel: self.cancel.clone(),
+            committed: false,
+        };
+        tokio::select! {biased;()=guard.cancel.cancelled()=>return Err(DispatchError::NotAllowed),result=async {let writer=guard.writer.as_mut().ok_or(io::ErrorKind::BrokenPipe)?;writer.write_all(&packet).await?;if flush_packets {writer.flush().await}else{Ok(())}}=>result?};
+        guard.committed = true;
+        Ok(())
+    }
+    fn supports_poll_receive(&self) -> bool {
+        true
+    }
+    fn poll_receive(
+        &mut self,
+        context: &mut Context<'_>,
+        _scratch: &mut Vec<u8>,
+    ) -> Poll<Result<Datagram, DispatchError>> {
+        self.poll_response(context)
+    }
+    async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+        std::future::poll_fn(|context| self.poll_response(context)).await
+    }
+    async fn close(&mut self) -> Result<(), DispatchError> {
+        self.closed = true;
+        self.cancel.cancel();
+        self.writer.take();
+        self.responses.close();
+        if let Some(reader) = self.reader.take() {
+            reader
+                .await
+                .map_err(|_| io::Error::other("Mieru UDP reader stopped"))?;
+        }
+        Ok(())
+    }
+}
+impl Drop for PacketTransport {
+    fn drop(&mut self) {
+        self.cancel.cancel();
+        self.writer.take();
+        if let Some(reader) = self.reader.take() {
+            reader.abort();
+        }
+    }
+}
+async fn read_loop<R: AsyncRead + Unpin>(
+    mut reader: R,
+    mut send: response_slot::Sender<io::Result<Datagram>>,
+    maximum: u16,
+    cancel: CancellationToken,
+    _life: ReaderLife,
+) {
+    let reading = async {
+        loop {
+            let response = read_packet(&mut reader, maximum).await;
+            let failed = response.is_err();
+            if send.send(response).await.is_err() || failed {
+                break;
+            }
+        }
+    };
+    tokio::select! {biased;()=cancel.cancelled()=>{},()=reading=>{}}
+}
+async fn read_packet<R: AsyncRead + Unpin>(reader: &mut R, maximum: u16) -> io::Result<Datagram> {
+    if reader.read_u8().await? != 0 {
+        return Err(io::ErrorKind::InvalidData.into());
+    }
+    let length = reader.read_u16().await? as usize;
+    let max_wire = (usize::from(maximum) + usize::from(socks5::MAX_UDP_HEADER_SIZE))
+        .min(usize::from(u16::MAX));
+    if length > max_wire {
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidData,
+            "Mieru UDP response exceeds receive budget",
+        ));
+    }
+    let mut body = vec![0; length];
+    reader.read_exact(&mut body).await?;
+    if reader.read_u8().await? != 255 {
+        return Err(io::ErrorKind::InvalidData.into());
+    }
+    let (remote, payload) = socks5::decode_udp_packet(&body, max_wire)
+        .map_err(|_| io::Error::new(io::ErrorKind::InvalidData, "invalid Mieru UDP response"))?;
+    if payload.len() > usize::from(maximum) {
+        return Err(io::ErrorKind::InvalidData.into());
+    }
+    let payload_offset = body.len() - payload.len();
+    Ok(Datagram {
+        remote,
+        payload: Bytes::from(body).slice(payload_offset..),
+        sniffed_domain: None,
+    })
+}
+
+#[cfg(test)]
+#[path = "packet_poll_tests.rs"]
+mod poll_tests;
+
+#[cfg(test)]
+#[path = "packet_decode_memory_tests.rs"]
+mod decode_memory_tests;
diff --git a/src/outbound/mieru/packet_decode_memory_tests.rs b/src/outbound/mieru/packet_decode_memory_tests.rs
new file mode 100644
index 0000000..db4087f
--- /dev/null
+++ b/src/outbound/mieru/packet_decode_memory_tests.rs
@@ -0,0 +1,52 @@
+//! Observe the production parser's destination buffer without opening I/O.
+use super::*;
+use std::{pin::Pin, sync::atomic::AtomicUsize};
+use tokio::io::ReadBuf;
+
+struct BodyRead<'a> {
+    wire: &'a [u8],
+    body_length: usize,
+    address: Arc<AtomicUsize>,
+}
+impl AsyncRead for BodyRead<'_> {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buffer: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        let this = self.get_mut();
+        if buffer.remaining() == this.body_length {
+            this.address
+                .store(buffer.filled().as_ptr() as usize, Ordering::SeqCst);
+        }
+        Pin::new(&mut this.wire).poll_read(cx, buffer)
+    }
+}
+
+#[tokio::test]
+async fn mieru_packet_payload_reuses_the_receive_allocation() {
+    let remote = Destination::Ip("198.51.100.1:53".parse().unwrap());
+    let body = socks5::encode_udp_packet(&remote, &[7; 1200], usize::from(u16::MAX)).unwrap();
+    let mut frame = vec![0];
+    frame.extend_from_slice(&(body.len() as u16).to_be_bytes());
+    frame.extend_from_slice(&body);
+    frame.push(255);
+    let address = Arc::new(AtomicUsize::new(0));
+    let mut input = BodyRead {
+        wire: &frame,
+        body_length: body.len(),
+        address: address.clone(),
+    };
+    let packet = read_packet(&mut input, 1452).await.unwrap();
+    let body_address = address.load(Ordering::SeqCst);
+    drop(input);
+    drop(frame);
+    assert_eq!(packet.remote, remote);
+    assert_eq!(packet.payload.as_ref(), &[7; 1200]);
+    assert_ne!(body_address, 0);
+    assert_eq!(
+        packet.payload.as_ptr() as usize,
+        body_address + 10,
+        "parser duplicates the received payload allocation"
+    );
+}
diff --git a/src/outbound/mieru/packet_poll_tests.rs b/src/outbound/mieru/packet_poll_tests.rs
new file mode 100644
index 0000000..da777a2
--- /dev/null
+++ b/src/outbound/mieru/packet_poll_tests.rs
@@ -0,0 +1,228 @@
+//! Actual packet parser/channel boundaries; no sockets or duplicate receive queue.
+use super::*;
+use crate::{resources::observation::ResourceProbe, session::DatagramSession};
+use futures_util::task::{ArcWake, waker};
+use std::{future::Future, sync::atomic::AtomicUsize, time::Duration};
+use tokio::io::DuplexStream;
+use tokio_util::task::TaskTracker;
+
+#[derive(Default)]
+struct WakeCount(AtomicUsize);
+impl ArcWake for WakeCount {
+    fn wake_by_ref(owner: &Arc<Self>) {
+        owner.0.fetch_add(1, Ordering::Relaxed);
+    }
+}
+
+fn memory_packet() -> (
+    PacketTransport,
+    DuplexStream,
+    CancellationToken,
+    TaskTracker,
+) {
+    let (client, peer) = tokio::io::duplex(128);
+    let parent = CancellationToken::new();
+    let tasks = TaskTracker::new();
+    let request = DatagramRequest::new(DatagramSession::for_tun(
+        "192.0.2.10:1000".parse().unwrap(),
+        1500,
+    ));
+    let context = EstablishContext::with_timeout(Duration::from_secs(1));
+    let transport = PacketTransport::new(
+        Box::new(client),
+        &request,
+        &context,
+        parent.clone(),
+        |reader| Ok(tasks.spawn(observation::task(reader))),
+    )
+    .unwrap();
+    (transport, peer, parent, tasks)
+}
+
+async fn reader_finished(alive: &AtomicBool) {
+    tokio::time::timeout(Duration::from_secs(1), async {
+        while alive.load(Ordering::Acquire) {
+            tokio::task::yield_now().await;
+        }
+    })
+    .await
+    .unwrap();
+}
+
+async fn close(mut transport: PacketTransport, tasks: TaskTracker) {
+    transport.close().await.unwrap();
+    drop(transport);
+    tasks.close();
+    tasks.wait().await;
+}
+
+#[tokio::test]
+async fn mieru_packet_pending_terminal_error_survives_reader_exit() {
+    let probe = ResourceProbe::default();
+    let results = probe
+        .scope(async {
+            let mut results = Vec::new();
+            for asynchronous in [false, true] {
+                let (mut transport, mut peer, _parent, tasks) = memory_packet();
+                let alive = transport.alive.clone();
+                let wakes = Arc::new(WakeCount::default());
+                let wake = waker(wakes.clone());
+                let mut context = Context::from_waker(&wake);
+                let mut scratch = Vec::new();
+                let (pending, result) = if asynchronous {
+                    let receiving = transport.receive();
+                    tokio::pin!(receiving);
+                    let pending = receiving.as_mut().poll(&mut context).is_pending();
+                    peer.write_all(&[1]).await.unwrap(); // Invalid real frame prefix.
+                    reader_finished(&alive).await;
+                    (pending, Poll::Ready(receiving.await))
+                } else {
+                    let pending = transport
+                        .poll_receive(&mut context, &mut scratch)
+                        .is_pending();
+                    peer.write_all(&[1]).await.unwrap();
+                    reader_finished(&alive).await;
+                    let result = transport.poll_receive(&mut context, &mut scratch);
+                    (pending, result)
+                };
+                let notified = wakes.0.load(Ordering::Relaxed) > 0;
+                close(transport, tasks).await;
+                drop(peer);
+                results.push((pending, notified, result));
+            }
+            results
+        })
+        .await;
+    assert!(probe.snapshot().is_idle());
+    for (pending, notified, result) in results {
+        assert!(
+            pending,
+            "receive must actually register Pending before the bad frame"
+        );
+        assert!(
+            notified,
+            "the sole sender must wake its registered receiver"
+        );
+        assert!(
+            matches!(result, Poll::Ready(Err(DispatchError::Other(ref message)))
+            if message == &io::Error::from(io::ErrorKind::InvalidData).to_string()),
+            "alive=false must not hide the queued codec error"
+        );
+    }
+}
+
+#[tokio::test]
+async fn mieru_packet_pending_cancel_wakes_and_closed_or_cancelled_queues_do_not_deliver() {
+    let probe = ResourceProbe::default();
+    let results = probe
+        .scope(async {
+            let (mut transport, peer, parent, tasks) = memory_packet();
+            let alive = transport.alive.clone();
+            let wakes = Arc::new(WakeCount::default());
+            let wake = waker(wakes.clone());
+            let mut context = Context::from_waker(&wake);
+            let mut scratch = Vec::new();
+            let pending = transport
+                .poll_receive(&mut context, &mut scratch)
+                .is_pending();
+            parent.cancel();
+            reader_finished(&alive).await;
+            let notified = wakes.0.load(Ordering::Relaxed) > 0;
+            let cancelled = transport.poll_receive(&mut context, &mut scratch);
+            close(transport, tasks).await;
+            drop(peer);
+            let mut cached = Vec::new();
+            for cancel in [false, true] {
+                let (mut transport, mut peer, parent, tasks) = memory_packet();
+                let body = socks5::encode_udp_packet(
+                    &Destination::Ip("198.51.100.1:53".parse().unwrap()),
+                    b"buffered",
+                    usize::from(u16::MAX),
+                )
+                .unwrap();
+                let mut frame = vec![0];
+                frame.extend_from_slice(&(body.len() as u16).to_be_bytes());
+                frame.extend_from_slice(&body);
+                frame.push(255);
+                peer.write_all(&frame).await.unwrap();
+                tokio::time::timeout(Duration::from_secs(1), async {
+                    while transport.responses.is_empty() {
+                        tokio::task::yield_now().await;
+                    }
+                })
+                .await
+                .unwrap();
+                if cancel {
+                    parent.cancel();
+                } else {
+                    transport.close().await.unwrap();
+                }
+                let result = transport.poll_receive(&mut context, &mut scratch);
+                let asynchronous = transport.receive().await;
+                close(transport, tasks).await;
+                drop(peer);
+                cached.push((result, asynchronous));
+            }
+            (pending, notified, cancelled, cached)
+        })
+        .await;
+    assert!(probe.snapshot().is_idle());
+    assert!(
+        results.0 && results.1,
+        "parent cancellation must wake a real Pending receive"
+    );
+    assert!(matches!(
+        results.2,
+        Poll::Ready(Err(DispatchError::NotAllowed))
+    ));
+    for (polled, asynchronous) in results.3 {
+        assert!(matches!(
+            polled,
+            Poll::Ready(Err(DispatchError::NotAllowed))
+        ));
+        assert!(matches!(asynchronous, Err(DispatchError::NotAllowed)));
+    }
+}
+
+#[tokio::test]
+async fn mieru_packet_cancelled_partial_send_revokes_shared_stream_without_cancelling_parent() {
+    let probe = ResourceProbe::default();
+    tokio::time::timeout(
+        Duration::from_secs(2),
+        probe.scope(async {
+            let (client, mut peer) = tokio::io::duplex(1);
+            let parent = CancellationToken::new();
+            let tasks = TaskTracker::new();
+            let request = DatagramRequest::new(DatagramSession::for_tun(
+                "192.0.2.10:1000".parse().unwrap(),
+                1500,
+            ));
+            let mut transport = PacketTransport::new(
+                Box::new(client),
+                &request,
+                &EstablishContext::default(),
+                parent.clone(),
+                |reader| Ok(tasks.spawn(observation::task(reader))),
+            )
+            .unwrap();
+            let packet = Datagram {
+                remote: Destination::Ip("198.51.100.1:53".parse().unwrap()),
+                payload: Bytes::from_static(b"partially-written"),
+                sniffed_domain: None,
+            };
+            let mut sending = Box::pin(transport.send(packet.clone()));
+            assert!(futures_util::poll!(&mut sending).is_pending());
+            drop(sending);
+            let mut partial = Vec::new();
+            peer.read_to_end(&mut partial).await.unwrap();
+            assert_eq!(partial, vec![0]);
+            assert!(transport.send(packet).await.is_err());
+            assert!(transport.receive().await.is_err());
+            close(transport, tasks).await;
+            assert!(!parent.is_cancelled());
+        }),
+    )
+    .await
+    .expect("cancelled Mieru shared stream must release both halves");
+    assert!(probe.snapshot().is_idle());
+}
diff --git a/src/outbound/mieru/packet_response.rs b/src/outbound/mieru/packet_response.rs
new file mode 100644
index 0000000..443254a
--- /dev/null
+++ b/src/outbound/mieru/packet_response.rs
@@ -0,0 +1,131 @@
+//! The packet reader and transport each own one end of this one-response slot.
+use futures_util::task::AtomicWaker;
+use std::{
+    future::poll_fn,
+    sync::{Arc, Mutex},
+    task::{Context, Poll},
+};
+
+struct State<T> {
+    value: Option<T>,
+    sender_alive: bool,
+    receiver_alive: bool,
+}
+
+struct Shared<T> {
+    state: Mutex<State<T>>,
+    sender: AtomicWaker,
+    receiver: AtomicWaker,
+}
+
+// Neither endpoint is Clone; mutable methods serialize each direction's waker.
+pub(super) struct Sender<T>(Arc<Shared<T>>);
+pub(super) struct Receiver<T>(Arc<Shared<T>>);
+
+struct SendWait<'a>(&'a AtomicWaker);
+impl Drop for SendWait<'_> {
+    fn drop(&mut self) {
+        self.0.take();
+    }
+}
+
+pub(super) fn channel<T>() -> (Sender<T>, Receiver<T>) {
+    let shared = Arc::new(Shared {
+        state: Mutex::new(State {
+            value: None,
+            sender_alive: true,
+            receiver_alive: true,
+        }),
+        sender: AtomicWaker::new(),
+        receiver: AtomicWaker::new(),
+    });
+    (Sender(shared.clone()), Receiver(shared))
+}
+
+impl<T> Sender<T> {
+    pub(super) async fn send(&mut self, value: T) -> Result<(), T> {
+        let mut value = Some(value);
+        let _wait = SendWait(&self.0.sender);
+        poll_fn(|context| {
+            let mut registered = false;
+            loop {
+                let mut state = self.0.state.lock().unwrap();
+                if !state.receiver_alive {
+                    drop(state);
+                    return Poll::Ready(Err(value.take().unwrap()));
+                }
+                if state.value.is_none() {
+                    state.value = value.take();
+                    drop(state);
+                    self.0.receiver.wake();
+                    return Poll::Ready(Ok(()));
+                }
+                drop(state);
+                if registered {
+                    return Poll::Pending;
+                }
+                // Register only for a full slot, then recheck any concurrent take.
+                self.0.sender.register(context.waker());
+                registered = true;
+            }
+        })
+        .await
+    }
+}
+
+impl<T> Drop for Sender<T> {
+    fn drop(&mut self) {
+        self.0.state.lock().unwrap().sender_alive = false;
+        // A final packet or codec error remains available before EOF.
+        self.0.receiver.wake();
+    }
+}
+
+impl<T> Receiver<T> {
+    pub(super) fn poll_recv(&mut self, context: &mut Context<'_>) -> Poll<Option<T>> {
+        self.0.receiver.register(context.waker());
+        let mut state = self.0.state.lock().unwrap();
+        if !state.receiver_alive {
+            return Poll::Ready(None);
+        }
+        if let Some(value) = state.value.take() {
+            drop(state);
+            self.0.sender.wake();
+            return Poll::Ready(Some(value));
+        }
+        if state.sender_alive {
+            Poll::Pending
+        } else {
+            Poll::Ready(None)
+        }
+    }
+
+    pub(super) fn close(&mut self) {
+        let queued = {
+            let mut state = self.0.state.lock().unwrap();
+            if !state.receiver_alive {
+                return;
+            }
+            state.receiver_alive = false;
+            state.value.take()
+        };
+        // Dropping a response or waking its producer may execute other code.
+        drop(queued);
+        self.0.sender.wake();
+    }
+
+    #[cfg(test)]
+    pub(super) fn is_empty(&self) -> bool {
+        self.0.state.lock().unwrap().value.is_none()
+    }
+}
+
+impl<T> Drop for Receiver<T> {
+    fn drop(&mut self) {
+        self.close();
+    }
+}
+
+#[cfg(test)]
+#[path = "packet_response_tests.rs"]
+mod tests;
diff --git a/src/outbound/mieru/packet_response_tests.rs b/src/outbound/mieru/packet_response_tests.rs
new file mode 100644
index 0000000..a207f0c
--- /dev/null
+++ b/src/outbound/mieru/packet_response_tests.rs
@@ -0,0 +1,202 @@
+use super::*;
+use futures_util::task::{ArcWake, waker};
+use std::{
+    future::Future,
+    sync::atomic::{AtomicUsize, Ordering},
+    time::Duration,
+};
+
+#[derive(Default)]
+struct WakeCount(AtomicUsize);
+impl ArcWake for WakeCount {
+    fn wake_by_ref(owner: &Arc<Self>) {
+        owner.0.fetch_add(1, Ordering::Relaxed);
+    }
+}
+
+#[test]
+fn mieru_response_slot_empty_send_does_not_register_a_producer_wake() {
+    let (mut sender, mut receiver) = channel();
+    let wakes = Arc::new(WakeCount::default());
+    let wake = waker(wakes.clone());
+    let mut context = Context::from_waker(&wake);
+    {
+        let sending = sender.send(1);
+        let mut sending = std::pin::pin!(sending);
+        assert_eq!(sending.as_mut().poll(&mut context), Poll::Ready(Ok(())));
+    }
+    assert_eq!(receiver.poll_recv(&mut context), Poll::Ready(Some(1)));
+    assert_eq!(wakes.0.load(Ordering::Relaxed), 0);
+}
+
+#[test]
+fn mieru_response_slot_backpressure_wakes_both_directions() {
+    let (mut sender, mut receiver) = channel();
+    let receive_wakes = Arc::new(WakeCount::default());
+    let receive_waker = waker(receive_wakes.clone());
+    let mut receiving = Context::from_waker(&receive_waker);
+    let send_wakes = Arc::new(WakeCount::default());
+    let send_waker = waker(send_wakes.clone());
+    let mut sending = Context::from_waker(&send_waker);
+
+    assert!(receiver.poll_recv(&mut receiving).is_pending());
+    {
+        let sending = sender.send(1);
+        let mut sending = std::pin::pin!(sending);
+        assert_eq!(sending.as_mut().poll(&mut receiving), Poll::Ready(Ok(())));
+    }
+    assert!(receive_wakes.0.load(Ordering::Relaxed) > 0);
+    let sending_second = sender.send(2);
+    let mut sending_second = std::pin::pin!(sending_second);
+    assert!(sending_second.as_mut().poll(&mut sending).is_pending());
+    let before = send_wakes.0.load(Ordering::Relaxed);
+    assert_eq!(receiver.poll_recv(&mut receiving), Poll::Ready(Some(1)));
+    assert!(send_wakes.0.load(Ordering::Relaxed) > before);
+    assert!(receiver.poll_recv(&mut receiving).is_pending());
+    let before = receive_wakes.0.load(Ordering::Relaxed);
+    assert_eq!(
+        sending_second.as_mut().poll(&mut sending),
+        Poll::Ready(Ok(()))
+    );
+    assert!(receive_wakes.0.load(Ordering::Relaxed) > before);
+    assert_eq!(receiver.poll_recv(&mut receiving), Poll::Ready(Some(2)));
+}
+
+#[test]
+fn mieru_response_slot_sender_end_preserves_final_error_then_eof() {
+    let (mut sender, mut receiver) = channel::<Result<(), &'static str>>();
+    let wakes = Arc::new(WakeCount::default());
+    let wake = waker(wakes.clone());
+    let mut context = Context::from_waker(&wake);
+    assert!(receiver.poll_recv(&mut context).is_pending());
+    {
+        let sending = sender.send(Err("final codec error"));
+        let mut sending = std::pin::pin!(sending);
+        assert_eq!(sending.as_mut().poll(&mut context), Poll::Ready(Ok(())));
+    }
+    drop(sender);
+    assert_eq!(
+        receiver.poll_recv(&mut context),
+        Poll::Ready(Some(Err("final codec error")))
+    );
+    assert_eq!(receiver.poll_recv(&mut context), Poll::Ready(None));
+
+    let (sender, mut receiver) = channel::<()>();
+    assert!(receiver.poll_recv(&mut context).is_pending());
+    let before = wakes.0.load(Ordering::Relaxed);
+    drop(sender);
+    assert!(wakes.0.load(Ordering::Relaxed) > before);
+    assert_eq!(receiver.poll_recv(&mut context), Poll::Ready(None));
+}
+
+struct CountDrop(Arc<AtomicUsize>);
+impl Drop for CountDrop {
+    fn drop(&mut self) {
+        self.0.fetch_add(1, Ordering::Relaxed);
+    }
+}
+
+#[test]
+fn mieru_response_slot_receiver_close_or_drop_releases_blocked_sender() {
+    for explicit_close in [false, true] {
+        let (mut sender, mut receiver) = channel();
+        let drops = Arc::new(AtomicUsize::new(0));
+        let wakes = Arc::new(WakeCount::default());
+        let wake = waker(wakes.clone());
+        let mut context = Context::from_waker(&wake);
+        {
+            let sending = sender.send(CountDrop(drops.clone()));
+            let mut sending = std::pin::pin!(sending);
+            assert!(matches!(
+                sending.as_mut().poll(&mut context),
+                Poll::Ready(Ok(()))
+            ));
+        }
+        let blocked = sender.send(CountDrop(drops.clone()));
+        let mut blocked = std::pin::pin!(blocked);
+        assert!(blocked.as_mut().poll(&mut context).is_pending());
+        let before = wakes.0.load(Ordering::Relaxed);
+        if explicit_close {
+            receiver.close();
+            receiver.close();
+            assert!(matches!(
+                receiver.poll_recv(&mut context),
+                Poll::Ready(None)
+            ));
+        }
+        drop(receiver);
+        assert!(wakes.0.load(Ordering::Relaxed) > before);
+        assert_eq!(drops.load(Ordering::Relaxed), 1, "queued item discarded");
+        let Poll::Ready(Err(unsubmitted)) = blocked.as_mut().poll(&mut context) else {
+            panic!("receiver termination must return the unsubmitted item");
+        };
+        assert_eq!(drops.load(Ordering::Relaxed), 1);
+        drop(unsubmitted);
+        assert_eq!(drops.load(Ordering::Relaxed), 2);
+    }
+}
+
+#[test]
+fn mieru_response_slot_cancelled_send_keeps_the_committed_item() {
+    let (mut sender, mut receiver) = channel();
+    let wake = futures_util::task::noop_waker();
+    let mut context = Context::from_waker(&wake);
+    {
+        let sending = sender.send(1);
+        let mut sending = std::pin::pin!(sending);
+        assert_eq!(sending.as_mut().poll(&mut context), Poll::Ready(Ok(())));
+    }
+    {
+        let blocked = sender.send(2);
+        let mut blocked = std::pin::pin!(blocked);
+        assert!(blocked.as_mut().poll(&mut context).is_pending());
+        // Drop the actual pending send future, rather than just its Pin handle.
+    }
+    assert_eq!(receiver.poll_recv(&mut context), Poll::Ready(Some(1)));
+    let sending = sender.send(3);
+    let mut sending = std::pin::pin!(sending);
+    assert_eq!(sending.as_mut().poll(&mut context), Poll::Ready(Ok(())));
+    assert_eq!(receiver.poll_recv(&mut context), Poll::Ready(Some(3)));
+    assert!(receiver.poll_recv(&mut context).is_pending());
+}
+
+#[tokio::test]
+async fn mieru_response_slot_cross_thread_handoffs_drain_and_join() {
+    let (mut sender, mut receiver) = channel::<usize>();
+    let producer = std::thread::spawn(move || {
+        let runtime = tokio::runtime::Builder::new_current_thread()
+            .enable_time()
+            .build()
+            .unwrap();
+        let sent = runtime.block_on(async move {
+            tokio::time::timeout(Duration::from_secs(5), async move {
+                for value in 0..2048 {
+                    sender.send(value).await?;
+                    if value % 3 == 0 {
+                        tokio::task::yield_now().await;
+                    }
+                }
+                Ok::<_, usize>(())
+            })
+            .await
+        });
+        (std::thread::current().id(), sent)
+    });
+    let received = tokio::time::timeout(Duration::from_secs(5), async {
+        let mut received = Vec::new();
+        while let Some(value) = poll_fn(|context| receiver.poll_recv(context)).await {
+            received.push(value);
+            if received.len() % 5 == 0 {
+                tokio::task::yield_now().await;
+            }
+        }
+        received
+    })
+    .await;
+    // Always unblock and join the other thread before asserting timeout/results.
+    receiver.close();
+    let (producer_thread, sent) = producer.join().unwrap();
+    assert_ne!(producer_thread, std::thread::current().id());
+    assert!(matches!(sent, Ok(Ok(()))));
+    assert_eq!(received.unwrap(), (0..2048).collect::<Vec<_>>());
+}
diff --git a/src/outbound/mieru/packet_routing_tests.rs b/src/outbound/mieru/packet_routing_tests.rs
new file mode 100644
index 0000000..3573a69
--- /dev/null
+++ b/src/outbound/mieru/packet_routing_tests.rs
@@ -0,0 +1,518 @@
+//! Real Mieru packet receivers selected by the managed router; memory IO only.
+use super::{
+    MieruOutbound,
+    tests::{Peer, config, session},
+};
+use crate::{
+    config::{Config, MieruHandshake},
+    connections::Registry,
+    dialer::{ResolvedEndpoint, Resolver},
+    dispatch::{
+        BoxStream, DatagramBudget, DatagramTransport, DispatchError, Dispatcher,
+        observe_sessions_with_stats,
+    },
+    dns::resolution::ResolutionContext,
+    outbound::{ConnectorDispatcher, OutboundConnector, UpstreamPath},
+    resources::{RuntimeResourceStats, observation::ResourceProbe},
+    routing::{
+        EmptyGeoMatcher, ProxyDispatchers, RoutingDispatcher, RuleSet, diagnostics::Diagnostics,
+    },
+    session::{Datagram, DatagramSession, Destination, StreamSession},
+};
+use async_trait::async_trait;
+use bytes::Bytes;
+use futures_util::task::ArcWake;
+use std::{
+    future::{Future, poll_fn},
+    io,
+    net::SocketAddr,
+    pin::Pin,
+    sync::{
+        Arc, Mutex,
+        atomic::{AtomicUsize, Ordering},
+    },
+    task::{Context, Poll},
+    time::Duration,
+};
+
+const STEP: Duration = Duration::from_secs(2);
+type DispatchFuture<'a, T> = Pin<Box<dyn Future<Output = Result<T, DispatchError>> + Send + 'a>>;
+
+#[derive(Default)]
+struct Counts {
+    async_created: AtomicUsize,
+    async_polls: AtomicUsize,
+    receiver_polls: AtomicUsize,
+    pending_polls: AtomicUsize,
+    closes: AtomicUsize,
+}
+
+#[derive(Debug, Clone, Copy)]
+struct CountSnapshot {
+    async_created: usize,
+    async_polls: usize,
+    receiver_polls: usize,
+    pending_polls: usize,
+    closes: usize,
+}
+
+impl Counts {
+    fn snapshot(&self) -> CountSnapshot {
+        CountSnapshot {
+            async_created: self.async_created.load(Ordering::Relaxed),
+            async_polls: self.async_polls.load(Ordering::Relaxed),
+            receiver_polls: self.receiver_polls.load(Ordering::Relaxed),
+            pending_polls: self.pending_polls.load(Ordering::Relaxed),
+            closes: self.closes.load(Ordering::Relaxed),
+        }
+    }
+}
+
+fn snapshots(counts: &Mutex<Vec<Arc<Counts>>>) -> Vec<CountSnapshot> {
+    counts
+        .lock()
+        .unwrap()
+        .iter()
+        .map(|entry| entry.snapshot())
+        .collect()
+}
+
+struct CountedReceive<'a> {
+    inner: DispatchFuture<'a, Datagram>,
+    counts: Arc<Counts>,
+}
+
+impl Future for CountedReceive<'_> {
+    type Output = Result<Datagram, DispatchError>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.get_mut();
+        this.counts.async_polls.fetch_add(1, Ordering::Relaxed);
+        this.inner.as_mut().poll(cx)
+    }
+}
+
+struct CountedTransport {
+    inner: Box<dyn DatagramTransport>,
+    counts: Arc<Counts>,
+}
+
+// Spell out the async_trait ABI so creation is counted before the returned
+// receive future is first polled. Every operation delegates to the real IO.
+impl DatagramTransport for CountedTransport {
+    fn supports_shared_destinations(&self) -> bool {
+        self.inner.supports_shared_destinations()
+    }
+
+    fn supports_poll_receive(&self) -> bool {
+        self.inner.supports_poll_receive()
+    }
+
+    fn poll_receive(
+        &mut self,
+        cx: &mut Context<'_>,
+        scratch: &mut Vec<u8>,
+    ) -> Poll<Result<Datagram, DispatchError>> {
+        self.counts.receiver_polls.fetch_add(1, Ordering::Relaxed);
+        let result = self.inner.poll_receive(cx, scratch);
+        if result.is_pending() {
+            self.counts.pending_polls.fetch_add(1, Ordering::Relaxed);
+        }
+        result
+    }
+
+    fn payload_budget(&self, remote: &Destination) -> DatagramBudget {
+        self.inner.payload_budget(remote)
+    }
+
+    fn send<'life0, 'async_trait>(
+        &'life0 mut self,
+        datagram: Datagram,
+    ) -> DispatchFuture<'async_trait, ()>
+    where
+        'life0: 'async_trait,
+        Self: 'async_trait,
+    {
+        self.inner.send(datagram)
+    }
+
+    fn receive<'life0, 'async_trait>(&'life0 mut self) -> DispatchFuture<'async_trait, Datagram>
+    where
+        'life0: 'async_trait,
+        Self: 'async_trait,
+    {
+        self.counts.async_created.fetch_add(1, Ordering::Relaxed);
+        Box::pin(CountedReceive {
+            inner: self.inner.receive(),
+            counts: self.counts.clone(),
+        })
+    }
+
+    fn close<'life0, 'async_trait>(&'life0 mut self) -> DispatchFuture<'async_trait, ()>
+    where
+        'life0: 'async_trait,
+        Self: 'async_trait,
+    {
+        let closing = self.inner.close();
+        let counts = self.counts.clone();
+        Box::pin(async move {
+            closing.await?;
+            counts.closes.fetch_add(1, Ordering::Relaxed);
+            Ok(())
+        })
+    }
+}
+
+struct CountedDispatcher {
+    inner: Arc<dyn Dispatcher>,
+    counts: Arc<Mutex<Vec<Arc<Counts>>>>,
+}
+
+#[async_trait]
+impl Dispatcher for CountedDispatcher {
+    fn supports_udp(&self) -> bool {
+        self.inner.supports_udp()
+    }
+
+    async fn connect_tcp(&self, session: StreamSession) -> Result<BoxStream, DispatchError> {
+        self.inner.connect_tcp(session).await
+    }
+
+    async fn open_datagram(
+        &self,
+        session: DatagramSession,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        let inner = self.inner.open_datagram(session).await?;
+        let counts = Arc::new(Counts::default());
+        self.counts.lock().unwrap().push(counts.clone());
+        Ok(Box::new(CountedTransport { inner, counts }))
+    }
+}
+
+#[derive(Default)]
+struct WakeCount(AtomicUsize);
+impl ArcWake for WakeCount {
+    fn wake_by_ref(owner: &Arc<Self>) {
+        owner.0.fetch_add(1, Ordering::Relaxed);
+    }
+}
+
+async fn bounded<T>(future: impl Future<Output = Result<T, DispatchError>>) -> Result<T, String> {
+    tokio::time::timeout(STEP, future)
+        .await
+        .map_err(|_| "memory IO timed out".to_owned())?
+        .map_err(|error| error.to_string())
+}
+
+async fn echo(
+    transport: &mut dyn DatagramTransport,
+    remote: SocketAddr,
+    body: &'static [u8],
+) -> Result<(), String> {
+    bounded(transport.send(Datagram {
+        remote: Destination::Ip(remote),
+        payload: Bytes::from_static(body),
+        sniffed_domain: None,
+    }))
+    .await?;
+    let response = bounded(transport.receive()).await?;
+    if response.remote != Destination::Ip(remote) || response.payload.as_ref() != body {
+        return Err("Mieru routed datagram payload or source differs".into());
+    }
+    Ok(())
+}
+
+struct FixedResolver;
+
+#[async_trait]
+impl Resolver for FixedResolver {
+    async fn resolve(&self, host: &str, port: u16) -> io::Result<ResolvedEndpoint> {
+        Ok(ResolvedEndpoint {
+            logical_host: host.into(),
+            port,
+            addresses: vec![SocketAddr::from(([198, 51, 100, 1], port))],
+        })
+    }
+}
+
+async fn echo_domain(
+    transport: &mut dyn DatagramTransport,
+    remote: SocketAddr,
+    body: &'static [u8],
+) -> Result<(), String> {
+    bounded(transport.send(Datagram {
+        remote: Destination::Domain {
+            host: format!("target-{}.invalid", remote.port()),
+            port: remote.port(),
+        },
+        payload: Bytes::from_static(body),
+        sniffed_domain: None,
+    }))
+    .await?;
+    let response = bounded(transport.receive()).await?;
+    if response.remote != Destination::Ip(remote) || response.payload.as_ref() != body {
+        return Err("Mieru domain datagram payload or source differs".into());
+    }
+    Ok(())
+}
+
+struct Evidence {
+    prime_pending: bool,
+    before_hot: Vec<CountSnapshot>,
+    after_hot: Vec<CountSnapshot>,
+    controller_pending: bool,
+    controller_wakes: usize,
+    remaining_after_cancel: usize,
+}
+
+#[tokio::test]
+async fn mieru_udp_dedicated_domain_routing_polls_only_ready_targets_and_preserves_cancelled_siblings()
+ {
+    let probe = ResourceProbe::default();
+    let (business, closed, joined, peer_joined, final_counts, remaining, udp_current) = probe.scope(async {
+        let parsed = Config::parse_yaml(br#"
+proxies: [{name: edge, type: mieru, server: memory.invalid, port: 2000, username: vole, password: fixture-password, transport: TCP, udp: true, multiplexing: MULTIPLEXING_HIGH}]
+rules: ["MATCH,edge"]
+"#).unwrap();
+        let peer = Peer::new(false);
+        let node = Arc::new(MieruOutbound::new(
+            &config(MieruHandshake::Standard), UpstreamPath::proxy(peer.clone()), 1024,
+        ).unwrap());
+        let counts = Arc::new(Mutex::new(Vec::new()));
+        let counted: Arc<dyn Dispatcher> = Arc::new(CountedDispatcher {
+            inner: Arc::new(ConnectorDispatcher::new(node.clone()).with_resolution(
+                ResolutionContext::measurement(Arc::new(FixedResolver), false),
+            )),
+            counts: counts.clone(),
+        });
+        let stats = RuntimeResourceStats::new("mieru_packet_router");
+        let leaf = observe_sessions_with_stats(counted, stats.clone());
+        // An accidental DIRECT route cannot open UDP through the memory Peer.
+        let direct: Arc<dyn Dispatcher> = Arc::new(ConnectorDispatcher::new(peer.clone()));
+        let rules = RuleSet::compile(parsed.rules.clone()).unwrap();
+        let registry = Arc::new(Registry::default());
+        let diagnostics = Arc::new(Diagnostics::new(&parsed, &rules, registry.clone()));
+        let router = RoutingDispatcher::new(
+            ProxyDispatchers::new(vec![leaf.clone()]).unwrap(), direct, None, rules, Arc::new(EmptyGeoMatcher),
+        ).with_diagnostics(diagnostics);
+        let mut associations = Vec::new();
+        let business = tokio::time::timeout(Duration::from_secs(10), async {
+            let targets: [SocketAddr; 3] = [
+                "198.51.100.1:11000".parse().unwrap(),
+                "198.51.100.1:11001".parse().unwrap(),
+                "198.51.100.1:11002".parse().unwrap(),
+            ];
+            let mut prime_pending = true;
+            // Each source owns its routing receiver. Domain requests retain
+            // dedicated transports because the IP response cannot identify a
+            // domain alias. This protects Dedicated readiness, not shared IO.
+            for source_index in 0..3 {
+                let mut source = session().source;
+                source.set_port(source.port() + source_index);
+                let mut transport = bounded(router.open_datagram(DatagramSession::for_tun(
+                    source, 1500,
+                ))).await?;
+                for mut remote in targets {
+                    remote.set_port(remote.port() + source_index * 10);
+                    echo_domain(transport.as_mut(), remote, b"prime").await?;
+                }
+                // Consume requeues and prime all three actual empty receivers.
+                let pending = {
+                    let mut receive = transport.receive();
+                    futures_util::poll!(receive.as_mut()).is_pending()
+                };
+                prime_pending &= pending;
+                associations.push(transport);
+            }
+            let transport = &mut associations[0];
+            let before_hot = snapshots(&counts);
+            echo_domain(transport.as_mut(), targets[0], b"hot").await?;
+            let after_hot = snapshots(&counts);
+
+            let snapshot = serde_json::to_value(registry.snapshot()).map_err(|error| error.to_string())?;
+            let cold_port = targets[1].port().to_string();
+            let id = snapshot["connections"].as_array().ok_or("connections missing")?
+                .iter().find(|entry| entry["metadata"]["destinationPort"].as_str() == Some(cold_port.as_str()))
+                .and_then(|entry| entry["id"].as_str()).ok_or("cold connection missing")?.to_owned();
+            let cold = counts.lock().unwrap().get(1).cloned().ok_or("cold receiver missing")?;
+            let wakes = Arc::new(WakeCount::default());
+            let mut waiting = transport.receive();
+            let controller_pending = {
+                let waker = futures_util::task::waker(wakes.clone());
+                waiting.as_mut().poll(&mut Context::from_waker(&waker)).is_pending()
+            };
+            registry.close(&id);
+            let controller_wakes = wakes.0.load(Ordering::Relaxed);
+            // Keep this receive alive while its cancellation path joins the
+            // actual reader. Drop only after close has completed and it is idle.
+            bounded(poll_fn(|cx| {
+                match waiting.as_mut().poll(cx) {
+                    Poll::Ready(_) => Poll::Ready(Err(DispatchError::Other("unexpected receive during cancellation".into()))),
+                    Poll::Pending if cold.closes.load(Ordering::Relaxed) == 1 => Poll::Ready(Ok(())),
+                    Poll::Pending => Poll::Pending,
+                }
+            })).await?;
+            drop(waiting);
+            let snapshot = serde_json::to_value(registry.snapshot()).map_err(|error| error.to_string())?;
+            let remaining_after_cancel = snapshot["connections"].as_array().ok_or("connections missing")?.len();
+            echo_domain(transport.as_mut(), targets[0], b"sibling-after-cancel").await?;
+            Ok::<_, String>(Evidence {
+                prime_pending, before_hot, after_hot, controller_pending,
+                controller_wakes, remaining_after_cancel,
+            })
+        }).await.map_err(|_| "routed memory scenario timed out".to_owned()).and_then(|result| result);
+
+        // Complete all three source owners before asserting readiness counters.
+        let mut closed = Ok(());
+        for mut transport in associations {
+            if let Err(error) = bounded(transport.close()).await {
+                closed = Err(error);
+            }
+        }
+        let joined = tokio::time::timeout(STEP, node.shutdown()).await.is_ok();
+        let peer_joined = tokio::time::timeout(STEP, peer.stop()).await.is_ok();
+        drop((router, leaf, node, peer));
+        let remaining = serde_json::to_value(registry.snapshot()).unwrap()["connections"].as_array().unwrap().len();
+        (business, closed, joined, peer_joined, snapshots(&counts), remaining, stats.snapshot().udp_current)
+    }).await;
+
+    assert!(probe.snapshot().is_idle());
+    assert!(closed.is_ok(), "association close: {closed:?}");
+    assert!(joined && peer_joined, "Mieru or memory peer did not join");
+    assert_eq!(remaining, 0);
+    assert_eq!(udp_current, 0);
+    let evidence = business.unwrap();
+    assert!(evidence.prime_pending && evidence.controller_pending);
+    assert!(
+        evidence.controller_wakes > 0,
+        "Controller close did not wake the pending router"
+    );
+    assert_eq!(evidence.remaining_after_cancel, 8);
+    assert_eq!(evidence.before_hot.len(), 9);
+    assert_eq!(evidence.after_hot.len(), 9);
+    assert_eq!(final_counts.len(), 9);
+    for (index, counts) in final_counts.iter().enumerate() {
+        assert_eq!(
+            counts.async_created, 0,
+            "receiver {index} used asynchronous fanout: {counts:?}"
+        );
+        assert_eq!(
+            counts.async_polls, 0,
+            "receiver {index} polled asynchronous receive"
+        );
+        assert_eq!(
+            counts.closes, 1,
+            "receiver {index} did not close exactly once"
+        );
+        assert!(
+            evidence.before_hot[index].pending_polls > 0,
+            "receiver {index} was never primed to Pending"
+        );
+        if index == 0 {
+            assert!(
+                evidence.after_hot[index].receiver_polls
+                    > evidence.before_hot[index].receiver_polls
+            );
+        } else {
+            assert_eq!(
+                evidence.after_hot[index].receiver_polls, evidence.before_hot[index].receiver_polls,
+                "idle receiver {index} was polled for its hot sibling"
+            );
+        }
+    }
+}
+
+#[tokio::test]
+async fn mieru_udp_routing_shares_targets_and_retires_closed_generations_without_closing_siblings()
+{
+    let probe = ResourceProbe::default();
+    let (business, closed, joined, peer_joined, closes, remaining, udp_current) = probe.scope(async {
+        let parsed = Config::parse_yaml(br#"
+proxies: [{name: edge, type: mieru, server: memory.invalid, port: 2000, username: vole, password: fixture-password, transport: TCP, udp: true, multiplexing: MULTIPLEXING_HIGH}]
+rules: ["MATCH,edge"]
+"#).unwrap();
+        let peer = Peer::new(false);
+        let node = Arc::new(MieruOutbound::new(
+            &config(MieruHandshake::Standard), UpstreamPath::proxy(peer.clone()), 1024,
+        ).unwrap());
+        let counts = Arc::new(Mutex::new(Vec::new()));
+        let counted: Arc<dyn Dispatcher> = Arc::new(CountedDispatcher {
+            inner: Arc::new(ConnectorDispatcher::new(node.clone())), counts: counts.clone(),
+        });
+        let stats = RuntimeResourceStats::new("mieru_packet_router");
+        let leaf = observe_sessions_with_stats(counted, stats.clone());
+        let direct: Arc<dyn Dispatcher> = Arc::new(ConnectorDispatcher::new(peer.clone()));
+        let rules = RuleSet::compile(parsed.rules.clone()).unwrap();
+        let registry = Arc::new(Registry::default());
+        let diagnostics = Arc::new(Diagnostics::new(&parsed, &rules, registry.clone()));
+        let router = RoutingDispatcher::new(
+            ProxyDispatchers::new(vec![leaf.clone()]).unwrap(), direct, None, rules, Arc::new(EmptyGeoMatcher),
+        ).with_diagnostics(diagnostics);
+        let mut associations = Vec::new();
+        let business = tokio::time::timeout(Duration::from_secs(10), async {
+            let targets: [SocketAddr; 3] = [
+                "198.51.100.1:11000".parse().unwrap(),
+                "198.51.100.1:11001".parse().unwrap(),
+                "[2001:db8::1]:11002".parse().unwrap(),
+            ];
+            associations.push(bounded(router.open_datagram(DatagramSession::for_tun(
+                session().source, 1500,
+            ))).await?);
+            for remote in targets {
+                echo(associations[0].as_mut(), remote, b"prime").await?;
+            }
+            if counts.lock().unwrap().len() != 1 {
+                return Err("same-source targets did not share one UDP Associate".into());
+            }
+            let snapshot = serde_json::to_value(registry.snapshot()).map_err(|error| error.to_string())?;
+            let port = targets[1].port().to_string();
+            let id = snapshot["connections"].as_array().ok_or("connections missing")?
+                .iter().find(|entry| entry["metadata"]["destinationPort"].as_str() == Some(port.as_str()))
+                .and_then(|entry| entry["id"].as_str()).ok_or("connection missing")?.to_owned();
+            registry.close(&id);
+            echo(associations[0].as_mut(), targets[0], b"sibling-after-close").await?;
+            if counts.lock().unwrap()[0].closes.load(Ordering::Relaxed) != 0 {
+                return Err("closing one target closed its live sibling".into());
+            }
+            echo(associations[0].as_mut(), targets[1], b"reopened").await?;
+            if counts.lock().unwrap().len() != 2 {
+                return Err("reopened target reused a retired association".into());
+            }
+            echo(associations[0].as_mut(), targets[2], b"old-generation-sibling").await?;
+            associations.push(bounded(router.open_datagram(DatagramSession::for_tun(
+                "192.0.2.10:1001".parse().unwrap(), 1500,
+            ))).await?);
+            for remote in targets {
+                echo(associations[1].as_mut(), remote, b"other-source").await?;
+            }
+            if counts.lock().unwrap().len() != 3 {
+                return Err("different sources were merged or targets were not shared".into());
+            }
+            let remaining = serde_json::to_value(registry.snapshot()).map_err(|error| error.to_string())?
+                ["connections"].as_array().ok_or("connections missing")?.len();
+            if remaining != 6 {
+                return Err("shared associations did not retain per-target connections".into());
+            }
+            Ok::<_, String>(())
+        }).await.map_err(|_| "routed memory scenario timed out".to_owned()).and_then(|result| result);
+        let mut closed = Ok(());
+        for mut transport in associations {
+            if let Err(error) = bounded(transport.close()).await {
+                closed = Err(error);
+            }
+        }
+        let joined = tokio::time::timeout(STEP, node.shutdown()).await.is_ok();
+        let peer_joined = tokio::time::timeout(STEP, peer.stop()).await.is_ok();
+        drop((router, leaf, node, peer));
+        let remaining = serde_json::to_value(registry.snapshot()).unwrap()["connections"].as_array().unwrap().len();
+        let closes = counts.lock().unwrap().iter().map(|count| count.closes.load(Ordering::Relaxed)).collect::<Vec<_>>();
+        (business, closed, joined, peer_joined, closes, remaining, stats.snapshot().udp_current)
+    }).await;
+    assert!(probe.snapshot().is_idle());
+    assert!(closed.is_ok(), "association close: {closed:?}");
+    assert!(joined && peer_joined, "Mieru or memory peer did not join");
+    assert_eq!(remaining, 0);
+    assert_eq!(udp_current, 0);
+    business.unwrap();
+    assert_eq!(closes, vec![1, 1, 1]);
+}
diff --git a/src/outbound/mieru/pattern.rs b/src/outbound/mieru/pattern.rs
new file mode 100644
index 0000000..1e8648f
--- /dev/null
+++ b/src/outbound/mieru/pattern.rs
@@ -0,0 +1,1072 @@
+//! Native traffic-pattern policies for the public Mieru v3 wire format.
+//! Protobuf field numbers and behavior target the SDK 3.38.0 consumed by Mihomo.
+//! This independent implementation contains no copied protobuf or Go source.
+use super::wire::{
+    BodyEncoding, DataKind, FrameEncoding, LowEntropyEncoding, MAX_CONTROL_PAYLOAD,
+    MAX_DATA_PAYLOAD, Metadata, PACKET_OVERHEAD, Padding,
+};
+use crate::config::MieruTransport;
+use base64::{Engine as _, alphabet, engine::general_purpose};
+use prost::Message;
+use rand::RngExt as _;
+use sha2::{Digest, Sha256};
+use std::{io, ops::Range, time::Duration};
+
+const PROFILE_VERSION: &[u8] = b"3.38.0";
+const PADDING_LIMIT: usize = 255;
+const COMMON_64: &[u8; 64] = b"CCOzB3KKr9NDAgVnJcCn9ib37T1JH6vRSVx8YaNnXbfo6yFU1EHPy2r3D5LM1Qi4";
+
+// Independent definitions of the public field-number/type contract. Optional
+// scalars retain absence separately from zero, including unknown nonce enums.
+#[derive(Clone, PartialEq, Message)]
+struct RawPattern {
+    #[prost(int32, optional, tag = "1")]
+    seed: Option<i32>,
+    #[prost(bool, optional, tag = "2")]
+    unlock_all: Option<bool>,
+    #[prost(message, optional, tag = "3")]
+    fragment: Option<RawFragment>,
+    #[prost(message, optional, tag = "4")]
+    nonce: Option<RawNonce>,
+    #[prost(message, optional, tag = "5")]
+    padding: Option<RawPadding>,
+    #[prost(message, optional, tag = "6")]
+    low_entropy: Option<RawLowEntropy>,
+}
+
+#[derive(Clone, PartialEq, Message)]
+struct RawFragment {
+    #[prost(bool, optional, tag = "1")]
+    enable: Option<bool>,
+    #[prost(int32, optional, tag = "2")]
+    max_sleep_ms: Option<i32>,
+}
+
+#[derive(Clone, PartialEq, Message)]
+struct RawNonce {
+    #[prost(int32, optional, tag = "1")]
+    kind: Option<i32>,
+    #[prost(bool, optional, tag = "2")]
+    all_udp: Option<bool>,
+    #[prost(int32, optional, tag = "3")]
+    minimum: Option<i32>,
+    #[prost(int32, optional, tag = "4")]
+    maximum: Option<i32>,
+    #[prost(string, repeated, tag = "5")]
+    fixed: Vec<String>,
+}
+
+#[derive(Clone, PartialEq, Message)]
+struct RawPadding {
+    #[prost(int32, optional, tag = "1")]
+    middle: Option<i32>,
+    #[prost(int32, optional, tag = "2")]
+    end: Option<i32>,
+}
+
+#[derive(Clone, PartialEq, Message)]
+struct RawLowEntropy {
+    #[prost(int32, optional, tag = "1")]
+    mode: Option<i32>,
+    #[prost(int32, optional, tag = "2")]
+    rotation: Option<i32>,
+}
+
+fn invalid_pattern() -> io::Error {
+    io::Error::new(io::ErrorKind::InvalidInput, "invalid Mieru traffic-pattern")
+}
+
+fn fixed_hash(bytes: &[u8], versioned: bool) -> u32 {
+    let mut hash = Sha256::new();
+    hash.update(bytes);
+    if versioned {
+        hash.update(b" ");
+        hash.update(PROFILE_VERSION);
+    }
+    let digest = hash.finalize();
+    u32::from_be_bytes([digest[0] & 0x7f, digest[1], digest[2], digest[3]])
+}
+
+/// One factory snapshot, shared by defaults, padding polarity and idle timeout.
+#[derive(Clone, Copy)]
+pub(crate) struct HostProfile(u32);
+
+impl HostProfile {
+    pub(crate) fn capture() -> Self {
+        Self(fixed_hash(
+            &hostname::get().unwrap_or_default().into_encoded_bytes(),
+            true,
+        ))
+    }
+
+    pub(crate) fn fixed_int(self, upper: u32) -> u32 {
+        if upper == 0 { 0 } else { self.0 % upper }
+    }
+}
+
+fn decode_raw(encoded: &str) -> io::Result<RawPattern> {
+    // Go's StdEncoding permits CR/LF and noncanonical unused tail bits, while
+    // still requiring padded standard base64 and rejecting other whitespace.
+    let clean: Vec<_> = encoded
+        .bytes()
+        .filter(|b| !matches!(b, b'\r' | b'\n'))
+        .collect();
+    let engine = general_purpose::GeneralPurpose::new(
+        &alphabet::STANDARD,
+        general_purpose::GeneralPurposeConfig::new().with_decode_allow_trailing_bits(true),
+    );
+    let bytes = engine.decode(clean).map_err(|_| invalid_pattern())?;
+    let raw = RawPattern::decode(bytes.as_slice()).map_err(|_| invalid_pattern())?;
+    validate(&raw)?;
+    Ok(raw)
+}
+
+fn valid_range(value: Option<i32>, maximum: i32) -> bool {
+    value.is_none_or(|value| (0..=maximum).contains(&value))
+}
+
+fn valid_rotation(value: i32) -> bool {
+    (0..=15).contains(&value) || (16..=240).contains(&value) && value % 16 == 0
+}
+
+fn validate(raw: &RawPattern) -> io::Result<()> {
+    if raw
+        .fragment
+        .as_ref()
+        .is_some_and(|v| !valid_range(v.max_sleep_ms, 100))
+        || raw
+            .padding
+            .as_ref()
+            .is_some_and(|v| !valid_range(v.middle, 255) || !valid_range(v.end, 255))
+        || raw.low_entropy.as_ref().is_some_and(|v| {
+            !valid_range(v.mode, 4) || v.rotation.is_some_and(|n| !valid_rotation(n))
+        })
+    {
+        return Err(invalid_pattern());
+    }
+    if let Some(nonce) = &raw.nonce {
+        if !valid_range(nonce.minimum, 12)
+            || !valid_range(nonce.maximum, 12)
+            || nonce.minimum.zip(nonce.maximum).is_some_and(|(a, b)| a > b)
+        {
+            return Err(invalid_pattern());
+        }
+        for value in &nonce.fixed {
+            decode_prefix(value)?;
+        }
+    }
+    Ok(())
+}
+
+pub(crate) fn validate_raw(encoded: &str) -> crate::Result<()> {
+    decode_raw(encoded)
+        .map(|_| ())
+        .map_err(|_| crate::error::VoleError::InvalidConfig("invalid Mieru traffic-pattern".into()))
+}
+
+struct NoncePrefix {
+    bytes: [u8; 12],
+    len: usize,
+}
+
+fn decode_prefix(value: &str) -> io::Result<NoncePrefix> {
+    if value.len() > 24 || !value.len().is_multiple_of(2) {
+        return Err(invalid_pattern());
+    }
+    let mut result = NoncePrefix {
+        bytes: [0; 12],
+        len: value.len() / 2,
+    };
+    for (index, pair) in value.as_bytes().as_chunks::<2>().0.iter().enumerate() {
+        let digit = |b: u8| match b {
+            b'0'..=b'9' => Some(b - b'0'),
+            b'a'..=b'f' => Some(b - b'a' + 10),
+            b'A'..=b'F' => Some(b - b'A' + 10),
+            _ => None,
+        };
+        result.bytes[index] = digit(pair[0])
+            .zip(digit(pair[1]))
+            .map(|(a, b)| a * 16 + b)
+            .ok_or_else(invalid_pattern)?;
+    }
+    Ok(result)
+}
+
+/// Immutable policy; all per-carrier mutation lives in NonceState or the driver.
+pub(crate) struct EffectivePattern {
+    fragment: bool,
+    max_sleep_ms: u64,
+    nonce_kind: i32,
+    all_udp: bool,
+    nonce_min: usize,
+    nonce_max: usize,
+    fixed_nonce: Vec<NoncePrefix>,
+    middle: usize,
+    end: usize,
+    low_mode: u8,
+    rotation: u8,
+    padding_bit: u8,
+    ascii_run: usize,
+    control_entropy: bool,
+}
+
+impl EffectivePattern {
+    pub(crate) fn compile(
+        encoded: Option<&str>,
+        host: HostProfile,
+        username: &str,
+    ) -> io::Result<Self> {
+        let raw = decode_raw(encoded.unwrap_or_default())?;
+        let seed = raw.seed.unwrap_or(host.fixed_int(i32::MAX as u32) as i32);
+        let unlocked = raw.unlock_all.unwrap_or(false);
+        let implicit = |name: &str, upper: u32| {
+            if upper == 0 {
+                0
+            } else {
+                fixed_hash(format!("{seed}:{name}").as_bytes(), false) % upper
+            }
+        };
+        let fragment = raw.fragment.unwrap_or_default();
+        let nonce = raw.nonce.unwrap_or_default();
+        let padding = raw.padding.unwrap_or_default();
+        let low = raw.low_entropy.unwrap_or_default();
+        let nonce_min = nonce.minimum.unwrap_or_else(|| {
+            if unlocked {
+                implicit("nonce.minLen", 13) as i32
+            } else {
+                6 + implicit("nonce.minLen", 7) as i32
+            }
+        });
+        let nonce_max = nonce.maximum.unwrap_or_else(|| {
+            nonce_min + implicit("nonce.maxLen", (13 - nonce_min) as u32) as i32
+        });
+        let rotation = low.rotation.unwrap_or_else(|| {
+            let value = implicit("lowEntropy.maskRotation", 31) as i32;
+            if value <= 15 {
+                value
+            } else {
+                (value - 15) * 16
+            }
+        });
+        Ok(Self {
+            fragment: fragment
+                .enable
+                .unwrap_or_else(|| unlocked && implicit("tcpFragment.enable", 2) == 1),
+            max_sleep_ms: fragment.max_sleep_ms.unwrap_or_else(|| {
+                if unlocked {
+                    1 + implicit("tcpFragment.maxSleepMs", 100) as i32
+                } else {
+                    0
+                }
+            }) as u64,
+            nonce_kind: nonce.kind.unwrap_or_else(|| {
+                if unlocked {
+                    implicit("nonce.type", 3) as i32
+                } else {
+                    1 + implicit("nonce.type", 2) as i32
+                }
+            }),
+            all_udp: nonce
+                .all_udp
+                .unwrap_or_else(|| implicit("nonce.applyToAllUDPPacket", 2) == 1),
+            nonce_min: nonce_min as usize,
+            nonce_max: nonce_max as usize,
+            fixed_nonce: nonce
+                .fixed
+                .iter()
+                .map(|value| decode_prefix(value))
+                .collect::<io::Result<_>>()?,
+            middle: padding.middle.unwrap_or_else(|| {
+                (implicit("padding.maxMiddlePaddingLen", 256) as i32 - 128).max(0)
+            }) as usize,
+            end: padding.end.unwrap_or_else(|| {
+                if unlocked {
+                    implicit("padding.maxEndPaddingLen", 256) as i32
+                } else {
+                    255
+                }
+            }) as usize,
+            low_mode: low.mode.unwrap_or_else(|| {
+                if unlocked {
+                    implicit("lowEntropy.mode", 5) as i32
+                } else {
+                    0
+                }
+            }) as u8,
+            rotation: rotation as u8,
+            padding_bit: host.fixed_int(2) as u8,
+            ascii_run: 24 + host.fixed_int(17) as usize,
+            control_entropy: !fixed_hash(username.as_bytes(), true).is_multiple_of(2),
+        })
+    }
+
+    pub(crate) fn low_entropy_enabled(&self) -> bool {
+        self.low_mode != 0
+    }
+
+    fn body(&self, random: &mut impl PatternRandom) -> io::Result<BodyEncoding> {
+        if !self.low_entropy_enabled() {
+            return Ok(BodyEncoding::Plain);
+        }
+        let count = 12 + usize::from(self.low_mode) * 4;
+        let mut mask = 0u32;
+        let mut needed = count;
+        // Sampling without replacement gives each mask of this population the
+        // same probability, without an allocation or an unbounded rejection loop.
+        for bit in 0..32 {
+            if random.uniform(32 - bit) < needed {
+                mask |= 1 << bit;
+                needed -= 1;
+            }
+        }
+        Ok(BodyEncoding::LowEntropy(LowEntropyEncoding {
+            mode: self.low_mode,
+            half_mask: mask,
+            rotation: self.rotation,
+            padding_bit: self.padding_bit,
+        }))
+    }
+
+    pub(crate) fn plaintext_fragment_limit(
+        &self,
+        transport: MieruTransport,
+        wire_budget: usize,
+    ) -> io::Result<usize> {
+        let available = match transport {
+            MieruTransport::Tcp => u16::MAX as usize,
+            MieruTransport::Udp => wire_budget
+                .checked_sub(PACKET_OVERHEAD)
+                .ok_or_else(invalid_pattern)?,
+        }
+        .min(u16::MAX as usize);
+        let maximum = if self.low_entropy_enabled() {
+            let source = 3 + usize::from(self.low_mode);
+            available / 8 * source
+        } else {
+            available
+        };
+        let maximum = maximum.min(MAX_DATA_PAYLOAD);
+        if maximum == 0 {
+            return Err(invalid_pattern());
+        }
+        Ok(maximum)
+    }
+
+    pub(crate) fn prepare_frame(
+        &self,
+        metadata: Metadata,
+        plain_len: usize,
+        transport: MieruTransport,
+        wire_budget: usize,
+    ) -> io::Result<PreparedFrame> {
+        self.prepare_with(
+            metadata,
+            plain_len,
+            transport,
+            wire_budget,
+            &mut rand::rng(),
+        )
+    }
+
+    fn prepare_with(
+        &self,
+        metadata: Metadata,
+        plain_len: usize,
+        transport: MieruTransport,
+        wire_budget: usize,
+        random: &mut impl PatternRandom,
+    ) -> io::Result<PreparedFrame> {
+        let control = matches!(metadata, Metadata::Session(_));
+        if plain_len
+            > if control {
+                MAX_CONTROL_PAYLOAD
+            } else {
+                MAX_DATA_PAYLOAD
+            }
+        {
+            return Err(invalid_pattern());
+        }
+        let data = matches!(metadata, Metadata::Data(v) if matches!(v.kind, DataKind::ClientData | DataKind::ServerData));
+        let body = if data && plain_len != 0 {
+            self.body(random)?
+        } else {
+            BodyEncoding::Plain
+        };
+        let body_len = body.encoded_len(plain_len)?;
+        let available = match transport {
+            MieruTransport::Tcp => usize::MAX,
+            MieruTransport::Udp => wire_budget
+                .checked_sub(PACKET_OVERHEAD + body_len)
+                .ok_or_else(invalid_pattern)?,
+        };
+        let mut result = PreparedFrame {
+            prefix: [0; 255],
+            suffix: [0; 255],
+            prefix_len: 0,
+            suffix_len: 0,
+            body,
+        };
+        if control {
+            let cap = self.end.min(available);
+            result.suffix_len = if self.control_entropy {
+                let surrogate_len = if transport == MieruTransport::Tcp {
+                    64
+                } else {
+                    88
+                } + plain_len;
+                let mut ones = 0;
+                let mut remaining = surrogate_len;
+                let mut scratch = [0u8; 256];
+                while remaining != 0 {
+                    let len = remaining.min(scratch.len());
+                    random.fill(&mut scratch[..len]);
+                    ones += scratch[..len]
+                        .iter()
+                        .map(|b| b.count_ones() as usize)
+                        .sum::<usize>();
+                    remaining -= len;
+                }
+                entropy_padding(&mut result.suffix[..cap], surrogate_len * 8, ones, random)
+            } else {
+                ascii_padding(&mut result.suffix[..cap], self.ascii_run.min(cap), random)
+            };
+        } else {
+            let cap = self.middle.min(available);
+            result.prefix_len = ascii_padding(&mut result.prefix[..cap], 0, random);
+            let cap = self.end.min(available.saturating_sub(result.prefix_len));
+            result.suffix_len = ascii_padding(&mut result.suffix[..cap], 0, random);
+        }
+        Ok(result)
+    }
+
+    pub(crate) fn control_chunks(&self, frame_len: usize) -> ControlChunks {
+        ControlChunks {
+            frame_len,
+            position: 0,
+            fragmented: self.fragment,
+            max_sleep_ms: self.max_sleep_ms,
+        }
+    }
+
+    pub(crate) fn rewrite_nonce(
+        &self,
+        state: &mut NonceState,
+        nonce: &mut [u8; 24],
+        transport: MieruTransport,
+    ) {
+        self.rewrite_with(state, nonce, transport, &mut rand::rng());
+    }
+
+    fn rewrite_with(
+        &self,
+        state: &mut NonceState,
+        nonce: &mut [u8; 24],
+        transport: MieruTransport,
+        random: &mut impl PatternRandom,
+    ) {
+        if !state.first && (transport == MieruTransport::Tcp || !self.all_udp) {
+            return;
+        }
+        state.first = false;
+        match self.nonce_kind {
+            1 | 2 => {
+                // Explicit maximum can be below an implicitly generated minimum.
+                // Raw validation precedes defaults; the actual consumer clamps it.
+                let min = self.nonce_min.min(self.nonce_max);
+                let len = if min == self.nonce_max {
+                    min
+                } else {
+                    min + random.uniform(self.nonce_max - min + 1)
+                };
+                if self.nonce_kind == 1 {
+                    printable(&mut nonce[..len], random);
+                } else {
+                    for b in &mut nonce[..len] {
+                        *b = COMMON_64[usize::from(*b & 63)];
+                    }
+                }
+            }
+            3 if !self.fixed_nonce.is_empty() => {
+                let prefix = &self.fixed_nonce[random.uniform(self.fixed_nonce.len())];
+                nonce[..prefix.len].copy_from_slice(&prefix.bytes[..prefix.len]);
+            }
+            _ => {}
+        }
+    }
+}
+
+pub(crate) struct NonceState {
+    first: bool,
+}
+impl NonceState {
+    pub(crate) fn new() -> Self {
+        Self { first: true }
+    }
+}
+
+/// Temporary stack-owned padding and one immutable body descriptor.
+pub(crate) struct PreparedFrame {
+    prefix: [u8; PADDING_LIMIT],
+    suffix: [u8; PADDING_LIMIT],
+    prefix_len: usize,
+    suffix_len: usize,
+    body: BodyEncoding,
+}
+impl PreparedFrame {
+    pub(crate) fn encoding(&self) -> FrameEncoding<'_> {
+        FrameEncoding {
+            padding: Padding {
+                prefix: &self.prefix[..self.prefix_len],
+                suffix: &self.suffix[..self.suffix_len],
+            },
+            body: self.body,
+        }
+    }
+}
+
+pub(crate) struct WriteChunk {
+    pub(crate) range: Range<usize>,
+    pub(crate) delay_after: Duration,
+}
+pub(crate) struct ControlChunks {
+    frame_len: usize,
+    position: usize,
+    fragmented: bool,
+    max_sleep_ms: u64,
+}
+impl Iterator for ControlChunks {
+    type Item = WriteChunk;
+    fn next(&mut self) -> Option<Self::Item> {
+        self.next_with(&mut rand::rng())
+    }
+}
+impl ControlChunks {
+    fn next_with(&mut self, random: &mut impl PatternRandom) -> Option<WriteChunk> {
+        if self.position == self.frame_len {
+            return None;
+        }
+        let (len, delay_after) = if self.fragmented {
+            let min = (self.frame_len as f64).sqrt() as usize + 1;
+            let max = min.max(self.frame_len / 2);
+            let len = (min + random.uniform(max - min + 1)).min(self.frame_len - self.position);
+            // The reference sleeps after every piece, including the final one.
+            let delay = if self.max_sleep_ms == 0 {
+                0
+            } else {
+                random.uniform(self.max_sleep_ms as usize + 1) as u64
+            };
+            (len, Duration::from_millis(delay))
+        } else {
+            (self.frame_len - self.position, Duration::ZERO)
+        };
+        let start = self.position;
+        self.position += len;
+        Some(WriteChunk {
+            range: start..self.position,
+            delay_after,
+        })
+    }
+}
+
+trait PatternRandom {
+    fn uniform(&mut self, upper: usize) -> usize;
+    fn unit(&mut self) -> f64;
+    fn fill(&mut self, bytes: &mut [u8]);
+}
+impl<R: rand::Rng + ?Sized> PatternRandom for R {
+    fn uniform(&mut self, upper: usize) -> usize {
+        self.random_range(0..upper)
+    }
+    fn unit(&mut self) -> f64 {
+        self.random()
+    }
+    fn fill(&mut self, bytes: &mut [u8]) {
+        rand::RngExt::fill(self, bytes);
+    }
+}
+
+fn biased_int(random: &mut impl PatternRandom, upper: usize) -> usize {
+    let scale = random.unit();
+    (random.uniform(upper + 1) as f64 * (scale * scale * scale).sqrt()) as usize
+}
+
+fn printable(bytes: &mut [u8], random: &mut impl PatternRandom) {
+    for byte in bytes {
+        if (32..=126).contains(byte) {
+            continue;
+        }
+        if (32..=126).contains(&(*byte & 127)) {
+            *byte &= 127;
+            continue;
+        }
+        loop {
+            let mut draw = [0; 2];
+            random.fill(&mut draw);
+            let draw = u16::from_be_bytes(draw);
+            if draw < 65_455 {
+                *byte = 32 + (draw % 95) as u8;
+                break;
+            }
+        }
+    }
+}
+
+fn ascii_padding(output: &mut [u8], run: usize, random: &mut impl PatternRandom) -> usize {
+    let len = run + biased_int(random, output.len() - run + 1);
+    random.fill(&mut output[..len]);
+    let start = if len > run {
+        random.uniform(len - run)
+    } else {
+        0
+    };
+    printable(&mut output[start..start + run], random);
+    len
+}
+
+fn entropy_padding(
+    output: &mut [u8],
+    bits: usize,
+    ones: usize,
+    random: &mut impl PatternRandom,
+) -> usize {
+    let zeros = bits - ones;
+    let minority_one = ones < zeros;
+    let minority = ones.min(zeros);
+    let minimum_bits = (minority as f64 / 0.325 - bits as f64).max(0.0) as usize;
+    let minimum = minimum_bits.div_ceil(8);
+    let len = if minimum >= output.len() {
+        output.len()
+    } else {
+        minimum + biased_int(random, output.len() - minimum + 1)
+    };
+    output[..len].fill(if minority_one { 0 } else { 255 });
+    let flips = (((bits + len * 8) as f64 * 0.325) as usize)
+        .saturating_sub(minority)
+        .min(len * 8);
+    // Repeated positions are intentional; deduplication changes camouflage.
+    for _ in 0..flips {
+        let bit = random.uniform(len * 8);
+        if minority_one {
+            output[bit / 8] |= 1 << (bit % 8);
+        } else {
+            output[bit / 8] &= !(1 << (bit % 8));
+        }
+    }
+    len
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::{
+        crypto::make_client_nonce,
+        wire::{DataMetadata, SessionKind, SessionMetadata},
+    };
+    use super::*;
+    use std::collections::VecDeque;
+
+    // Hand-encoded protobuf fields, independent of prost's encoder. Both set
+    // fixed aabbcc nonce, zero padding, mode 32 and rotation zero. Only TCP
+    // enables control fragmentation; max sleep is explicitly zero.
+    const TCP: &str = "CAAaBAgBEAAiEAgDEAEYACAAKgZhYWJiY2MqBAgAEAAyBAgBEAA=";
+    const UDP: &str = "CAAaBAgAEAAiEAgDEAEYACAAKgZhYWJiY2MqBAgAEAAyBAgBEAA=";
+    fn host() -> HostProfile {
+        HostProfile(fixed_hash(b"vole-fixture", true))
+    }
+    fn frame() -> Metadata {
+        Metadata::Data(DataMetadata {
+            kind: DataKind::ClientData,
+            session_id: 1,
+            sequence: 0,
+            unack_sequence: 0,
+            window: 16,
+            fragment: 0,
+        })
+    }
+    fn control() -> Metadata {
+        Metadata::Session(SessionMetadata {
+            kind: SessionKind::OpenRequest,
+            session_id: 1,
+            sequence: 0,
+            status: 0,
+        })
+    }
+    struct FixedRandom {
+        draws: VecDeque<usize>,
+        bytes: VecDeque<u8>,
+        fallback_byte: u8,
+        fraction: f64,
+    }
+    impl Default for FixedRandom {
+        fn default() -> Self {
+            Self {
+                draws: VecDeque::new(),
+                bytes: VecDeque::new(),
+                fallback_byte: 0x55,
+                fraction: 0.25,
+            }
+        }
+    }
+    impl PatternRandom for FixedRandom {
+        fn uniform(&mut self, upper: usize) -> usize {
+            let value = self.draws.pop_front().unwrap_or(0);
+            assert!(value < upper);
+            value
+        }
+        fn unit(&mut self) -> f64 {
+            self.fraction
+        }
+        fn fill(&mut self, bytes: &mut [u8]) {
+            for byte in bytes {
+                *byte = self.bytes.pop_front().unwrap_or(self.fallback_byte);
+            }
+        }
+    }
+
+    #[test]
+    fn implicit_profile_uses_host_version_and_scalar_presence() {
+        assert_eq!(host().0, 1_090_847_407);
+        assert_eq!(host().fixed_int(17), 9);
+        let default = EffectivePattern::compile(None, host(), "bob").unwrap();
+        assert!(!default.fragment && !default.all_udp);
+        assert_eq!(
+            (default.nonce_kind, default.nonce_min, default.nonce_max),
+            (2, 12, 12)
+        );
+        assert_eq!(
+            (
+                default.middle,
+                default.end,
+                default.low_mode,
+                default.rotation
+            ),
+            (96, 255, 0, 48)
+        );
+        assert_eq!((default.ascii_run, default.padding_bit), (33, 1));
+        let explicit = EffectivePattern::compile(Some(TCP), host(), "bob").unwrap();
+        assert!(explicit.fragment && explicit.all_udp && explicit.low_entropy_enabled());
+        assert_eq!(
+            (
+                explicit.nonce_min,
+                explicit.nonce_max,
+                explicit.middle,
+                explicit.end
+            ),
+            (0, 0, 0, 0)
+        );
+        assert_eq!(explicit.rotation, 0);
+        // unlockAll=true does not overwrite a present false/zero. Signed seed
+        // participates in its decimal implicit hint without extra restrictions.
+        let raw = RawPattern {
+            seed: Some(-1),
+            unlock_all: Some(true),
+            fragment: Some(RawFragment {
+                enable: Some(false),
+                max_sleep_ms: Some(0),
+            }),
+            ..Default::default()
+        };
+        let encoded = general_purpose::STANDARD.encode(raw.encode_to_vec());
+        let signed = EffectivePattern::compile(Some(&encoded), host(), "bob").unwrap();
+        assert!(!signed.fragment);
+        assert_eq!(
+            (
+                signed.max_sleep_ms,
+                signed.nonce_kind,
+                signed.nonce_min,
+                signed.end,
+                signed.low_mode
+            ),
+            (0, 1, 9, 63, 3)
+        );
+    }
+
+    #[test]
+    fn base64_and_raw_validation_preserve_upstream_boundaries() {
+        let raw = decode_raw("C\r\nAB=").unwrap();
+        assert_eq!(raw.seed, Some(0)); // noncanonical unused tail bits accepted
+        assert!(decode_raw("C AB=").is_err());
+        assert!(decode_raw("CAA").is_err()); // StdEncoding requires padding
+        // An unknown nonce enum is a no-op, not an enum validation failure.
+        let raw = RawPattern {
+            nonce: Some(RawNonce {
+                kind: Some(99),
+                maximum: Some(0),
+                ..Default::default()
+            }),
+            ..Default::default()
+        };
+        let encoded = general_purpose::STANDARD.encode(raw.encode_to_vec());
+        validate_raw(&encoded).unwrap();
+        let pattern = EffectivePattern::compile(Some(&encoded), host(), "bob").unwrap();
+        assert!(pattern.nonce_min > pattern.nonce_max);
+        let mut nonce = [7; 24];
+        let mut state = NonceState::new();
+        pattern.rewrite_with(
+            &mut state,
+            &mut nonce,
+            MieruTransport::Udp,
+            &mut FixedRandom::default(),
+        );
+        assert_eq!(nonce, [7; 24]);
+        assert!(!state.first);
+        // Only the relationship between two explicit nonce bounds is checked.
+        let mut raw = raw;
+        raw.nonce.as_mut().unwrap().minimum = Some(1);
+        assert!(validate(&raw).is_err());
+        assert!(
+            validate(&RawPattern {
+                low_entropy: Some(RawLowEntropy {
+                    mode: Some(1),
+                    rotation: Some(17)
+                }),
+                ..Default::default()
+            })
+            .is_err()
+        );
+        assert!(
+            validate(&RawPattern {
+                nonce: Some(RawNonce {
+                    fixed: vec!["0x".into()],
+                    ..Default::default()
+                }),
+                ..Default::default()
+            })
+            .is_err()
+        );
+    }
+
+    #[test]
+    fn fixed_nonce_applies_per_physical_carrier_and_preserves_user_hint() {
+        let mut pattern = EffectivePattern::compile(Some(UDP), host(), "vole").unwrap();
+        let raw: [u8; 24] = std::array::from_fn(|i| i as u8);
+        let mut state = NonceState::new();
+        let mut nonce = raw;
+        pattern.rewrite_with(
+            &mut state,
+            &mut nonce,
+            MieruTransport::Udp,
+            &mut FixedRandom::default(),
+        );
+        assert_eq!(&nonce[..3], &[0xaa, 0xbb, 0xcc]);
+        assert_eq!(&nonce[3..], &raw[3..]);
+        let nonce = make_client_nonce("vole", nonce);
+        assert_eq!(&nonce[20..], &[0x4e, 0x5b, 0xb3, 0xbf]);
+        pattern.all_udp = false;
+        let mut next = raw;
+        pattern.rewrite_with(
+            &mut state,
+            &mut next,
+            MieruTransport::Udp,
+            &mut FixedRandom::default(),
+        );
+        assert_eq!(next, raw);
+        let mut fresh = NonceState::new();
+        pattern.rewrite_with(
+            &mut fresh,
+            &mut next,
+            MieruTransport::Udp,
+            &mut FixedRandom::default(),
+        );
+        assert_eq!(&next[..3], &[0xaa, 0xbb, 0xcc]);
+        // A fresh UDP attempt still follows apply-all; TCP generates one
+        // explicit patterned nonce, then its cipher increments internally.
+        pattern.all_udp = true;
+        let mut next = raw;
+        pattern.rewrite_with(
+            &mut state,
+            &mut next,
+            MieruTransport::Udp,
+            &mut FixedRandom::default(),
+        );
+        assert_eq!(&next[..3], &[0xaa, 0xbb, 0xcc]);
+        let mut next = raw;
+        pattern.rewrite_with(
+            &mut state,
+            &mut next,
+            MieruTransport::Tcp,
+            &mut FixedRandom::default(),
+        );
+        assert_eq!(next, raw);
+    }
+
+    #[test]
+    fn printable_and_subset_nonce_vectors_are_independent_of_padding_bias() {
+        let mut pattern = EffectivePattern::compile(Some(UDP), host(), "vole").unwrap();
+        pattern.nonce_kind = 1;
+        pattern.nonce_min = 8;
+        pattern.nonce_max = 8;
+        let mut nonce: [u8; 24] = std::array::from_fn(|i| i as u8);
+        nonce[..8].copy_from_slice(&[0x20, 0x7e, 0xa0, 0xfe, 0x1f, 0x7f, 0xff, 0]);
+        let mut random = FixedRandom {
+            bytes: VecDeque::from([0xff, 0xaf, 0, 0, 0, 94, 0, 95, 0, 189]),
+            ..Default::default()
+        };
+        pattern.rewrite_with(
+            &mut NonceState::new(),
+            &mut nonce,
+            MieruTransport::Udp,
+            &mut random,
+        );
+        assert_eq!(
+            &nonce[..8],
+            &[0x20, 0x7e, 0x20, 0x7e, 0x20, 0x7e, 0x20, 0x7e]
+        );
+        assert_eq!(
+            &make_client_nonce("vole", nonce)[20..],
+            &[0xb8, 0xd8, 0xa2, 0x30]
+        );
+        pattern.nonce_kind = 2;
+        pattern.nonce_min = 6;
+        pattern.nonce_max = 6;
+        nonce = std::array::from_fn(|i| i as u8);
+        nonce[..6].copy_from_slice(&[0, 1, 2, 63, 64, 255]);
+        pattern.rewrite_with(
+            &mut NonceState::new(),
+            &mut nonce,
+            MieruTransport::Udp,
+            &mut FixedRandom::default(),
+        );
+        assert_eq!(&nonce[..6], b"CCO4C4");
+        assert_eq!(
+            &make_client_nonce("vole", nonce)[20..],
+            &[0xbd, 0xcc, 0xc2, 0xa8]
+        );
+    }
+
+    #[test]
+    fn control_padding_uses_username_version_and_both_recommended_strategies() {
+        assert_eq!(fixed_hash(b"alice", true), 391_071_193);
+        assert_eq!(fixed_hash(b"bob", true), 1_310_367_922);
+        let ascii = EffectivePattern::compile(None, host(), "bob").unwrap();
+        let prepared = ascii
+            .prepare_with(
+                control(),
+                0,
+                MieruTransport::Tcp,
+                usize::MAX,
+                &mut FixedRandom::default(),
+            )
+            .unwrap();
+        assert!(prepared.encoding().padding.prefix.is_empty());
+        assert_eq!(prepared.encoding().padding.suffix, &[0x55; 33]);
+        let entropy = EffectivePattern::compile(None, host(), "alice").unwrap();
+        let mut random = FixedRandom {
+            draws: VecDeque::from([200]),
+            ..Default::default()
+        };
+        let prepared = entropy
+            .prepare_with(control(), 0, MieruTransport::Tcp, usize::MAX, &mut random)
+            .unwrap();
+        let suffix = prepared.encoding().padding.suffix;
+        assert_eq!(suffix.len(), 60);
+        assert_eq!(suffix[0], 0xfe); // all 66 flips target position zero
+        assert!(suffix[1..].iter().all(|byte| *byte == 0xff));
+        let mut output = [0; 1];
+        // x=0 gives no minimum padding. Select length one explicitly:
+        // floor(2 * sqrt(0.999^3))=1, then repeat bit position zero.
+        let mut random = FixedRandom {
+            draws: VecDeque::from([2]),
+            fraction: 0.999,
+            ..Default::default()
+        };
+        assert_eq!(entropy_padding(&mut output, 32, 0, &mut random), 1);
+        assert_eq!(output, [1]);
+        assert_eq!(
+            entropy_padding(&mut [], 32, 16, &mut FixedRandom::default()),
+            0
+        );
+    }
+
+    #[test]
+    fn low_entropy_fragment_and_padding_share_the_real_udp_budget() {
+        let mut pattern = EffectivePattern::compile(Some(UDP), host(), "vole").unwrap();
+        for (mode, source) in [(1, 4), (2, 5), (3, 6), (4, 7)] {
+            pattern.low_mode = mode;
+            assert_eq!(
+                pattern
+                    .plaintext_fragment_limit(MieruTransport::Udp, 96)
+                    .unwrap(),
+                source
+            );
+            assert_eq!(
+                pattern
+                    .plaintext_fragment_limit(MieruTransport::Udp, 128)
+                    .unwrap(),
+                5 * source
+            );
+            let prepared = pattern
+                .prepare_with(
+                    frame(),
+                    source,
+                    MieruTransport::Udp,
+                    96,
+                    &mut FixedRandom::default(),
+                )
+                .unwrap();
+            let BodyEncoding::LowEntropy(body) = prepared.encoding().body else {
+                panic!("expected LE");
+            };
+            assert_eq!(body.half_mask.count_ones(), 12 + u32::from(mode) * 4);
+            assert_eq!(body.encoded_len(source).unwrap(), 8);
+            assert!(
+                pattern
+                    .prepare_frame(frame(), source + 1, MieruTransport::Udp, 96)
+                    .is_err()
+            );
+        }
+        pattern.low_mode = 1;
+        assert_eq!(
+            pattern
+                .plaintext_fragment_limit(MieruTransport::Tcp, usize::MAX)
+                .unwrap(),
+            32_764
+        );
+        assert!(
+            pattern
+                .plaintext_fragment_limit(MieruTransport::Udp, 95)
+                .is_err()
+        );
+        pattern.middle = 255;
+        pattern.end = 255;
+        let mut random = FixedRandom {
+            fraction: 0.999,
+            ..Default::default()
+        };
+        let prepared = pattern
+            .prepare_with(frame(), 4, MieruTransport::Udp, 128, &mut random)
+            .unwrap();
+        let encoding = prepared.encoding();
+        assert!(
+            PACKET_OVERHEAD
+                + encoding.body.encoded_len(4).unwrap()
+                + encoding.padding.prefix.len()
+                + encoding.padding.suffix.len()
+                <= 128
+        );
+    }
+
+    #[test]
+    fn control_fragment_ranges_and_final_delay_follow_the_physical_write() {
+        let pattern = EffectivePattern::compile(Some(TCP), host(), "vole").unwrap();
+        let mut chunks = pattern.control_chunks(100);
+        chunks.max_sleep_ms = 100;
+        let mut random = FixedRandom {
+            draws: (0..10).flat_map(|_| [0, 7]).collect(),
+            ..Default::default()
+        };
+        let mut end = 0;
+        let mut count = 0;
+        while let Some(chunk) = chunks.next_with(&mut random) {
+            assert_eq!(chunk.range.start, end);
+            assert_eq!(chunk.delay_after, Duration::from_millis(7));
+            end = chunk.range.end;
+            count += 1;
+        }
+        assert_eq!((end, count), (100, 10));
+        let default = EffectivePattern::compile(None, host(), "vole").unwrap();
+        let chunks: Vec<_> = default.control_chunks(100).collect();
+        assert_eq!(chunks.len(), 1);
+        assert_eq!(chunks[0].range, 0..100);
+        assert_eq!(chunks[0].delay_after, Duration::ZERO);
+    }
+}
diff --git a/src/outbound/mieru/reliability.rs b/src/outbound/mieru/reliability.rs
new file mode 100644
index 0000000..7b36dc1
--- /dev/null
+++ b/src/outbound/mieru/reliability.rs
@@ -0,0 +1,174 @@
+//! Timer-free models for Mieru's reliable carrier. The driver owns packets and permits.
+//!
+//! The RTT estimator and CUBIC equation are implemented independently from their
+//! mathematical definitions, with Mieru's segment units and timing profile.
+//! https://www.rfc-editor.org/rfc/rfc6298
+//! https://www.rfc-editor.org/rfc/rfc9438
+use std::time::Duration;
+use tokio::time::Instant;
+
+pub(super) struct Rtt {
+    estimate: Option<(Duration, Duration)>,
+}
+
+impl Rtt {
+    pub fn new() -> Self {
+        Self { estimate: None }
+    }
+
+    pub fn update(&mut self, sample: Duration) {
+        if sample.is_zero() || sample.as_nanos() >= i64::MAX as u128 {
+            return;
+        }
+        self.estimate = Some(match self.estimate {
+            None => (sample, sample / 2),
+            Some((delay, variation)) => {
+                // The peer's profile quantizes subsequent estimates to whole
+                // microseconds, performing the weighted sums in float32.
+                let delta = delay.abs_diff(sample).as_micros() as f32;
+                let variation = variation.as_micros() as f32 * 0.75 + delta * 0.25;
+                let delay = delay.as_micros() as f32 * 0.875 + sample.as_micros() as f32 * 0.125;
+                (
+                    Duration::from_micros(delay as u64),
+                    Duration::from_micros(variation as u64),
+                )
+            }
+        });
+    }
+
+    pub fn rto(&self) -> Duration {
+        let Some((delay, variation)) = self.estimate else {
+            return Duration::from_secs(2);
+        };
+        let base = delay
+            .saturating_add(variation.saturating_mul(4).max(Duration::from_millis(10)))
+            .saturating_add(Duration::from_millis(1));
+        scale(base, 1.5)
+    }
+
+    pub fn retransmit_delay(&self, tx_count: u32) -> Duration {
+        Self::retransmit_delay_from_rto(self.rto(), tx_count)
+    }
+
+    pub fn retransmit_delay_from_rto(base_rto: Duration, tx_count: u32) -> Duration {
+        // Count includes the first transmission. The legacy duration cast
+        // truncates the exponential multiplier before it scales the RTO.
+        scale(base_rto, 1.5_f64.powf(f64::from(tx_count)).floor()).min(Duration::from_secs(10))
+    }
+}
+
+fn scale(duration: Duration, multiplier: f64) -> Duration {
+    let nanos = (duration.as_nanos() as f64 * multiplier) as u128;
+    Duration::new(
+        (nanos / 1_000_000_000).min(u64::MAX as u128) as u64,
+        (nanos % 1_000_000_000) as u32,
+    )
+}
+
+struct Recovery {
+    peak: u32,
+    began: Instant,
+    acknowledged: u64,
+}
+
+pub(super) struct Cubic {
+    segments: u32,
+    recovery: Option<Recovery>,
+}
+
+impl Cubic {
+    pub fn new() -> Self {
+        Self {
+            segments: 16,
+            recovery: None,
+        }
+    }
+
+    pub fn window(&self) -> u32 {
+        self.segments
+    }
+
+    pub fn on_ack(&mut self, now: Instant) -> u32 {
+        self.segments = match self.recovery.as_mut() {
+            None => self.segments.saturating_add(1),
+            Some(recovery) => {
+                recovery.acknowledged = recovery.acknowledged.saturating_add(1);
+                let origin = (f64::from(recovery.peak) * 0.3 / 0.4).cbrt();
+                let elapsed = now.saturating_duration_since(recovery.began).as_secs_f64();
+                let curve = 0.4 * (elapsed - origin).powi(3) + f64::from(recovery.peak);
+                (curve as u32)
+                    .saturating_add(u32::try_from(recovery.acknowledged / 16).unwrap_or(u32::MAX))
+            }
+        }
+        .clamp(16, 4096);
+        self.segments
+    }
+
+    pub fn on_loss(&mut self, now: Instant) -> u32 {
+        self.recovery = Some(Recovery {
+            peak: self.segments,
+            began: now,
+            acknowledged: 0,
+        });
+        self.segments = ((f64::from(self.segments) * 0.7) as u32).clamp(16, 4096);
+        self.segments
+    }
+
+    pub fn on_timeout(&mut self) -> u32 {
+        *self = Self::new();
+        self.segments
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn mieru_rtt_quantization_and_retransmission_profile() {
+        let mut rtt = Rtt::new();
+        assert_eq!(rtt.rto(), Duration::from_secs(2));
+        assert_eq!(
+            (1..=5)
+                .map(|count| rtt.retransmit_delay(count).as_millis())
+                .collect::<Vec<_>>(),
+            [2000, 4000, 6000, 10000, 10000]
+        );
+        // Independent Python float32/whole-microsecond calculations. The first
+        // fractional-microsecond sample also distinguishes truncation from rounding.
+        for (sample, expected) in [
+            (100_000_015, 451_500_064),
+            (80_000_000, 402_750_000),
+            (140_000_000, 410_718_000),
+        ] {
+            rtt.update(Duration::from_nanos(sample));
+            assert_eq!(rtt.rto(), Duration::from_nanos(expected));
+        }
+        let previous = rtt.rto();
+        rtt.update(Duration::ZERO);
+        assert_eq!(rtt.rto(), previous);
+        assert_eq!(rtt.retransmit_delay(20), Duration::from_secs(10));
+    }
+
+    #[test]
+    fn mieru_segment_cubic_loss_time_growth_and_timeout() {
+        let mut cubic = Cubic::new();
+        let now = Instant::now();
+        for _ in 0..48 {
+            cubic.on_ack(now);
+        }
+        assert_eq!(cubic.window(), 64);
+        assert_eq!(cubic.on_loss(now), 44);
+        for _ in 0..16 {
+            cubic.on_ack(now);
+        }
+        // Evaluated independently from the public polynomial at peak 64.
+        assert_eq!(cubic.window(), 45);
+        for (seconds, expected) in [(1, 57), (3, 64), (10, 168)] {
+            assert_eq!(cubic.on_ack(now + Duration::from_secs(seconds)), expected);
+        }
+        assert_eq!(cubic.on_ack(now + Duration::from_secs(100)), 4096);
+        assert_eq!(cubic.on_timeout(), 16);
+        assert_eq!(cubic.on_ack(now), 17);
+    }
+}
diff --git a/src/outbound/mieru/stream.rs b/src/outbound/mieru/stream.rs
new file mode 100644
index 0000000..de0d759
--- /dev/null
+++ b/src/outbound/mieru/stream.rs
@@ -0,0 +1,634 @@
+//! Logical Mieru byte streams and the lazy SOCKS business handshake.
+use super::tcp::{Business, Carrier, WriterCommand};
+use crate::{
+    resources::observation::{self, ResourceKind},
+    session::Destination,
+    socks5,
+};
+use bytes::Bytes;
+use futures_util::{future::BoxFuture, task::AtomicWaker};
+use std::{
+    collections::VecDeque,
+    io,
+    pin::Pin,
+    sync::{
+        Arc, Mutex,
+        atomic::{AtomicBool, AtomicU8, AtomicU32, Ordering},
+    },
+    task::{Context, Poll, Wake, Waker, ready},
+    time::Duration,
+};
+use tokio::{
+    io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt, ReadBuf},
+    sync::{Notify, OwnedSemaphorePermit, Semaphore, oneshot},
+    time::{Instant, timeout_at},
+};
+use tokio_util::sync::CancellationToken;
+
+pub(super) fn closed() -> io::Error {
+    io::ErrorKind::BrokenPipe.into()
+}
+#[derive(Default)]
+struct Input {
+    queue: VecDeque<ReceivedChunk>,
+    failure: bool,
+    finished: bool,
+}
+pub(super) struct ReceivedChunk {
+    pub bytes: Bytes,
+    pub permit: OwnedSemaphorePermit,
+}
+const ACK_DRAINED: u8 = 0;
+const ACK_PENDING: u8 = 1;
+const ACK_TERMINAL: u8 = 2;
+
+pub(super) struct State {
+    pub id: u32,
+    pub(super) business: Business,
+    pub opened: AtomicBool,
+    pub sequence: AtomicU32,
+    pub next_receive: AtomicU32,
+    pub local_closed: AtomicBool,
+    pub remote_closed: AtomicBool,
+    pub close_response: AtomicBool,
+    pub cancel: CancellationToken,
+    input: Mutex<Input>,
+    read: AtomicWaker,
+    pub write: AtomicWaker,
+    ack_drain: AtomicU8,
+    space: Notify,
+    pub activity: Arc<Notify>,
+    capacity: usize,
+    pub receive_bytes: Arc<Semaphore>,
+    _observation: observation::Guard,
+}
+impl State {
+    pub(super) fn mark_ack_pending(&self) {
+        if self.business == Business::TcpConnect {
+            let _ = self.ack_drain.compare_exchange(
+                ACK_DRAINED,
+                ACK_PENDING,
+                Ordering::AcqRel,
+                Ordering::Acquire,
+            );
+        }
+    }
+
+    pub(super) fn mark_ack_drained(&self) {
+        if self.business != Business::TcpConnect {
+            return;
+        }
+        if self
+            .ack_drain
+            .compare_exchange(
+                ACK_PENDING,
+                ACK_DRAINED,
+                Ordering::AcqRel,
+                Ordering::Acquire,
+            )
+            .is_ok()
+        {
+            self.write.wake();
+        }
+    }
+
+    pub(super) fn mark_ack_terminal(&self) {
+        if self.ack_drain.swap(ACK_TERMINAL, Ordering::AcqRel) != ACK_TERMINAL {
+            self.write.wake();
+        }
+    }
+
+    fn poll_ack_drain(&self, cx: &mut Context<'_>) -> Poll<()> {
+        self.write.register(cx.waker());
+        if self.ack_drain.load(Ordering::Acquire) == ACK_PENDING && !self.cancel.is_cancelled() {
+            Poll::Pending
+        } else {
+            Poll::Ready(())
+        }
+    }
+
+    #[cfg(test)]
+    pub fn new(
+        id: u32,
+        capacity: usize,
+        cancellation: &CancellationToken,
+        activity: Arc<Notify>,
+    ) -> Arc<Self> {
+        Self::new_for_business(id, capacity, Business::TcpConnect, cancellation, activity)
+    }
+    pub fn new_for_business(
+        id: u32,
+        capacity: usize,
+        business: Business,
+        cancellation: &CancellationToken,
+        activity: Arc<Notify>,
+    ) -> Arc<Self> {
+        Arc::new(Self {
+            id,
+            business,
+            opened: AtomicBool::new(false),
+            sequence: AtomicU32::new(0),
+            next_receive: AtomicU32::new(0),
+            local_closed: AtomicBool::new(false),
+            remote_closed: AtomicBool::new(false),
+            close_response: AtomicBool::new(false),
+            cancel: cancellation.child_token(),
+            input: Mutex::new(Input::default()),
+            read: AtomicWaker::new(),
+            write: AtomicWaker::new(),
+            ack_drain: AtomicU8::new(ACK_DRAINED),
+            space: Notify::new(),
+            activity,
+            capacity,
+            receive_bytes: Arc::new(Semaphore::new(capacity)),
+            _observation: observation::track(ResourceKind::Session),
+        })
+    }
+    pub fn close(&self) {
+        self.mark_ack_terminal();
+        self.local_closed.store(true, Ordering::Release);
+        self.cancel.cancel();
+        let mut input = self.input.lock().unwrap();
+        input.queue.clear();
+        drop(input);
+        self.read.wake();
+        self.write.wake();
+        self.space.notify_one();
+        self.activity.notify_one();
+    }
+    pub fn finish(&self, failure: bool) {
+        self.mark_ack_terminal();
+        self.remote_closed.store(true, Ordering::Release);
+        let mut input = self.input.lock().unwrap();
+        input.failure |= failure;
+        input.finished = true;
+        drop(input);
+        self.cancel.cancel();
+        self.read.wake();
+        self.write.wake();
+        self.space.notify_one();
+        self.activity.notify_one();
+    }
+    pub fn unread_segments(&self) -> usize {
+        self.input.lock().unwrap().queue.len()
+    }
+    #[cfg(test)]
+    pub(super) fn unread_bytes(&self) -> usize {
+        self.input
+            .lock()
+            .unwrap()
+            .queue
+            .iter()
+            .map(|chunk| chunk.bytes.len())
+            .sum()
+    }
+    pub(super) fn receive_capacity(&self) -> usize {
+        self.capacity
+    }
+    pub fn deliver_reserved(&self, chunk: ReceivedChunk) {
+        if chunk.bytes.is_empty() {
+            return;
+        }
+        let mut input = self.input.lock().unwrap();
+        if self.cancel.is_cancelled() {
+            return;
+        }
+        input.queue.push_back(chunk);
+        drop(input);
+        self.read.wake();
+    }
+    pub(super) fn try_deliver_reserved(&self, chunk: ReceivedChunk) -> bool {
+        let mut input = self.input.lock().unwrap();
+        if input.finished || self.cancel.is_cancelled() {
+            return false;
+        }
+        if chunk.bytes.is_empty() {
+            return true;
+        }
+        input.queue.push_back(chunk);
+        drop(input);
+        self.read.wake();
+        true
+    }
+    pub async fn deliver(&self, mut data: Bytes) -> io::Result<()> {
+        // Detach every piece of a split frame, including its final short tail.
+        // Otherwise a small queued slice keeps the whole decrypted allocation
+        // alive after delivery completes and the physical reader moves on.
+        let split_frame = data.len() > self.capacity;
+        while !data.is_empty() {
+            let count = data.len().min(self.capacity);
+            let permit = tokio::select! { biased;
+                ()=self.cancel.cancelled()=>return Err(closed()),
+                result=self.receive_bytes.clone().acquire_many_owned(count as u32)=>result.map_err(|_|closed())?,
+            };
+            let bytes = data.split_to(count);
+            self.deliver_reserved(ReceivedChunk {
+                bytes: if split_frame {
+                    Bytes::copy_from_slice(&bytes)
+                } else {
+                    bytes
+                },
+                permit,
+            });
+        }
+        Ok(())
+    }
+    pub(super) fn poll_read(
+        &self,
+        cx: &mut Context<'_>,
+        buffer: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        self.read.register(cx.waker());
+        let mut input = self.input.lock().unwrap();
+        if let Some(mut chunk) = input.queue.pop_front() {
+            let count = chunk.bytes.len().min(buffer.remaining());
+            buffer.put_slice(&chunk.bytes[..count]);
+            drop(chunk.permit.split(count).unwrap());
+            if count < chunk.bytes.len() {
+                chunk.bytes = chunk.bytes.slice(count..);
+                input.queue.push_front(chunk);
+            }
+            drop(input);
+            self.space.notify_one();
+            self.activity.notify_one();
+            return Poll::Ready(Ok(()));
+        }
+        if input.failure {
+            Poll::Ready(Err(closed()))
+        } else if input.finished || self.local_closed.load(Ordering::Acquire) {
+            Poll::Ready(Ok(()))
+        } else {
+            Poll::Pending
+        }
+    }
+}
+type WriteReady = (usize, Option<oneshot::Receiver<io::Result<()>>>);
+
+pub(super) struct RawStream {
+    pub state: Arc<State>,
+    carrier: Arc<Carrier>,
+    pending: Option<BoxFuture<'static, io::Result<WriteReady>>>,
+    queued_writes: bool,
+    latest: Option<oneshot::Receiver<io::Result<()>>>,
+    queued_admissions: u8,
+    chunk: usize,
+    ended: bool,
+}
+impl RawStream {
+    pub fn new(carrier: Arc<Carrier>, state: Arc<State>, capacity: usize) -> Self {
+        let chunk = capacity.min(32768).min(carrier.maximum_write());
+        Self {
+            state,
+            carrier,
+            pending: None,
+            queued_writes: false,
+            latest: None,
+            queued_admissions: 0,
+            chunk,
+            ended: false,
+        }
+    }
+    pub(super) fn with_queued_writes(mut self, queued: bool) -> Self {
+        self.queued_writes = queued;
+        self
+    }
+    fn poll_latest(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let Some(latest) = self.latest.as_mut() else {
+            return Poll::Ready(Ok(()));
+        };
+        let result = ready!(std::future::Future::poll(Pin::new(latest), cx));
+        self.latest = None;
+        self.queued_admissions = 0;
+        Poll::Ready(result.map_err(|_| closed()).and_then(|result| result))
+    }
+    fn accept_write(&mut self, result: io::Result<WriteReady>) -> io::Result<usize> {
+        let (count, latest) = result?;
+        // A later write's final first-send covers older same-SID FIFO writes.
+        if latest.is_some() {
+            self.queued_admissions += 1;
+        }
+        self.latest = latest;
+        Ok(count)
+    }
+    fn end(&mut self) {
+        self.ended = true;
+        self.state.close();
+        self.pending = None;
+        self.latest = None;
+    }
+}
+impl Drop for RawStream {
+    fn drop(&mut self) {
+        self.end();
+    }
+}
+impl AsyncRead for RawStream {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buffer: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        if buffer.remaining() == 0 {
+            return Poll::Ready(Ok(()));
+        }
+        self.state.poll_read(cx, buffer)
+    }
+}
+impl AsyncWrite for RawStream {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        bytes: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        self.state.write.register(cx.waker());
+        if self.ended || self.state.cancel.is_cancelled() {
+            return Poll::Ready(Err(closed()));
+        }
+        let latest = self.poll_latest(cx);
+        // Empty writes retain their original non-flushing behaviour.
+        if self.pending.is_none() && bytes.is_empty() {
+            return match latest {
+                Poll::Ready(Err(error)) => Poll::Ready(Err(error)),
+                _ => Poll::Ready(Ok(0)),
+            };
+        }
+        // Admit at most four queued writes before observing the latest first-send.
+        // Always propagate a ready error, including while the burst has room.
+        match latest {
+            Poll::Ready(result) => result?,
+            Poll::Pending if self.queued_writes && self.queued_admissions < 4 => {}
+            Poll::Pending => return Poll::Pending,
+        }
+        if self.pending.is_none() {
+            let count = bytes.len().min(self.chunk);
+            let data = Bytes::copy_from_slice(&bytes[..count]);
+            let piggyback = bytes.len() <= 1024;
+            let carrier = self.carrier.clone();
+            let state = self.state.clone();
+            let queued = self.queued_writes;
+            self.pending = Some(Box::pin(async move {
+                let operation = async {
+                    let permit = carrier
+                        .bytes
+                        .clone()
+                        .acquire_many_owned(count as u32)
+                        .await
+                        .map_err(|_| closed())?;
+                    let (done, response) = oneshot::channel();
+                    carrier
+                        .writer
+                        .send(WriterCommand {
+                            state: state.clone(),
+                            data,
+                            piggyback,
+                            done,
+                            _bytes: permit,
+                        })
+                        .await
+                        .map_err(|_| closed())?;
+                    if queued {
+                        // Ownership and the original byte permit are now in the
+                        // existing bounded command FIFO; keep only its done barrier.
+                        return Ok((count, Some(response)));
+                    }
+                    response.await.map_err(|_| closed())??;
+                    Ok((count, None))
+                };
+                tokio::select! {biased;()=state.cancel.cancelled()=>Err(closed()),result=operation=>result}
+            }));
+        }
+        let result = ready!(self.pending.as_mut().unwrap().as_mut().poll(cx));
+        self.pending = None;
+        Poll::Ready(self.accept_write(result))
+    }
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        self.state.write.register(cx.waker());
+        if self.state.cancel.is_cancelled() {
+            return Poll::Ready(Err(closed()));
+        }
+        if let Some(pending) = self.pending.as_mut() {
+            let result = ready!(pending.as_mut().poll(cx));
+            self.pending = None;
+            self.accept_write(result)?;
+        }
+        ready!(self.poll_latest(cx))?;
+        if self.state.cancel.is_cancelled() {
+            return Poll::Ready(Err(closed()));
+        }
+        Poll::Ready(Ok(()))
+    }
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        if self.ended {
+            return Poll::Ready(Ok(()));
+        }
+        ready!(self.as_mut().poll_flush(cx))?;
+        // Only UDP TCP-business enqueue can leave this per-SID state pending.
+        ready!(self.state.poll_ack_drain(cx));
+        self.end();
+        Poll::Ready(Ok(()))
+    }
+}
+
+#[derive(Default)]
+struct HandshakeWake {
+    read: AtomicWaker,
+    write: AtomicWaker,
+}
+impl Wake for HandshakeWake {
+    fn wake(self: Arc<Self>) {
+        self.wake_by_ref();
+    }
+    fn wake_by_ref(self: &Arc<Self>) {
+        self.read.wake();
+        self.write.wake();
+    }
+}
+type Handshake = BoxFuture<'static, (RawStream, io::Result<usize>)>;
+pub(super) struct Stream {
+    raw: Option<RawStream>,
+    request: Option<Bytes>,
+    pending: Option<Handshake>,
+    completed_write: Option<io::Result<usize>>,
+    queued_writes: bool,
+    wake: Arc<HandshakeWake>,
+    state: Arc<State>,
+    chunk: usize,
+}
+impl Stream {
+    pub async fn standard(
+        mut raw: RawStream,
+        target: &Destination,
+        command: u8,
+        deadline: Instant,
+    ) -> io::Result<RawStream> {
+        let request = request(target, command)?;
+        let _guard = observation::track(ResourceKind::Handshake);
+        timeout_at(
+            deadline.min(Instant::now() + Duration::from_secs(10)),
+            async {
+                raw.write_all(&request).await?;
+                read_response(&mut raw).await
+            },
+        )
+        .await
+        .map_err(|_| io::ErrorKind::TimedOut)??;
+        Ok(raw)
+    }
+    fn ready(raw: RawStream) -> Self {
+        let state = raw.state.clone();
+        let chunk = raw.chunk;
+        let queued_writes = raw.queued_writes;
+        Self {
+            raw: Some(raw),
+            request: None,
+            pending: None,
+            completed_write: None,
+            queued_writes,
+            wake: Arc::default(),
+            state,
+            chunk,
+        }
+    }
+    pub fn no_wait(raw: RawStream, target: &Destination, command: u8) -> io::Result<Self> {
+        let request = request(target, command)?;
+        let mut stream = Self::ready(raw);
+        stream.request = Some(request);
+        Ok(stream)
+    }
+    fn progress(&mut self) -> Poll<io::Result<()>> {
+        if let Some(pending) = self.pending.as_mut() {
+            let waker = Waker::from(self.wake.clone());
+            let mut context = Context::from_waker(&waker);
+            let (raw, result) = ready!(pending.as_mut().poll(&mut context));
+            self.raw = Some(raw);
+            self.pending = None;
+            if result.is_err() {
+                self.state.close();
+            }
+            self.completed_write = Some(result);
+            self.wake.wake_by_ref();
+        }
+        if self.state.local_closed.load(Ordering::Acquire) {
+            Poll::Ready(Err(closed()))
+        } else {
+            Poll::Ready(Ok(()))
+        }
+    }
+}
+impl Drop for Stream {
+    fn drop(&mut self) {
+        self.state.close();
+        self.pending = None;
+        self.raw = None;
+    }
+}
+impl AsyncRead for Stream {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buffer: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        if buffer.remaining() == 0 {
+            return Poll::Ready(Ok(()));
+        }
+        self.wake.read.register(cx.waker());
+        self.state.read.register(cx.waker());
+        if self.state.cancel.is_cancelled() && self.request.is_some() {
+            return Poll::Ready(Err(closed()));
+        }
+        if self.state.local_closed.load(Ordering::Acquire) {
+            return Poll::Ready(Err(closed()));
+        }
+        if self.request.is_some() {
+            return Poll::Pending;
+        }
+        ready!(self.progress())?;
+        Pin::new(self.raw.as_mut().unwrap()).poll_read(cx, buffer)
+    }
+}
+impl AsyncWrite for Stream {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        bytes: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        self.wake.write.register(cx.waker());
+        if self.state.local_closed.load(Ordering::Acquire) {
+            return Poll::Ready(Err(closed()));
+        }
+        if let Some(request) = self.request.take() {
+            let count = bytes.len().min(self.chunk);
+            let mut combined = Vec::with_capacity(request.len() + count);
+            combined.extend_from_slice(&request);
+            combined.extend_from_slice(&bytes[..count]);
+            let mut raw = self.raw.take().unwrap();
+            self.pending = Some(Box::pin(async move {
+                let _guard = observation::track(ResourceKind::Handshake);
+                let result = timeout_at(Instant::now() + Duration::from_secs(10), async {
+                    raw.write_all(&combined).await?;
+                    read_response(&mut raw).await?;
+                    Ok(count)
+                })
+                .await
+                .map_err(|_| io::ErrorKind::TimedOut.into())
+                .and_then(|result| result);
+                (raw, result)
+            }));
+            self.wake.read.wake();
+        }
+        ready!(self.progress())?;
+        if let Some(result) = self.completed_write.take() {
+            return Poll::Ready(result);
+        }
+        Pin::new(self.raw.as_mut().unwrap()).poll_write(cx, bytes)
+    }
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        self.wake.write.register(cx.waker());
+        if self.request.is_some() {
+            return Poll::Ready(Ok(()));
+        }
+        ready!(self.progress())?;
+        if self.completed_write.as_ref().is_some_and(Result::is_err) {
+            return Poll::Ready(Err(closed()));
+        }
+        Pin::new(self.raw.as_mut().unwrap()).poll_flush(cx)
+    }
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        if self.queued_writes {
+            if self.raw.is_none() && self.pending.is_none() {
+                return Poll::Ready(Ok(()));
+            }
+            self.wake.write.register(cx.waker());
+            ready!(self.progress())?;
+            ready!(Pin::new(self.raw.as_mut().unwrap()).poll_shutdown(cx))?;
+            self.raw = None;
+            return Poll::Ready(Ok(()));
+        }
+        self.state.close();
+        self.pending = None;
+        self.raw = None;
+        Poll::Ready(Ok(()))
+    }
+}
+fn request(target: &Destination, command: u8) -> io::Result<Bytes> {
+    let mut request = vec![socks5::VERSION, command, 0];
+    socks5::encode_address(target, &mut request)?;
+    Ok(Bytes::from(request))
+}
+async fn read_response(raw: &mut RawStream) -> io::Result<()> {
+    let mut header = [0; 3];
+    raw.read_exact(&mut header).await?;
+    if header[0] != socks5::VERSION || header[1] != 0 {
+        return Err(io::Error::new(
+            io::ErrorKind::ConnectionRefused,
+            "Mieru business handshake rejected",
+        ));
+    }
+    // The bind endpoint is metadata only. Port zero is valid in a SOCKS reply.
+    socks5::read_destination(raw, true).await?;
+    Ok(())
+}
+
+#[cfg(test)]
+#[path = "stream_memory_tests.rs"]
+mod memory_tests;
diff --git a/src/outbound/mieru/stream_memory_tests.rs b/src/outbound/mieru/stream_memory_tests.rs
new file mode 100644
index 0000000..cc5565e
--- /dev/null
+++ b/src/outbound/mieru/stream_memory_tests.rs
@@ -0,0 +1,116 @@
+//! Exercise the actual delivery/read path with observable backing ownership.
+use super::*;
+
+#[tokio::test]
+async fn mieru_standard_business_does_not_retain_lazy_handshake_state() {
+    use super::super::{
+        MieruOutbound,
+        tests::{Peer, config, session},
+    };
+    use crate::{
+        config::MieruHandshake,
+        outbound::{EstablishContext, OutboundConnector, UpstreamPath},
+        resources::observation::ResourceProbe,
+    };
+
+    let probe = ResourceProbe::default();
+    let bytes = probe
+        .scope(async {
+            let peer = Peer::new(false);
+            let node = MieruOutbound::new(
+                &config(MieruHandshake::Standard),
+                UpstreamPath::proxy(peer.clone()),
+                32768,
+            )
+            .unwrap();
+            let mut connected = node
+                .connect_stream(
+                    session(),
+                    &EstablishContext::with_timeout(Duration::from_secs(3)),
+                )
+                .await
+                .unwrap();
+            let bytes = std::mem::size_of_val(connected.io.as_ref());
+            connected.io.shutdown().await.unwrap();
+            node.shutdown().await;
+            drop((connected, node));
+            peer.stop().await;
+            bytes
+        })
+        .await;
+    assert!(probe.snapshot().is_idle());
+    assert!(
+        bytes <= 64,
+        "completed standard handshake retains {bytes} bytes of stream state"
+    );
+}
+
+struct Payload {
+    bytes: Vec<u8>,
+    released: Arc<AtomicBool>,
+}
+impl AsRef<[u8]> for Payload {
+    fn as_ref(&self) -> &[u8] {
+        &self.bytes
+    }
+}
+impl Drop for Payload {
+    fn drop(&mut self) {
+        self.released.store(true, Ordering::Release);
+    }
+}
+
+#[tokio::test]
+async fn mieru_tcp_delivery_does_not_pin_a_large_frame_for_its_small_tail() {
+    const CAPACITY: usize = 8192;
+    const TAIL: usize = 17;
+    let probe = crate::resources::observation::ResourceProbe::default();
+    let detached = probe
+        .scope(async {
+            let cancel = CancellationToken::new();
+            let state = State::new(1, CAPACITY, &cancel, Arc::default());
+            let released = Arc::new(AtomicBool::new(false));
+            let payload = Bytes::from_owner(Payload {
+                bytes: vec![0x5a; 2 * CAPACITY + TAIL],
+                released: released.clone(),
+            });
+            let delivering = {
+                let state = state.clone();
+                tokio::spawn(async move { state.deliver(payload).await })
+            };
+            // The same read implementation serves RawStream and the packet
+            // parser. Leave the last small chunk queued after delivery ends.
+            for length in [CAPACITY, CAPACITY] {
+                let mut bytes = vec![0; length];
+                let mut buffer = ReadBuf::new(&mut bytes);
+                tokio::time::timeout(
+                    Duration::from_secs(1),
+                    std::future::poll_fn(|cx| state.poll_read(cx, &mut buffer)),
+                )
+                .await
+                .unwrap()
+                .unwrap();
+                assert_eq!(buffer.filled(), vec![0x5a; length]);
+            }
+            tokio::time::timeout(Duration::from_secs(1), delivering)
+                .await
+                .unwrap()
+                .unwrap()
+                .unwrap();
+            let detached = released.load(Ordering::Acquire);
+            let mut bytes = [0; TAIL];
+            let mut buffer = ReadBuf::new(&mut bytes);
+            std::future::poll_fn(|cx| state.poll_read(cx, &mut buffer))
+                .await
+                .unwrap();
+            assert_eq!(buffer.filled(), [0x5a; TAIL]);
+            assert_eq!(state.receive_bytes.available_permits(), CAPACITY);
+            state.close();
+            drop(state);
+            assert!(released.load(Ordering::Acquire));
+            detached
+        })
+        .await;
+    assert!(probe.snapshot().is_idle());
+    assert!(detached, "queued tail still pins the entire received frame");
+}
diff --git a/src/outbound/mieru/tcp.rs b/src/outbound/mieru/tcp.rs
new file mode 100644
index 0000000..f5b4be9
--- /dev/null
+++ b/src/outbound/mieru/tcp.rs
@@ -0,0 +1,1501 @@
+//! Carrier ownership, idle reuse and serialized AEAD framing.
+//! LOW pools separate business types; TCP pooling isolates concurrent slow readers.
+use super::{
+    crypto,
+    pattern::{EffectivePattern, HostProfile, NonceState},
+    stream::{RawStream, State, closed},
+    wire::{
+        DataKind, DataMetadata, Metadata, SessionKind, SessionMetadata, StreamDecoder,
+        StreamEncoder,
+    },
+};
+use crate::{
+    config::{MieruMultiplexing, MieruOutboundConfig, MieruTransport},
+    dispatch::BoxStream,
+    outbound::{EstablishContext, UpstreamPath, server_destination},
+    resources::observation::{self, ResourceKind},
+    session::StreamSession,
+};
+use bytes::Bytes;
+use futures_util::future::BoxFuture;
+use std::{
+    collections::HashMap,
+    io,
+    pin::Pin,
+    sync::{
+        Arc, Mutex, Weak,
+        atomic::{AtomicUsize, Ordering},
+    },
+    task::{Context, Poll},
+    time::{Duration, SystemTime, UNIX_EPOCH},
+};
+use tokio::{
+    io::{AsyncRead, AsyncWrite, AsyncWriteExt, ReadBuf},
+    sync::{Notify, OwnedSemaphorePermit, Semaphore, mpsc, oneshot},
+    task::JoinHandle,
+    time::{Instant, timeout_at},
+};
+use tokio_util::{sync::CancellationToken, task::TaskTracker};
+
+const CLEAN_INTERVAL: Duration = Duration::from_secs(5);
+const WRITER_COMMANDS: usize = 2;
+
+#[cfg(test)]
+#[path = "tcp_receive_memory_tests.rs"]
+mod receive_memory_tests;
+#[cfg(test)]
+#[path = "udp_admission_memory_tests.rs"]
+mod udp_admission_memory_tests;
+#[cfg(test)]
+#[path = "udp_pool_memory_tests.rs"]
+mod udp_pool_memory_tests;
+#[cfg(test)]
+#[path = "udp_send_credit_memory_tests.rs"]
+mod udp_send_credit_memory_tests;
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(super) enum Business {
+    TcpConnect,
+    UdpAssociate,
+}
+impl Business {
+    pub fn command(self) -> u8 {
+        match self {
+            Self::TcpConnect => crate::socks5::COMMAND_CONNECT,
+            Self::UdpAssociate => crate::socks5::COMMAND_UDP_ASSOCIATE,
+        }
+    }
+}
+pub(super) struct WriterCommand {
+    pub state: Arc<State>,
+    pub data: Bytes,
+    pub piggyback: bool,
+    pub done: oneshot::Sender<io::Result<()>>,
+    pub _bytes: OwnedSemaphorePermit,
+}
+pub(super) struct Schedule {
+    pending: usize,
+    last_schedule: Instant,
+    disabled: Option<Instant>,
+    closed: bool,
+    in_bytes: u64,
+    out_bytes: u64,
+}
+pub(super) struct Shared {
+    pub(super) sessions: Mutex<HashMap<u32, Arc<State>>>,
+    control: mpsc::Sender<Metadata>,
+    pub(super) schedule: Mutex<Schedule>,
+    pub(super) cancel: CancellationToken,
+    pub(super) activity: Arc<Notify>,
+    idle: Duration,
+    pub(super) volume: u64,
+    created: Instant,
+    udp: bool,
+    // LOW separates business types on either carrier; other modes share a pool.
+    business: Option<Business>,
+    maximum_write: AtomicUsize,
+}
+impl Shared {
+    #[cfg(test)]
+    pub(super) fn output_test_shared(cancel: CancellationToken) -> Arc<Self> {
+        let (control, _receiver) = mpsc::channel(1);
+        Arc::new(Self {
+            sessions: Mutex::new(HashMap::new()),
+            control,
+            schedule: Mutex::new(Schedule {
+                pending: 0,
+                last_schedule: Instant::now(),
+                disabled: None,
+                closed: false,
+                in_bytes: 0,
+                out_bytes: 0,
+            }),
+            cancel,
+            activity: Arc::new(Notify::new()),
+            idle: Duration::from_secs(120),
+            volume: u64::MAX,
+            created: Instant::now(),
+            udp: true,
+            business: None,
+            maximum_write: AtomicUsize::new(32768),
+        })
+    }
+
+    pub(super) fn reap_unopened(&self) {
+        self.sessions.lock().unwrap().retain(|_, state| {
+            !(state.cancel.is_cancelled() && !state.opened.load(Ordering::Acquire))
+        });
+    }
+
+    pub(super) fn set_maximum_write(&self, value: usize) {
+        self.maximum_write.store(value, Ordering::Release);
+    }
+    pub(super) fn count_input(&self, count: usize) {
+        self.schedule.lock().unwrap().in_bytes += count as u64;
+    }
+    pub(super) fn count_output(&self, count: usize) {
+        self.schedule.lock().unwrap().out_bytes += count as u64;
+    }
+
+    fn reserve(&self, idle_only: bool) -> bool {
+        let active = idle_only && self.count() != 0;
+        let mut schedule = self.schedule.lock().unwrap();
+        if schedule.closed
+            || schedule.disabled.is_some()
+            || self.cancel.is_cancelled()
+            || active
+            || (idle_only && schedule.pending != 0)
+        {
+            return false;
+        }
+        schedule.pending += 1;
+        schedule.last_schedule = Instant::now();
+        true
+    }
+    fn release(&self) {
+        let mut schedule = self.schedule.lock().unwrap();
+        schedule.pending -= 1;
+        schedule.last_schedule = Instant::now();
+    }
+    fn count(&self) -> usize {
+        self.sessions
+            .lock()
+            .unwrap()
+            .values()
+            .filter(|state| {
+                !state.local_closed.load(Ordering::Acquire)
+                    && !state.remote_closed.load(Ordering::Acquire)
+            })
+            .count()
+    }
+    pub(super) fn clean(&self) -> bool {
+        let active = self.count();
+        let mut schedule = self.schedule.lock().unwrap();
+        let now = Instant::now();
+        if self.udp && now >= self.created + Duration::from_secs(60) && schedule.disabled.is_none()
+        {
+            schedule.disabled = Some(now);
+        }
+        if active == 0
+            && schedule.pending == 0
+            && now >= schedule.last_schedule + self.idle
+            && schedule.disabled.is_none()
+        {
+            schedule.disabled = Some(now);
+        }
+        if (schedule.in_bytes > self.volume || schedule.out_bytes > self.volume)
+            && schedule.disabled.is_none()
+        {
+            schedule.disabled = Some(now);
+        }
+        if active == 0
+            && schedule.pending == 0
+            && schedule.disabled.is_some_and(|disabled| {
+                now >= disabled + self.idle && now >= schedule.last_schedule + self.idle
+            })
+        {
+            schedule.closed = true;
+            return true;
+        }
+        false
+    }
+    pub(super) fn fail(&self) {
+        self.cancel.cancel();
+        self.schedule.lock().unwrap().closed = true;
+        for state in self.sessions.lock().unwrap().values() {
+            state.finish(true);
+        }
+        self.activity.notify_one();
+    }
+}
+// The scheduler counts carrier traffic, including authenticated headers and padding.
+struct CountedIo {
+    io: BoxStream,
+    shared: Arc<Shared>,
+}
+impl AsyncRead for CountedIo {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        let before = buf.filled().len();
+        let result = Pin::new(&mut self.io).poll_read(cx, buf);
+        self.shared.schedule.lock().unwrap().in_bytes += (buf.filled().len() - before) as u64;
+        result
+    }
+}
+impl AsyncWrite for CountedIo {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        bytes: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        let result = Pin::new(&mut self.io).poll_write(cx, bytes);
+        if let Poll::Ready(Ok(count)) = &result {
+            self.shared.schedule.lock().unwrap().out_bytes += *count as u64;
+        }
+        result
+    }
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.io).poll_flush(cx)
+    }
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.io).poll_shutdown(cx)
+    }
+}
+pub(super) struct Carrier {
+    shared: Arc<Shared>,
+    pub writer: mpsc::Sender<WriterCommand>,
+    pub bytes: Arc<Semaphore>,
+}
+impl Carrier {
+    pub fn maximum_write(&self) -> usize {
+        self.shared.maximum_write.load(Ordering::Acquire)
+    }
+}
+impl Drop for Carrier {
+    fn drop(&mut self) {
+        self.shared.cancel.cancel();
+    }
+}
+struct Reservation(Arc<Carrier>);
+impl Drop for Reservation {
+    fn drop(&mut self) {
+        self.0.shared.release();
+    }
+}
+struct Factory {
+    config: MieruOutboundConfig,
+    upstream: UpstreamPath,
+    pattern: Arc<EffectivePattern>,
+}
+#[derive(Default)]
+struct Registry {
+    next: u64,
+    carriers: HashMap<u64, Arc<Carrier>>,
+}
+pub(super) struct Client {
+    factory: Arc<Factory>,
+    registry: Arc<Mutex<Registry>>,
+    admission: Mutex<()>,
+    cancel: CancellationToken,
+    tasks: TaskTracker,
+    capacity: usize,
+    factor: usize,
+    idle: Duration,
+}
+impl Client {
+    pub fn new(
+        config: &MieruOutboundConfig,
+        upstream: UpstreamPath,
+        capacity: usize,
+    ) -> io::Result<Self> {
+        if capacity == 0 || capacity > u32::MAX as usize {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "invalid Mieru stream buffer capacity",
+            ));
+        }
+        let factor = match config.multiplexing {
+            MieruMultiplexing::Off => 0,
+            MieruMultiplexing::Low => 1,
+            MieruMultiplexing::Middle => 2,
+            MieruMultiplexing::High => 3,
+        };
+        let host = HostProfile::capture();
+        let idle = Duration::from_secs(120 + u64::from(host.fixed_int(61)));
+        let pattern = Arc::new(EffectivePattern::compile(
+            config.traffic_pattern.as_deref(),
+            host,
+            &config.username,
+        )?);
+        Ok(Self {
+            factory: Arc::new(Factory {
+                config: config.clone(),
+                upstream,
+                pattern,
+            }),
+            registry: Arc::default(),
+            admission: Mutex::new(()),
+            cancel: CancellationToken::new(),
+            tasks: TaskTracker::new(),
+            capacity,
+            factor,
+            idle,
+        })
+    }
+    pub(super) fn queues_datagrams(&self) -> bool {
+        self.factory.config.transport == MieruTransport::Udp
+    }
+    pub fn cancellation(&self) -> CancellationToken {
+        self.cancel.clone()
+    }
+    pub fn spawn(&self, future: BoxFuture<'static, ()>) -> io::Result<JoinHandle<()>> {
+        let _admission = self.admission.lock().unwrap();
+        if self.cancel.is_cancelled() {
+            return Err(closed());
+        }
+        Ok(self.tasks.spawn(observation::task(future)))
+    }
+    fn reserve_reusable(
+        &self,
+        business: Business,
+        choose: impl FnOnce(usize) -> usize,
+    ) -> io::Result<Option<Reservation>> {
+        let _admission = self.admission.lock().unwrap();
+        if self.cancel.is_cancelled() {
+            return Err(closed());
+        }
+        let pool = self.pool(business);
+        // Isolate slow TCP readers without dedicating a carrier to every UDP target.
+        // Reservations cover the gap before open publishes its session.
+        let idle_only = self.factory.config.transport == MieruTransport::Tcp
+            && pool == Some(Business::TcpConnect);
+        let registry = self.registry.lock().unwrap();
+        let available: Vec<_> = registry
+            .carriers
+            .values()
+            .filter(|carrier| {
+                carrier.shared.clean();
+                let active = idle_only && carrier.shared.count() != 0;
+                let schedule = carrier.shared.schedule.lock().unwrap();
+                carrier.shared.business == pool
+                    && !schedule.closed
+                    && schedule.disabled.is_none()
+                    && !active
+                    && (!idle_only || schedule.pending == 0)
+            })
+            .cloned()
+            .collect();
+        let weight = available
+            .len()
+            .checked_mul(self.factor)
+            .ok_or_else(closed)?;
+        let choice = choose(weight);
+        Ok(if choice < weight {
+            let start = choice / self.factor;
+            let mut selected = start;
+            if self.factor == 1 && self.factory.config.transport == MieruTransport::Udp {
+                // A setup-time estimate only; release the session lock before
+                // reading pending reservations, without a second ownership ledger.
+                let load = |carrier: &Arc<Carrier>| {
+                    let active = carrier.shared.count();
+                    let pending = carrier.shared.schedule.lock().unwrap().pending;
+                    active.saturating_add(pending)
+                };
+                let mut selected_load = load(&available[start]);
+                for offset in 1..available.len() {
+                    let index = (start + offset) % available.len();
+                    let candidate_load = load(&available[index]);
+                    if candidate_load < selected_load {
+                        selected = index;
+                        selected_load = candidate_load;
+                    }
+                }
+            }
+            let carrier = available[selected].clone();
+            if carrier.shared.reserve(idle_only) {
+                Some(Reservation(carrier))
+            } else {
+                None
+            }
+        } else {
+            None
+        })
+    }
+    fn pool(&self, business: Business) -> Option<Business> {
+        (self.factor == 1).then_some(business)
+    }
+    pub async fn open(
+        &self,
+        session: StreamSession,
+        business: Business,
+        datagram_receive_budget: Option<u16>,
+        context: &EstablishContext,
+    ) -> io::Result<RawStream> {
+        // TCP UDP-associate readers need one bounded packet envelope, not a
+        // full TCP stream window per destination. Physical UDP retains its
+        // existing capacity for reliable windows and reordered data.
+        let receive_capacity = if business == Business::UdpAssociate
+            && self.factory.config.transport == MieruTransport::Tcp
+        {
+            datagram_receive_budget.map_or(self.capacity, |maximum| {
+                self.capacity.min(
+                    (usize::from(maximum) + usize::from(crate::socks5::MAX_UDP_HEADER_SIZE))
+                        .min(usize::from(u16::MAX))
+                        + 4,
+                )
+            })
+        } else {
+            self.capacity
+        };
+        let operation = async {
+            let _waiter = observation::track(ResourceKind::Waiter);
+            let reusable =
+                self.reserve_reusable(business, |weight| rand::random_range(0..=weight))?;
+            let reservation = match reusable {
+                Some(reservation) => reservation,
+                None => self.create(session, business, context).await?,
+            };
+            let carrier = reservation.0.clone();
+            let state = {
+                let _admission = self.admission.lock().unwrap();
+                if self.cancel.is_cancelled() || carrier.shared.cancel.is_cancelled() {
+                    return Err(closed());
+                }
+                let mut sessions = carrier.shared.sessions.lock().unwrap();
+                let id = loop {
+                    let id = rand::random::<u32>();
+                    if id != 0 && !sessions.contains_key(&id) {
+                        break id;
+                    }
+                };
+                let state = State::new_for_business(
+                    id,
+                    receive_capacity,
+                    business,
+                    &carrier.shared.cancel,
+                    carrier.shared.activity.clone(),
+                );
+                sessions.insert(id, state.clone());
+                state
+            };
+            drop(reservation);
+            Ok(RawStream::new(carrier, state, self.capacity)
+                .with_queued_writes(business == Business::UdpAssociate && self.queues_datagrams()))
+        };
+        tokio::select! {biased;()=self.cancel.cancelled()=>Err(closed()),result=timeout_at(context.deadline(),operation)=>result.map_err(|_|io::ErrorKind::TimedOut)?}
+    }
+    async fn create(
+        &self,
+        session: StreamSession,
+        business: Business,
+        context: &EstablishContext,
+    ) -> io::Result<Reservation> {
+        let (control, control_frames) = mpsc::channel(1);
+        let shared = Arc::new(Shared {
+            control,
+            sessions: Mutex::new(HashMap::new()),
+            schedule: Mutex::new(Schedule {
+                pending: 1,
+                last_schedule: Instant::now(),
+                disabled: None,
+                closed: false,
+                in_bytes: 0,
+                out_bytes: 0,
+            }),
+            cancel: self.cancel.child_token(),
+            activity: Arc::new(Notify::new()),
+            idle: self.idle,
+            volume: (512 * 1024 * 1024_u64) << self.factor,
+            created: Instant::now(),
+            udp: self.factory.config.transport == MieruTransport::Udp,
+            business: self.pool(business),
+            maximum_write: AtomicUsize::new(32768),
+        });
+        let (writer, commands) = mpsc::channel(WRITER_COMMANDS);
+        // Only the isolated LOW UDP-associate pool gets default TX headroom.
+        // Preserve non-default resource budgets and all per-session RX limits.
+        let send_capacity = if self.factory.config.transport == MieruTransport::Udp
+            && self.pool(business) == Some(Business::UdpAssociate)
+            && self.capacity == 32 * 1024
+        {
+            96 * 1024
+        } else {
+            self.capacity
+        };
+        let carrier = Arc::new(Carrier {
+            shared: shared.clone(),
+            writer,
+            bytes: Arc::new(Semaphore::new(send_capacity)),
+        });
+        let id = {
+            let mut registry = self.registry.lock().unwrap();
+            registry.next = registry.next.checked_add(1).ok_or_else(closed)?;
+            registry.next
+        };
+        let (ready, connected) = oneshot::channel();
+        let context = context.clone();
+        let factory = self.factory.clone();
+        let registry = Arc::downgrade(&self.registry);
+        let deadline = context.deadline();
+        let mut setup = SetupCancel(Some(shared.cancel.clone()));
+        self.spawn(Box::pin(drive(
+            factory,
+            session,
+            context,
+            shared,
+            commands,
+            control_frames,
+            ready,
+            registry,
+            id,
+        )))?;
+        timeout_at(deadline, connected)
+            .await
+            .map_err(|_| io::ErrorKind::TimedOut)?
+            .map_err(|_| closed())??;
+        let _admission = self.admission.lock().unwrap();
+        if self.cancel.is_cancelled() || carrier.shared.cancel.is_cancelled() {
+            return Err(closed());
+        }
+        self.registry
+            .lock()
+            .unwrap()
+            .carriers
+            .insert(id, carrier.clone());
+        setup.0.take(); // Published ownership now belongs to registry/streams.
+        Ok(Reservation(carrier))
+    }
+    #[cfg(test)]
+    pub(super) fn attach_tcp_stream_for_test(&self) -> io::Result<RawStream> {
+        // Use the real live carrier and production reservation/stream objects;
+        // never let a random new-carrier bucket make sibling isolation pass.
+        if self.registry.lock().unwrap().carriers.len() != 1 {
+            return Err(closed());
+        }
+        let reservation = self
+            .reserve_reusable(Business::TcpConnect, |_| 0)?
+            .ok_or_else(closed)?;
+        let carrier = reservation.0.clone();
+        let state = {
+            let _admission = self.admission.lock().unwrap();
+            if self.cancel.is_cancelled() || carrier.shared.cancel.is_cancelled() {
+                return Err(closed());
+            }
+            let mut sessions = carrier.shared.sessions.lock().unwrap();
+            let mut id = 1_u32;
+            while sessions.contains_key(&id) {
+                id = id.checked_add(1).ok_or_else(closed)?;
+            }
+            let state = State::new_for_business(
+                id,
+                self.capacity,
+                Business::TcpConnect,
+                &carrier.shared.cancel,
+                carrier.shared.activity.clone(),
+            );
+            sessions.insert(id, state.clone());
+            state
+        };
+        drop(reservation);
+        Ok(RawStream::new(carrier, state, self.capacity))
+    }
+
+    pub fn begin_shutdown(&self) {
+        let _admission = self.admission.lock().unwrap();
+        self.cancel.cancel();
+        self.tasks.close();
+    }
+    pub async fn shutdown(&self) {
+        self.begin_shutdown();
+        self.tasks.wait().await;
+        self.registry.lock().unwrap().carriers.clear();
+    }
+}
+impl Drop for Client {
+    fn drop(&mut self) {
+        self.cancel.cancel();
+        self.tasks.close();
+    }
+}
+struct SetupCancel(Option<CancellationToken>);
+impl Drop for SetupCancel {
+    fn drop(&mut self) {
+        if let Some(cancel) = &self.0 {
+            cancel.cancel();
+        }
+    }
+}
+pub(super) fn now() -> io::Result<u64> {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|time| time.as_secs())
+        .map_err(|_| {
+            io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "system clock precedes Mieru epoch",
+            )
+        })
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn drive(
+    factory: Arc<Factory>,
+    session: StreamSession,
+    context: EstablishContext,
+    shared: Arc<Shared>,
+    commands: mpsc::Receiver<WriterCommand>,
+    control_frames: mpsc::Receiver<Metadata>,
+    ready: oneshot::Sender<io::Result<()>>,
+    registry: Weak<Mutex<Registry>>,
+    id: u64,
+) {
+    let _pool = observation::track(ResourceKind::Pool);
+    if factory.config.transport == MieruTransport::Udp {
+        super::udp::drive(
+            &factory.config,
+            &factory.upstream,
+            &factory.pattern,
+            session,
+            context,
+            &shared,
+            commands,
+            ready,
+        )
+        .await;
+        shared.fail();
+        shared.sessions.lock().unwrap().clear();
+        if let Some(registry) = registry.upgrade() {
+            registry.lock().unwrap().carriers.remove(&id);
+        }
+        return;
+    }
+    let setup = async {
+        let _handshake = observation::track(ResourceKind::Handshake);
+        shared.set_maximum_write(
+            factory
+                .pattern
+                .plaintext_fragment_limit(MieruTransport::Tcp, usize::MAX)?,
+        );
+        let port = rand::random_range(factory.config.port..=factory.config.port_end);
+        let server = server_destination(&factory.config.address, port)?;
+        let upstream = factory.upstream.for_server(&server, true);
+        let io = upstream
+            .connect_server(session, &server, &context)
+            .await
+            .map_err(|_| closed())?;
+        let key = Arc::new(crypto::derive_key(
+            &factory.config.username,
+            &factory.config.password,
+            now()?,
+        ));
+        let mut nonce = rand::random();
+        factory
+            .pattern
+            .rewrite_nonce(&mut NonceState::new(), &mut nonce, MieruTransport::Tcp);
+        let nonce = crypto::make_client_nonce(&factory.config.username, nonce);
+        Ok::<_, io::Error>((
+            io.io,
+            StreamEncoder::new(key.clone(), nonce),
+            StreamDecoder::new(key),
+        ))
+    };
+    let setup = tokio::select! {biased;()=shared.cancel.cancelled()=>Err(closed()),result=timeout_at(context.deadline(),setup)=>result.map_err(|_|io::ErrorKind::TimedOut.into()).and_then(|result|result)};
+    match setup {
+        Ok((io, mut encoder, mut decoder)) => {
+            if ready.send(Ok(())).is_ok() {
+                let (mut reader, mut writer) = tokio::io::split(CountedIo {
+                    io,
+                    shared: shared.clone(),
+                });
+                tokio::select! {biased;
+                    ()=shared.cancel.cancelled()=>{},
+                    _=read_loop(&mut reader,&mut decoder,&shared)=>{},
+                    _=write_loop(&mut writer,&mut encoder,commands,control_frames,&shared,&factory.pattern)=>{},
+                    ()=idle_loop(&shared)=>{},
+                }
+                shared.fail();
+                let _ = tokio::time::timeout(Duration::from_secs(1), writer.shutdown()).await;
+                drop((reader, writer));
+            }
+        }
+        Err(error) => {
+            let _ = ready.send(Err(error));
+        }
+    }
+    shared.fail();
+    shared.sessions.lock().unwrap().clear();
+    if let Some(registry) = registry.upgrade() {
+        registry.lock().unwrap().carriers.remove(&id);
+    }
+}
+async fn idle_loop(shared: &Shared) {
+    let mut interval = tokio::time::interval(CLEAN_INTERVAL);
+    loop {
+        interval.tick().await;
+        if shared.clean() {
+            return;
+        }
+    }
+}
+async fn read_loop<R: AsyncRead + Unpin>(
+    reader: &mut R,
+    decoder: &mut StreamDecoder,
+    shared: &Shared,
+) -> io::Result<()> {
+    while let Some(frame) = decoder.read_frame_with_clock(reader, now).await? {
+        let (id, sequence, kind) = match frame.metadata {
+            Metadata::Session(meta) => (meta.session_id, meta.sequence, 0_u8),
+            Metadata::Data(meta) => (
+                meta.session_id,
+                meta.sequence,
+                if meta.kind == DataKind::ServerAck {
+                    1
+                } else {
+                    0
+                },
+            ),
+        };
+        let state = shared.sessions.lock().unwrap().get(&id).cloned();
+        let Some(state) = state else {
+            match frame.metadata {
+                Metadata::Data(meta) => {
+                    shared
+                        .control
+                        .send(Metadata::Session(SessionMetadata {
+                            kind: SessionKind::CloseRequest,
+                            session_id: id,
+                            sequence: meta.unack_sequence,
+                            status: 0,
+                        }))
+                        .await
+                        .map_err(|_| closed())?;
+                }
+                Metadata::Session(meta) if meta.kind == SessionKind::OpenResponse => {
+                    return Err(io::ErrorKind::InvalidData.into());
+                }
+                Metadata::Session(_) => {}
+            }
+            continue;
+        };
+        if kind == 1 {
+            continue;
+        }
+        if sequence != state.next_receive.load(Ordering::Acquire) {
+            state.finish(true);
+            state.close();
+            continue;
+        }
+        state
+            .next_receive
+            .store(sequence.wrapping_add(1), Ordering::Release);
+        match frame.metadata {
+            Metadata::Session(meta) => match meta.kind {
+                SessionKind::OpenResponse => {}
+                SessionKind::CloseRequest => {
+                    state.close_response.store(true, Ordering::Release);
+                    state.finish(meta.status != 0);
+                    continue;
+                }
+                SessionKind::CloseResponse => {
+                    state.finish(meta.status != 0);
+                    shared.sessions.lock().unwrap().remove(&id);
+                    continue;
+                }
+                SessionKind::OpenRequest => return Err(io::ErrorKind::InvalidData.into()),
+            },
+            Metadata::Data(meta) if meta.kind != DataKind::ServerData => {
+                return Err(io::ErrorKind::InvalidData.into());
+            }
+            Metadata::Data(_) => {}
+        }
+        // Business cancellation interrupts delivery, never the physical decoder.
+        let _ = state.deliver(frame.payload).await;
+    }
+    Err(io::ErrorKind::UnexpectedEof.into())
+}
+async fn write_loop<W: AsyncWrite + Unpin>(
+    writer: &mut W,
+    encoder: &mut StreamEncoder,
+    mut commands: mpsc::Receiver<WriterCommand>,
+    mut control_frames: mpsc::Receiver<Metadata>,
+    shared: &Shared,
+    pattern: &EffectivePattern,
+) -> io::Result<()> {
+    let mut output = Vec::new();
+    loop {
+        tokio::select! {
+            frame=control_frames.recv()=>{let Some(metadata)=frame else{return Ok(());};write_frame(writer,encoder,pattern,metadata,&[],&mut output).await?;},
+            command=commands.recv()=>{
+                let Some(command)=command else{return Ok(());};
+                if command.state.local_closed.load(Ordering::Acquire) || command.state.remote_closed.load(Ordering::Acquire){let _=command.done.send(Err(closed()));continue;}
+                let operation=async {
+                    let first=!command.state.opened.swap(true,Ordering::AcqRel);
+                    if first {
+                        let piggyback=!pattern.low_entropy_enabled() && command.piggyback && command.data.len()<=1024;
+                        let metadata=Metadata::Session(SessionMetadata{kind:SessionKind::OpenRequest,session_id:command.state.id,sequence:command.state.sequence.fetch_add(1,Ordering::AcqRel),status:0});
+                        write_frame(writer,encoder,pattern,metadata,if piggyback{&command.data}else{&[]},&mut output).await?;
+                        if piggyback{return Ok(());}
+                    }
+                    let metadata=Metadata::Data(DataMetadata{kind:DataKind::ClientData,session_id:command.state.id,sequence:command.state.sequence.fetch_add(1,Ordering::AcqRel),unack_sequence:command.state.next_receive.load(Ordering::Acquire),window:1,fragment:0});
+                    write_frame(writer,encoder,pattern,metadata,&command.data,&mut output).await
+                }.await;
+                let failed=operation.is_err();let _=command.done.send(operation);if failed{return Err(closed());}
+            },
+            ()=shared.activity.notified()=>{
+                let closing:Vec<_>=shared.sessions.lock().unwrap().values().filter(|state|state.local_closed.load(Ordering::Acquire)||state.remote_closed.load(Ordering::Acquire)).cloned().collect();
+                for state in closing {
+                    if state.opened.load(Ordering::Acquire) {
+                        let kind=if state.close_response.load(Ordering::Acquire){SessionKind::CloseResponse}else{SessionKind::CloseRequest};
+                        write_frame(writer,encoder,pattern,Metadata::Session(SessionMetadata{kind,session_id:state.id,sequence:state.sequence.fetch_add(1,Ordering::AcqRel),status:0}),&[],&mut output).await?;
+                    }
+                    shared.sessions.lock().unwrap().remove(&state.id);
+                }
+            },
+        }
+    }
+}
+async fn write_frame<W: AsyncWrite + Unpin>(
+    writer: &mut W,
+    encoder: &mut StreamEncoder,
+    pattern: &EffectivePattern,
+    metadata: Metadata,
+    payload: &[u8],
+    output: &mut Vec<u8>,
+) -> io::Result<()> {
+    let prepared =
+        pattern.prepare_frame(metadata, payload.len(), MieruTransport::Tcp, usize::MAX)?;
+    encoder.encode_frame(metadata, payload, prepared.encoding(), now()?, output)?;
+    // Encoding commits the directional nonce. Business cancellation cannot
+    // interrupt this write or retry it; only physical Stop/failure can retire it.
+    if matches!(metadata, Metadata::Session(_)) {
+        for chunk in pattern.control_chunks(output.len()) {
+            writer.write_all(&output[chunk.range]).await?;
+            if !chunk.delay_after.is_zero() {
+                tokio::time::sleep(chunk.delay_after).await;
+            }
+        }
+    } else {
+        writer.write_all(output).await?;
+    }
+    writer.flush().await
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::{
+        stream::Stream,
+        tests::{Peer, config, echo, session},
+    };
+    use super::*;
+    use crate::{config::MieruHandshake, resources::observation::ResourceProbe};
+    #[derive(Default)]
+    struct RecordedWriter {
+        bytes: Vec<u8>,
+        writes: Vec<usize>,
+    }
+    impl AsyncWrite for RecordedWriter {
+        fn poll_write(
+            mut self: Pin<&mut Self>,
+            _: &mut Context<'_>,
+            bytes: &[u8],
+        ) -> Poll<io::Result<usize>> {
+            self.writes.push(bytes.len());
+            self.bytes.extend_from_slice(bytes);
+            Poll::Ready(Ok(bytes.len()))
+        }
+        fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Poll::Ready(Ok(()))
+        }
+        fn poll_shutdown(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Poll::Ready(Ok(()))
+        }
+    }
+    #[tokio::test]
+    async fn mieru_tcp_pattern_consumes_low_entropy_and_control_fragmentation() {
+        // Independently encoded protobuf: fixed nonce prefix, no padding,
+        // MODE32 low entropy and TCP control fragmentation with zero sleep.
+        const PATTERN: &str = "CAAaBAgBEAAiEAgDEAEYACAAKgZhYWJiY2MqBAgAEAAyBAgBEAA=";
+        let probe = ResourceProbe::default();
+        probe
+            .scope(async {
+                let peer = Peer::new(false);
+                let mut configuration = config(MieruHandshake::NoWait);
+                configuration.traffic_pattern = Some(PATTERN.into());
+                let client =
+                    Client::new(&configuration, UpstreamPath::proxy(peer.clone()), 32768).unwrap();
+                let context = EstablishContext::with_timeout(Duration::from_secs(5));
+                let raw = client
+                    .open(session(), Business::TcpConnect, None, &context)
+                    .await
+                    .unwrap();
+                let state = raw.state.clone();
+                assert_eq!(
+                    client
+                        .registry
+                        .lock()
+                        .unwrap()
+                        .carriers
+                        .values()
+                        .next()
+                        .unwrap()
+                        .maximum_write(),
+                    32764
+                );
+                let mut stream: BoxStream =
+                    Box::new(Stream::no_wait(raw, &session().destination, 1).unwrap());
+                echo(&mut stream, b"client-first low entropy").await;
+                assert_eq!(state.sequence.load(Ordering::Acquire), 2);
+                echo(&mut stream, &vec![0x53; 32768]).await;
+                assert_eq!(state.sequence.load(Ordering::Acquire), 4);
+
+                let pattern = &client.factory.pattern;
+                let key = Arc::new(crypto::derive_key(
+                    "vole",
+                    "fixture-password",
+                    now().unwrap(),
+                ));
+                let mut encoder = StreamEncoder::new(key.clone(), rand::random());
+                let mut recorded = RecordedWriter::default();
+                let mut output = Vec::new();
+                let control = Metadata::Session(SessionMetadata {
+                    kind: SessionKind::CloseRequest,
+                    session_id: 1,
+                    sequence: 0,
+                    status: 0,
+                });
+                write_frame(
+                    &mut recorded,
+                    &mut encoder,
+                    pattern,
+                    control,
+                    &[],
+                    &mut output,
+                )
+                .await
+                .unwrap();
+                assert!(
+                    recorded.writes.len() > 1,
+                    "control frame was not fragmented"
+                );
+                recorded.writes.clear();
+                let metadata = Metadata::Data(DataMetadata {
+                    kind: DataKind::ClientData,
+                    session_id: 1,
+                    sequence: 1,
+                    unack_sequence: 0,
+                    window: 1,
+                    fragment: 0,
+                });
+                let payload = vec![0x35; 32764];
+                write_frame(
+                    &mut recorded,
+                    &mut encoder,
+                    pattern,
+                    metadata,
+                    &payload,
+                    &mut output,
+                )
+                .await
+                .unwrap();
+                assert_eq!(recorded.writes.len(), 1, "DATA was control-fragmented");
+                assert_eq!(output.len(), 48 + 65528 + 16);
+                let mut decoder = StreamDecoder::new(key);
+                let mut input = recorded.bytes.as_slice();
+                let first = decoder
+                    .read_frame_with_clock(&mut input, now)
+                    .await
+                    .unwrap()
+                    .unwrap();
+                assert_eq!(first.metadata, control);
+                let data = decoder
+                    .read_frame_with_clock(&mut input, now)
+                    .await
+                    .unwrap()
+                    .unwrap();
+                assert_eq!(data.metadata, metadata);
+                assert_eq!(data.payload, payload);
+                assert!(input.is_empty());
+                client.shutdown().await;
+                drop((stream, state, client));
+                peer.stop().await;
+            })
+            .await;
+        assert!(probe.snapshot().is_idle());
+    }
+    #[tokio::test]
+    async fn mieru_tcp_low_separates_business_pools_without_changing_other_modes() {
+        let probe = ResourceProbe::default();
+        let outcomes: io::Result<Vec<(String, bool, bool)>> = probe
+            .scope(async {
+                let mut outcomes = Vec::new();
+                for (
+                    label,
+                    transport,
+                    multiplexing,
+                    business,
+                    active_reusable,
+                    other_business_reusable,
+                ) in [
+                    (
+                        "tcp-low",
+                        MieruTransport::Tcp,
+                        MieruMultiplexing::Low,
+                        Business::TcpConnect,
+                        false,
+                        false,
+                    ),
+                    (
+                        "udp-associate-low",
+                        MieruTransport::Tcp,
+                        MieruMultiplexing::Low,
+                        Business::UdpAssociate,
+                        true,
+                        false,
+                    ),
+                    (
+                        "middle",
+                        MieruTransport::Tcp,
+                        MieruMultiplexing::Middle,
+                        Business::TcpConnect,
+                        true,
+                        true,
+                    ),
+                    (
+                        "high",
+                        MieruTransport::Tcp,
+                        MieruMultiplexing::High,
+                        Business::TcpConnect,
+                        true,
+                        true,
+                    ),
+                    (
+                        "udp-carrier-low",
+                        MieruTransport::Udp,
+                        MieruMultiplexing::Low,
+                        Business::TcpConnect,
+                        true,
+                        false,
+                    ),
+                    (
+                        "udp-carrier-low-associate",
+                        MieruTransport::Udp,
+                        MieruMultiplexing::Low,
+                        Business::UdpAssociate,
+                        true,
+                        false,
+                    ),
+                    (
+                        "udp-carrier-middle",
+                        MieruTransport::Udp,
+                        MieruMultiplexing::Middle,
+                        Business::TcpConnect,
+                        true,
+                        true,
+                    ),
+                    (
+                        "udp-carrier-high",
+                        MieruTransport::Udp,
+                        MieruMultiplexing::High,
+                        Business::TcpConnect,
+                        true,
+                        true,
+                    ),
+                    (
+                        "udp-carrier-off",
+                        MieruTransport::Udp,
+                        MieruMultiplexing::Off,
+                        Business::TcpConnect,
+                        false,
+                        false,
+                    ),
+                    (
+                        "off",
+                        MieruTransport::Tcp,
+                        MieruMultiplexing::Off,
+                        Business::TcpConnect,
+                        false,
+                        false,
+                    ),
+                ] {
+                    let peer = Peer::new(false);
+                    let mut settings = config(MieruHandshake::NoWait);
+                    settings.transport = transport;
+                    settings.multiplexing = multiplexing;
+                    let client = Client::new(&settings, UpstreamPath::proxy(peer.clone()), 1024)?;
+                    let mut shared = Shared::output_test_shared(client.cancel.child_token());
+                    let settings = Arc::get_mut(&mut shared).unwrap();
+                    settings.udp = transport == MieruTransport::Udp;
+                    settings.business = client.pool(business);
+                    let state = State::new(1, 1024, &shared.cancel, shared.activity.clone());
+                    shared.sessions.lock().unwrap().insert(1, state.clone());
+                    let (writer, receiver) = mpsc::channel(WRITER_COMMANDS);
+                    let carrier = Arc::new(Carrier {
+                        shared: shared.clone(),
+                        writer,
+                        bytes: Arc::new(Semaphore::new(1024)),
+                    });
+                    client
+                        .registry
+                        .lock()
+                        .unwrap()
+                        .carriers
+                        .insert(1, carrier.clone());
+                    // Call the production picker, always selecting the sole reusable bucket.
+                    // No framing or network is needed to test this admission decision.
+                    let result: io::Result<Vec<(String, bool, bool)>> = (|| {
+                        let mut observed = Vec::new();
+                        let active = client.reserve_reusable(business, |_| 0)?;
+                        observed.push((
+                            format!("{label} active"),
+                            active.is_some(),
+                            active_reusable,
+                        ));
+                        drop(active);
+                        state.close();
+                        let idle = client.reserve_reusable(business, |_| 0)?;
+                        observed.push((
+                            format!("{label} idle after close"),
+                            idle.is_some(),
+                            multiplexing != MieruMultiplexing::Off,
+                        ));
+                        // Keep the first reservation across the second attempt,
+                        // matching the gap before Client::open inserts its session.
+                        let pending = client.reserve_reusable(business, |_| 0)?;
+                        observed.push((
+                            format!("{label} pending"),
+                            pending.is_some(),
+                            active_reusable,
+                        ));
+                        drop(pending);
+                        drop(idle);
+                        let other_business = match business {
+                            Business::TcpConnect => Business::UdpAssociate,
+                            Business::UdpAssociate => Business::TcpConnect,
+                        };
+                        let other = client.reserve_reusable(other_business, |_| 0)?;
+                        observed.push((
+                            format!("{label} other business"),
+                            other.is_some(),
+                            other_business_reusable,
+                        ));
+                        drop(other);
+                        let idle_again = client.reserve_reusable(business, |_| 0)?;
+                        observed.push((
+                            format!("{label} after reservation release"),
+                            idle_again.is_some(),
+                            multiplexing != MieruMultiplexing::Off,
+                        ));
+                        drop(idle_again);
+                        let new_carrier = client.reserve_reusable(business, |weight| weight)?;
+                        observed.push((
+                            format!("{label} new carrier bucket"),
+                            new_carrier.is_some(),
+                            false,
+                        ));
+                        drop(new_carrier);
+                        Ok(observed)
+                    })();
+                    client.shutdown().await;
+                    drop((client, carrier, shared, state, receiver));
+                    peer.stop().await;
+                    outcomes.extend(result?);
+                }
+                Ok(outcomes)
+            })
+            .await;
+        // Check decisions only after every owner has been stopped/dropped.
+        assert!(probe.snapshot().is_idle());
+        for (label, actual, expected) in outcomes.unwrap() {
+            assert_eq!(actual, expected, "{label}");
+        }
+    }
+    #[tokio::test]
+    async fn mieru_tcp_low_udp_associate_uses_active_pool_from_outbound_callsite() {
+        use crate::{
+            outbound::{DatagramRequest, OutboundConnector},
+            session::DatagramSession,
+        };
+        let probe = ResourceProbe::default();
+        let active_reusable = probe
+            .scope(async {
+                let peer = Peer::new(false);
+                let mut settings = config(MieruHandshake::Standard);
+                settings.multiplexing = MieruMultiplexing::Low;
+                let node = super::super::MieruOutbound::new(
+                    &settings,
+                    UpstreamPath::proxy(peer.clone()),
+                    1024,
+                )
+                .unwrap();
+                let context = EstablishContext::with_timeout(Duration::from_secs(5));
+                let request =
+                    DatagramRequest::new(DatagramSession::for_tun(session().source, 1500));
+                let mut packet = node.open_datagram(request, &context).await.unwrap();
+                assert_eq!(peer.calls.load(Ordering::Acquire), 1);
+                // Exercise the actual outbound's published carrier, choosing the
+                // reuse bucket deterministically while its UDP session is active.
+                let reusable = node
+                    .client
+                    .reserve_reusable(Business::UdpAssociate, |_| 0)
+                    .unwrap();
+                let active_reusable = reusable.is_some();
+                drop(reusable);
+                packet.close().await.unwrap();
+                drop(packet);
+                node.shutdown().await;
+                drop(node);
+                peer.stop().await;
+                active_reusable
+            })
+            .await;
+        assert!(probe.snapshot().is_idle());
+        assert!(
+            active_reusable,
+            "LOW UDP Associate must retain active reuse"
+        );
+    }
+    #[tokio::test]
+    async fn mieru_tcp_low_slow_reader_does_not_block_tcp_or_udp_siblings() {
+        use crate::{
+            dispatch::DispatchError,
+            outbound::{DatagramRequest, OutboundConnector},
+            session::{Datagram, DatagramSession, Destination},
+        };
+        use tokio::io::AsyncReadExt;
+
+        let probe = ResourceProbe::default();
+        let (blocked, exhausted, siblings) = probe
+            .scope(async {
+                let peer = Peer::new(false);
+                let mut settings = config(MieruHandshake::Standard);
+                settings.multiplexing = MieruMultiplexing::Low;
+                let node = super::super::MieruOutbound::new(
+                    &settings,
+                    UpstreamPath::proxy(peer.clone()),
+                    1024,
+                )
+                .unwrap();
+                let context = EstablishContext::with_timeout(Duration::from_secs(5));
+                let first = node.connect_stream(session(), &context).await.unwrap();
+                let carrier = node
+                    .client
+                    .registry
+                    .lock()
+                    .unwrap()
+                    .carriers
+                    .values()
+                    .next()
+                    .unwrap()
+                    .clone();
+                let state = carrier
+                    .shared
+                    .sessions
+                    .lock()
+                    .unwrap()
+                    .values()
+                    .next()
+                    .unwrap()
+                    .clone();
+                let (reader, mut writer) = tokio::io::split(first.io);
+                let payload = vec![7; 16384];
+                let (blocked, exhausted, siblings) = {
+                    // Hold the read half without consuming the echoed bytes. The
+                    // real decoder fills its unchanged 1 KiB receive budget.
+                    let writing = writer.write_all(&payload);
+                    tokio::pin!(writing);
+                    let blocked = tokio::time::timeout(Duration::from_millis(20), &mut writing)
+                        .await
+                        .is_err();
+                    let exhausted = state.receive_bytes.available_permits() == 0;
+                    let siblings = tokio::time::timeout(Duration::from_secs(3), async {
+                        let mut sibling = node.connect_stream(session(), &context).await?.io;
+                        sibling.write_all(b"sibling").await?;
+                        let mut echoed = [0; 7];
+                        sibling.read_exact(&mut echoed).await?;
+                        let request =
+                            DatagramRequest::new(DatagramSession::for_tun(session().source, 1500));
+                        let mut packet = node.open_datagram(request, &context).await?;
+                        let remote = Destination::Ip("198.51.100.1:53".parse().unwrap());
+                        packet
+                            .send(Datagram {
+                                remote: remote.clone(),
+                                payload: Bytes::from_static(b"packet"),
+                                sniffed_domain: None,
+                            })
+                            .await?;
+                        let response = packet.receive().await?;
+                        packet.close().await?;
+                        Ok::<_, DispatchError>(
+                            echoed == *b"sibling"
+                                && response.remote == remote
+                                && response.payload == b"packet"[..],
+                        )
+                    })
+                    .await;
+                    (blocked, exhausted, siblings)
+                };
+                drop((reader, writer, state, carrier));
+                node.shutdown().await;
+                drop(node);
+                peer.stop().await;
+                (blocked, exhausted, siblings)
+            })
+            .await;
+        assert!(probe.snapshot().is_idle());
+        assert!(
+            blocked,
+            "the unread stream must apply physical backpressure"
+        );
+        assert!(
+            exhausted,
+            "the unread stream must exhaust its original receive budget"
+        );
+        assert!(
+            siblings.unwrap().unwrap(),
+            "TCP and UDP siblings must retain their data"
+        );
+    }
+    #[tokio::test]
+    async fn mieru_tcp_shared_carrier_preserves_sibling_and_bounded_reader() {
+        let probe = ResourceProbe::default();
+        probe
+            .scope(async {
+                let peer = Peer::new(false);
+                let client = Client::new(
+                    &config(MieruHandshake::NoWait),
+                    UpstreamPath::proxy(peer.clone()),
+                    32768,
+                )
+                .unwrap();
+                let context = EstablishContext::with_timeout(Duration::from_secs(5));
+                let raw = client
+                    .open(session(), Business::TcpConnect, None, &context)
+                    .await
+                    .unwrap();
+                let target = session().destination;
+                let mut first: BoxStream = Box::new(Stream::no_wait(raw, &target, 1).unwrap());
+                echo(&mut first, &vec![1; 8192]).await;
+                // Pin this second business session to the actual published carrier
+                // so probabilistic scheduling cannot make the wire fixture flaky.
+                let carrier = client
+                    .registry
+                    .lock()
+                    .unwrap()
+                    .carriers
+                    .values()
+                    .next()
+                    .unwrap()
+                    .clone();
+                assert!(carrier.shared.reserve(false));
+                let reservation = Reservation(carrier.clone());
+                let id = loop {
+                    let id = rand::random::<u32>();
+                    if id != 0 && !carrier.shared.sessions.lock().unwrap().contains_key(&id) {
+                        break id;
+                    }
+                };
+                let state = State::new(
+                    id,
+                    client.capacity,
+                    &carrier.shared.cancel,
+                    carrier.shared.activity.clone(),
+                );
+                carrier
+                    .shared
+                    .sessions
+                    .lock()
+                    .unwrap()
+                    .insert(id, state.clone());
+                drop(reservation);
+                let raw = RawStream::new(carrier.clone(), state, client.capacity);
+                let mut second: BoxStream = Box::new(Stream::no_wait(raw, &target, 1).unwrap());
+                echo(&mut second, b"second-session").await;
+                assert_eq!(peer.calls.load(Ordering::Acquire), 1);
+                drop(first);
+                echo(&mut second, b"sibling-after-close").await;
+                assert!(carrier.bytes.available_permits() <= client.capacity);
+                client.shutdown().await;
+                drop((second, carrier, client));
+                peer.stop().await;
+            })
+            .await;
+        assert!(probe.snapshot().is_idle());
+    }
+    #[tokio::test(start_paused = true)]
+    async fn mieru_tcp_scheduler_drains_without_killing_active_session() {
+        let probe = ResourceProbe::default();
+        probe
+            .scope(async {
+                let peer = Peer::new(false);
+                let client = Client::new(
+                    &config(MieruHandshake::NoWait),
+                    UpstreamPath::proxy(peer.clone()),
+                    1024,
+                )
+                .unwrap();
+                let context = EstablishContext::with_timeout(Duration::from_secs(5));
+                let raw = client
+                    .open(session(), Business::TcpConnect, None, &context)
+                    .await
+                    .unwrap();
+                let carrier = client
+                    .registry
+                    .lock()
+                    .unwrap()
+                    .carriers
+                    .values()
+                    .next()
+                    .unwrap()
+                    .clone();
+                let mut io: BoxStream =
+                    Box::new(Stream::no_wait(raw, &session().destination, 1).unwrap());
+                echo(&mut io, b"active").await;
+                carrier.shared.schedule.lock().unwrap().out_bytes = carrier.shared.volume + 1;
+                assert!(!carrier.shared.clean());
+                assert!(!carrier.shared.reserve(false));
+                echo(&mut io, b"after-scheduling-disabled").await;
+                drop(io);
+                tokio::time::advance(client.idle + CLEAN_INTERVAL).await;
+                tokio::time::timeout(Duration::from_secs(3), async {
+                    while !carrier.shared.cancel.is_cancelled() {
+                        tokio::task::yield_now().await;
+                    }
+                })
+                .await
+                .unwrap();
+                client.shutdown().await;
+                drop((carrier, client));
+                peer.stop().await;
+            })
+            .await;
+        assert!(probe.snapshot().is_idle());
+    }
+    #[tokio::test(start_paused = true)]
+    async fn mieru_udp_carrier_age_disables_new_reservations_and_drains() {
+        let cancellation = CancellationToken::new();
+        let activity = Arc::new(Notify::new());
+        let state = State::new(1, 32768, &cancellation, activity.clone());
+        let (control, _) = mpsc::channel(1);
+        let shared = Shared {
+            sessions: Mutex::new(HashMap::from([(1, state.clone())])),
+            control,
+            schedule: Mutex::new(Schedule {
+                pending: 0,
+                last_schedule: Instant::now(),
+                disabled: None,
+                closed: false,
+                in_bytes: 0,
+                out_bytes: 0,
+            }),
+            cancel: cancellation,
+            activity,
+            idle: Duration::from_secs(150),
+            volume: 512 * 1024 * 1024,
+            created: Instant::now(),
+            udp: true,
+            business: None,
+            maximum_write: AtomicUsize::new(32768),
+        };
+        // A lazy NO_WAIT connection may be dropped without ever submitting a write.
+        let unopened = State::new(2, 32768, &shared.cancel, shared.activity.clone());
+        shared.sessions.lock().unwrap().insert(2, unopened.clone());
+        unopened.close();
+        shared.reap_unopened();
+        assert_eq!(shared.sessions.lock().unwrap().len(), 1);
+        assert!(shared.sessions.lock().unwrap().contains_key(&1));
+        drop(unopened);
+        tokio::time::advance(Duration::from_secs(59)).await;
+        assert!(!shared.clean());
+        assert!(shared.reserve(false));
+        shared.release();
+        tokio::time::advance(Duration::from_secs(1)).await;
+        assert!(!shared.clean());
+        assert!(!shared.reserve(false));
+        assert!(!state.cancel.is_cancelled());
+        state.close();
+        tokio::time::advance(Duration::from_secs(150)).await;
+        assert!(shared.clean());
+    }
+}
diff --git a/src/outbound/mieru/tcp_receive_memory_tests.rs b/src/outbound/mieru/tcp_receive_memory_tests.rs
new file mode 100644
index 0000000..f85a9d0
--- /dev/null
+++ b/src/outbound/mieru/tcp_receive_memory_tests.rs
@@ -0,0 +1,133 @@
+//! Coalesced encrypted UDP responses through the production outbound and reader.
+use super::super::{
+    MieruOutbound,
+    tests::{Peer, config, session},
+};
+use super::*;
+use crate::{
+    config::MieruHandshake,
+    outbound::{DatagramRequest, OutboundConnector},
+    resources::observation::ResourceProbe,
+    session::{DatagramSession, Destination},
+    socks5,
+};
+
+const CAPACITY: usize = 32768;
+const PACKETS: usize = 64;
+const PAYLOAD: usize = 123;
+const ENVELOPE: usize = 4 + 10 + PAYLOAD;
+
+async fn bounded<T>(future: impl std::future::Future<Output = T>) -> T {
+    tokio::time::timeout(Duration::from_secs(3), future)
+        .await
+        .expect("Mieru memory operation timed out")
+}
+
+async fn inject(carrier: &Carrier, state: &Arc<State>, bytes: &[u8]) {
+    let permit = bounded(carrier.bytes.clone().acquire_many_owned(bytes.len() as u32))
+        .await
+        .unwrap();
+    let (done, response) = oneshot::channel();
+    bounded(carrier.writer.send(WriterCommand {
+        state: state.clone(),
+        data: Bytes::copy_from_slice(bytes),
+        piggyback: false,
+        done,
+        _bytes: permit,
+    }))
+    .await
+    .unwrap();
+    bounded(response).await.unwrap().unwrap();
+}
+
+async fn blocked_input(state: &State) -> usize {
+    let expected = state.receive_capacity().min(PACKETS * ENVELOPE) - 2 * ENVELOPE;
+    bounded(async {
+        loop {
+            // One response is queued and one is pending in the sole sender.
+            // Semaphore waiters may reserve permits; inspect actual queued data.
+            if state.unread_bytes() == expected {
+                return expected;
+            }
+            tokio::task::yield_now().await;
+        }
+    })
+    .await
+}
+
+#[tokio::test]
+async fn mieru_tcp_udp_receive_memory_tracks_the_datagram_budget() {
+    let probe = ResourceProbe::default();
+    let (capacity, queued, expected) = probe
+        .scope(async {
+            let peer = Peer::new(false);
+            let mut settings = config(MieruHandshake::Standard);
+            settings.multiplexing = MieruMultiplexing::Low;
+            let node =
+                MieruOutbound::new(&settings, UpstreamPath::proxy(peer.clone()), CAPACITY).unwrap();
+            let context = EstablishContext::with_timeout(Duration::from_secs(3));
+            let request = DatagramRequest::new(DatagramSession::for_tun(session().source, 1500));
+            let expected = usize::from(request.budget().receive())
+                + usize::from(socks5::MAX_UDP_HEADER_SIZE)
+                + 4;
+            let mut packet = bounded(node.open_datagram(request, &context))
+                .await
+                .unwrap();
+            let carrier = node
+                .client
+                .registry
+                .lock()
+                .unwrap()
+                .carriers
+                .values()
+                .next()
+                .unwrap()
+                .clone();
+            let state = carrier
+                .shared
+                .sessions
+                .lock()
+                .unwrap()
+                .values()
+                .next()
+                .unwrap()
+                .clone();
+            let remote = Destination::Ip("198.51.100.1:53".parse().unwrap());
+            let mut bytes = Vec::new();
+            for index in 0..PACKETS {
+                let body = socks5::encode_udp_packet(
+                    &remote,
+                    &[index as u8; PAYLOAD],
+                    usize::from(u16::MAX),
+                )
+                .unwrap();
+                bytes.push(0);
+                bytes.extend_from_slice(&(body.len() as u16).to_be_bytes());
+                bytes.extend_from_slice(&body);
+                bytes.push(255);
+            }
+            assert_eq!(bytes.len(), PACKETS * ENVELOPE);
+            inject(&carrier, &state, &bytes).await;
+            let queued = blocked_input(&state).await;
+            for index in 0..PACKETS {
+                let response = bounded(packet.receive()).await.unwrap();
+                assert_eq!(response.remote, remote);
+                assert_eq!(response.payload.as_ref(), [index as u8; PAYLOAD]);
+            }
+            inject(&carrier, &state, &bytes).await;
+            blocked_input(&state).await;
+            bounded(node.shutdown()).await; // Stop must not await the application reader.
+            bounded(packet.close()).await.unwrap();
+            let capacity = state.receive_capacity();
+            drop((packet, state, carrier, node));
+            peer.stop().await;
+            (capacity, queued, expected)
+        })
+        .await;
+    assert!(probe.snapshot().is_idle());
+    assert!(
+        queued <= expected,
+        "queued {queued} exceeds datagram credit {expected}"
+    );
+    assert_eq!(capacity, expected);
+}
diff --git a/src/outbound/mieru/tests.rs b/src/outbound/mieru/tests.rs
new file mode 100644
index 0000000..a8dea64
--- /dev/null
+++ b/src/outbound/mieru/tests.rs
@@ -0,0 +1,317 @@
+//! Framing peers use bounded in-memory IO; no DNS, sockets or server processes.
+use super::{
+    MieruOutbound, crypto,
+    wire::{
+        DataKind, DataMetadata, Metadata, Padding, SessionKind, SessionMetadata, StreamDecoder,
+        StreamEncoder,
+    },
+};
+use crate::{
+    config::{MieruHandshake, MieruMultiplexing, MieruOutboundConfig, MieruTransport},
+    dispatch::{DatagramTransport, DispatchError},
+    outbound::{
+        ConnectedStream, DatagramRequest, EstablishContext, OutboundConnector, UpstreamPath,
+    },
+    resources::observation::{self, ResourceProbe},
+    session::{Datagram, DatagramSession, Destination, InboundKind, StreamSession},
+    socks5,
+};
+use async_trait::async_trait;
+use std::{
+    collections::HashMap,
+    io,
+    sync::{
+        Arc, Mutex,
+        atomic::{AtomicUsize, Ordering},
+    },
+    time::{Duration, SystemTime, UNIX_EPOCH},
+};
+use tokio::{
+    io::{AsyncReadExt, AsyncWriteExt, DuplexStream},
+    sync::Notify,
+};
+use tokio_util::{sync::CancellationToken, task::TaskTracker};
+
+pub(super) fn unix() -> io::Result<u64> {
+    Ok(SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap()
+        .as_secs())
+}
+pub(super) fn config(mode: MieruHandshake) -> MieruOutboundConfig {
+    MieruOutboundConfig {
+        address: "memory.invalid".into(),
+        port: 2000,
+        port_end: 2002,
+        username: "vole".into(),
+        password: "fixture-password".into(),
+        transport: MieruTransport::Tcp,
+        udp: true,
+        multiplexing: MieruMultiplexing::High,
+        handshake_mode: mode,
+        traffic_pattern: None,
+    }
+}
+pub(super) fn session() -> StreamSession {
+    StreamSession {
+        metadata: Default::default(),
+        inbound: InboundKind::Socks5,
+        source: "192.0.2.10:1000".parse().unwrap(),
+        destination: Destination::Ip("203.0.113.20:80".parse().unwrap()),
+        sniffed_domain: None,
+    }
+}
+pub(super) struct Peer {
+    pub calls: AtomicUsize,
+    stall: bool,
+    cancel: CancellationToken,
+    tasks: TaskTracker,
+    ports: Mutex<Vec<u16>>,
+    pub started: Notify,
+}
+impl Peer {
+    pub fn new(stall: bool) -> Arc<Self> {
+        Arc::new(Self {
+            calls: AtomicUsize::new(0),
+            stall,
+            cancel: CancellationToken::new(),
+            tasks: TaskTracker::new(),
+            ports: Mutex::new(Vec::new()),
+            started: Notify::new(),
+        })
+    }
+    pub async fn stop(&self) {
+        self.cancel.cancel();
+        self.tasks.close();
+        self.tasks.wait().await;
+    }
+}
+struct PeerSession {
+    sequence: u32,
+    request: Vec<u8>,
+    ready: bool,
+}
+#[async_trait]
+impl OutboundConnector for Peer {
+    async fn connect_stream(
+        &self,
+        request: StreamSession,
+        _: &EstablishContext,
+    ) -> Result<ConnectedStream, DispatchError> {
+        self.calls.fetch_add(1, Ordering::AcqRel);
+        self.ports.lock().unwrap().push(request.destination.port());
+        let (client, server) = tokio::io::duplex(if self.stall { 8 } else { 128 });
+        let cancel = self.cancel.clone();
+        let stall = self.stall;
+        self.tasks.spawn(observation::task(async move {
+            let serving = async {
+                if stall {
+                    let _server = server;
+                    std::future::pending::<()>().await;
+                } else {
+                    let _ = serve(server).await;
+                }
+            };
+            tokio::select! {biased;()=cancel.cancelled()=>{},()=serving=>{}}
+        }));
+        self.started.notify_one();
+        Ok(ConnectedStream {
+            io: Box::new(client),
+            effective_peer: request.destination,
+        })
+    }
+    async fn open_datagram(
+        &self,
+        _: DatagramRequest,
+        _: &EstablishContext,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        Err(DispatchError::NotAllowed)
+    }
+}
+async fn send(
+    stream: &mut DuplexStream,
+    encoder: &mut StreamEncoder,
+    metadata: Metadata,
+    payload: &[u8],
+    output: &mut Vec<u8>,
+) -> io::Result<()> {
+    encoder.encode_frame(
+        metadata,
+        payload,
+        Padding {
+            prefix: &[],
+            suffix: &[],
+        },
+        unix()?,
+        output,
+    )?;
+    stream.write_all(output).await?;
+    stream.flush().await
+}
+async fn data(
+    stream: &mut DuplexStream,
+    encoder: &mut StreamEncoder,
+    id: u32,
+    state: &mut PeerSession,
+    bytes: &[u8],
+    output: &mut Vec<u8>,
+) -> io::Result<()> {
+    for chunk in bytes.chunks(32768) {
+        send(
+            stream,
+            encoder,
+            Metadata::Data(DataMetadata {
+                kind: DataKind::ServerData,
+                session_id: id,
+                sequence: state.sequence,
+                unack_sequence: 0,
+                window: 16,
+                fragment: 0,
+            }),
+            chunk,
+            output,
+        )
+        .await?;
+        state.sequence = state.sequence.wrapping_add(1);
+    }
+    Ok(())
+}
+async fn serve(mut stream: DuplexStream) -> io::Result<()> {
+    let key = Arc::new(crypto::derive_key("vole", "fixture-password", unix()?));
+    let mut decoder = StreamDecoder::new(key.clone());
+    let mut encoder = StreamEncoder::new(key, crypto::make_client_nonce("vole", rand::random()));
+    let mut output = Vec::new();
+    let mut sessions = HashMap::<u32, PeerSession>::new();
+    while let Some(frame) = decoder.read_frame_with_clock(&mut stream, unix).await? {
+        let id = match frame.metadata {
+            Metadata::Session(meta) => meta.session_id,
+            Metadata::Data(meta) => meta.session_id,
+        };
+        if let Metadata::Session(meta) = frame.metadata {
+            if meta.kind == SessionKind::OpenRequest {
+                assert_ne!(id, 0);
+                assert!(!sessions.contains_key(&id));
+                sessions.insert(
+                    id,
+                    PeerSession {
+                        sequence: 1,
+                        request: Vec::new(),
+                        ready: false,
+                    },
+                );
+                send(
+                    &mut stream,
+                    &mut encoder,
+                    Metadata::Session(SessionMetadata {
+                        kind: SessionKind::OpenResponse,
+                        session_id: id,
+                        sequence: 0,
+                        status: 0,
+                    }),
+                    &[],
+                    &mut output,
+                )
+                .await?;
+            } else if meta.kind == SessionKind::CloseRequest {
+                if let Some(state) = sessions.remove(&id) {
+                    send(
+                        &mut stream,
+                        &mut encoder,
+                        Metadata::Session(SessionMetadata {
+                            kind: SessionKind::CloseResponse,
+                            session_id: id,
+                            sequence: state.sequence,
+                            status: 0,
+                        }),
+                        &[],
+                        &mut output,
+                    )
+                    .await?;
+                }
+                continue;
+            }
+        }
+        let state = sessions.get_mut(&id).unwrap();
+        if !state.ready {
+            state.request.extend_from_slice(&frame.payload);
+            if state.request.len() < 10 {
+                continue;
+            }
+            assert_eq!(state.request[0], 5);
+            assert!(matches!(state.request[1], 1 | 3));
+            assert_eq!(state.request[2], 0);
+            let mut address = &state.request[3..];
+            socks5::read_destination(&mut address, true).await?;
+            let consumed = state.request.len() - address.len();
+            let body = state.request.split_off(consumed);
+            state.request.clear();
+            state.ready = true;
+            data(
+                &mut stream,
+                &mut encoder,
+                id,
+                state,
+                &[5, 0, 0, 1, 0, 0, 0, 0, 0, 0],
+                &mut output,
+            )
+            .await?;
+            data(&mut stream, &mut encoder, id, state, &body, &mut output).await?;
+        } else {
+            data(
+                &mut stream,
+                &mut encoder,
+                id,
+                state,
+                &frame.payload,
+                &mut output,
+            )
+            .await?;
+        }
+    }
+    Ok(())
+}
+pub(super) async fn echo(stream: &mut crate::dispatch::BoxStream, bytes: &[u8]) {
+    tokio::time::timeout(Duration::from_secs(3), async {
+        stream.write_all(bytes).await.unwrap();
+        let mut received = vec![0; bytes.len()];
+        stream.read_exact(&mut received).await.unwrap();
+        assert_eq!(received, bytes);
+    })
+    .await
+    .unwrap();
+}
+#[tokio::test]
+async fn mieru_tcp_standard_and_no_wait_client_first_and_udp_business() {
+    let probe = ResourceProbe::default();
+    probe.scope(async {
+        for mode in [MieruHandshake::Standard,MieruHandshake::NoWait] {
+            let peer=Peer::new(false);let node=MieruOutbound::new(&config(mode),UpstreamPath::proxy(peer.clone()),1024).unwrap();let context=EstablishContext::with_timeout(Duration::from_secs(5));
+            let mut stream=node.connect_stream(session(),&context).await.unwrap().io;
+            if mode==MieruHandshake::NoWait {
+                let mut byte=[0];let reading=stream.read_exact(&mut byte);tokio::pin!(reading);
+                tokio::select!{result=&mut reading=>panic!("read before first write completed: {result:?}"),()=tokio::time::sleep(Duration::from_millis(10))=>{}}
+            }
+            echo(&mut stream,&vec![1;512]).await;
+            let request=DatagramRequest::new(DatagramSession::new(InboundKind::Socks5,"192.0.2.10:1000".parse().unwrap()));
+            let mut packet=node.open_datagram(request,&context).await.unwrap();
+            let remote=Destination::Ip("198.51.100.1:53".parse().unwrap());let payload=vec![9;4096];packet.send(Datagram{remote:remote.clone(),payload:payload.clone().into(),sniffed_domain:None}).await.unwrap();let response=packet.receive().await.unwrap();assert_eq!(response.remote,remote);assert_eq!(response.payload,payload);
+            packet.close().await.unwrap();drop(packet);node.shutdown().await;drop(stream);drop(node);peer.stop().await;
+            assert!(peer.ports.lock().unwrap().iter().all(|port|(2000..=2002).contains(port)));
+        }
+    }).await;
+    assert!(probe.snapshot().is_idle());
+}
+#[tokio::test]
+async fn mieru_tcp_stop_joins_partial_physical_frame_and_lazy_reader() {
+    let probe = ResourceProbe::default();
+    probe.scope(async {
+        let peer=Peer::new(true);let node=MieruOutbound::new(&config(MieruHandshake::NoWait),UpstreamPath::proxy(peer.clone()),32).unwrap();let context=EstablishContext::with_timeout(Duration::from_secs(5));
+        let mut stream=node.connect_stream(session(),&context).await.unwrap().io;
+        let bytes=vec![3;4096];let writing=stream.write_all(&bytes);let mut writing=Box::pin(writing);
+        tokio::select!{result=&mut writing=>panic!("write completed on stalled frame: {result:?}"),()=tokio::time::sleep(Duration::from_millis(20))=>{}}
+        drop(writing);drop(stream);
+        tokio::time::timeout(Duration::from_secs(2),node.shutdown()).await.unwrap();
+        assert!(node.client.spawn(Box::pin(async {})).is_err());drop(node);peer.stop().await;
+    }).await;
+    assert!(probe.snapshot().is_idle());
+}
diff --git a/src/outbound/mieru/udp.rs b/src/outbound/mieru/udp.rs
new file mode 100644
index 0000000..631009d
--- /dev/null
+++ b/src/outbound/mieru/udp.rs
@@ -0,0 +1,4062 @@
+//! Reliable UDP carrier. One owned driver serializes physical IO and all timers.
+//! Datagram loss never advances the receiver or releases unacknowledged bytes.
+use super::{
+    crypto,
+    pattern::{EffectivePattern, NonceState},
+    reliability::{Cubic, Rtt},
+    stream::{ReceivedChunk, State, closed},
+    tcp::{Shared, WriterCommand},
+    wire::{
+        DataKind, DataMetadata, Frame, Metadata, PacketDecoder, PacketEncoder, SessionKind,
+        SessionMetadata,
+    },
+};
+use crate::{
+    config::{MieruOutboundConfig, MieruTransport},
+    dispatch::{DatagramBudget, DatagramTransport},
+    outbound::{DatagramRequest, EstablishContext, UpstreamPath, server_destination},
+    resources::observation::{self, ResourceKind},
+    session::{Datagram, DatagramSession, Destination, StreamSession},
+};
+use bytes::Bytes;
+use futures_util::FutureExt;
+use std::{
+    collections::{BTreeMap, VecDeque},
+    io,
+    sync::{
+        Arc, Mutex,
+        atomic::{AtomicUsize, Ordering},
+    },
+};
+use tokio::{
+    sync::{OwnedSemaphorePermit, Semaphore, mpsc, oneshot},
+    time::{Duration, Instant, timeout_at},
+};
+const MTU: u16 = 1400;
+const EMPTY_OVERHEAD: usize = super::wire::PACKET_HEADER_LEN;
+const DATA_OVERHEAD: usize = super::wire::PACKET_OVERHEAD;
+const SEGMENTS: usize = 4096;
+const TX_LIMIT: u32 = 20;
+const ACK_DELAY: Duration = Duration::from_millis(1);
+const FIRST_CHECK: Duration = Duration::from_millis(10);
+const CLOSE_RECEIVE_GRACE: Duration = Duration::from_millis(100);
+const RECEIVE_BATCH: u8 = 8;
+const OUTPUT_QUANTUM: usize = 8;
+const CLOSE_RETRY_CAPACITY: usize = 16;
+const CLOSE_RETRY_INTERVAL: Duration = Duration::from_millis(100);
+const REORDER_SLACK: usize = 32768;
+
+struct WriteLease {
+    _bytes: OwnedSemaphorePermit,
+    remaining: AtomicUsize,
+    done: Mutex<Option<oneshot::Sender<io::Result<()>>>>,
+}
+impl WriteLease {
+    fn sent(&self) {
+        if self.remaining.fetch_sub(1, Ordering::AcqRel) == 1
+            && let Some(done) = self.done.lock().unwrap().take()
+        {
+            let _ = done.send(Ok(()));
+        }
+    }
+}
+impl Drop for WriteLease {
+    fn drop(&mut self) {
+        if let Some(done) = self.done.get_mut().unwrap().take() {
+            let _ = done.send(Err(closed()));
+        }
+    }
+}
+struct Segment {
+    metadata: Metadata,
+    payload: Bytes,
+    lease: Option<Arc<WriteLease>>,
+    sent: Option<Instant>,
+    // Used after successful UDP-associate sends; the <=10s value is exact in u64 ns.
+    timeout_nanos: u64,
+    tx_count: u32,
+    ack_count: u32,
+}
+struct Inbound {
+    frame: Frame,
+    permit: OwnedSemaphorePermit,
+}
+// The physical driver may retain one authenticated packet independently of
+// application byte credit. Copying bounds the retained allocation by RX MTU,
+// even when an upstream supplied a slice backed by a larger allocation.
+struct Partial {
+    session_id: u32,
+    sequence: u32,
+    payload: Bytes,
+    offset: usize,
+}
+struct PacketPattern<'a> {
+    pattern: &'a EffectivePattern,
+    nonce: NonceState,
+    wire_budget: usize,
+    remaining: usize,
+    truncated: bool,
+}
+#[derive(Clone, Copy)]
+struct CloseRetry {
+    metadata: SessionMetadata,
+    due: Instant,
+    remaining: u8,
+}
+#[derive(Default)]
+struct CloseRetries {
+    entries: Option<Box<[Option<CloseRetry>; CLOSE_RETRY_CAPACITY]>>,
+}
+impl CloseRetries {
+    fn remove(&mut self, id: u32) {
+        let Some(entries) = self.entries.as_mut() else {
+            return;
+        };
+        if let Some(index) = entries
+            .iter()
+            .position(|entry| entry.is_some_and(|entry| entry.metadata.session_id == id))
+        {
+            entries[index..].rotate_left(1);
+            entries[CLOSE_RETRY_CAPACITY - 1] = None;
+        }
+    }
+    fn insert(&mut self, metadata: SessionMetadata, now: Instant) {
+        self.remove(metadata.session_id);
+        let entries = self
+            .entries
+            .get_or_insert_with(|| Box::new([None; CLOSE_RETRY_CAPACITY]));
+        let retry = Some(CloseRetry {
+            metadata,
+            due: now + CLOSE_RETRY_INTERVAL,
+            remaining: 2,
+        });
+        if let Some(slot) = entries.iter_mut().find(|entry| entry.is_none()) {
+            *slot = retry;
+        } else {
+            entries.rotate_left(1); // Evict only the oldest best-effort record.
+            entries[CLOSE_RETRY_CAPACITY - 1] = retry;
+        }
+    }
+    fn deadline(&self) -> Option<Instant> {
+        self.entries
+            .as_ref()?
+            .iter()
+            .flatten()
+            .map(|entry| entry.due)
+            .min()
+    }
+    fn due(&self, now: Instant) -> Option<(usize, CloseRetry)> {
+        self.entries
+            .as_ref()?
+            .iter()
+            .enumerate()
+            .filter_map(|(index, entry)| entry.as_ref().map(|entry| (index, *entry)))
+            .filter(|(_, entry)| entry.due <= now)
+            .min_by_key(|(_, entry)| entry.due)
+    }
+    fn attempted(&mut self, index: usize, retry: CloseRetry, success: bool, now: Instant) {
+        if success && retry.remaining > 1 {
+            if let Some(entries) = self.entries.as_mut() {
+                entries[index] = Some(CloseRetry {
+                    due: now + CLOSE_RETRY_INTERVAL,
+                    remaining: retry.remaining - 1,
+                    ..retry
+                });
+            }
+        } else {
+            self.remove(retry.metadata.session_id);
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+struct CloseGrace {
+    end: u32,
+    until: Instant,
+}
+struct Reliable {
+    state: Arc<State>,
+    pending: VecDeque<Segment>,
+    outstanding: BTreeMap<u32, Segment>,
+    reorder: BTreeMap<u32, Inbound>,
+    // Authenticated pending DATA and application unread bytes own separate
+    // bounded leases. A blocked reader must not spend the missing head's credit.
+    reorder_bytes: Arc<Semaphore>,
+    // Fixed extra retention for normal windows; never advertised to the peer.
+    reorder_slack: usize,
+    established: bool,
+    remote_window: u32,
+    rtt: Rtt,
+    cubic: Cubic,
+    // One timeout response for the pre-epoch flight across bounded TX slices.
+    timeout_epoch: Option<Instant>,
+    ack_due: Option<Instant>,
+    heartbeat: Instant,
+    heartbeat_interval: Duration,
+    first_check: Option<Instant>,
+    last_window: u16,
+    receive_chunk: usize,
+    // A remote Close must not truncate the one already authenticated packet
+    // being delivered through a smaller application byte budget.
+    remote_close: Option<bool>,
+    // Fixed in-flight DATA opportunity, never a reliable FIN or added credit.
+    close_grace: Option<CloseGrace>,
+}
+impl Drop for Reliable {
+    fn drop(&mut self) {
+        // Publish before the original pending/outstanding fields release leases.
+        self.state.mark_ack_terminal();
+    }
+}
+
+fn heartbeat_interval() -> Duration {
+    Duration::from_millis(4000 + rand::random_range(0..=2000u64))
+}
+fn sequence(metadata: Metadata) -> u32 {
+    match metadata {
+        Metadata::Session(m) => m.sequence,
+        Metadata::Data(m) => m.sequence,
+    }
+}
+fn session_id(metadata: Metadata) -> u32 {
+    match metadata {
+        Metadata::Session(m) => m.session_id,
+        Metadata::Data(m) => m.session_id,
+    }
+}
+fn close_metadata(state: &State, kind: SessionKind) -> Metadata {
+    Metadata::Session(SessionMetadata {
+        kind,
+        session_id: state.id,
+        sequence: state.sequence.fetch_add(1, Ordering::AcqRel),
+        status: 0,
+    })
+}
+impl Reliable {
+    fn new(state: Arc<State>, receive_chunk: usize) -> Self {
+        let now = Instant::now();
+        let interval = heartbeat_interval();
+        let capacity = state.receive_capacity();
+        let reorder_slack = if state.business == super::tcp::Business::TcpConnect
+            && capacity >= REORDER_SLACK
+            && capacity >= receive_chunk
+        {
+            REORDER_SLACK
+        } else {
+            0
+        };
+        let reorder_bytes = Arc::new(Semaphore::new(capacity + reorder_slack));
+        Self {
+            state,
+            reorder_bytes,
+            reorder_slack,
+            pending: VecDeque::new(),
+            outstanding: BTreeMap::new(),
+            reorder: BTreeMap::new(),
+            established: false,
+            remote_window: 16,
+            rtt: Rtt::new(),
+            cubic: Cubic::new(),
+            timeout_epoch: None,
+            ack_due: None,
+            heartbeat: now + interval,
+            heartbeat_interval: interval,
+            first_check: None,
+            last_window: 0,
+            receive_chunk,
+            remote_close: None,
+            close_grace: None,
+        }
+    }
+    fn small_budget(&self) -> bool {
+        self.state.receive_capacity() < self.receive_chunk
+    }
+    fn window(&self, partial_available: bool) -> u16 {
+        let count = self.reorder.len() + self.state.unread_segments();
+        let segment_space = SEGMENTS.saturating_sub(count);
+        let small_budget = self.small_budget();
+        let bytes = if small_budget {
+            self.state.receive_bytes.available_permits()
+        } else {
+            self.reorder_bytes.available_permits()
+        };
+        let byte_space = if small_budget {
+            // A single physical parser slot, plus real app byte credit,
+            // permits incremental delivery without pretending the queue can
+            // buffer a complete peer segment. While occupied, advertise zero.
+            usize::from(partial_available && bytes > 0)
+        } else {
+            // New DATA must leave the same missing-head credit as input().
+            let reserve = if self
+                .reorder
+                .first_key_value()
+                .is_some_and(|(seq, _)| *seq > self.state.next_receive.load(Ordering::Acquire))
+            {
+                self.receive_chunk
+            } else {
+                0
+            };
+            // Advertise only original capacity minus actual retained bytes.
+            // Taking min(bytes, capacity) would silently reuse the extra slack.
+            bytes
+                .saturating_sub(self.reorder_slack)
+                .saturating_sub(reserve)
+                / self.receive_chunk
+        };
+        segment_space.min(byte_space).min(u16::MAX as usize) as u16
+    }
+    fn request_ack(&mut self, now: Instant) {
+        let due = now + ACK_DELAY;
+        self.ack_due = Some(self.ack_due.map_or(due, |old| old.min(due)));
+    }
+    fn enqueue(&mut self, command: WriterCommand, chunk: usize, allow_piggyback: bool) {
+        self.state.mark_ack_pending();
+        let first = !self.state.opened.swap(true, Ordering::AcqRel);
+        let piggyback = first
+            && allow_piggyback
+            && command.piggyback
+            && command.data.len() <= 1024
+            && command.data.len() <= chunk;
+        let count = if piggyback {
+            1
+        } else {
+            command.data.len().div_ceil(chunk)
+        };
+        let lease = Arc::new(WriteLease {
+            _bytes: command._bytes,
+            remaining: AtomicUsize::new(count),
+            done: Mutex::new(Some(command.done)),
+        });
+        if first {
+            let metadata = Metadata::Session(SessionMetadata {
+                kind: SessionKind::OpenRequest,
+                session_id: self.state.id,
+                sequence: self.state.sequence.fetch_add(1, Ordering::AcqRel),
+                status: 0,
+            });
+            self.pending.push_back(Segment {
+                metadata,
+                payload: if piggyback {
+                    command.data.clone()
+                } else {
+                    Bytes::new()
+                },
+                lease: if piggyback { Some(lease.clone()) } else { None },
+                sent: None,
+                timeout_nanos: 0,
+                tx_count: 0,
+                ack_count: 0,
+            });
+        }
+        if !piggyback {
+            let fragments = command.data.len().div_ceil(chunk);
+            for (index, part) in command.data.chunks(chunk).enumerate() {
+                let start = index * chunk;
+                let metadata = Metadata::Data(DataMetadata {
+                    kind: DataKind::ClientData,
+                    session_id: self.state.id,
+                    sequence: self.state.sequence.fetch_add(1, Ordering::AcqRel),
+                    unack_sequence: self.state.next_receive.load(Ordering::Acquire),
+                    window: 0,
+                    fragment: (fragments - index - 1) as u8,
+                });
+                self.pending.push_back(Segment {
+                    metadata,
+                    payload: command.data.slice(start..start + part.len()),
+                    lease: Some(lease.clone()),
+                    sent: None,
+                    timeout_nanos: 0,
+                    tx_count: 0,
+                    ack_count: 0,
+                });
+            }
+        }
+    }
+    fn acknowledge(&mut self, unack: u32, window: u16, only_ack: bool, now: Instant) {
+        while self
+            .outstanding
+            .first_key_value()
+            .is_some_and(|(seq, _)| *seq < unack)
+        {
+            let (_, segment) = self.outstanding.pop_first().unwrap();
+            self.rtt
+                .update(now.saturating_duration_since(segment.sent.unwrap()));
+            self.cubic.on_ack(now);
+        }
+        self.remote_window = u32::from(window);
+        if only_ack && let Some(segment) = self.outstanding.get_mut(&unack) {
+            segment.ack_count = segment.ack_count.saturating_add(1);
+        }
+        // Only a real cumulative ACK may publish successful drain. First-send
+        // completion, lease drop, and terminal tree clearing are not ACKs.
+        if self.pending.is_empty() && self.outstanding.is_empty() {
+            self.state.mark_ack_drained();
+        }
+    }
+    fn input(&mut self, frame: Frame, now: Instant, partial: &mut Option<Partial>) {
+        if self.remote_close.is_some()
+            && !(self.close_grace.is_some_and(|grace| {
+                now < grace.until
+                    && matches!(frame.metadata, Metadata::Data(meta)
+                        if meta.kind == DataKind::ServerData && meta.sequence < grace.end)
+            }) && !self.state.cancel.is_cancelled()
+                && !self.state.local_closed.load(Ordering::Acquire))
+        {
+            return;
+        }
+        if let Metadata::Data(meta) = frame.metadata {
+            self.acknowledge(
+                meta.unack_sequence,
+                meta.window,
+                meta.kind == DataKind::ServerAck,
+                now,
+            );
+            if meta.kind == DataKind::ServerAck {
+                return;
+            }
+        }
+        self.request_ack(now);
+        let seq = sequence(frame.metadata);
+        let next_receive = self.state.next_receive.load(Ordering::Acquire);
+        if seq < next_receive || self.reorder.contains_key(&seq) {
+            return;
+        }
+        if partial
+            .as_ref()
+            .is_some_and(|pending| pending.session_id == self.state.id && pending.sequence == seq)
+        {
+            return; // A retransmission must never deliver the prefix twice.
+        }
+        let segment_limit = SEGMENTS - usize::from(seq != next_receive);
+        if self.reorder.len() + self.state.unread_segments() >= segment_limit {
+            return;
+        }
+        if self.small_budget() && !frame.payload.is_empty() {
+            // Future DATA must not consume the byte credit needed by the
+            // missing preceding frame. Its peer retains it until cumulative ACK.
+            if seq != self.state.next_receive.load(Ordering::Acquire) || partial.is_some() {
+                return;
+            }
+            if matches!(frame.metadata,Metadata::Session(meta) if meta.kind==SessionKind::OpenResponse)
+            {
+                self.established = true;
+            }
+            *partial = Some(Partial {
+                session_id: self.state.id,
+                sequence: seq,
+                payload: Bytes::copy_from_slice(&frame.payload),
+                offset: 0,
+            });
+            return;
+        }
+        // Tiny budgets keep the existing physical Partial slot and app leases.
+        // Normal DATA first owns reorder credit, independent of app unread bytes.
+        let receive_bytes = if self.small_budget() {
+            &self.state.receive_bytes
+        } else {
+            &self.reorder_bytes
+        };
+        if !frame.payload.is_empty() {
+            let reserve = if seq == next_receive {
+                0
+            } else {
+                self.receive_chunk
+            };
+            let required = frame.payload.len().saturating_add(reserve);
+            let available = receive_bytes.available_permits();
+            if available < required {
+                let reclaimable = self
+                    .reorder
+                    .iter()
+                    .rev()
+                    .take_while(|(queued, _)| **queued > seq)
+                    .map(|(_, inbound)| inbound.frame.payload.len())
+                    .sum::<usize>();
+                if available.saturating_add(reclaimable) < required {
+                    return;
+                }
+                while receive_bytes.available_permits() < required
+                    && self
+                        .reorder
+                        .last_key_value()
+                        .is_some_and(|(queued, _)| *queued > seq)
+                {
+                    drop(self.reorder.pop_last());
+                }
+            }
+        }
+        let Ok(permit) = receive_bytes
+            .clone()
+            .try_acquire_many_owned(frame.payload.len() as u32)
+        else {
+            return;
+        };
+        if matches!(frame.metadata,Metadata::Session(meta) if meta.kind==SessionKind::OpenResponse)
+        {
+            self.established = true;
+        }
+        self.reorder.insert(seq, Inbound { frame, permit });
+        self.deliver_contiguous();
+    }
+    fn deliver_contiguous(&mut self) -> bool {
+        let mut advanced = false;
+        if self.small_budget() {
+            // Preserve the tiny path's existing app permit ownership exactly.
+            while let Some(inbound) = self
+                .reorder
+                .remove(&self.state.next_receive.load(Ordering::Acquire))
+            {
+                self.state.next_receive.fetch_add(1, Ordering::AcqRel);
+                self.state.deliver_reserved(ReceivedChunk {
+                    bytes: inbound.frame.payload,
+                    permit: inbound.permit,
+                });
+                advanced = true;
+            }
+            return advanced;
+        }
+        loop {
+            let next = self.state.next_receive.load(Ordering::Acquire);
+            let Some(inbound) = self.reorder.get(&next) else {
+                break;
+            };
+            let Ok(permit) = self
+                .state
+                .receive_bytes
+                .clone()
+                .try_acquire_many_owned(inbound.frame.payload.len() as u32)
+            else {
+                break;
+            };
+            // Clone only the Bytes handle, retaining the same allocation and
+            // reorder lease until the app enqueue has actually committed.
+            let delivered = self.state.try_deliver_reserved(ReceivedChunk {
+                bytes: inbound.frame.payload.clone(),
+                permit,
+            });
+            if !delivered {
+                break;
+            }
+            drop(self.reorder.remove(&next));
+            // The cumulative ACK commits only bytes actually queued for the app.
+            self.state.next_receive.fetch_add(1, Ordering::AcqRel);
+            advanced = true;
+        }
+        advanced
+    }
+    fn retain_contiguous_on_close(&mut self) {
+        let mut next = self.state.next_receive.load(Ordering::Acquire);
+        let mut gap = false;
+        self.reorder.retain(|sequence, _| {
+            if gap || *sequence != next {
+                gap = true;
+                return false;
+            }
+            next = next.wrapping_add(1);
+            true
+        });
+    }
+    fn converge_close_grace(&mut self, now: Instant) {
+        if self.close_grace.is_some_and(|grace| {
+            now >= grace.until
+                || self.state.next_receive.load(Ordering::Acquire) >= grace.end
+                || self.state.cancel.is_cancelled()
+                || self.state.local_closed.load(Ordering::Acquire)
+        }) {
+            // Clear before app-prefix draining: a blocked app may not keep
+            // choosing an expired deadline in a busy loop.
+            self.close_grace = None;
+            self.retain_contiguous_on_close();
+        }
+    }
+    fn next_deadline(&self, now: Instant) -> Instant {
+        let mut next = now + Duration::from_secs(5);
+        if self.remote_close.is_some() {
+            return self.close_grace.map_or(next, |grace| next.min(grace.until));
+        }
+        if let Some(first) = self.first_check {
+            next = next.min(first);
+        }
+        // RTT is unchanged within this read-only SID scan. Compute its base
+        // lazily, so empty scans and fast-ACK-only scans still do no RTO work.
+        let saved_timeout = self.state.business == super::tcp::Business::UdpAssociate;
+        let single_segment = self.outstanding.len() == 1;
+        let mut base_rto = None;
+        for segment in self.outstanding.values() {
+            let due = if segment.ack_count >= 3 && segment.tx_count <= 1 {
+                now
+            } else {
+                segment.sent.unwrap()
+                    + if saved_timeout {
+                        Duration::from_nanos(segment.timeout_nanos)
+                    } else if single_segment {
+                        self.rtt.retransmit_delay(segment.tx_count)
+                    } else {
+                        Rtt::retransmit_delay_from_rto(
+                            *base_rto.get_or_insert_with(|| self.rtt.rto()),
+                            segment.tx_count,
+                        )
+                    }
+            };
+            next = next.min(due);
+        }
+        if self.established {
+            next = next.min(self.heartbeat);
+            if let Some(ack) = self.ack_due {
+                next = next.min(ack);
+            }
+        }
+        next
+    }
+}
+
+fn advance_partial(
+    partial: &mut Option<Partial>,
+    sessions: &mut BTreeMap<u32, Reliable>,
+) -> Option<u32> {
+    let pending = partial.as_mut()?;
+    let Some(state) = sessions.get_mut(&pending.session_id) else {
+        *partial = None;
+        return None;
+    };
+    if state.state.cancel.is_cancelled() {
+        *partial = None;
+        return None;
+    }
+    let count = (pending.payload.len() - pending.offset)
+        .min(state.state.receive_capacity())
+        .min(state.state.receive_bytes.available_permits());
+    if count == 0 {
+        return None;
+    }
+    let Ok(permit) = state
+        .state
+        .receive_bytes
+        .clone()
+        .try_acquire_many_owned(count as u32)
+    else {
+        return None;
+    };
+    state.state.deliver_reserved(ReceivedChunk {
+        // Never let an app chunk retain the larger parser allocation.
+        bytes: Bytes::copy_from_slice(&pending.payload[pending.offset..pending.offset + count]),
+        permit,
+    });
+    pending.offset += count;
+    if pending.offset == pending.payload.len() {
+        debug_assert_eq!(
+            state.state.next_receive.load(Ordering::Acquire),
+            pending.sequence
+        );
+        state.state.next_receive.fetch_add(1, Ordering::AcqRel);
+        state.deliver_contiguous();
+        state.request_ack(Instant::now());
+        if let Some(failure) = state.remote_close {
+            state.state.finish(failure);
+            let id = pending.session_id;
+            *partial = None;
+            sessions.remove(&id);
+            return Some(id);
+        }
+        *partial = None;
+    }
+    None
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(super) async fn drive(
+    config: &MieruOutboundConfig,
+    upstream: &UpstreamPath,
+    pattern: &EffectivePattern,
+    session: StreamSession,
+    context: EstablishContext,
+    shared: &Arc<Shared>,
+    commands: mpsc::Receiver<WriterCommand>,
+    ready: oneshot::Sender<io::Result<()>>,
+) {
+    let setup = async {
+        let _guard = observation::track(ResourceKind::Handshake);
+        let port = rand::random_range(config.port..=config.port_end);
+        let server = server_destination(&config.address, port)?;
+        let upstream = upstream.for_server(&server, true);
+        let destination = upstream
+            .datagram_server(&server, &context)
+            .await
+            .map_err(|_| closed())?;
+        let peer = context
+            .resolve_ip(&destination)
+            .await
+            .map_err(|_| closed())?;
+        let mut datagram = DatagramSession::new(session.inbound, session.source);
+        datagram.metadata = session.metadata;
+        let request = DatagramRequest::new(datagram).with_udp_receive_buffer_size(512 * 1024);
+        let transport = upstream
+            .open_datagram(request.with_budget(DatagramBudget::new(MTU, MTU)), &context)
+            .await
+            .map_err(|_| closed())?;
+        let peer = Destination::Ip(peer);
+        let budget = DatagramBudget::new(MTU, MTU).intersect(transport.payload_budget(&peer));
+        if usize::from(budget.transmit()) <= DATA_OVERHEAD
+            || usize::from(budget.receive()) < EMPTY_OVERHEAD
+        {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Mieru UDP path budget is too small",
+            ));
+        }
+        let chunk = pattern
+            .plaintext_fragment_limit(MieruTransport::Udp, usize::from(budget.transmit()))?;
+        shared.set_maximum_write((chunk * 255).min(32768));
+        let key = crypto::derive_packet_key(&config.username, &config.password, super::tcp::now()?);
+        let low_entropy = pattern.low_entropy_enabled();
+        Ok((
+            transport,
+            peer,
+            budget,
+            // BodyEncoding applies the pattern independently of the AEAD backend.
+            PacketEncoder::new(&key, false)?,
+            PacketDecoder::new(&key, low_entropy)?,
+        ))
+    };
+    let result = tokio::select! {biased;()=shared.cancel.cancelled()=>Err(closed()),result=timeout_at(context.deadline(),setup)=>result.map_err(|_|io::Error::from(io::ErrorKind::TimedOut)).and_then(|result|result)};
+    match result {
+        Ok((mut transport, peer, budget, mut encoder, mut decoder)) => {
+            if ready.send(Ok(())).is_ok() {
+                let _ = run(
+                    &mut *transport,
+                    &peer,
+                    budget,
+                    &mut encoder,
+                    &mut decoder,
+                    &config.username,
+                    pattern,
+                    shared,
+                    commands,
+                )
+                .await;
+            }
+            shared.fail();
+            let _ = tokio::time::timeout(Duration::from_secs(1), transport.close()).await;
+        }
+        Err(error) => {
+            let _ = ready.send(Err(error));
+        }
+    }
+}
+async fn receive_packet(
+    transport: &mut dyn DatagramTransport,
+    scratch: &mut Vec<u8>,
+) -> Result<Datagram, crate::dispatch::DispatchError> {
+    if transport.supports_poll_receive() {
+        std::future::poll_fn(|context| transport.poll_receive(context, scratch)).await
+    } else {
+        transport.receive().await
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn send(
+    transport: &mut dyn DatagramTransport,
+    peer: &Destination,
+    encoder: &mut PacketEncoder,
+    username: &str,
+    shared: &Shared,
+    pattern: &mut PacketPattern<'_>,
+    metadata: Metadata,
+    payload: &[u8],
+    output: &mut Vec<u8>,
+) -> io::Result<()> {
+    let mut nonce = rand::random();
+    pattern
+        .pattern
+        .rewrite_nonce(&mut pattern.nonce, &mut nonce, MieruTransport::Udp);
+    let nonce = crypto::make_client_nonce(username, nonce);
+    let prepared = pattern.pattern.prepare_frame(
+        metadata,
+        payload.len(),
+        MieruTransport::Udp,
+        pattern.wire_budget,
+    )?;
+    encoder.encode_frame(
+        metadata,
+        payload,
+        prepared.encoding(),
+        nonce,
+        super::tcp::now()?,
+        output,
+    )?;
+    tokio::select! {biased;()=shared.cancel.cancelled()=>return Err(closed()),result=tokio::time::timeout(Duration::from_secs(10),transport.send(Datagram{remote:peer.clone(),payload:Bytes::copy_from_slice(output),sniffed_domain:None}))=>result.map_err(|_|io::ErrorKind::TimedOut)?.map_err(|_|closed())?}
+    pattern.remaining -= 1;
+    shared.count_output(output.len());
+    Ok(())
+}
+#[allow(clippy::too_many_arguments)]
+async fn output(
+    transport: &mut dyn DatagramTransport,
+    peer: &Destination,
+    encoder: &mut PacketEncoder,
+    username: &str,
+    shared: &Shared,
+    pattern: &mut PacketPattern<'_>,
+    state: &mut Reliable,
+    partial_available: bool,
+    buffer: &mut Vec<u8>,
+) -> io::Result<bool> {
+    let now = Instant::now();
+    let mut had_timeout = false;
+    let mut new_timeout = false;
+    let timeout_epoch = state.timeout_epoch;
+    let mut had_loss = false;
+    let mut new_sent = 0u32;
+    state.first_check = None;
+    if state.established && (state.ack_due.is_some_and(|due| now >= due) || now >= state.heartbeat)
+    {
+        if pattern.remaining == 0 {
+            pattern.truncated = true;
+            return Ok(true);
+        }
+        let window = state.window(partial_available);
+        let metadata = Metadata::Data(DataMetadata {
+            kind: DataKind::ClientAck,
+            session_id: state.state.id,
+            sequence: state.state.sequence.load(Ordering::Acquire).wrapping_sub(1),
+            unack_sequence: state.state.next_receive.load(Ordering::Acquire),
+            window,
+            fragment: 0,
+        });
+        send(
+            transport,
+            peer,
+            encoder,
+            username,
+            shared,
+            pattern,
+            metadata,
+            &[],
+            buffer,
+        )
+        .await?;
+        state.last_window = window;
+        state.ack_due = None;
+        state.heartbeat_interval = heartbeat_interval();
+        state.heartbeat = Instant::now() + state.heartbeat_interval;
+    }
+    // This owner cannot process incoming ACKs while output holds the SID.
+    // Keep the base local to this scan, including across its physical sends.
+    let rtt = &state.rtt;
+    let saved_timeout = state.state.business == super::tcp::Business::UdpAssociate;
+    let single_segment = state.outstanding.len() == 1;
+    let mut base_rto = None;
+    for segment in state.outstanding.values_mut() {
+        let fast = segment.ack_count >= 3 && segment.tx_count <= 1;
+        let sent = segment.sent.unwrap();
+        let timeout = now
+            >= sent
+                + if saved_timeout {
+                    Duration::from_nanos(segment.timeout_nanos)
+                } else if single_segment {
+                    rtt.retransmit_delay(segment.tx_count)
+                } else {
+                    Rtt::retransmit_delay_from_rto(
+                        *base_rto.get_or_insert_with(|| rtt.rto()),
+                        segment.tx_count,
+                    )
+                };
+        if !fast && !timeout {
+            continue;
+        }
+        if pattern.remaining == 0 {
+            pattern.truncated = true;
+            break;
+        }
+        if segment.tx_count >= TX_LIMIT {
+            return Ok(false);
+        }
+        if let Metadata::Data(ref mut meta) = segment.metadata {
+            meta.unack_sequence = state.state.next_receive.load(Ordering::Acquire);
+            meta.window = state.last_window;
+        }
+        send(
+            transport,
+            peer,
+            encoder,
+            username,
+            shared,
+            pattern,
+            segment.metadata,
+            &segment.payload,
+            buffer,
+        )
+        .await?;
+        had_loss |= fast;
+        had_timeout |= !fast;
+        new_timeout |= !fast && timeout_epoch.is_none_or(|epoch| sent >= epoch);
+        segment.ack_count = 0;
+        segment.tx_count += 1;
+        segment.sent = Some(Instant::now());
+        state.heartbeat = segment.sent.unwrap() + state.heartbeat_interval;
+        if saved_timeout {
+            segment.timeout_nanos = rtt.retransmit_delay(segment.tx_count).as_nanos() as u64;
+        }
+    }
+    if had_timeout {
+        if new_timeout {
+            state.cubic.on_timeout();
+            state.timeout_epoch = Some(now);
+        }
+    } else if had_loss {
+        state.cubic.on_loss(now);
+    }
+    if pattern.truncated {
+        return Ok(true);
+    }
+    let available = state
+        .cubic
+        .window()
+        .saturating_sub(state.outstanding.len() as u32)
+        .min(state.remote_window);
+    loop {
+        if new_sent >= available || state.outstanding.len() >= SEGMENTS - 1 {
+            break;
+        }
+        let Some(front) = state.pending.front() else {
+            break;
+        };
+        if !state.established && matches!(front.metadata, Metadata::Data(_)) {
+            break;
+        }
+        if pattern.remaining == 0 {
+            pattern.truncated = true;
+            break;
+        }
+        let mut segment = state.pending.pop_front().unwrap();
+        if let Metadata::Data(ref mut meta) = segment.metadata {
+            meta.unack_sequence = state.state.next_receive.load(Ordering::Acquire);
+            meta.window = state.window(partial_available);
+        }
+        send(
+            transport,
+            peer,
+            encoder,
+            username,
+            shared,
+            pattern,
+            segment.metadata,
+            &segment.payload,
+            buffer,
+        )
+        .await?;
+        segment.sent = Some(Instant::now());
+        state.heartbeat = segment.sent.unwrap() + state.heartbeat_interval;
+        segment.tx_count = 1;
+        if saved_timeout {
+            segment.timeout_nanos = state.rtt.retransmit_delay(segment.tx_count).as_nanos() as u64;
+        }
+        if let Metadata::Data(meta) = segment.metadata {
+            state.last_window = meta.window;
+        }
+        if let Some(lease) = &segment.lease {
+            lease.sent();
+        }
+        if state.outstanding.is_empty() {
+            state.first_check = Some(Instant::now() + FIRST_CHECK);
+        }
+        state
+            .outstanding
+            .insert(sequence(segment.metadata), segment);
+        new_sent += 1;
+    }
+    Ok(true)
+}
+fn valid_direction(metadata: Metadata) -> bool {
+    match metadata {
+        Metadata::Data(m) => matches!(m.kind, DataKind::ServerData | DataKind::ServerAck),
+        Metadata::Session(m) => matches!(
+            m.kind,
+            SessionKind::OpenResponse | SessionKind::CloseRequest | SessionKind::CloseResponse
+        ),
+    }
+}
+fn input_command(
+    command: WriterCommand,
+    sessions: &mut BTreeMap<u32, Reliable>,
+    chunk: usize,
+    receive_chunk: usize,
+    allow_piggyback: bool,
+) {
+    if command.state.cancel.is_cancelled() {
+        let _ = command.done.send(Err(closed()));
+        return;
+    }
+    let state = sessions
+        .entry(command.state.id)
+        .or_insert_with(|| Reliable::new(command.state.clone(), receive_chunk));
+    if state.remote_close.is_some() {
+        let _ = command.done.send(Err(closed()));
+    } else {
+        state.enqueue(command, chunk, allow_piggyback);
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn input_packet(
+    packet: Datagram,
+    transport: &mut dyn DatagramTransport,
+    peer: &Destination,
+    budget: DatagramBudget,
+    encoder: &mut PacketEncoder,
+    decoder: &mut PacketDecoder,
+    username: &str,
+    shared: &Shared,
+    pattern: &mut PacketPattern<'_>,
+    sessions: &mut BTreeMap<u32, Reliable>,
+    partial: &mut Option<Partial>,
+    buffer: &mut Vec<u8>,
+    close_retries: &mut CloseRetries,
+) -> io::Result<bool> {
+    if &packet.remote != peer || packet.payload.len() > usize::from(budget.receive()) {
+        return Ok(false);
+    }
+    shared.count_input(packet.payload.len());
+    let frame = match decoder.decode_frame(packet.payload, super::tcp::now()?) {
+        Ok(frame) => frame,
+        Err(_) => return Ok(false),
+    };
+    if !valid_direction(frame.metadata) {
+        return Ok(false);
+    }
+    let id = session_id(frame.metadata);
+    if matches!(frame.metadata, Metadata::Session(meta) if meta.kind == SessionKind::CloseResponse)
+    {
+        close_retries.remove(id); // Only after the original peer/auth/direction checks.
+    }
+    if let Some(state) = sessions.get_mut(&id) {
+        match frame.metadata {
+            Metadata::Session(meta)
+                if matches!(
+                    meta.kind,
+                    SessionKind::CloseRequest | SessionKind::CloseResponse
+                ) =>
+            {
+                state.state.mark_ack_terminal();
+                // Anchor before the original timely response send; never renew.
+                let received_at = Instant::now();
+                if meta.kind == SessionKind::CloseRequest {
+                    let metadata = close_metadata(&state.state, SessionKind::CloseResponse);
+                    send(
+                        transport,
+                        peer,
+                        encoder,
+                        username,
+                        shared,
+                        pattern,
+                        metadata,
+                        &[],
+                        buffer,
+                    )
+                    .await?;
+                }
+                if partial
+                    .as_ref()
+                    .is_some_and(|pending| pending.session_id == id)
+                {
+                    state.remote_close =
+                        Some(state.remote_close.unwrap_or(false) || meta.status != 0);
+                    state.pending.clear();
+                    state.outstanding.clear();
+                    state.reorder.clear();
+                } else if !state.small_budget() {
+                    let first_close = state.remote_close.is_none();
+                    let normal_tcp_request = meta.kind == SessionKind::CloseRequest
+                        && meta.status == 0
+                        && state.state.business == super::tcp::Business::TcpConnect
+                        && state.established
+                        && !state.state.cancel.is_cancelled()
+                        && !state.state.local_closed.load(Ordering::Acquire);
+                    // Keep the original TX gate closed during RX grace.
+                    state.remote_close =
+                        Some(state.remote_close.unwrap_or(false) || meta.status != 0);
+                    state.pending.clear();
+                    state.outstanding.clear();
+                    if first_close
+                        && normal_tcp_request
+                        && meta.sequence > state.state.next_receive.load(Ordering::Acquire)
+                    {
+                        state.close_grace = Some(CloseGrace {
+                            end: meta.sequence,
+                            until: received_at + CLOSE_RECEIVE_GRACE,
+                        });
+                    } else if !normal_tcp_request {
+                        state.close_grace = None;
+                    }
+                    if state.close_grace.is_none() {
+                        state.retain_contiguous_on_close();
+                    }
+                } else {
+                    state.state.finish(meta.status != 0);
+                    sessions.remove(&id);
+                    shared.sessions.lock().unwrap().remove(&id);
+                }
+            }
+            _ => state.input(frame, Instant::now(), partial),
+        }
+    } else if let Metadata::Data(meta) = frame.metadata {
+        let close = Metadata::Session(SessionMetadata {
+            kind: SessionKind::CloseRequest,
+            session_id: id,
+            sequence: meta.unack_sequence,
+            status: 0,
+        });
+        send(
+            transport,
+            peer,
+            encoder,
+            username,
+            shared,
+            pattern,
+            close,
+            &[],
+            buffer,
+        )
+        .await?;
+    }
+    Ok(true)
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn run(
+    transport: &mut dyn DatagramTransport,
+    peer: &Destination,
+    budget: DatagramBudget,
+    encoder: &mut PacketEncoder,
+    decoder: &mut PacketDecoder,
+    username: &str,
+    pattern: &EffectivePattern,
+    shared: &Shared,
+    mut commands: mpsc::Receiver<WriterCommand>,
+) -> io::Result<()> {
+    let chunk =
+        pattern.plaintext_fragment_limit(MieruTransport::Udp, usize::from(budget.transmit()))?;
+    let mut packet_pattern = PacketPattern {
+        pattern,
+        nonce: NonceState::new(),
+        wire_budget: usize::from(budget.transmit()),
+        remaining: OUTPUT_QUANTUM,
+        truncated: false,
+    };
+    let receive_chunk = usize::from(budget.receive())
+        .saturating_sub(DATA_OVERHEAD)
+        .max(1);
+    let mut sessions = BTreeMap::<u32, Reliable>::new();
+    let mut close_retries = CloseRetries::default();
+    let mut partial = None;
+    let mut buffer = Vec::with_capacity(usize::from(budget.transmit()));
+    let mut receive_scratch = Vec::new();
+    // Give application readers a turn before a ready burst consumes their credit.
+    let mut received_since_yield = 0u8;
+    let mut has_output = false;
+    let mut last_output = None;
+    'driver: loop {
+        if sessions.is_empty() && shared.clean() {
+            return Ok(());
+        }
+        // Direct receive requires its first successful physical send.
+        has_output |= packet_pattern.remaining < OUTPUT_QUANTUM;
+        packet_pattern.remaining = OUTPUT_QUANTUM;
+        packet_pattern.truncated = false;
+        if let Some(id) = advance_partial(&mut partial, &mut sessions) {
+            shared.sessions.lock().unwrap().remove(&id);
+        }
+        let now = Instant::now();
+        let mut received = None;
+        tokio::select! {biased;
+            ()=shared.cancel.cancelled()=>return Ok(()),
+            command=commands.recv()=>{let Some(command)=command else{return Ok(());};close_retries.remove(command.state.id);input_command(command,&mut sessions,chunk,receive_chunk,!pattern.low_entropy_enabled());},
+            ()=shared.activity.notified()=>{},
+            ()=async {
+                let deadline = sessions
+                    .values()
+                    .map(|state| state.next_deadline(now))
+                    .min()
+                    .unwrap_or(now + Duration::from_secs(5))
+                    .min(now + Duration::from_secs(5));
+                let deadline = close_retries.deadline().map_or(deadline, |due| deadline.min(due));
+                tokio::time::sleep_until(deadline).await;
+            }=>{},
+            packet=receive_packet(transport, &mut receive_scratch),if has_output=>{received=Some(packet.map_err(|_|closed())?);}
+        }
+        let mut received_in_turn = 0u8;
+        while received_in_turn < RECEIVE_BATCH {
+            if shared.cancel.is_cancelled() {
+                return Ok(());
+            }
+            let selected_receive = received.is_some();
+            let packet = if let Some(packet) = received.take() {
+                packet
+            } else if has_output {
+                // The receive contract permits dropping a pending future. A
+                // ready Datagram owns its complete payload before we borrow TX.
+                let Some(packet) = receive_packet(transport, &mut receive_scratch)
+                    .now_or_never()
+                    .transpose()
+                    .map_err(|_| closed())?
+                else {
+                    break;
+                };
+                packet
+            } else {
+                break;
+            };
+            received_in_turn += 1;
+            received_since_yield += 1;
+            if received_since_yield == RECEIVE_BATCH {
+                received_since_yield = 0;
+                tokio::task::yield_now().await;
+            }
+            if shared.cancel.is_cancelled() {
+                return Ok(());
+            }
+            if !input_packet(
+                packet,
+                transport,
+                peer,
+                budget,
+                encoder,
+                decoder,
+                username,
+                shared,
+                &mut packet_pattern,
+                &mut sessions,
+                &mut partial,
+                &mut buffer,
+                &mut close_retries,
+            )
+            .await?
+            {
+                if selected_receive {
+                    continue 'driver;
+                }
+                // An extra invalid packet must not discard the selected
+                // command or due timer's output turn.
+                continue;
+            }
+        }
+        if let Some(id) = advance_partial(&mut partial, &mut sessions) {
+            shared.sessions.lock().unwrap().remove(&id);
+        }
+        shared.reap_unopened();
+        if shared.clean() {
+            return Ok(());
+        }
+        // One due retry gets one original TX opportunity after authenticated RX.
+        // This intentionally leaves at least seven slots when RX used none.
+        if packet_pattern.remaining != 0
+            && let Some((index, retry)) = close_retries.due(Instant::now())
+        {
+            let id = retry.metadata.session_id;
+            let live =
+                sessions.contains_key(&id) || shared.sessions.lock().unwrap().contains_key(&id);
+            if live {
+                close_retries.remove(id);
+            } else {
+                let result = send(
+                    transport,
+                    peer,
+                    encoder,
+                    username,
+                    shared,
+                    &mut packet_pattern,
+                    Metadata::Session(retry.metadata),
+                    &[],
+                    &mut buffer,
+                )
+                .await;
+                if shared.cancel.is_cancelled() {
+                    return Ok(());
+                }
+                // A failed best-effort retry must not fail healthy sibling SIDs.
+                close_retries.attempted(index, retry, result.is_ok(), Instant::now());
+            }
+        }
+        // Reuse the ID scan with fresh post-await time, before OUTPUT_QUANTUM
+        // can stop the following loop. No new timer task or receive budget.
+        let mut ids: Vec<_> = sessions
+            .iter_mut()
+            .map(|(id, state)| {
+                if state.close_grace.is_some() {
+                    state.converge_close_grace(Instant::now());
+                }
+                *id
+            })
+            .collect();
+        if let Some(last) = last_output {
+            let first = ids.partition_point(|id| *id <= last);
+            ids.rotate_left(first);
+        }
+        for id in ids {
+            if packet_pattern.remaining == 0 {
+                packet_pattern.truncated = true;
+                break;
+            }
+            last_output = Some(id);
+            let state = sessions.get_mut(&id).unwrap();
+            if state.state.cancel.is_cancelled() {
+                let mut retry = None;
+                if state.remote_close.is_none() && state.state.opened.load(Ordering::Acquire) {
+                    let metadata = close_metadata(&state.state, SessionKind::CloseRequest);
+                    send(
+                        transport,
+                        peer,
+                        encoder,
+                        username,
+                        shared,
+                        &mut packet_pattern,
+                        metadata,
+                        &[],
+                        &mut buffer,
+                    )
+                    .await?;
+                    if state.state.business == super::tcp::Business::TcpConnect
+                        && let Metadata::Session(metadata) = metadata
+                    {
+                        retry = Some(metadata);
+                    }
+                }
+                sessions.remove(&id);
+                shared.sessions.lock().unwrap().remove(&id);
+                if let Some(metadata) = retry {
+                    close_retries.insert(metadata, Instant::now());
+                }
+                continue;
+            }
+            // App reads notify this driver. Retry delivery before every window
+            // calculation, including when the window floor would stay unchanged.
+            if !state.small_budget() && state.deliver_contiguous() {
+                state.request_ack(Instant::now());
+            }
+            if let Some(failure) = state.remote_close {
+                if state.close_grace.is_some() {
+                    // App space may have let deliver_contiguous reach the hint.
+                    state.converge_close_grace(Instant::now());
+                }
+                // Only the original accepted app prefix may outlive the grace.
+                if state.close_grace.is_none() && !state.small_budget() && state.reorder.is_empty()
+                {
+                    state.state.finish(failure);
+                    sessions.remove(&id);
+                    shared.sessions.lock().unwrap().remove(&id);
+                }
+                continue;
+            }
+            if state.window(partial.is_none()) != state.last_window {
+                state.request_ack(Instant::now());
+            }
+            if !output(
+                transport,
+                peer,
+                encoder,
+                username,
+                shared,
+                &mut packet_pattern,
+                state,
+                partial.is_none(),
+                &mut buffer,
+            )
+            .await?
+            {
+                state.state.finish(true);
+                let metadata = close_metadata(&state.state, SessionKind::CloseRequest);
+                send(
+                    transport,
+                    peer,
+                    encoder,
+                    username,
+                    shared,
+                    &mut packet_pattern,
+                    metadata,
+                    &[],
+                    &mut buffer,
+                )
+                .await?;
+                sessions.remove(&id);
+                shared.sessions.lock().unwrap().remove(&id);
+            }
+            if packet_pattern.truncated {
+                break;
+            }
+        }
+        if packet_pattern.truncated {
+            shared.activity.notify_one();
+        }
+        // Yield after actual TX budget exhaustion for cooperative task fairness.
+        if packet_pattern.remaining == 0 {
+            tokio::task::yield_now().await;
+        }
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::super::wire::Padding;
+    use super::*;
+    use crate::{
+        dispatch::DispatchError,
+        outbound::OutboundConnector,
+        resources::observation::ResourceProbe,
+        session::{DatagramSession, InboundKind},
+    };
+    use async_trait::async_trait;
+    use std::sync::atomic::AtomicBool;
+    use tokio::{
+        io::{AsyncReadExt, AsyncWriteExt},
+        task::JoinHandle,
+    };
+    use tokio_util::{sync::CancellationToken, task::TaskTracker};
+    include!("udp_upload_shutdown_tests.rs");
+
+    #[derive(Default)]
+    struct ReceiveCalls {
+        polls: AtomicUsize,
+        boxed: AtomicUsize,
+    }
+
+    struct Peer {
+        polled_receive: bool,
+        receive_calls: Arc<ReceiveCalls>,
+        upload: Option<Arc<UploadFixture>>,
+        drop_open: bool,
+        drop_response: bool,
+        response_dropped: AtomicBool,
+        response_transmissions: AtomicUsize,
+        large_response: bool,
+        close_after_response: bool,
+        close_replied: tokio::sync::Notify,
+        stall: bool,
+        tasks: TaskTracker,
+        cancel: CancellationToken,
+        opens: AtomicUsize,
+        nonces: Mutex<Vec<[u8; 24]>>,
+        transmit_limit: u16,
+        received: Mutex<Vec<(u8, usize, usize)>>,
+    }
+    struct Memory {
+        polled_receive: bool,
+        receive_calls: Arc<ReceiveCalls>,
+        input: mpsc::Receiver<Datagram>,
+        output: mpsc::Sender<Datagram>,
+        cancel: CancellationToken,
+        task: Option<JoinHandle<()>>,
+        budget: DatagramBudget,
+        quiet_close: Option<(Arc<UploadFixture>, PacketDecoder)>,
+    }
+    impl Memory {
+        fn quiet_close_input(&self) -> bool {
+            self.quiet_close.as_ref().is_some_and(|(upload, _)| {
+                let sends = upload.physical_close_sends.load(Ordering::Acquire);
+                sends == 1 || (sends != 0 && upload.drop_all_close.load(Ordering::Acquire))
+            })
+        }
+        fn record_quiet_input(&self) {
+            if self.quiet_close_input() {
+                self.quiet_close
+                    .as_ref()
+                    .unwrap()
+                    .0
+                    .input_before_close_retry
+                    .fetch_add(1, Ordering::AcqRel);
+            }
+        }
+    }
+    #[async_trait]
+    impl DatagramTransport for Memory {
+        fn supports_shared_destinations(&self) -> bool {
+            false
+        }
+
+        fn supports_poll_receive(&self) -> bool {
+            self.polled_receive
+        }
+
+        fn poll_receive(
+            &mut self,
+            context: &mut std::task::Context<'_>,
+            _: &mut Vec<u8>,
+        ) -> std::task::Poll<Result<Datagram, DispatchError>> {
+            self.receive_calls.polls.fetch_add(1, Ordering::Relaxed);
+            if self.quiet_close_input() {
+                return std::task::Poll::Pending;
+            }
+            let result = self
+                .input
+                .poll_recv(context)
+                .map(|packet| packet.ok_or(DispatchError::NotAllowed));
+            if matches!(&result, std::task::Poll::Ready(Ok(_))) {
+                self.record_quiet_input();
+            }
+            result
+        }
+
+        fn payload_budget(&self, _: &Destination) -> DatagramBudget {
+            self.budget
+        }
+        async fn send(&mut self, packet: Datagram) -> Result<(), DispatchError> {
+            let close = if let Some((upload, decoder)) = &mut self.quiet_close {
+                let frame = decoder
+                    .decode_frame(
+                        packet.payload.clone(),
+                        super::super::tcp::now().map_err(|_| DispatchError::NotAllowed)?,
+                    )
+                    .map_err(|_| DispatchError::NotAllowed)?;
+                matches!(frame.metadata, Metadata::Session(meta)
+                    if meta.kind == SessionKind::CloseRequest && upload.is_target(meta.session_id))
+            } else {
+                false
+            };
+            self.output
+                .send(packet)
+                .await
+                .map_err(|_| DispatchError::NotAllowed)?;
+            // Count only original transport Ready-OK, never an attempted poll.
+            if close {
+                self.quiet_close
+                    .as_ref()
+                    .unwrap()
+                    .0
+                    .physical_close_sends
+                    .fetch_add(1, Ordering::AcqRel);
+            }
+            Ok(())
+        }
+        async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+            self.receive_calls.boxed.fetch_add(1, Ordering::Relaxed);
+            if self.quiet_close_input() {
+                // Original driver timer/cancel may drop this unconsumed RX future.
+                std::future::pending::<()>().await;
+            }
+            let packet = self.input.recv().await.ok_or(DispatchError::NotAllowed)?;
+            self.record_quiet_input();
+            Ok(packet)
+        }
+        async fn close(&mut self) -> Result<(), DispatchError> {
+            self.cancel.cancel();
+            if let Some(task) = self.task.take() {
+                let _ = task.await;
+            }
+            Ok(())
+        }
+    }
+    impl Drop for Memory {
+        fn drop(&mut self) {
+            self.cancel.cancel();
+            if let Some(task) = self.task.take() {
+                task.abort();
+            }
+        }
+    }
+    impl Peer {
+        fn new(drop_open: bool, stall: bool) -> Arc<Self> {
+            Self::with_response_loss(drop_open, false, stall)
+        }
+        fn with_response_loss(drop_open: bool, drop_response: bool, stall: bool) -> Arc<Self> {
+            Arc::new(Self {
+                polled_receive: false,
+                receive_calls: Arc::default(),
+                upload: None,
+                drop_open,
+                drop_response,
+                response_dropped: AtomicBool::new(false),
+                response_transmissions: AtomicUsize::new(0),
+                large_response: false,
+                close_after_response: false,
+                close_replied: tokio::sync::Notify::new(),
+                stall,
+                tasks: TaskTracker::new(),
+                cancel: CancellationToken::new(),
+                opens: AtomicUsize::new(0),
+                nonces: Mutex::new(Vec::new()),
+                transmit_limit: MTU,
+                received: Mutex::new(Vec::new()),
+            })
+        }
+        async fn stop(&self) {
+            self.cancel.cancel();
+            self.tasks.close();
+            self.tasks.wait().await;
+        }
+    }
+    #[async_trait]
+    impl OutboundConnector for Arc<Peer> {
+        async fn connect_stream(
+            &self,
+            _session: StreamSession,
+            _context: &EstablishContext,
+        ) -> Result<crate::outbound::ConnectedStream, DispatchError> {
+            Err(DispatchError::NotAllowed)
+        }
+        async fn open_datagram(
+            &self,
+            _request: DatagramRequest,
+            _context: &EstablishContext,
+        ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+            let (output, incoming) = mpsc::channel(64);
+            let (outgoing, input) = mpsc::channel(64);
+            if let Some(upload) = &self.upload {
+                upload.physical_opens.fetch_add(1, Ordering::AcqRel);
+                *upload.outgoing.lock().unwrap() = Some(outgoing.clone());
+            }
+            let quiet_close =
+                if let Some(upload) = self.upload.as_ref().filter(|u| u.quiet_close_loss) {
+                    let key = crypto::derive_packet_key(
+                        "vole",
+                        "fixture-password",
+                        super::super::tcp::now().map_err(|_| DispatchError::NotAllowed)?,
+                    );
+                    Some((
+                        upload.clone(),
+                        PacketDecoder::new(&key, false).map_err(|_| DispatchError::NotAllowed)?,
+                    ))
+                } else {
+                    None
+                };
+            let cancel = self.cancel.child_token();
+            let server_cancel = cancel.clone();
+            let peer = self.clone();
+            let task=self.tasks.spawn(observation::task(async move{tokio::select!{()=server_cancel.cancelled()=>{},_=serve(&peer,incoming,outgoing)=>{}}}));
+            Ok(Box::new(Memory {
+                polled_receive: self.polled_receive,
+                receive_calls: self.receive_calls.clone(),
+                input,
+                output,
+                cancel,
+                task: Some(task),
+                budget: DatagramBudget::new(self.transmit_limit, MTU),
+                quiet_close,
+            }))
+        }
+    }
+    struct ServerSession {
+        next: u32,
+        client_next: u32,
+        request: Vec<u8>,
+        ready: bool,
+        pending: BTreeMap<u32, Frame>,
+        peer: Destination,
+        outstanding: BTreeMap<u32, ServerSegment>,
+        rtt: Rtt,
+        ack_due: Option<Instant>,
+    }
+    struct ServerSegment {
+        metadata: Metadata,
+        payload: Bytes,
+        sent: Instant,
+        transmissions: u32,
+    }
+    impl ServerSession {
+        fn acknowledge(&mut self, next_missing: u32, now: Instant) {
+            while self
+                .outstanding
+                .first_key_value()
+                .is_some_and(|(sequence, _)| *sequence < next_missing)
+            {
+                let (_, sent) = self.outstanding.pop_first().unwrap();
+                self.rtt.update(now.saturating_duration_since(sent.sent));
+            }
+        }
+        fn deadline(&self) -> Instant {
+            self.outstanding
+                .values()
+                .map(|segment| segment.sent + self.rtt.retransmit_delay(segment.transmissions))
+                .chain(self.ack_due)
+                .min()
+                .unwrap_or_else(|| Instant::now() + Duration::from_secs(10))
+        }
+    }
+    async fn emit(
+        send: &mpsc::Sender<Datagram>,
+        encoder: &mut PacketEncoder,
+        peer: &Destination,
+        metadata: Metadata,
+        payload: &[u8],
+        duplicate: bool,
+    ) -> io::Result<()> {
+        let mut packet = Vec::new();
+        encoder.encode_frame(
+            metadata,
+            payload,
+            Padding {
+                prefix: &[],
+                suffix: &[],
+            },
+            rand::random(),
+            super::super::tcp::now()?,
+            &mut packet,
+        )?;
+        let datagram = Datagram {
+            remote: peer.clone(),
+            payload: packet.into(),
+            sniffed_domain: None,
+        };
+        if duplicate {
+            let mut wrong = Vec::new();
+            encoder.encode_frame(
+                metadata,
+                b"wrong source",
+                Padding {
+                    prefix: &[],
+                    suffix: &[],
+                },
+                rand::random(),
+                super::super::tcp::now()?,
+                &mut wrong,
+            )?;
+            send.send(Datagram {
+                remote: Destination::Ip("192.0.2.99:2000".parse().unwrap()),
+                payload: wrong.into(),
+                sniffed_domain: None,
+            })
+            .await
+            .map_err(|_| closed())?;
+            send.send(datagram.clone()).await.map_err(|_| closed())?;
+        }
+        send.send(datagram).await.map_err(|_| closed())
+    }
+    async fn emit_server(
+        peer: &Peer,
+        send: &mpsc::Sender<Datagram>,
+        encoder: &mut PacketEncoder,
+        remote: &Destination,
+        metadata: Metadata,
+        payload: &[u8],
+        duplicate: bool,
+    ) -> io::Result<()> {
+        if let Some(upload) = &peer.upload {
+            upload.observe_server(metadata);
+            if upload.withholds(metadata) {
+                return Ok(());
+            }
+        }
+        if matches!(metadata, Metadata::Session(m) if m.kind == SessionKind::OpenResponse) {
+            peer.response_transmissions.fetch_add(1, Ordering::Relaxed);
+        }
+        if peer.drop_response && !peer.response_dropped.swap(true, Ordering::AcqRel) {
+            return Ok(());
+        }
+        emit(send, encoder, remote, metadata, payload, duplicate).await
+    }
+    async fn emit_reliable(
+        peer: &Peer,
+        send: &mpsc::Sender<Datagram>,
+        encoder: &mut PacketEncoder,
+        state: &mut ServerSession,
+        metadata: Metadata,
+        payload: &[u8],
+        duplicate: bool,
+    ) -> io::Result<()> {
+        state.outstanding.insert(
+            sequence(metadata),
+            ServerSegment {
+                metadata,
+                payload: Bytes::copy_from_slice(payload),
+                sent: Instant::now(),
+                transmissions: 1,
+            },
+        );
+        emit_server(
+            peer,
+            send,
+            encoder,
+            &state.peer,
+            metadata,
+            payload,
+            duplicate,
+        )
+        .await
+    }
+    async fn serve(
+        peer: &Peer,
+        mut receive: mpsc::Receiver<Datagram>,
+        send: mpsc::Sender<Datagram>,
+    ) -> io::Result<()> {
+        let key = crypto::derive_packet_key("vole", "fixture-password", super::super::tcp::now()?);
+        let mut decoder = PacketDecoder::new(&key, false)?;
+        let mut header_cipher = crypto::PacketCipher::new(&key, false)?;
+        let mut encoder = PacketEncoder::new(&key, false)?;
+        let mut sessions = BTreeMap::<u32, ServerSession>::new();
+        let mut dropped = false;
+        loop {
+            let deadline = sessions
+                .values()
+                .map(ServerSession::deadline)
+                .min()
+                .unwrap_or_else(|| Instant::now() + Duration::from_secs(10));
+            let packet = tokio::select! {
+                packet = receive.recv() => {
+                    let Some(packet) = packet else { return Ok(()); };
+                    packet
+                },
+                () = tokio::time::sleep_until(deadline) => {
+                    let now = Instant::now();
+                    for (&id, state) in &mut sessions {
+                        // Reference output ordering: due retransmissions, then
+                        // independent cumulative ACKs. Re-encode every retry.
+                        for segment in state.outstanding.values_mut() {
+                            if now < segment.sent + state.rtt.retransmit_delay(segment.transmissions) {
+                                continue;
+                            }
+                            assert!(segment.transmissions < 20);
+                            if let Metadata::Data(ref mut metadata) = segment.metadata {
+                                metadata.unack_sequence = state.client_next;
+                            }
+                            emit_server(peer, &send, &mut encoder, &state.peer, segment.metadata, &segment.payload, false).await?;
+                            segment.sent = Instant::now();
+                            segment.transmissions += 1;
+                        }
+                        if state.ack_due.is_some_and(|due| now >= due) {
+                            emit_server(peer, &send, &mut encoder, &state.peer, Metadata::Data(DataMetadata {
+                                kind: DataKind::ServerAck,
+                                session_id: id,
+                                sequence: state.next.saturating_sub(1),
+                                unack_sequence: state.client_next,
+                                window: 64,
+                                fragment: 0,
+                            }), &[], false).await?;
+                            state.ack_due = None;
+                        }
+                    }
+                    continue;
+                }
+            };
+            let mut nonce = [0; 24];
+            nonce.copy_from_slice(&packet.payload[..24]);
+            peer.nonces.lock().unwrap().push(nonce);
+            let wire_len = packet.payload.len();
+            let mut header = packet.payload[24..56].to_vec();
+            let mut tag = [0; 16];
+            tag.copy_from_slice(&packet.payload[56..72]);
+            header_cipher.open(nonce, &mut header, tag)?;
+            let frame = decoder.decode_frame(packet.payload, super::super::tcp::now()?)?;
+            peer.received
+                .lock()
+                .unwrap()
+                .push((header[0], wire_len, frame.payload.len()));
+            let id = session_id(frame.metadata);
+            if matches!(frame.metadata,Metadata::Session(m) if m.kind==SessionKind::CloseResponse) {
+                peer.close_replied.notify_one();
+                if let Some(upload) = &peer.upload {
+                    upload.close_origin(id).await;
+                }
+                sessions.remove(&id);
+                continue;
+            }
+            if matches!(frame.metadata,Metadata::Session(m) if m.kind==SessionKind::OpenRequest) {
+                if let Some(upload) = &peer.upload {
+                    upload.select(id, &packet.remote);
+                }
+                peer.opens.fetch_add(1, Ordering::Relaxed);
+                if peer.stall {
+                    continue;
+                }
+                if peer.drop_open && !dropped {
+                    dropped = true;
+                    continue;
+                }
+                if !sessions.contains_key(&id) {
+                    sessions.insert(
+                        id,
+                        ServerSession {
+                            next: 1,
+                            client_next: 0,
+                            request: Vec::new(),
+                            ready: false,
+                            pending: BTreeMap::new(),
+                            peer: packet.remote.clone(),
+                            outstanding: BTreeMap::new(),
+                            rtt: Rtt::new(),
+                            ack_due: None,
+                        },
+                    );
+                    emit_reliable(
+                        peer,
+                        &send,
+                        &mut encoder,
+                        sessions.get_mut(&id).unwrap(),
+                        Metadata::Session(SessionMetadata {
+                            kind: SessionKind::OpenResponse,
+                            session_id: id,
+                            sequence: 0,
+                            status: 0,
+                        }),
+                        &[],
+                        false,
+                    )
+                    .await?;
+                }
+            }
+            let Some(state) = sessions.get_mut(&id) else {
+                continue;
+            };
+            if let Some(upload) = &peer.upload
+                && upload.drop_or_observe(id, &frame, state.ready)
+            {
+                continue;
+            }
+            if let Metadata::Data(metadata) = frame.metadata {
+                state.acknowledge(metadata.unack_sequence, Instant::now());
+            }
+            if let Metadata::Session(m) = frame.metadata {
+                if m.kind == SessionKind::CloseRequest {
+                    emit(
+                        &send,
+                        &mut encoder,
+                        &packet.remote,
+                        Metadata::Session(SessionMetadata {
+                            kind: SessionKind::CloseResponse,
+                            session_id: id,
+                            sequence: state.next,
+                            status: 0,
+                        }),
+                        &[],
+                        false,
+                    )
+                    .await?;
+                    if let Some(upload) = &peer.upload {
+                        upload.close_origin(id).await;
+                    }
+                    sessions.remove(&id);
+                    continue;
+                }
+            }
+            if matches!(frame.metadata,Metadata::Data(m) if m.kind==DataKind::ClientAck) {
+                continue;
+            }
+            let seq = sequence(frame.metadata);
+            if seq >= state.client_next {
+                state.pending.entry(seq).or_insert(frame);
+            }
+            let mut body = Vec::new();
+            while let Some(frame) = state.pending.remove(&state.client_next) {
+                state.client_next += 1;
+                body.extend_from_slice(&frame.payload);
+            }
+            let due = Instant::now() + Duration::from_millis(1);
+            state.ack_due = Some(state.ack_due.map_or(due, |previous| previous.min(due)));
+            if body.is_empty() {
+                continue;
+            }
+            if !state.ready {
+                state.request.extend_from_slice(&body);
+                if state.request.len() < 10 {
+                    continue;
+                }
+                let command = state.request[1];
+                assert!(command == 1 || command == 3);
+                let mut address = &state.request[3..];
+                crate::socks5::read_destination(&mut address, true).await?;
+                let header = state.request.len() - address.len();
+                body = state.request.split_off(header);
+                state.ready = true;
+                let mut reply = vec![5, 0, 0, 1, 0, 0, 0, 0, 0, 0];
+                let metadata = Metadata::Data(DataMetadata {
+                    kind: DataKind::ServerData,
+                    session_id: id,
+                    sequence: state.next,
+                    unack_sequence: state.client_next,
+                    window: 64,
+                    fragment: 0,
+                });
+                state.next += 1;
+                if peer.large_response {
+                    reply.extend_from_slice(&[0x91; 128]);
+                    if !peer.close_after_response {
+                        let future = Metadata::Data(DataMetadata {
+                            kind: DataKind::ServerData,
+                            session_id: id,
+                            sequence: state.next,
+                            unack_sequence: state.client_next,
+                            window: 64,
+                            fragment: 0,
+                        });
+                        state.next += 1;
+                        // A future small frame must not steal all credit from the
+                        // preceding frame, which is larger than the app queue.
+                        emit_reliable(peer, &send, &mut encoder, state, future, &[0x92; 4], false)
+                            .await?;
+                    }
+                }
+                emit_reliable(
+                    peer,
+                    &send,
+                    &mut encoder,
+                    state,
+                    metadata,
+                    &reply,
+                    peer.large_response && !peer.close_after_response,
+                )
+                .await?;
+                if peer.close_after_response {
+                    emit(
+                        &send,
+                        &mut encoder,
+                        &packet.remote,
+                        Metadata::Session(SessionMetadata {
+                            kind: SessionKind::CloseRequest,
+                            session_id: id,
+                            sequence: state.next,
+                            status: 0,
+                        }),
+                        &[],
+                        false,
+                    )
+                    .await?;
+                    sessions.remove(&id);
+                    continue;
+                }
+            }
+            if !body.is_empty() {
+                if let Some(upload) = &peer.upload
+                    && upload.is_target(id)
+                {
+                    upload.write_origin(&body).await?;
+                    continue;
+                }
+                let parts: Vec<_> = body.chunks(1000).collect();
+                let mut frames = Vec::new();
+                for part in parts {
+                    let meta = Metadata::Data(DataMetadata {
+                        kind: DataKind::ServerData,
+                        session_id: id,
+                        sequence: state.next,
+                        unack_sequence: state.client_next,
+                        window: 64,
+                        fragment: 0,
+                    });
+                    state.next += 1;
+                    frames.push((meta, part));
+                }
+                for (meta, part) in frames.into_iter().rev() {
+                    emit_reliable(peer, &send, &mut encoder, state, meta, part, true).await?;
+                }
+            }
+        }
+    }
+    fn config() -> MieruOutboundConfig {
+        let mut c = super::super::tests::config(crate::config::MieruHandshake::NoWait);
+        c.address = "127.0.0.1".into();
+        c.transport = crate::config::MieruTransport::Udp;
+        c
+    }
+    #[tokio::test]
+    async fn mieru_udp_physical_poll_and_fallback_keep_reliability_and_stop() {
+        const PAYLOAD: &[u8] = b"physical carrier roundtrip";
+        for polled in [false, true] {
+            let probe = ResourceProbe::default();
+            let (result, calls, loss) = probe
+                .scope(async {
+                    let mut peer = Peer::with_response_loss(true, true, false);
+                    Arc::get_mut(&mut peer).unwrap().polled_receive = polled;
+                    let calls = peer.receive_calls.clone();
+                    let mut configuration = config();
+                    configuration.handshake_mode = crate::config::MieruHandshake::Standard;
+                    let node = super::super::MieruOutbound::new(
+                        &configuration,
+                        UpstreamPath::proxy(Arc::new(peer.clone())),
+                        32768,
+                    )
+                    .unwrap();
+                    let result = tokio::time::timeout(Duration::from_secs(10), async {
+                        let context = EstablishContext::with_timeout(Duration::from_secs(10));
+                        let mut stream = node
+                            .connect_stream(super::super::tests::session(), &context)
+                            .await
+                            .map_err(|_| closed())?
+                            .io;
+                        stream.write_all(PAYLOAD).await?;
+                        let mut echoed = [0; PAYLOAD.len()];
+                        stream.read_exact(&mut echoed).await?;
+                        Ok::<_, io::Error>(echoed)
+                    })
+                    .await;
+                    node.shutdown().await;
+                    drop(node);
+                    peer.stop().await;
+                    let loss = (
+                        peer.opens.load(Ordering::Acquire),
+                        peer.response_dropped.load(Ordering::Acquire),
+                        peer.response_transmissions.load(Ordering::Acquire),
+                    );
+                    (result, calls, loss)
+                })
+                .await;
+            // Validate business progress and joined ownership before path selection.
+            assert!(probe.snapshot().is_idle());
+            assert_eq!(
+                result
+                    .expect("memory physical carrier timed out")
+                    .expect("memory physical carrier failed"),
+                PAYLOAD
+            );
+            assert!(loss.0 >= 2, "first OPEN was not retried");
+            assert!(loss.1, "first response was not dropped");
+            assert!(loss.2 >= 2, "first response was not retried");
+            let polls = calls.polls.load(Ordering::Relaxed);
+            let boxed = calls.boxed.load(Ordering::Relaxed);
+            if polled {
+                assert!(polls > 0, "polled physical carrier was never polled");
+                assert_eq!(boxed, 0, "polled carrier used boxed async receive");
+            } else {
+                assert_eq!(polls, 0, "fallback unexpectedly used optional poll");
+                assert!(boxed > 0, "fallback never used its async receive");
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn mieru_udp_pattern_consumes_nonce_low_entropy_and_actual_path_budget() {
+        // Independently encoded MODE32 pattern with no padding/control
+        // fragmentation; fixed nonce prefix applies to every UDP attempt.
+        const PATTERN: &str = "CAAaBAgAEAAiEAgDEAEYACAAKgZhYWJiY2MqBAgAEAAyBAgBEAA=";
+        let probe = ResourceProbe::default();
+        probe
+            .scope(async {
+                let mut peer = Peer::new(true, false);
+                Arc::get_mut(&mut peer).unwrap().transmit_limit = 128;
+                let mut configuration = config();
+                configuration.traffic_pattern = Some(PATTERN.into());
+                let node = super::super::MieruOutbound::new(
+                    &configuration,
+                    UpstreamPath::proxy(Arc::new(peer.clone())),
+                    4096,
+                )
+                .unwrap();
+                let context = EstablishContext::with_timeout(Duration::from_secs(5));
+                let mut stream = node
+                    .connect_stream(super::super::tests::session(), &context)
+                    .await
+                    .unwrap()
+                    .io;
+                super::super::tests::echo(&mut stream, &vec![0x69; 400]).await;
+                assert!(
+                    peer.opens.load(Ordering::Acquire) >= 2,
+                    "OPEN loss was not retried"
+                );
+                {
+                    let received = peer.received.lock().unwrap();
+                    assert!(received.iter().all(|(_, wire_len, _)| *wire_len <= 128));
+                    let data: Vec<_> = received
+                        .iter()
+                        .filter(|(protocol, _, _)| *protocol == 10)
+                        .collect();
+                    assert!(!data.is_empty(), "production DATA did not use low entropy");
+                    assert!(data.iter().all(|(_, _, payload_len)| *payload_len <= 20));
+                    assert!(
+                        received
+                            .iter()
+                            .filter(|(protocol, _, _)| *protocol == 2)
+                            .all(|(_, _, size)| *size == 0)
+                    );
+                    let nonces = peer.nonces.lock().unwrap();
+                    assert!(nonces.iter().all(|nonce| nonce[..3] == [0xaa, 0xbb, 0xcc]));
+                    assert!(nonces.iter().all(|nonce| {
+                        nonce[20..] == crypto::make_client_nonce("vole", *nonce)[20..]
+                    }));
+                    assert!(nonces.windows(2).all(|pair| pair[0] != pair[1]));
+                }
+                drop(stream);
+                node.shutdown().await;
+                drop(node);
+                peer.stop().await;
+            })
+            .await;
+        assert!(probe.snapshot().is_idle());
+    }
+    #[tokio::test]
+    async fn mieru_udp_remote_close_preserves_small_budget_partial_frame() {
+        let probe = ResourceProbe::default();
+        probe
+            .scope(async {
+                let mut peer = Peer::new(false, false);
+                let fixture = Arc::get_mut(&mut peer).unwrap();
+                fixture.large_response = true;
+                fixture.close_after_response = true;
+                let mut configuration = config();
+                configuration.handshake_mode = crate::config::MieruHandshake::Standard;
+                configuration.multiplexing = crate::config::MieruMultiplexing::Off;
+                let node = super::super::MieruOutbound::new(
+                    &configuration,
+                    UpstreamPath::proxy(Arc::new(peer.clone())),
+                    8,
+                )
+                .unwrap();
+                let result: io::Result<crate::dispatch::BoxStream> = async {
+                    let context = EstablishContext::with_timeout(Duration::from_secs(5));
+                    let mut stream = node
+                        .connect_stream(super::super::tests::session(), &context)
+                        .await
+                        .map_err(io::Error::other)?
+                        .io;
+                    // This response witnesses that remote Close was consumed
+                    // before the app releases credit for the remaining DATA.
+                    tokio::time::timeout(Duration::from_secs(1), peer.close_replied.notified())
+                        .await
+                        .map_err(|_| io::ErrorKind::TimedOut)?;
+                    let mut got = [0; 128];
+                    tokio::time::timeout(Duration::from_secs(3), stream.read_exact(&mut got))
+                        .await
+                        .map_err(|_| io::ErrorKind::TimedOut)??;
+                    assert_eq!(got, [0x91; 128]);
+                    let mut last = [0];
+                    let count =
+                        tokio::time::timeout(Duration::from_secs(1), stream.read(&mut last))
+                            .await
+                            .map_err(|_| io::ErrorKind::TimedOut)??;
+                    assert_eq!(count, 0, "remote close did not finish after DATA");
+                    drop(stream);
+                    let context = EstablishContext::with_timeout(Duration::from_secs(5));
+                    let stream = node
+                        .connect_stream(super::super::tests::session(), &context)
+                        .await
+                        .map_err(io::Error::other)?
+                        .io;
+                    tokio::time::timeout(Duration::from_secs(1), peer.close_replied.notified())
+                        .await
+                        .map_err(|_| io::ErrorKind::TimedOut)?;
+                    // Keep a remotely closed partial frame unread. Node Stop
+                    // must still cancel and join without waiting for byte credit.
+                    Ok(stream)
+                }
+                .await;
+                let failure = result.as_ref().err().map(ToString::to_string);
+                tokio::time::timeout(Duration::from_secs(2), node.shutdown())
+                    .await
+                    .unwrap();
+                drop(result);
+                drop(node);
+                peer.stop().await;
+                assert!(
+                    failure.is_none(),
+                    "remote Close lost DATA tail: {failure:?}"
+                );
+            })
+            .await;
+        assert!(probe.snapshot().is_idle());
+    }
+    #[tokio::test]
+    async fn mieru_udp_small_byte_budget_delivers_large_reordered_frames_and_stops() {
+        let probe = ResourceProbe::default();
+        probe
+            .scope(async {
+                let mut peer = Peer::new(false, false);
+                Arc::get_mut(&mut peer).unwrap().large_response = true;
+                let mut configuration = config();
+                configuration.handshake_mode = crate::config::MieruHandshake::Standard;
+                configuration.multiplexing = crate::config::MieruMultiplexing::Off;
+                let node = super::super::MieruOutbound::new(
+                    &configuration,
+                    UpstreamPath::proxy(Arc::new(peer.clone())),
+                    8,
+                )
+                .unwrap();
+                let result: io::Result<crate::dispatch::BoxStream> = async {
+                    let context = EstablishContext::with_timeout(Duration::from_secs(5));
+                    let mut stream = node
+                        .connect_stream(super::super::tests::session(), &context)
+                        .await
+                        .map_err(io::Error::other)?
+                        .io;
+                    let mut expected = vec![0x91; 128];
+                    expected.extend_from_slice(&[0x92; 4]);
+                    let mut got = vec![0; expected.len()];
+                    tokio::time::timeout(Duration::from_secs(3), stream.read_exact(&mut got))
+                        .await
+                        .map_err(|_| io::ErrorKind::TimedOut)??;
+                    if got != expected {
+                        return Err(io::Error::other(
+                            "small-budget frame was reordered or duplicated",
+                        ));
+                    }
+                    let data = b"small-budget roundtrip";
+                    stream.write_all(data).await?;
+                    let mut echo = vec![0; data.len()];
+                    tokio::time::timeout(Duration::from_secs(3), stream.read_exact(&mut echo))
+                        .await
+                        .map_err(|_| io::ErrorKind::TimedOut)??;
+                    if echo != data {
+                        return Err(io::Error::other("small-budget business bytes changed"));
+                    }
+                    drop(stream);
+                    let context = EstablishContext::with_timeout(Duration::from_secs(5));
+                    // Leave the server-first frame partially unread so Stop must
+                    // release both queued byte permits and the physical frame slot.
+                    Ok(node
+                        .connect_stream(super::super::tests::session(), &context)
+                        .await
+                        .map_err(io::Error::other)?
+                        .io)
+                }
+                .await;
+                let failure = result.as_ref().err().map(ToString::to_string);
+                tokio::time::timeout(Duration::from_secs(2), node.shutdown())
+                    .await
+                    .unwrap();
+                drop(result);
+                drop(node);
+                peer.stop().await;
+                assert!(
+                    failure.is_none(),
+                    "capacity 8 UDP stream failed: {failure:?}"
+                );
+            })
+            .await;
+        assert!(probe.snapshot().is_idle());
+    }
+    #[test]
+    fn mieru_udp_reorder_gap_keeps_receive_credit() {
+        const CHUNK: usize = 32;
+        const CAPACITY: usize = 3 * CHUNK;
+        let cancellation = CancellationToken::new();
+        let state = State::new(
+            1,
+            CAPACITY,
+            &cancellation,
+            Arc::new(tokio::sync::Notify::new()),
+        );
+        let mut reliable = Reliable::new(state.clone(), CHUNK);
+        let mut partial = None;
+        reliable.input(
+            Frame {
+                metadata: Metadata::Session(SessionMetadata {
+                    kind: SessionKind::OpenResponse,
+                    session_id: 1,
+                    sequence: 0,
+                    status: 0,
+                }),
+                payload: Bytes::new(),
+            },
+            Instant::now(),
+            &mut partial,
+        );
+        let frame = |sequence: u32| Frame {
+            metadata: Metadata::Data(DataMetadata {
+                kind: DataKind::ServerData,
+                session_id: 1,
+                sequence,
+                unack_sequence: 0,
+                window: 16,
+                fragment: 0,
+            }),
+            payload: Bytes::from(vec![sequence as u8; CHUNK]),
+        };
+        assert!(!reliable.small_budget());
+        assert_eq!(reliable.window(true), 3);
+        // A missing seq1 followed by a burst of future DATA must not consume
+        // the credit seq1 needs to unblock the actual receive queue.
+        for sequence in 2..=4 {
+            reliable.input(frame(sequence), Instant::now(), &mut partial);
+        }
+        assert_eq!(state.next_receive.load(Ordering::Acquire), 1);
+        assert_eq!(reliable.reorder_bytes.available_permits(), CHUNK);
+        assert_eq!(reliable.window(true), 0);
+        reliable.input(frame(1), Instant::now(), &mut partial);
+        assert_eq!(
+            state.next_receive.load(Ordering::Acquire),
+            4,
+            "future DATA exhausted the missing segment's receive credit"
+        );
+        assert_eq!(reliable.window(true), 3);
+        let waker = futures_util::task::noop_waker();
+        let mut context = std::task::Context::from_waker(&waker);
+        for sequence in 1..=3 {
+            let mut bytes = [0; CHUNK];
+            let mut read = tokio::io::ReadBuf::new(&mut bytes);
+            assert!(matches!(
+                state.poll_read(&mut context, &mut read),
+                std::task::Poll::Ready(Ok(()))
+            ));
+            assert_eq!(read.filled(), &[sequence; CHUNK]);
+        }
+        assert_eq!(state.receive_bytes.available_permits(), CAPACITY);
+        // The future seq4 may be dropped to keep the missing-segment credit.
+        // Its real retransmission succeeds once application reads free bytes.
+        reliable.input(frame(4), Instant::now(), &mut partial);
+        let mut bytes = [0; CHUNK];
+        let mut read = tokio::io::ReadBuf::new(&mut bytes);
+        assert!(matches!(
+            state.poll_read(&mut context, &mut read),
+            std::task::Poll::Ready(Ok(()))
+        ));
+        assert_eq!(read.filled(), &[4; CHUNK]);
+        assert_eq!(state.next_receive.load(Ordering::Acquire), 5);
+        assert!(reliable.reorder.is_empty());
+        assert!(partial.is_none());
+        assert_eq!(state.receive_bytes.available_permits(), CAPACITY);
+        state.close();
+    }
+
+    #[test]
+    fn mieru_udp_hidden_reorder_slack_preserves_original_credit_and_all_data() {
+        const CAPACITY: usize = 32768;
+        const CHUNK: usize = 1312;
+        let cancellation = CancellationToken::new();
+        let state = State::new(
+            1,
+            CAPACITY,
+            &cancellation,
+            Arc::new(tokio::sync::Notify::new()),
+        );
+        let mut reliable = Reliable::new(state.clone(), CHUNK);
+        let mut partial = None;
+        reliable.input(
+            Frame {
+                metadata: Metadata::Session(SessionMetadata {
+                    kind: SessionKind::OpenResponse,
+                    session_id: 1,
+                    sequence: 0,
+                    status: 0,
+                }),
+                payload: Bytes::new(),
+            },
+            Instant::now(),
+            &mut partial,
+        );
+        let frame = |sequence: u32| Frame {
+            metadata: Metadata::Data(DataMetadata {
+                kind: DataKind::ServerData,
+                session_id: 1,
+                sequence,
+                unack_sequence: 0,
+                window: 16,
+                fragment: 0,
+            }),
+            payload: Bytes::from(vec![sequence as u8; CHUNK]),
+        };
+        assert_eq!(reliable.window(true), 24);
+        // 40 future frames retain 52,480 payload bytes: beyond original
+        // credit, but below the bounded original + 32KiB reorder capacity.
+        for sequence in 2..=41 {
+            reliable.input(frame(sequence), Instant::now(), &mut partial);
+        }
+        assert_eq!(state.next_receive.load(Ordering::Acquire), 1);
+        assert_eq!(state.unread_bytes(), 0);
+        assert_eq!(state.receive_bytes.available_permits(), CAPACITY);
+        assert_eq!(
+            reliable.window(true),
+            0,
+            "hidden slack enlarged wire credit"
+        );
+        reliable.input(frame(1), Instant::now(), &mut partial);
+
+        let waker = futures_util::task::noop_waker();
+        let mut context = std::task::Context::from_waker(&waker);
+        for sequence in 1..=41 {
+            let mut bytes = [0; CHUNK];
+            let mut read = tokio::io::ReadBuf::new(&mut bytes);
+            assert!(
+                matches!(
+                    state.poll_read(&mut context, &mut read),
+                    std::task::Poll::Ready(Ok(()))
+                ),
+                "future frame {sequence} was not retained through the hole"
+            );
+            assert_eq!(read.filled(), &[sequence as u8; CHUNK]);
+            // This is the driver's original app-read recovery seam, not a
+            // second implementation of queue transfer or window arithmetic.
+            reliable.deliver_contiguous();
+            assert!(
+                reliable.window(true) <= 24,
+                "hidden slack enlarged wire credit"
+            );
+        }
+        assert_eq!(state.next_receive.load(Ordering::Acquire), 42);
+        assert!(reliable.reorder.is_empty());
+        assert!(partial.is_none());
+        assert_eq!(state.unread_bytes(), 0);
+        assert_eq!(state.receive_bytes.available_permits(), CAPACITY);
+        assert_eq!(reliable.reorder_bytes.available_permits(), CAPACITY + 32768);
+        assert_eq!(reliable.window(true), 24);
+        let mut bytes = [0; 1];
+        let mut read = tokio::io::ReadBuf::new(&mut bytes);
+        assert!(matches!(
+            state.poll_read(&mut context, &mut read),
+            std::task::Poll::Pending
+        ));
+        state.close();
+    }
+
+    #[test]
+    fn mieru_udp_associate_keeps_original_receive_budget() {
+        const CAPACITY: usize = 32768;
+        const CHUNK: usize = 1312;
+        let cancel = CancellationToken::new();
+        let state = State::new_for_business(
+            1,
+            CAPACITY,
+            super::super::tcp::Business::UdpAssociate,
+            &cancel,
+            Arc::new(tokio::sync::Notify::new()),
+        );
+        let mut reliable = Reliable::new(state.clone(), CHUNK);
+        assert_eq!(
+            state.business.command(),
+            crate::socks5::COMMAND_UDP_ASSOCIATE
+        );
+        assert_eq!(state.receive_bytes.available_permits(), CAPACITY);
+        assert_eq!(reliable.reorder_bytes.available_permits(), CAPACITY);
+        let mut partial = None;
+        reliable.input(
+            Frame {
+                metadata: Metadata::Session(SessionMetadata {
+                    kind: SessionKind::OpenResponse,
+                    session_id: 1,
+                    sequence: 0,
+                    status: 0,
+                }),
+                payload: Bytes::new(),
+            },
+            Instant::now(),
+            &mut partial,
+        );
+        let frame = |sequence: u32| Frame {
+            metadata: Metadata::Data(DataMetadata {
+                kind: DataKind::ServerData,
+                session_id: 1,
+                sequence,
+                unack_sequence: 0,
+                window: 16,
+                fragment: 0,
+            }),
+            payload: Bytes::from(vec![sequence as u8; CHUNK]),
+        };
+        assert_eq!(reliable.window(true), 24);
+        for sequence in 2..=41 {
+            reliable.input(frame(sequence), Instant::now(), &mut partial);
+        }
+        assert_eq!(state.unread_bytes(), 0);
+        assert_eq!(reliable.window(true), 0);
+        reliable.input(frame(1), Instant::now(), &mut partial);
+        let waker = futures_util::task::noop_waker();
+        let mut cx = std::task::Context::from_waker(&waker);
+        for sequence in 1..=41 {
+            // Beyond the original retention budget, peer DATA is retried.
+            if sequence >= 25 {
+                reliable.input(frame(sequence), Instant::now(), &mut partial);
+            }
+            let mut bytes = [0; CHUNK];
+            let mut read = tokio::io::ReadBuf::new(&mut bytes);
+            assert!(matches!(
+                state.poll_read(&mut cx, &mut read),
+                std::task::Poll::Ready(Ok(()))
+            ));
+            assert_eq!(read.filled(), &[sequence as u8; CHUNK]);
+            reliable.deliver_contiguous();
+            assert!(reliable.window(true) <= 24);
+        }
+        assert_eq!(state.next_receive.load(Ordering::Acquire), 42);
+        assert!(reliable.reorder.is_empty());
+        assert_eq!(state.unread_bytes(), 0);
+        assert_eq!(state.receive_bytes.available_permits(), CAPACITY);
+        assert_eq!(reliable.reorder_bytes.available_permits(), CAPACITY);
+        state.close();
+
+        let connect = State::new_for_business(
+            2,
+            CAPACITY,
+            super::super::tcp::Business::TcpConnect,
+            &cancel,
+            Arc::new(tokio::sync::Notify::new()),
+        );
+        let reliable = Reliable::new(connect.clone(), CHUNK);
+        assert_eq!(reliable.reorder_bytes.available_permits(), 2 * CAPACITY);
+        assert_eq!(connect.receive_bytes.available_permits(), CAPACITY);
+        assert_eq!(reliable.window(true), 24);
+        connect.close();
+    }
+
+    #[test]
+    fn mieru_udp_partial_slot_keeps_byte_credit_and_control_live() {
+        let cancellation = CancellationToken::new();
+        let state = State::new(1, 8, &cancellation, Arc::new(tokio::sync::Notify::new()));
+        let mut sessions = BTreeMap::from([(1, Reliable::new(state.clone(), 1312))]);
+        let mut partial = None;
+        let data = |sequence, payload: Bytes| Frame {
+            metadata: Metadata::Data(DataMetadata {
+                kind: DataKind::ServerData,
+                session_id: 1,
+                sequence,
+                unack_sequence: 0,
+                window: 64,
+                fragment: 0,
+            }),
+            payload,
+        };
+        assert_eq!(sessions[&1].window(true), 1);
+        sessions.get_mut(&1).unwrap().input(
+            data(1, Bytes::from_static(b"late")),
+            Instant::now(),
+            &mut partial,
+        );
+        assert_eq!(state.receive_bytes.available_permits(), 8);
+        assert!(sessions[&1].reorder.is_empty());
+        let expected = b"abcdefghijklmnopqrstuvwxyz12";
+        let mut allocation = vec![0; 8192];
+        allocation[1024..1024 + expected.len()].copy_from_slice(expected);
+        let large = Bytes::from(allocation).slice(1024..1024 + expected.len());
+        let original = large.as_ptr();
+        sessions
+            .get_mut(&1)
+            .unwrap()
+            .input(data(0, large), Instant::now(), &mut partial);
+        assert_ne!(partial.as_ref().unwrap().payload.as_ptr(), original);
+        let _ = advance_partial(&mut partial, &mut sessions);
+        assert_eq!(state.receive_bytes.available_permits(), 0);
+        assert_eq!(state.next_receive.load(Ordering::Acquire), 0);
+        assert_eq!(sessions[&1].window(false), 0);
+        sessions.get_mut(&1).unwrap().input(
+            data(0, Bytes::copy_from_slice(expected)),
+            Instant::now(),
+            &mut partial,
+        );
+        assert_eq!(partial.as_ref().unwrap().offset, 8);
+        sessions.get_mut(&1).unwrap().input(
+            Frame {
+                metadata: Metadata::Session(SessionMetadata {
+                    kind: SessionKind::OpenResponse,
+                    session_id: 1,
+                    sequence: 1,
+                    status: 0,
+                }),
+                payload: Bytes::new(),
+            },
+            Instant::now(),
+            &mut partial,
+        );
+        sessions.get_mut(&1).unwrap().input(
+            Frame {
+                metadata: Metadata::Data(DataMetadata {
+                    kind: DataKind::ServerAck,
+                    session_id: 1,
+                    sequence: 1,
+                    unack_sequence: 0,
+                    window: 77,
+                    fragment: 0,
+                }),
+                payload: Bytes::new(),
+            },
+            Instant::now(),
+            &mut partial,
+        );
+        assert!(sessions[&1].established);
+        assert_eq!(sessions[&1].remote_window, 77);
+        let waker = futures_util::task::noop_waker();
+        let mut context = std::task::Context::from_waker(&waker);
+        let mut got = Vec::new();
+        loop {
+            let mut bytes = [0; 8];
+            let mut buffer = tokio::io::ReadBuf::new(&mut bytes);
+            assert!(matches!(
+                state.poll_read(&mut context, &mut buffer),
+                std::task::Poll::Ready(Ok(()))
+            ));
+            got.extend_from_slice(buffer.filled());
+            assert_eq!(state.receive_bytes.available_permits(), 8);
+            if partial.is_none() {
+                break;
+            }
+            let _ = advance_partial(&mut partial, &mut sessions);
+        }
+        assert_eq!(got, expected);
+        assert_eq!(state.next_receive.load(Ordering::Acquire), 2);
+        sessions.get_mut(&1).unwrap().input(
+            data(2, Bytes::copy_from_slice(expected)),
+            Instant::now(),
+            &mut partial,
+        );
+        let _ = advance_partial(&mut partial, &mut sessions);
+        state.close();
+        let _ = advance_partial(&mut partial, &mut sessions);
+        assert!(partial.is_none());
+        assert_eq!(state.receive_bytes.available_permits(), 8);
+    }
+    #[tokio::test]
+    async fn mieru_udp_standard_recovers_first_packet_loss_in_both_directions() {
+        let probe = ResourceProbe::default();
+        probe
+            .scope(async {
+                let peer = Peer::with_response_loss(true, true, false);
+                let mut configuration = config();
+                configuration.handshake_mode = crate::config::MieruHandshake::Standard;
+                let node = super::super::MieruOutbound::new(
+                    &configuration,
+                    UpstreamPath::proxy(Arc::new(peer.clone())),
+                    32768,
+                )
+                .unwrap();
+                let context = EstablishContext::with_timeout(Duration::from_secs(10));
+                let result = node
+                    .connect_stream(super::super::tests::session(), &context)
+                    .await;
+                assert!(
+                    peer.opens.load(Ordering::Relaxed) >= 2,
+                    "client first OPEN was not retried"
+                );
+                assert!(
+                    peer.response_dropped.load(Ordering::Acquire),
+                    "server first response was not dropped"
+                );
+                assert!(
+                    peer.response_transmissions.load(Ordering::Relaxed) >= 2,
+                    "server OPEN response was not retried"
+                );
+                let mut stream = result
+                    .expect("STANDARD SOCKS handshake failed under one loss per direction")
+                    .io;
+                super::super::tests::echo(&mut stream, b"standard double-loss echo").await;
+                drop(stream);
+                node.shutdown().await;
+                drop(node);
+                peer.stop().await;
+            })
+            .await;
+        assert!(probe.snapshot().is_idle());
+    }
+    #[tokio::test]
+    async fn mieru_udp_lost_open_reorders_duplicate_data_and_business_packets() {
+        let probe = ResourceProbe::default();
+        probe
+            .scope(async {
+                let peer = Peer::new(true, false);
+                let node = super::super::MieruOutbound::new(
+                    &config(),
+                    UpstreamPath::proxy(Arc::new(peer.clone())),
+                    32768,
+                )
+                .unwrap();
+                let context = EstablishContext::with_timeout(Duration::from_secs(5));
+                let mut stream = node
+                    .connect_stream(super::super::tests::session(), &context)
+                    .await
+                    .unwrap()
+                    .io;
+                let data: Vec<_> = (0..5000).map(|i| (i % 251) as u8).collect();
+                tokio::time::timeout(Duration::from_secs(8), async {
+                    stream.write_all(&data).await.unwrap();
+                    let mut got = vec![0; data.len()];
+                    stream.read_exact(&mut got).await.unwrap();
+                    assert_eq!(got, data);
+                })
+                .await
+                .unwrap();
+                assert!(peer.opens.load(Ordering::Relaxed) >= 2);
+                let nonces = peer.nonces.lock().unwrap().clone();
+                assert_eq!(
+                    nonces.len(),
+                    nonces
+                        .iter()
+                        .collect::<std::collections::HashSet<_>>()
+                        .len()
+                );
+                let request = DatagramRequest::new(DatagramSession::new(
+                    InboundKind::Socks5,
+                    "192.0.2.10:1000".parse().unwrap(),
+                ));
+                let mut packet = node.open_datagram(request, &context).await.unwrap();
+                let payload = Bytes::from(vec![9; 1200]);
+                let remote = Destination::Ip("198.51.100.1:53".parse().unwrap());
+                packet
+                    .send(Datagram {
+                        remote: remote.clone(),
+                        payload: payload.clone(),
+                        sniffed_domain: None,
+                    })
+                    .await
+                    .unwrap();
+                let echoed = tokio::time::timeout(Duration::from_secs(3), packet.receive())
+                    .await
+                    .unwrap()
+                    .unwrap();
+                assert_eq!(echoed.payload, payload);
+                assert_eq!(echoed.remote, remote);
+                packet.close().await.unwrap();
+                drop(packet);
+                drop(stream);
+                node.shutdown().await;
+                drop(node);
+                peer.stop().await;
+            })
+            .await;
+        assert!(probe.snapshot().is_idle());
+    }
+    #[tokio::test]
+    async fn mieru_udp_stop_releases_unacked_bytes_and_open_deadline() {
+        let probe = ResourceProbe::default();
+        probe.scope(async{
+            let peer=Peer::new(false,true);let node=super::super::MieruOutbound::new(&config(),UpstreamPath::proxy(Arc::new(peer.clone())),32768).unwrap();let context=EstablishContext::with_timeout(Duration::from_secs(5));let mut stream=node.connect_stream(super::super::tests::session(),&context).await.unwrap().io;let data=vec![1;32768];{let writing=stream.write_all(&data);tokio::pin!(writing);tokio::select!{result=&mut writing=>panic!("unacknowledged opening unexpectedly wrote: {result:?}"),()=tokio::time::sleep(Duration::from_millis(20))=>{}}
+            tokio::time::timeout(Duration::from_secs(2),node.shutdown()).await.unwrap();assert!(writing.await.is_err());}drop(stream);drop(node);peer.stop().await;
+        }).await;
+        assert!(probe.snapshot().is_idle());
+    }
+    #[tokio::test]
+    async fn mieru_udp_reorder_unread_and_unacknowledged_credit_are_independent() {
+        let cancellation = CancellationToken::new();
+        let state = State::new(1, 8, &cancellation, Arc::new(tokio::sync::Notify::new()));
+        let mut reliable = Reliable::new(state.clone(), 2);
+        let mut partial = None;
+        let frame = |sequence, bytes: &'static [u8]| Frame {
+            metadata: Metadata::Data(DataMetadata {
+                kind: DataKind::ServerData,
+                session_id: 1,
+                sequence,
+                unack_sequence: 0,
+                window: 16,
+                fragment: 0,
+            }),
+            payload: Bytes::from_static(bytes),
+        };
+        reliable.input(frame(1, b"AAAA"), Instant::now(), &mut partial);
+        assert_eq!(state.receive_bytes.available_permits(), 8);
+        assert_eq!(reliable.reorder_bytes.available_permits(), 4);
+        reliable.input(frame(0, b"BBBB"), Instant::now(), &mut partial);
+        assert!(reliable.reorder.is_empty());
+        assert_eq!(state.receive_bytes.available_permits(), 0);
+        assert_eq!(reliable.reorder_bytes.available_permits(), 8);
+        assert_eq!(reliable.window(true), 4);
+        reliable.input(frame(1, b"wrong"), Instant::now(), &mut partial);
+        let mut buffer = [0; 4];
+        let mut read = tokio::io::ReadBuf::new(&mut buffer);
+        futures_util::future::poll_fn(|cx| state.poll_read(cx, &mut read))
+            .await
+            .unwrap();
+        assert_eq!(buffer, *b"BBBB");
+        assert_eq!(state.receive_bytes.available_permits(), 4);
+        let mut read = tokio::io::ReadBuf::new(&mut buffer);
+        futures_util::future::poll_fn(|cx| state.poll_read(cx, &mut read))
+            .await
+            .unwrap();
+        assert_eq!(buffer, *b"AAAA");
+        assert_eq!(state.receive_bytes.available_permits(), 8);
+        let permits = Arc::new(tokio::sync::Semaphore::new(8));
+        let permit = permits.clone().acquire_many_owned(8).await.unwrap();
+        let (done, result) = oneshot::channel();
+        reliable.enqueue(
+            WriterCommand {
+                state: state.clone(),
+                data: Bytes::from_static(b"12345678"),
+                piggyback: true,
+                done,
+                _bytes: permit,
+            },
+            2,
+            true,
+        );
+        while let Some(mut segment) = reliable.pending.pop_front() {
+            segment.sent = Some(Instant::now());
+            segment.tx_count = 1;
+            if let Some(lease) = &segment.lease {
+                lease.sent();
+            }
+            reliable
+                .outstanding
+                .insert(sequence(segment.metadata), segment);
+        }
+        result.await.unwrap().unwrap();
+        assert_eq!(permits.available_permits(), 0);
+        reliable.acknowledge(3, 16, true, Instant::now());
+        assert_eq!(permits.available_permits(), 0);
+        reliable.acknowledge(3, 16, true, Instant::now());
+        reliable.acknowledge(3, 16, true, Instant::now());
+        assert_eq!(reliable.outstanding.get(&3).unwrap().ack_count, 3);
+        reliable.acknowledge(5, 16, true, Instant::now());
+        assert_eq!(permits.available_permits(), 8);
+        state.close();
+        drop(reliable);
+        drop(state);
+    }
+    // These tests use the actual reliable writer/output and Close rejection paths.
+    // Replaced completion receivers own no payload credit and are not cancellation.
+    struct LookaheadPackets {
+        decoder: PacketDecoder,
+        frames: Vec<Frame>,
+        latest: Option<oneshot::Receiver<io::Result<()>>>,
+    }
+    #[async_trait]
+    impl DatagramTransport for LookaheadPackets {
+        fn supports_shared_destinations(&self) -> bool {
+            false
+        }
+        async fn send(&mut self, packet: Datagram) -> Result<(), DispatchError> {
+            if let Some(latest) = self.latest.as_mut() {
+                assert!(
+                    matches!(latest.try_recv(), Err(oneshot::error::TryRecvError::Empty)),
+                    "latest cannot complete before its final physical fragment is sent"
+                );
+            }
+            self.frames.push(
+                self.decoder
+                    .decode_frame(packet.payload, super::super::tcp::now().unwrap())
+                    .map_err(|_| DispatchError::NotAllowed)?,
+            );
+            Ok(())
+        }
+        async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+            std::future::pending().await
+        }
+        async fn close(&mut self) -> Result<(), DispatchError> {
+            Ok(())
+        }
+    }
+    fn lookahead_command(
+        state: &Arc<State>,
+        credit: &Arc<Semaphore>,
+        data: &'static [u8],
+    ) -> (WriterCommand, oneshot::Receiver<io::Result<()>>) {
+        let (done, response) = oneshot::channel();
+        (
+            WriterCommand {
+                state: state.clone(),
+                data: Bytes::from_static(data),
+                piggyback: false,
+                done,
+                _bytes: credit
+                    .clone()
+                    .try_acquire_many_owned(data.len() as u32)
+                    .unwrap(),
+            },
+            response,
+        )
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn mieru_udp_admission_depth4_latest_first_send_covers_older_actual_fifo_fragments() {
+        let shared = Shared::output_test_shared(CancellationToken::new());
+        let state = State::new_for_business(
+            7,
+            32768,
+            super::super::tcp::Business::UdpAssociate,
+            &shared.cancel,
+            shared.activity.clone(),
+        );
+        state.opened.store(true, Ordering::Release);
+        shared.sessions.lock().unwrap().insert(7, state.clone());
+        let credit = Arc::new(Semaphore::new(32768));
+        let (writer, mut commands) = mpsc::channel(2);
+        assert_eq!(writer.max_capacity(), 2);
+        assert_eq!(OUTPUT_QUANTUM, 8);
+        const DATA: [&[u8]; 4] = [&[b'A'; 1214], &[b'B'; 1214], &[b'C'; 1214], &[b'D'; 1214]];
+        let mut sessions = BTreeMap::new();
+        let mut latest = None;
+        for data in DATA {
+            let (command, completion) = lookahead_command(&state, &credit, data);
+            writer.try_send(command).unwrap();
+            latest = Some(completion); // Drop old witnesses, never their byte permits.
+            if writer.capacity() == 0 {
+                for _ in 0..2 {
+                    input_command(
+                        commands.try_recv().unwrap(),
+                        &mut sessions,
+                        656,
+                        1312,
+                        false,
+                    );
+                }
+            }
+        }
+        assert!(commands.try_recv().is_err());
+        let reliable = sessions.get_mut(&7).unwrap();
+        reliable.established = true;
+        let key = crypto::derive_packet_key(
+            "vole",
+            "fixture-password",
+            super::super::tcp::now().unwrap(),
+        );
+        let mut encoder = PacketEncoder::new(&key, false).unwrap();
+        let mut packets = LookaheadPackets {
+            decoder: PacketDecoder::new(&key, false).unwrap(),
+            frames: Vec::new(),
+            latest,
+        };
+        let pattern =
+            EffectivePattern::compile(None, super::super::pattern::HostProfile::capture(), "vole")
+                .unwrap();
+        let peer = Destination::Ip("192.0.2.1:2000".parse().unwrap());
+        let mut patterned = PacketPattern {
+            pattern: &pattern,
+            nonce: NonceState::new(),
+            wire_budget: usize::from(MTU),
+            remaining: OUTPUT_QUANTUM,
+            truncated: false,
+        };
+        assert!(
+            output(
+                &mut packets,
+                &peer,
+                &mut encoder,
+                "vole",
+                &shared,
+                &mut patterned,
+                reliable,
+                true,
+                &mut Vec::new()
+            )
+            .await
+            .unwrap()
+        );
+        assert_eq!(packets.frames.len(), OUTPUT_QUANTUM);
+        assert_eq!(patterned.remaining, 0);
+        packets
+            .latest
+            .as_mut()
+            .unwrap()
+            .try_recv()
+            .unwrap()
+            .unwrap();
+        let mut payload = Vec::new();
+        for (sequence, frame) in packets.frames.iter().enumerate() {
+            assert!(matches!(frame.metadata, Metadata::Data(meta)
+                if meta.session_id == 7 && meta.sequence == sequence as u32 && meta.fragment == (1 - sequence % 2) as u8));
+            payload.extend_from_slice(&frame.payload);
+        }
+        assert_eq!(payload, DATA.concat());
+        assert_eq!(
+            credit.available_permits(),
+            32768 - 4 * 1214,
+            "first-send does not release ACK-owned credit"
+        );
+        reliable.acknowledge(8, 16, false, Instant::now());
+        assert_eq!(credit.available_permits(), 32768);
+        state.close();
+    }
+    #[tokio::test(start_paused = true)]
+    async fn mieru_udp_admission_depth4_deferred_close_rejects_latest_without_immediate_state_cancel()
+     {
+        let shared = Shared::output_test_shared(CancellationToken::new());
+        let state = State::new_for_business(
+            7,
+            8,
+            super::super::tcp::Business::UdpAssociate,
+            &shared.cancel,
+            shared.activity.clone(),
+        );
+        state.opened.store(true, Ordering::Release);
+        shared.sessions.lock().unwrap().insert(7, state.clone());
+        let credit = Arc::new(Semaphore::new(32));
+        let (first, older) = lookahead_command(&state, &credit, b"AAAA");
+        let (second, second_done) = lookahead_command(&state, &credit, b"BBBB");
+        let (third, third_done) = lookahead_command(&state, &credit, b"CCCC");
+        let (fourth, mut latest) = lookahead_command(&state, &credit, b"DDDD");
+        drop((older, second_done, third_done));
+        let mut sessions = BTreeMap::new();
+        input_command(first, &mut sessions, 2, 4, false);
+        let mut partial = None;
+        state
+            .deliver(Bytes::from_static(b"12345678"))
+            .await
+            .unwrap();
+        let reliable = sessions.get_mut(&7).unwrap();
+        reliable.established = true;
+        reliable.input(
+            Frame {
+                metadata: Metadata::Data(DataMetadata {
+                    kind: DataKind::ServerData,
+                    session_id: 7,
+                    sequence: 0,
+                    unack_sequence: 0,
+                    window: 16,
+                    fragment: 0,
+                }),
+                payload: Bytes::from_static(b"tail"),
+            },
+            Instant::now(),
+            &mut partial,
+        );
+        assert_eq!(
+            reliable.reorder.len(),
+            1,
+            "application credit forces the accepted tail to remain"
+        );
+        let key = crypto::derive_packet_key(
+            "vole",
+            "fixture-password",
+            super::super::tcp::now().unwrap(),
+        );
+        let mut encoder = PacketEncoder::new(&key, false).unwrap();
+        let mut decoder = PacketDecoder::new(&key, false).unwrap();
+        let mut packets = LookaheadPackets {
+            decoder: PacketDecoder::new(&key, false).unwrap(),
+            frames: Vec::new(),
+            latest: None,
+        };
+        let pattern =
+            EffectivePattern::compile(None, super::super::pattern::HostProfile::capture(), "vole")
+                .unwrap();
+        let peer = Destination::Ip("192.0.2.1:2000".parse().unwrap());
+        let mut patterned = PacketPattern {
+            pattern: &pattern,
+            nonce: NonceState::new(),
+            wire_budget: usize::from(MTU),
+            remaining: OUTPUT_QUANTUM,
+            truncated: false,
+        };
+        let mut wire = Vec::new();
+        PacketEncoder::new(&key, false)
+            .unwrap()
+            .encode_frame(
+                Metadata::Session(SessionMetadata {
+                    kind: SessionKind::CloseRequest,
+                    session_id: 7,
+                    sequence: 1,
+                    status: 0,
+                }),
+                &[],
+                Padding {
+                    prefix: &[],
+                    suffix: &[],
+                },
+                rand::random(),
+                super::super::tcp::now().unwrap(),
+                &mut wire,
+            )
+            .unwrap();
+        assert!(
+            input_packet(
+                Datagram {
+                    remote: peer.clone(),
+                    payload: Bytes::from(wire),
+                    sniffed_domain: None
+                },
+                &mut packets,
+                &peer,
+                DatagramBudget::new(MTU, MTU),
+                &mut encoder,
+                &mut decoder,
+                "vole",
+                &shared,
+                &mut patterned,
+                &mut sessions,
+                &mut partial,
+                &mut Vec::new(),
+                &mut CloseRetries::default()
+            )
+            .await
+            .unwrap()
+        );
+        assert_eq!(sessions[&7].remote_close, Some(false));
+        assert_eq!(sessions[&7].reorder.len(), 1);
+        assert!(
+            !state.cancel.is_cancelled(),
+            "Close defers State.finish until the accepted tail is delivered"
+        );
+        assert!(sessions[&7].pending.is_empty());
+        assert!(matches!(
+            latest.try_recv(),
+            Err(oneshot::error::TryRecvError::Empty)
+        ));
+        input_command(second, &mut sessions, 2, 4, false);
+        input_command(third, &mut sessions, 2, 4, false);
+        assert!(matches!(
+            latest.try_recv(),
+            Err(oneshot::error::TryRecvError::Empty)
+        ));
+        input_command(fourth, &mut sessions, 2, 4, false);
+        assert!(
+            matches!(latest.try_recv().unwrap(), Err(error) if error.kind() == io::ErrorKind::BrokenPipe)
+        );
+        assert!(
+            !state.cancel.is_cancelled(),
+            "the retained latest itself propagates this rejection"
+        );
+        assert_eq!(credit.available_permits(), 32);
+        state.close();
+    }
+
+    // Two business SIDs deliberately use the same output owner, wire codec and
+    // byte credit. Eligibility must come from each State, not Shared's creator.
+    struct QualifiedRtoPackets {
+        inner: LookaheadPackets,
+        delay: Duration,
+        fail: bool,
+    }
+    #[async_trait]
+    impl DatagramTransport for QualifiedRtoPackets {
+        fn supports_shared_destinations(&self) -> bool {
+            false
+        }
+        async fn send(&mut self, packet: Datagram) -> Result<(), DispatchError> {
+            if !self.delay.is_zero() {
+                tokio::time::sleep(self.delay).await;
+            }
+            if self.fail {
+                return Err(DispatchError::ConnectionRefused);
+            }
+            self.inner.send(packet).await
+        }
+        async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+            std::future::pending().await
+        }
+        async fn close(&mut self) -> Result<(), DispatchError> {
+            Ok(())
+        }
+    }
+    struct QualifiedRtoFixture {
+        shared: Arc<Shared>,
+        credit: Arc<Semaphore>,
+        encoder: PacketEncoder,
+        ack_encoder: PacketEncoder,
+        ack_decoder: PacketDecoder,
+        packets: QualifiedRtoPackets,
+        pattern: EffectivePattern,
+        wire: Vec<u8>,
+    }
+    impl QualifiedRtoFixture {
+        fn new() -> Self {
+            let key = crypto::derive_packet_key(
+                "vole",
+                "fixture-password",
+                super::super::tcp::now().unwrap(),
+            );
+            Self {
+                shared: Shared::output_test_shared(CancellationToken::new()),
+                credit: Arc::new(Semaphore::new(64)),
+                encoder: PacketEncoder::new(&key, false).unwrap(),
+                ack_encoder: PacketEncoder::new(&key, false).unwrap(),
+                ack_decoder: PacketDecoder::new(&key, false).unwrap(),
+                packets: QualifiedRtoPackets {
+                    inner: LookaheadPackets {
+                        decoder: PacketDecoder::new(&key, false).unwrap(),
+                        frames: Vec::new(),
+                        latest: None,
+                    },
+                    delay: Duration::ZERO,
+                    fail: false,
+                },
+                pattern: EffectivePattern::compile(
+                    None,
+                    super::super::pattern::HostProfile::capture(),
+                    "vole",
+                )
+                .unwrap(),
+                wire: Vec::new(),
+            }
+        }
+        fn session(
+            &self,
+            id: u32,
+            business: super::super::tcp::Business,
+            rtt: Duration,
+        ) -> Reliable {
+            let state = State::new_for_business(
+                id,
+                64,
+                business,
+                &self.shared.cancel,
+                self.shared.activity.clone(),
+            );
+            state.opened.store(true, Ordering::Release);
+            self.shared
+                .sessions
+                .lock()
+                .unwrap()
+                .insert(id, state.clone());
+            let mut reliable = Reliable::new(state, 1312);
+            reliable.established = true;
+            reliable.heartbeat_interval = Duration::from_secs(30);
+            reliable.heartbeat = Instant::now() + reliable.heartbeat_interval;
+            reliable.rtt.update(rtt);
+            reliable
+        }
+        fn enqueue(
+            &self,
+            reliable: &mut Reliable,
+            data: &'static [u8],
+            chunk: usize,
+        ) -> oneshot::Receiver<io::Result<()>> {
+            let (command, done) = lookahead_command(&reliable.state, &self.credit, data);
+            reliable.enqueue(command, chunk, false);
+            done
+        }
+        fn ack(&mut self, reliable: &mut Reliable, unack: u32, nonce: u8) {
+            timeout_epoch_codec_ack(
+                reliable,
+                &mut self.ack_encoder,
+                &mut self.ack_decoder,
+                unack,
+                nonce,
+            );
+        }
+        async fn output(&mut self, reliable: &mut Reliable) -> io::Result<bool> {
+            let mut pattern = PacketPattern {
+                pattern: &self.pattern,
+                nonce: NonceState::new(),
+                wire_budget: MTU.into(),
+                remaining: OUTPUT_QUANTUM,
+                truncated: false,
+            };
+            output(
+                &mut self.packets,
+                &Destination::Ip("192.0.2.1:2000".parse().unwrap()),
+                &mut self.encoder,
+                "vole",
+                &self.shared,
+                &mut pattern,
+                reliable,
+                true,
+                &mut self.wire,
+            )
+            .await
+        }
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn mieru_udp_saved_rto_qualifies_each_business_with_live_tcp_control() {
+        let probe = ResourceProbe::default();
+        probe
+            .scope(async {
+                for (initial, sample, rises) in [(100, 1000, true), (1000, 800, false)] {
+                    let mut fixture = QualifiedRtoFixture::new();
+                    let mut udp = fixture.session(
+                        7,
+                        super::super::tcp::Business::UdpAssociate,
+                        Duration::from_millis(initial),
+                    );
+                    let mut tcp = fixture.session(
+                        9,
+                        super::super::tcp::Business::TcpConnect,
+                        Duration::from_millis(initial),
+                    );
+                    let mut completions = [
+                        fixture.enqueue(&mut udp, b"A", 1312),
+                        fixture.enqueue(&mut udp, b"B", 1312),
+                        fixture.enqueue(&mut tcp, b"A", 1312),
+                        fixture.enqueue(&mut tcp, b"B", 1312),
+                    ];
+                    assert!(fixture.output(&mut udp).await.unwrap());
+                    assert!(fixture.output(&mut tcp).await.unwrap());
+                    for done in &mut completions {
+                        done.try_recv().unwrap().unwrap();
+                    }
+                    let sent = udp.outstanding[&1].sent.unwrap();
+                    assert_eq!(tcp.outstanding[&1].sent, Some(sent));
+                    let frozen = udp.outstanding[&1].timeout_nanos;
+                    assert!(frozen > 0);
+                    assert!(
+                        tcp.outstanding
+                            .values()
+                            .all(|segment| segment.timeout_nanos == 0)
+                    );
+                    tokio::time::advance(FIRST_CHECK).await;
+                    assert!(fixture.output(&mut udp).await.unwrap());
+                    assert!(fixture.output(&mut tcp).await.unwrap());
+                    assert!(udp.first_check.is_none() && tcp.first_check.is_none());
+                    assert_eq!(fixture.packets.inner.frames.len(), 4);
+                    tokio::time::advance(sent + Duration::from_millis(sample) - Instant::now())
+                        .await;
+                    fixture.ack(&mut udp, 1, 1);
+                    fixture.ack(&mut tcp, 1, 2);
+                    assert_eq!(fixture.credit.available_permits(), 62);
+                    assert_eq!(udp.outstanding.len(), 1);
+                    assert_eq!(tcp.outstanding.len(), 1);
+                    assert_eq!(udp.rtt.rto(), tcp.rtt.rto());
+                    let frozen_due = sent + Duration::from_nanos(frozen);
+                    let live_due = sent + tcp.rtt.retransmit_delay(1);
+                    assert_eq!(live_due > frozen_due, rises);
+                    assert_eq!(udp.outstanding[&1].timeout_nanos, frozen);
+                    assert_eq!(udp.next_deadline(Instant::now()), frozen_due);
+                    assert_eq!(tcp.next_deadline(Instant::now()), live_due);
+                    let earlier = frozen_due.min(live_due).max(Instant::now());
+                    assert!(earlier < frozen_due.max(live_due));
+                    tokio::time::advance(earlier - Instant::now()).await;
+                    assert!(fixture.output(&mut udp).await.unwrap());
+                    assert!(fixture.output(&mut tcp).await.unwrap());
+                    assert_eq!(udp.outstanding[&1].tx_count, if rises { 2 } else { 1 });
+                    assert_eq!(tcp.outstanding[&1].tx_count, if rises { 1 } else { 2 });
+                    assert_eq!(fixture.packets.inner.frames.len(), 5);
+                    tokio::time::advance(frozen_due.max(live_due) - Instant::now()).await;
+                    assert!(fixture.output(&mut udp).await.unwrap());
+                    assert!(fixture.output(&mut tcp).await.unwrap());
+                    assert_eq!(udp.outstanding[&1].tx_count, 2);
+                    assert_eq!(tcp.outstanding[&1].tx_count, 2);
+                    assert_eq!(fixture.packets.inner.frames.len(), 6);
+                    let mut retry_ids: Vec<_> = fixture.packets.inner.frames[4..]
+                        .iter()
+                        .map(|frame| {
+                            assert!(matches!(frame.metadata, Metadata::Data(meta)
+                        if meta.kind == DataKind::ClientData && meta.sequence == 1));
+                            assert_eq!(frame.payload.as_ref(), b"B");
+                            session_id(frame.metadata)
+                        })
+                        .collect();
+                    retry_ids.sort_unstable();
+                    assert_eq!(retry_ids, [7, 9]);
+                    fixture.ack(&mut udp, 2, 3);
+                    fixture.ack(&mut tcp, 2, 4);
+                    assert_eq!(fixture.credit.available_permits(), 64);
+                    fixture.shared.cancel.cancel();
+                    udp.state.close();
+                    tcp.state.close();
+                    fixture.shared.sessions.lock().unwrap().clear();
+                    drop((udp, tcp));
+                }
+            })
+            .await;
+        assert!(probe.snapshot().is_idle());
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn mieru_udp_saved_rto_publishes_only_success_and_keeps_fast_retry_leases() {
+        let probe = ResourceProbe::default();
+        probe.scope(async {
+            let mut fixture = QualifiedRtoFixture::new();
+            let mut failed = fixture.session(11, super::super::tcp::Business::UdpAssociate, Duration::from_secs(1));
+            let mut failed_done = fixture.enqueue(&mut failed, b"X", 1);
+            let heartbeat = failed.heartbeat;
+            fixture.packets.fail = true;
+            fixture.packets.delay = Duration::from_millis(13);
+            assert!(fixture.output(&mut failed).await.is_err());
+            assert!(failed.outstanding.is_empty());
+            assert!(fixture.packets.inner.frames.is_empty());
+            assert_eq!(failed.heartbeat, heartbeat);
+            assert!(failed_done.try_recv().unwrap().is_err());
+            assert_eq!(fixture.credit.available_permits(), 64);
+            failed.state.close();
+            fixture.shared.sessions.lock().unwrap().remove(&11);
+            drop(failed);
+
+            fixture.packets.fail = false;
+            fixture.packets.delay = Duration::ZERO;
+            let mut reliable = fixture.session(7, super::super::tcp::Business::UdpAssociate, Duration::from_secs(1));
+            let mut done = fixture.enqueue(&mut reliable, b"AB", 1);
+            assert!(fixture.output(&mut reliable).await.unwrap());
+            done.try_recv().unwrap().unwrap();
+            assert_eq!(fixture.packets.inner.frames.len(), 2);
+            let sent = reliable.outstanding[&1].sent.unwrap();
+            let first_timeout = reliable.outstanding[&1].timeout_nanos;
+            tokio::time::advance(FIRST_CHECK).await;
+            assert!(fixture.output(&mut reliable).await.unwrap());
+            assert!(reliable.first_check.is_none());
+            tokio::time::advance(sent + Duration::from_millis(800) - Instant::now()).await;
+            fixture.ack(&mut reliable, 1, 1);
+            let rto = reliable.rtt.rto();
+            assert_eq!(fixture.credit.available_permits(), 62, "the retained tail owns the whole fragmented write");
+            assert_eq!(reliable.outstanding[&1].timeout_nanos, first_timeout);
+            fixture.ack(&mut reliable, 1, 2);
+            fixture.ack(&mut reliable, 1, 3);
+            assert_eq!(reliable.rtt.rto(), rto);
+            assert_eq!(reliable.outstanding[&1].ack_count, 3);
+            assert!(Instant::now() < sent + Duration::from_nanos(first_timeout));
+            assert_eq!(reliable.next_deadline(Instant::now()), Instant::now());
+            let old = &reliable.outstanding[&1];
+            let previous = (old.sent, old.timeout_nanos, old.tx_count, old.ack_count);
+            let heartbeat = reliable.heartbeat;
+            fixture.packets.delay = Duration::from_millis(13);
+            fixture.packets.fail = true;
+            assert!(fixture.output(&mut reliable).await.is_err());
+            let old = &reliable.outstanding[&1];
+            assert_eq!((old.sent, old.timeout_nanos, old.tx_count, old.ack_count), previous);
+            assert_eq!(reliable.heartbeat, heartbeat);
+            assert_eq!(fixture.packets.inner.frames.len(), 2);
+            assert_eq!(fixture.credit.available_permits(), 62);
+            fixture.packets.fail = false;
+            let before_send = Instant::now();
+            let refreshed = reliable.rtt.retransmit_delay(2);
+            assert_ne!(refreshed, Duration::from_nanos(first_timeout));
+            assert!(fixture.output(&mut reliable).await.unwrap());
+            let retried = &reliable.outstanding[&1];
+            assert_eq!(retried.sent, Some(Instant::now()));
+            assert!(retried.sent.unwrap() >= before_send + Duration::from_millis(13));
+            assert_eq!(Duration::from_nanos(retried.timeout_nanos), refreshed);
+            assert_eq!((retried.tx_count, retried.ack_count), (2, 0));
+            assert!(reliable.timeout_epoch.is_none(), "fast-only must remain loss, not timeout");
+            assert_eq!(fixture.packets.inner.frames.len(), 3);
+            let frame = fixture.packets.inner.frames.last().unwrap();
+            assert!(matches!(frame.metadata, Metadata::Data(meta)
+                if meta.kind == DataKind::ClientData && meta.session_id == 7 && meta.sequence == 1 && meta.fragment == 0));
+            assert_eq!(frame.payload.as_ref(), b"B");
+            assert_eq!(fixture.credit.available_permits(), 62);
+            fixture.ack(&mut reliable, 2, 4);
+            assert!(reliable.outstanding.is_empty());
+            assert_eq!(fixture.credit.available_permits(), 64);
+            fixture.shared.cancel.cancel(); reliable.state.close();
+            fixture.shared.sessions.lock().unwrap().clear();
+            drop(reliable);
+        }).await;
+        assert!(probe.snapshot().is_idle());
+    }
+
+    fn timeout_epoch_codec_ack(
+        reliable: &mut Reliable,
+        encoder: &mut PacketEncoder,
+        decoder: &mut PacketDecoder,
+        unack: u32,
+        nonce: u8,
+    ) {
+        let mut wire = Vec::new();
+        encoder
+            .encode_frame(
+                Metadata::Data(DataMetadata {
+                    kind: DataKind::ServerAck,
+                    session_id: reliable.state.id,
+                    sequence: 0,
+                    unack_sequence: unack,
+                    window: 4096,
+                    fragment: 0,
+                }),
+                &[],
+                Padding {
+                    prefix: &[],
+                    suffix: &[],
+                },
+                [nonce; 24],
+                super::super::tcp::now().unwrap(),
+                &mut wire,
+            )
+            .unwrap();
+        let frame = decoder
+            .decode_frame(Bytes::from(wire), super::super::tcp::now().unwrap())
+            .unwrap();
+        reliable.input(frame, Instant::now(), &mut None);
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn mieru_udp_timeout_epoch_preserves_cross_slice_ack_growth_and_repeated_loss() {
+        let probe = ResourceProbe::default();
+        probe
+            .scope(async {
+                let shared = Shared::output_test_shared(CancellationToken::new());
+                let state = State::new_for_business(
+                    7,
+                    64,
+                    super::super::tcp::Business::UdpAssociate,
+                    &shared.cancel,
+                    shared.activity.clone(),
+                );
+                state.opened.store(true, Ordering::Release);
+                shared.sessions.lock().unwrap().insert(7, state.clone());
+                let credit = Arc::new(Semaphore::new(64));
+                let mut reliable = Reliable::new(state.clone(), 1312);
+                reliable.established = true;
+                reliable.rtt.update(Duration::from_nanos(100_000_015));
+                let delay = Duration::from_nanos(451_500_064);
+                assert_eq!(reliable.rtt.retransmit_delay(1), delay);
+                let (command, mut completion) =
+                    lookahead_command(&state, &credit, b"ABCDEFGHIJKLMNOP");
+                reliable.enqueue(command, 1, false);
+                let pattern = EffectivePattern::compile(
+                    None,
+                    super::super::pattern::HostProfile::capture(),
+                    "vole",
+                )
+                .unwrap();
+                let mut patterned = PacketPattern {
+                    pattern: &pattern,
+                    nonce: NonceState::new(),
+                    wire_budget: MTU.into(),
+                    remaining: OUTPUT_QUANTUM,
+                    truncated: false,
+                };
+                let key = crypto::derive_packet_key(
+                    "vole",
+                    "fixture-password",
+                    super::super::tcp::now().unwrap(),
+                );
+                let mut encoder = PacketEncoder::new(&key, false).unwrap();
+                let mut packets = LookaheadPackets {
+                    decoder: PacketDecoder::new(&key, false).unwrap(),
+                    frames: Vec::new(),
+                    latest: None,
+                };
+                let mut ack_encoder = PacketEncoder::new(&key, false).unwrap();
+                let mut ack_decoder = PacketDecoder::new(&key, false).unwrap();
+                let peer = Destination::Ip("192.0.2.1:2000".parse().unwrap());
+                let mut wire = Vec::new();
+                for expected in [8, 16] {
+                    patterned.remaining = OUTPUT_QUANTUM;
+                    patterned.truncated = false;
+                    assert!(
+                        output(
+                            &mut packets,
+                            &peer,
+                            &mut encoder,
+                            "vole",
+                            &shared,
+                            &mut patterned,
+                            &mut reliable,
+                            true,
+                            &mut wire
+                        )
+                        .await
+                        .unwrap()
+                    );
+                    assert_eq!(packets.frames.len(), expected);
+                }
+                completion.try_recv().unwrap().unwrap();
+                assert_eq!(reliable.outstanding.len(), 16);
+                assert_eq!(credit.available_permits(), 48);
+                let first_sent = reliable.outstanding[&0].sent.unwrap();
+                let sent_delay = Duration::from_nanos(reliable.outstanding[&0].timeout_nanos);
+                assert_eq!(sent_delay, delay);
+                tokio::time::advance(first_sent + sent_delay - Instant::now()).await;
+                patterned.remaining = OUTPUT_QUANTUM;
+                patterned.truncated = false;
+                assert!(
+                    output(
+                        &mut packets,
+                        &peer,
+                        &mut encoder,
+                        "vole",
+                        &shared,
+                        &mut patterned,
+                        &mut reliable,
+                        true,
+                        &mut wire
+                    )
+                    .await
+                    .unwrap()
+                );
+                assert_eq!(packets.frames.len(), 24);
+                assert_eq!(patterned.remaining, 0);
+                assert!(patterned.truncated);
+                assert_eq!(reliable.cubic.window(), 16);
+                let epoch_send = Instant::now();
+                timeout_epoch_codec_ack(&mut reliable, &mut ack_encoder, &mut ack_decoder, 8, 1);
+                assert_eq!(reliable.outstanding.len(), 8);
+                assert_eq!(reliable.cubic.window(), 24);
+                assert_eq!(
+                    credit.available_permits(),
+                    48,
+                    "the unacked tail still owns the whole write"
+                );
+                patterned.remaining = OUTPUT_QUANTUM;
+                patterned.truncated = false;
+                assert!(
+                    output(
+                        &mut packets,
+                        &peer,
+                        &mut encoder,
+                        "vole",
+                        &shared,
+                        &mut patterned,
+                        &mut reliable,
+                        true,
+                        &mut wire
+                    )
+                    .await
+                    .unwrap()
+                );
+                assert_eq!(packets.frames.len(), 32);
+                // Declared oracle: DD resets again to 16; the old-flight continuation
+                // must retain the eight real ACK increments, not emulate CUBIC math.
+                assert_eq!(reliable.cubic.window(), 24);
+                assert!(
+                    reliable
+                        .outstanding
+                        .values()
+                        .all(|s| s.tx_count == 2 && s.sent == Some(epoch_send))
+                );
+                let retried = &reliable.outstanding[&8];
+                let repeated_due =
+                    retried.sent.unwrap() + Duration::from_nanos(retried.timeout_nanos);
+                assert!(
+                    reliable
+                        .outstanding
+                        .values()
+                        .all(|segment| segment.timeout_nanos > 0
+                            && segment.sent.unwrap() + Duration::from_nanos(segment.timeout_nanos)
+                                == repeated_due)
+                );
+                tokio::time::advance(repeated_due - Instant::now()).await;
+                patterned.remaining = OUTPUT_QUANTUM;
+                patterned.truncated = false;
+                assert!(
+                    output(
+                        &mut packets,
+                        &peer,
+                        &mut encoder,
+                        "vole",
+                        &shared,
+                        &mut patterned,
+                        &mut reliable,
+                        true,
+                        &mut wire
+                    )
+                    .await
+                    .unwrap()
+                );
+                assert_eq!(packets.frames.len(), 40);
+                assert_eq!(
+                    reliable.cubic.window(),
+                    16,
+                    "a genuinely repeated timeout still resets"
+                );
+                assert!(
+                    reliable
+                        .outstanding
+                        .values()
+                        .all(|s| s.tx_count == 3 && s.sent == Some(repeated_due))
+                );
+                for (index, frame) in packets.frames.iter().enumerate() {
+                    let expected_sequence = match index {
+                        0..=15 => index,
+                        16..=23 => index - 16,
+                        24..=31 => index - 16,
+                        _ => index - 24,
+                    };
+                    assert!(matches!(frame.metadata, Metadata::Data(meta)
+                    if meta.kind == DataKind::ClientData && meta.session_id == 7
+                    && meta.sequence == expected_sequence as u32
+                    && meta.fragment == 15 - expected_sequence as u8));
+                    assert_eq!(
+                        frame.payload.as_ref(),
+                        &b"ABCDEFGHIJKLMNOP"[expected_sequence..expected_sequence + 1]
+                    );
+                }
+                timeout_epoch_codec_ack(&mut reliable, &mut ack_encoder, &mut ack_decoder, 16, 2);
+                assert!(reliable.outstanding.is_empty());
+                assert_eq!(credit.available_permits(), 64);
+                shared.cancel.cancel();
+                state.close();
+                shared.sessions.lock().unwrap().clear();
+                drop((reliable, state));
+            })
+            .await;
+        assert!(probe.snapshot().is_idle());
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn mieru_udp_timeout_epoch_keeps_timeout_priority_fast_loss_and_stop_ownership() {
+        let probe = ResourceProbe::default();
+        probe
+            .scope(async {
+                let shared = Shared::output_test_shared(CancellationToken::new());
+                let state = State::new_for_business(
+                    7,
+                    64,
+                    super::super::tcp::Business::UdpAssociate,
+                    &shared.cancel,
+                    shared.activity.clone(),
+                );
+                state.opened.store(true, Ordering::Release);
+                shared.sessions.lock().unwrap().insert(7, state.clone());
+                let credit = Arc::new(Semaphore::new(64));
+                let mut reliable = Reliable::new(state.clone(), 1312);
+                reliable.established = true;
+                reliable.rtt.update(Duration::from_nanos(100_000_015));
+                let delay = Duration::from_nanos(451_500_064);
+                assert_eq!(reliable.rtt.retransmit_delay(1), delay);
+                let (command, mut completion) = lookahead_command(&state, &credit, b"ABC");
+                reliable.enqueue(command, 1, false);
+                let pattern = EffectivePattern::compile(
+                    None,
+                    super::super::pattern::HostProfile::capture(),
+                    "vole",
+                )
+                .unwrap();
+                let mut patterned = PacketPattern {
+                    pattern: &pattern,
+                    nonce: NonceState::new(),
+                    wire_budget: MTU.into(),
+                    remaining: OUTPUT_QUANTUM,
+                    truncated: false,
+                };
+                let key = crypto::derive_packet_key(
+                    "vole",
+                    "fixture-password",
+                    super::super::tcp::now().unwrap(),
+                );
+                let mut encoder = PacketEncoder::new(&key, false).unwrap();
+                let mut packets = LookaheadPackets {
+                    decoder: PacketDecoder::new(&key, false).unwrap(),
+                    frames: Vec::new(),
+                    latest: None,
+                };
+                let mut ack_encoder = PacketEncoder::new(&key, false).unwrap();
+                let mut ack_decoder = PacketDecoder::new(&key, false).unwrap();
+                let peer = Destination::Ip("192.0.2.1:2000".parse().unwrap());
+                let mut wire = Vec::new();
+                assert!(
+                    output(
+                        &mut packets,
+                        &peer,
+                        &mut encoder,
+                        "vole",
+                        &shared,
+                        &mut patterned,
+                        &mut reliable,
+                        true,
+                        &mut wire
+                    )
+                    .await
+                    .unwrap()
+                );
+                completion.try_recv().unwrap().unwrap();
+                assert_eq!(packets.frames.len(), 3);
+                let first_sent = reliable.outstanding[&0].sent.unwrap();
+                let sent_delay = Duration::from_nanos(reliable.outstanding[&0].timeout_nanos);
+                assert_eq!(sent_delay, delay);
+                tokio::time::advance(first_sent + sent_delay - Instant::now()).await;
+                // Seven earlier sends of the shared TX8 can leave this SID one slot.
+                patterned.remaining = 1;
+                patterned.truncated = false;
+                assert!(
+                    output(
+                        &mut packets,
+                        &peer,
+                        &mut encoder,
+                        "vole",
+                        &shared,
+                        &mut patterned,
+                        &mut reliable,
+                        true,
+                        &mut wire
+                    )
+                    .await
+                    .unwrap()
+                );
+                assert_eq!(packets.frames.len(), 4);
+                assert!(patterned.truncated);
+                for nonce in 1..=3 {
+                    timeout_epoch_codec_ack(
+                        &mut reliable,
+                        &mut ack_encoder,
+                        &mut ack_decoder,
+                        1,
+                        nonce,
+                    );
+                }
+                assert_eq!(reliable.cubic.window(), 17);
+                assert_eq!(reliable.outstanding[&1].ack_count, 3);
+                patterned.remaining = OUTPUT_QUANTUM;
+                patterned.truncated = false;
+                assert!(
+                    output(
+                        &mut packets,
+                        &peer,
+                        &mut encoder,
+                        "vole",
+                        &shared,
+                        &mut patterned,
+                        &mut reliable,
+                        true,
+                        &mut wire
+                    )
+                    .await
+                    .unwrap()
+                );
+                assert_eq!(packets.frames.len(), 6);
+                assert_eq!(patterned.remaining, 6);
+                // The old timeout on seq2 keeps priority over fast seq1 even when
+                // its repeated timeout response is coalesced; do not call OnLoss.
+                assert_eq!(reliable.cubic.window(), 17);
+                for (frame, sequence) in packets.frames[4..].iter().zip([1, 2]) {
+                    assert!(matches!(frame.metadata, Metadata::Data(meta)
+                    if meta.kind == DataKind::ClientData && meta.sequence == sequence));
+                    assert_eq!(reliable.outstanding[&sequence].tx_count, 2);
+                }
+                assert_eq!(credit.available_permits(), 61);
+                timeout_epoch_codec_ack(&mut reliable, &mut ack_encoder, &mut ack_decoder, 3, 4);
+                assert_eq!(reliable.cubic.window(), 19);
+                assert_eq!(credit.available_permits(), 64);
+                let (command, mut done) = lookahead_command(&state, &credit, b"D");
+                reliable.enqueue(command, 1, false);
+                patterned.remaining = OUTPUT_QUANTUM;
+                patterned.truncated = false;
+                assert!(
+                    output(
+                        &mut packets,
+                        &peer,
+                        &mut encoder,
+                        "vole",
+                        &shared,
+                        &mut patterned,
+                        &mut reliable,
+                        true,
+                        &mut wire
+                    )
+                    .await
+                    .unwrap()
+                );
+                done.try_recv().unwrap().unwrap();
+                for nonce in 5..=7 {
+                    timeout_epoch_codec_ack(
+                        &mut reliable,
+                        &mut ack_encoder,
+                        &mut ack_decoder,
+                        3,
+                        nonce,
+                    );
+                }
+                tokio::time::advance(Duration::from_millis(1)).await;
+                assert!(
+                    Instant::now()
+                        < reliable.outstanding[&3].sent.unwrap() + reliable.rtt.retransmit_delay(1)
+                );
+                patterned.remaining = OUTPUT_QUANTUM;
+                patterned.truncated = false;
+                assert!(
+                    output(
+                        &mut packets,
+                        &peer,
+                        &mut encoder,
+                        "vole",
+                        &shared,
+                        &mut patterned,
+                        &mut reliable,
+                        true,
+                        &mut wire
+                    )
+                    .await
+                    .unwrap()
+                );
+                assert_eq!(packets.frames.len(), 8);
+                assert_eq!(reliable.outstanding[&3].tx_count, 2);
+                assert_eq!(reliable.cubic.window(), 16);
+                timeout_epoch_codec_ack(&mut reliable, &mut ack_encoder, &mut ack_decoder, 4, 8);
+                assert_eq!(
+                    reliable.cubic.window(),
+                    16,
+                    "fast-only retains loss recovery; a timeout reset would ACK-grow to 17"
+                );
+                let (command, mut done) = lookahead_command(&state, &credit, b"E");
+                reliable.enqueue(command, 1, false);
+                patterned.remaining = OUTPUT_QUANTUM;
+                patterned.truncated = false;
+                assert!(
+                    output(
+                        &mut packets,
+                        &peer,
+                        &mut encoder,
+                        "vole",
+                        &shared,
+                        &mut patterned,
+                        &mut reliable,
+                        true,
+                        &mut wire
+                    )
+                    .await
+                    .unwrap()
+                );
+                done.try_recv().unwrap().unwrap();
+                assert_eq!(credit.available_permits(), 63);
+                assert_eq!(reliable.outstanding.len(), 1);
+                shared.cancel.cancel();
+                state.close();
+                drop(reliable);
+                shared.sessions.lock().unwrap().clear();
+                assert_eq!(credit.available_permits(), 64);
+                drop(state);
+            })
+            .await;
+        assert!(probe.snapshot().is_idle());
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn mieru_udp_send_credit96_two_sids_keep_fragment_leases_until_their_acks() {
+        let probe = ResourceProbe::default();
+        probe.scope(async {
+            let shared = Shared::output_test_shared(CancellationToken::new());
+            let credit = Arc::new(Semaphore::new(98304));
+            let (writer, mut commands) = mpsc::channel(2);
+            let mut states = Vec::new();
+            let mut completions = Vec::new();
+            for (id, data) in [(7, &[b'A'; 32768][..]), (8, &[b'B'; 32768][..])] {
+                let state = State::new_for_business(
+                    id, 32768, super::super::tcp::Business::UdpAssociate,
+                    &shared.cancel, shared.activity.clone(),
+                );
+                state.opened.store(true, Ordering::Release);
+                shared.sessions.lock().unwrap().insert(id, state.clone());
+                let (command, done) = lookahead_command(&state, &credit, data);
+                writer.try_send(command).unwrap();
+                states.push(state);
+                completions.push(done);
+            }
+            assert_eq!(credit.available_permits(), 32768);
+            assert_eq!(writer.max_capacity(), 2);
+            let pattern = EffectivePattern::compile(
+                None, super::super::pattern::HostProfile::capture(), "vole",
+            ).unwrap();
+            let chunk = pattern.plaintext_fragment_limit(MieruTransport::Udp, MTU.into()).unwrap();
+            let fragments = 32768_usize.div_ceil(chunk);
+            assert!(fragments > 16 && fragments <= 32);
+            let mut sessions = BTreeMap::new();
+            for _ in 0..2 {
+                input_command(commands.try_recv().unwrap(), &mut sessions, chunk, 1312, false);
+            }
+            for reliable in sessions.values_mut() {
+                reliable.established = true;
+            }
+            let key = crypto::derive_packet_key("vole", "fixture-password", super::super::tcp::now().unwrap());
+            let mut encoder = PacketEncoder::new(&key, false).unwrap();
+            let mut packets = LookaheadPackets {
+                decoder: PacketDecoder::new(&key, false).unwrap(),
+                frames: Vec::new(), latest: None,
+            };
+            let peer = Destination::Ip("192.0.2.1:2000".parse().unwrap());
+            let mut patterned = PacketPattern {
+                pattern: &pattern, nonce: NonceState::new(), wire_budget: MTU.into(),
+                remaining: OUTPUT_QUANTUM, truncated: false,
+            };
+            let mut buffer = Vec::new();
+            for _ in 0..2 {
+                for id in [7, 8] {
+                    patterned.remaining = OUTPUT_QUANTUM;
+                    patterned.truncated = false;
+                    let before = packets.frames.len();
+                    assert!(output(&mut packets, &peer, &mut encoder, "vole", &shared,
+                        &mut patterned, sessions.get_mut(&id).unwrap(), true, &mut buffer)
+                        .await.unwrap());
+                    assert!(packets.frames.len() - before <= 8);
+                }
+            }
+            for done in &mut completions {
+                assert!(matches!(done.try_recv(), Err(oneshot::error::TryRecvError::Empty)));
+            }
+            for reliable in sessions.values_mut() {
+                assert_eq!(reliable.outstanding.len(), 16);
+                reliable.acknowledge(16, 16, true, Instant::now());
+                reliable.acknowledge(16, 16, true, Instant::now());
+            }
+            assert_eq!(credit.available_permits(), 32768,
+                "partial and duplicate ACKs retain the shared whole-write leases");
+            for _ in 0..2 {
+                for id in [7, 8] {
+                    patterned.remaining = OUTPUT_QUANTUM;
+                    patterned.truncated = false;
+                    let before = packets.frames.len();
+                    assert!(output(&mut packets, &peer, &mut encoder, "vole", &shared,
+                        &mut patterned, sessions.get_mut(&id).unwrap(), true, &mut buffer)
+                        .await.unwrap());
+                    assert!(packets.frames.len() - before <= 8);
+                }
+            }
+            for done in &mut completions { done.try_recv().unwrap().unwrap(); }
+            assert_eq!(credit.available_permits(), 32768, "first-send success is not an ACK");
+            for (id, expected) in [(7, b'A'), (8, b'B')] {
+                let mut payload = Vec::new();
+                let mut next = 0;
+                for frame in &packets.frames {
+                    if matches!(frame.metadata, Metadata::Data(meta) if meta.session_id == id) {
+                        assert!(matches!(frame.metadata, Metadata::Data(meta)
+                            if meta.sequence == next && meta.fragment as usize == fragments - 1 - next as usize));
+                        payload.extend_from_slice(&frame.payload);
+                        next += 1;
+                    }
+                }
+                assert_eq!(next as usize, fragments);
+                assert_eq!(payload, vec![expected; 32768]);
+            }
+            sessions.get_mut(&7).unwrap().acknowledge(fragments as u32, 16, true, Instant::now());
+            assert_eq!(credit.available_permits(), 65536,
+                "ACK for one SID retires only that SID's shared-carrier lease");
+            shared.cancel.cancel();
+            sessions.clear(); // Terminal clearing releases the unacked sibling, not a false ACK.
+            shared.sessions.lock().unwrap().clear();
+            for state in &states { state.close(); }
+            drop(states);
+            assert_eq!(credit.available_permits(), 98304);
+        }).await;
+        assert!(probe.snapshot().is_idle());
+    }
+}
+
+#[cfg(test)]
+include!("udp_split_receive_tests.rs");
+
+#[cfg(test)]
+include!("udp_balanced_driver_tests.rs");
diff --git a/src/outbound/mieru/udp_admission_memory_tests.rs b/src/outbound/mieru/udp_admission_memory_tests.rs
new file mode 100644
index 0000000..c6f0e0f
--- /dev/null
+++ b/src/outbound/mieru/udp_admission_memory_tests.rs
@@ -0,0 +1,521 @@
+//! Real RawStream/PacketTransport boundaries over the existing bounded command FIFO.
+//! Manual done signals are physical-first-send witnesses, not a second UDP driver.
+use super::super::{packet::PacketTransport, stream::Stream};
+use super::*;
+use crate::{
+    dispatch::DatagramTransport,
+    outbound::DatagramRequest,
+    session::{Datagram, DatagramSession, Destination},
+};
+use std::{
+    future::Future,
+    task::{Wake, Waker},
+};
+
+async fn bounded<F: Future>(future: F) -> F::Output {
+    tokio::time::timeout(Duration::from_secs(1), future)
+        .await
+        .expect("Mieru memory seam did not complete within its original ownership boundary")
+}
+
+#[tokio::test]
+async fn mieru_udp_admission_empty_write_keeps_pending_barrier_and_error_priority() {
+    let (mut raw, mut commands, state, credit) = fixture(true, 16);
+    bounded(raw.write_all(b"AAAA")).await.unwrap();
+    let command = commands.try_recv().unwrap();
+    let mut cx = Context::from_waker(futures_util::task::noop_waker_ref());
+    assert!(matches!(
+        Pin::new(&mut raw).poll_write(&mut cx, &[]),
+        Poll::Ready(Ok(0))
+    ));
+    assert_eq!(credit.available_permits(), 12);
+    assert!(Pin::new(&mut raw).poll_flush(&mut cx).is_pending());
+    let permit = first_sent(command);
+    bounded(raw.flush()).await.unwrap();
+    assert_eq!(credit.available_permits(), 12);
+    drop(permit);
+    assert_eq!(credit.available_permits(), 16);
+    state.close();
+
+    let (mut raw, mut commands, state, _) = fixture(true, 16);
+    bounded(raw.write_all(b"AAAA")).await.unwrap();
+    let WriterCommand { done, _bytes, .. } = commands.try_recv().unwrap();
+    done.send(Err(io::ErrorKind::TimedOut.into())).unwrap();
+    assert!(matches!(
+        Pin::new(&mut raw).poll_write(&mut cx, &[]),
+        Poll::Ready(Err(error)) if error.kind() == io::ErrorKind::TimedOut
+    ));
+    drop(_bytes);
+    state.close();
+
+    let (mut raw, mut commands, state, _) = fixture(true, 16);
+    bounded(raw.write_all(b"AAAA")).await.unwrap();
+    let command = commands.try_recv().unwrap();
+    state.close();
+    assert!(matches!(
+        Pin::new(&mut raw).poll_write(&mut cx, &[]),
+        Poll::Ready(Err(error)) if error.kind() == io::ErrorKind::BrokenPipe
+    ));
+    drop(command);
+}
+
+#[derive(Default)]
+struct WakeCount(AtomicUsize);
+impl Wake for WakeCount {
+    fn wake(self: Arc<Self>) {
+        self.wake_by_ref();
+    }
+    fn wake_by_ref(self: &Arc<Self>) {
+        self.0.fetch_add(1, Ordering::Relaxed);
+    }
+}
+fn fixture(
+    queued: bool,
+    capacity: usize,
+) -> (
+    RawStream,
+    mpsc::Receiver<WriterCommand>,
+    Arc<State>,
+    Arc<Semaphore>,
+) {
+    fixture_chunk(queued, capacity, capacity)
+}
+fn fixture_chunk(
+    queued: bool,
+    capacity: usize,
+    chunk: usize,
+) -> (
+    RawStream,
+    mpsc::Receiver<WriterCommand>,
+    Arc<State>,
+    Arc<Semaphore>,
+) {
+    let shared = Shared::output_test_shared(CancellationToken::new());
+    let business = if queued {
+        Business::UdpAssociate
+    } else {
+        Business::TcpConnect
+    };
+    let state = State::new_for_business(
+        7,
+        capacity,
+        business,
+        &shared.cancel,
+        shared.activity.clone(),
+    );
+    shared.sessions.lock().unwrap().insert(7, state.clone());
+    let (writer, commands) = mpsc::channel(WRITER_COMMANDS);
+    let bytes = Arc::new(Semaphore::new(capacity));
+    let carrier = Arc::new(Carrier {
+        shared,
+        writer,
+        bytes: bytes.clone(),
+    });
+    (
+        RawStream::new(carrier, state.clone(), chunk).with_queued_writes(queued),
+        commands,
+        state,
+        bytes,
+    )
+}
+fn first_sent(command: WriterCommand) -> OwnedSemaphorePermit {
+    let WriterCommand { done, _bytes, .. } = command;
+    let _ = done.send(Ok(())); // A cancelled owner may already have dropped its witness.
+    _bytes // Keep the original payload permit through simulated ACK/retirement.
+}
+
+#[tokio::test]
+async fn mieru_udp_admission_latest_first_send_barrier_and_byte_ownership() {
+    let (mut raw, mut commands, state, credit) = fixture(true, 32);
+    let wake = Arc::new(WakeCount::default());
+    let waker = Waker::from(wake.clone());
+    let mut cx = Context::from_waker(&waker);
+    let mut admitted = Vec::new();
+    for data in [b"AAAA", b"BBBB", b"CCCC", b"DDDD"] {
+        bounded(raw.write_all(data)).await.unwrap();
+        admitted.push(commands.try_recv().unwrap());
+    }
+    assert_eq!(credit.available_permits(), 16);
+    let mut next = Box::pin(raw.write_all(b"EEEE"));
+    assert!(next.as_mut().poll(&mut cx).is_pending());
+    assert!(commands.try_recv().is_err());
+    assert_eq!(
+        credit.available_permits(),
+        16,
+        "fifth write allocates no permit before its barrier"
+    );
+    let fourth = admitted.pop().unwrap();
+    let mut held: Vec<_> = admitted.into_iter().map(first_sent).collect();
+    assert!(
+        next.as_mut().poll(&mut cx).is_pending(),
+        "latest covers all replaced first-send witnesses"
+    );
+    assert_eq!(credit.available_permits(), 16);
+    let wakes = wake.0.load(Ordering::Relaxed);
+    held.push(first_sent(fourth));
+    assert!(wake.0.load(Ordering::Relaxed) > wakes);
+    assert!(matches!(next.as_mut().poll(&mut cx), Poll::Ready(Ok(()))));
+    drop(next);
+    let fifth = commands.try_recv().unwrap();
+    assert_eq!(&fifth.data[..], b"EEEE");
+    assert_eq!(credit.available_permits(), 12);
+    let mut flushing = Box::pin(raw.flush());
+    assert!(flushing.as_mut().poll(&mut cx).is_pending());
+    drop(flushing);
+    let mut shutdown = Box::pin(raw.shutdown());
+    assert!(shutdown.as_mut().poll(&mut cx).is_pending());
+    assert!(!state.local_closed.load(Ordering::Acquire));
+    held.push(first_sent(fifth));
+    assert!(matches!(
+        shutdown.as_mut().poll(&mut cx),
+        Poll::Ready(Ok(()))
+    ));
+    drop(shutdown);
+    assert!(state.local_closed.load(Ordering::Acquire));
+    assert_eq!(
+        credit.available_permits(),
+        12,
+        "first-send and shutdown retain actor credit"
+    );
+    bounded(raw.shutdown()).await.unwrap();
+    drop(held);
+    assert_eq!(credit.available_permits(), 32);
+}
+
+#[tokio::test]
+async fn mieru_udp_admission_depth4_never_bypasses_a_ready_first_send_error() {
+    for dropped in [false, true] {
+        let (mut raw, mut commands, state, credit) = fixture(true, 16);
+        bounded(raw.write_all(b"AAAA")).await.unwrap();
+        let WriterCommand { done, _bytes, .. } = commands.try_recv().unwrap();
+        if dropped {
+            drop(done);
+        } else {
+            done.send(Err(io::ErrorKind::TimedOut.into())).unwrap();
+        }
+        let mut cx = Context::from_waker(Waker::noop());
+        let result = Pin::new(&mut raw).poll_write(&mut cx, b"B");
+        assert!(
+            matches!(result, Poll::Ready(Err(error)) if error.kind() == if dropped { io::ErrorKind::BrokenPipe } else { io::ErrorKind::TimedOut })
+        );
+        assert!(matches!(
+            commands.try_recv(),
+            Err(mpsc::error::TryRecvError::Empty)
+        ));
+        assert_eq!(credit.available_permits(), 12);
+        state.close();
+        drop(_bytes);
+        assert_eq!(credit.available_permits(), 16);
+    }
+}
+
+#[tokio::test]
+async fn mieru_udp_admission_depth4_state_failure_wakes_without_releasing_actor_credit() {
+    let (mut raw, mut commands, state, credit) = fixture(true, 32);
+    let mut admitted = Vec::new();
+    for data in [b"AAAA", b"BBBB", b"CCCC", b"DDDD"] {
+        bounded(raw.write_all(data)).await.unwrap();
+        admitted.push(commands.try_recv().unwrap());
+    }
+    let wake = Arc::new(WakeCount::default());
+    let waker = Waker::from(wake.clone());
+    let mut cx = Context::from_waker(&waker);
+    let mut fifth = Box::pin(raw.write_all(b"E"));
+    assert!(fifth.as_mut().poll(&mut cx).is_pending());
+    let before = wake.0.load(Ordering::Relaxed);
+    state.finish(true);
+    assert!(wake.0.load(Ordering::Relaxed) > before);
+    assert!(matches!(fifth.as_mut().poll(&mut cx), Poll::Ready(Err(_))));
+    drop(fifth);
+    assert!(bounded(raw.flush()).await.is_err());
+    assert!(bounded(raw.shutdown()).await.is_err());
+    assert!(matches!(
+        Pin::new(&mut raw).poll_write(&mut cx, &[]),
+        Poll::Ready(Err(_))
+    ));
+    assert_eq!(credit.available_permits(), 16);
+    drop((raw, admitted, commands));
+    assert_eq!(credit.available_permits(), 32);
+}
+
+#[tokio::test]
+async fn mieru_udp_admission_classic_write_and_budget_cancel_keep_original_boundaries() {
+    let wake = Arc::new(WakeCount::default());
+    let waker = Waker::from(wake.clone());
+    let mut cx = Context::from_waker(&waker);
+    let (mut raw, mut commands, _state, credit) = fixture(false, 4);
+    let mut writing = Box::pin(raw.write_all(b"AAAA"));
+    assert!(
+        writing.as_mut().poll(&mut cx).is_pending(),
+        "classic mode still waits physical first-send"
+    );
+    let permit = first_sent(commands.try_recv().unwrap());
+    assert!(matches!(
+        writing.as_mut().poll(&mut cx),
+        Poll::Ready(Ok(()))
+    ));
+    drop(writing);
+    drop(permit);
+    drop(raw);
+    assert_eq!(credit.available_permits(), 4);
+
+    for complete_first in [false, true] {
+        let capacity = if complete_first { 4 } else { 32 };
+        let (mut raw, mut commands, state, credit) = fixture(true, capacity);
+        bounded(raw.write_all(b"AAAA")).await.unwrap();
+        let first = commands.try_recv().unwrap();
+        let (mut retained, retained_permit) = if complete_first {
+            (Vec::new(), Some(first_sent(first)))
+        } else {
+            (vec![first], None)
+        };
+        if !complete_first {
+            for data in [b"BBBB", b"CCCC", b"DDDD"] {
+                bounded(raw.write_all(data)).await.unwrap();
+                retained.push(commands.try_recv().unwrap());
+            }
+        }
+        assert_eq!(
+            credit.available_permits(),
+            capacity - if complete_first { 4 } else { 16 }
+        );
+        let mut blocked = Box::pin(raw.write_all(b"B"));
+        assert!(
+            blocked.as_mut().poll(&mut cx).is_pending(),
+            "block at depth4 latest with free bytes, or original budget after first-send"
+        );
+        assert!(matches!(
+            commands.try_recv(),
+            Err(mpsc::error::TryRecvError::Empty)
+        ));
+        let wakes = wake.0.load(Ordering::Relaxed);
+        state.close();
+        assert!(wake.0.load(Ordering::Relaxed) > wakes);
+        assert!(matches!(
+            blocked.as_mut().poll(&mut cx),
+            Poll::Ready(Err(_))
+        ));
+        drop(blocked);
+        drop(raw);
+        assert!(matches!(
+            commands.try_recv(),
+            Err(mpsc::error::TryRecvError::Disconnected)
+        ));
+        drop((retained, retained_permit));
+        assert_eq!(credit.available_permits(), capacity);
+    }
+}
+
+#[tokio::test]
+async fn mieru_udp_admission_packet_send_cancel_never_reuses_a_partial_record() {
+    let shared = Shared::output_test_shared(CancellationToken::new());
+    let state = State::new(7, 128, &shared.cancel, shared.activity.clone());
+    shared.sessions.lock().unwrap().insert(7, state.clone());
+    let sibling = State::new(8, 128, &shared.cancel, shared.activity.clone());
+    let credit = Arc::new(Semaphore::new(128));
+    let (writer, mut commands) = mpsc::channel(WRITER_COMMANDS);
+    // Another logical source fills the original FIFO, so our SID can cancel
+    // its first admission while waiting on mpsc, independently of the first-send burst gate.
+    for data in [b"AAAA", b"BBBB"] {
+        let (done, _receiver) = oneshot::channel();
+        writer
+            .try_send(WriterCommand {
+                state: sibling.clone(),
+                data: Bytes::copy_from_slice(data),
+                piggyback: false,
+                done,
+                _bytes: credit.clone().try_acquire_many_owned(4).unwrap(),
+            })
+            .unwrap();
+    }
+    let carrier = Arc::new(Carrier {
+        shared,
+        writer,
+        bytes: credit.clone(),
+    });
+    let raw = RawStream::new(carrier, state.clone(), 128).with_queued_writes(true);
+    let parent = CancellationToken::new();
+    let request = DatagramRequest::new(DatagramSession::for_tun(
+        "192.0.2.1:1234".parse().unwrap(),
+        1500,
+    ));
+    let context = EstablishContext::with_timeout(Duration::from_secs(1));
+    let mut packet = PacketTransport::new(Box::new(raw), &request, &context, parent, |reader| {
+        Ok(tokio::spawn(reader))
+    })
+    .unwrap()
+    .with_queued_sends(true);
+    let datagram = || Datagram {
+        remote: Destination::Ip("198.51.100.1:443".parse().unwrap()),
+        payload: Bytes::from_static(b"cancelled"),
+        sniffed_domain: None,
+    };
+    let waker = Waker::noop();
+    let mut cx = Context::from_waker(waker);
+    let mut sending = Box::pin(packet.send(datagram()));
+    assert!(sending.as_mut().poll(&mut cx).is_pending());
+    drop(sending); // Exercise the production SendGuard, not raw AsyncWrite cancellation/reuse.
+    assert!(bounded(packet.send(datagram())).await.is_err());
+    bounded(packet.close()).await.unwrap();
+    assert!(state.local_closed.load(Ordering::Acquire));
+    let first = commands.try_recv().unwrap();
+    let second = commands.try_recv().unwrap();
+    assert_eq!(&first.data[..], b"AAAA");
+    assert_eq!(&second.data[..], b"BBBB");
+    assert!(
+        commands.try_recv().is_err(),
+        "cancelled pending mpsc admission is never replayed"
+    );
+    drop((first, second, commands, packet));
+    assert_eq!(credit.available_permits(), 128);
+}
+
+#[tokio::test]
+async fn mieru_udp_admission_no_wait_shutdown_retains_the_started_handshake_barrier() {
+    let (raw, mut commands, state, credit) = fixture(true, 256);
+    let target = Destination::Ip("0.0.0.0:0".parse().unwrap());
+    let mut stream = Stream::no_wait(raw, &target, crate::socks5::COMMAND_UDP_ASSOCIATE).unwrap();
+    let wake = Arc::new(WakeCount::default());
+    let waker = Waker::from(wake);
+    let mut cx = Context::from_waker(&waker);
+    let mut writing = Box::pin(stream.write_all(b"AAAA"));
+    assert!(writing.as_mut().poll(&mut cx).is_pending());
+    drop(writing); // The Stream retains its original in-progress business handshake.
+    let command = commands.try_recv().unwrap();
+    let queued = command.data.len();
+    state
+        .deliver(Bytes::from_static(&[5, 0, 0, 1, 0, 0, 0, 0, 0, 0]))
+        .await
+        .unwrap();
+    let mut shutdown = Box::pin(stream.shutdown());
+    assert!(
+        shutdown.as_mut().poll(&mut cx).is_pending(),
+        "successful response must not drop the outstanding first-send barrier"
+    );
+    assert!(!state.local_closed.load(Ordering::Acquire));
+    let permit = first_sent(command);
+    assert!(matches!(
+        shutdown.as_mut().poll(&mut cx),
+        Poll::Ready(Ok(()))
+    ));
+    drop(shutdown);
+    bounded(stream.shutdown()).await.unwrap(); // Idempotent after successful queued shutdown.
+    assert!(state.local_closed.load(Ordering::Acquire));
+    assert_eq!(credit.available_permits(), 256 - queued);
+    drop((stream, permit, commands));
+    assert_eq!(credit.available_permits(), 256);
+}
+
+#[tokio::test]
+async fn mieru_udp_admission_depth4_partial_packet_chunks_preserve_send_guard() {
+    for cancel in [false, true] {
+        let (raw, mut commands, state, credit) = fixture_chunk(true, 128, 4);
+        let request = DatagramRequest::new(DatagramSession::for_tun(
+            "192.0.2.1:1234".parse().unwrap(),
+            1500,
+        ));
+        let context = EstablishContext::with_timeout(Duration::from_secs(1));
+        let mut packet = PacketTransport::new(
+            Box::new(raw),
+            &request,
+            &context,
+            CancellationToken::new(),
+            |reader| Ok(tokio::spawn(reader)),
+        )
+        .unwrap()
+        .with_queued_sends(true);
+        let target = Destination::Ip("198.51.100.1:443".parse().unwrap());
+        let datagram = || Datagram {
+            remote: target.clone(),
+            payload: Bytes::from_static(b"cancelled"),
+            sniffed_domain: None,
+        };
+        let mut cx = Context::from_waker(Waker::noop());
+        let mut sending = Box::pin(packet.send(datagram()));
+        let result = sending.as_mut().poll(&mut cx);
+        assert!(result.is_pending());
+        assert_eq!(
+            credit.available_permits(),
+            116,
+            "FIFO2 holds two chunks and the pending third owns its original permit"
+        );
+        let first = commands.try_recv().unwrap();
+        let second = commands.try_recv().unwrap();
+        assert_eq!(first.data.len(), 4);
+        assert_eq!(second.data.len(), 4);
+        assert!(matches!(
+            commands.try_recv(),
+            Err(mpsc::error::TryRecvError::Empty)
+        ));
+        // Free the original FIFO2, then allow the third and fourth chunks.
+        assert!(sending.as_mut().poll(&mut cx).is_pending());
+        let third = commands.try_recv().unwrap();
+        let fourth = commands.try_recv().unwrap();
+        assert_eq!(third.data.len(), 4);
+        assert_eq!(fourth.data.len(), 4);
+        assert_eq!(credit.available_permits(), 112);
+        assert!(
+            commands.try_recv().is_err(),
+            "fifth chunk waits before allocation"
+        );
+        if cancel {
+            drop(sending);
+            assert!(
+                bounded(packet.send(datagram())).await.is_err(),
+                "cancelled partial record poisons the stream"
+            );
+            bounded(packet.close()).await.unwrap();
+            assert!(state.local_closed.load(Ordering::Acquire));
+            assert!(
+                commands.try_recv().is_err(),
+                "cancelled next chunk is never admitted or replayed"
+            );
+            assert_eq!(credit.available_permits(), 112);
+            drop((first, second, third, fourth, packet, commands));
+            assert_eq!(credit.available_permits(), 128);
+            continue;
+        }
+        let mut wire = first.data.to_vec();
+        wire.extend_from_slice(&second.data);
+        wire.extend_from_slice(&third.data);
+        wire.extend_from_slice(&fourth.data);
+        let mut held = vec![
+            first_sent(first),
+            first_sent(second),
+            first_sent(third),
+            first_sent(fourth),
+        ];
+        loop {
+            let result = sending.as_mut().poll(&mut cx);
+            let mut admitted = 0;
+            while let Ok(command) = commands.try_recv() {
+                assert!(command.data.len() <= 4);
+                wire.extend_from_slice(&command.data);
+                held.push(first_sent(command));
+                admitted += 1;
+            }
+            assert!(
+                (1..=2).contains(&admitted),
+                "remaining record chunks keep the original FIFO2 bound"
+            );
+            if let Poll::Ready(value) = result {
+                value.unwrap();
+                break;
+            }
+        }
+        drop(sending);
+        assert_eq!(wire[0], 0);
+        assert_eq!(wire.last(), Some(&255));
+        let length = usize::from(u16::from_be_bytes([wire[1], wire[2]]));
+        assert_eq!(wire.len(), length + 4);
+        let (remote, payload) =
+            crate::socks5::decode_udp_packet(&wire[3..wire.len() - 1], usize::from(u16::MAX))
+                .unwrap();
+        assert_eq!(remote, target);
+        assert_eq!(payload, b"cancelled");
+        assert_eq!(credit.available_permits(), 128 - wire.len());
+        bounded(packet.close()).await.unwrap();
+        drop((held, packet, commands));
+        assert_eq!(credit.available_permits(), 128);
+    }
+}
diff --git a/src/outbound/mieru/udp_balanced_driver_tests.rs b/src/outbound/mieru/udp_balanced_driver_tests.rs
new file mode 100644
index 0000000..d6e87d3
--- /dev/null
+++ b/src/outbound/mieru/udp_balanced_driver_tests.rs
@@ -0,0 +1,637 @@
+#[cfg(test)]
+mod balanced_driver_tests {
+    use super::*;
+    use crate::{dispatch::DispatchError, resources::observation::ResourceProbe};
+    use async_trait::async_trait;
+    use std::sync::atomic::AtomicBool;
+    use tokio::sync::Semaphore;
+
+    const WRITES: usize = 12;
+    const READS: usize = 16;
+    const TX_CREDIT: usize = 64;
+    const RX_CREDIT: usize = 32768;
+    fn failed(message: &'static str) -> io::Error {
+        io::Error::other(message)
+    }
+
+    #[derive(Default)]
+    struct Control {
+        started: AtomicBool,
+        tx: AtomicUsize,
+        rx: AtomicUsize,
+        invalid: AtomicUsize,
+        first_rx: AtomicUsize,
+        first_data_rx: AtomicUsize,
+        receive_calls: AtomicUsize,
+        allow_send: AtomicBool,
+        close_requests: AtomicUsize,
+        queued: Mutex<VecDeque<WriterCommand>>,
+        sent: Mutex<Vec<(u32, Bytes)>>,
+    }
+    struct Packets {
+        incoming: mpsc::Receiver<Datagram>,
+        inject: mpsc::Sender<Datagram>,
+        commands: mpsc::Sender<WriterCommand>,
+        control: Arc<Control>,
+        encoder: PacketEncoder,
+        decoder: PacketDecoder,
+        peer: Destination,
+        invalid_first: bool,
+        ready_invalid: Option<Datagram>,
+        invalid_remaining: usize,
+    }
+    impl Packets {
+        fn inject(&mut self, metadata: Metadata, payload: &[u8]) -> Result<(), DispatchError> {
+            let mut encoded = Vec::new();
+            self.encoder
+                .encode_frame(
+                    metadata,
+                    payload,
+                    super::super::wire::Padding {
+                        prefix: &[],
+                        suffix: &[],
+                    },
+                    rand::random(),
+                    super::super::tcp::now().unwrap(),
+                    &mut encoded,
+                )
+                .map_err(|_| DispatchError::NotAllowed)?;
+            self.inject
+                .try_send(Datagram {
+                    remote: self.peer.clone(),
+                    payload: Bytes::from(encoded),
+                    sniffed_domain: None,
+                })
+                .map_err(|_| DispatchError::NotAllowed)
+        }
+        fn feed_next(&self) -> Result<(), DispatchError> {
+            let command = self.control.queued.lock().unwrap().pop_front();
+            if let Some(command) = command {
+                self.commands
+                    .try_send(command)
+                    .map_err(|_| DispatchError::NotAllowed)?;
+            }
+            Ok(())
+        }
+    }
+    #[async_trait]
+    impl DatagramTransport for Packets {
+        fn supports_shared_destinations(&self) -> bool {
+            false
+        }
+
+        async fn send(&mut self, packet: Datagram) -> Result<(), DispatchError> {
+            if self.ready_invalid.is_some() {
+                std::future::poll_fn(|_| {
+                    if self.control.allow_send.load(Ordering::Acquire) {
+                        std::task::Poll::Ready(())
+                    } else {
+                        std::task::Poll::Pending
+                    }
+                })
+                .await;
+            }
+            let frame = self
+                .decoder
+                .decode_frame(packet.payload, super::super::tcp::now().unwrap())
+                .map_err(|_| DispatchError::NotAllowed)?;
+            if self.ready_invalid.is_some() {
+                match frame.metadata {
+                    Metadata::Session(meta) if meta.kind == SessionKind::OpenRequest => {
+                        self.control
+                            .sent
+                            .lock()
+                            .unwrap()
+                            .push((meta.sequence, frame.payload));
+                        self.control.started.store(true, Ordering::Release);
+                    }
+                    Metadata::Session(meta) if meta.kind == SessionKind::CloseRequest => {
+                        self.control.close_requests.fetch_add(1, Ordering::AcqRel);
+                    }
+                    _ => {}
+                }
+                self.control.tx.fetch_add(1, Ordering::AcqRel);
+                return Ok(()); // No fake OPEN response or ACK is synthesized.
+            }
+            if let Metadata::Session(meta) = frame.metadata {
+                if meta.kind == SessionKind::OpenRequest {
+                    self.inject(
+                        Metadata::Session(SessionMetadata {
+                            kind: SessionKind::OpenResponse,
+                            session_id: meta.session_id,
+                            sequence: 0,
+                            status: 0,
+                        }),
+                        &[],
+                    )?;
+                    self.inject(
+                        Metadata::Data(DataMetadata {
+                            kind: DataKind::ServerAck,
+                            session_id: meta.session_id,
+                            sequence: 0,
+                            unack_sequence: 1,
+                            window: 64,
+                            fragment: 0,
+                        }),
+                        &[],
+                    )?;
+                }
+            }
+            if matches!(frame.metadata, Metadata::Data(m) if m.kind == DataKind::ClientAck)
+                && !self.control.started.swap(true, Ordering::AcqRel)
+            {
+                // Supply both competitors at one real physical-send boundary.
+                self.control.tx.store(0, Ordering::Release);
+                if self.invalid_first {
+                    for sequence in 100..100 + READS as u32 {
+                        self.inject(
+                            Metadata::Data(DataMetadata {
+                                kind: DataKind::ClientData,
+                                session_id: 1,
+                                sequence,
+                                unack_sequence: 1,
+                                window: 64,
+                                fragment: 0,
+                            }),
+                            b"x",
+                        )?;
+                    }
+                }
+                for sequence in 1..=READS as u32 {
+                    self.inject(
+                        Metadata::Data(DataMetadata {
+                            kind: DataKind::ServerData,
+                            session_id: 1,
+                            sequence,
+                            unack_sequence: 1,
+                            window: 64,
+                            fragment: 0,
+                        }),
+                        &[sequence as u8],
+                    )?;
+                }
+                self.feed_next()?;
+            } else if let Metadata::Data(meta) = frame.metadata {
+                if meta.kind == DataKind::ClientData {
+                    let received = if self.invalid_first {
+                        &self.control.invalid
+                    } else {
+                        &self.control.rx
+                    };
+                    let _ = self.control.first_data_rx.compare_exchange(
+                        usize::MAX,
+                        received.load(Ordering::Acquire),
+                        Ordering::AcqRel,
+                        Ordering::Acquire,
+                    );
+                    self.control
+                        .sent
+                        .lock()
+                        .unwrap()
+                        .push((meta.sequence, frame.payload));
+                    // Refill the real size-two command FIFO only after successful DATA.
+                    self.feed_next()?;
+                }
+            }
+            if self.control.started.load(Ordering::Acquire) {
+                self.control.tx.fetch_add(1, Ordering::AcqRel);
+            }
+            Ok(())
+        }
+        async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+            self.control.receive_calls.fetch_add(1, Ordering::AcqRel);
+            if let Some(packet) = &self.ready_invalid {
+                if self.control.started.load(Ordering::Acquire) && self.invalid_remaining != 0 {
+                    self.invalid_remaining -= 1;
+                    self.control.invalid.fetch_add(1, Ordering::AcqRel);
+                    return Ok(packet.clone()); // Reuse one encoded Bytes; no fixture per-packet allocation.
+                }
+                return std::future::pending().await;
+            }
+            let packet = self
+                .incoming
+                .recv()
+                .await
+                .ok_or(DispatchError::NotAllowed)?;
+            if let Ok(frame) = self
+                .decoder
+                .decode_frame(packet.payload.clone(), super::super::tcp::now().unwrap())
+            {
+                if matches!(frame.metadata, Metadata::Data(m) if m.kind == DataKind::ClientData) {
+                    self.control.invalid.fetch_add(1, Ordering::AcqRel);
+                }
+                if matches!(frame.metadata, Metadata::Data(m) if m.kind == DataKind::ServerData) {
+                    self.control.rx.fetch_add(1, Ordering::AcqRel);
+                    let _ = self.control.first_rx.compare_exchange(
+                        usize::MAX,
+                        self.control.tx.load(Ordering::Acquire),
+                        Ordering::AcqRel,
+                        Ordering::Acquire,
+                    );
+                }
+            }
+            Ok(packet)
+        }
+    }
+
+    async fn exercise(invalid_first: bool) {
+        let probe = ResourceProbe::default();
+        let (first_rx, first_data_rx) = probe
+            .scope(async {
+                let shared = Shared::output_test_shared(tokio_util::sync::CancellationToken::new());
+                let state = State::new(1, RX_CREDIT, &shared.cancel, shared.activity.clone());
+                shared.sessions.lock().unwrap().insert(1, state.clone());
+                let credit = Arc::new(Semaphore::new(TX_CREDIT));
+                let (commands, receiver) = mpsc::channel(2);
+                let (incoming, packets) = mpsc::channel(64);
+                let control = Arc::new(Control::default());
+                control.first_rx.store(usize::MAX, Ordering::Release);
+                control.first_data_rx.store(usize::MAX, Ordering::Release);
+                let mut writes = Vec::new();
+                for index in 0..WRITES {
+                    let (done, result) = oneshot::channel();
+                    control.queued.lock().unwrap().push_back(WriterCommand {
+                        state: state.clone(),
+                        data: Bytes::from(vec![0x81 + index as u8]),
+                        piggyback: false,
+                        done,
+                        _bytes: credit.clone().try_acquire_many_owned(1).unwrap(),
+                    });
+                    writes.push(result);
+                }
+                let key = crypto::derive_packet_key(
+                    "vole",
+                    "fixture-password",
+                    super::super::tcp::now().unwrap(),
+                );
+                let mut encoder = PacketEncoder::new(&key, false).unwrap();
+                let mut decoder = PacketDecoder::new(&key, false).unwrap();
+                let pattern = EffectivePattern::compile(
+                    None,
+                    super::super::pattern::HostProfile::capture(),
+                    "vole",
+                )
+                .unwrap();
+                let peer = Destination::Ip("192.0.2.1:2000".parse().unwrap());
+                let mut transport = Packets {
+                    incoming: packets,
+                    inject: incoming,
+                    commands: commands.clone(),
+                    control: control.clone(),
+                    encoder: PacketEncoder::new(&key, false).unwrap(),
+                    decoder: PacketDecoder::new(&key, false).unwrap(),
+                    peer: peer.clone(),
+                    invalid_first,
+                    ready_invalid: None,
+                    invalid_remaining: 0,
+                };
+                let (done, opening) = oneshot::channel();
+                commands
+                    .try_send(WriterCommand {
+                        state: state.clone(),
+                        data: Bytes::from_static(b"q"),
+                        piggyback: true,
+                        done,
+                        _bytes: credit.clone().try_acquire_many_owned(1).unwrap(),
+                    })
+                    .map_err(|_| failed("test opening command rejected"))
+                    .unwrap();
+                let (driver, work) = tokio::join!(
+                    run(
+                        &mut transport,
+                        &peer,
+                        DatagramBudget::new(MTU, MTU),
+                        &mut encoder,
+                        &mut decoder,
+                        "vole",
+                        &pattern,
+                        &shared,
+                        receiver
+                    ),
+                    async {
+                        let work = tokio::time::timeout(Duration::from_secs(1), async {
+                            opening
+                                .await
+                                .map_err(|_| failed("opening result dropped"))??;
+                            let (sent, received) = tokio::join!(
+                                async {
+                                    for write in writes {
+                                        write
+                                            .await
+                                            .map_err(|_| failed("write result dropped"))??;
+                                    }
+                                    Ok::<_, io::Error>(())
+                                },
+                                async {
+                                    let mut received = vec![0; READS];
+                                    let mut offset = 0;
+                                    while offset < READS {
+                                        let mut buffer =
+                                            tokio::io::ReadBuf::new(&mut received[offset..]);
+                                        futures_util::future::poll_fn(|cx| {
+                                            state.poll_read(cx, &mut buffer)
+                                        })
+                                        .await?;
+                                        if buffer.filled().is_empty() {
+                                            return Err(failed("early stream EOF"));
+                                        }
+                                        offset += buffer.filled().len();
+                                    }
+                                    Ok::<_, io::Error>(received)
+                                }
+                            );
+                            sent?;
+                            received
+                        })
+                        .await
+                        .unwrap_or_else(|_| Err(failed("bounded driver work timed out")));
+                        shared.fail(); // Also runs on failure; join waits for the actual driver.
+                        work
+                    }
+                );
+                state.close();
+                shared.sessions.lock().unwrap().clear();
+                drop(transport);
+                drop(commands);
+                control.queued.lock().unwrap().clear();
+                assert!(
+                    driver.is_ok()
+                        || driver
+                            .as_ref()
+                            .is_err_and(|e| e.kind() == io::ErrorKind::BrokenPipe)
+                );
+                assert_eq!(work.unwrap(), (1..=READS as u8).collect::<Vec<_>>());
+                let sent = control.sent.lock().unwrap();
+                assert_eq!(
+                    sent.iter()
+                        .map(|(sequence, _)| *sequence)
+                        .collect::<Vec<_>>(),
+                    (1..=WRITES as u32).collect::<Vec<_>>()
+                );
+                assert_eq!(
+                    sent.iter()
+                        .flat_map(|(_, bytes)| bytes.iter().copied())
+                        .collect::<Vec<_>>(),
+                    (0x81..0x81 + WRITES as u8).collect::<Vec<_>>()
+                );
+                assert_eq!(control.rx.load(Ordering::Acquire), READS);
+                assert_eq!(
+                    control.invalid.load(Ordering::Acquire),
+                    if invalid_first { READS } else { 0 }
+                );
+                assert_eq!(credit.available_permits(), TX_CREDIT);
+                assert_eq!(state.receive_bytes.available_permits(), RX_CREDIT);
+                (
+                    control.first_rx.load(Ordering::Acquire),
+                    control.first_data_rx.load(Ordering::Acquire),
+                )
+            })
+            .await;
+        assert!(probe.snapshot().is_idle());
+        // Scheduling assertions follow content, completion and credit cleanup.
+        assert!(
+            first_rx <= 8,
+            "ready RX followed {first_rx} successful physical sends"
+        );
+        assert!(
+            first_data_rx <= 8,
+            "selected DATA followed {first_data_rx} receives"
+        );
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn mieru_udp_empty_sid_ready_invalid_preserves_idle_retirement_cancel_and_first_send_gate()
+     {
+        use std::{future::Future, task::Poll};
+
+        const INVALID_PACKETS: usize = 16_384;
+        async fn once<F: Future>(mut future: std::pin::Pin<&mut F>) -> Poll<F::Output> {
+            std::future::poll_fn(|cx| Poll::Ready(future.as_mut().poll(cx))).await
+        }
+        let resources = ResourceProbe::default();
+        resources
+            .scope(async {
+                for cancel in [false, true] {
+                    let shared =
+                        Shared::output_test_shared(tokio_util::sync::CancellationToken::new());
+                    let state = State::new(1, RX_CREDIT, &shared.cancel, shared.activity.clone());
+                    shared.sessions.lock().unwrap().insert(1, state.clone());
+                    let credit = Arc::new(Semaphore::new(TX_CREDIT));
+                    let (commands, receiver) = mpsc::channel(2);
+                    let (inject, incoming) = mpsc::channel(1);
+                    let control = Arc::new(Control::default());
+                    let key = crypto::derive_packet_key(
+                        "vole",
+                        "fixture-password",
+                        super::super::tcp::now().unwrap(),
+                    );
+                    let mut encoder = PacketEncoder::new(&key, false).unwrap();
+                    let mut decoder = PacketDecoder::new(&key, false).unwrap();
+                    let pattern = EffectivePattern::compile(
+                        None,
+                        super::super::pattern::HostProfile::capture(),
+                        "vole",
+                    )
+                    .unwrap();
+                    let peer = Destination::Ip("192.0.2.1:2000".parse().unwrap());
+                    let mut bytes = Vec::new();
+                    PacketEncoder::new(&key, false)
+                        .unwrap()
+                        .encode_frame(
+                            Metadata::Data(DataMetadata {
+                                kind: DataKind::ClientData,
+                                session_id: 1,
+                                sequence: 100,
+                                unack_sequence: 0,
+                                window: 64,
+                                fragment: 0,
+                            }),
+                            b"x",
+                            super::super::wire::Padding {
+                                prefix: &[],
+                                suffix: &[],
+                            },
+                            [7; crypto::NONCE_LEN],
+                            super::super::tcp::now().unwrap(),
+                            &mut bytes,
+                        )
+                        .unwrap();
+                    let mut transport = Packets {
+                        incoming,
+                        inject,
+                        commands: commands.clone(),
+                        control: control.clone(),
+                        encoder: PacketEncoder::new(&key, false).unwrap(),
+                        decoder: PacketDecoder::new(&key, false).unwrap(),
+                        peer: peer.clone(),
+                        invalid_first: false,
+                        ready_invalid: Some(Datagram {
+                            remote: peer.clone(),
+                            payload: Bytes::from(bytes),
+                            sniffed_domain: None,
+                        }),
+                        invalid_remaining: INVALID_PACKETS,
+                    };
+                    let created = Instant::now();
+                    let mut driver = Box::pin(run(
+                        &mut transport,
+                        &peer,
+                        DatagramBudget::new(MTU, MTU),
+                        &mut encoder,
+                        &mut decoder,
+                        "vole",
+                        &pattern,
+                        &shared,
+                        receiver,
+                    ));
+                    let mut completed = None;
+                    // Empty original command sender stays alive. RX must not run before
+                    // the first physical send, including while that actual send is Pending.
+                    for _ in 0..2 {
+                        if let Poll::Ready(result) = once(driver.as_mut()).await {
+                            completed = Some(result);
+                            break;
+                        }
+                    }
+                    let (done, mut opening) = oneshot::channel();
+                    commands
+                        .try_send(WriterCommand {
+                            state: state.clone(),
+                            data: Bytes::from_static(b"q"),
+                            piggyback: true,
+                            done,
+                            _bytes: credit.clone().try_acquire_many_owned(1).unwrap(),
+                        })
+                        .map_err(|_| failed("empty-SID opening command rejected"))
+                        .unwrap();
+                    for _ in 0..4 {
+                        if completed.is_some() {
+                            break;
+                        }
+                        if let Poll::Ready(result) = once(driver.as_mut()).await {
+                            completed = Some(result);
+                            break;
+                        }
+                    }
+                    let before_send_ok = completed.is_none()
+                        && control.tx.load(Ordering::Acquire) == 0
+                        && control.receive_calls.load(Ordering::Acquire) == 0
+                        && matches!(opening.try_recv(), Err(oneshot::error::TryRecvError::Empty));
+                    control.allow_send.store(true, Ordering::Release);
+                    for _ in 0..8 {
+                        if completed.is_some() || control.tx.load(Ordering::Acquire) != 0 {
+                            break;
+                        }
+                        if let Poll::Ready(result) = once(driver.as_mut()).await {
+                            completed = Some(result);
+                        }
+                    }
+                    let sent_first = control.tx.load(Ordering::Acquire) == 1
+                        && matches!(opening.try_recv(), Ok(Ok(())))
+                        && state.opened.load(Ordering::Acquire);
+                    state.close();
+                    for _ in 0..16 {
+                        if completed.is_some() || shared.sessions.lock().unwrap().is_empty() {
+                            break;
+                        }
+                        if let Poll::Ready(result) = once(driver.as_mut()).await {
+                            completed = Some(result);
+                        }
+                    }
+                    let empty_after_close = shared.sessions.lock().unwrap().is_empty()
+                        && control.close_requests.load(Ordering::Acquire) == 1
+                        && control.tx.load(Ordering::Acquire) == 2
+                        && credit.available_permits() == TX_CREDIT;
+                    let mut progressed = true;
+                    let mut bounded_rx = true;
+                    let steps = if cancel { 16 } else { 190 };
+                    for _ in 0..steps {
+                        if completed.is_some() {
+                            break;
+                        }
+                        let before = control.invalid.load(Ordering::Acquire);
+                        // Less than the original idle sleep; continuously Ready invalid
+                        // selected RX discards/recreates that sleep before it can win.
+                        tokio::time::advance(Duration::from_secs(1)).await;
+                        if let Poll::Ready(result) = once(driver.as_mut()).await {
+                            completed = Some(result);
+                        }
+                        let after = control.invalid.load(Ordering::Acquire);
+                        if completed.is_none() {
+                            progressed &= after > before;
+                        }
+                        bounded_rx &= after - before <= usize::from(RECEIVE_BATCH);
+                        tokio::task::yield_now().await;
+                    }
+                    let completed_before_cancel = completed.is_some();
+                    let elapsed = Instant::now().saturating_duration_since(created);
+                    let reads = control.invalid.load(Ordering::Acquire);
+                    shared.cancel.cancel();
+                    for _ in 0..8 {
+                        if completed.is_some() {
+                            break;
+                        }
+                        if let Poll::Ready(result) = once(driver.as_mut()).await {
+                            completed = Some(result);
+                        }
+                        tokio::task::yield_now().await;
+                    }
+                    drop(driver);
+                    state.close();
+                    shared.sessions.lock().unwrap().clear();
+                    drop((transport, commands));
+                    let tx_credit = credit.available_permits();
+                    let rx_credit = state.receive_bytes.available_permits();
+                    drop((state, shared, encoder, decoder));
+
+                    assert!(
+                        before_send_ok,
+                        "receive callback ran before first successful physical send"
+                    );
+                    assert!(
+                        sent_first && empty_after_close,
+                        "actual OPEN/Close/local-SID removal was not established"
+                    );
+                    assert!(
+                        progressed && bounded_rx,
+                        "ready invalid RX did not progress with the original RX8 yield bound"
+                    );
+                    assert!(
+                        reads > 0 && reads < INVALID_PACKETS,
+                        "finite shared-Bytes flood exhausted or was not received"
+                    );
+                    assert_eq!(
+                        completed_before_cancel, !cancel,
+                        "empty-map retirement or cancellation phase did not match"
+                    );
+                    if !cancel {
+                        assert!(
+                            (Duration::from_secs(180)..=Duration::from_secs(190))
+                                .contains(&elapsed),
+                            "retirement skipped original created60 + idle120 policy: {elapsed:?}"
+                        );
+                    }
+                    assert!(
+                        matches!(completed, Some(Ok(()))),
+                        "actual driver failed to retire/cancel cleanly"
+                    );
+                    assert_eq!(OUTPUT_QUANTUM, 8);
+                    assert_eq!(RECEIVE_BATCH, 8);
+                    assert_eq!(tx_credit, TX_CREDIT);
+                    assert_eq!(rx_credit, RX_CREDIT);
+                }
+            })
+            .await;
+        assert!(resources.snapshot().is_idle());
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn mieru_udp_balanced_ready_reads_and_writes_complete() {
+        exercise(false).await;
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn mieru_udp_balanced_invalid_supplement_keeps_selected_output() {
+        exercise(true).await;
+    }
+}
diff --git a/src/outbound/mieru/udp_pool_memory_tests.rs b/src/outbound/mieru/udp_pool_memory_tests.rs
new file mode 100644
index 0000000..f741140
--- /dev/null
+++ b/src/outbound/mieru/udp_pool_memory_tests.rs
@@ -0,0 +1,511 @@
+//! Pool admission over the original Carrier FIFO, RawStream and byte permits.
+//! No physical driver is started; done/permit retirement are explicit witnesses.
+use super::super::tests::{Peer, config};
+use super::*;
+use crate::{config::MieruHandshake, resources::observation::ResourceProbe};
+
+const CREDIT: usize = 16;
+
+fn install(client: &Client, business: Business) -> (Arc<Carrier>, mpsc::Receiver<WriterCommand>) {
+    let mut shared = Shared::output_test_shared(client.cancel.child_token());
+    let settings = Arc::get_mut(&mut shared).unwrap();
+    settings.udp = true;
+    settings.business = client.pool(business);
+    let state = State::new(1, CREDIT, &shared.cancel, shared.activity.clone());
+    shared.sessions.lock().unwrap().insert(1, state);
+    let (writer, receiver) = mpsc::channel(WRITER_COMMANDS);
+    let carrier = Arc::new(Carrier {
+        shared,
+        writer,
+        bytes: Arc::new(Semaphore::new(CREDIT)),
+    });
+    client
+        .registry
+        .lock()
+        .unwrap()
+        .carriers
+        .insert(1, carrier.clone());
+    (carrier, receiver)
+}
+
+fn pooled_stream(client: &Client, business: Business, id: u32) -> (RawStream, Arc<Carrier>) {
+    let reservation = client.reserve_reusable(business, |_| 0).unwrap().unwrap();
+    let carrier = reservation.0.clone();
+    let state = State::new(
+        id,
+        CREDIT,
+        &carrier.shared.cancel,
+        carrier.shared.activity.clone(),
+    );
+    carrier
+        .shared
+        .sessions
+        .lock()
+        .unwrap()
+        .insert(id, state.clone());
+    drop(reservation); // Match Client::open: publish State before releasing admission.
+    let raw = RawStream::new(carrier.clone(), state, CREDIT)
+        .with_queued_writes(business == Business::UdpAssociate && client.queues_datagrams());
+    (raw, carrier)
+}
+
+#[tokio::test]
+async fn busy_tcp_credit_is_not_a_udp_business_carrier() {
+    let probe = ResourceProbe::default();
+    let (write_pending, full, excluded, tcp_active_reuse, cancelled, reclaimed, calls) = probe
+        .scope(async {
+            let peer = Peer::new(false);
+            let mut settings = config(MieruHandshake::Standard);
+            settings.transport = MieruTransport::Udp;
+            settings.multiplexing = MieruMultiplexing::Low;
+            let client = Client::new(&settings, UpstreamPath::proxy(peer.clone()), CREDIT).unwrap();
+            let (carrier, mut commands) = install(&client, Business::TcpConnect);
+            let credit = carrier.bytes.clone();
+            let (mut raw, selected) = pooled_stream(&client, Business::TcpConnect, 2);
+            drop(selected);
+            let mut cx = Context::from_waker(futures_util::task::noop_waker_ref());
+            // Production classic TCP-business write owns all original permits
+            // and is waiting for its command's first-send completion.
+            let write_pending = Pin::new(&mut raw)
+                .poll_write(&mut cx, b"0123456789ABCDEF")
+                .is_pending();
+            let command = commands.try_recv().unwrap();
+            let full =
+                credit.available_permits() == 0 && command.data.as_ref() == b"0123456789ABCDEF";
+            // Before the fix the real picker returns this occupied TCP carrier.
+            let udp = client
+                .reserve_reusable(Business::UdpAssociate, |_| 0)
+                .unwrap();
+            let excluded = udp.is_none();
+            drop(udp);
+            // UDP carrier LOW must still reuse an active same-business carrier;
+            // changing pool() alone would accidentally make TCP SID exclusive.
+            let tcp = client
+                .reserve_reusable(Business::TcpConnect, |_| 0)
+                .unwrap();
+            let tcp_active_reuse = tcp
+                .as_ref()
+                .is_some_and(|picked| Arc::ptr_eq(&picked.0, &carrier));
+            drop(tcp);
+            client.shutdown().await;
+            let cancelled = matches!(Pin::new(&mut raw).poll_write(&mut cx, b"x"),
+                Poll::Ready(Err(error)) if error.kind() == io::ErrorKind::BrokenPipe);
+            drop((raw, command, commands, carrier, client));
+            let reclaimed = credit.available_permits();
+            let calls = peer.calls.load(Ordering::Acquire);
+            peer.stop().await;
+            (
+                write_pending,
+                full,
+                excluded,
+                tcp_active_reuse,
+                cancelled,
+                reclaimed,
+                calls,
+            )
+        })
+        .await;
+    assert!(probe.snapshot().is_idle());
+    assert!(
+        write_pending && full,
+        "real TCP command must hold the complete byte credit"
+    );
+    assert!(
+        excluded,
+        "a UDP business must not reuse the busy TCP business carrier"
+    );
+    assert!(
+        tcp_active_reuse,
+        "UDP carrier must retain same-business active reuse"
+    );
+    assert!(cancelled);
+    assert_eq!(reclaimed, CREDIT);
+    assert_eq!(calls, 0, "pool admission must not open any physical IO");
+}
+
+#[tokio::test]
+async fn udp_active_pool_keeps_the_original_fifo_credit_and_stop() {
+    let probe = ResourceProbe::default();
+    let outcome = probe
+        .scope(async {
+            let peer = Peer::new(false);
+            let mut settings = config(MieruHandshake::Standard);
+            settings.transport = MieruTransport::Udp;
+            settings.multiplexing = MieruMultiplexing::Low;
+            let client = Client::new(&settings, UpstreamPath::proxy(peer.clone()), CREDIT).unwrap();
+            let (carrier, mut commands) = install(&client, Business::UdpAssociate);
+            let credit = carrier.bytes.clone();
+            let (mut first, first_carrier) = pooled_stream(&client, Business::UdpAssociate, 2);
+            let (mut second, second_carrier) = pooled_stream(&client, Business::UdpAssociate, 3);
+            let (mut third, third_carrier) = pooled_stream(&client, Business::UdpAssociate, 4);
+            let same_carrier = Arc::ptr_eq(&first_carrier, &carrier)
+                && Arc::ptr_eq(&second_carrier, &carrier)
+                && Arc::ptr_eq(&third_carrier, &carrier);
+            drop((first_carrier, second_carrier, third_carrier));
+            let mut cx = Context::from_waker(futures_util::task::noop_waker_ref());
+            let first_admitted = matches!(
+                Pin::new(&mut first).poll_write(&mut cx, b"AAAAAAAA"),
+                Poll::Ready(Ok(8))
+            );
+            let second_admitted = matches!(
+                Pin::new(&mut second).poll_write(&mut cx, b"BBBBBBBB"),
+                Poll::Ready(Ok(8))
+            );
+            let full = credit.available_permits() == 0 && carrier.writer.capacity() == 0;
+            let blocked = Pin::new(&mut third).poll_write(&mut cx, b"C").is_pending();
+            let WriterCommand {
+                state,
+                data,
+                done,
+                _bytes,
+                ..
+            } = commands.try_recv().unwrap();
+            let fifo_first = state.id == 2 && data.as_ref() == b"AAAAAAAA";
+            done.send(Ok(())).unwrap(); // First send completes; retained payload credit does not.
+            let first_flushed = matches!(
+                Pin::new(&mut first).poll_flush(&mut cx),
+                Poll::Ready(Ok(()))
+            );
+            let still_blocked = Pin::new(&mut third).poll_write(&mut cx, b"C").is_pending()
+                && credit.available_permits() == 0;
+            drop((_bytes, state, data)); // Simulated actor retirement / ACK, not a fake extra queue.
+            let resumed = matches!(
+                Pin::new(&mut third).poll_write(&mut cx, b"C"),
+                Poll::Ready(Ok(1))
+            );
+            let queued_second = commands.try_recv().unwrap();
+            let queued_third = commands.try_recv().unwrap();
+            let fifo_rest = queued_second.state.id == 3
+                && queued_second.data.as_ref() == b"BBBBBBBB"
+                && queued_third.state.id == 4
+                && queued_third.data.as_ref() == b"C"
+                && credit.available_permits() == 7;
+            let flush_pending = Pin::new(&mut second).poll_flush(&mut cx).is_pending();
+            client.shutdown().await;
+            let stop_error = matches!(Pin::new(&mut second).poll_flush(&mut cx),
+                Poll::Ready(Err(error)) if error.kind() == io::ErrorKind::BrokenPipe);
+            drop((
+                first,
+                second,
+                third,
+                queued_second,
+                queued_third,
+                commands,
+                carrier,
+                client,
+            ));
+            let reclaimed = credit.available_permits();
+            let calls = peer.calls.load(Ordering::Acquire);
+            peer.stop().await;
+            (
+                same_carrier,
+                first_admitted,
+                second_admitted,
+                full,
+                blocked,
+                fifo_first,
+                first_flushed,
+                still_blocked,
+                resumed,
+                fifo_rest,
+                flush_pending,
+                stop_error,
+                reclaimed,
+                calls,
+            )
+        })
+        .await;
+    assert!(probe.snapshot().is_idle());
+    let (
+        same_carrier,
+        first_admitted,
+        second_admitted,
+        full,
+        blocked,
+        fifo_first,
+        first_flushed,
+        still_blocked,
+        resumed,
+        fifo_rest,
+        flush_pending,
+        stop_error,
+        reclaimed,
+        calls,
+    ) = outcome;
+    assert!(same_carrier && first_admitted && second_admitted);
+    assert!(full && blocked && fifo_first);
+    assert!(
+        first_flushed && still_blocked,
+        "first-send does not retire the original payload permits"
+    );
+    assert!(resumed && fifo_rest);
+    assert!(flush_pending && stop_error);
+    assert_eq!(reclaimed, CREDIT);
+    assert_eq!(
+        calls, 0,
+        "the real pool seam must remain entirely in memory"
+    );
+}
+
+// Two real registry carriers with controlled live State ownership; no IO or driver.
+fn install_counted(
+    client: &Client,
+    carrier_id: u64,
+    business: Business,
+    active: u32,
+) -> (Arc<Carrier>, mpsc::Receiver<WriterCommand>) {
+    let mut shared = Shared::output_test_shared(client.cancel.child_token());
+    let settings = Arc::get_mut(&mut shared).unwrap();
+    settings.udp = client.factory.config.transport == MieruTransport::Udp;
+    settings.business = client.pool(business);
+    for id in 1..=active {
+        let state = State::new(id, CREDIT, &shared.cancel, shared.activity.clone());
+        state.opened.store(true, Ordering::Release);
+        shared.sessions.lock().unwrap().insert(id, state);
+    }
+    let (writer, receiver) = mpsc::channel(WRITER_COMMANDS);
+    let carrier = Arc::new(Carrier {
+        shared,
+        writer,
+        bytes: Arc::new(Semaphore::new(CREDIT)),
+    });
+    client
+        .registry
+        .lock()
+        .unwrap()
+        .carriers
+        .insert(carrier_id, carrier.clone());
+    (carrier, receiver)
+}
+
+fn choose_bucket(
+    client: &Client,
+    business: Business,
+    bucket: usize,
+) -> (Option<Reservation>, usize) {
+    let mut observed_weight = 0;
+    let selected = client
+        .reserve_reusable(business, |weight| {
+            observed_weight = weight;
+            bucket
+        })
+        .unwrap();
+    (selected, observed_weight)
+}
+
+#[tokio::test]
+async fn least_load_uses_live_sessions_in_both_udp_low_pools() {
+    let probe = ResourceProbe::default();
+    let observed = probe
+        .scope(async {
+            let mut observed = Vec::new();
+            for business in [Business::TcpConnect, Business::UdpAssociate] {
+                let peer = Peer::new(false);
+                let mut settings = config(MieruHandshake::Standard);
+                settings.transport = MieruTransport::Udp;
+                settings.multiplexing = MieruMultiplexing::Low;
+                let client =
+                    Client::new(&settings, UpstreamPath::proxy(peer.clone()), CREDIT).unwrap();
+                let (busy, busy_rx) = install_counted(&client, 1, business, 3);
+                let (light, light_rx) = install_counted(&client, 2, business, 1);
+                // The sole two eligible carriers occupy the original two reuse buckets.
+                // Before GREEN, one bucket selects busy regardless of HashMap order.
+                for bucket in 0..2 {
+                    let (selected, weight) = choose_bucket(&client, business, bucket);
+                    observed.push((
+                        "selected fewer live sessions",
+                        weight == 2 && selected.as_ref().is_some_and(|r| Arc::ptr_eq(&r.0, &light)),
+                    ));
+                    drop(selected);
+                }
+                client.shutdown().await;
+                drop((client, busy, light, busy_rx, light_rx));
+                observed.push(("no physical IO", peer.calls.load(Ordering::Acquire) == 0));
+                peer.stop().await;
+            }
+            observed
+        })
+        .await;
+    assert!(probe.snapshot().is_idle());
+    for (name, passed) in observed {
+        assert!(passed, "{name}");
+    }
+}
+
+#[tokio::test]
+async fn least_load_counts_reservations_until_state_publication() {
+    let probe = ResourceProbe::default();
+    let observed = probe
+        .scope(async {
+            let peer = Peer::new(false);
+            let mut settings = config(MieruHandshake::Standard);
+            settings.transport = MieruTransport::Udp;
+            settings.multiplexing = MieruMultiplexing::Low;
+            let client = Client::new(&settings, UpstreamPath::proxy(peer.clone()), CREDIT).unwrap();
+            let (first, first_rx) = install_counted(&client, 1, Business::UdpAssociate, 1);
+            let (second, second_rx) = install_counted(&client, 2, Business::UdpAssociate, 1);
+            // Establish the pending owner through the production picker, not a fake counter.
+            let (held, _) = choose_bucket(&client, Business::UdpAssociate, 0);
+            let held = held.unwrap();
+            let other = if Arc::ptr_eq(&held.0, &first) {
+                second.clone()
+            } else {
+                first.clone()
+            };
+            let mut observed = Vec::new();
+            for bucket in 0..2 {
+                let (selected, weight) = choose_bucket(&client, Business::UdpAssociate, bucket);
+                observed.push((
+                    "pending reservation changes admission",
+                    weight == 2 && selected.as_ref().is_some_and(|r| Arc::ptr_eq(&r.0, &other)),
+                ));
+                drop(selected);
+            }
+            // Match open(): publish a State before dropping the corresponding reservation.
+            let published = State::new(
+                2,
+                CREDIT,
+                &held.0.shared.cancel,
+                held.0.shared.activity.clone(),
+            );
+            held.0.shared.sessions.lock().unwrap().insert(2, published);
+            drop(held);
+            for bucket in 0..2 {
+                let (selected, weight) = choose_bucket(&client, Business::UdpAssociate, bucket);
+                observed.push((
+                    "published state keeps the load",
+                    weight == 2 && selected.as_ref().is_some_and(|r| Arc::ptr_eq(&r.0, &other)),
+                ));
+                drop(selected);
+            }
+            client.shutdown().await;
+            drop((client, first, second, first_rx, second_rx, other));
+            observed.push(("no physical IO", peer.calls.load(Ordering::Acquire) == 0));
+            peer.stop().await;
+            observed
+        })
+        .await;
+    assert!(probe.snapshot().is_idle());
+    for (name, passed) in observed {
+        assert!(passed, "{name}");
+    }
+}
+
+#[tokio::test]
+async fn least_load_keeps_random_ties_new_bucket_and_other_modes() {
+    let probe = ResourceProbe::default();
+    let observed = probe
+        .scope(async {
+            let mut observed = Vec::new();
+            for (transport, level, business, tied) in [
+                (
+                    MieruTransport::Udp,
+                    MieruMultiplexing::Low,
+                    Business::UdpAssociate,
+                    true,
+                ),
+                (
+                    MieruTransport::Udp,
+                    MieruMultiplexing::Low,
+                    Business::TcpConnect,
+                    true,
+                ),
+                (
+                    MieruTransport::Tcp,
+                    MieruMultiplexing::Low,
+                    Business::UdpAssociate,
+                    false,
+                ),
+                (
+                    MieruTransport::Tcp,
+                    MieruMultiplexing::Middle,
+                    Business::TcpConnect,
+                    false,
+                ),
+                (
+                    MieruTransport::Tcp,
+                    MieruMultiplexing::High,
+                    Business::TcpConnect,
+                    false,
+                ),
+                (
+                    MieruTransport::Udp,
+                    MieruMultiplexing::Middle,
+                    Business::TcpConnect,
+                    false,
+                ),
+                (
+                    MieruTransport::Udp,
+                    MieruMultiplexing::High,
+                    Business::TcpConnect,
+                    false,
+                ),
+                (
+                    MieruTransport::Tcp,
+                    MieruMultiplexing::Off,
+                    Business::TcpConnect,
+                    false,
+                ),
+                (
+                    MieruTransport::Udp,
+                    MieruMultiplexing::Off,
+                    Business::TcpConnect,
+                    false,
+                ),
+            ] {
+                let peer = Peer::new(false);
+                let mut settings = config(MieruHandshake::Standard);
+                settings.transport = transport;
+                settings.multiplexing = level;
+                let client =
+                    Client::new(&settings, UpstreamPath::proxy(peer.clone()), CREDIT).unwrap();
+                let (first, first_rx) =
+                    install_counted(&client, 1, business, if tied { 1 } else { 3 });
+                let (second, second_rx) = install_counted(&client, 2, business, 1);
+                // Both constructed carriers are eligible, with no disable/close flags.
+                // Registry iteration gives the original bucket order; no sorting/filter copy.
+                let order: Vec<_> = client
+                    .registry
+                    .lock()
+                    .unwrap()
+                    .carriers
+                    .values()
+                    .cloned()
+                    .collect();
+                if level == MieruMultiplexing::Off {
+                    let (selected, weight) = choose_bucket(&client, business, 0);
+                    observed.push(("OFF always new", weight == 0 && selected.is_none()));
+                    drop(selected);
+                } else {
+                    for (index, expected) in order.iter().enumerate() {
+                        let (selected, weight) =
+                            choose_bucket(&client, business, index * client.factor);
+                        observed.push((
+                            "original tie or unaffected bucket",
+                            weight == 2 * client.factor
+                                && selected
+                                    .as_ref()
+                                    .is_some_and(|r| Arc::ptr_eq(&r.0, expected)),
+                        ));
+                        drop(selected);
+                    }
+                    let (selected, weight) = choose_bucket(&client, business, 2 * client.factor);
+                    observed.push((
+                        "original new-carrier bucket",
+                        weight == 2 * client.factor && selected.is_none(),
+                    ));
+                    drop(selected);
+                }
+                client.shutdown().await;
+                drop((client, first, second, first_rx, second_rx, order));
+                observed.push(("no physical IO", peer.calls.load(Ordering::Acquire) == 0));
+                peer.stop().await;
+            }
+            observed
+        })
+        .await;
+    assert!(probe.snapshot().is_idle());
+    for (name, passed) in observed {
+        assert!(passed, "{name}");
+    }
+}
diff --git a/src/outbound/mieru/udp_send_credit_memory_tests.rs b/src/outbound/mieru/udp_send_credit_memory_tests.rs
new file mode 100644
index 0000000..db02857
--- /dev/null
+++ b/src/outbound/mieru/udp_send_credit_memory_tests.rs
@@ -0,0 +1,252 @@
+//! Actual Client::create over an owned in-memory DatagramTransport, then RawStream.
+//! No server/framing implementation, sockets, DNS, listeners or network resources.
+use super::super::tests::{Peer, config, session};
+use super::*;
+use crate::{
+    dispatch::{DatagramTransport, DispatchError},
+    outbound::{ConnectedStream, DatagramRequest, OutboundConnector},
+    resources::observation::ResourceProbe,
+    session::Datagram,
+};
+use async_trait::async_trait;
+
+#[derive(Default)]
+struct Counts {
+    opened: AtomicUsize,
+    closed: AtomicUsize,
+    dropped: AtomicUsize,
+}
+#[derive(Default)]
+struct MemoryPeer {
+    counts: Arc<Counts>,
+}
+struct MemoryDatagram {
+    counts: Arc<Counts>,
+    closed: bool,
+}
+#[async_trait]
+impl DatagramTransport for MemoryDatagram {
+    fn supports_shared_destinations(&self) -> bool {
+        false
+    }
+    async fn send(&mut self, _: Datagram) -> Result<(), DispatchError> {
+        Ok(())
+    }
+    async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+        std::future::pending().await
+    }
+    async fn close(&mut self) -> Result<(), DispatchError> {
+        assert!(
+            !self.closed,
+            "the actual carrier must close its transport once"
+        );
+        self.closed = true;
+        self.counts.closed.fetch_add(1, Ordering::AcqRel);
+        Ok(())
+    }
+}
+impl Drop for MemoryDatagram {
+    fn drop(&mut self) {
+        self.counts.dropped.fetch_add(1, Ordering::AcqRel);
+    }
+}
+#[async_trait]
+impl OutboundConnector for MemoryPeer {
+    async fn connect_stream(
+        &self,
+        _: StreamSession,
+        _: &EstablishContext,
+    ) -> Result<ConnectedStream, DispatchError> {
+        Err(DispatchError::NotAllowed)
+    }
+    async fn open_datagram(
+        &self,
+        _: DatagramRequest,
+        _: &EstablishContext,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        self.counts.opened.fetch_add(1, Ordering::AcqRel);
+        Ok(Box::new(MemoryDatagram {
+            counts: self.counts.clone(),
+            closed: false,
+        }))
+    }
+}
+fn settings(multiplexing: MieruMultiplexing) -> MieruOutboundConfig {
+    let mut settings = config(crate::config::MieruHandshake::Standard);
+    settings.address = "192.0.2.1".into(); // Actual setup resolves this literal locally.
+    settings.transport = MieruTransport::Udp;
+    settings.multiplexing = multiplexing;
+    settings
+}
+fn assert_joined(counts: &Counts, expected: usize) {
+    assert_eq!(counts.opened.load(Ordering::Acquire), expected);
+    assert_eq!(counts.closed.load(Ordering::Acquire), expected);
+    assert_eq!(counts.dropped.load(Ordering::Acquire), expected);
+}
+
+#[tokio::test(start_paused = true)]
+async fn mieru_udp_send_credit96_actual_factory_preserves_scope_and_nondefault_budgets() {
+    let probe = ResourceProbe::default();
+    probe
+        .scope(async {
+            assert!(98304 <= Semaphore::MAX_PERMITS);
+            for (mode, business, capacity, expected) in [
+                (MieruMultiplexing::Low, Business::UdpAssociate, 32768, 98304),
+                (MieruMultiplexing::Low, Business::TcpConnect, 32768, 32768),
+                (MieruMultiplexing::Low, Business::UdpAssociate, 1, 1),
+                (MieruMultiplexing::Low, Business::UdpAssociate, 16, 16),
+                (MieruMultiplexing::Low, Business::UdpAssociate, 32767, 32767),
+                (MieruMultiplexing::Low, Business::UdpAssociate, 32769, 32769),
+                (MieruMultiplexing::Low, Business::UdpAssociate, 65536, 65536),
+                (MieruMultiplexing::Off, Business::UdpAssociate, 32768, 32768),
+                (
+                    MieruMultiplexing::Middle,
+                    Business::UdpAssociate,
+                    32768,
+                    32768,
+                ),
+                (
+                    MieruMultiplexing::High,
+                    Business::UdpAssociate,
+                    32768,
+                    32768,
+                ),
+            ] {
+                let peer = Arc::new(MemoryPeer::default());
+                let client =
+                    Client::new(&settings(mode), UpstreamPath::proxy(peer.clone()), capacity)
+                        .unwrap();
+                let context = EstablishContext::with_timeout(Duration::from_secs(1));
+                let reservation = client.create(session(), business, &context).await.unwrap();
+                let carrier = reservation.0.clone();
+                assert_eq!(carrier.bytes.available_permits(), expected);
+                assert_eq!(carrier.writer.max_capacity(), 2);
+                assert_eq!(
+                    client.capacity, capacity,
+                    "the original SID/chunk budget is retained"
+                );
+                drop(reservation);
+                client.shutdown().await;
+                assert!(client.registry.lock().unwrap().carriers.is_empty());
+                drop((carrier, client));
+                assert_joined(&peer.counts, 1);
+            }
+            // Physical TCP creates its real original memory stream carrier as a control.
+            for business in [Business::TcpConnect, Business::UdpAssociate] {
+                let peer = Peer::new(false);
+                let mut settings = config(crate::config::MieruHandshake::Standard);
+                settings.multiplexing = MieruMultiplexing::Low;
+                let client =
+                    Client::new(&settings, UpstreamPath::proxy(peer.clone()), 32768).unwrap();
+                let context = EstablishContext::with_timeout(Duration::from_secs(1));
+                let reservation = client.create(session(), business, &context).await.unwrap();
+                let carrier = reservation.0.clone();
+                assert_eq!(carrier.bytes.available_permits(), 32768);
+                drop(reservation);
+                client.shutdown().await;
+                drop((carrier, client));
+                peer.stop().await;
+            }
+        })
+        .await;
+    assert!(probe.snapshot().is_idle());
+}
+
+#[tokio::test(start_paused = true)]
+async fn mieru_udp_send_credit96_actual_carrier_two_sids_share_credit_fifo_and_stop() {
+    let probe = ResourceProbe::default();
+    probe
+        .scope(async {
+            let peer = Arc::new(MemoryPeer::default());
+            let client = Client::new(
+                &settings(MieruMultiplexing::Low),
+                UpstreamPath::proxy(peer.clone()),
+                32768,
+            )
+            .unwrap();
+            let context = EstablishContext::with_timeout(Duration::from_secs(1));
+            let reservation = client
+                .create(session(), Business::UdpAssociate, &context)
+                .await
+                .unwrap();
+            let carrier = reservation.0.clone();
+            let credit = carrier.bytes.clone();
+            drop(reservation);
+            let mut streams = Vec::new();
+            let mut states = Vec::new();
+            for id in [7, 8] {
+                // Assemble the exact post-reservation State/RawStream ownership from open().
+                let state = State::new_for_business(
+                    id,
+                    client.capacity,
+                    Business::UdpAssociate,
+                    &carrier.shared.cancel,
+                    carrier.shared.activity.clone(),
+                );
+                carrier
+                    .shared
+                    .sessions
+                    .lock()
+                    .unwrap()
+                    .insert(id, state.clone());
+                streams.push(
+                    RawStream::new(carrier.clone(), state.clone(), client.capacity)
+                        .with_queued_writes(true),
+                );
+                states.push(state);
+            }
+            let mut cx = Context::from_waker(futures_util::task::noop_waker_ref());
+            let first = vec![b'A'; 32768];
+            let second = vec![b'B'; 32768];
+            // No await between setup and Stop: the single-thread executor cannot consume
+            // these two FIFO entries before the shared-credit assertions below.
+            assert!(matches!(
+                Pin::new(&mut streams[0]).poll_write(&mut cx, &first),
+                Poll::Ready(Ok(32768))
+            ));
+            assert!(
+                matches!(
+                    Pin::new(&mut streams[1]).poll_write(&mut cx, &second),
+                    Poll::Ready(Ok(32768))
+                ),
+                "a second SID must use the same carrier's shared credit"
+            );
+            assert_eq!(credit.available_permits(), 32768);
+            assert_eq!(carrier.writer.max_capacity(), 2);
+            assert_eq!(carrier.writer.capacity(), 0);
+            assert_eq!(states[0].receive_bytes.available_permits(), 32768);
+            assert_eq!(states[1].receive_bytes.available_permits(), 32768);
+            assert!(
+                Pin::new(&mut streams[1])
+                    .poll_write(&mut cx, b"C")
+                    .is_pending()
+            );
+            // FIFO2, not byte-credit exhaustion, blocks this third write.
+            // Its one-byte permit remains owned inside the original pending send.
+            assert_eq!(credit.available_permits(), 32767);
+            assert!(Pin::new(&mut streams[0]).poll_flush(&mut cx).is_pending());
+            let selected = client
+                .reserve_reusable(Business::UdpAssociate, |_| 0)
+                .unwrap()
+                .unwrap();
+            assert!(Arc::ptr_eq(&selected.0, &carrier));
+            drop(selected);
+            assert!(
+                client
+                    .reserve_reusable(Business::TcpConnect, |_| 0)
+                    .unwrap()
+                    .is_none()
+            );
+            client.begin_shutdown();
+            client.shutdown().await;
+            for stream in &mut streams {
+                assert!(matches!(Pin::new(stream).poll_flush(&mut cx),
+                Poll::Ready(Err(error)) if error.kind() == io::ErrorKind::BrokenPipe));
+            }
+            drop((streams, states, carrier, client));
+            assert_eq!(credit.available_permits(), 98304);
+            assert_joined(&peer.counts, 1);
+        })
+        .await;
+    assert!(probe.snapshot().is_idle());
+}
diff --git a/src/outbound/mieru/udp_split_receive_tests.rs b/src/outbound/mieru/udp_split_receive_tests.rs
new file mode 100644
index 0000000..64ecd32
--- /dev/null
+++ b/src/outbound/mieru/udp_split_receive_tests.rs
@@ -0,0 +1,879 @@
+#[cfg(test)]
+mod split_receive_tests {
+    use super::*;
+    use crate::{
+        config::{MieruHandshake, MieruMultiplexing},
+        dispatch::DispatchError,
+        outbound::{ConnectedStream, OutboundConnector},
+        resources::observation::ResourceProbe,
+    };
+    use async_trait::async_trait;
+    use std::sync::atomic::AtomicBool;
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+    const CAPACITY: usize = 32768;
+    const CHUNK: usize = 1312;
+
+    fn failed(message: &'static str) -> io::Error {
+        io::Error::other(message)
+    }
+
+    struct Packets {
+        incoming: mpsc::Receiver<Datagram>,
+        sent: mpsc::Sender<Metadata>,
+        received: Arc<AtomicUsize>,
+        closed: Arc<AtomicBool>,
+        decoder: PacketDecoder,
+        delay_after_close_reply: Duration,
+        hold_until: Option<Instant>,
+    }
+
+    #[async_trait]
+    impl DatagramTransport for Packets {
+        fn supports_shared_destinations(&self) -> bool {
+            false
+        }
+
+        fn payload_budget(&self, _: &Destination) -> DatagramBudget {
+            DatagramBudget::new(MTU, MTU)
+        }
+
+        async fn send(&mut self, packet: Datagram) -> Result<(), DispatchError> {
+            let frame = self
+                .decoder
+                .decode_frame(packet.payload, super::super::tcp::now().unwrap())
+                .map_err(|_| DispatchError::NotAllowed)?;
+            if matches!(frame.metadata, Metadata::Session(meta)
+                if meta.kind == SessionKind::CloseResponse)
+                && self.hold_until.is_none()
+                && !self.delay_after_close_reply.is_zero()
+            {
+                // First response alone activates the test physical Pending edge.
+                self.hold_until = Some(Instant::now() + self.delay_after_close_reply);
+            }
+            self.sent
+                .try_send(frame.metadata)
+                .map_err(|_| DispatchError::NotAllowed)
+        }
+
+        async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+            if let Some(until) = self.hold_until {
+                // Pending cancellation retains the same prequeued DATA.
+                tokio::time::sleep_until(until).await;
+            }
+            let packet = self
+                .incoming
+                .recv()
+                .await
+                .ok_or(DispatchError::NotAllowed)?;
+            self.received.fetch_add(1, Ordering::AcqRel);
+            Ok(packet)
+        }
+
+        async fn close(&mut self) -> Result<(), DispatchError> {
+            self.closed.store(true, Ordering::Release);
+            Ok(())
+        }
+    }
+
+    struct Peer {
+        incoming: Mutex<Option<mpsc::Receiver<Datagram>>>,
+        sent: mpsc::Sender<Metadata>,
+        received: Arc<AtomicUsize>,
+        closed: Arc<AtomicBool>,
+        delay_after_close_reply: Duration,
+    }
+
+    #[async_trait]
+    impl OutboundConnector for Arc<Peer> {
+        async fn connect_stream(
+            &self,
+            _: StreamSession,
+            _: &EstablishContext,
+        ) -> Result<ConnectedStream, DispatchError> {
+            Err(DispatchError::NotAllowed)
+        }
+
+        async fn open_datagram(
+            &self,
+            _: DatagramRequest,
+            _: &EstablishContext,
+        ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+            let incoming = self
+                .incoming
+                .lock()
+                .unwrap()
+                .take()
+                .ok_or(DispatchError::NotAllowed)?;
+            let key = crypto::derive_packet_key(
+                "vole",
+                "fixture-password",
+                super::super::tcp::now().map_err(|_| DispatchError::NotAllowed)?,
+            );
+            Ok(Box::new(Packets {
+                incoming,
+                sent: self.sent.clone(),
+                received: self.received.clone(),
+                closed: self.closed.clone(),
+                decoder: PacketDecoder::new(&key, false).map_err(|_| DispatchError::NotAllowed)?,
+                delay_after_close_reply: self.delay_after_close_reply,
+                hold_until: None,
+            }))
+        }
+    }
+
+    struct Fixture {
+        node: super::super::MieruOutbound,
+        raw: Option<super::super::stream::RawStream>,
+        state: Arc<State>,
+        capacity: usize,
+        incoming: mpsc::Sender<Datagram>,
+        sent: mpsc::Receiver<Metadata>,
+        closed: Arc<AtomicBool>,
+        encoder: PacketEncoder,
+        remote: Destination,
+    }
+
+    impl Fixture {
+        async fn new(capacity: usize) -> io::Result<Self> {
+            Self::with_close_gate(capacity, super::super::tcp::Business::TcpConnect, Duration::ZERO).await
+        }
+        async fn with_close_gate(
+            capacity: usize,
+            business: super::super::tcp::Business,
+            delay_after_close_reply: Duration,
+        ) -> io::Result<Self> {
+            let (incoming, packets) = mpsc::channel(64);
+            let (sent, observations) = mpsc::channel(128);
+            let received = Arc::new(AtomicUsize::new(0));
+            let closed = Arc::new(AtomicBool::new(false));
+            let peer = Arc::new(Peer {
+                incoming: Mutex::new(Some(packets)),
+                sent,
+                received: received.clone(),
+                closed: closed.clone(),
+                delay_after_close_reply,
+            });
+            let mut config = super::super::tests::config(MieruHandshake::NoWait);
+            config.address = "192.0.2.1".into();
+            config.port = 2000;
+            config.port_end = 2000;
+            config.transport = MieruTransport::Udp;
+            config.multiplexing = MieruMultiplexing::Off;
+            let node = super::super::MieruOutbound::new(
+                &config,
+                UpstreamPath::proxy(Arc::new(peer)),
+                capacity,
+            )?;
+            let context = EstablishContext::with_timeout(Duration::from_secs(1));
+            let raw = match node
+                .client
+                .open(
+                    super::super::tests::session(),
+                    business,
+                    None,
+                    &context,
+                )
+                .await
+            {
+                Ok(raw) => raw,
+                Err(error) => {
+                    node.shutdown().await;
+                    return Err(error);
+                }
+            };
+            let state = raw.state.clone();
+            let key = crypto::derive_packet_key(
+                "vole",
+                "fixture-password",
+                super::super::tcp::now()?,
+            );
+            Ok(Self {
+                node,
+                raw: Some(raw),
+                state,
+                capacity,
+                incoming,
+                sent: observations,
+                closed,
+                encoder: PacketEncoder::new(&key, false)?,
+                remote: Destination::Ip("192.0.2.1:2000".parse().unwrap()),
+            })
+        }
+
+        fn inject(&mut self, metadata: Metadata, payload: &[u8]) -> io::Result<()> {
+            let mut bytes = Vec::new();
+            self.encoder.encode_frame(
+                metadata,
+                payload,
+                super::super::wire::Padding {
+                    prefix: &[],
+                    suffix: &[],
+                },
+                rand::random(),
+                super::super::tcp::now()?,
+                &mut bytes,
+            )?;
+            self.incoming
+                .try_send(Datagram {
+                    remote: self.remote.clone(),
+                    payload: Bytes::from(bytes),
+                    sniffed_domain: None,
+                })
+                .map_err(|_| failed("bounded test input is full or closed"))
+        }
+
+        fn data(&mut self, sequence: u32) -> io::Result<()> {
+            self.inject(
+                Metadata::Data(DataMetadata {
+                    kind: DataKind::ServerData,
+                    session_id: self.state.id,
+                    sequence,
+                    unack_sequence: 1,
+                    window: 64,
+                    fragment: 0,
+                }),
+                &vec![sequence as u8; CHUNK],
+            )
+        }
+
+        async fn ack(&mut self, prefix: u32, window: Option<u16>) -> io::Result<u16> {
+            tokio::time::timeout(Duration::from_millis(200), async {
+                while let Some(metadata) = self.sent.recv().await {
+                    if matches!(metadata, Metadata::Data(meta)
+                        if meta.kind == DataKind::ClientAck
+                            && meta.unack_sequence == prefix && window.is_none_or(|window| meta.window == window))
+                    {
+                        if let Metadata::Data(meta) = metadata {
+                            return Ok(meta.window);
+                        }
+                    }
+                }
+                Err(failed("driver output ended before the expected ACK"))
+            })
+            .await
+            .map_err(|_| failed("expected cumulative ACK did not arrive"))?
+        }
+
+        async fn bootstrap(&mut self) -> io::Result<()> {
+            self.raw.as_mut().unwrap().write_all(&[0x71]).await?;
+            let open = tokio::time::timeout(Duration::from_millis(200), self.sent.recv())
+                .await
+                .map_err(|_| failed("open request did not arrive"))?
+                .ok_or_else(|| failed("driver output closed before open request"))?;
+            if !matches!(open, Metadata::Session(meta)
+                if meta.kind == SessionKind::OpenRequest && meta.session_id == self.state.id)
+            {
+                return Err(failed("first output is not this session's open request"));
+            }
+            self.inject(
+                Metadata::Session(SessionMetadata {
+                    kind: SessionKind::OpenResponse,
+                    session_id: self.state.id,
+                    sequence: 0,
+                    status: 0,
+                }),
+                &[],
+            )?;
+            self.inject(
+                Metadata::Data(DataMetadata {
+                    kind: DataKind::ServerAck,
+                    session_id: self.state.id,
+                    sequence: 0,
+                    unack_sequence: 1,
+                    window: 64,
+                    fragment: 0,
+                }),
+                &[],
+            )?;
+            self.ack(
+                1,
+                Some(if self.capacity < CHUNK {
+                    1
+                } else {
+                    (self.capacity / CHUNK) as u16
+                }),
+            )
+            .await?;
+            Ok(())
+        }
+
+        fn data_bytes(&mut self, sequence: u32, payload: &[u8]) -> io::Result<()> {
+            self.inject(
+                Metadata::Data(DataMetadata {
+                    kind: DataKind::ServerData,
+                    session_id: self.state.id,
+                    sequence,
+                    unack_sequence: 1,
+                    window: 64,
+                    fragment: 0,
+                }),
+                payload,
+            )
+        }
+        async fn fill_app(&mut self) -> io::Result<Vec<u8>> {
+            let mut expected = Vec::new();
+            for sequence in 1..=24 {
+                self.data(sequence)?;
+                expected.extend(std::iter::repeat_n(sequence as u8, CHUNK));
+            }
+            let last = vec![25; CAPACITY - 24 * CHUNK];
+            self.data_bytes(25, &last)?;
+            expected.extend(last);
+            self.ack(26, None).await?;
+            if self.state.next_receive.load(Ordering::Acquire) != 26
+                || self.state.receive_bytes.available_permits() != 0
+            {
+                return Err(failed("authenticated DATA did not fill app capacity"));
+            }
+            Ok(expected)
+        }
+        fn remote_close(&mut self, sequence: u32) -> io::Result<()> {
+            self.inject(
+                Metadata::Session(SessionMetadata {
+                    kind: SessionKind::CloseRequest,
+                    session_id: self.state.id,
+                    sequence,
+                    status: 0,
+                }),
+                &[],
+            )
+        }
+        async fn close_reply(&mut self) -> io::Result<()> {
+            tokio::time::timeout(Duration::from_millis(200), async {
+                while let Some(metadata) = self.sent.recv().await {
+                    if matches!(metadata, Metadata::Session(meta) if meta.kind == SessionKind::CloseResponse) {
+                        return Ok(());
+                    }
+                }
+                Err(failed("driver ended before responding to Close"))
+            })
+            .await
+            .map_err(|_| failed("Close was not consumed before app reads"))?
+        }
+        async fn stop(&mut self) -> io::Result<()> {
+            self.node.begin_shutdown();
+            tokio::time::timeout(Duration::from_secs(1), self.node.shutdown())
+                .await
+                .map_err(|_| failed("driver Stop waited for unread app credit"))?;
+            self.raw.take();
+            if !self.closed.load(Ordering::Acquire)
+                || self.state.receive_bytes.available_permits() != self.capacity
+            {
+                return Err(failed(
+                    "Stop did not close transport or stream release did not refund credit",
+                ));
+            }
+            Ok(())
+        }
+    }
+
+    struct Wire {
+        encoder: PacketEncoder,
+        decoder: PacketDecoder,
+        unix: u64,
+        nonce: u64,
+    }
+    impl Wire {
+        fn new() -> Self {
+            let unix = super::super::tcp::now().unwrap();
+            let key = crypto::derive_packet_key("vole", "fixture-password", unix);
+            Self {
+                encoder: PacketEncoder::new(&key, false).unwrap(),
+                decoder: PacketDecoder::new(&key, false).unwrap(),
+                unix,
+                nonce: 0,
+            }
+        }
+        fn input(
+            &mut self,
+            reliable: &mut Reliable,
+            partial: &mut Option<Partial>,
+            metadata: Metadata,
+            payload: &[u8],
+        ) -> Bytes {
+            self.nonce += 1;
+            let mut nonce = [0; 24];
+            nonce[..8].copy_from_slice(&self.nonce.to_be_bytes());
+            let mut packet = Vec::new();
+            self.encoder
+                .encode_frame(
+                    metadata,
+                    payload,
+                    super::super::wire::Padding::default(),
+                    nonce,
+                    self.unix,
+                    &mut packet,
+                )
+                .unwrap();
+            let frame = self
+                .decoder
+                .decode_frame(Bytes::from(packet), self.unix)
+                .unwrap();
+            let owner = frame.payload.clone();
+            reliable.input(frame, Instant::now(), partial);
+            owner
+        }
+        fn data(
+            &mut self,
+            reliable: &mut Reliable,
+            partial: &mut Option<Partial>,
+            sequence: u32,
+            payload: &[u8],
+        ) -> Bytes {
+            self.input(
+                reliable,
+                partial,
+                Metadata::Data(DataMetadata {
+                    kind: DataKind::ServerData,
+                    session_id: 1,
+                    sequence,
+                    unack_sequence: 0,
+                    window: 64,
+                    fragment: 0,
+                }),
+                payload,
+            )
+        }
+    }
+    fn content(first: u32, end: u32) -> Vec<u8> {
+        (first..end)
+            .flat_map(|sequence| std::iter::repeat_n(sequence as u8, CHUNK))
+            .collect()
+    }
+    fn read_exact(state: &State, expected: &[u8]) {
+        let mut actual = Vec::with_capacity(expected.len());
+        let waker = futures_util::task::noop_waker();
+        let mut cx = std::task::Context::from_waker(&waker);
+        while actual.len() < expected.len() {
+            let mut storage = [0; 257];
+            let len = (expected.len() - actual.len()).min(storage.len());
+            let mut read = tokio::io::ReadBuf::new(&mut storage[..len]);
+            assert!(matches!(
+                state.poll_read(&mut cx, &mut read),
+                std::task::Poll::Ready(Ok(()))
+            ));
+            assert!(!read.filled().is_empty());
+            actual.extend_from_slice(read.filled());
+        }
+        assert_eq!(actual, expected);
+    }
+    fn direct_prefix_proof() {
+        let cancellation = tokio_util::sync::CancellationToken::new();
+        let state = State::new(
+            1,
+            CAPACITY,
+            &cancellation,
+            Arc::new(tokio::sync::Notify::new()),
+        );
+        let mut reliable = Reliable::new(state.clone(), CHUNK);
+        let receive_pool = reliable.reorder_bytes.clone();
+        assert_eq!(receive_pool.available_permits(), 2 * CAPACITY);
+        let mut partial = None;
+        let mut wire = Wire::new();
+        wire.input(
+            &mut reliable,
+            &mut partial,
+            Metadata::Session(SessionMetadata {
+                kind: SessionKind::OpenResponse,
+                session_id: 1,
+                sequence: 0,
+                status: 0,
+            }),
+            &[],
+        );
+        for sequence in 1..=24 {
+            wire.data(
+                &mut reliable,
+                &mut partial,
+                sequence,
+                &vec![sequence as u8; CHUNK],
+            );
+        }
+        let mut app_content = content(1, 25);
+        let last = vec![25; CAPACITY - 24 * CHUNK];
+        wire.data(&mut reliable, &mut partial, 25, &last);
+        app_content.extend(last);
+        assert_eq!(state.receive_bytes.available_permits(), 0);
+        // Fill the new 64KiB reorder pool up to its reserved head slot:
+        // 48 full future frames + one 1248-byte tail = 64,224 bytes.
+        for sequence in 50..=97 {
+            wire.data(
+                &mut reliable,
+                &mut partial,
+                sequence,
+                &vec![sequence as u8; CHUNK],
+            );
+        }
+        let far_owner = wire.data(&mut reliable, &mut partial, 98, &[98; 1248]);
+        assert_eq!(reliable.reorder.len(), 49);
+        assert_eq!(receive_pool.available_permits(), CHUNK);
+        assert_eq!(state.unread_bytes(), CAPACITY);
+        assert!(
+            (2 * CAPACITY - receive_pool.available_permits()) + state.unread_bytes()
+                <= 3 * CAPACITY
+        );
+        wire.data(&mut reliable, &mut partial, 30, &[30; CHUNK]);
+        let head_owner = wire.data(&mut reliable, &mut partial, 26, &[26; CHUNK]);
+        // The authenticated head stays retained until app transfer can commit.
+        assert!(reliable.reorder.contains_key(&26));
+        assert_eq!(state.next_receive.load(Ordering::Acquire), 26);
+        assert_eq!(state.receive_bytes.available_permits(), 0);
+        assert!(far_owner.is_unique());
+        drop(far_owner);
+        assert!(!head_owner.is_unique());
+        for sequence in 27..=29 {
+            wire.data(
+                &mut reliable,
+                &mut partial,
+                sequence,
+                &vec![sequence as u8; CHUNK],
+            );
+        }
+        // Duplicate content must not overwrite the retained nearer prefix.
+        wire.data(&mut reliable, &mut partial, 30, &[0xfe; CHUNK]);
+        for sequence in 31..=48 {
+            wire.data(
+                &mut reliable,
+                &mut partial,
+                sequence,
+                &vec![sequence as u8; CHUNK],
+            );
+        }
+        assert_eq!(reliable.reorder.len(), 48);
+        assert_eq!(receive_pool.available_permits(), 2 * CAPACITY - 48 * CHUNK);
+        for sequence in 26..=48 {
+            assert!(reliable.reorder.contains_key(&sequence));
+        }
+        for sequence in 50..=74 {
+            assert!(reliable.reorder.contains_key(&sequence));
+        }
+        assert!(!reliable.reorder.contains_key(&49));
+        let far_survivor = reliable.reorder.get(&50).unwrap().frame.payload.clone();
+        assert!(!far_survivor.is_unique());
+        assert_eq!(state.next_receive.load(Ordering::Acquire), 26);
+        let retained = reliable
+            .reorder
+            .values()
+            .map(|inbound| inbound.frame.payload.len())
+            .sum::<usize>();
+        assert!(retained <= 2 * CAPACITY);
+        assert!(retained + CAPACITY - state.receive_bytes.available_permits() <= 3 * CAPACITY);
+        read_exact(&state, &app_content);
+        assert_eq!(state.receive_bytes.available_permits(), CAPACITY);
+        reliable.deliver_contiguous();
+        assert_eq!(state.next_receive.load(Ordering::Acquire), 49);
+        // The nearer prefix is committed, but seq49 still separates the
+        // retained far DATA from the app. It must survive without delivery.
+        assert_eq!(reliable.reorder.len(), 25);
+        assert_eq!(receive_pool.available_permits(), 2 * CAPACITY - 25 * CHUNK);
+        read_exact(&state, &content(26, 49));
+        assert_eq!(state.receive_bytes.available_permits(), CAPACITY);
+        assert!(!reliable.deliver_contiguous());
+        assert_eq!(state.next_receive.load(Ordering::Acquire), 49);
+        let waker = futures_util::task::noop_waker();
+        let mut cx = std::task::Context::from_waker(&waker);
+        let mut storage = [0; CHUNK];
+        let mut read = tokio::io::ReadBuf::new(&mut storage);
+        assert!(matches!(
+            state.poll_read(&mut cx, &mut read),
+            std::task::Poll::Pending
+        ));
+        assert!(!far_survivor.is_unique());
+        assert!(head_owner.is_unique());
+        drop(head_owner);
+        assert!(partial.is_none());
+        state.close();
+        drop(reliable);
+        assert_eq!(state.receive_bytes.available_permits(), CAPACITY);
+        assert_eq!(receive_pool.available_permits(), 2 * CAPACITY);
+        assert!(far_survivor.is_unique());
+        drop(far_survivor);
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn mieru_split_receive_protects_prefix_and_commits_ack_after_app_transfer() {
+        let probe = ResourceProbe::default();
+        let result: io::Result<()> = probe
+            .scope(async {
+                direct_prefix_proof();
+                let mut fixture = Fixture::new(CAPACITY).await?;
+                let result = async {
+                    fixture.bootstrap().await?;
+                    let mut expected = fixture.fill_app().await?;
+                    fixture.data_bytes(26, &[26; 40])?;
+                    fixture.data_bytes(27, &[27; 40])?;
+                    fixture.ack(26, None).await?;
+                    if fixture.state.next_receive.load(Ordering::Acquire) != 26
+                        || fixture.state.receive_bytes.available_permits() != 0
+                    {
+                        return Err(failed("cumulative ACK moved before app enqueue"));
+                    }
+                    let mut first = [0; 40];
+                    fixture.raw.as_mut().unwrap().read_exact(&mut first).await?;
+                    if first != [1; 40] {
+                        return Err(failed("first app bytes changed"));
+                    }
+                    // No new peer input follows the read. The real driver must
+                    // commit seq26 and ACK it even though RX window stays at24.
+                    fixture.ack(27, Some(24)).await?;
+                    if fixture.state.next_receive.load(Ordering::Acquire) != 27 {
+                        return Err(failed(
+                            "driver did not retry app transfer on reader activity",
+                        ));
+                    }
+                    expected.extend_from_slice(&[26; 40]);
+                    expected.extend_from_slice(&[27; 40]);
+                    let mut tail = vec![0; expected.len() - first.len()];
+                    tokio::time::timeout(
+                        Duration::from_millis(200),
+                        fixture.raw.as_mut().unwrap().read_exact(&mut tail),
+                    )
+                    .await
+                    .map_err(|_| failed("pending app transfer did not complete"))??;
+                    if tail != expected[first.len()..] {
+                        return Err(failed("split app transfer changed or duplicated content"));
+                    }
+                    fixture.ack(28, Some(24)).await?;
+                    if fixture.state.receive_bytes.available_permits() != CAPACITY {
+                        return Err(failed("actual app reads did not refund all app credit"));
+                    }
+                    Ok(())
+                }
+                .await;
+                fixture.stop().await?;
+                result
+            })
+            .await;
+        assert!(probe.snapshot().is_idle());
+        result.unwrap();
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn mieru_split_receive_remote_close_drains_contiguous_prefix_to_eof() {
+        let probe = ResourceProbe::default();
+        let result: io::Result<()> = probe
+            .scope(async {
+                let mut fixture = Fixture::new(CAPACITY).await?;
+                let result = async {
+                    fixture.bootstrap().await?;
+                    let mut expected = fixture.fill_app().await?;
+                    fixture.data(27)?;
+                    fixture.data(26)?;
+                    fixture.data(29)?; // seq28 is absent; this future must be dropped on Close.
+                    fixture.remote_close(30)?;
+                    fixture.close_reply().await?;
+                    // Close is observed before there is any app reader. Retained
+                    // seq26/27 must later become readable; seq29 must not cross the gap.
+                    let mut actual = Vec::new();
+                    tokio::time::timeout(
+                        Duration::from_millis(200),
+                        fixture.raw.as_mut().unwrap().read_to_end(&mut actual),
+                    )
+                    .await
+                    .map_err(|_| failed("deferred close did not produce EOF after draining"))??;
+                    expected.extend_from_slice(&[26; CHUNK]);
+                    expected.extend_from_slice(&[27; CHUNK]);
+                    if actual != expected {
+                        return Err(failed(
+                            "closed accepted contiguous DATA was truncated or future gap crossed",
+                        ));
+                    }
+                    if fixture.state.receive_bytes.available_permits() != CAPACITY
+                        || !fixture.state.remote_closed.load(Ordering::Acquire)
+                    {
+                        return Err(failed("closed app credit or EOF state was not completed"));
+                    }
+                    Ok(())
+                }
+                .await;
+                fixture.stop().await?;
+                result
+            })
+            .await;
+        assert!(probe.snapshot().is_idle());
+        result.unwrap();
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn mieru_split_receive_unread_closed_stream_does_not_block_stop() {
+        let probe = ResourceProbe::default();
+        let result: io::Result<()> = probe
+            .scope(async {
+                let mut fixture = Fixture::new(CAPACITY).await?;
+                let result = async {
+                    fixture.bootstrap().await?;
+                    fixture.fill_app().await?;
+                    fixture.data_bytes(26, &[26; 40])?;
+                    fixture.data_bytes(27, &[27; 40])?;
+                    fixture.remote_close(28)?;
+                    fixture.close_reply().await?;
+                    // No app read occurs. Stop must cancel the bounded deferred drain.
+                    Ok(())
+                }
+                .await;
+                fixture.stop().await?;
+                result
+            })
+            .await;
+        assert!(probe.snapshot().is_idle());
+        result.unwrap();
+    }
+    async fn grace_read_to_eof(mut fixture: Fixture) -> io::Result<(Vec<u8>, io::Result<usize>)> {
+        let mut raw = fixture.raw.take().unwrap();
+        let mut bytes = Vec::new();
+        let read = tokio::time::timeout(Duration::from_millis(200), raw.read_to_end(&mut bytes)).await;
+        drop(raw);
+        fixture.stop().await?;
+        let read = read.map_err(|_| failed("invalid RED: no real EOF before fixture guard"))?;
+        Ok((bytes, read))
+    }
+    fn grace_read_is_pending(raw: &mut super::super::stream::RawStream) -> io::Result<bool> {
+        let mut storage = [0u8; 16];
+        let mut buffer = tokio::io::ReadBuf::new(&mut storage);
+        let mut cx = std::task::Context::from_waker(futures_util::task::noop_waker_ref());
+        match tokio::io::AsyncRead::poll_read(std::pin::Pin::new(raw), &mut cx, &mut buffer) {
+            std::task::Poll::Pending => Ok(true),
+            std::task::Poll::Ready(Ok(())) => Ok(false),
+            std::task::Poll::Ready(Err(error)) => Err(error),
+        }
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn mieru_close_grace_recovers_head_after_original_turn() {
+        let probe = ResourceProbe::default();
+        probe.scope(async {
+            let mut fixture = Fixture::with_close_gate(CAPACITY,
+                super::super::tcp::Business::TcpConnect, Duration::from_millis(10)).await?;
+            fixture.bootstrap().await?;
+            // All DATA exists before Close. Only physical readiness of the head
+            // is delayed, avoiding inject-after-closed errors as a fake RED.
+            fixture.data_bytes(2, b"FUTURE")?;
+            fixture.remote_close(3)?;
+            fixture.data_bytes(1, b"HEAD")?;
+            fixture.data_bytes(3, b"BEYOND-HINT")?;
+            fixture.close_reply().await?;
+            let (bytes, read) = grace_read_to_eof(fixture).await?;
+            read?;
+            // Only actual old-driver EOF/0B is expected assertion RED.
+            assert_eq!(bytes, b"HEADFUTURE");
+            Ok::<_, io::Error>(())
+        }).await.unwrap();
+        assert!(probe.snapshot().is_idle(), "{:?}", probe.snapshot());
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn mieru_close_grace_first_deadline_is_hard_and_duplicates_do_not_extend() {
+        let probe = ResourceProbe::default();
+        probe.scope(async {
+            let mut fixture = Fixture::new(CAPACITY).await?;
+            fixture.bootstrap().await?;
+            fixture.data_bytes(2, b"FUTURE")?;
+            fixture.remote_close(3)?;
+            fixture.close_reply().await?;
+            let closed_at = Instant::now();
+            let mut raw = fixture.raw.take().unwrap();
+            let first_pending = grace_read_is_pending(&mut raw)?;
+            tokio::time::advance(Duration::from_millis(90)).await;
+            fixture.remote_close(3)?;
+            fixture.close_reply().await?;
+            tokio::time::advance(Duration::from_millis(9)).await;
+            let before_deadline_pending = grace_read_is_pending(&mut raw)?;
+            tokio::time::advance(Duration::from_millis(1)).await;
+            let mut bytes = Vec::new();
+            let end = tokio::time::timeout(Duration::from_millis(1), raw.read_to_end(&mut bytes)).await;
+            let elapsed = Instant::now().saturating_duration_since(closed_at);
+            drop(raw);
+            fixture.stop().await?;
+            let end = end.map_err(|_| failed("first 100ms deadline was not observed"))?;
+            end?;
+            assert!(first_pending && before_deadline_pending);
+            assert!(bytes.is_empty());
+            assert!(elapsed >= Duration::from_millis(100) && elapsed < Duration::from_millis(102));
+            Ok::<_, io::Error>(())
+        }).await.unwrap();
+        assert!(probe.snapshot().is_idle(), "{:?}", probe.snapshot());
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn mieru_close_grace_rejects_new_write_without_losing_read() {
+        let probe = ResourceProbe::default();
+        probe.scope(async {
+            let mut fixture = Fixture::with_close_gate(CAPACITY,
+                super::super::tcp::Business::TcpConnect, Duration::from_millis(10)).await?;
+            fixture.bootstrap().await?; // Prior write already physically first-sent.
+            fixture.data_bytes(2, b"FUTURE")?;
+            fixture.remote_close(3)?;
+            fixture.data_bytes(1, b"HEAD")?;
+            fixture.close_reply().await?;
+            let mut raw = fixture.raw.take().unwrap();
+            let write = raw.write_all(b"MUST-NOT-SEND").await;
+            let mut bytes = Vec::new();
+            let read = tokio::time::timeout(Duration::from_millis(200), raw.read_to_end(&mut bytes)).await;
+            drop(raw);
+            let mut new_client_data = false;
+            while let Ok(metadata) = fixture.sent.try_recv() {
+                new_client_data |= matches!(metadata, Metadata::Data(meta) if meta.kind == DataKind::ClientData);
+            }
+            fixture.stop().await?;
+            let read = read.map_err(|_| failed("read was cancelled by rejected write"))?;
+            read?;
+            assert_eq!(write.unwrap_err().kind(), io::ErrorKind::BrokenPipe);
+            assert!(!new_client_data);
+            assert_eq!(bytes, b"HEADFUTURE");
+            Ok::<_, io::Error>(())
+        }).await.unwrap();
+        assert!(probe.snapshot().is_idle(), "{:?}", probe.snapshot());
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn mieru_close_grace_stop_and_excluded_paths_keep_original_boundaries() {
+        let probe = ResourceProbe::default();
+        probe.scope(async {
+            let mut fixture = Fixture::with_close_gate(CAPACITY,
+                super::super::tcp::Business::TcpConnect, Duration::from_millis(10)).await?;
+            fixture.bootstrap().await?;
+            let _unread = fixture.fill_app().await?;
+            fixture.data_bytes(27, b"FUTURE")?;
+            fixture.remote_close(28)?;
+            fixture.data_bytes(26, b"HEAD")?;
+            fixture.close_reply().await?;
+            let stopped_at = Instant::now();
+            fixture.stop().await?;
+            assert!(Instant::now().saturating_duration_since(stopped_at) < Duration::from_millis(100));
+            for (business, capacity, kind, status) in [
+                (super::super::tcp::Business::TcpConnect, CAPACITY, SessionKind::CloseResponse, 0),
+                (super::super::tcp::Business::TcpConnect, CAPACITY, SessionKind::CloseRequest, 1),
+                (super::super::tcp::Business::UdpAssociate, CAPACITY, SessionKind::CloseRequest, 0),
+                (super::super::tcp::Business::TcpConnect, 64, SessionKind::CloseRequest, 0),
+            ] {
+                let mut fixture = Fixture::with_close_gate(capacity, business, Duration::ZERO).await?;
+                fixture.bootstrap().await?;
+                fixture.data_bytes(2, b"FUTURE")?;
+                fixture.inject(Metadata::Session(SessionMetadata {
+                    kind, session_id: fixture.state.id, sequence: 3, status,
+                }), &[])?;
+                fixture.data_bytes(1, b"HEAD")?;
+                if kind == SessionKind::CloseRequest { fixture.close_reply().await?; }
+                let (bytes, read) = grace_read_to_eof(fixture).await?;
+                assert!(bytes.is_empty());
+                if status != 0 { assert_eq!(read.unwrap_err().kind(), io::ErrorKind::BrokenPipe); }
+                else { read?; }
+            }
+            let mut fixture = Fixture::new(CAPACITY).await?;
+            fixture.bootstrap().await?;
+            fixture.inject(Metadata::Session(SessionMetadata {
+                kind: SessionKind::CloseRequest, session_id: fixture.state.id.wrapping_add(1), sequence: 3, status: 0,
+            }), &[])?;
+            fixture.data_bytes(1, b"HEAD")?;
+            fixture.remote_close(2)?;
+            fixture.close_reply().await?;
+            let (bytes, read) = grace_read_to_eof(fixture).await?;
+            read?;
+            assert_eq!(bytes, b"HEAD");
+            Ok::<_, io::Error>(())
+        }).await.unwrap();
+        assert!(probe.snapshot().is_idle(), "{:?}", probe.snapshot());
+    }
+
+}
diff --git a/src/outbound/mieru/udp_upload_shutdown_tests.rs b/src/outbound/mieru/udp_upload_shutdown_tests.rs
new file mode 100644
index 0000000..ea3bc4c
--- /dev/null
+++ b/src/outbound/mieru/udp_upload_shutdown_tests.rs
@@ -0,0 +1,807 @@
+// Real client/codec/driver feedback; no application bytes are credited by a model.
+const UPLOAD_PREFIX: &[u8] = &[0x21; 256];
+const UPLOAD_TAIL: &[u8] = &[0x5a; 32];
+
+struct UploadFixture {
+    target: std::sync::atomic::AtomicU32,
+    arm: AtomicBool,
+    dropped: AtomicBool,
+    dropped_sequence: std::sync::atomic::AtomicU32,
+    retried: AtomicBool,
+    closed: AtomicBool,
+    close_before_retry: AtomicBool,
+    physical_opens: AtomicUsize,
+    hold_ack: AtomicBool,
+    quiet_close_loss: bool,
+    drop_all_close: AtomicBool,
+    physical_close_sends: AtomicUsize,
+    input_before_close_retry: AtomicUsize,
+    drop_first_close: AtomicBool,
+    close_dropped: AtomicBool,
+    target_close_count: AtomicUsize,
+    last_target_close: Mutex<Option<(SessionMetadata, usize)>>,
+    close_dropped_notify: tokio::sync::Notify,
+    outgoing: Mutex<Option<mpsc::Sender<Datagram>>>,
+    remote: Mutex<Option<Destination>>,
+    server_next: std::sync::atomic::AtomicU32,
+    dropped_notify: tokio::sync::Notify,
+    origin: tokio::sync::Mutex<Option<tokio::io::DuplexStream>>,
+}
+
+impl UploadFixture {
+    fn new(origin: tokio::io::DuplexStream) -> Self {
+        Self {
+            target: std::sync::atomic::AtomicU32::new(0),
+            arm: AtomicBool::new(false),
+            dropped: AtomicBool::new(false),
+            dropped_sequence: std::sync::atomic::AtomicU32::new(u32::MAX),
+            retried: AtomicBool::new(false),
+            closed: AtomicBool::new(false),
+            close_before_retry: AtomicBool::new(false),
+            physical_opens: AtomicUsize::new(0),
+            hold_ack: AtomicBool::new(false),
+            quiet_close_loss: false,
+            drop_all_close: AtomicBool::new(false),
+            physical_close_sends: AtomicUsize::new(0),
+            input_before_close_retry: AtomicUsize::new(0),
+            drop_first_close: AtomicBool::new(false),
+            close_dropped: AtomicBool::new(false),
+            target_close_count: AtomicUsize::new(0),
+            last_target_close: Mutex::new(None),
+            close_dropped_notify: tokio::sync::Notify::new(),
+            outgoing: Mutex::new(None),
+            remote: Mutex::new(None),
+            server_next: std::sync::atomic::AtomicU32::new(0),
+            dropped_notify: tokio::sync::Notify::new(),
+            origin: tokio::sync::Mutex::new(Some(origin)),
+        }
+    }
+
+    fn select(&self, id: u32, remote: &Destination) {
+        if self
+            .target
+            .compare_exchange(0, id, Ordering::AcqRel, Ordering::Acquire)
+            .is_ok()
+        {
+            *self.remote.lock().unwrap() = Some(remote.clone());
+        }
+    }
+
+    fn observe_server(&self, metadata: Metadata) {
+        if self.is_target(session_id(metadata)) {
+            self.server_next
+                .fetch_max(sequence(metadata).saturating_add(1), Ordering::AcqRel);
+        }
+    }
+
+    fn withholds(&self, metadata: Metadata) -> bool {
+        self.hold_ack.load(Ordering::Acquire)
+            && self.is_target(session_id(metadata))
+            && matches!(metadata, Metadata::Data(_))
+    }
+
+    async fn send_remote_close(&self) -> io::Result<()> {
+        let key = crypto::derive_packet_key("vole", "fixture-password", super::super::tcp::now()?);
+        let mut encoder = PacketEncoder::new(&key, false)?;
+        let mut bytes = Vec::new();
+        encoder.encode_frame(
+            Metadata::Session(SessionMetadata {
+                kind: SessionKind::CloseRequest,
+                session_id: self.target.load(Ordering::Acquire),
+                sequence: self.server_next.load(Ordering::Acquire),
+                status: 0,
+            }),
+            &[],
+            Padding {
+                prefix: &[],
+                suffix: &[],
+            },
+            rand::random(),
+            super::super::tcp::now()?,
+            &mut bytes,
+        )?;
+        let sender = self.outgoing.lock().unwrap().clone().ok_or_else(closed)?;
+        let remote = self.remote.lock().unwrap().clone().ok_or_else(closed)?;
+        sender
+            .send(Datagram {
+                remote,
+                payload: bytes.into(),
+                sniffed_domain: None,
+            })
+            .await
+            .map_err(|_| closed())
+    }
+
+    async fn send_late_ack(&self, unack_sequence: u32) -> io::Result<()> {
+        let key = crypto::derive_packet_key("vole", "fixture-password", super::super::tcp::now()?);
+        let mut encoder = PacketEncoder::new(&key, false)?;
+        let mut bytes = Vec::new();
+        encoder.encode_frame(
+            Metadata::Data(DataMetadata {
+                kind: DataKind::ServerAck,
+                session_id: self.target.load(Ordering::Acquire),
+                sequence: self.server_next.load(Ordering::Acquire).saturating_sub(1),
+                unack_sequence,
+                window: 64,
+                fragment: 0,
+            }),
+            &[],
+            Padding {
+                prefix: &[],
+                suffix: &[],
+            },
+            rand::random(),
+            super::super::tcp::now()?,
+            &mut bytes,
+        )?;
+        let sender = self.outgoing.lock().unwrap().clone().ok_or_else(closed)?;
+        let remote = self.remote.lock().unwrap().clone().ok_or_else(closed)?;
+        sender
+            .send(Datagram {
+                remote,
+                payload: bytes.into(),
+                sniffed_domain: None,
+            })
+            .await
+            .map_err(|_| closed())
+    }
+
+    async fn wait_close_dropped(&self) {
+        while !self.close_dropped.load(Ordering::Acquire) {
+            self.close_dropped_notify.notified().await;
+        }
+    }
+
+    fn is_target(&self, id: u32) -> bool {
+        self.target.load(Ordering::Acquire) == id
+    }
+
+    fn drop_or_observe(&self, id: u32, frame: &Frame, ready: bool) -> bool {
+        if !ready || !self.is_target(id) {
+            return false;
+        }
+        if let Metadata::Session(meta) = frame.metadata {
+            if meta.kind == SessionKind::CloseRequest {
+                self.target_close_count.fetch_add(1, Ordering::AcqRel);
+                *self.last_target_close.lock().unwrap() = Some((meta, frame.payload.len()));
+                if self.drop_first_close.swap(false, Ordering::AcqRel)
+                    || self.drop_all_close.load(Ordering::Acquire)
+                {
+                    if self.quiet_close_loss {
+                        self.hold_ack.store(true, Ordering::Release);
+                    }
+                    self.close_dropped.store(true, Ordering::Release);
+                    self.close_dropped_notify.notify_one();
+                    return true;
+                }
+            }
+            return false;
+        }
+        let Metadata::Data(meta) = frame.metadata else {
+            return false;
+        };
+        if meta.kind != DataKind::ClientData || frame.payload.is_empty() {
+            return false;
+        }
+        if self.arm.swap(false, Ordering::AcqRel) {
+            self.dropped_sequence
+                .store(meta.sequence, Ordering::Release);
+            self.dropped.store(true, Ordering::Release);
+            self.dropped_notify.notify_one();
+            return true;
+        }
+        if self.dropped.load(Ordering::Acquire)
+            && meta.sequence == self.dropped_sequence.load(Ordering::Acquire)
+        {
+            self.retried.store(true, Ordering::Release);
+        }
+        false
+    }
+
+    async fn wait_dropped(&self) {
+        while !self.dropped.load(Ordering::Acquire) {
+            self.dropped_notify.notified().await;
+        }
+    }
+
+    async fn write_origin(&self, bytes: &[u8]) -> io::Result<()> {
+        self.origin
+            .lock()
+            .await
+            .as_mut()
+            .ok_or_else(closed)?
+            .write_all(bytes)
+            .await
+    }
+
+    async fn close_origin(&self, id: u32) {
+        if self.is_target(id) {
+            self.close_before_retry
+                .store(!self.retried.load(Ordering::Acquire), Ordering::Release);
+            self.closed.store(true, Ordering::Release);
+            let writer = self.origin.lock().await.take();
+            drop(writer);
+        }
+    }
+}
+
+struct UploadHarness {
+    node: super::super::MieruOutbound,
+    peer: Arc<Peer>,
+    fixture: Arc<UploadFixture>,
+    origin: tokio::io::DuplexStream,
+    stream: crate::dispatch::BoxStream,
+    prefix: Vec<u8>,
+}
+
+impl UploadHarness {
+    async fn stop(self) {
+        drop(self.stream);
+        self.node.shutdown().await;
+        self.peer.stop().await;
+    }
+}
+
+async fn faulted_upload() -> UploadHarness {
+    upload_harness(true).await
+}
+
+async fn upload_harness(drop_tail: bool) -> UploadHarness {
+    upload_harness_with_quiet_close_loss(drop_tail, false).await
+}
+
+async fn upload_harness_with_quiet_close_loss(drop_tail: bool, quiet: bool) -> UploadHarness {
+    let (origin_writer, mut origin) = tokio::io::duplex(4096);
+    let mut fixture = UploadFixture::new(origin_writer);
+    fixture.quiet_close_loss = quiet;
+    let fixture = Arc::new(fixture);
+    let mut peer = Peer::new(false, false);
+    Arc::get_mut(&mut peer).unwrap().upload = Some(fixture.clone());
+    let mut settings = config();
+    settings.handshake_mode = crate::config::MieruHandshake::Standard;
+    settings.multiplexing = crate::config::MieruMultiplexing::Low;
+    settings.traffic_pattern = Some("CAAaBAgAEAAiEAgDEAEYACAAKgZhYWJiY2MqBAgAEAAyBAgBEAA=".into());
+    let node = super::super::MieruOutbound::new(
+        &settings,
+        UpstreamPath::proxy(Arc::new(peer.clone())),
+        32768,
+    )
+    .unwrap();
+    let context = EstablishContext::with_timeout(Duration::from_secs(5));
+    let mut stream = node
+        .connect_stream(super::super::tests::session(), &context)
+        .await
+        .unwrap()
+        .io;
+    stream.write_all(UPLOAD_PREFIX).await.unwrap();
+    let mut prefix = vec![0; UPLOAD_PREFIX.len()];
+    origin.read_exact(&mut prefix).await.unwrap();
+    assert_eq!(prefix, UPLOAD_PREFIX);
+    fixture.arm.store(drop_tail, Ordering::Release);
+    stream.write_all(UPLOAD_TAIL).await.unwrap();
+    if drop_tail {
+        // The client first-send receipt succeeded, but the peer did not admit the tail.
+        fixture.wait_dropped().await;
+    }
+    UploadHarness {
+        node,
+        peer,
+        fixture,
+        origin,
+        stream,
+        prefix,
+    }
+}
+
+#[tokio::test(start_paused = true)]
+async fn mieru_udp_upload_shutdown_delivers_a_successfully_sent_but_lost_tail_before_eof() {
+    let probe = ResourceProbe::default();
+    let (actual, dropped, retried, closed, close_before_retry, physical_opens) = probe
+        .scope(async {
+            let mut h = faulted_upload().await;
+            h.stream.shutdown().await.unwrap();
+            let mut tail = Vec::new();
+            h.origin.read_to_end(&mut tail).await.unwrap();
+            let mut actual = h.prefix.clone();
+            actual.extend_from_slice(&tail);
+            let result = (
+                actual,
+                h.fixture.dropped.load(Ordering::Acquire),
+                h.fixture.retried.load(Ordering::Acquire),
+                h.fixture.closed.load(Ordering::Acquire),
+                h.fixture.close_before_retry.load(Ordering::Acquire),
+                h.fixture.physical_opens.load(Ordering::Acquire),
+            );
+            h.stop().await;
+            result
+        })
+        .await;
+    assert!(probe.snapshot().is_idle());
+    assert!(
+        dropped && closed && physical_opens == 1,
+        "required real-wire loss/close condition was absent"
+    );
+    let mut expected = UPLOAD_PREFIX.to_vec();
+    expected.extend_from_slice(UPLOAD_TAIL);
+    assert_eq!(
+        actual, expected,
+        "origin received EOF before the accepted upload tail"
+    );
+    assert!(
+        retried && !close_before_retry,
+        "close overtook the tail's reliable retry"
+    );
+}
+
+#[tokio::test(start_paused = true)]
+async fn mieru_udp_upload_pending_ack_shutdown_does_not_delay_active_stop() {
+    let probe = ResourceProbe::default();
+    probe
+        .scope(async {
+            let mut h = faulted_upload().await;
+            h.fixture.hold_ack.store(true, Ordering::Release);
+            {
+                let mut shutting_down = Box::pin(h.stream.shutdown());
+                assert!(shutting_down.as_mut().now_or_never().is_none());
+                h.node.shutdown().await;
+                assert!(shutting_down.await.is_err());
+            }
+            h.stop().await;
+        })
+        .await;
+    assert!(probe.snapshot().is_idle());
+}
+
+#[tokio::test(start_paused = true)]
+async fn mieru_udp_upload_cancelled_shutdown_keeps_same_carrier_sibling_live() {
+    let probe = ResourceProbe::default();
+    let (actual, physical_opens) = probe
+        .scope(async {
+            let mut h = faulted_upload().await;
+            h.fixture.hold_ack.store(true, Ordering::Release);
+            let raw = h.node.client.attach_tcp_stream_for_test().unwrap();
+            let session = super::super::tests::session();
+            let context = EstablishContext::with_timeout(Duration::from_secs(5));
+            let mut sibling: crate::dispatch::BoxStream = Box::new(
+                super::super::stream::Stream::standard(
+                    raw,
+                    &session.destination,
+                    crate::socks5::COMMAND_CONNECT,
+                    context.deadline(),
+                )
+                .await
+                .unwrap(),
+            );
+            assert_eq!(h.fixture.physical_opens.load(Ordering::Acquire), 1);
+            assert_eq!(h.peer.opens.load(Ordering::Acquire), 2);
+            {
+                let mut shutting_down = Box::pin(h.stream.shutdown());
+                assert!(shutting_down.as_mut().now_or_never().is_none());
+                // A live ACK waiter must not reserve the carrier's sibling credit.
+                super::super::tests::echo(&mut sibling, b"sibling while ACK wait is pending").await;
+                assert!(shutting_down.as_mut().now_or_never().is_none());
+                // Dropping only this future must not close/replay the underlying stream.
+                drop(shutting_down);
+            }
+            assert!(!h.fixture.closed.load(Ordering::Acquire));
+            super::super::tests::echo(&mut sibling, b"same physical carrier remains live").await;
+            h.fixture.hold_ack.store(false, Ordering::Release);
+            h.stream.shutdown().await.unwrap();
+            let mut actual = h.prefix.clone();
+            h.origin.read_to_end(&mut actual).await.unwrap();
+            let physical_opens = h.fixture.physical_opens.load(Ordering::Acquire);
+            drop(sibling);
+            h.stop().await;
+            (actual, physical_opens)
+        })
+        .await;
+    assert!(probe.snapshot().is_idle());
+    let mut expected = UPLOAD_PREFIX.to_vec();
+    expected.extend_from_slice(UPLOAD_TAIL);
+    assert_eq!(
+        actual, expected,
+        "cancelled shutdown replayed or lost application data"
+    );
+    assert_eq!(physical_opens, 1);
+}
+
+#[tokio::test(start_paused = true)]
+async fn mieru_udp_upload_drop_keeps_immediate_close_without_waiting_for_ack() {
+    let probe = ResourceProbe::default();
+    let (actual, close_before_retry) = probe
+        .scope(async {
+            let mut h = faulted_upload().await;
+            h.fixture.hold_ack.store(true, Ordering::Release);
+            {
+                let mut shutting_down = Box::pin(h.stream.shutdown());
+                assert!(shutting_down.as_mut().now_or_never().is_none());
+            }
+            let UploadHarness {
+                node,
+                peer,
+                fixture,
+                mut origin,
+                stream,
+                mut prefix,
+            } = h;
+            drop(stream);
+            origin.read_to_end(&mut prefix).await.unwrap();
+            let close_before_retry = fixture.close_before_retry.load(Ordering::Acquire);
+            node.shutdown().await;
+            peer.stop().await;
+            (prefix, close_before_retry)
+        })
+        .await;
+    assert!(probe.snapshot().is_idle());
+    assert_eq!(
+        actual, UPLOAD_PREFIX,
+        "Drop unexpectedly waited to retry the missing tail"
+    );
+    assert!(close_before_retry, "Drop was delayed behind ACK drain");
+}
+
+#[tokio::test(start_paused = true)]
+async fn mieru_udp_upload_peer_close_releases_ack_wait_with_original_close_result() {
+    let probe = ResourceProbe::default();
+    probe
+        .scope(async {
+            let mut h = faulted_upload().await;
+            h.fixture.hold_ack.store(true, Ordering::Release);
+            {
+                let mut shutting_down = Box::pin(h.stream.shutdown());
+                assert!(shutting_down.as_mut().now_or_never().is_none());
+                h.fixture.send_remote_close().await.unwrap();
+                // TX_LIMIT failure is not evidence that our Close was processed.
+                h.peer.close_replied.notified().await;
+                let result = shutting_down.await;
+                assert!(
+                    result.is_ok()
+                        || result
+                            .as_ref()
+                            .is_err_and(|e| e.kind() == io::ErrorKind::BrokenPipe)
+                );
+            }
+            h.stop().await;
+        })
+        .await;
+    assert!(probe.snapshot().is_idle());
+}
+
+// Both controls exercise the actual client, packet codecs, physical memory carrier,
+// and origin socket. No cleanup-induced EOF is credited as business progress.
+async fn close_loss_recovers_via_late_ack(with_sibling: bool) {
+    const LATE_ACK: u32 = 0x1357_2468;
+    let probe = ResourceProbe::default();
+    let outcome = probe
+        .scope(async {
+            let mut h = upload_harness(false).await;
+            let mut sibling: Option<crate::dispatch::BoxStream> = None;
+            let result: io::Result<_> = async {
+                if with_sibling {
+                    let raw = h.node.client.attach_tcp_stream_for_test()?;
+                    let session = super::super::tests::session();
+                    let context = EstablishContext::with_timeout(Duration::from_secs(5));
+                    sibling = Some(Box::new(
+                        super::super::stream::Stream::standard(
+                            raw,
+                            &session.destination,
+                            crate::socks5::COMMAND_CONNECT,
+                            context.deadline(),
+                        )
+                        .await?,
+                    ));
+                }
+                let expected_opens = if with_sibling { 2 } else { 1 };
+                if h.fixture.physical_opens.load(Ordering::Acquire) != 1
+                    || h.peer.opens.load(Ordering::Acquire) != expected_opens
+                {
+                    return Err(io::Error::other(
+                        "Close-loss controls did not share one physical carrier",
+                    ));
+                }
+                h.fixture.drop_first_close.store(true, Ordering::Release);
+                h.stream.shutdown().await?;
+                tokio::time::timeout(Duration::from_secs(5), h.fixture.wait_close_dropped())
+                    .await
+                    .map_err(|_| io::Error::from(io::ErrorKind::TimedOut))?;
+                if h.fixture.target_close_count.load(Ordering::Acquire) != 1
+                    || h.fixture.closed.load(Ordering::Acquire)
+                {
+                    return Err(io::Error::other(
+                        "first real Close was not uniquely dropped before origin close",
+                    ));
+                }
+                h.fixture.send_late_ack(LATE_ACK).await?;
+                let mut actual = h.prefix.clone();
+                tokio::time::timeout(Duration::from_secs(5), h.origin.read_to_end(&mut actual))
+                    .await
+                    .map_err(|_| io::Error::from(io::ErrorKind::TimedOut))??;
+                let observed = *h.fixture.last_target_close.lock().unwrap();
+                Ok((
+                    actual,
+                    observed,
+                    h.fixture.target_close_count.load(Ordering::Acquire),
+                    h.fixture.target.load(Ordering::Acquire),
+                    h.fixture.closed.load(Ordering::Acquire),
+                    h.fixture.physical_opens.load(Ordering::Acquire),
+                    h.peer.opens.load(Ordering::Acquire),
+                ))
+            }
+            .await;
+            drop(sibling);
+            h.stop().await;
+            result
+        })
+        .await;
+    assert!(
+        probe.snapshot().is_idle(),
+        "RED and GREEN must both join and release before assertions"
+    );
+    let (actual, observed, count, id, closed, physical_opens, opens) =
+        outcome.expect("late ACK did not reach the existing unknown-SID Close path before cleanup");
+    let mut expected = UPLOAD_PREFIX.to_vec();
+    expected.extend_from_slice(UPLOAD_TAIL);
+    assert_eq!(actual, expected);
+    assert_eq!(
+        <sha2::Sha256 as sha2::Digest>::digest(&actual),
+        <sha2::Sha256 as sha2::Digest>::digest(&expected)
+    );
+    assert_eq!(
+        observed,
+        Some((
+            SessionMetadata {
+                kind: SessionKind::CloseRequest,
+                session_id: id,
+                sequence: LATE_ACK,
+                status: 0,
+            },
+            0
+        ))
+    );
+    assert_eq!(
+        count, 2,
+        "only the injected late ACK should cause the second Close"
+    );
+    assert!(
+        closed,
+        "origin EOF must follow actual peer Close handling, before Stop"
+    );
+    assert_eq!(physical_opens, 1);
+    assert_eq!(opens, if with_sibling { 2 } else { 1 });
+}
+
+#[tokio::test(start_paused = true)]
+async fn mieru_udp_closed_last_sid_accepts_late_ack_after_first_close_loss() {
+    close_loss_recovers_via_late_ack(false).await;
+}
+
+#[tokio::test(start_paused = true)]
+async fn mieru_udp_closed_sid_with_live_sibling_accepts_late_ack_after_first_close_loss() {
+    close_loss_recovers_via_late_ack(true).await;
+}
+
+// A real Close loss must recover without any incoming DATA/ACK trigger.
+#[tokio::test(start_paused = true)]
+async fn mieru_udp_first_close_loss_recovers_with_silent_peer_before_origin_eof() {
+    let probe = ResourceProbe::default();
+    let outcome = probe
+        .scope(async {
+            let mut h = upload_harness_with_quiet_close_loss(false, true).await;
+            let result: io::Result<_> = async {
+                h.fixture.drop_first_close.store(true, Ordering::Release);
+                tokio::time::timeout(Duration::from_secs(5), h.stream.shutdown())
+                    .await
+                    .map_err(|_| io::Error::other("setup: DATA ACK drain did not complete"))??;
+                tokio::time::timeout(Duration::from_secs(5), h.fixture.wait_close_dropped())
+                    .await
+                    .map_err(|_| io::Error::other("setup: first real Close was not dropped"))?;
+                if h.fixture.physical_close_sends.load(Ordering::Acquire) == 0 {
+                    return Err(io::Error::other(
+                        "setup: Close transport never returned Ready-OK",
+                    ));
+                }
+                let mut actual = h.prefix.clone();
+                let read =
+                    tokio::time::timeout(Duration::from_secs(5), h.origin.read_to_end(&mut actual))
+                        .await;
+                // Snapshot before Stop: cleanup EOF cannot satisfy the assertion.
+                Ok((
+                    read,
+                    actual,
+                    h.fixture.physical_close_sends.load(Ordering::Acquire),
+                    h.fixture.target_close_count.load(Ordering::Acquire),
+                    h.fixture.input_before_close_retry.load(Ordering::Acquire),
+                    h.fixture.closed.load(Ordering::Acquire),
+                    h.fixture.physical_opens.load(Ordering::Acquire),
+                    h.peer.opens.load(Ordering::Acquire),
+                ))
+            }
+            .await;
+            h.stop().await;
+            result
+        })
+        .await;
+    assert!(
+        probe.snapshot().is_idle(),
+        "cleanup must complete before RED/GREEN assertions"
+    );
+    let (read, actual, sends, peer_closes, input, closed, physical_opens, opens) =
+        outcome.expect("invalid fixture/setup; not the intended Close-loss RED");
+    let mut expected = UPLOAD_PREFIX.to_vec();
+    expected.extend_from_slice(UPLOAD_TAIL);
+    assert_eq!(actual, expected);
+    assert_eq!(
+        <sha2::Sha256 as sha2::Digest>::digest(&actual),
+        <sha2::Sha256 as sha2::Digest>::digest(&expected)
+    );
+    assert_eq!(
+        input, 0,
+        "a later peer packet supplied an opportunistic Close trigger"
+    );
+    assert_eq!((physical_opens, opens), (1, 1));
+    assert!(
+        read.as_ref().is_ok_and(|r| r.is_ok()),
+        "no normal origin EOF before the original 5s guard: {read:?}; Close Ready-OK={sends}, peer Close={peer_closes}, input before retry={input}"
+    );
+    assert!(
+        sends >= 2 && peer_closes >= 2,
+        "EOF did not follow a real repeated Close"
+    );
+    assert!(
+        closed,
+        "origin was not closed by the original peer Close handler before Stop"
+    );
+}
+
+#[tokio::test(start_paused = true)]
+async fn mieru_udp_close_retry_without_response_stops_after_two_timer_resends() {
+    let probe = ResourceProbe::default();
+    let outcome = probe
+        .scope(async {
+            let mut h = upload_harness_with_quiet_close_loss(false, true).await;
+            let result: io::Result<_> = async {
+                h.fixture.drop_all_close.store(true, Ordering::Release);
+                let mut actual = h.prefix.clone();
+                let mut tail = [0; UPLOAD_TAIL.len()];
+                tokio::time::timeout(Duration::from_secs(5), h.origin.read_exact(&mut tail))
+                    .await
+                    .map_err(|_| {
+                        io::Error::other("setup: origin did not receive the DATA tail")
+                    })??;
+                actual.extend_from_slice(&tail);
+                tokio::time::timeout(Duration::from_secs(5), h.stream.shutdown())
+                    .await
+                    .map_err(|_| io::Error::other("setup: DATA ACK drain did not complete"))??;
+                tokio::time::timeout(Duration::from_secs(5), h.fixture.wait_close_dropped())
+                    .await
+                    .map_err(|_| io::Error::other("setup: no actual first Close drop"))?;
+                let first = *h.fixture.last_target_close.lock().unwrap();
+                let third = tokio::time::timeout(Duration::from_secs(5), async {
+                    while h.fixture.target_close_count.load(Ordering::Acquire) < 3 {
+                        h.fixture.close_dropped_notify.notified().await;
+                    }
+                })
+                .await;
+                // A second full fixture guard is an observation horizon, not a retry constant.
+                tokio::time::advance(Duration::from_secs(5)).await;
+                for _ in 0..16 {
+                    tokio::task::yield_now().await;
+                }
+                let mut byte = [0];
+                let origin_pending = h.origin.read(&mut byte).now_or_never().is_none();
+                Ok((
+                    third.is_ok(),
+                    actual,
+                    h.fixture.physical_close_sends.load(Ordering::Acquire),
+                    h.fixture.target_close_count.load(Ordering::Acquire),
+                    h.fixture.input_before_close_retry.load(Ordering::Acquire),
+                    origin_pending,
+                    h.fixture.closed.load(Ordering::Acquire),
+                    first,
+                    *h.fixture.last_target_close.lock().unwrap(),
+                ))
+            }
+            .await;
+            h.stop().await;
+            result
+        })
+        .await;
+    assert!(probe.snapshot().is_idle());
+    let (third, actual, sends, seen, input, pending, closed, first, last) = outcome.unwrap();
+    let mut expected = UPLOAD_PREFIX.to_vec();
+    expected.extend_from_slice(UPLOAD_TAIL);
+    assert_eq!(actual, expected);
+    assert_eq!(
+        <sha2::Sha256 as sha2::Digest>::digest(&actual),
+        <sha2::Sha256 as sha2::Digest>::digest(&expected)
+    );
+    assert!(
+        third,
+        "two timer resends did not reach the real peer decoder"
+    );
+    assert_eq!(
+        (sends, seen),
+        (3, 3),
+        "original Close plus exactly two timer resends"
+    );
+    assert_eq!(
+        input, 0,
+        "a peer packet supplied an opportunistic resend trigger"
+    );
+    assert!(
+        pending && !closed,
+        "all Closes were dropped; Stop must not supply business EOF"
+    );
+    assert!(first.is_some());
+    assert_eq!(
+        first, last,
+        "retry changed the original Close metadata or payload length"
+    );
+}
+
+#[tokio::test(start_paused = true)]
+async fn mieru_udp_close_retry_active_stop_releases_driver_and_peer_owners() {
+    let probe = ResourceProbe::default();
+    let outcome = probe
+        .scope(async {
+            let mut h = upload_harness_with_quiet_close_loss(false, true).await;
+            let fixture = Arc::downgrade(&h.fixture);
+            let peer = Arc::downgrade(&h.peer);
+            let result: io::Result<_> = async {
+                h.fixture.drop_all_close.store(true, Ordering::Release);
+                tokio::time::timeout(Duration::from_secs(5), h.stream.shutdown())
+                    .await
+                    .map_err(|_| io::Error::other("setup: DATA ACK drain did not complete"))??;
+                tokio::time::timeout(Duration::from_secs(5), h.fixture.wait_close_dropped())
+                    .await
+                    .map_err(|_| io::Error::other("setup: no actual first Close drop"))?;
+                let before = (
+                    h.fixture.physical_close_sends.load(Ordering::Acquire),
+                    h.fixture.target_close_count.load(Ordering::Acquire),
+                );
+                let start = Instant::now();
+                let stopped = tokio::time::timeout(Duration::from_secs(1), h.node.shutdown()).await;
+                let elapsed = Instant::now().saturating_duration_since(start);
+                Ok((
+                    before,
+                    stopped.is_ok(),
+                    elapsed,
+                    h.fixture.physical_close_sends.load(Ordering::Acquire),
+                    h.fixture.target_close_count.load(Ordering::Acquire),
+                    h.fixture.input_before_close_retry.load(Ordering::Acquire),
+                    h.fixture.closed.load(Ordering::Acquire),
+                ))
+            }
+            .await;
+            h.stop().await;
+            (
+                result,
+                fixture.upgrade().is_none(),
+                peer.upgrade().is_none(),
+            )
+        })
+        .await;
+    assert!(probe.snapshot().is_idle());
+    let (result, fixture_gone, peer_gone) = outcome;
+    let (before, stopped, elapsed, sends, seen, input, closed) = result.unwrap();
+    assert_eq!(
+        before,
+        (1, 1),
+        "Stop did not begin with an active retry obligation"
+    );
+    assert!(stopped, "active Stop did not join the physical driver");
+    assert_eq!(
+        elapsed,
+        Duration::ZERO,
+        "paused-clock Stop waited for a retry timer"
+    );
+    assert_eq!((sends, seen, input), (1, 1, 0));
+    assert!(
+        !closed,
+        "peer logical Close was not allowed in this all-loss control"
+    );
+    assert!(
+        fixture_gone && peer_gone,
+        "driver/peer retained fixture ownership after Stop/drop"
+    );
+}
diff --git a/src/outbound/mieru/wire.rs b/src/outbound/mieru/wire.rs
new file mode 100644
index 0000000..320bbc3
--- /dev/null
+++ b/src/outbound/mieru/wire.rs
@@ -0,0 +1,1143 @@
+//! Bounded TCP and UDP framing for the public Mieru v3 protocol.
+//! https://github.com/enfein/mieru/blob/v3.38.1/docs/protocol.md
+//! Session state, SOCKS business bytes, carrier I/O ownership and padding policy live above it.
+use super::crypto::{ImplicitCipher, Key, NONCE_LEN, PacketCipher, TAG_LEN};
+use bytes::{Bytes, BytesMut};
+use std::{fmt, io, sync::Arc};
+use tokio::io::{AsyncRead, AsyncReadExt};
+
+pub(crate) const METADATA_LEN: usize = 32;
+pub(crate) const MAX_CONTROL_PAYLOAD: usize = 1024;
+pub(crate) const MAX_DATA_PAYLOAD: usize = 32_768;
+pub(crate) const PACKET_HEADER_LEN: usize = NONCE_LEN + METADATA_LEN + TAG_LEN;
+pub(crate) const PACKET_OVERHEAD: usize = PACKET_HEADER_LEN + TAG_LEN;
+const ENCRYPTED_METADATA_LEN: usize = METADATA_LEN + TAG_LEN;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum SessionKind {
+    OpenRequest,
+    OpenResponse,
+    CloseRequest,
+    CloseResponse,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum DataKind {
+    ClientData,
+    ServerData,
+    ClientAck,
+    ServerAck,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) struct SessionMetadata {
+    pub(crate) kind: SessionKind,
+    pub(crate) session_id: u32,
+    pub(crate) sequence: u32,
+    pub(crate) status: u8,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) struct DataMetadata {
+    pub(crate) kind: DataKind,
+    pub(crate) session_id: u32,
+    pub(crate) sequence: u32,
+    pub(crate) unack_sequence: u32,
+    pub(crate) window: u16,
+    pub(crate) fragment: u8,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum Metadata {
+    Session(SessionMetadata),
+    Data(DataMetadata),
+}
+
+pub(crate) struct Frame {
+    pub(crate) metadata: Metadata,
+    pub(crate) payload: Bytes,
+}
+
+impl fmt::Debug for Frame {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter
+            .debug_struct("MieruFrame")
+            .field("payload_len", &self.payload.len())
+            .finish_non_exhaustive()
+    }
+}
+
+#[derive(Clone, Copy, Default)]
+pub(crate) struct Padding<'a> {
+    pub(crate) prefix: &'a [u8],
+    pub(crate) suffix: &'a [u8],
+}
+
+#[derive(Clone, Copy)]
+pub(crate) struct LowEntropyEncoding {
+    pub(crate) mode: u8,
+    pub(crate) half_mask: u32,
+    pub(crate) rotation: u8,
+    pub(crate) padding_bit: u8,
+}
+
+#[derive(Clone, Copy)]
+pub(crate) enum BodyEncoding {
+    Plain,
+    LowEntropy(LowEntropyEncoding),
+}
+
+impl BodyEncoding {
+    pub(crate) fn encoded_len(self, plain_len: usize) -> io::Result<usize> {
+        match self {
+            Self::Plain => Ok(plain_len),
+            Self::LowEntropy(encoding) => encoding.encoded_len(plain_len),
+        }
+    }
+
+    fn expand(self, body: &mut [u8], plain_len: usize) -> io::Result<()> {
+        match self {
+            Self::Plain => Ok(()),
+            Self::LowEntropy(encoding) => encoding.expand(body, plain_len),
+        }
+    }
+
+    fn compact(self, body: &mut [u8], plain_len: usize) -> io::Result<()> {
+        match self {
+            Self::Plain => Ok(()),
+            Self::LowEntropy(encoding) => encoding.compact(body, plain_len),
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+pub(crate) struct FrameEncoding<'a> {
+    pub(crate) padding: Padding<'a>,
+    pub(crate) body: BodyEncoding,
+}
+
+impl<'a> From<Padding<'a>> for FrameEncoding<'a> {
+    fn from(padding: Padding<'a>) -> Self {
+        Self {
+            padding,
+            body: BodyEncoding::Plain,
+        }
+    }
+}
+
+struct Header {
+    metadata: Metadata,
+    payload_len: usize,
+    plain_len: usize,
+    body: BodyEncoding,
+    prefix_len: usize,
+    suffix_len: usize,
+}
+
+fn invalid_frame() -> io::Error {
+    io::Error::new(io::ErrorKind::InvalidData, "invalid Mieru frame")
+}
+
+fn encode_metadata(
+    metadata: Metadata,
+    payload_len: usize,
+    encoding: FrameEncoding<'_>,
+    unix_secs: u64,
+) -> io::Result<[u8; METADATA_LEN]> {
+    let prefix_len = u8::try_from(encoding.padding.prefix.len()).map_err(|_| invalid_frame())?;
+    let suffix_len = u8::try_from(encoding.padding.suffix.len()).map_err(|_| invalid_frame())?;
+    let encoded_len = encoding.body.encoded_len(payload_len)?;
+    let mut header = [0; METADATA_LEN];
+    header[2..6].copy_from_slice(&((unix_secs / 60) as u32).to_be_bytes());
+    match metadata {
+        Metadata::Session(session) => {
+            if payload_len > MAX_CONTROL_PAYLOAD
+                || prefix_len != 0
+                || !matches!(encoding.body, BodyEncoding::Plain)
+            {
+                return Err(invalid_frame());
+            }
+            header[0] = match session.kind {
+                SessionKind::OpenRequest => 2,
+                SessionKind::OpenResponse => 3,
+                SessionKind::CloseRequest => 4,
+                SessionKind::CloseResponse => 5,
+            };
+            header[6..10].copy_from_slice(&session.session_id.to_be_bytes());
+            header[10..14].copy_from_slice(&session.sequence.to_be_bytes());
+            header[14] = session.status;
+            header[15..17].copy_from_slice(&(payload_len as u16).to_be_bytes());
+            header[17] = suffix_len;
+        }
+        Metadata::Data(data) => {
+            if payload_len > MAX_DATA_PAYLOAD {
+                return Err(invalid_frame());
+            }
+            header[0] = match data.kind {
+                DataKind::ClientData => 6,
+                DataKind::ServerData => 7,
+                DataKind::ClientAck => 8,
+                DataKind::ServerAck => 9,
+            };
+            if let BodyEncoding::LowEntropy(body) = encoding.body {
+                header[0] = match data.kind {
+                    DataKind::ClientData => 10,
+                    DataKind::ServerData => 11,
+                    _ => return Err(invalid_frame()),
+                };
+                header[1] = body.mode;
+                header[25..29].copy_from_slice(&body.half_mask.to_be_bytes());
+                header[29..31].copy_from_slice(&(payload_len as u16).to_be_bytes());
+                header[31] = body.rotation;
+            }
+            header[6..10].copy_from_slice(&data.session_id.to_be_bytes());
+            header[10..14].copy_from_slice(&data.sequence.to_be_bytes());
+            header[14..18].copy_from_slice(&data.unack_sequence.to_be_bytes());
+            header[18..20].copy_from_slice(&data.window.to_be_bytes());
+            header[20] = data.fragment;
+            header[21] = prefix_len;
+            header[22..24].copy_from_slice(&(encoded_len as u16).to_be_bytes());
+            header[24] = suffix_len;
+        }
+    }
+    Ok(header)
+}
+
+fn decode_metadata(header: [u8; METADATA_LEN], unix_secs: u64) -> io::Result<Header> {
+    let u32_at = |offset: usize| {
+        u32::from_be_bytes(header[offset..offset + 4].try_into().expect("fixed header"))
+    };
+    let u16_at = |offset: usize| u16::from_be_bytes([header[offset], header[offset + 1]]);
+    if u32_at(2).abs_diff((unix_secs / 60) as u32) > 1 {
+        return Err(invalid_frame());
+    }
+    let kind = match header[0] {
+        2 => Some(SessionKind::OpenRequest),
+        3 => Some(SessionKind::OpenResponse),
+        4 => Some(SessionKind::CloseRequest),
+        5 => Some(SessionKind::CloseResponse),
+        _ => None,
+    };
+    if let Some(kind) = kind {
+        let payload_len = usize::from(u16_at(15));
+        if payload_len > MAX_CONTROL_PAYLOAD {
+            return Err(invalid_frame());
+        }
+        return Ok(Header {
+            metadata: Metadata::Session(SessionMetadata {
+                kind,
+                session_id: u32_at(6),
+                sequence: u32_at(10),
+                status: header[14],
+            }),
+            payload_len,
+            plain_len: payload_len,
+            body: BodyEncoding::Plain,
+            prefix_len: 0,
+            suffix_len: usize::from(header[17]),
+        });
+    }
+    let kind = match header[0] {
+        6 | 10 => DataKind::ClientData,
+        7 | 11 => DataKind::ServerData,
+        8 => DataKind::ClientAck,
+        9 => DataKind::ServerAck,
+        _ => return Err(invalid_frame()),
+    };
+    let payload_len = usize::from(u16_at(22));
+    let (body, plain_len) = if matches!(header[0], 10 | 11) {
+        let body = BodyEncoding::LowEntropy(LowEntropyEncoding {
+            mode: header[1],
+            half_mask: u32_at(25),
+            rotation: header[31],
+            padding_bit: 0,
+        });
+        let plain_len = usize::from(u16_at(29));
+        if body.encoded_len(plain_len)? != payload_len {
+            return Err(invalid_frame());
+        }
+        (body, plain_len)
+    } else {
+        (BodyEncoding::Plain, payload_len)
+    };
+    // Received ordinary data uses the full wire u16 bound. The 32 KiB fragment limit
+    // constrains our sender; it must not become an additional peer parser restriction.
+    Ok(Header {
+        metadata: Metadata::Data(DataMetadata {
+            kind,
+            session_id: u32_at(6),
+            sequence: u32_at(10),
+            unack_sequence: u32_at(14),
+            window: u16_at(18),
+            fragment: header[20],
+        }),
+        payload_len,
+        plain_len,
+        body,
+        prefix_len: usize::from(header[21]),
+        suffix_len: usize::from(header[24]),
+    })
+}
+
+/// Encodes one UDP datagram without retaining any packet or nonce state. The caller owns
+/// the physical payload budget, padding policy and fresh explicit nonce for every attempt.
+pub(crate) struct PacketEncoder {
+    cipher: PacketCipher,
+}
+
+impl PacketEncoder {
+    pub(crate) fn new(key: &[u8; 32], low_entropy: bool) -> io::Result<Self> {
+        Ok(Self {
+            cipher: PacketCipher::new(key, low_entropy)?,
+        })
+    }
+
+    pub(crate) fn encode_frame<'a>(
+        &mut self,
+        metadata: Metadata,
+        payload: &[u8],
+        encoding: impl Into<FrameEncoding<'a>>,
+        nonce: [u8; NONCE_LEN],
+        unix_secs: u64,
+        out: &mut Vec<u8>,
+    ) -> io::Result<()> {
+        let encoding = encoding.into();
+        let padding = encoding.padding;
+        let header = encode_metadata(metadata, payload.len(), encoding, unix_secs)?;
+        let payload_start = PACKET_HEADER_LEN + padding.prefix.len();
+        let payload_end = payload_start + encoding.body.encoded_len(payload.len())?;
+        let suffix_start = payload_end + if payload.is_empty() { 0 } else { TAG_LEN };
+        out.clear();
+        out.resize(suffix_start + padding.suffix.len(), 0);
+        out[..NONCE_LEN].copy_from_slice(&nonce);
+        out[NONCE_LEN..NONCE_LEN + METADATA_LEN].copy_from_slice(&header);
+        out[PACKET_HEADER_LEN..payload_start].copy_from_slice(padding.prefix);
+        out[payload_start..payload_start + payload.len()].copy_from_slice(payload);
+        out[suffix_start..].copy_from_slice(padding.suffix);
+        let tag = self
+            .cipher
+            .seal(nonce, &mut out[NONCE_LEN..NONCE_LEN + METADATA_LEN])?;
+        out[NONCE_LEN + METADATA_LEN..PACKET_HEADER_LEN].copy_from_slice(&tag);
+        if !payload.is_empty() {
+            let tag = self.cipher.seal(
+                nonce,
+                &mut out[payload_start..payload_start + payload.len()],
+            )?;
+            encoding
+                .body
+                .expand(&mut out[payload_start..payload_end], payload.len())?;
+            out[payload_end..suffix_start].copy_from_slice(&tag);
+        }
+        Ok(())
+    }
+}
+
+/// Authenticates one complete UDP datagram. Malformed input discards only that packet;
+/// there is no implicit cursor to retire and no replay or logical session state here.
+pub(crate) struct PacketDecoder {
+    cipher: PacketCipher,
+}
+
+impl PacketDecoder {
+    pub(crate) fn new(key: &[u8; 32], low_entropy: bool) -> io::Result<Self> {
+        Ok(Self {
+            cipher: PacketCipher::new(key, low_entropy)?,
+        })
+    }
+
+    pub(crate) fn decode_frame(&mut self, packet: Bytes, unix_secs: u64) -> io::Result<Frame> {
+        if packet.len() < PACKET_HEADER_LEN {
+            return Err(invalid_frame());
+        }
+        // An owned datagram can be decrypted in its existing allocation. A shared/static
+        // buffer needs one copy; the caller already bounds the physical packet length.
+        let mut packet = match packet.try_into_mut() {
+            Ok(packet) => packet,
+            Err(packet) => BytesMut::from(packet.as_ref()),
+        };
+        let nonce = packet[..NONCE_LEN].try_into().expect("fixed packet nonce");
+        let tag = packet[NONCE_LEN + METADATA_LEN..PACKET_HEADER_LEN]
+            .try_into()
+            .expect("fixed metadata tag");
+        self.cipher
+            .open(nonce, &mut packet[NONCE_LEN..NONCE_LEN + METADATA_LEN], tag)?;
+        let header = decode_metadata(
+            packet[NONCE_LEN..NONCE_LEN + METADATA_LEN]
+                .try_into()
+                .expect("fixed metadata"),
+            unix_secs,
+        )?;
+        let payload_start = PACKET_HEADER_LEN + header.prefix_len;
+        let payload_end = payload_start + header.payload_len;
+        let suffix_start = payload_end + if header.payload_len == 0 { 0 } else { TAG_LEN };
+        if packet.len() != suffix_start + header.suffix_len {
+            return Err(invalid_frame());
+        }
+        let payload = if header.payload_len == 0 {
+            Bytes::new()
+        } else {
+            let tag = packet[payload_end..suffix_start]
+                .try_into()
+                .expect("fixed payload tag");
+            header
+                .body
+                .compact(&mut packet[payload_start..payload_end], header.plain_len)?;
+            self.cipher.open(
+                nonce,
+                &mut packet[payload_start..payload_start + header.plain_len],
+                tag,
+            )?;
+            packet.truncate(payload_start + header.plain_len);
+            packet.freeze().slice(payload_start..)
+        };
+        Ok(Frame {
+            metadata: header.metadata,
+            payload,
+        })
+    }
+}
+
+impl fmt::Debug for PacketEncoder {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("MieruPacketEncoder(..)")
+    }
+}
+
+impl fmt::Debug for PacketDecoder {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("MieruPacketDecoder(..)")
+    }
+}
+
+/// Serial encoder for one physical TCP write direction. The owner must finish writing an
+/// encoded frame even if the logical business operation is subsequently cancelled.
+pub(crate) struct StreamEncoder {
+    cipher: ImplicitCipher,
+    initial_nonce: [u8; NONCE_LEN],
+    first: bool,
+    unusable: bool,
+}
+
+impl StreamEncoder {
+    pub(crate) fn new(key: Arc<Key>, initial_nonce: [u8; NONCE_LEN]) -> Self {
+        Self {
+            cipher: ImplicitCipher::new(key, initial_nonce),
+            initial_nonce,
+            first: true,
+            unusable: false,
+        }
+    }
+
+    /// Replace `out` with exactly one frame. Invalid local shapes do not consume a nonce;
+    /// cryptographic failure retires this encoder and its physical connection.
+    pub(crate) fn encode_frame<'a>(
+        &mut self,
+        metadata: Metadata,
+        payload: &[u8],
+        encoding: impl Into<FrameEncoding<'a>>,
+        unix_secs: u64,
+        out: &mut Vec<u8>,
+    ) -> io::Result<()> {
+        if self.unusable {
+            return Err(io::Error::other("Mieru encoder retired"));
+        }
+        let encoding = encoding.into();
+        let padding = encoding.padding;
+        let header = encode_metadata(metadata, payload.len(), encoding, unix_secs)?;
+        let nonce_len = if self.first { NONCE_LEN } else { 0 };
+        let payload_tag_len = if payload.is_empty() { 0 } else { TAG_LEN };
+        let payload_start = nonce_len + ENCRYPTED_METADATA_LEN + padding.prefix.len();
+        let payload_end = payload_start + encoding.body.encoded_len(payload.len())?;
+        let suffix_start = payload_end + payload_tag_len;
+        let frame_len = suffix_start + padding.suffix.len();
+        out.clear();
+        out.resize(frame_len, 0);
+        if self.first {
+            out[..NONCE_LEN].copy_from_slice(&self.initial_nonce);
+        }
+        out[nonce_len..nonce_len + METADATA_LEN].copy_from_slice(&header);
+        out[nonce_len + ENCRYPTED_METADATA_LEN..payload_start].copy_from_slice(padding.prefix);
+        out[payload_start..payload_start + payload.len()].copy_from_slice(payload);
+        out[suffix_start..].copy_from_slice(padding.suffix);
+        self.unusable = true;
+        let tag = self
+            .cipher
+            .seal(&mut out[nonce_len..nonce_len + METADATA_LEN])?;
+        out[nonce_len + METADATA_LEN..nonce_len + ENCRYPTED_METADATA_LEN].copy_from_slice(&tag);
+        if !payload.is_empty() {
+            let tag = self
+                .cipher
+                .seal(&mut out[payload_start..payload_start + payload.len()])?;
+            encoding
+                .body
+                .expand(&mut out[payload_start..payload_end], payload.len())?;
+            out[payload_end..suffix_start].copy_from_slice(&tag);
+        }
+        self.first = false;
+        self.unusable = false;
+        Ok(())
+    }
+}
+
+/// One physical TCP read direction. No tasks or I/O handles are retained here.
+/// Dropping a polled read future retires the decoder, so a partial frame cannot be retried.
+pub(crate) struct StreamDecoder {
+    key: Arc<Key>,
+    cipher: Option<ImplicitCipher>,
+    unusable: bool,
+}
+
+impl StreamDecoder {
+    pub(crate) fn new(key: Arc<Key>) -> Self {
+        Self {
+            key,
+            cipher: None,
+            unusable: false,
+        }
+    }
+
+    #[cfg(test)]
+    pub(crate) async fn read_frame<R: AsyncRead + Unpin + ?Sized>(
+        &mut self,
+        reader: &mut R,
+        unix_secs: u64,
+    ) -> io::Result<Option<Frame>> {
+        self.read_frame_with_clock(reader, || Ok(unix_secs)).await
+    }
+
+    /// Read the clock after metadata arrives, so an idle pending read cannot reject a
+    /// fresh frame using the time at which its future was first polled.
+    pub(crate) async fn read_frame_with_clock<
+        R: AsyncRead + Unpin + ?Sized,
+        C: FnOnce() -> io::Result<u64>,
+    >(
+        &mut self,
+        reader: &mut R,
+        clock: C,
+    ) -> io::Result<Option<Frame>> {
+        if self.unusable {
+            return Err(io::Error::other("Mieru decoder retired"));
+        }
+        self.unusable = true;
+        let result = self.read_frame_inner(reader, clock).await;
+        if result.is_ok() {
+            self.unusable = false;
+        }
+        result
+    }
+
+    async fn read_frame_inner<R: AsyncRead + Unpin + ?Sized, C: FnOnce() -> io::Result<u64>>(
+        &mut self,
+        reader: &mut R,
+        clock: C,
+    ) -> io::Result<Option<Frame>> {
+        let first = self.cipher.is_none();
+        let nonce_len = if first { NONCE_LEN } else { 0 };
+        let header_len = nonce_len + ENCRYPTED_METADATA_LEN;
+        let mut encrypted_header = [0; NONCE_LEN + ENCRYPTED_METADATA_LEN];
+        if reader.read(&mut encrypted_header[..1]).await? == 0 {
+            return Ok(None);
+        }
+        reader
+            .read_exact(&mut encrypted_header[1..header_len])
+            .await?;
+        if first {
+            let nonce = encrypted_header[..NONCE_LEN]
+                .try_into()
+                .expect("fixed nonce");
+            self.cipher = Some(ImplicitCipher::new(self.key.clone(), nonce));
+        }
+        let cipher = self.cipher.as_mut().expect("initialized direction");
+        let tag = encrypted_header[nonce_len + METADATA_LEN..header_len]
+            .try_into()
+            .expect("fixed tag");
+        let header_bytes = &mut encrypted_header[nonce_len..nonce_len + METADATA_LEN];
+        cipher.open(header_bytes, tag)?;
+        let header = decode_metadata(
+            (&*header_bytes).try_into().expect("fixed metadata"),
+            clock()?,
+        )?;
+        let mut padding = [0; u8::MAX as usize];
+        reader.read_exact(&mut padding[..header.prefix_len]).await?;
+        let payload = if header.payload_len == 0 {
+            Bytes::new()
+        } else {
+            // Authenticated u16 length, allocated once only when a payload exists. The
+            // 16-byte tag shares that allocation; prefix/suffix need no heap storage.
+            let mut payload = vec![0; header.payload_len + TAG_LEN];
+            reader.read_exact(&mut payload).await?;
+            let tag = payload[header.payload_len..]
+                .try_into()
+                .expect("fixed payload tag");
+            header
+                .body
+                .compact(&mut payload[..header.payload_len], header.plain_len)?;
+            cipher.open(&mut payload[..header.plain_len], tag)?;
+            payload.truncate(header.plain_len);
+            Bytes::from(payload)
+        };
+        reader.read_exact(&mut padding[..header.suffix_len]).await?;
+        Ok(Some(Frame {
+            metadata: header.metadata,
+            payload,
+        }))
+    }
+}
+
+impl fmt::Debug for StreamEncoder {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("MieruStreamEncoder(..)")
+    }
+}
+
+impl fmt::Debug for StreamDecoder {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("MieruStreamDecoder(..)")
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::crypto::{derive_key, make_client_nonce};
+    use super::*;
+    use std::{
+        cell::Cell,
+        future::Future,
+        pin::Pin,
+        rc::Rc,
+        task::{Context, Poll, Waker},
+    };
+    use tokio::io::{AsyncWriteExt, ReadBuf};
+
+    const TIME: u64 = 1_700_000_000;
+    // Independently computed from the wire specification and RFC 8439/HChaCha primitives.
+    // The temporary Python oracle first verified the published ChaCha block, HChaCha
+    // subkey and Poly1305 vectors; it is not a second production implementation.
+    const OPEN_HEX: &str = concat!(
+        "000102030405060708090a0b0c0d0e0f101112135b65f257",
+        "2289a2f66e5cf623a3b69e0fb82a6dfb7d7ae09f5c0ad82e8e5b8c7d42961eb2",
+        "ef09b588a8a6c70b7e206a7acf8a6b060",
+        "ae568fd11d1c65dd949ecedbfccbbc1a2aaa9e471d3a6517dac",
+        "aabb"
+    );
+    const ACK_HEX: &str = concat!(
+        "6f872a970b7082c014e1e455394012129994baab97850b0af96d618860c4bddd",
+        "70d580cdbabb0289ea3df4e5402fd904",
+        "ccddeeff"
+    );
+    // Same key and explicit nonce for metadata and payload, independently generated
+    // using the validated RFC/HChaCha oracle used for the TCP vectors above.
+    const UDP_OPEN_HEX: &str = concat!(
+        "000102030405060708090a0b0c0d0e0f101112135b65f257",
+        "2289a2f66e5cf623a3b69e0fb82a6dfb7d7ae09f5c0ad82e8e5b8c7d42961eb2",
+        "ef09b588a8a6c70b7e206a7acf8a6b06",
+        "2588a3474449f720a0e29c11650495d90e67718616c00b0673ed",
+        "aabb"
+    );
+    const UDP_ACK_HEX: &str = concat!(
+        "202122232425262728292a2b2c2d2e2f3031323343da3786",
+        "8fd41edb4d29643a018643ca73b9ad828da1c861ecc893ef66e677f6c287f65c",
+        "98bae79d403d0a3012d1d438209943ea",
+        "ccddeeff"
+    );
+
+    fn hex(input: &str) -> Vec<u8> {
+        assert_eq!(input.len() % 2, 0, "fixture contains a partial byte");
+        input
+            .as_bytes()
+            .chunks_exact(2)
+            .map(|pair| {
+                let digit = |byte: u8| match byte {
+                    b'0'..=b'9' => byte - b'0',
+                    b'a'..=b'f' => byte - b'a' + 10,
+                    _ => panic!("invalid fixture hex"),
+                };
+                digit(pair[0]) * 16 + digit(pair[1])
+            })
+            .collect()
+    }
+
+    fn key() -> Arc<Key> {
+        Arc::new(derive_key("vole", "fixture-password", TIME))
+    }
+
+    fn packet_key() -> zeroize::Zeroizing<[u8; 32]> {
+        super::super::crypto::derive_packet_key("vole", "fixture-password", TIME)
+    }
+
+    fn nonce() -> [u8; NONCE_LEN] {
+        make_client_nonce("vole", std::array::from_fn(|index| index as u8))
+    }
+
+    fn open() -> Metadata {
+        Metadata::Session(SessionMetadata {
+            kind: SessionKind::OpenRequest,
+            session_id: 0x0102_0304,
+            sequence: 0,
+            status: 0,
+        })
+    }
+
+    fn ack() -> Metadata {
+        Metadata::Data(DataMetadata {
+            kind: DataKind::ClientAck,
+            session_id: 0x0102_0304,
+            sequence: 1,
+            unack_sequence: 2,
+            window: 16,
+            fragment: 0,
+        })
+    }
+
+    fn data() -> Metadata {
+        let Metadata::Data(mut data) = ack() else {
+            unreachable!()
+        };
+        data.kind = DataKind::ClientData;
+        Metadata::Data(data)
+    }
+
+    #[test]
+    fn mieru_low_entropy_packet_preserves_aead_tag_and_owned_buffer() {
+        let mut encoder = PacketEncoder::new(&packet_key(), false).unwrap();
+        let mut decoder = PacketDecoder::new(&packet_key(), true).unwrap();
+        let plain = b"partial last chunk";
+        let padding = Padding {
+            prefix: &[0x42],
+            suffix: &[0x55, 0x66],
+        };
+        let mut ordinary = Vec::new();
+        encoder
+            .encode_frame(data(), plain, padding, nonce(), TIME, &mut ordinary)
+            .unwrap();
+        for (mode, half_mask) in [
+            (1, 0x0f0f0f0f),
+            (2, 0x00fffff0),
+            (3, 0x00ffffff),
+            (4, 0x0fffffff),
+        ] {
+            for rotation in [0, 7, 16, 240] {
+                for padding_bit in [0, 1] {
+                    let body = LowEntropyEncoding {
+                        mode,
+                        half_mask,
+                        rotation,
+                        padding_bit,
+                    };
+                    let mut packet = Vec::new();
+                    encoder
+                        .encode_frame(
+                            data(),
+                            plain,
+                            FrameEncoding {
+                                padding,
+                                body: BodyEncoding::LowEntropy(body),
+                            },
+                            nonce(),
+                            TIME,
+                            &mut packet,
+                        )
+                        .unwrap();
+                    let start = PACKET_HEADER_LEN + 1;
+                    let end = start + body.encoded_len(plain.len()).unwrap();
+                    // Both representations encrypt precisely the original plaintext.
+                    // Expansion changes ciphertext bytes and length, never the tag.
+                    assert_eq!(
+                        &packet[end..end + TAG_LEN],
+                        &ordinary[start + plain.len()..start + plain.len() + TAG_LEN]
+                    );
+                    let mut cipher = PacketCipher::new(&packet_key(), true).unwrap();
+                    let mut metadata: [u8; METADATA_LEN] = packet
+                        [NONCE_LEN..NONCE_LEN + METADATA_LEN]
+                        .try_into()
+                        .unwrap();
+                    cipher
+                        .open(
+                            nonce(),
+                            &mut metadata,
+                            packet[NONCE_LEN + METADATA_LEN..PACKET_HEADER_LEN]
+                                .try_into()
+                                .unwrap(),
+                        )
+                        .unwrap();
+                    assert_eq!(
+                        (metadata[0], metadata[1], metadata[31]),
+                        (10, mode, rotation)
+                    );
+                    assert_eq!(&metadata[25..29], &half_mask.to_be_bytes());
+                    assert_eq!(&metadata[29..31], &(plain.len() as u16).to_be_bytes());
+                    let received = Bytes::from(packet);
+                    let payload_address = received.as_ptr().wrapping_add(start);
+                    let received = decoder.decode_frame(received, TIME).unwrap();
+                    assert_eq!(received.metadata, data());
+                    assert_eq!(&received.payload[..], plain);
+                    assert_eq!(received.payload.as_ptr(), payload_address);
+                }
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn mieru_low_entropy_stream_shares_normal_nonce_sequence() {
+        let mut encoder = StreamEncoder::new(key(), nonce());
+        let body = BodyEncoding::LowEntropy(LowEntropyEncoding {
+            mode: 1,
+            half_mask: 0x0f0f0f0f,
+            rotation: 7,
+            padding_bit: 1,
+        });
+        let encoding = FrameEncoding {
+            padding: Padding::default(),
+            body,
+        };
+        let mut bytes = Vec::new();
+        let mut frame = Vec::new();
+        // Rejected local shapes leave the initial implicit cursor untouched.
+        assert!(
+            encoder
+                .encode_frame(open(), b"invalid", encoding, TIME, &mut frame)
+                .is_err()
+        );
+        encoder
+            .encode_frame(open(), b"open", Padding::default(), TIME, &mut frame)
+            .unwrap();
+        bytes.extend_from_slice(&frame);
+        encoder
+            .encode_frame(data(), b"expanded", encoding, TIME, &mut frame)
+            .unwrap();
+        bytes.extend_from_slice(&frame);
+        encoder
+            .encode_frame(ack(), &[], Padding::default(), TIME, &mut frame)
+            .unwrap();
+        bytes.extend_from_slice(&frame);
+        encoder
+            .encode_frame(data(), b"ordinary", Padding::default(), TIME, &mut frame)
+            .unwrap();
+        bytes.extend_from_slice(&frame);
+        let mut decoder = StreamDecoder::new(key());
+        let mut reader = bytes.as_slice();
+        for (metadata, payload) in [
+            (open(), b"open".as_slice()),
+            (data(), b"expanded"),
+            (ack(), b""),
+            (data(), b"ordinary"),
+        ] {
+            let frame = decoder
+                .read_frame(&mut reader, TIME)
+                .await
+                .unwrap()
+                .unwrap();
+            assert_eq!(frame.metadata, metadata);
+            assert_eq!(&frame.payload[..], payload);
+        }
+        assert!(
+            decoder
+                .read_frame(&mut reader, TIME)
+                .await
+                .unwrap()
+                .is_none()
+        );
+    }
+
+    #[test]
+    fn fixed_udp_vectors_reorder_and_repeated_datagrams() {
+        let payload = hex("050100017f0000010050");
+        let mut encoder = PacketEncoder::new(&packet_key(), false).unwrap();
+        let mut encoded = Vec::new();
+        encoder
+            .encode_frame(
+                open(),
+                &payload,
+                Padding {
+                    prefix: &[],
+                    suffix: &[0xaa, 0xbb],
+                },
+                nonce(),
+                TIME,
+                &mut encoded,
+            )
+            .unwrap();
+        assert_eq!(encoded, hex(UDP_OPEN_HEX));
+        encoder
+            .encode_frame(
+                ack(),
+                &[],
+                Padding {
+                    prefix: &[0xcc],
+                    suffix: &[0xdd, 0xee, 0xff],
+                },
+                make_client_nonce("vole", std::array::from_fn(|index| index as u8 + 32)),
+                TIME,
+                &mut encoded,
+            )
+            .unwrap();
+        assert_eq!(encoded, hex(UDP_ACK_HEX));
+        let mut decoder = PacketDecoder::new(&packet_key(), false).unwrap();
+        let received = decoder.decode_frame(Bytes::from(encoded), TIME).unwrap();
+        assert_eq!(received.metadata, ack());
+        assert!(received.payload.is_empty());
+        for _ in 0..2 {
+            let packet = Bytes::from(hex(UDP_OPEN_HEX));
+            let payload_address = packet.as_ptr().wrapping_add(PACKET_HEADER_LEN);
+            let received = decoder.decode_frame(packet, TIME).unwrap();
+            assert_eq!(received.metadata, open());
+            assert_eq!(received.payload.as_ref(), payload.as_slice());
+            assert_eq!(received.payload.as_ptr(), payload_address);
+        }
+    }
+
+    #[test]
+    fn packet_errors_leave_decoder_available() {
+        let mut decoder = PacketDecoder::new(&packet_key(), false).unwrap();
+        let valid = hex(UDP_OPEN_HEX);
+        let mut bad_metadata_tag = valid.clone();
+        bad_metadata_tag[PACKET_HEADER_LEN - 1] ^= 1;
+        let mut bad_payload_tag = valid.clone();
+        bad_payload_tag[PACKET_HEADER_LEN + 10] ^= 1;
+        let mut short_padding = valid.clone();
+        short_padding.pop();
+        for packet in [bad_metadata_tag, bad_payload_tag, short_padding] {
+            assert_eq!(
+                decoder
+                    .decode_frame(Bytes::from(packet), TIME)
+                    .unwrap_err()
+                    .kind(),
+                io::ErrorKind::InvalidData
+            );
+            assert_eq!(
+                decoder
+                    .decode_frame(Bytes::from(valid.clone()), TIME)
+                    .unwrap()
+                    .metadata,
+                open()
+            );
+        }
+        assert!(
+            decoder
+                .decode_frame(Bytes::from(valid.clone()), TIME + 180)
+                .is_err()
+        );
+        // Shared received storage takes the copy branch and remains intact for its owner.
+        let packet = Bytes::from(valid);
+        let original = packet.clone();
+        let received = decoder.decode_frame(packet, TIME).unwrap();
+        assert_eq!(received.metadata, open());
+        assert_eq!(original.as_ref(), hex(UDP_OPEN_HEX).as_slice());
+    }
+
+    #[test]
+    fn packet_key_survives_epoch_and_receiver_preserves_u16_bound() {
+        let creation_time = 1_700_000_039;
+        let reply_time = 1_700_000_160;
+        let key =
+            super::super::crypto::derive_packet_key("vole", "fixture-password", creation_time);
+        let nonce = [0x5a; NONCE_LEN];
+        let mut header = encode_metadata(ack(), 0, Padding::default().into(), reply_time).unwrap();
+        header[0] = 7;
+        header[1] = 0xfe;
+        header[22..24].copy_from_slice(&u16::MAX.to_be_bytes());
+        header[25..].fill(0xff);
+        let mut payload = vec![0x5a; usize::from(u16::MAX)];
+        let mut cipher = PacketCipher::new(&key, false).unwrap();
+        let tag = cipher.seal(nonce, &mut header).unwrap();
+        let mut packet = nonce.to_vec();
+        packet.extend_from_slice(&header);
+        packet.extend_from_slice(&tag);
+        let tag = cipher.seal(nonce, &mut payload).unwrap();
+        packet.extend_from_slice(&payload);
+        packet.extend_from_slice(&tag);
+        let packet = Bytes::from(packet);
+        let received = PacketDecoder::new(&key, false)
+            .unwrap()
+            .decode_frame(packet.clone(), reply_time)
+            .unwrap();
+        assert_eq!(received.payload.len(), usize::from(u16::MAX));
+        assert!(received.payload.iter().all(|byte| *byte == 0x5a));
+        let mut new_carrier = PacketDecoder::new(
+            &super::super::crypto::derive_packet_key("vole", "fixture-password", reply_time),
+            false,
+        )
+        .unwrap();
+        assert_eq!(
+            new_carrier
+                .decode_frame(packet, reply_time)
+                .unwrap_err()
+                .kind(),
+            io::ErrorKind::InvalidData
+        );
+    }
+
+    struct Chunks {
+        bytes: Bytes,
+        read: Rc<Cell<usize>>,
+        chunk: usize,
+    }
+
+    impl AsyncRead for Chunks {
+        fn poll_read(
+            self: Pin<&mut Self>,
+            _context: &mut Context<'_>,
+            buffer: &mut ReadBuf<'_>,
+        ) -> Poll<io::Result<()>> {
+            let this = self.get_mut();
+            let offset = this.read.get();
+            let length = buffer
+                .remaining()
+                .min(this.chunk)
+                .min(this.bytes.len() - offset);
+            buffer.put_slice(&this.bytes[offset..offset + length]);
+            this.read.set(offset + length);
+            Poll::Ready(Ok(()))
+        }
+    }
+
+    #[tokio::test]
+    async fn fixed_wire_vectors_and_implicit_nonce_sequence() {
+        let payload = hex("050100017f0000010050");
+        let mut encoder = StreamEncoder::new(key(), nonce());
+        let mut encoded = Vec::new();
+        encoder
+            .encode_frame(
+                open(),
+                &payload,
+                Padding {
+                    prefix: &[],
+                    suffix: &[0xaa, 0xbb],
+                },
+                TIME,
+                &mut encoded,
+            )
+            .unwrap();
+        assert_eq!(encoded, hex(OPEN_HEX));
+        encoder
+            .encode_frame(
+                ack(),
+                &[],
+                Padding {
+                    prefix: &[0xcc],
+                    suffix: &[0xdd, 0xee, 0xff],
+                },
+                TIME,
+                &mut encoded,
+            )
+            .unwrap();
+        assert_eq!(encoded, hex(ACK_HEX));
+        let mut incoming = hex(OPEN_HEX);
+        incoming.extend_from_slice(&hex(ACK_HEX));
+        let mut reader = Chunks {
+            bytes: Bytes::from(incoming),
+            read: Rc::new(Cell::new(0)),
+            chunk: 1,
+        };
+        let mut decoder = StreamDecoder::new(key());
+        let received = decoder
+            .read_frame(&mut reader, TIME)
+            .await
+            .unwrap()
+            .unwrap();
+        assert_eq!(received.metadata, open());
+        assert_eq!(received.payload.as_ref(), payload.as_slice());
+        let received = decoder
+            .read_frame(&mut reader, TIME)
+            .await
+            .unwrap()
+            .unwrap();
+        assert_eq!(received.metadata, ack());
+        assert!(received.payload.is_empty());
+        assert!(
+            decoder
+                .read_frame(&mut reader, TIME)
+                .await
+                .unwrap()
+                .is_none()
+        );
+    }
+
+    #[tokio::test]
+    async fn delayed_reply_keeps_physical_key_and_samples_clock_after_header() {
+        let creation_time = 1_700_000_039;
+        let reply_time = 1_700_000_160;
+        let key = Arc::new(derive_key("vole", "fixture-password", creation_time));
+        let mut encoder = StreamEncoder::new(key.clone(), [0x5a; NONCE_LEN]);
+        let metadata = Metadata::Session(SessionMetadata {
+            kind: SessionKind::OpenResponse,
+            session_id: 0x0102_0304,
+            sequence: 0,
+            status: 0,
+        });
+        let mut encoded = Vec::new();
+        encoder
+            .encode_frame(
+                metadata,
+                b"reply",
+                Padding::default(),
+                reply_time,
+                &mut encoded,
+            )
+            .unwrap();
+        let consumed = Rc::new(Cell::new(0));
+        let mut reader = Chunks {
+            bytes: Bytes::from(encoded.clone()),
+            read: consumed.clone(),
+            chunk: 3,
+        };
+        let mut decoder = StreamDecoder::new(key);
+        let received = decoder
+            .read_frame_with_clock(&mut reader, || {
+                assert_eq!(consumed.get(), NONCE_LEN + ENCRYPTED_METADATA_LEN);
+                Ok(reply_time)
+            })
+            .await
+            .unwrap()
+            .unwrap();
+        assert_eq!(received.metadata, metadata);
+        assert_eq!(received.payload.as_ref(), b"reply");
+        // A new physical carrier selects a new key; it cannot decrypt this old carrier reply.
+        let mut wrong =
+            StreamDecoder::new(Arc::new(derive_key("vole", "fixture-password", reply_time)));
+        let error = wrong
+            .read_frame(&mut encoded.as_slice(), reply_time)
+            .await
+            .unwrap_err();
+        assert_eq!(error.kind(), io::ErrorKind::InvalidData);
+    }
+
+    #[tokio::test]
+    async fn cancelling_partial_frame_retires_decoder() {
+        let (mut sender, mut reader) = tokio::io::duplex(128);
+        sender.write_all(&hex(OPEN_HEX)[..10]).await.unwrap();
+        let mut decoder = StreamDecoder::new(key());
+        let mut pending = Box::pin(decoder.read_frame(&mut reader, TIME));
+        let mut context = Context::from_waker(Waker::noop());
+        assert!(pending.as_mut().poll(&mut context).is_pending());
+        drop(pending);
+        let error = decoder.read_frame(&mut reader, TIME).await.unwrap_err();
+        assert_eq!(error.to_string(), "Mieru decoder retired");
+    }
+
+    #[tokio::test]
+    async fn receiver_accepts_full_u16_payload_and_ignored_reserved_bytes() {
+        // Construct a peer frame directly, since our own sender fragments at 32 KiB.
+        let mut header = encode_metadata(ack(), 0, Padding::default().into(), TIME).unwrap();
+        header[0] = 7;
+        header[1] = 0xfe;
+        header[22..24].copy_from_slice(&u16::MAX.to_be_bytes());
+        header[25..].fill(0xff);
+        let mut payload = vec![0x5a; usize::from(u16::MAX)];
+        let mut cipher = ImplicitCipher::new(key(), nonce());
+        let tag = cipher.seal(&mut header).unwrap();
+        let mut incoming = nonce().to_vec();
+        incoming.extend_from_slice(&header);
+        incoming.extend_from_slice(&tag);
+        let tag = cipher.seal(&mut payload).unwrap();
+        incoming.extend_from_slice(&payload);
+        incoming.extend_from_slice(&tag);
+        let received = StreamDecoder::new(key())
+            .read_frame(&mut incoming.as_slice(), TIME)
+            .await
+            .unwrap()
+            .unwrap();
+        assert_eq!(received.payload.len(), usize::from(u16::MAX));
+        assert!(received.payload.iter().all(|byte| *byte == 0x5a));
+    }
+}
diff --git a/src/outbound/mod.rs b/src/outbound/mod.rs
index 0379cd9..0e0a04a 100644
--- a/src/outbound/mod.rs
+++ b/src/outbound/mod.rs
@@ -1,21 +1,44 @@
 //! Composable proxy connectors and the built-in DIRECT dispatcher.
 
 pub mod address;
+#[cfg(feature = "outbound-http")]
+pub mod http;
+#[cfg(feature = "outbound-masque")]
+pub mod masque;
+#[cfg(feature = "outbound-mieru")]
+pub mod mieru;
 #[cfg(feature = "outbound-trojan")]
 pub mod trojan;
+#[cfg(feature = "outbound-trusttunnel")]
+pub mod trusttunnel;
 #[cfg(feature = "outbound-vmess")]
 pub mod vmess;
+#[cfg(feature = "outbound-wireguard")]
+pub mod wireguard;
 
 #[cfg(feature = "outbound-anytls")]
 mod anytls;
 mod connector;
+mod control;
+pub(crate) use control::RuleControlConnector;
+#[cfg(feature = "sing-mux")]
+mod sing_mux;
+#[cfg(feature = "sing-mux")]
+pub use sing_mux::SingMuxConnector;
 #[cfg(feature = "outbound-shadowsocks")]
 mod shadowsocks;
-#[cfg(any(feature = "outbound-anytls", feature = "outbound-shadowsocks"))]
+#[cfg(any(
+    feature = "outbound-anytls",
+    feature = "outbound-shadowsocks",
+    feature = "outbound-tuic"
+))]
 mod uot;
 #[cfg(feature = "outbound-shadowsocks")]
 pub use shadowsocks::ShadowsocksOutbound;
 mod direct;
+mod dns;
+mod named_direct;
+mod reject;
 #[cfg(feature = "outbound-socks5")]
 mod socks5;
 #[cfg(feature = "outbound-vless")]
@@ -30,9 +53,13 @@ pub use connector::{
     EstablishContext, OutboundConnector, SelectUpstream, UpstreamPath, server_destination,
 };
 pub(crate) use connector::{
-    MAX_OUTBOUND_DIAGNOSTIC_MESSAGE_BYTES, OutboundDiagnostic, capture_outbound_diagnostic,
+    IpVersionConnector, MAX_OUTBOUND_DIAGNOSTIC_MESSAGE_BYTES, OutboundDiagnostic,
+    capture_outbound_diagnostic,
 };
 pub use direct::DirectOutbound;
+pub(crate) use dns::{DnsExchange, DnsOutbound, dns_tcp_stream};
+pub(crate) use named_direct::NamedDirectOutbound;
+pub(crate) use reject::RejectOutbound;
 #[cfg(feature = "outbound-socks5")]
 pub use socks5::{Socks5Auth, Socks5Outbound};
 #[cfg(feature = "outbound-vless")]
@@ -53,8 +80,11 @@ pub mod hysteria2;
     feature = "outbound-trojan",
     feature = "outbound-vmess",
     feature = "outbound-vless",
+    feature = "outbound-shadowsocks",
     feature = "outbound-hysteria2",
-    feature = "outbound-tuic"
+    feature = "outbound-tuic",
+    feature = "outbound-wireguard",
+    feature = "outbound-masque"
 ))]
 mod owned_stream;
 #[cfg(feature = "outbound-tuic")]
diff --git a/src/outbound/named_direct.rs b/src/outbound/named_direct.rs
new file mode 100644
index 0000000..3822420
--- /dev/null
+++ b/src/outbound/named_direct.rs
@@ -0,0 +1,137 @@
+//! A named direct route retains its own physical policy and direct DNS role.
+use std::task::{Context, Poll};
+
+use async_trait::async_trait;
+
+use crate::{
+    dialer::Dialer,
+    dispatch::{DatagramBudget, DatagramTransport, DispatchError},
+    dns::resolution::ResolutionContext,
+    session::{Datagram, Destination, StreamSession},
+};
+
+use super::{
+    ConnectedStream, DEFAULT_ESTABLISH_TIMEOUT, DatagramRequest, DirectOutbound, EstablishContext,
+    OutboundConnector,
+};
+
+pub(crate) struct NamedDirectOutbound {
+    dialer: Dialer,
+    direct: DirectOutbound,
+}
+
+impl NamedDirectOutbound {
+    pub(crate) fn new(dialer: Dialer) -> Self {
+        Self {
+            direct: DirectOutbound::new(dialer.clone()),
+            dialer,
+        }
+    }
+}
+
+#[async_trait]
+impl OutboundConnector for NamedDirectOutbound {
+    async fn connect_stream(
+        &self,
+        session: StreamSession,
+        context: &EstablishContext,
+    ) -> Result<ConnectedStream, DispatchError> {
+        let endpoint = context
+            .resolution()
+            .with_physical_dialer(&self.dialer)
+            .resolve_direct(&session.destination, context.deadline())
+            .await?;
+        let stream = context
+            .run_io(
+                "direct TCP connect",
+                self.dialer
+                    .connect_server_tcp(&endpoint, context.deadline()),
+            )
+            .await?;
+        let effective_peer = Destination::Ip(stream.address);
+        Ok(ConnectedStream {
+            io: stream.io,
+            effective_peer,
+        })
+    }
+
+    async fn open_datagram(
+        &self,
+        request: DatagramRequest,
+        context: &EstablishContext,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        let inner = self.direct.open_datagram(request, context).await?;
+        Ok(Box::new(NamedDirectDatagram {
+            inner,
+            resolution: context.resolution(),
+        }))
+    }
+}
+
+struct NamedDirectDatagram {
+    inner: Box<dyn DatagramTransport>,
+    resolution: ResolutionContext,
+}
+
+#[async_trait]
+impl DatagramTransport for NamedDirectDatagram {
+    fn supports_shared_destinations(&self) -> bool {
+        self.inner.supports_shared_destinations()
+    }
+
+    fn payload_budget(&self, peer: &Destination) -> DatagramBudget {
+        self.inner.payload_budget(peer)
+    }
+
+    fn send_owned(
+        &mut self,
+        packet: Datagram,
+    ) -> Result<crate::dispatch::OwnedDatagramSend, Datagram> {
+        if matches!(packet.remote, Destination::Ip(_)) {
+            self.inner.send_owned(packet)
+        } else {
+            Err(packet)
+        }
+    }
+
+    async fn send(&mut self, mut packet: Datagram) -> Result<(), DispatchError> {
+        if matches!(packet.remote, Destination::Ip(_)) {
+            return self.inner.send(packet).await;
+        }
+        let endpoint = self
+            .resolution
+            .resolve_direct(
+                &packet.remote,
+                tokio::time::Instant::now() + DEFAULT_ESTABLISH_TIMEOUT,
+            )
+            .await?;
+        packet.remote = Destination::Ip(
+            endpoint
+                .addresses
+                .first()
+                .copied()
+                .ok_or(DispatchError::HostUnreachable)?,
+        );
+        self.inner.send(packet).await
+    }
+
+    async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+        self.inner.receive().await
+    }
+
+    fn supports_poll_receive(&self) -> bool {
+        self.inner.supports_poll_receive()
+    }
+
+    fn poll_receive(
+        &mut self,
+        context: &mut Context<'_>,
+        scratch: &mut Vec<u8>,
+    ) -> Poll<Result<Datagram, DispatchError>> {
+        self.inner.poll_receive(context, scratch)
+    }
+
+    async fn close(&mut self) -> Result<(), DispatchError> {
+        self.inner.close().await
+    }
+}
diff --git a/src/outbound/reject.rs b/src/outbound/reject.rs
new file mode 100644
index 0000000..5cc74e9
--- /dev/null
+++ b/src/outbound/reject.rs
@@ -0,0 +1,181 @@
+//! Functional rejection without opening a physical connection.
+use std::{
+    future::Future,
+    io,
+    pin::Pin,
+    task::{Context, Poll},
+    time::Duration,
+};
+
+use async_trait::async_trait;
+use tokio::{
+    io::{AsyncRead, AsyncWrite, ReadBuf},
+    time::Instant,
+};
+use tokio_util::sync::CancellationToken;
+
+use crate::{
+    dispatch::{DatagramTransport, DispatchError},
+    session::{Datagram, StreamSession},
+};
+
+use super::{ConnectedStream, DatagramRequest, EstablishContext, OutboundConnector};
+
+const DROP_DELAY: Duration = Duration::from_secs(60);
+
+/// A named reject ends immediately. The reserved REJECT-DROP delays TCP only;
+/// neither mode creates sockets, queues or detached work.
+#[derive(Debug, Default)]
+pub(crate) struct RejectOutbound {
+    drop: bool,
+    cancel: CancellationToken,
+}
+
+impl RejectOutbound {
+    pub(crate) fn drop_connections() -> Self {
+        Self::with_drop_cancellation(CancellationToken::new())
+    }
+
+    pub(crate) fn with_drop_cancellation(cancel: CancellationToken) -> Self {
+        Self { drop: true, cancel }
+    }
+}
+
+#[async_trait]
+impl OutboundConnector for RejectOutbound {
+    async fn connect_stream(
+        &self,
+        session: StreamSession,
+        context: &EstablishContext,
+    ) -> Result<ConnectedStream, DispatchError> {
+        if self.cancel.is_cancelled() {
+            return Err(DispatchError::NotAllowed);
+        }
+        if context.deadline() <= Instant::now() {
+            return Err(DispatchError::TimedOut);
+        }
+        Ok(ConnectedStream {
+            io: Box::new(RejectedStream::new(self.drop, self.cancel.clone())),
+            effective_peer: session.destination,
+        })
+    }
+
+    async fn open_datagram(
+        &self,
+        _request: DatagramRequest,
+        _context: &EstablishContext,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        if self.cancel.is_cancelled() {
+            return Err(DispatchError::NotAllowed);
+        }
+        Ok(Box::new(RejectedDatagram))
+    }
+
+    fn begin_shutdown(&self) {
+        self.cancel.cancel();
+    }
+}
+
+type Wait = Pin<Box<dyn Future<Output = ()> + Send>>;
+
+struct RejectedStream {
+    read_wait: Option<Wait>,
+    write_wait: Option<Wait>,
+}
+
+impl RejectedStream {
+    fn new(drop: bool, cancel: CancellationToken) -> Self {
+        let deadline = Instant::now() + DROP_DELAY;
+        let wait = |cancel: CancellationToken| -> Wait {
+            Box::pin(async move {
+                tokio::select! { biased;
+                    () = cancel.cancelled() => {},
+                    () = tokio::time::sleep_until(deadline) => {},
+                }
+            })
+        };
+        Self {
+            read_wait: drop.then(|| wait(cancel.clone())),
+            write_wait: drop.then(|| wait(cancel)),
+        }
+    }
+
+    fn ready(wait: &mut Option<Wait>, context: &mut Context<'_>) -> Poll<()> {
+        if let Some(wait) = wait {
+            std::task::ready!(wait.as_mut().poll(context));
+        }
+        Poll::Ready(())
+    }
+}
+
+impl AsyncRead for RejectedStream {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        context: &mut Context<'_>,
+        output: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        if output.remaining() > 0 {
+            std::task::ready!(Self::ready(&mut self.read_wait, context));
+            self.read_wait = None;
+        }
+        Poll::Ready(Ok(()))
+    }
+}
+
+impl AsyncWrite for RejectedStream {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        context: &mut Context<'_>,
+        input: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        if input.is_empty() {
+            return Poll::Ready(Ok(0));
+        }
+        // Tokio's bidirectional relay exits on a write error. Retain the
+        // bounded caller buffer until DROP expires instead of ending early.
+        std::task::ready!(Self::ready(&mut self.write_wait, context));
+        self.write_wait = None;
+        Poll::Ready(Err(io::ErrorKind::UnexpectedEof.into()))
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, _context: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn poll_shutdown(self: Pin<&mut Self>, _context: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+}
+
+struct RejectedDatagram;
+
+#[async_trait]
+impl DatagramTransport for RejectedDatagram {
+    fn supports_shared_destinations(&self) -> bool {
+        true
+    }
+
+    async fn send(&mut self, _packet: Datagram) -> Result<(), DispatchError> {
+        Ok(())
+    }
+
+    async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+        Err(io::Error::from(io::ErrorKind::UnexpectedEof).into())
+    }
+
+    fn supports_poll_receive(&self) -> bool {
+        true
+    }
+
+    fn poll_receive(
+        &mut self,
+        _context: &mut Context<'_>,
+        _scratch: &mut Vec<u8>,
+    ) -> Poll<Result<Datagram, DispatchError>> {
+        Poll::Ready(Err(io::Error::from(io::ErrorKind::UnexpectedEof).into()))
+    }
+}
+
+#[cfg(test)]
+#[path = "reject_tests.rs"]
+mod tests;
diff --git a/src/outbound/reject_tests.rs b/src/outbound/reject_tests.rs
new file mode 100644
index 0000000..2073c23
--- /dev/null
+++ b/src/outbound/reject_tests.rs
@@ -0,0 +1,104 @@
+use super::*;
+use crate::session::{DatagramSession, Destination, InboundKind, InboundMetadata};
+use bytes::Bytes;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+fn session() -> StreamSession {
+    StreamSession {
+        metadata: InboundMetadata::new(443),
+        inbound: InboundKind::Tun,
+        source: "192.0.2.10:12345".parse().unwrap(),
+        destination: Destination::domain("rejected.test", 443).unwrap(),
+        sniffed_domain: None,
+    }
+}
+
+#[tokio::test]
+async fn named_reject_ends_tcp_without_resolving_the_destination() {
+    let node = RejectOutbound::default();
+    let mut stream = node
+        .connect_stream(session(), &EstablishContext::default())
+        .await
+        .unwrap()
+        .io;
+    assert_eq!(stream.read(&mut [0]).await.unwrap(), 0);
+    assert_eq!(
+        stream.write(b"request").await.unwrap_err().kind(),
+        io::ErrorKind::UnexpectedEof
+    );
+    node.begin_shutdown();
+    assert!(
+        node.connect_stream(session(), &EstablishContext::default())
+            .await
+            .is_err()
+    );
+}
+
+#[tokio::test(start_paused = true)]
+async fn reject_drop_holds_first_write_and_read_until_one_absolute_deadline() {
+    let node = RejectOutbound::drop_connections();
+    let stream = node
+        .connect_stream(session(), &EstablishContext::default())
+        .await
+        .unwrap()
+        .io;
+    let (mut reader, mut writer) = tokio::io::split(stream);
+    let mut byte = [0];
+    let read = reader.read(&mut byte);
+    let write = writer.write(b"client first");
+    tokio::pin!(read, write);
+    assert!(futures_util::poll!(&mut read).is_pending());
+    assert!(futures_util::poll!(&mut write).is_pending());
+    tokio::time::advance(Duration::from_secs(59)).await;
+    assert!(futures_util::poll!(&mut read).is_pending());
+    assert!(futures_util::poll!(&mut write).is_pending());
+    tokio::time::advance(Duration::from_secs(1)).await;
+    assert_eq!(read.await.unwrap(), 0);
+    assert_eq!(
+        write.await.unwrap_err().kind(),
+        io::ErrorKind::UnexpectedEof
+    );
+}
+
+#[tokio::test(start_paused = true)]
+async fn reject_drop_stop_wakes_both_pending_directions_without_waiting() {
+    let node = RejectOutbound::drop_connections();
+    let stream = node
+        .connect_stream(session(), &EstablishContext::default())
+        .await
+        .unwrap()
+        .io;
+    let (mut reader, mut writer) = tokio::io::split(stream);
+    let mut byte = [0];
+    let read = reader.read(&mut byte);
+    let write = writer.write(b"client first");
+    tokio::pin!(read, write);
+    assert!(futures_util::poll!(&mut read).is_pending());
+    assert!(futures_util::poll!(&mut write).is_pending());
+    let stopped = Instant::now();
+    node.begin_shutdown();
+    assert_eq!(read.await.unwrap(), 0);
+    assert!(write.await.is_err());
+    assert_eq!(Instant::now(), stopped);
+}
+
+#[tokio::test(start_paused = true)]
+async fn reject_drop_udp_ends_immediately_instead_of_adding_the_tcp_delay() {
+    let node = RejectOutbound::drop_connections();
+    let request = DatagramRequest::new(DatagramSession::new(InboundKind::Tun, session().source));
+    let mut transport = node
+        .open_datagram(request, &EstablishContext::default())
+        .await
+        .unwrap();
+    transport
+        .send(Datagram {
+            remote: session().destination,
+            payload: Bytes::from_static(b"packet"),
+            sniffed_domain: None,
+        })
+        .await
+        .unwrap();
+    let before = Instant::now();
+    assert!(transport.receive().await.is_err());
+    assert_eq!(Instant::now(), before);
+}
diff --git a/src/outbound/shadowsocks/datagram.rs b/src/outbound/shadowsocks/datagram.rs
index db0d763..14651f6 100644
--- a/src/outbound/shadowsocks/datagram.rs
+++ b/src/outbound/shadowsocks/datagram.rs
@@ -1,7 +1,4 @@
-use super::{
-    packet_io::{MAX_WIRE_PACKET, PacketIo},
-    packet_window::PacketWindowFilter,
-};
+use super::{datagram_codec, packet_window::PacketWindowFilter};
 use crate::{
     dispatch::{DatagramTransport, DispatchError},
     session::{Datagram, Destination},
@@ -9,13 +6,14 @@ use crate::{
 use async_trait::async_trait;
 use bytes::Bytes;
 use shadowsocks::{
-    ServerConfig,
-    context::SharedContext,
-    relay::udprelay::{ProxySocket, options::UdpSocketControlData, proxy_socket::UdpSocketType},
+    ServerConfig, context::SharedContext, crypto::v2::udp::UdpCipher,
+    relay::udprelay::options::UdpSocketControlData,
 };
-use std::{collections::VecDeque, time::Duration};
+use std::{collections::VecDeque, sync::Arc, time::Duration};
 use tokio::time::Instant;
 
+pub(super) const MAX_WIRE_PACKET: usize = 65_507;
+
 // Largest response: XChaCha nonce, IDs/type/time/length, optional padding,
 // maximum SOCKS address and AEAD tag. The payload is separately bounded.
 pub(super) const MAX_RESPONSE_HEADER: u16 = 24 + 16 + 1 + 8 + 8 + 2 + 900 + 259 + 16;
@@ -33,18 +31,21 @@ fn nonce_size(config: &ServerConfig) -> usize {
     }
 }
 const SESSION_RETENTION: Duration = Duration::from_secs(60);
+const SEND_BURST: usize = 1;
 
 struct ServerSession {
     id: u64,
     last: Instant,
     window: PacketWindowFilter,
+    cipher: Option<UdpCipher>,
 }
 
 pub(super) struct SsDatagram {
     inner: Box<dyn DatagramTransport>,
     server: Destination,
-    socket: ProxySocket<PacketIo>,
-    io: PacketIo,
+    context: SharedContext,
+    config: Arc<ServerConfig>,
+    tx_cipher: Option<UdpCipher>,
     control: UdpSocketControlData,
     sessions: VecDeque<ServerSession>,
     maximum: usize,
@@ -53,6 +54,7 @@ pub(super) struct SsDatagram {
     closed: bool,
     request_header: usize,
     response_header: usize,
+    sent_in_burst: usize,
 }
 
 impl SsDatagram {
@@ -60,30 +62,39 @@ impl SsDatagram {
         inner: Box<dyn DatagramTransport>,
         server: Destination,
         context: SharedContext,
-        config: &ServerConfig,
+        config: Arc<ServerConfig>,
         maximum: u16,
         wire_maximum: u16,
     ) -> Self {
-        let io = PacketIo::default();
         let mut control = UdpSocketControlData::default();
         control.client_session_id = rand::random();
         Self {
             inner,
             server,
-            socket: ProxySocket::from_socket(UdpSocketType::Client, context, config, io.clone()),
-            io,
+            tx_cipher: Some(UdpCipher::new(
+                config.method(),
+                config.key(),
+                control.client_session_id,
+            )),
+            context,
             control,
             sessions: VecDeque::with_capacity(2),
             maximum: usize::from(maximum),
             wire_maximum: usize::from(wire_maximum).min(MAX_WIRE_PACKET),
             buffer: vec![0; usize::from(wire_maximum).min(MAX_WIRE_PACKET)],
             closed: false,
-            request_header: request_header(config),
-            response_header: nonce_size(config) + 51,
+            request_header: request_header(&config),
+            response_header: nonce_size(&config) + 51,
+            config,
+            sent_in_burst: 0,
         }
     }
 
-    fn accept_control(&mut self, control: &UdpSocketControlData) -> bool {
+    fn accept_control(
+        &mut self,
+        control: &UdpSocketControlData,
+        cipher: Option<UdpCipher>,
+    ) -> bool {
         if control.client_session_id != self.control.client_session_id
             || control.packet_id == u64::MAX
         {
@@ -109,6 +120,7 @@ impl SsDatagram {
                 id: control.server_session_id,
                 last: now,
                 window: PacketWindowFilter::new(),
+                cipher,
             });
             self.sessions.len() - 1
         };
@@ -132,6 +144,12 @@ impl SsDatagram {
 
 #[async_trait]
 impl DatagramTransport for SsDatagram {
+    fn supports_shared_destinations(&self) -> bool {
+        // SIP022 authenticates an address in every packet. The source owner
+        // keeps one replay window; the router demultiplexes live IP targets.
+        true
+    }
+
     fn payload_budget(&self, peer: &Destination) -> crate::dispatch::DatagramBudget {
         let address = super::address(peer).serialized_len();
         let response_address = if matches!(peer, Destination::Domain { .. }) {
@@ -164,6 +182,12 @@ impl DatagramTransport for SsDatagram {
                 "Shadowsocks UDP payload exceeds wire limit".into(),
             ));
         }
+        if self.sent_in_burst == SEND_BURST {
+            self.sent_in_burst = 0;
+            // Give sibling IO a turn before encoding another packet. A
+            // cancellation here cannot leave an accepted wire packet behind.
+            tokio::task::yield_now().await;
+        }
         // Reserve the ID before any cancellable write; an abandoned send must
         // never cause the next packet to reuse an ID/session combination.
         if self.control.packet_id == u64::MAX - 1 {
@@ -176,24 +200,33 @@ impl DatagramTransport for SsDatagram {
             }
             self.control.packet_id = 0;
             self.sessions.clear();
+            self.tx_cipher = Some(UdpCipher::new(
+                self.config.method(),
+                self.config.key(),
+                self.control.client_session_id,
+            ));
         }
         self.control.packet_id += 1;
-        self.socket
-            .send_with_ctrl(
-                &super::address(&datagram.remote),
-                &self.control,
-                &datagram.payload,
-            )
-            .await
-            .map_err(|_| DispatchError::Other("Shadowsocks UDP encoding failed".into()))?;
-        let payload = self.io.take().map_err(DispatchError::from)?;
+        let target = super::address(&datagram.remote);
+        let payload = datagram_codec::encode_request(
+            &self.context,
+            &self.config,
+            self.tx_cipher.as_ref().expect("open SS association"),
+            &target,
+            &self.control,
+            &datagram.payload,
+        )
+        .map_err(|_| DispatchError::Other("Shadowsocks UDP encoding failed".into()))?
+        .freeze();
         self.inner
             .send(Datagram {
                 remote: self.server.clone(),
                 payload,
                 sniffed_domain: None,
             })
-            .await
+            .await?;
+        self.sent_in_burst += 1;
+        Ok(())
     }
 
     async fn receive(&mut self) -> Result<Datagram, DispatchError> {
@@ -202,14 +235,40 @@ impl DatagramTransport for SsDatagram {
         }
         loop {
             let wire = self.inner.receive().await?;
-            if !self.peer_matches(&wire.remote) || wire.payload.len() > self.wire_maximum {
+            if !self.peer_matches(&wire.remote)
+                || wire.payload.len() < self.response_header
+                || wire.payload.len() > self.wire_maximum
+            {
                 continue;
             }
-            self.io.put(wire.payload).map_err(DispatchError::from)?;
-            // The handoff is always Ready. The only cancellable receive is
-            // the shared transport above, so partial packets cannot survive.
-            let Ok((size, source, _, Some(control))) =
-                self.socket.recv_with_ctrl(&mut self.buffer).await
+            let length = wire.payload.len();
+            self.buffer[..length].copy_from_slice(&wire.payload);
+            drop(wire);
+            let Ok(server_id) =
+                datagram_codec::prepare_response(&self.config, &mut self.buffer[..length])
+            else {
+                continue;
+            };
+            let mut candidate = None;
+            let cipher = if let Some(id) = server_id {
+                if let Some(session) = self.sessions.iter().find(|session| session.id == id) {
+                    session.cipher.as_ref().expect("AES session cipher")
+                } else {
+                    if self.sessions.len() == 2
+                        && Instant::now().duration_since(self.sessions[0].last) < SESSION_RETENTION
+                    {
+                        continue;
+                    }
+                    // A tentative unauthenticated ID never enters retained state.
+                    candidate = Some(UdpCipher::new(self.config.method(), self.config.key(), id));
+                    candidate.as_ref().unwrap()
+                }
+            } else {
+                // ChaCha's cipher depends only on PSK; the nonce is per packet.
+                self.tx_cipher.as_ref().expect("open SS association")
+            };
+            let Ok((size, source, control)) =
+                datagram_codec::decode_response(&self.config, cipher, &mut self.buffer[..length])
             else {
                 continue;
             };
@@ -219,7 +278,7 @@ impl DatagramTransport for SsDatagram {
             let Ok(remote) = super::destination(source) else {
                 continue;
             };
-            if !self.accept_control(&control) {
+            if !self.accept_control(&control, candidate) {
                 continue;
             }
             return Ok(Datagram {
@@ -233,6 +292,7 @@ impl DatagramTransport for SsDatagram {
     async fn close(&mut self) -> Result<(), DispatchError> {
         self.closed = true;
         self.sessions.clear();
+        self.tx_cipher.take();
         self.inner.close().await
     }
 }
diff --git a/src/outbound/shadowsocks/datagram_codec.rs b/src/outbound/shadowsocks/datagram_codec.rs
new file mode 100644
index 0000000..0a1d83d
--- /dev/null
+++ b/src/outbound/shadowsocks/datagram_codec.rs
@@ -0,0 +1,214 @@
+//! SIP022 UDP packet-layer adaptation over official public packet ciphers.
+//!
+//! Field layout and EIH were checked against shadowsocks-rust 1.25.0 (MIT)
+//! and the Shadowsocks 2022 specifications. Crypto implementations remain in
+//! shadowsocks::crypto::v2::udp; this adapter owns framing and bounded lifetimes.
+use super::datagram::MAX_WIRE_PACKET;
+use aes::{
+    Aes128, Aes256, Block,
+    cipher::{BlockCipherDecrypt, BlockCipherEncrypt, KeyInit},
+};
+use bytes::{BufMut, BytesMut};
+use shadowsocks::{
+    ServerConfig,
+    context::Context,
+    crypto::{CipherKind, v2::udp::UdpCipher},
+    relay::{socks5::Address, udprelay::options::UdpSocketControlData},
+};
+use std::{
+    io,
+    time::{SystemTime, UNIX_EPOCH},
+};
+
+const TAG: usize = 16;
+const ID_PAIR: usize = 16;
+const RESPONSE_HEADER: usize = 35;
+const MAX_PADDING: usize = 900;
+
+pub(super) fn is_chacha(config: &ServerConfig) -> bool {
+    config.method() == CipherKind::AEAD2022_BLAKE3_CHACHA20_POLY1305
+}
+
+fn nonce_len(config: &ServerConfig) -> usize {
+    if is_chacha(config) { 24 } else { 0 }
+}
+
+fn invalid() -> io::Error {
+    io::Error::new(io::ErrorKind::InvalidData, "invalid Shadowsocks UDP packet")
+}
+
+fn timestamp() -> io::Result<u64> {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|time| time.as_secs())
+        .map_err(|_| invalid())
+}
+
+fn aes_header(method: CipherKind, key: &[u8], bytes: &mut [u8], decrypt: bool) -> io::Result<()> {
+    let block = <&mut Block>::try_from(bytes).map_err(|_| invalid())?;
+    match method {
+        CipherKind::AEAD2022_BLAKE3_AES_128_GCM => {
+            let aes = Aes128::new_from_slice(key).map_err(|_| invalid())?;
+            if decrypt {
+                aes.decrypt_block(block);
+            } else {
+                aes.encrypt_block(block);
+            }
+        }
+        CipherKind::AEAD2022_BLAKE3_AES_256_GCM => {
+            let aes = Aes256::new_from_slice(key).map_err(|_| invalid())?;
+            if decrypt {
+                aes.decrypt_block(block);
+            } else {
+                aes.encrypt_block(block);
+            }
+        }
+        _ => return Err(invalid()),
+    }
+    Ok(())
+}
+
+pub(super) fn encode_request(
+    context: &Context,
+    config: &ServerConfig,
+    cipher: &UdpCipher,
+    target: &Address,
+    control: &UdpSocketControlData,
+    payload: &[u8],
+) -> io::Result<BytesMut> {
+    let nonce = nonce_len(config);
+    let identities = config.identity_keys();
+    let eih = if is_chacha(config) {
+        0
+    } else {
+        identities.len().checked_mul(16).ok_or_else(invalid)?
+    };
+    // Preserve the existing maximum-padding check for empty requests. All
+    // possible padding bytes are initialized before the wire buffer is cleared.
+    let padding_limit = if payload.is_empty() { MAX_PADDING } else { 0 };
+    let maximum = nonce
+        .checked_add(43)
+        .and_then(|n| n.checked_add(eih))
+        .and_then(|n| n.checked_add(target.serialized_len()))
+        .and_then(|n| n.checked_add(payload.len()))
+        .and_then(|n| n.checked_add(padding_limit))
+        .filter(|n| *n <= MAX_WIRE_PACKET)
+        .ok_or_else(invalid)?;
+    let padding = if payload.is_empty() {
+        rand::random_range(0..=MAX_PADDING)
+    } else {
+        0
+    };
+    let mut wire = if payload.is_empty() {
+        let mut initialized = BytesMut::zeroed(maximum);
+        rand::fill(&mut initialized[..]);
+        initialized.clear();
+        initialized
+    } else {
+        BytesMut::with_capacity(maximum)
+    };
+    if nonce != 0 {
+        wire.resize(nonce, 0);
+        context.generate_nonce(config.method(), &mut wire[..nonce], false);
+    }
+    let mut ids = [0u8; ID_PAIR];
+    ids[..8].copy_from_slice(&control.client_session_id.to_be_bytes());
+    ids[8..].copy_from_slice(&control.packet_id.to_be_bytes());
+    wire.extend_from_slice(&ids);
+    if eih != 0 {
+        for (index, identity) in identities.iter().enumerate() {
+            let next = identities
+                .get(index + 1)
+                .map_or(config.key(), |key| key.as_ref());
+            let digest = blake3::hash(next);
+            let mut block = ids;
+            for (byte, hash) in block.iter_mut().zip(&digest.as_bytes()[..16]) {
+                *byte ^= *hash;
+            }
+            aes_header(config.method(), identity, &mut block, false)?;
+            wire.extend_from_slice(&block);
+        }
+    }
+    wire.put_u8(0);
+    wire.put_u64(timestamp()?);
+    wire.put_u16(padding as u16);
+    let start = wire.len();
+    wire.resize(start + padding, 0);
+    rand::fill(&mut wire[start..]);
+    target.write_to_buf(&mut wire);
+    wire.extend_from_slice(payload);
+    wire.resize(wire.len() + TAG, 0);
+    if nonce != 0 {
+        let (nonce, message) = wire.split_at_mut(nonce);
+        cipher.encrypt_packet(nonce, message);
+    } else {
+        cipher.encrypt_packet(&ids[4..], &mut wire[ID_PAIR + eih..]);
+        let header_key = identities.first().map_or(config.key(), |key| key.as_ref());
+        aes_header(config.method(), header_key, &mut wire[..ID_PAIR], false)?;
+    }
+    if wire.len() > MAX_WIRE_PACKET {
+        return Err(invalid());
+    }
+    Ok(wire)
+}
+
+// AES's visible header supplies only a tentative session ID. It is NOT an
+// authenticated cache key: callers may use a temporary cipher, then promote it
+// only after every packet/control/address/replay check succeeds.
+pub(super) fn prepare_response(
+    config: &ServerConfig,
+    packet: &mut [u8],
+) -> io::Result<Option<u64>> {
+    if packet.len() < nonce_len(config) + RESPONSE_HEADER + TAG {
+        return Err(invalid());
+    }
+    if is_chacha(config) {
+        return Ok(None);
+    }
+    aes_header(config.method(), config.key(), &mut packet[..ID_PAIR], true)?;
+    Ok(Some(u64::from_be_bytes(packet[..8].try_into().unwrap())))
+}
+
+pub(super) fn decode_response(
+    config: &ServerConfig,
+    cipher: &UdpCipher,
+    packet: &mut [u8],
+) -> io::Result<(usize, Address, UdpSocketControlData)> {
+    let nonce = nonce_len(config);
+    if packet.len() < nonce + RESPONSE_HEADER + TAG {
+        return Err(invalid());
+    }
+    let authenticated = if nonce != 0 {
+        let (nonce, message) = packet.split_at_mut(nonce);
+        cipher.decrypt_packet(nonce, message)
+    } else {
+        let (header, message) = packet.split_at_mut(ID_PAIR);
+        cipher.decrypt_packet(&header[4..], message)
+    };
+    if !authenticated {
+        return Err(invalid());
+    }
+    let message = &packet[nonce..packet.len() - TAG];
+    if message[16] != 1 {
+        return Err(invalid());
+    }
+    let time = u64::from_be_bytes(message[17..25].try_into().unwrap());
+    if timestamp()?.abs_diff(time) > 30 {
+        return Err(invalid());
+    }
+    let padding = usize::from(u16::from_be_bytes(message[33..35].try_into().unwrap()));
+    let address = message
+        .get(RESPONSE_HEADER + padding..)
+        .ok_or_else(invalid)?;
+    let mut cursor = io::Cursor::new(address);
+    let source = Address::read_cursor(&mut cursor).map_err(|_| invalid())?;
+    let mut control = UdpSocketControlData::default();
+    control.server_session_id = u64::from_be_bytes(message[..8].try_into().unwrap());
+    control.packet_id = u64::from_be_bytes(message[8..16].try_into().unwrap());
+    control.client_session_id = u64::from_be_bytes(message[25..33].try_into().unwrap());
+    let start = nonce + RESPONSE_HEADER + padding + cursor.position() as usize;
+    let end = packet.len() - TAG;
+    let size = end.checked_sub(start).ok_or_else(invalid)?;
+    packet.copy_within(start..end, 0);
+    Ok((size, source, control))
+}
diff --git a/src/outbound/shadowsocks/datagram_tests.rs b/src/outbound/shadowsocks/datagram_tests.rs
index c4a8055..96f47d8 100644
--- a/src/outbound/shadowsocks/datagram_tests.rs
+++ b/src/outbound/shadowsocks/datagram_tests.rs
@@ -1,5 +1,7 @@
+use super::super::packet_io::PacketIo;
 use super::*;
 use base64::{Engine as _, engine::general_purpose::STANDARD};
+use shadowsocks::relay::udprelay::{ProxySocket, proxy_socket::UdpSocketType};
 use shadowsocks::{config::ServerType, context::Context, crypto::CipherKind};
 use std::sync::{
     Arc,
@@ -22,6 +24,10 @@ struct MockTransport {
 
 #[async_trait]
 impl DatagramTransport for MockTransport {
+    fn supports_shared_destinations(&self) -> bool {
+        false
+    }
+
     async fn send(&mut self, packet: Datagram) -> Result<(), DispatchError> {
         self.permits.acquire().await.unwrap().forget();
         self.sent.send(packet).await.unwrap();
@@ -58,6 +64,11 @@ impl Fixture {
             method,
         )
         .unwrap();
+        let config = Arc::new(config);
+        Self::with_configs(config.clone(), &config, maximum)
+    }
+
+    fn with_configs(config: Arc<ServerConfig>, server_config: &ServerConfig, maximum: u16) -> Self {
         let (tx, sent) = mpsc::channel(32);
         let (replies, rx) = mpsc::channel(32);
         let permits = Arc::new(Semaphore::new(0));
@@ -72,7 +83,7 @@ impl Fixture {
             Box::new(inner),
             Destination::Ip("127.0.0.1:12345".parse().unwrap()),
             Context::new_shared(ServerType::Local),
-            &config,
+            config,
             maximum,
             maximum.saturating_add(MAX_RESPONSE_HEADER),
         );
@@ -80,7 +91,7 @@ impl Fixture {
         let server = ProxySocket::from_socket(
             UdpSocketType::Server,
             Context::new_shared(ServerType::Server),
-            &config,
+            server_config,
             io.clone(),
         );
         Self {
@@ -135,6 +146,251 @@ fn request(payload: &'static [u8]) -> Datagram {
     }
 }
 
+#[tokio::test]
+async fn udp_authenticated_invalid_headers_do_not_advance_the_replay_window() {
+    use aes::cipher::{BlockCipherEncrypt, KeyInit};
+    use bytes::{BufMut, BytesMut};
+    use shadowsocks::crypto::v2::udp::UdpCipher;
+    use std::time::{SystemTime, UNIX_EPOCH};
+
+    for name in CIPHERS {
+        let method: CipherKind = name.parse().unwrap();
+        let mut f = Fixture::new(name, 1500);
+        let key = vec![7; method.key_len()];
+        let nonce_len = if name == CIPHERS[2] { 24 } else { 0 };
+        let now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_secs();
+        for (index, (role, time, padding)) in [
+            (0, now, 0),
+            (1, now - 3600, 0),
+            (1, now + 3600, 0),
+            (1, now, u16::MAX),
+            (1, now, 0),
+        ]
+        .into_iter()
+        .enumerate()
+        {
+            let mut wire = BytesMut::new();
+            if nonce_len != 0 {
+                let mut nonce = [0u8; 24];
+                nonce[23] = index as u8;
+                wire.extend_from_slice(&nonce);
+            }
+            wire.put_u64(1);
+            wire.put_u64(1);
+            wire.put_u8(role);
+            wire.put_u64(time);
+            wire.put_u64(f.client.control.client_session_id);
+            wire.put_u16(padding);
+            super::super::address(&target()).write_to_buf(&mut wire);
+            wire.extend_from_slice(b"invalid-header");
+            if index == 4 {
+                wire.truncate(nonce_len + 27);
+            }
+            wire.resize(wire.len() + 16, 0);
+            let cipher = UdpCipher::new(method, &key, 1);
+            if nonce_len != 0 {
+                let (nonce, message) = wire.split_at_mut(nonce_len);
+                cipher.encrypt_packet(nonce, message);
+            } else {
+                let nonce: [u8; 12] = wire[4..16].try_into().unwrap();
+                cipher.encrypt_packet(&nonce, &mut wire[16..]);
+                let block = <&mut aes::Block>::try_from(&mut wire[..16]).unwrap();
+                if name == CIPHERS[0] {
+                    aes::Aes128::new_from_slice(&key)
+                        .unwrap()
+                        .encrypt_block(block);
+                } else {
+                    aes::Aes256::new_from_slice(&key)
+                        .unwrap()
+                        .encrypt_block(block);
+                }
+            }
+            f.replies
+                .send(Datagram {
+                    remote: f.client.server.clone(),
+                    payload: wire.freeze(),
+                    sniffed_domain: None,
+                })
+                .await
+                .unwrap();
+        }
+        let valid = f.response(&f.control(1, 1), b"valid-after-rejection").await;
+        f.replies.send(valid).await.unwrap();
+        let received = tokio::time::timeout(Duration::from_secs(1), f.client.receive())
+            .await
+            .unwrap()
+            .unwrap();
+        assert_eq!(received.remote, target());
+        assert_eq!(received.payload, &b"valid-after-rejection"[..]);
+        assert_eq!(f.client.sessions.len(), 1);
+        f.client.close().await.unwrap();
+    }
+}
+
+#[tokio::test]
+async fn udp_empty_payload_preserves_cancellation_ids_and_official_decoding() {
+    for name in CIPHERS {
+        let mut f = Fixture::new(name, 1500);
+        let session_id = f.client.control.client_session_id;
+        let mut pending = Box::pin(f.client.send(request(b"")));
+        assert!(futures_util::poll!(&mut pending).is_pending());
+        drop(pending);
+        assert_eq!(f.client.control.packet_id, 1);
+        assert!(f.sent.try_recv().is_err());
+
+        f.permits.add_permits(2);
+        f.client.send(request(b"")).await.unwrap();
+        let wire = f.sent.recv().await.unwrap();
+        let minimum = f.client.request_header + super::super::address(&target()).serialized_len();
+        assert!((minimum..=minimum + 900).contains(&wire.payload.len()));
+        let (body, control) = f.decode_request(wire).await;
+        assert!(body.is_empty());
+        assert_eq!(control.client_session_id, session_id);
+        assert_eq!(control.packet_id, 2);
+
+        // Switching back to the ordinary nonempty codec keeps one association
+        // and never replays the cancelled empty packet or a stale handoff.
+        f.client.send(request(b"after-empty")).await.unwrap();
+        let wire = f.sent.recv().await.unwrap();
+        let (body, control) = f.decode_request(wire).await;
+        assert_eq!(body, b"after-empty");
+        assert_eq!(control.client_session_id, session_id);
+        assert_eq!(control.packet_id, 3);
+        assert!(f.sent.try_recv().is_err());
+        f.client.close().await.unwrap();
+        assert!(f.closed.load(Ordering::SeqCst));
+    }
+}
+
+#[tokio::test]
+async fn udp_empty_payload_keeps_aes_eih_authentication() {
+    use shadowsocks::config::{ServerUser, ServerUserManager};
+
+    for name in &CIPHERS[..2] {
+        let method: CipherKind = name.parse().unwrap();
+        let identity = vec![3; method.key_len()];
+        let user_key = vec![7; method.key_len()];
+        let password = format!(
+            "{}:{}",
+            STANDARD.encode(&identity),
+            STANDARD.encode(&user_key)
+        );
+        let config = Arc::new(ServerConfig::new(("127.0.0.1", 12345), password, method).unwrap());
+        let mut server_config =
+            ServerConfig::new(("127.0.0.1", 12345), STANDARD.encode(&identity), method).unwrap();
+        let mut users = ServerUserManager::new();
+        users.add_user(ServerUser::new("fixture", user_key.clone()));
+        server_config.set_user_manager(users);
+        let mut f = Fixture::with_configs(config, &server_config, 1500);
+        f.permits.add_permits(1);
+        f.client.send(request(b"")).await.unwrap();
+        let wire = f.sent.recv().await.unwrap();
+        let minimum = f.client.request_header + super::super::address(&target()).serialized_len();
+        assert!((minimum..=minimum + 900).contains(&wire.payload.len()));
+        let (body, control) = f.decode_request(wire).await;
+        assert!(body.is_empty());
+        assert_eq!(
+            control.client_session_id,
+            f.client.control.client_session_id
+        );
+        assert_eq!(control.packet_id, 1);
+        assert_eq!(control.user.unwrap().key(), user_key);
+        f.client.close().await.unwrap();
+    }
+}
+
+#[tokio::test]
+async fn udp_busy_sender_yields_before_accepting_another_wire_packet() {
+    for name in CIPHERS {
+        let mut f = Fixture::new(name, 1500);
+        f.permits.add_permits(2 * SEND_BURST + 1);
+        for _ in 0..SEND_BURST {
+            f.client.send(request(b"burst")).await.unwrap();
+        }
+        // With writable IO, a new send must give other ready tasks a turn
+        // before adding another packet to the physical peer's burst.
+        let mut sending = Box::pin(f.client.send(request(b"after-burst")));
+        assert!(futures_util::poll!(&mut sending).is_pending());
+        assert_eq!(f.sent.len(), SEND_BURST);
+        drop(sending);
+        // Cancellation at that scheduling boundary has not encoded or sent
+        // the new packet, and must not poison its nonce/control ownership.
+        f.client.send(request(b"resumed")).await.unwrap();
+        assert_eq!(f.sent.len(), SEND_BURST + 1);
+        assert_eq!(f.client.control.packet_id, SEND_BURST as u64 + 1);
+        let progressed = Arc::new(AtomicBool::new(false));
+        let sibling = {
+            let progressed = progressed.clone();
+            tokio::spawn(async move { progressed.store(true, Ordering::SeqCst) })
+        };
+        tokio::time::timeout(Duration::from_secs(1), async {
+            for _ in 0..SEND_BURST {
+                f.client.send(request(b"more")).await.unwrap();
+            }
+        })
+        .await
+        .expect("writable packets must continue after yielding");
+        assert!(
+            progressed.load(Ordering::SeqCst),
+            "busy sending starved a ready sibling"
+        );
+        sibling.await.unwrap();
+        assert_eq!(f.sent.len(), 2 * SEND_BURST + 1);
+        f.client.close().await.unwrap();
+    }
+}
+
+#[tokio::test]
+async fn udp_one_session_preserves_multiple_ip_targets_across_receive_cancellation() {
+    for name in CIPHERS {
+        let mut f = Fixture::new(name, 1500);
+        let shareable = f.client.supports_shared_destinations();
+        let id = f.client.control.client_session_id;
+        for (index, address) in ["192.0.2.1:53", "[2001:db8::1]:443", "192.0.2.1:54"]
+            .into_iter()
+            .enumerate()
+        {
+            assert!(futures_util::poll!(f.client.receive()).is_pending());
+            let target = Destination::Ip(address.parse().unwrap());
+            let packet = Datagram {
+                remote: target.clone(),
+                payload: Bytes::from_static(b"multi-target"),
+                sniffed_domain: None,
+            };
+            f.permits.add_permits(1);
+            f.client.send(packet.clone()).await.unwrap();
+            f.io.put(f.sent.recv().await.unwrap().payload).unwrap();
+            let mut buffer = [0; 2048];
+            let (size, actual, _, control) = f.server.recv_with_ctrl(&mut buffer).await.unwrap();
+            assert_eq!(actual, super::super::address(&target));
+            assert_eq!(&buffer[..size], packet.payload);
+            assert_eq!(control.unwrap().client_session_id, id);
+            f.server
+                .send_with_ctrl(&actual, &f.control(7, index as u64 + 1), &buffer[..size])
+                .await
+                .unwrap();
+            f.replies
+                .send(Datagram {
+                    remote: f.client.server.clone(),
+                    payload: f.io.take().unwrap(),
+                    sniffed_domain: None,
+                })
+                .await
+                .unwrap();
+            assert_eq!(f.client.receive().await.unwrap(), packet);
+        }
+        f.client.close().await.unwrap();
+        assert!(f.closed.load(Ordering::SeqCst));
+        assert!(
+            shareable,
+            "multi-target SS must not allocate a transport per IP target"
+        );
+    }
+}
+
 #[tokio::test]
 async fn udp_three_ciphers_pending_cancel_exactly_once_and_close() {
     for name in CIPHERS {
@@ -150,7 +406,6 @@ async fn udp_three_ciphers_pending_cancel_exactly_once_and_close() {
         );
         assert_eq!(f.client.control.packet_id, 1);
         assert!(f.sent.try_recv().is_err());
-        assert!(f.client.io.take().is_err());
         f.permits.add_permits(1);
         f.client.send(request(b"once")).await.unwrap();
         let wire = f.sent.recv().await.unwrap();
@@ -275,7 +530,6 @@ async fn udp_invalid_packets_and_limits_do_not_poison_replay_state() {
             assert_eq!(actual.payload.len(), usize::from(maximum));
             assert!(actual.payload.iter().all(|byte| *byte == 0x5a));
             assert_eq!(f.client.sessions.len(), 1);
-            assert!(f.client.io.take().is_err());
         }
     }
 }
@@ -316,7 +570,6 @@ async fn udp_encoded_wire_exact_limit_and_one_over_never_reach_inner_io() {
                 .is_err()
         );
         assert!(f.sent.try_recv().is_err());
-        assert!(f.client.io.take().is_err());
         // A rejected oversized send neither poisons the slot nor reuses its ID.
         f.client.send(request(b"after-limit")).await.unwrap();
         let sent = f.sent.recv().await.unwrap();
@@ -330,3 +583,111 @@ async fn udp_encoded_wire_exact_limit_and_one_over_never_reach_inner_io() {
         );
     }
 }
+
+#[tokio::test]
+async fn udp_session_owned_codec_keeps_nonempty_eih_cancel_ids_and_encoded_limit() {
+    use shadowsocks::config::{ServerUser, ServerUserManager};
+
+    for name in &CIPHERS[..2] {
+        let method: CipherKind = name.parse().unwrap();
+        let identity = vec![3; method.key_len()];
+        let user_key = vec![7; method.key_len()];
+        let password = format!(
+            "{}:{}",
+            STANDARD.encode(&identity),
+            STANDARD.encode(&user_key)
+        );
+        let config = Arc::new(ServerConfig::new(("127.0.0.1", 12345), password, method).unwrap());
+        assert_eq!(config.identity_keys().len(), 1);
+        let mut server_config =
+            ServerConfig::new(("127.0.0.1", 12345), STANDARD.encode(&identity), method).unwrap();
+        let mut users = ServerUserManager::new();
+        users.add_user(ServerUser::new("fixture", user_key.clone()));
+        server_config.set_user_manager(users);
+        let mut f = Fixture::with_configs(config, &server_config, MAX_WIRE_PACKET as u16);
+        let session_id = f.client.control.client_session_id;
+
+        let mut cancelled = Box::pin(f.client.send(request(b"cancelled-EIH")));
+        assert!(futures_util::poll!(&mut cancelled).is_pending());
+        drop(cancelled);
+        assert_eq!(f.client.control.packet_id, 1);
+        assert!(f.sent.try_recv().is_err());
+
+        f.permits.add_permits(3);
+        let payload = b"nonempty-EIH-body";
+        f.client.send(request(payload)).await.unwrap();
+        let wire = f.sent.recv().await.unwrap();
+        let overhead = 43 + 16 + super::super::address(&target()).serialized_len();
+        assert_eq!(wire.payload.len(), overhead + payload.len());
+        let (body, control) = f.decode_request(wire).await;
+        assert_eq!(body, payload);
+        assert_eq!(control.client_session_id, session_id);
+        assert_eq!(control.packet_id, 2);
+        assert_eq!(control.user.unwrap().key(), user_key);
+
+        let packet = |length| Datagram {
+            remote: target(),
+            payload: Bytes::from(vec![0x5a; length]),
+            sniffed_domain: None,
+        };
+        f.client
+            .send(packet(MAX_WIRE_PACKET - overhead))
+            .await
+            .unwrap();
+        let wire = f.sent.recv().await.unwrap();
+        assert_eq!(wire.payload.len(), MAX_WIRE_PACKET);
+        let (body, control) = f.decode_request(wire).await;
+        assert_eq!(body.len(), MAX_WIRE_PACKET - overhead);
+        assert!(body.iter().all(|byte| *byte == 0x5a));
+        assert_eq!(control.client_session_id, session_id);
+        assert_eq!(control.packet_id, 3);
+        assert_eq!(control.user.unwrap().key(), user_key);
+
+        assert!(
+            f.client
+                .send(packet(MAX_WIRE_PACKET - overhead + 1))
+                .await
+                .is_err()
+        );
+        assert!(f.sent.try_recv().is_err());
+        f.client.send(request(b"after-limit")).await.unwrap();
+        let wire = f.sent.recv().await.unwrap();
+        let (body, control) = f.decode_request(wire).await;
+        assert_eq!(body, b"after-limit");
+        assert_eq!(control.client_session_id, session_id);
+        assert_eq!(control.packet_id, 5);
+        assert_eq!(control.user.unwrap().key(), user_key);
+        f.client.close().await.unwrap();
+        assert!(f.closed.load(Ordering::SeqCst));
+        assert!(f.client.send(request(b"closed")).await.is_err());
+    }
+}
+
+#[tokio::test]
+async fn udp_unauthenticated_session_ids_never_fill_retained_cipher_slots() {
+    for name in CIPHERS {
+        let mut f = Fixture::new(name, 1500);
+        for id in 100..116 {
+            let mut rejected = f.response(&f.control(id, 1), b"unauthenticated").await;
+            let mut bytes = rejected.payload.to_vec();
+            *bytes.last_mut().unwrap() ^= 1;
+            rejected.payload = bytes.into();
+            f.replies.send(rejected).await.unwrap();
+        }
+        let valid = f.response(&f.control(1, 1), b"first-valid-session").await;
+        f.replies.send(valid).await.unwrap();
+        let actual = tokio::time::timeout(Duration::from_secs(1), f.client.receive())
+            .await
+            .unwrap()
+            .unwrap();
+        assert_eq!(actual.payload, &b"first-valid-session"[..]);
+        assert_eq!(f.client.sessions.len(), 1);
+        assert_eq!(f.client.sessions[0].id, 1);
+        assert_eq!(f.client.sessions[0].cipher.is_some(), name != CIPHERS[2]);
+        assert!(f.client.tx_cipher.is_some());
+        f.client.close().await.unwrap();
+        assert!(f.client.tx_cipher.is_none());
+        assert!(f.client.sessions.is_empty());
+        assert!(f.closed.load(Ordering::SeqCst));
+    }
+}
diff --git a/src/outbound/shadowsocks/mod.rs b/src/outbound/shadowsocks/mod.rs
index 6ce6f7f..385208c 100644
--- a/src/outbound/shadowsocks/mod.rs
+++ b/src/outbound/shadowsocks/mod.rs
@@ -13,8 +13,11 @@ use shadowsocks::{ServerConfig, config::ServerType, context::Context};
 use std::{io, sync::Arc};
 
 mod datagram;
+mod datagram_codec;
+#[cfg(test)]
 mod packet_io;
 mod packet_window;
+mod plugin;
 mod stream;
 mod uot;
 
@@ -25,8 +28,7 @@ pub struct ShadowsocksOutbound {
     context: shadowsocks::context::SharedContext,
     upstream: UpstreamPath,
     uot: Option<Arc<uot::Owner>>,
-    #[cfg(feature = "shadow-tls-v3")]
-    shadow_tls: Option<crate::security::ShadowTlsClient>,
+    plugin: Option<Arc<plugin::Owner>>,
 }
 
 impl std::fmt::Debug for ShadowsocksOutbound {
@@ -41,18 +43,15 @@ impl ShadowsocksOutbound {
         config: &ShadowsocksOutboundConfig,
         upstream: UpstreamPath,
     ) -> io::Result<Self> {
-        Self::with_security(
-            config,
-            upstream,
-            #[cfg(feature = "shadow-tls-v3")]
-            None,
-        )
+        Self::with_security(config, upstream, None, 0, 64 * 1024)
     }
 
     pub(crate) fn with_security(
         config: &ShadowsocksOutboundConfig,
         upstream: UpstreamPath,
-        #[cfg(feature = "shadow-tls-v3")] security: Option<&crate::security::SecurityContext>,
+        security: Option<&crate::security::SecurityContext>,
+        sessions: usize,
+        buffer: usize,
     ) -> io::Result<Self> {
         config.validate().map_err(|_| {
             io::Error::new(
@@ -61,15 +60,20 @@ impl ShadowsocksOutbound {
             )
         })?;
         let server = server_destination(&config.address, config.port)?;
-        #[cfg(feature = "shadow-tls-v3")]
-        let shadow_tls = config
-            .shadow_tls
+        let plugin = config
+            .plugin
             .as_ref()
             .map(|options| {
-                let context = security.cloned().unwrap_or_default();
-                crate::security::ShadowTlsClient::new(&context, options)
+                plugin::Owner::new(
+                    options,
+                    &security.cloned().unwrap_or_default(),
+                    sessions,
+                    buffer,
+                    config.port,
+                )
             })
-            .transpose()?;
+            .transpose()?
+            .map(Arc::new);
         let method = config.cipher.as_str().parse().map_err(|_| {
             io::Error::new(
                 io::ErrorKind::InvalidInput,
@@ -94,8 +98,7 @@ impl ShadowsocksOutbound {
             context: Context::new_shared(ServerType::Local),
             upstream,
             uot,
-            #[cfg(feature = "shadow-tls-v3")]
-            shadow_tls,
+            plugin,
         })
     }
 }
@@ -108,27 +111,20 @@ impl OutboundConnector for ShadowsocksOutbound {
         context: &EstablishContext,
     ) -> Result<ConnectedStream, DispatchError> {
         let target = session.destination.clone();
-        let connected = self
-            .upstream
-            .connect_server(session, &self.server, context)
-            .await?;
-        let io = connected.io;
-        #[cfg(feature = "shadow-tls-v3")]
-        let io = if let Some(shadow_tls) = &self.shadow_tls {
-            context
-                .run_io("Shadowsocks ShadowTLS handshake", shadow_tls.connect(io))
+        let io = if let Some(plugin) = &self.plugin {
+            plugin
+                .open(&self.upstream, &self.server, session, context)
                 .await?
         } else {
-            io
+            self.upstream
+                .connect_server(session, &self.server, context)
+                .await?
+                .io
         };
-        let stream = shadowsocks::ProxyClientStream::from_stream(
-            self.context.clone(),
-            io,
-            &self.config,
-            address(&target),
-        );
+        let stream =
+            stream::SsStream::new(self.context.clone(), io, &self.config, address(&target));
         Ok(ConnectedStream {
-            io: Box::new(stream::SsStream::new(stream)),
+            io: Box::new(stream),
             effective_peer: target,
         })
     }
@@ -141,7 +137,10 @@ impl OutboundConnector for ShadowsocksOutbound {
         if let Some(uot) = &self.uot {
             return uot.open(self, request, context).await;
         }
-        let server = self.upstream.datagram_server(&self.server, context)?;
+        let server = self
+            .upstream
+            .ip4p_datagram_server(&self.server, context)
+            .await?;
         let maximum = request.max_response_payload_size();
         let wire_maximum = maximum.saturating_add(datagram::MAX_RESPONSE_HEADER);
         let inner = self
@@ -159,7 +158,7 @@ impl OutboundConnector for ShadowsocksOutbound {
                 inner,
                 server,
                 self.context.clone(),
-                &self.config,
+                self.config.clone(),
                 maximum,
                 wire_maximum,
             )),
@@ -168,12 +167,18 @@ impl OutboundConnector for ShadowsocksOutbound {
     }
 
     fn begin_shutdown(&self) {
+        if let Some(plugin) = &self.plugin {
+            plugin.begin_shutdown();
+        }
         if let Some(uot) = &self.uot {
             uot.begin_shutdown();
         }
     }
 
     async fn shutdown(&self) {
+        if let Some(plugin) = &self.plugin {
+            plugin.shutdown().await;
+        }
         if let Some(uot) = &self.uot {
             uot.shutdown().await;
         }
diff --git a/src/outbound/shadowsocks/packet_io.rs b/src/outbound/shadowsocks/packet_io.rs
index f4c7ef8..24d3b3d 100644
--- a/src/outbound/shadowsocks/packet_io.rs
+++ b/src/outbound/shadowsocks/packet_io.rs
@@ -10,7 +10,7 @@ use std::{
 };
 use tokio::io::ReadBuf;
 
-pub(crate) const MAX_WIRE_PACKET: usize = 65_507;
+use super::datagram::MAX_WIRE_PACKET;
 
 #[derive(Clone, Default)]
 pub(crate) struct PacketIo(Arc<Mutex<Option<Bytes>>>);
diff --git a/src/outbound/shadowsocks/plugin.rs b/src/outbound/shadowsocks/plugin.rs
new file mode 100644
index 0000000..1f09db8
--- /dev/null
+++ b/src/outbound/shadowsocks/plugin.rs
@@ -0,0 +1,138 @@
+//! Stream plugins are below SS2022; UDP stays native unless UoT is configured.
+use crate::{
+    config::{SecurityConfig, ShadowsocksPlugin, StreamTransport},
+    dispatch::{BoxStream, DispatchError},
+    outbound::{EstablishContext, UpstreamPath, owned_stream::OwnedStream},
+    security::{SecurityClient, SecurityContext},
+    session::{Destination, StreamSession},
+    transport::{self, ss_framed},
+};
+use std::{io, sync::Mutex};
+use tokio_util::{sync::CancellationToken, task::TaskTracker};
+enum Kind {
+    Security(SecurityClient),
+    Obfs {
+        tls: bool,
+        host: String,
+        port: u16,
+    },
+    WebSocket {
+        security: Option<SecurityClient>,
+        transport: StreamTransport,
+        gost: bool,
+        mux: bool,
+    },
+}
+pub(super) struct Owner {
+    kind: Kind,
+    cancel: CancellationToken,
+    tasks: TaskTracker,
+    closed: Mutex<bool>,
+}
+impl Owner {
+    pub(super) fn new(
+        config: &ShadowsocksPlugin,
+        context: &SecurityContext,
+        sessions: usize,
+        buffer: usize,
+        port: u16,
+    ) -> io::Result<Self> {
+        let kind = match config {
+            ShadowsocksPlugin::ShadowTls(config) => {
+                Kind::Security(SecurityClient::from_security_with_context(
+                    &SecurityConfig::ShadowTls(config.clone()),
+                    context,
+                    0,
+                    buffer,
+                )?)
+            }
+            ShadowsocksPlugin::Jls(config) => {
+                Kind::Security(SecurityClient::from_security_with_context(
+                    &SecurityConfig::Jls(config.clone()),
+                    context,
+                    0,
+                    buffer,
+                )?)
+            }
+            ShadowsocksPlugin::Obfs { tls, host } => Kind::Obfs {
+                tls: *tls,
+                host: host.clone(),
+                port,
+            },
+            ShadowsocksPlugin::WebSocket {
+                gost,
+                mux,
+                transport,
+                tls,
+            } => Kind::WebSocket {
+                security: tls
+                    .as_ref()
+                    .map(|config| {
+                        SecurityClient::from_security_with_context(
+                            &SecurityConfig::Tls(config.clone()),
+                            context,
+                            sessions,
+                            buffer,
+                        )
+                    })
+                    .transpose()?,
+                transport: transport.clone(),
+                gost: *gost,
+                mux: *mux,
+            },
+        };
+        Ok(Self {
+            kind,
+            cancel: CancellationToken::new(),
+            tasks: TaskTracker::new(),
+            closed: Mutex::new(false),
+        })
+    }
+    pub(super) async fn open(
+        &self,
+        upstream: &UpstreamPath,
+        server: &Destination,
+        session: StreamSession,
+        context: &EstablishContext,
+    ) -> Result<BoxStream, DispatchError> {
+        tokio::select! {biased;
+            ()=self.cancel.cancelled()=>Err(DispatchError::NotAllowed),
+            result=async {
+                let raw=upstream.connect_server(session,server,context).await?.io;
+                match &self.kind {
+                    Kind::Security(security)=>context.run_io("Shadowsocks plugin identity",security.connect_with_context(raw,context)).await,
+                    Kind::Obfs {tls,host,port}=>Ok(ss_framed::wrap(raw,if *tls{ss_framed::Kind::Tls {host:host.clone()}}else{ss_framed::Kind::Http {host:host.clone(),port:*port}})),
+                    Kind::WebSocket {security,transport,gost,mux}=>{
+                        let raw=if let Some(security)=security {context.run_io("Shadowsocks plugin TLS",security.connect_with_context(raw,context)).await?}else{raw};
+                        let options=transport.websocket_options()?.expect("validated WebSocket plugin");
+                        let raw=transport::connect_websocket(raw,&options,&[],context.deadline()).await?;
+                        if !mux {return Ok(raw);}
+                        if !gost{return Ok(ss_framed::wrap(raw,ss_framed::Kind::V2rayMux));}
+                        let cancel=self.cancel.child_token();let guard=cancel.clone().drop_guard();
+                        let (client,driver)=transport::smux::new(raw);
+                        let stopped=cancel.clone();
+                        let observation=crate::resources::observation::track(crate::resources::observation::ResourceKind::Task);
+                        {
+                            let closed=self.closed.lock().unwrap();
+                            if *closed { return Err(DispatchError::NotAllowed); }
+                            self.tasks.spawn(crate::resources::observation::bind(async move {let _observation=observation;tokio::select!{biased;()=stopped.cancelled()=>{},_=driver=>{}}stopped.cancel();}));
+                        }
+                        let raw=context.run_io("Shadowsocks Gost smux",client.open()).await?;
+                        guard.disarm();
+                        Ok(Box::new(OwnedStream::new(raw,cancel))as BoxStream)
+                    }
+                }
+            }=>result,
+        }
+    }
+    pub(super) fn begin_shutdown(&self) {
+        self.cancel.cancel();
+        let mut closed = self.closed.lock().unwrap();
+        *closed = true;
+        self.tasks.close();
+    }
+    pub(super) async fn shutdown(&self) {
+        self.begin_shutdown();
+        self.tasks.wait().await;
+    }
+}
diff --git a/src/outbound/shadowsocks/stream.rs b/src/outbound/shadowsocks/stream.rs
index 267fe27..02977ef 100644
--- a/src/outbound/shadowsocks/stream.rs
+++ b/src/outbound/shadowsocks/stream.rs
@@ -1,5 +1,12 @@
 use crate::dispatch::BoxStream;
-use shadowsocks::ProxyClientStream;
+use shadowsocks::{
+    ServerConfig,
+    context::SharedContext,
+    relay::{
+        socks5::Address,
+        tcprelay::crypto_io::{CryptoRead, CryptoStream, CryptoWrite, StreamType},
+    },
+};
 use std::{
     io,
     pin::Pin,
@@ -7,42 +14,75 @@ use std::{
 };
 use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
 
-// Keep each codec call bounded, including the target header on the first
-// write. The upstream first-write wrapper expects that entire frame to fit
-// within the SS 2022 u16 payload limit. Larger caller buffers use partial writes.
 use crate::limits::SHADOWSOCKS_WRITE_CHUNK as WRITE_CHUNK;
 
+const MAX_PADDING: usize = 900;
+
 enum Start {
-    Fresh,
+    Fresh(Address),
     EmptyPending,
     EmptyFlushing,
     Started,
 }
 
 pub(super) struct SsStream {
-    inner: ProxyClientStream<BoxStream>,
+    inner: CryptoStream<BoxStream>,
+    context: SharedContext,
     start: Start,
     pending: Option<Vec<u8>>,
+    response_checked: bool,
 }
 
 impl SsStream {
-    pub(super) fn new(inner: ProxyClientStream<BoxStream>) -> Self {
+    pub(super) fn new(
+        context: SharedContext,
+        io: BoxStream,
+        config: &ServerConfig,
+        target: Address,
+    ) -> Self {
         Self {
-            inner,
-            start: Start::Fresh,
+            inner: CryptoStream::from_stream_with_identity(
+                &context,
+                io,
+                StreamType::Client,
+                config.method(),
+                config.key(),
+                config.identity_keys(),
+                None,
+            ),
+            context,
+            start: Start::Fresh(target),
             pending: None,
+            response_checked: false,
         }
     }
+
+    fn first_packet(&mut self, payload: &[u8]) -> Vec<u8> {
+        let Start::Fresh(target) = std::mem::replace(&mut self.start, Start::Started) else {
+            unreachable!("Shadowsocks target header was already consumed");
+        };
+        let padding = if payload.is_empty() {
+            rand::random_range(1..=MAX_PADDING)
+        } else {
+            0
+        };
+        request_packet(&target, payload, padding)
+    }
+
+    fn begin_empty(&mut self) {
+        self.pending = Some(self.first_packet(&[]));
+        self.start = Start::EmptyPending;
+    }
+
     fn finish_empty(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
         if matches!(self.start, Start::EmptyPending) {
-            ready!(Pin::new(&mut self.inner).poll_write(cx, &[])).map_err(super::safe_io)?;
+            ready!(self.finish_write(cx))?;
             self.start = Start::EmptyFlushing;
         }
         if matches!(self.start, Start::EmptyFlushing) {
-            // A buffered carrier may accept the target header without sending
-            // it. The internally generated read-first handshake owns its flush;
-            // no application write is available to make it reach the server.
-            ready!(Pin::new(&mut self.inner).poll_flush(cx)).map_err(super::safe_io)?;
+            // Buffered carriers need a flush when no application payload can
+            // make the target header reach the server.
+            ready!(self.inner.poll_flush(cx)).map_err(|error| super::safe_io(error.into()))?;
             self.start = Start::Started;
         }
         Poll::Ready(Ok(()))
@@ -50,11 +90,10 @@ impl SsStream {
 
     fn finish_write(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
         if let Some(bytes) = &self.pending {
-            // The official codec retains its encrypted frame on Pending but
-            // reports the retry buffer's length. Keep that input stable even
-            // when a caller (including Tokio copy) tops up its own buffer.
-            let written =
-                ready!(Pin::new(&mut self.inner).poll_write(cx, bytes)).map_err(super::safe_io)?;
+            // The official writer reports the retry slice's length after
+            // draining its frame, so retain the original input across Pending.
+            let written = ready!(Pin::new(&mut self.inner).poll_write_encrypted(cx, bytes))
+                .map_err(|error| super::safe_io(error.into()))?;
             if written != bytes.len() {
                 return Poll::Ready(Err(io::Error::other(
                     "Shadowsocks buffered write was incomplete",
@@ -66,71 +105,116 @@ impl SsStream {
     }
 }
 
+// Only the request prelude is assembled here. The official CryptoStream owns
+// salts, EIH, AEAD framing and authentication. Initialize before randomizing so
+// every byte is defined even when an allocator reuses old storage.
+fn request_packet(target: &Address, payload: &[u8], padding: usize) -> Vec<u8> {
+    let mut packet = Vec::with_capacity(target.serialized_len() + 2 + padding + payload.len());
+    target.write_to_buf(&mut packet);
+    packet.extend_from_slice(&(padding as u16).to_be_bytes());
+    let start = packet.len();
+    packet.resize(start + padding, 0);
+    rand::fill(&mut packet[start..]);
+    packet.extend_from_slice(payload);
+    packet
+}
+
 impl AsyncRead for SsStream {
     fn poll_read(
-        mut self: Pin<&mut Self>,
+        self: Pin<&mut Self>,
         cx: &mut Context<'_>,
         buf: &mut ReadBuf<'_>,
     ) -> Poll<io::Result<()>> {
         if buf.remaining() == 0 {
             return Poll::Ready(Ok(()));
         }
-        // Client-first writes remain combined with the target header. Reading
-        // before the first write requests the upstream's empty handshake.
-        if matches!(self.start, Start::Fresh) {
-            self.start = Start::EmptyPending;
+        let this = self.get_mut();
+        if matches!(this.start, Start::Fresh(_)) {
+            this.begin_empty();
         }
-        ready!(self.finish_empty(cx))?;
-        // Progress buffered output while waiting for a response, but do not
-        // block reads on a full write side: both directions may be backpressured.
-        if let Poll::Ready(result) = self.finish_write(cx) {
+        ready!(this.finish_empty(cx))?;
+        // Advance accepted writes without blocking reads on a full write side.
+        if let Poll::Ready(result) = this.finish_write(cx) {
             result?;
         }
-        Pin::new(&mut self.inner)
-            .poll_read(cx, buf)
-            .map_err(super::safe_io)
+        let result = Pin::new(&mut this.inner)
+            .poll_read_decrypted(cx, &this.context, buf)
+            .map_err(|error| super::safe_io(error.into()));
+        if !this.response_checked
+            && let Some(request_nonce) = this.inner.received_request_nonce()
+        {
+            // This nonce is exposed only after authenticating the response
+            // header. Bind it before returning plaintext, even when the body
+            // remains pending.
+            if request_nonce != this.inner.sent_nonce() {
+                return Poll::Ready(Err(super::safe_io(io::Error::new(
+                    io::ErrorKind::InvalidData,
+                    "Shadowsocks response did not match its request",
+                ))));
+            }
+            this.response_checked = true;
+        }
+        result
     }
 }
 
 impl AsyncWrite for SsStream {
     fn poll_write(
-        mut self: Pin<&mut Self>,
+        self: Pin<&mut Self>,
         cx: &mut Context<'_>,
         buf: &[u8],
     ) -> Poll<io::Result<usize>> {
-        ready!(self.finish_empty(cx))?;
-        ready!(self.finish_write(cx))?;
-        // Mark before polling: a concurrent read must not replace an in-flight
-        // first payload with an empty write while upstream reports Pending.
-        self.start = Start::Started;
-        let buf = &buf[..buf.len().min(WRITE_CHUNK)];
-        match Pin::new(&mut self.inner).poll_write(cx, buf) {
+        let this = self.get_mut();
+        ready!(this.finish_empty(cx))?;
+        ready!(this.finish_write(cx))?;
+        if buf.is_empty() {
+            if matches!(this.start, Start::Fresh(_)) {
+                this.begin_empty();
+                ready!(this.finish_empty(cx))?;
+            }
+            return Poll::Ready(Ok(0));
+        }
+        let payload = &buf[..buf.len().min(WRITE_CHUNK)];
+        if matches!(this.start, Start::Fresh(_)) {
+            this.pending = Some(this.first_packet(payload));
+            // Accept one bounded payload while keeping the complete first
+            // frame stable for reads, flush and later writes under backpressure.
+            if let Poll::Ready(result) = this.finish_write(cx) {
+                result?;
+            }
+            return Poll::Ready(Ok(payload.len()));
+        }
+        match Pin::new(&mut this.inner).poll_write_encrypted(cx, payload) {
             Poll::Pending => {
-                // Accept exactly this bounded chunk into owned storage now;
-                // subsequent writes/flush/shutdown resume the same codec call.
-                self.pending = Some(buf.to_vec());
-                Poll::Ready(Ok(buf.len()))
+                this.pending = Some(payload.to_vec());
+                Poll::Ready(Ok(payload.len()))
+            }
+            Poll::Ready(result) => {
+                Poll::Ready(result.map_err(|error| super::safe_io(error.into())))
             }
-            Poll::Ready(result) => Poll::Ready(result.map_err(super::safe_io)),
         }
     }
-    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        ready!(self.finish_empty(cx))?;
-        ready!(self.finish_write(cx))?;
-        Pin::new(&mut self.inner)
+
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let this = self.get_mut();
+        ready!(this.finish_empty(cx))?;
+        ready!(this.finish_write(cx))?;
+        this.inner
             .poll_flush(cx)
-            .map_err(super::safe_io)
+            .map_err(|error| super::safe_io(error.into()))
     }
-    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        // A write EOF still needs to deliver the target header so the peer can
-        // connect and respond. Resume any pending empty handshake before FIN.
-        if matches!(self.start, Start::Fresh) {
-            self.start = Start::EmptyPending;
+
+    fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let this = self.get_mut();
+        // Write-half EOF can still receive a response to an empty upload.
+        // Drop/cancellation never calls this or creates a target header.
+        if matches!(this.start, Start::Fresh(_)) {
+            this.begin_empty();
         }
-        ready!(self.finish_empty(cx))?;
-        ready!(self.finish_write(cx))?;
-        Pin::new(&mut self.inner)
+        ready!(this.finish_empty(cx))?;
+        ready!(this.finish_write(cx))?;
+        this.inner
             .poll_shutdown(cx)
-            .map_err(super::safe_io)
+            .map_err(|error| super::safe_io(error.into()))
     }
 }
diff --git a/src/outbound/shadowsocks/tests.rs b/src/outbound/shadowsocks/tests.rs
index b585d4f..a2623db 100644
--- a/src/outbound/shadowsocks/tests.rs
+++ b/src/outbound/shadowsocks/tests.rs
@@ -5,89 +5,16 @@ use crate::{
     session::InboundKind,
 };
 use base64::{Engine as _, engine::general_purpose::STANDARD};
-use shadowsocks::relay::tcprelay::proxy_stream::{ProxyServerStream, protocol::TcpRequestHeader};
+use shadowsocks::relay::tcprelay::proxy_stream::ProxyServerStream;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 
-// A lower-level codec peer, deliberately not a conforming SS server. It keeps
-// adapter scheduling/half-close checks independent of upstream's randomized
-// zero-padding rejection. Strict acceptance and rejection have separate,
-// deterministic fixtures in tests/shadowsocks_backpressure.rs.
-struct CodecPeer {
-    stream: shadowsocks::relay::tcprelay::crypto_io::CryptoStream<tokio::io::DuplexStream>,
-    context: Arc<Context>,
-}
-impl CodecPeer {
-    fn new(
-        raw: tokio::io::DuplexStream,
-        method: shadowsocks::crypto::CipherKind,
-        key: &[u8],
-    ) -> Self {
-        let context = Context::new_shared(ServerType::Server);
-        Self {
-            stream: shadowsocks::relay::tcprelay::crypto_io::CryptoStream::from_stream(
-                &context,
-                raw,
-                shadowsocks::relay::tcprelay::crypto_io::StreamType::Server,
-                method,
-                key,
-            ),
-            context,
-        }
-    }
-    async fn header(&mut self) -> shadowsocks::relay::socks5::Address {
-        let header = TcpRequestHeader::read_from(self.stream.method(), self)
-            .await
-            .unwrap();
-        let nonce = self.stream.received_nonce().unwrap().to_vec();
-        self.stream.set_request_nonce(&nonce);
-        header.addr()
-    }
-}
-impl tokio::io::AsyncRead for CodecPeer {
-    fn poll_read(
-        self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-        out: &mut tokio::io::ReadBuf<'_>,
-    ) -> std::task::Poll<io::Result<()>> {
-        use shadowsocks::relay::tcprelay::crypto_io::CryptoRead;
-        let this = self.get_mut();
-        std::pin::Pin::new(&mut this.stream)
-            .poll_read_decrypted(cx, &this.context, out)
-            .map_err(Into::into)
-    }
-}
-impl tokio::io::AsyncWrite for CodecPeer {
-    fn poll_write(
-        mut self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-        data: &[u8],
-    ) -> std::task::Poll<io::Result<usize>> {
-        use shadowsocks::relay::tcprelay::crypto_io::CryptoWrite;
-        std::pin::Pin::new(&mut self.stream)
-            .poll_write_encrypted(cx, data)
-            .map_err(Into::into)
-    }
-    fn poll_flush(
-        mut self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<io::Result<()>> {
-        self.stream.poll_flush(cx).map_err(Into::into)
-    }
-    fn poll_shutdown(
-        mut self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<io::Result<()>> {
-        self.stream.poll_shutdown(cx).map_err(Into::into)
-    }
-}
-
 fn config(cipher: ShadowsocksCipher) -> ShadowsocksOutboundConfig {
     ShadowsocksOutboundConfig {
         address: "127.0.0.1".into(),
         port: 12345,
         cipher,
         password: STANDARD.encode(vec![7; cipher.key_len()]),
-        shadow_tls: None,
+        plugin: None,
         udp_over_tcp: false,
     }
 }
@@ -99,7 +26,7 @@ async fn official_tcp_codecs_all_ciphers_first_payload_read_first_and_backpressu
         ShadowsocksCipher::Aes256Gcm,
         ShadowsocksCipher::Chacha20Poly1305,
     ] {
-        for server_first in [false, true] {
+        for start in ["payload", "read", "empty-write"] {
             let config = config(cipher);
             let method = cipher.as_str().parse().unwrap();
             let key = vec![7; cipher.key_len()];
@@ -107,18 +34,25 @@ async fn official_tcp_codecs_all_ciphers_first_payload_read_first_and_backpressu
                 ServerConfig::new(("127.0.0.1", 12345), config.password, method).unwrap();
             let target = Destination::domain("fixture.invalid", 443).unwrap();
             let (client, server) = tokio::io::duplex(4096);
-            let inner = shadowsocks::ProxyClientStream::from_stream(
+            let mut client = stream::SsStream::new(
                 Context::new_shared(ServerType::Local),
                 Box::new(client) as BoxStream,
                 &server_config,
                 address(&target),
             );
-            let mut client = stream::SsStream::new(inner);
-            let mut server = CodecPeer::new(server, method, &key);
+            let mut server = ProxyServerStream::from_stream(
+                Context::new_shared(ServerType::Server),
+                server,
+                method,
+                &key,
+            );
             tokio::time::timeout(std::time::Duration::from_secs(5), async {
                 tokio::join!(
                     async {
-                        if server_first {
+                        if start == "empty-write" {
+                            assert_eq!(client.write(&[]).await.unwrap(), 0);
+                        }
+                        if start != "payload" {
                             let mut hello = [0; 5];
                             client.read_exact(&mut hello).await.unwrap();
                             assert_eq!(&hello, b"hello");
@@ -132,8 +66,8 @@ async fn official_tcp_codecs_all_ciphers_first_payload_read_first_and_backpressu
                         assert_eq!(result, b"response");
                     },
                     async {
-                        assert_eq!(server.header().await, address(&target));
-                        if server_first {
+                        assert_eq!(server.handshake().await.unwrap(), address(&target));
+                        if start != "payload" {
                             server.write_all(b"hello").await.unwrap();
                         }
                         let mut payload = Vec::new();
@@ -173,13 +107,12 @@ async fn official_tcp_codecs_all_ciphers_empty_half_close_keeps_response() {
             if start != "fresh" {
                 socket.write_all(&prefill).await.unwrap();
             }
-            let inner = shadowsocks::ProxyClientStream::from_stream(
+            let mut client = stream::SsStream::new(
                 Context::new_shared(ServerType::Local),
                 Box::new(socket) as BoxStream,
                 &server_config,
                 address(&target),
             );
-            let mut client = stream::SsStream::new(inner);
             tokio::time::timeout(std::time::Duration::from_secs(5), async {
                 if start != "fresh" {
                     // Cancel after one poll, then let shutdown resume the same
@@ -199,7 +132,12 @@ async fn official_tcp_codecs_all_ciphers_empty_half_close_keeps_response() {
                     assert_eq!(prefill, [0x5a; 4095]);
                 }
                 client.shutdown().await.unwrap();
-                let mut server = CodecPeer::new(peer, method, &vec![7; cipher.key_len()]);
+                let mut server = ProxyServerStream::from_stream(
+                    Context::new_shared(ServerType::Server),
+                    peer,
+                    method,
+                    &vec![7; cipher.key_len()],
+                );
                 tokio::join!(
                     async {
                         let mut response = Vec::new();
@@ -207,7 +145,7 @@ async fn official_tcp_codecs_all_ciphers_empty_half_close_keeps_response() {
                         assert_eq!(response, b"hello");
                     },
                     async {
-                        assert_eq!(server.header().await, address(&target));
+                        assert_eq!(server.handshake().await.unwrap(), address(&target));
                         let mut payload = Vec::new();
                         server.read_to_end(&mut payload).await.unwrap();
                         assert!(payload.is_empty());
@@ -242,6 +180,7 @@ async fn ss_physical_tcp_uses_shared_dialer_and_logical_target() {
     .unwrap();
     let target = Destination::domain("fixture.invalid", 443).unwrap();
     let session = StreamSession {
+        metadata: Default::default(),
         inbound: InboundKind::Http,
         source: "127.0.0.1:10000".parse().unwrap(),
         destination: target.clone(),
@@ -280,7 +219,6 @@ async fn ss_physical_tcp_uses_shared_dialer_and_logical_target() {
     })
     .await
     .unwrap();
-    assert_eq!(log::STATIC_MAX_LEVEL, log::LevelFilter::Off);
     assert!(!format!("{outbound:?}").contains(&config.password));
 }
 
@@ -325,6 +263,8 @@ async fn tcp_response_header_time_salt_auth_and_fragmentation_follow_official_co
             "future",
             "wrong-type",
             "wrong-request-salt",
+            "wrong-request-salt-empty-response",
+            "wrong-request-salt-header-only",
             "corrupt",
             "short-fixed-header",
         ] {
@@ -333,17 +273,16 @@ async fn tcp_response_header_time_salt_auth_and_fragmentation_follow_official_co
             let server =
                 ServerConfig::new(("127.0.0.1", 12345), STANDARD.encode(&key), cipher).unwrap();
             let (client, mut peer) = tokio::io::duplex(4096);
-            let inner = shadowsocks::ProxyClientStream::from_stream(
+            let mut client = stream::SsStream::new(
                 Context::new_shared(ServerType::Local),
                 Box::new(client) as BoxStream,
                 &server,
-                ("private-target.invalid".to_owned(), 80),
+                ("private-target.invalid".to_owned(), 80).into(),
             );
-            let mut client = stream::SsStream::new(inner);
             client.write_all(b"private-payload").await.unwrap();
             let mut request_salt = vec![0; method.key_len()];
             peer.read_exact(&mut request_salt).await.unwrap();
-            if case == "wrong-request-salt" {
+            if case.starts_with("wrong-request-salt") {
                 request_salt[0] ^= 1;
             }
             let response_salt = vec![9; method.key_len()];
@@ -359,7 +298,8 @@ async fn tcp_response_header_time_salt_auth_and_fragmentation_follow_official_co
             let mut header = vec![if case == "wrong-type" { 0 } else { 1 }];
             header.extend_from_slice(&timestamp.to_be_bytes());
             header.extend_from_slice(&request_salt);
-            header.extend_from_slice(&1u16.to_be_bytes());
+            let body_length = u16::from(case != "wrong-request-salt-empty-response");
+            header.extend_from_slice(&body_length.to_be_bytes());
             header.extend_from_slice(&[0; 16]);
             let mut codec = TcpCipher::new(cipher, &key, &response_salt);
             codec.encrypt_packet(&mut header);
@@ -372,7 +312,7 @@ async fn tcp_response_header_time_salt_auth_and_fragmentation_follow_official_co
                 wire.truncate(wire.len() - 1);
             }
             peer.write_all(&wire).await.unwrap();
-            let mut body = vec![0x5a; 1];
+            let mut body = vec![0x5a; usize::from(body_length)];
             body.extend_from_slice(&[0; 16]);
             codec.encrypt_packet(&mut body);
             tokio::time::timeout(std::time::Duration::from_secs(1), async {
@@ -390,7 +330,13 @@ async fn tcp_response_header_time_salt_auth_and_fragmentation_follow_official_co
                             }
                         }
                     );
+                } else if case == "wrong-request-salt-header-only" {
+                    let error = client.read(&mut [0; 1]).await.unwrap_err();
+                    assert_eq!(error.to_string(), "Shadowsocks stream operation failed");
                 } else {
+                    if case == "wrong-request-salt-empty-response" {
+                        peer.write_all(&body).await.unwrap();
+                    }
                     peer.shutdown().await.unwrap();
                     let error = client.read(&mut [0; 1]).await.unwrap_err();
                     assert_eq!(error.to_string(), "Shadowsocks stream operation failed");
@@ -446,6 +392,7 @@ async fn physical_tcp_udp_protection_is_shared_and_fails_closed() {
         )
         .unwrap();
         let session = StreamSession {
+            metadata: Default::default(),
             inbound: InboundKind::Socks5,
             source: "127.0.0.1:10000".parse().unwrap(),
             destination: Destination::domain("private-target.invalid", 443).unwrap(),
diff --git a/src/outbound/shadowsocks/uot.rs b/src/outbound/shadowsocks/uot.rs
index 70e0fb8..f61bdf1 100644
--- a/src/outbound/shadowsocks/uot.rs
+++ b/src/outbound/shadowsocks/uot.rs
@@ -43,6 +43,7 @@ impl Owner {
             biased;
             () = self.cancellation.cancelled() => return Err(DispatchError::NotAllowed),
             result = outbound.connect_stream(StreamSession {
+                metadata: request.session.metadata.clone(),
                 inbound: request.session.inbound,
                 source: request.session.source,
                 destination: magic_destination(),
@@ -116,6 +117,10 @@ struct DatagramAdapter {
 
 #[async_trait]
 impl DatagramTransport for DatagramAdapter {
+    fn supports_shared_destinations(&self) -> bool {
+        self.inner.supports_shared_destinations()
+    }
+
     async fn send(&mut self, mut datagram: Datagram) -> Result<(), DispatchError> {
         let deadline = self
             .first_deadline
diff --git a/src/outbound/sing_mux.rs b/src/outbound/sing_mux.rs
new file mode 100644
index 0000000..a602242
--- /dev/null
+++ b/src/outbound/sing_mux.rs
@@ -0,0 +1,744 @@
+//! Node-owned sing-mux adapter over any normal protocol connector.
+use super::{ConnectedStream, DatagramRequest, EstablishContext, OutboundConnector};
+use crate::{
+    config::SingMuxConfig,
+    dispatch::{DatagramTransport, DispatchError},
+    session::{Destination, StreamSession},
+    transport::sing_mux::{Pool, SuppliedStream, datagram::DatagramIo},
+};
+use async_trait::async_trait;
+use std::{io, sync::Arc};
+use tokio_util::sync::CancellationToken;
+
+pub struct SingMuxConnector {
+    inner: Arc<dyn OutboundConnector>,
+    pool: Pool,
+    cancellation: CancellationToken,
+    tracking: Option<Tracking>,
+    #[cfg(target_os = "linux")]
+    capture_tcp: bool,
+}
+struct Tracking {
+    registry: Arc<crate::connections::Registry>,
+    chain: Arc<str>,
+    providers: Vec<Arc<str>>,
+}
+impl std::fmt::Debug for SingMuxConnector {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("SingMuxConnector").finish_non_exhaustive()
+    }
+}
+impl SingMuxConnector {
+    /// Wrap an inner node with normalized, enabled smux options.
+    pub fn new(inner: Arc<dyn OutboundConnector>, options: SingMuxConfig) -> Self {
+        Self {
+            inner,
+            pool: Pool::new(options),
+            cancellation: CancellationToken::new(),
+            tracking: None,
+            #[cfg(target_os = "linux")]
+            capture_tcp: false,
+        }
+    }
+    pub(crate) fn with_autonomous_xhttp(mut self, proxy: &crate::config::ProxyConfig) -> Self {
+        // Match the proven XUDP path: VLESS Encryption and sing-mux padding
+        // retain their own final write, so they cannot inherit this capability.
+        let enabled = matches!(
+            &proxy.protocol,
+            crate::config::ProxyProtocol::Vless(config)
+                if config.xhttp().is_some()
+                    && matches!(&config.encryption, crate::config::VlessEncryption::None)
+        );
+        let h2_packet_up = enabled
+            && matches!(
+                &proxy.protocol,
+                crate::config::ProxyProtocol::Vless(config)
+                    if config.xhttp().is_some_and(|xhttp| xhttp.mode == crate::config::XHttpMode::PacketUp)
+            );
+        self.pool.set_autonomous_writes(enabled, h2_packet_up);
+        self
+    }
+    #[cfg(target_os = "linux")]
+    pub(crate) fn with_physical_tcp_control(mut self, proxy: &crate::config::ProxyConfig) -> Self {
+        self.capture_tcp = self.pool.brutal_enabled() && exclusive_tcp(proxy);
+        self
+    }
+    pub(crate) fn with_tracking(
+        mut self,
+        diagnostics: &crate::routing::diagnostics::Diagnostics,
+        name: &str,
+    ) -> Self {
+        let chain = diagnostics.text(name);
+        self.tracking = Some(Tracking {
+            registry: diagnostics.connections.clone(),
+            providers: diagnostics.providers(std::slice::from_ref(&chain)),
+            chain,
+        });
+        self
+    }
+    async fn connect(
+        &self,
+        mut session: StreamSession,
+        context: &EstablishContext,
+    ) -> io::Result<SuppliedStream> {
+        session.destination = Destination::domain("sp.mux.sing-box.arpa", 444)?;
+        session.sniffed_domain = None;
+        let source = session.source;
+        #[cfg(feature = "outbound-vless")]
+        let h3_capture = self
+            .pool
+            .captures_h3_udp()
+            .then(crate::transport::xhttp::UdpAssociationCapture::default);
+        #[cfg(feature = "outbound-vless")]
+        let h3_context = h3_capture
+            .as_ref()
+            .map(|capture| context.capture_h3_udp(capture.clone()));
+        #[cfg(feature = "outbound-vless")]
+        let context = h3_context.as_ref().unwrap_or(context);
+        #[cfg(target_os = "linux")]
+        let capture = self
+            .capture_tcp
+            .then(crate::dialer::tcp_control::Capture::default);
+        #[cfg(target_os = "linux")]
+        let captured_context = capture
+            .as_ref()
+            .map(|capture| context.capture_tcp_control(capture.clone()));
+        #[cfg(target_os = "linux")]
+        let context = captured_context.as_ref().unwrap_or(context);
+        let raw = self
+            .inner
+            .connect_stream(session, context)
+            .await
+            .map(|connected| connected.io)
+            .map_err(io::Error::other)?;
+        let io = match &self.tracking {
+            None => raw,
+            Some(tracking) => tracking
+                .registry
+                .open_inner(crate::connections::ConnectionInfo {
+                    metadata: crate::connections::ConnectionMetadata {
+                        network: "tcp",
+                        inbound_type: "Inner",
+                        source,
+                        destination_ip: None,
+                        destination_port: 444,
+                        host: Arc::from("sp.mux.sing-box.arpa"),
+                        dns_mode: "normal",
+                        sniff_host: Arc::from(""),
+                        process: Default::default(),
+                        original: None,
+                    },
+                    chains: vec![tracking.chain.clone()],
+                    provider_chains: tracking.providers.clone(),
+                    rule: "",
+                    rule_payload: Arc::from(""),
+                    dns_path: Vec::new(),
+                })
+                .stream(raw),
+        };
+        Ok(SuppliedStream {
+            io,
+            #[cfg(target_os = "linux")]
+            control: capture.and_then(|capture| capture.finish()),
+            #[cfg(feature = "outbound-vless")]
+            h3_udp: h3_capture.and_then(|capture| capture.take()),
+        })
+    }
+}
+#[cfg(target_os = "linux")]
+fn exclusive_tcp(proxy: &crate::config::ProxyConfig) -> bool {
+    use crate::config::{
+        ProxyProtocol, ShadowsocksPlugin, StreamTransport, TrojanTransport, VlessTransport,
+    };
+    if proxy.mptcp {
+        return false;
+    }
+    match &proxy.protocol {
+        ProxyProtocol::Http(_) | ProxyProtocol::Socks5(_) => true,
+        ProxyProtocol::Vless(config) => matches!(
+            &config.transport,
+            VlessTransport::Stream(StreamTransport::Tcp | StreamTransport::WebSocket { .. })
+        ),
+        ProxyProtocol::Vmess(config) => matches!(
+            &config.transport,
+            StreamTransport::Tcp | StreamTransport::WebSocket { .. }
+        ),
+        ProxyProtocol::Trojan(config) => matches!(
+            &config.transport,
+            TrojanTransport::Tcp | TrojanTransport::WebSocket { .. }
+        ),
+        ProxyProtocol::Shadowsocks(config) => !matches!(
+            &config.plugin,
+            Some(ShadowsocksPlugin::WebSocket { mux: true, .. })
+        ),
+        _ => false,
+    }
+}
+#[async_trait]
+impl OutboundConnector for SingMuxConnector {
+    async fn connect_stream(
+        &self,
+        session: StreamSession,
+        context: &EstablishContext,
+    ) -> Result<ConnectedStream, DispatchError> {
+        if tokio::time::Instant::now() >= context.deadline() {
+            return Err(DispatchError::TimedOut);
+        }
+        let effective_peer = session.destination.clone();
+        let io = self
+            .pool
+            .open(&effective_peer, false, context.deadline(), || {
+                self.connect(session, context)
+            })
+            .await?;
+        Ok(ConnectedStream { io, effective_peer })
+    }
+    async fn open_datagram(
+        &self,
+        request: DatagramRequest,
+        context: &EstablishContext,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        if tokio::time::Instant::now() >= context.deadline() {
+            return Err(DispatchError::TimedOut);
+        }
+        tokio::select! { biased;
+            ()=self.cancellation.cancelled()=>Err(DispatchError::NotAllowed),
+            result=async {
+                if self.pool.only_tcp() { return self.inner.open_datagram(request, context).await; }
+                let target = Destination::domain("sp.mux.sing-box.arpa", 444)?;
+                let session = StreamSession { metadata:request.session.metadata.clone(), inbound:request.session.inbound, source:request.session.source, destination:target.clone(), sniffed_domain:None };
+                let io=self.pool.open(&target, true, context.deadline(), || self.connect(session, context)).await?;
+                let transport = DatagramIo::new(io,request.budget(),context.resolution(),context.deadline(),self.cancellation.clone());
+                let transport = if self.pool.autonomous_writes() { transport.with_autonomous_writes() } else { transport };
+                Ok(crate::dispatch::bound_datagram(Box::new(transport),request.budget()))
+            }=>result,
+        }
+    }
+    fn begin_shutdown(&self) {
+        self.cancellation.cancel();
+        self.pool.begin_stop();
+        self.inner.begin_shutdown();
+    }
+    async fn shutdown(&self) {
+        self.begin_shutdown();
+        self.pool.stop().await;
+        self.inner.shutdown().await;
+    }
+}
+impl Drop for SingMuxConnector {
+    fn drop(&mut self) {
+        self.begin_shutdown();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        dispatch::{DatagramBudget, DatagramTransport},
+        resources::observation::{ResourceKind, ResourceProbe},
+        session::{DatagramSession, InboundKind},
+    };
+    use std::sync::Mutex;
+    use tokio::io::AsyncReadExt;
+    use tokio::{sync::Notify, time::Instant};
+
+    #[cfg(all(target_os = "linux", feature = "outbound-vless"))]
+    #[test]
+    fn brutal_physical_control_requires_exclusive_non_mptcp_transport() {
+        for (network, extra, allowed) in [
+            ("tcp", "", true),
+            ("ws", "", true),
+            ("grpc", "", false),
+            ("xhttp", "", false),
+            ("tcp", "mptcp: true", false),
+        ] {
+            let yaml = format!(
+                "mixed-port: 1080\nproxies:\n- name: edge\n  type: vless\n  server: 192.0.2.1\n  port: 443\n  uuid: 07070707-0707-0707-0707-070707070707\n  network: {network}\n  {extra}\nrules: ['MATCH,edge']\n"
+            );
+            let config = crate::config::Config::parse_yaml(yaml.as_bytes()).unwrap();
+            assert_eq!(
+                exclusive_tcp(&config.proxies[0]),
+                allowed,
+                "{network}, {extra}"
+            );
+        }
+    }
+
+    #[cfg(feature = "outbound-vless")]
+    #[test]
+    fn autonomous_capability_keeps_smux_and_requires_packet_up_for_h2mux() {
+        for (network, protocol, mode, padding, encryption, expected) in [
+            ("xhttp", "smux", "packet-up", false, false, true),
+            ("xhttp", "smux", "stream-one", false, false, true),
+            ("xhttp", "smux", "stream-up", false, false, true),
+            ("tcp", "smux", "packet-up", false, false, false),
+            ("xhttp", "h2mux", "packet-up", false, false, true),
+            ("xhttp", "h2mux", "stream-one", false, false, false),
+            ("xhttp", "h2mux", "stream-up", false, false, false),
+            ("xhttp", "yamux", "packet-up", false, false, false),
+            ("xhttp", "smux", "packet-up", true, false, false),
+            ("xhttp", "smux", "packet-up", false, true, false),
+            ("xhttp", "h2mux", "packet-up", true, false, false),
+            ("xhttp", "h2mux", "packet-up", false, true, false),
+        ] {
+            let yaml = format!(
+                "mixed-port: 1080\nproxies:\n- name: edge\n  type: vless\n  server: 192.0.2.1\n  port: 443\n  uuid: 07070707-0707-4707-8707-070707070707\n  network: {network}\n  smux: {{enabled: true, protocol: {protocol}, padding: {padding}}}\nrules: ['MATCH,DIRECT']\n"
+            );
+            let yaml = if network == "xhttp" {
+                yaml.replace(
+                    "  smux:",
+                    &format!("  xhttp-opts: {{mode: {mode}}}\n  smux:"),
+                )
+            } else {
+                yaml
+            };
+            let mut config = crate::config::Config::parse_yaml(yaml.as_bytes()).unwrap();
+            let proxy = &mut config.proxies[0];
+            if encryption {
+                let crate::config::ProxyProtocol::Vless(config) = &mut proxy.protocol else {
+                    panic!("VLESS test node");
+                };
+                config.encryption =
+                    crate::config::VlessEncryption::MlKem768X25519Plus(String::new());
+            }
+            let inner = Arc::new(MuxPeer {
+                calls: Mutex::default(),
+                tasks: Mutex::default(),
+                probe: ResourceProbe::default(),
+            });
+            let node = SingMuxConnector::new(inner, proxy.smux.as_ref().unwrap().clone())
+                .with_autonomous_xhttp(proxy);
+            assert_eq!(
+                node.pool.autonomous_writes(),
+                expected,
+                "{network}/{protocol}, padding={padding}, encryption={encryption}"
+            );
+        }
+    }
+
+    struct MuxPeer {
+        calls: Mutex<Vec<(StreamSession, Instant)>>,
+        tasks: Mutex<Vec<tokio::task::JoinHandle<()>>>,
+        probe: ResourceProbe,
+    }
+    #[async_trait]
+    impl OutboundConnector for MuxPeer {
+        async fn connect_stream(
+            &self,
+            session: StreamSession,
+            context: &EstablishContext,
+        ) -> Result<ConnectedStream, DispatchError> {
+            self.calls
+                .lock()
+                .unwrap()
+                .push((session.clone(), context.deadline()));
+            let (raw, mut peer) = tokio::io::duplex(65536);
+            self.tasks.lock().unwrap().push(tokio::spawn(async move {
+                let mut handshake = [0; 2];
+                peer.read_exact(&mut handshake).await.unwrap();
+                assert_eq!(handshake, [0, 2]);
+                let mut connection = h2::server::handshake(peer).await.unwrap();
+                let mut streams = Vec::new();
+                while let Some(Ok((request, mut reply))) = connection.accept().await {
+                    assert_eq!(request.method(), "CONNECT");
+                    let mut output = reply.send_response(http::Response::new(()), false).unwrap();
+                    output
+                        .send_data(bytes::Bytes::from_static(b"\x00x"), false)
+                        .unwrap();
+                    streams.push((request, output));
+                }
+            }));
+            Ok(ConnectedStream {
+                io: Box::new(raw),
+                effective_peer: session.destination,
+            })
+        }
+        async fn open_datagram(
+            &self,
+            _request: DatagramRequest,
+            _context: &EstablishContext,
+        ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+            panic!("mux UDP must use inner TCP rather than native UDP");
+        }
+        async fn shutdown(&self) {
+            // The wrapper must join its driver before releasing the supplied IO owner.
+            assert_eq!(self.probe.snapshot().current(ResourceKind::Task), 0);
+            let tasks = std::mem::take(&mut *self.tasks.lock().unwrap());
+            for task in tasks {
+                task.await.unwrap();
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn shared_wrapper_preserves_logical_peer_and_joins_mux_before_inner() {
+        let probe = ResourceProbe::default();
+        probe
+            .scope(async {
+                let inner = Arc::new(MuxPeer {
+                    calls: Mutex::default(),
+                    tasks: Mutex::default(),
+                    probe: probe.clone(),
+                });
+                let registry = Arc::new(crate::connections::Registry::default());
+                let config = crate::config::Config::parse_yaml(b"mixed-port: 1080\nproxies: [{name: edge, type: socks5, server: 192.0.2.1, port: 1080}]\nrules: ['MATCH,DIRECT']\n").unwrap();
+                let rules = crate::routing::RuleSet::compile(config.rules.clone()).unwrap();
+                let diagnostics = crate::routing::diagnostics::Diagnostics::new(&config, &rules, registry.clone());
+                let node = SingMuxConnector::new(
+                    inner.clone(),
+                    SingMuxConfig {
+                        enabled: true,
+                        max_connections: 1,
+                        statistic: true,
+                        ..Default::default()
+                    },
+                ).with_tracking(&diagnostics, "edge");
+                let session = StreamSession {
+                    metadata: crate::session::InboundMetadata {
+                        local_port: 1080,
+                        user: Some(Arc::from("alice")),
+                        ..Default::default()
+                    },
+                    inbound: InboundKind::Socks5,
+                    source: "127.0.0.1:1080".parse().unwrap(),
+                    destination: Destination::domain("business.invalid", 443).unwrap(),
+                    sniffed_domain: Some("sniffed.invalid".to_owned()),
+                };
+                let context = EstablishContext::default();
+                let mut first = node
+                    .connect_stream(session.clone(), &context)
+                    .await
+                    .unwrap();
+                let mut sibling = node
+                    .connect_stream(session.clone(), &context)
+                    .await
+                    .unwrap();
+                assert_eq!(first.effective_peer, session.destination);
+                assert_eq!(first.io.read_u8().await.unwrap(), b'x');
+                assert_eq!(sibling.io.read_u8().await.unwrap(), b'x');
+                let calls = inner.calls.lock().unwrap().clone();
+                assert_eq!(calls.len(), 1);
+                let physical = &calls[0].0;
+                assert_eq!(physical.destination.authority(), "sp.mux.sing-box.arpa:444");
+                assert_eq!(physical.inbound, session.inbound);
+                assert_eq!(physical.source, session.source);
+                assert_eq!(physical.metadata, session.metadata);
+                assert!(physical.sniffed_domain.is_none());
+                assert_eq!(calls[0].1, context.deadline());
+                assert_eq!(probe.snapshot().current(ResourceKind::Pool), 1);
+                assert_eq!(probe.snapshot().current(ResourceKind::Task), 1);
+                let snapshot = serde_json::to_value(registry.snapshot()).unwrap();
+                assert_eq!(snapshot["connections"].as_array().unwrap().len(), 1);
+                assert_eq!(snapshot["connections"][0]["metadata"]["type"], "Inner");
+                assert_eq!(snapshot["connections"][0]["chains"], serde_json::json!(["edge"]));
+                assert!(snapshot["connections"][0]["upload"].as_u64().unwrap() > 0);
+                assert_eq!(snapshot["uploadTotal"], 0);
+                assert_eq!(snapshot["downloadTotal"], 0);
+                registry.close(snapshot["connections"][0]["id"].as_str().unwrap());
+                for stream in [&mut first.io, &mut sibling.io] {
+                    assert!(tokio::time::timeout(std::time::Duration::from_secs(1), stream.read_u8()).await.unwrap().is_err());
+                }
+                node.shutdown().await;
+                drop((first, sibling, node));
+                assert!(probe.snapshot().is_idle());
+            })
+            .await;
+    }
+
+    #[derive(Default)]
+    struct PendingUdp {
+        request: Mutex<Option<(DatagramRequest, Instant)>>,
+        entered: Notify,
+        stopped: Mutex<Vec<&'static str>>,
+    }
+    #[async_trait]
+    impl OutboundConnector for PendingUdp {
+        async fn connect_stream(
+            &self,
+            _session: StreamSession,
+            _context: &EstablishContext,
+        ) -> Result<ConnectedStream, DispatchError> {
+            panic!("only-tcp must not establish a mux TCP stream for UDP");
+        }
+        async fn open_datagram(
+            &self,
+            request: DatagramRequest,
+            context: &EstablishContext,
+        ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+            *self.request.lock().unwrap() = Some((request, context.deadline()));
+            self.entered.notify_one();
+            std::future::pending().await
+        }
+        fn begin_shutdown(&self) {
+            self.stopped.lock().unwrap().push("begin");
+        }
+        async fn shutdown(&self) {
+            self.stopped.lock().unwrap().push("joined");
+        }
+    }
+
+    #[tokio::test]
+    async fn only_tcp_delegates_original_udp_metadata_budget_and_cancels_pending_setup() {
+        let inner = Arc::new(PendingUdp::default());
+        let node = SingMuxConnector::new(
+            inner.clone(),
+            SingMuxConfig {
+                enabled: true,
+                only_tcp: true,
+                ..Default::default()
+            },
+        );
+        let request = DatagramRequest::new(DatagramSession::new(
+            InboundKind::Socks5,
+            "127.0.0.1:10234".parse().unwrap(),
+        ))
+        .with_budget(DatagramBudget::new(913, 1714));
+        let context = EstablishContext::default();
+        let open = node.open_datagram(request.clone(), &context);
+        tokio::pin!(open);
+        tokio::select! {
+            _ = inner.entered.notified() => {},
+            _ = &mut open => panic!("inner setup should remain pending"),
+        }
+        let recorded = inner.request.lock().unwrap().clone().unwrap();
+        assert_eq!(recorded.0.session, request.session);
+        assert_eq!(recorded.0.budget(), request.budget());
+        assert_eq!(recorded.1, context.deadline());
+        node.begin_shutdown();
+        assert!(matches!(open.await, Err(DispatchError::NotAllowed)));
+        node.shutdown().await;
+        assert_eq!(*inner.stopped.lock().unwrap(), ["begin", "begin", "joined"]);
+        assert!(matches!(
+            node.open_datagram(request, &context).await,
+            Err(DispatchError::NotAllowed)
+        ));
+    }
+
+    #[cfg(feature = "outbound-vless")]
+    #[tokio::test]
+    async fn private_packet_up_h2mux_hands_off_tail_and_keeps_strong_flush_fin_stop() {
+        use crate::session::InboundMetadata;
+        use futures_util::task::AtomicWaker;
+        use std::{
+            pin::Pin,
+            sync::atomic::{AtomicBool, Ordering},
+            task::{Context, Poll},
+            time::Duration,
+        };
+        use tokio::io::{AsyncRead, AsyncWrite, AsyncWriteExt, DuplexStream, ReadBuf};
+
+        #[derive(Default)]
+        struct Gate {
+            blocked: AtomicBool,
+            wake: AtomicWaker,
+        }
+        impl Gate {
+            fn set(&self, blocked: bool) {
+                self.blocked.store(blocked, Ordering::SeqCst);
+                self.wake.wake();
+            }
+        }
+        struct GatedIo {
+            raw: DuplexStream,
+            gate: Arc<Gate>,
+        }
+        impl AsyncRead for GatedIo {
+            fn poll_read(
+                mut self: Pin<&mut Self>,
+                cx: &mut Context<'_>,
+                out: &mut ReadBuf<'_>,
+            ) -> Poll<io::Result<()>> {
+                Pin::new(&mut self.raw).poll_read(cx, out)
+            }
+        }
+        impl AsyncWrite for GatedIo {
+            fn poll_write(
+                mut self: Pin<&mut Self>,
+                cx: &mut Context<'_>,
+                bytes: &[u8],
+            ) -> Poll<io::Result<usize>> {
+                Pin::new(&mut self.raw).poll_write(cx, bytes)
+            }
+            fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+                self.gate.wake.register(cx.waker());
+                if self.gate.blocked.load(Ordering::SeqCst) {
+                    return Poll::Pending;
+                }
+                Pin::new(&mut self.raw).poll_flush(cx)
+            }
+            fn poll_shutdown(
+                mut self: Pin<&mut Self>,
+                cx: &mut Context<'_>,
+            ) -> Poll<io::Result<()>> {
+                Pin::new(&mut self.raw).poll_shutdown(cx)
+            }
+        }
+        struct Peer {
+            gate: Arc<Gate>,
+            tail: Mutex<Option<tokio::sync::oneshot::Sender<Vec<u8>>>>,
+            tasks: Mutex<Vec<tokio::task::JoinHandle<()>>>,
+            observed: Arc<Mutex<Vec<u8>>>,
+        }
+        #[async_trait]
+        impl OutboundConnector for Peer {
+            async fn connect_stream(
+                &self,
+                session: StreamSession,
+                _: &EstablishContext,
+            ) -> Result<ConnectedStream, DispatchError> {
+                let (raw, mut peer) = tokio::io::duplex(65536);
+                let tail = self.tail.lock().unwrap().take().expect("one physical");
+                let observed = self.observed.clone();
+                self.tasks.lock().unwrap().push(tokio::spawn(async move {
+                    let mut prefix = [0; 2];
+                    peer.read_exact(&mut prefix).await.unwrap();
+                    assert_eq!(prefix, [0, 2]);
+                    let mut connection = h2::server::handshake(peer).await.unwrap();
+                    let (request, mut reply) = connection.accept().await.unwrap().unwrap();
+                    assert_eq!(request.method(), "CONNECT");
+                    let mut output = reply.send_response(http::Response::new(()), false).unwrap();
+                    let mut input = request.into_body();
+                    let exchange = async move {
+                        let mut ready = false;
+                        let mut tail = Some(tail);
+                        while let Some(data) = input.data().await {
+                            let Ok(data) = data else { return; };
+                            let count = data.len();
+                            let bytes = {
+                                let mut bytes = observed.lock().unwrap();
+                                bytes.extend_from_slice(&data);
+                                bytes.clone()
+                            };
+                            input.flow_control().release_capacity(count).unwrap();
+                            if !ready && bytes.len() >= 9 {
+                                assert_eq!(&bytes[..9], &[0, 0, 1, 192, 0, 2, 1, 1, 187]);
+                                output.send_data(bytes::Bytes::from_static(b"\x00w"), false).unwrap();
+                                ready = true;
+                            }
+                            if bytes.len() >= 14 && let Some(tail) = tail.take() {
+                                tail.send(bytes[9..14].to_vec()).unwrap();
+                                output.send_data(bytes::Bytes::from_static(b"echo"), false).unwrap();
+                            }
+                        }
+                        output.send_data(bytes::Bytes::from_static(b"after-fin"), false).unwrap();
+                        // Keep the response open so the same pending read must
+                        // be woken by node Stop. Connection EOF drops this owner.
+                        std::future::pending::<()>().await;
+                    };
+                    tokio::pin!(exchange);
+                    loop {
+                        tokio::select! {
+                            () = &mut exchange => break,
+                            next = connection.accept() => if !matches!(next, Some(Ok(_))) { break; },
+                        }
+                    }
+                }));
+                Ok(ConnectedStream {
+                    io: Box::new(GatedIo {
+                        raw,
+                        gate: self.gate.clone(),
+                    }),
+                    effective_peer: session.destination,
+                })
+            }
+            async fn open_datagram(
+                &self,
+                _: DatagramRequest,
+                _: &EstablishContext,
+            ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+                panic!("memory peer only supplies authenticated byte IO");
+            }
+            async fn shutdown(&self) {
+                let tasks = std::mem::take(&mut *self.tasks.lock().unwrap());
+                for task in tasks {
+                    task.await.unwrap();
+                }
+            }
+        }
+        let gate = Arc::new(Gate::default());
+        let (tail, mut tail_rx) = tokio::sync::oneshot::channel();
+        let peer = Arc::new(Peer {
+            gate: gate.clone(),
+            tail: Mutex::new(Some(tail)),
+            tasks: Mutex::default(),
+            observed: Arc::default(),
+        });
+        let config = crate::config::Config::parse_yaml(b"mixed-port: 1080\nproxies: [{name: edge, type: vless, server: 192.0.2.1, port: 443, uuid: 07070707-0707-4707-8707-070707070707, network: xhttp, xhttp-opts: {mode: packet-up}, smux: {enabled: true, protocol: h2mux}}]\nrules: ['MATCH,DIRECT']\n").unwrap();
+        let proxy = &config.proxies[0];
+        let node = SingMuxConnector::new(peer.clone(), proxy.smux.as_ref().unwrap().clone())
+            .with_autonomous_xhttp(proxy);
+        let session = StreamSession {
+            metadata: InboundMetadata::default(),
+            inbound: InboundKind::Tun,
+            source: "192.0.2.2:12345".parse().unwrap(),
+            destination: "192.0.2.1:443"
+                .parse::<std::net::SocketAddr>()
+                .unwrap()
+                .into(),
+            sniffed_domain: None,
+        };
+        let mut stream = node
+            .connect_stream(session, &EstablishContext::default())
+            .await
+            .unwrap();
+        assert_eq!(stream.io.read_u8().await.unwrap(), b'w');
+        gate.set(true);
+        stream.io.write_all(b"tail1").await.unwrap();
+        // No following write/flush may rescue the last privately queued chunk.
+        let before_flush = tokio::time::timeout(Duration::from_millis(250), &mut tail_rx)
+            .await
+            .ok()
+            .map(Result::unwrap);
+        let mut flushing = Box::pin(stream.io.flush());
+        let strong_pending = futures_util::poll!(flushing.as_mut()).is_pending();
+        gate.set(false);
+        tokio::time::timeout(Duration::from_secs(1), flushing)
+            .await
+            .unwrap()
+            .unwrap();
+        let actual_tail = match &before_flush {
+            Some(bytes) => bytes.clone(),
+            None => tokio::time::timeout(Duration::from_secs(1), tail_rx)
+                .await
+                .unwrap()
+                .unwrap(),
+        };
+        let mut echo = [0; 4];
+        stream.io.read_exact(&mut echo).await.unwrap();
+        gate.set(true);
+        stream.io.write_all(b"close").await.unwrap();
+        let mut closing = Box::pin(stream.io.shutdown());
+        let fin_pending = futures_util::poll!(closing.as_mut()).is_pending();
+        gate.set(false);
+        tokio::time::timeout(Duration::from_secs(1), closing)
+            .await
+            .unwrap()
+            .unwrap();
+        let mut after_fin = [0; 9];
+        stream.io.read_exact(&mut after_fin).await.unwrap();
+        let mut reading = Box::pin(stream.io.read_u8());
+        let read_pending = futures_util::poll!(reading.as_mut()).is_pending();
+        tokio::time::timeout(Duration::from_secs(1), node.shutdown())
+            .await
+            .unwrap();
+        let stopped = tokio::time::timeout(Duration::from_secs(1), reading)
+            .await
+            .unwrap()
+            .is_err();
+        drop(stream);
+        // All physical/core/peer tasks are joined before intended RED assertion.
+        assert!(
+            strong_pending && fin_pending && read_pending && stopped,
+            "strong flush/FIN/Stop fixture failed"
+        );
+        assert_eq!(actual_tail, b"tail1");
+        assert_eq!(&echo, b"echo");
+        assert_eq!(&after_fin, b"after-fin");
+        assert_eq!(&peer.observed.lock().unwrap()[9..], b"tail1close");
+        assert!(
+            before_flush.is_some(),
+            "private h2mux must hand the final DATA to its driver before a later flush"
+        );
+    }
+}
diff --git a/src/outbound/socks5.rs b/src/outbound/socks5.rs
index e284e96..4d4c5c3 100644
--- a/src/outbound/socks5.rs
+++ b/src/outbound/socks5.rs
@@ -8,6 +8,9 @@ use crate::{
     config::Socks5OutboundConfig,
     dialer::{Dialer, ResolvedEndpoint},
     dispatch::{BoxStream, DatagramTransport, DispatchError, Dispatcher},
+    security::{
+        SecurityContext, StandardTlsClient, TLS_RESUMPTION_SESSION_BUDGET, TlsClientOptions,
+    },
     session::{Datagram, DatagramSession, Destination, StreamSession},
     socks5::{
         COMMAND_CONNECT, COMMAND_UDP_ASSOCIATE, MAX_UDP_HEADER_SIZE, VERSION, decode_udp_packet,
@@ -62,6 +65,7 @@ pub struct Socks5Outbound {
     server: Destination,
     auth: Option<Socks5Auth>,
     upstream: UpstreamPath,
+    tls: Option<StandardTlsClient>,
 }
 
 impl std::fmt::Debug for Socks5Outbound {
@@ -70,6 +74,7 @@ impl std::fmt::Debug for Socks5Outbound {
             .debug_struct("Socks5Outbound")
             .field("server", &self.server)
             .field("has_auth", &self.auth.is_some())
+            .field("tls", &self.tls.is_some())
             .field("upstream", &self.upstream)
             .finish()
     }
@@ -95,6 +100,23 @@ impl Socks5Outbound {
     pub fn new_with_path(
         config: &Socks5OutboundConfig,
         upstream: UpstreamPath,
+    ) -> io::Result<Self> {
+        let security = config.tls.as_ref().map(|_| SecurityContext::new());
+        Self::with_shared_security(
+            config,
+            upstream,
+            security.as_ref(),
+            TLS_RESUMPTION_SESSION_BUDGET,
+            64 * 1024,
+        )
+    }
+
+    pub(crate) fn with_shared_security(
+        config: &Socks5OutboundConfig,
+        upstream: UpstreamPath,
+        security: Option<&SecurityContext>,
+        sessions: usize,
+        buffer_limit: usize,
     ) -> io::Result<Self> {
         let auth = match (&config.username, &config.password) {
             (None, None) => None,
@@ -112,6 +134,33 @@ impl Socks5Outbound {
             server: server_destination(&config.address, config.port)?,
             auth,
             upstream,
+            tls: config
+                .tls
+                .as_ref()
+                .map(|policy| {
+                    StandardTlsClient::with_options(
+                        security.ok_or_else(|| {
+                            io::Error::new(
+                                io::ErrorKind::InvalidInput,
+                                "SOCKS5 TLS requires security context",
+                            )
+                        })?,
+                        &config.address,
+                        TlsClientOptions::from_policy(
+                            policy,
+                            None,
+                            security.ok_or_else(|| {
+                                io::Error::new(
+                                    io::ErrorKind::InvalidInput,
+                                    "SOCKS5 TLS requires security context",
+                                )
+                            })?,
+                        )?,
+                        sessions,
+                        buffer_limit,
+                    )
+                })
+                .transpose()?,
         })
     }
 
@@ -120,9 +169,16 @@ impl Socks5Outbound {
         session: StreamSession,
         context: &EstablishContext,
     ) -> Result<ConnectedStream, DispatchError> {
-        self.upstream
+        let mut control = self
+            .upstream
             .connect_server(session, &self.server, context)
-            .await
+            .await?;
+        if let Some(tls) = &self.tls {
+            control.io = context
+                .run_io("SOCKS5 TLS handshake", tls.connect(control.io))
+                .await?;
+        }
+        Ok(control)
     }
 
     async fn establish_tcp(
@@ -152,6 +208,7 @@ impl Socks5Outbound {
         context: &EstablishContext,
     ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
         let control_session = StreamSession {
+            metadata: request_parameters.session.metadata.clone(),
             inbound: request_parameters.session.inbound,
             source: request_parameters.session.source,
             destination: self.server.clone(),
@@ -172,6 +229,8 @@ impl Socks5Outbound {
             self.upstream.is_direct(context)?,
         )?;
 
+        let relay = self.upstream.ip4p_datagram_relay(relay, context)?;
+
         let upstream_limit = request_parameters
             .max_response_payload_size()
             .saturating_add(MAX_UDP_HEADER_SIZE);
@@ -393,6 +452,10 @@ struct Socks5DatagramTransport {
 
 #[async_trait]
 impl DatagramTransport for Socks5DatagramTransport {
+    fn supports_shared_destinations(&self) -> bool {
+        true
+    }
+
     fn payload_budget(&self, peer: &Destination) -> crate::dispatch::DatagramBudget {
         let Ok(address) = crate::socks5::encoded_address_size(peer) else {
             return crate::dispatch::DatagramBudget::new(0, 0);
@@ -505,7 +568,9 @@ mod tests {
         close_control: bool,
         fragment_response: bool,
         opened_limit: Arc<AtomicU16>,
-        switch_after_handshake: Option<Arc<AtomicUsize>>,
+        associates: Arc<AtomicUsize>,
+        udp_opens: Arc<AtomicUsize>,
+        switch_after_handshake: Option<Arc<crate::routing::GroupSelection>>,
     }
 
     impl MockUpstream {
@@ -517,6 +582,8 @@ mod tests {
                 close_control: false,
                 fragment_response: false,
                 opened_limit: Arc::new(AtomicU16::new(0)),
+                associates: Arc::new(AtomicUsize::new(0)),
+                udp_opens: Arc::new(AtomicUsize::new(0)),
                 switch_after_handshake: None,
             }
         }
@@ -535,6 +602,7 @@ mod tests {
             let auth = self.auth.clone();
             let relay = self.relay.clone();
             let close_control = self.close_control;
+            let associates = self.associates.clone();
             let switch_after_handshake = self.switch_after_handshake.clone();
             tokio::spawn(async move {
                 let mut greeting = [0_u8; 3];
@@ -572,6 +640,7 @@ mod tests {
                     .unwrap();
                 if command == COMMAND_UDP_ASSOCIATE {
                     assert_eq!(destination.port(), 0);
+                    associates.fetch_add(1, Ordering::Relaxed);
                 } else {
                     assert_eq!(
                         destination,
@@ -614,6 +683,7 @@ mod tests {
             request: DatagramRequest,
             _context: &EstablishContext,
         ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+            self.udp_opens.fetch_add(1, Ordering::Relaxed);
             self.opened_limit
                 .store(request.max_response_payload_size(), Ordering::Relaxed);
             Ok(Box::new(MockDatagrams {
@@ -734,6 +804,10 @@ mod tests {
 
     #[async_trait]
     impl DatagramTransport for MockDatagrams {
+        fn supports_shared_destinations(&self) -> bool {
+            false
+        }
+
         async fn send(&mut self, mut datagram: Datagram) -> Result<(), DispatchError> {
             if self.fragment_response {
                 let mut payload = datagram.payload.to_vec();
@@ -754,6 +828,7 @@ mod tests {
 
     fn config(auth: Option<(&str, &str)>) -> Socks5OutboundConfig {
         Socks5OutboundConfig {
+            tls: None,
             address: "socks.example".to_owned(),
             port: 1080,
             username: auth.map(|(username, _)| username.to_owned()),
@@ -763,6 +838,7 @@ mod tests {
 
     fn stream_session() -> StreamSession {
         StreamSession {
+            metadata: Default::default(),
             inbound: crate::session::InboundKind::Http,
             source: "127.0.0.1:10000".parse().unwrap(),
             destination: Destination::domain("target.example", 443).unwrap(),
@@ -847,11 +923,128 @@ mod tests {
         }
     }
 
+    #[tokio::test]
+    async fn managed_udp_shares_socks_association_and_isolates_closed_members() {
+        use crate::{
+            connections::Registry,
+            dispatch::observe_sessions_with_stats,
+            outbound::{ConnectorDispatcher, RejectOutbound},
+            resources::RuntimeResourceStats,
+            routing::{
+                EmptyGeoMatcher, ProxyDispatchers, RoutingDispatcher, RuleSet,
+                diagnostics::Diagnostics,
+            },
+        };
+
+        tokio::time::timeout(Duration::from_secs(2), async {
+            let upstream = MockUpstream::new(COMMAND_UDP_ASSOCIATE);
+            let associates = upstream.associates.clone();
+            let udp_opens = upstream.udp_opens.clone();
+            let opens = || {
+                (
+                    associates.load(Ordering::Relaxed),
+                    udp_opens.load(Ordering::Relaxed),
+                )
+            };
+            let node = Arc::new(
+                Socks5Outbound::new_with_upstream(&config(None), Arc::new(upstream)).unwrap(),
+            );
+            let leaf = observe_sessions_with_stats(
+                Arc::new(ConnectorDispatcher::new(node)),
+                RuntimeResourceStats::new("socks_managed_memory"),
+            );
+            let parsed = crate::config::Config::parse_yaml(
+                br#"
+proxies: [{name: edge, type: socks5, server: socks.example, port: 1080, udp: true}]
+rules: ["MATCH,edge"]
+"#,
+            )
+            .unwrap();
+            let rules = RuleSet::compile(parsed.rules.clone()).unwrap();
+            let registry = Arc::new(Registry::default());
+            let diagnostics = Arc::new(Diagnostics::new(&parsed, &rules, registry.clone()));
+            let router = RoutingDispatcher::new(
+                ProxyDispatchers::new(vec![leaf]).unwrap(),
+                Arc::new(ConnectorDispatcher::new(Arc::new(
+                    RejectOutbound::drop_connections(),
+                ))),
+                None,
+                rules,
+                Arc::new(EmptyGeoMatcher),
+            )
+            .with_diagnostics(diagnostics);
+            let mut first = router
+                .open_datagram(DatagramSession::for_tun(
+                    "127.0.0.1:10000".parse().unwrap(),
+                    1500,
+                ))
+                .await
+                .unwrap();
+            let mut second = router
+                .open_datagram(DatagramSession::for_tun(
+                    "127.0.0.1:10001".parse().unwrap(),
+                    1500,
+                ))
+                .await
+                .unwrap();
+            let a: std::net::SocketAddr = "198.51.100.1:443".parse().unwrap();
+            let b: std::net::SocketAddr = "198.51.100.2:53".parse().unwrap();
+            let packet = |remote: std::net::SocketAddr, body: &'static [u8]| Datagram {
+                remote: Destination::Ip(remote),
+                payload: Bytes::from_static(body),
+                sniffed_domain: None,
+            };
+            first.send(packet(a, b"stale")).await.unwrap();
+            first.send(packet(b, b"sibling")).await.unwrap();
+            assert_eq!(opens(), (1, 1), "same-source targets share one wire");
+            second.send(packet(a, b"separate")).await.unwrap();
+            assert_eq!(opens(), (2, 2), "different sources keep independent wires");
+
+            let snapshot = serde_json::to_value(registry.snapshot()).unwrap();
+            let closed = snapshot["connections"]
+                .as_array()
+                .unwrap()
+                .iter()
+                .find(|entry| {
+                    entry["metadata"]["sourcePort"] == "10000"
+                        && entry["metadata"]["destinationIP"] == "198.51.100.1"
+                        && entry["metadata"]["destinationPort"] == "443"
+                })
+                .unwrap();
+            registry.close(closed["id"].as_str().unwrap());
+            first.send(packet(a, b"fresh")).await.unwrap();
+            assert_eq!(opens(), (3, 3), "recreated target needs a new wire");
+
+            // Both old replies remain queued: the retired wire must deliver
+            // its sibling's frame while isolating the closed target's reply.
+            let mut replies = std::collections::HashMap::new();
+            for _ in 0..2 {
+                let reply = first.receive().await.unwrap();
+                assert!(replies.insert(reply.remote, reply.payload).is_none());
+            }
+            assert_eq!(replies[&Destination::Ip(a)].as_ref(), b"fresh");
+            assert_eq!(replies[&Destination::Ip(b)].as_ref(), b"sibling");
+            let reply = second.receive().await.unwrap();
+            assert_eq!(reply.remote, Destination::Ip(a));
+            assert_eq!(reply.payload.as_ref(), b"separate");
+            first.close().await.unwrap();
+            second.close().await.unwrap();
+            assert!(
+                serde_json::to_value(registry.snapshot()).unwrap()["connections"]
+                    .as_array()
+                    .unwrap()
+                    .is_empty()
+            );
+        })
+        .await
+        .expect("managed SOCKS memory IO must not wait on network or shutdown");
+    }
+
     #[tokio::test]
     async fn group_switch_during_udp_handshake_keeps_control_and_relay_on_one_upstream() {
         use crate::outbound::{SelectUpstream, SelectUpstreamMember};
 
-        let selection = Arc::new(AtomicUsize::new(0));
+        let selection = Arc::new(crate::routing::GroupSelection::new(0));
         let mut first = MockUpstream::new(COMMAND_UDP_ASSOCIATE);
         first.switch_after_handshake = Some(selection.clone());
         let first_budget = first.opened_limit.clone();
@@ -866,12 +1059,13 @@ mod tests {
             ],
         ));
         let group = Arc::new(SelectUpstream::new(
-            Arc::new(AtomicUsize::new(0)),
+            Arc::new(crate::routing::GroupSelection::new(0)),
             vec![SelectUpstreamMember::Group(child)],
         ));
         let outbound = Socks5Outbound::new_with_path(
             &config(None),
             UpstreamPath::Group {
+                server: crate::session::Destination::domain("server.example", 443).unwrap(),
                 group,
                 endpoint: None,
                 dialer: Dialer::default(),
@@ -999,6 +1193,7 @@ mod tests {
     async fn socks_over_socks_udp_nests_control_relay_and_wire_budgets() {
         let physical = Arc::new(NestedSocksUpstream::new());
         let outer_config = Socks5OutboundConfig {
+            tls: None,
             address: "outer.example".to_owned(),
             port: 1080,
             username: None,
@@ -1007,6 +1202,7 @@ mod tests {
         let outer =
             Arc::new(Socks5Outbound::new_with_upstream(&outer_config, physical.clone()).unwrap());
         let inner_config = Socks5OutboundConfig {
+            tls: None,
             address: "inner.example".to_owned(),
             port: 1080,
             username: None,
@@ -1142,4 +1338,32 @@ mod tests {
             &Destination::domain("other.example", 53_000).unwrap()
         ));
     }
+    #[test]
+    fn ip4p_udp_relay_source_check_uses_the_actual_endpoint() {
+        let encoded: std::net::SocketAddr = "[2001:0::1bb:c000:201]:8443".parse().unwrap();
+        let dialer = Dialer::default().with_connections(crate::config::ConnectionSettings {
+            dialer_ip4p_convert: true,
+            ..Default::default()
+        });
+        let path = UpstreamPath::direct(
+            ResolvedEndpoint {
+                logical_host: encoded.ip().to_string(),
+                port: 8443,
+                addresses: vec![encoded],
+            },
+            dialer,
+        );
+        let expected = path
+            .ip4p_datagram_relay(Destination::Ip(encoded), &EstablishContext::default())
+            .unwrap();
+        assert!(relay_source_matches(
+            &expected,
+            &Destination::Ip("192.0.2.1:443".parse().unwrap())
+        ));
+        assert!(!relay_source_matches(&expected, &Destination::Ip(encoded)));
+        assert!(!relay_source_matches(
+            &expected,
+            &Destination::Ip("192.0.2.2:443".parse().unwrap())
+        ));
+    }
 }
diff --git a/src/outbound/trojan/datagram.rs b/src/outbound/trojan/datagram.rs
index 53ec749..edd0050 100644
--- a/src/outbound/trojan/datagram.rs
+++ b/src/outbound/trojan/datagram.rs
@@ -1,7 +1,7 @@
 use std::io;
 
 use async_trait::async_trait;
-use bytes::{Buf, BytesMut};
+use bytes::{Buf, BufMut, BytesMut};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 
 use crate::{
@@ -93,6 +93,10 @@ fn invalid_frame() -> io::Error {
 
 #[async_trait]
 impl DatagramTransport for TrojanDatagram {
+    fn supports_shared_destinations(&self) -> bool {
+        true
+    }
+
     fn payload_budget(&self, _: &Destination) -> DatagramBudget {
         self.budget
     }
@@ -141,17 +145,18 @@ impl DatagramTransport for TrojanDatagram {
                     return Err(error.into());
                 }
             }
-            let mut buffer = [0; 2048];
-            let remaining = (MAX_FRAME_BYTES - self.wire.len()).min(buffer.len());
+            let remaining = (MAX_FRAME_BYTES - self.wire.len()).min(2048);
             if remaining == 0 {
                 self.stream.take();
                 return Err(invalid_frame().into());
             }
+            self.wire.reserve(remaining);
+            let mut output = (&mut self.wire).limit(remaining);
             match self
                 .stream
                 .as_mut()
                 .expect("checked open")
-                .read(&mut buffer[..remaining])
+                .read_buf(&mut output)
                 .await
             {
                 Ok(0) => {
@@ -162,7 +167,7 @@ impl DatagramTransport for TrojanDatagram {
                     )
                     .into());
                 }
-                Ok(length) => self.wire.extend_from_slice(&buffer[..length]),
+                Ok(_) => {}
                 Err(error) => {
                     self.stream.take();
                     return Err(error.into());
diff --git a/src/outbound/trojan/outbound.rs b/src/outbound/trojan/outbound.rs
index 6b9bf40..bb5f635 100644
--- a/src/outbound/trojan/outbound.rs
+++ b/src/outbound/trojan/outbound.rs
@@ -3,7 +3,7 @@ use std::io;
 use crate::outbound::owned_stream::OwnedStream;
 use async_trait::async_trait;
 use tokio::io::AsyncWriteExt;
-use tokio_util::{sync::CancellationToken, task::TaskTracker};
+use tokio_util::sync::CancellationToken;
 
 use crate::{
     config::{TrojanOutboundConfig, TrojanTransport},
@@ -12,13 +12,9 @@ use crate::{
         ConnectedStream, DatagramRequest, EstablishContext, OutboundConnector, UpstreamPath,
         server_destination,
     },
-    resources::observation::{self, ResourceKind},
-    security::{
-        SecurityContext, StandardTlsClient, TLS_RESUMPTION_SESSION_BUDGET, TlsCertificatePolicy,
-        TlsClientOptions,
-    },
+    security::{SecurityClient, SecurityContext, TLS_RESUMPTION_SESSION_BUDGET},
     session::{Destination, StreamSession},
-    transport::{WebSocketOptions, connect_websocket, grpc_duplex},
+    transport::{GrpcPool, WebSocketOptions, connect_websocket},
 };
 
 use super::{TrojanAuth, TrojanCommand, TrojanDatagram};
@@ -27,16 +23,15 @@ pub struct TrojanOutbound {
     server: Destination,
     upstream: UpstreamPath,
     auth: TrojanAuth,
-    tls: StandardTlsClient,
+    security: SecurityClient,
     cancellation: CancellationToken,
     transport: Transport,
-    tasks: TaskTracker,
 }
 
 enum Transport {
     Tcp,
     WebSocket(Box<WebSocketOptions>),
-    Grpc(String),
+    Grpc { uri: String, pool: GrpcPool },
 }
 
 impl std::fmt::Debug for TrojanOutbound {
@@ -75,26 +70,17 @@ impl TrojanOutbound {
                         .websocket_options()?
                         .expect("WebSocket config"),
                 )),
-                TrojanTransport::Grpc { uri } => Transport::Grpc(uri.clone()),
+                TrojanTransport::Grpc { uri, options } => Transport::Grpc {
+                    uri: uri.clone(),
+                    pool: GrpcPool::duplex_client_first(options.clone()),
+                },
             },
-            tasks: TaskTracker::new(),
             server: server_destination(&config.address, config.port)?,
             upstream,
             auth: TrojanAuth::new(&config.password)?,
-            tls: StandardTlsClient::with_options(
+            security: SecurityClient::from_security_with_context(
+                &config.security,
                 security,
-                &config.server_name,
-                TlsClientOptions {
-                    client_fingerprint: config.tls.client_fingerprint,
-                    alpn: config.tls.alpn.clone(),
-                    required_alpn: config.transport.required_alpn().map(<[u8]>::to_vec),
-                    certificate: TlsCertificatePolicy {
-                        skip_cert_verify: config.tls.skip_cert_verify,
-                        fingerprint: config.tls.fingerprint,
-                        ..Default::default()
-                    },
-                    ..Default::default()
-                },
                 resumption_sessions,
                 buffer_limit,
             )?,
@@ -102,6 +88,23 @@ impl TrojanOutbound {
         })
     }
 
+    async fn connect_tls(
+        &self,
+        session: StreamSession,
+        context: &EstablishContext,
+    ) -> Result<BoxStream, DispatchError> {
+        let raw = self
+            .upstream
+            .connect_server(session, &self.server, context)
+            .await?;
+        context
+            .run_io(
+                "Trojan TLS handshake",
+                self.security.connect_with_context(raw.io, context),
+            )
+            .await
+    }
+
     async fn connect(
         &self,
         session: StreamSession,
@@ -118,24 +121,17 @@ impl TrojanOutbound {
             biased;
             () = self.cancellation.cancelled() => Err(DispatchError::NotAllowed),
             connected = async {
-                let raw = self.upstream.connect_server(session, &self.server, context).await?;
-                let stream = context.run_io("Trojan TLS handshake", self.tls.connect(raw.io)).await?;
                 let token = self.cancellation.child_token();
                 let setup_guard = token.clone().drop_guard();
-                let stream = match &self.transport {
-                    Transport::Tcp => stream,
-                    Transport::WebSocket(options) => context.run_io("Trojan WebSocket upgrade",connect_websocket(stream,options,&request,context.deadline())).await?,
-                    Transport::Grpc(uri) => {
-                        let (stream, driver) = context.run_io("Trojan gRPC handshake",grpc_duplex(stream,uri,context.deadline())).await?;
-                        let token = token.clone();
-                        let observation = observation::track(ResourceKind::Task);
-                        self.tasks.spawn(observation::bind(async move {
-                            let _observation = observation;
-                            token.cancelled().await;
-                            let _ = driver.stop().await;
-                        }));
-                        stream
-                    },
+                let stream = if let Transport::Grpc { uri, pool } = &self.transport {
+                    pool.open(uri, context.deadline(), || async {
+                        self.connect_tls(session, context).await.map_err(io::Error::other)
+                    }).await?
+                } else {
+                    let stream = self.connect_tls(session, context).await?;
+                    if let Transport::WebSocket(options) = &self.transport {
+                        context.run_io("Trojan WebSocket upgrade",connect_websocket(stream,options,&request,context.deadline())).await?
+                    } else { stream }
                 };
                 let mut stream = OwnedStream::new(stream, token);
                 setup_guard.disarm();
@@ -172,6 +168,7 @@ impl OutboundConnector for TrojanOutbound {
     ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
         // UDP destinations live in individual frames, not this request header.
         let session = StreamSession {
+            metadata: request.session.metadata.clone(),
             inbound: request.session.inbound,
             source: request.session.source,
             destination: Destination::Ip(std::net::SocketAddr::from(([0, 0, 0, 0], 1))),
@@ -186,11 +183,15 @@ impl OutboundConnector for TrojanOutbound {
 
     fn begin_shutdown(&self) {
         self.cancellation.cancel();
+        if let Transport::Grpc { pool, .. } = &self.transport {
+            pool.begin_shutdown();
+        }
     }
     async fn shutdown(&self) {
         self.begin_shutdown();
-        self.tasks.close();
-        self.tasks.wait().await;
+        if let Transport::Grpc { pool, .. } = &self.transport {
+            pool.shutdown().await;
+        }
     }
 }
 
diff --git a/src/outbound/trusttunnel/mod.rs b/src/outbound/trusttunnel/mod.rs
new file mode 100644
index 0000000..7cd3319
--- /dev/null
+++ b/src/outbound/trusttunnel/mod.rs
@@ -0,0 +1,828 @@
+//! TrustTunnel CONNECT over supplied TLS/H2 or controlled QUIC IO. Physical sockets remain owned
+//! by the shared Dialer; the node owns the pool and its synchronous stop barrier.
+use crate::{
+    config::TrustTunnelOutboundConfig,
+    dispatch::{DatagramBudget, DatagramTransport, DispatchError},
+    outbound::{
+        ConnectedStream, DatagramRequest, EstablishContext, OutboundConnector, UpstreamPath,
+        server_destination,
+    },
+    security::{
+        SecurityContext, StandardTlsClient, TlsClientIdentity, TlsClientOptions, TlsVersions,
+    },
+    session::{DatagramSession, Destination, StreamSession},
+    transport::{GrpcPool, h3_connect as h3},
+};
+use async_trait::async_trait;
+use base64::Engine;
+use std::{
+    future::Future,
+    io,
+    pin::Pin,
+    sync::{
+        Arc, Mutex,
+        atomic::{AtomicUsize, Ordering},
+    },
+    task::{Context, Poll},
+    time::Duration,
+};
+use tokio::{
+    io::{AsyncRead, AsyncWrite, ReadBuf},
+    sync::watch,
+    task::JoinHandle,
+    time::Instant,
+};
+use tokio_util::{sync::CancellationToken, task::TaskTracker};
+
+mod packet;
+const HEALTH_INTERVAL: Duration = Duration::from_secs(7);
+
+struct ConnectionFactory {
+    server: Destination,
+    upstream: UpstreamPath,
+    tls: StandardTlsClient,
+    authorization: String,
+    quic: bool,
+    congestion: Option<quiche::CongestionControlAlgorithm>,
+}
+impl ConnectionFactory {
+    async fn connect(
+        &self,
+        session: StreamSession,
+        context: &EstablishContext,
+    ) -> io::Result<crate::dispatch::BoxStream> {
+        let raw = self
+            .upstream
+            .connect_server(session, &self.server, context)
+            .await
+            .map_err(io::Error::other)?;
+        // Mihomo's listener accepts an H2 preface over authenticated TLS
+        // without selecting ALPN. An explicit different protocol still fails.
+        self.tls.connect_h2_prior_knowledge(raw.io, context).await
+    }
+    async fn connect_quic(
+        &self,
+        session: StreamSession,
+        context: &EstablishContext,
+    ) -> io::Result<h3::QuicTransport> {
+        let tls = self.tls.quiche_config_with_context(context).await?;
+        let server_name = tls.server_name().to_owned();
+        let server = self
+            .upstream
+            .datagram_server(&self.server, context)
+            .await
+            .map_err(io::Error::other)?;
+        let peer = context
+            .resolve_ip(&server)
+            .await
+            .map_err(io::Error::other)?;
+        let budget = DatagramBudget::new(1400, 1400);
+        let request = DatagramRequest::new(
+            DatagramSession::new(session.inbound, session.source).with_metadata(session.metadata),
+        )
+        .with_budget(budget);
+        let transport = self
+            .upstream
+            .open_datagram(request, context)
+            .await
+            .map_err(io::Error::other)?;
+        Ok(h3::QuicTransport {
+            transport,
+            peer,
+            budget,
+            tls,
+            server_name,
+        })
+    }
+}
+
+enum ClientTransport {
+    H2(GrpcPool),
+    H3(h3::Pool),
+}
+impl ClientTransport {
+    async fn open(
+        &self,
+        request: http::Request<()>,
+        context: &EstablishContext,
+        observer: Option<Arc<dyn Fn() + Send + Sync>>,
+        factory: Arc<ConnectionFactory>,
+        session: StreamSession,
+    ) -> io::Result<crate::dispatch::BoxStream> {
+        match self {
+            Self::H2(pool) => match observer {
+                Some(observer) => {
+                    pool.open_connect_observed(request, context.deadline(), observer, || {
+                        factory.connect(session, context)
+                    })
+                    .await
+                }
+                None => {
+                    pool.open_connect(request, context.deadline(), || {
+                        factory.connect(session, context)
+                    })
+                    .await
+                }
+            },
+            Self::H3(pool) => {
+                let setup = context.clone();
+                pool.open_connect(request, context.deadline(), observer, move || async move {
+                    factory.connect_quic(session, &setup).await
+                })
+                .await
+            }
+        }
+    }
+    async fn probe(
+        &self,
+        request: http::Request<()>,
+        context: &EstablishContext,
+        factory: Arc<ConnectionFactory>,
+        session: StreamSession,
+    ) -> io::Result<()> {
+        match self {
+            Self::H2(pool) => {
+                pool.probe(request, context.deadline(), || {
+                    factory.connect(session, context)
+                })
+                .await
+            }
+            Self::H3(pool) => {
+                let setup = context.clone();
+                pool.probe(request, context.deadline(), move || async move {
+                    factory.connect_quic(session, &setup).await
+                })
+                .await
+            }
+        }
+    }
+    fn begin_shutdown(&self) {
+        match self {
+            Self::H2(pool) => pool.begin_shutdown(),
+            Self::H3(pool) => pool.begin_shutdown(),
+        }
+    }
+    async fn shutdown(&self) {
+        match self {
+            Self::H2(pool) => pool.shutdown().await,
+            Self::H3(pool) => pool.shutdown().await,
+        }
+    }
+}
+struct Client {
+    transport: ClientTransport,
+    active: AtomicUsize,
+    health_started: Mutex<bool>,
+    last_success: watch::Sender<Instant>,
+}
+impl Client {
+    fn new(factory: &ConnectionFactory) -> Self {
+        let (last_success, _) = watch::channel(Instant::now());
+        Self {
+            transport: if factory.quic {
+                ClientTransport::H3(h3::Pool::new(factory.congestion))
+            } else {
+                ClientTransport::H2(GrpcPool::connect_client())
+            },
+            active: AtomicUsize::new(0),
+            health_started: Mutex::new(false),
+            last_success,
+        }
+    }
+}
+struct ClientLease(Arc<Client>);
+impl Drop for ClientLease {
+    fn drop(&mut self) {
+        self.0.active.fetch_sub(1, Ordering::AcqRel);
+    }
+}
+
+struct OwnedTasks {
+    admission: Mutex<()>,
+    cancellation: CancellationToken,
+    tasks: TaskTracker,
+}
+impl OwnedTasks {
+    fn new() -> Self {
+        Self {
+            admission: Mutex::new(()),
+            cancellation: CancellationToken::new(),
+            tasks: TaskTracker::new(),
+        }
+    }
+    fn spawn(
+        &self,
+        future: impl Future<Output = ()> + Send + 'static,
+    ) -> io::Result<JoinHandle<()>> {
+        let _admission = self.admission.lock().unwrap();
+        if self.cancellation.is_cancelled() {
+            return Err(io::ErrorKind::ConnectionAborted.into());
+        }
+        let cancel = self.cancellation.clone();
+        Ok(self
+            .tasks
+            .spawn(crate::resources::observation::task(async move {
+                tokio::select! {biased; ()=cancel.cancelled()=>{}, ()=future=>{}}
+            })))
+    }
+    fn close(&self) {
+        let _admission = self.admission.lock().unwrap();
+        self.cancellation.cancel();
+        self.tasks.close();
+    }
+}
+
+pub struct TrustTunnelOutbound {
+    connection: Arc<ConnectionFactory>,
+    options: crate::config::TrustTunnelPoolOptions,
+    udp: bool,
+    health_check: bool,
+    clients: Mutex<Vec<Arc<Client>>>,
+    owned: OwnedTasks,
+}
+
+impl TrustTunnelOutbound {
+    pub(crate) fn with_shared_security(
+        config: &TrustTunnelOutboundConfig,
+        upstream: UpstreamPath,
+        security: &SecurityContext,
+        sessions: usize,
+        buffer_limit: usize,
+    ) -> io::Result<Self> {
+        let policy = &config.tls;
+        let tls = StandardTlsClient::with_options(
+            security,
+            &policy.server_name,
+            TlsClientOptions {
+                ech: policy.ech.clone(),
+                client_fingerprint: if config.quic {
+                    None
+                } else {
+                    policy.client_fingerprint
+                },
+                versions: if policy.tls13_only {
+                    TlsVersions::Tls13
+                } else {
+                    TlsVersions::Tls12And13
+                },
+                alpn: policy.alpn.clone(),
+                required_alpn: policy.required_alpn.clone(),
+                certificate: policy.certificate.clone(),
+                identity: policy
+                    .identity
+                    .as_ref()
+                    .map(|identity| TlsClientIdentity::from_config(identity, security))
+                    .transpose()?,
+            },
+            sessions,
+            buffer_limit,
+        )?;
+        if config.quic {
+            tls.prepare_quiche_identity()?;
+        }
+        let connection = Arc::new(ConnectionFactory {
+            server: server_destination(&config.address, config.port)?,
+            upstream,
+            tls,
+            authorization: format!(
+                "Basic {}",
+                base64::engine::general_purpose::STANDARD
+                    .encode(format!("{}:{}", config.username, config.password))
+            ),
+            quic: config.quic,
+            congestion: if config.quic {
+                crate::transport::quiche_h3::congestion_controller(&config.congestion_controller)
+            } else {
+                None
+            },
+        });
+        let first = Arc::new(Client::new(&connection));
+        Ok(Self {
+            connection,
+            options: config.pool,
+            udp: config.udp,
+            health_check: config.health_check,
+            clients: Mutex::new(vec![first]),
+            owned: OwnedTasks::new(),
+        })
+    }
+    fn select_client(&self) -> io::Result<ClientLease> {
+        let _admission = self.owned.admission.lock().unwrap();
+        if self.owned.cancellation.is_cancelled() {
+            return Err(io::ErrorKind::ConnectionAborted.into());
+        }
+        let mut clients = self.clients.lock().unwrap();
+        let candidate = clients
+            .iter()
+            .min_by_key(|client| client.active.load(Ordering::Acquire))
+            .cloned();
+        let client = match candidate {
+            Some(client)
+                if reuse_client(
+                    &self.options,
+                    clients.len(),
+                    client.active.load(Ordering::Acquire),
+                ) =>
+            {
+                client
+            }
+            _ => {
+                let client = Arc::new(Client::new(&self.connection));
+                clients.push(client.clone());
+                client
+            }
+        };
+        client
+            .active
+            .try_update(Ordering::AcqRel, Ordering::Acquire, |count| {
+                count.checked_add(1)
+            })
+            .map_err(|_| io::Error::from(io::ErrorKind::OutOfMemory))?;
+        Ok(ClientLease(client))
+    }
+    fn start_health(
+        &self,
+        client: &Arc<Client>,
+        session: &StreamSession,
+        context: &EstablishContext,
+    ) -> io::Result<()> {
+        if !self.health_check {
+            return Ok(());
+        }
+        let mut started = client.health_started.lock().unwrap();
+        if *started {
+            return Ok(());
+        }
+        client.last_success.send_replace(Instant::now());
+        let mut activity = client.last_success.subscribe();
+        let client = Arc::downgrade(client);
+        let factory = self.connection.clone();
+        let session = session.clone();
+        let resolution = context.resolution();
+        self.owned.spawn(async move {
+            loop {
+                let deadline = *activity.borrow_and_update() + HEALTH_INTERVAL;
+                tokio::select! {
+                    changed=activity.changed()=>{ if changed.is_err() { return; } continue; }
+                    ()=tokio::time::sleep_until(deadline)=>{}
+                }
+                let Some(client) = client.upgrade() else {
+                    return;
+                };
+                let context =
+                    EstablishContext::with_resolution(HEALTH_INTERVAL, resolution.clone());
+                if let Ok(request) =
+                    authority_request("_check", &factory.authorization, std::env::consts::OS)
+                {
+                    let _ = client
+                        .transport
+                        .probe(request, &context, factory.clone(), session.clone())
+                        .await;
+                }
+                // Probe failure does not reset physical connections or mutate a
+                // policy group's health; the next probe is scheduled normally.
+                client.last_success.send_replace(Instant::now());
+            }
+        })?;
+        *started = true;
+        Ok(())
+    }
+    async fn connect(
+        &self,
+        session: StreamSession,
+        authority: &str,
+        context: &EstablishContext,
+    ) -> io::Result<crate::dispatch::BoxStream> {
+        let lease = self.select_client()?;
+        self.start_health(&lease.0, &session, context)?;
+        let user_agent = if authority == "_udp2" {
+            format!("{} _udp2", std::env::consts::OS)
+        } else {
+            format!(
+                "{} Vole/{}",
+                std::env::consts::OS,
+                env!("CARGO_PKG_VERSION")
+            )
+        };
+        let request = authority_request(authority, &self.connection.authorization, &user_agent)?;
+        let observer = if self.health_check {
+            let client = Arc::downgrade(&lease.0);
+            Some(Arc::new(move || {
+                if let Some(client) = client.upgrade() {
+                    client.last_success.send_replace(Instant::now());
+                }
+            }) as Arc<dyn Fn() + Send + Sync>)
+        } else {
+            None
+        };
+        let stream = lease
+            .0
+            .transport
+            .open(request, context, observer, self.connection.clone(), session)
+            .await?;
+        Ok(Box::new(CountedStream {
+            io: stream,
+            lease: Some(lease),
+        }))
+    }
+}
+
+fn reuse_client(
+    options: &crate::config::TrustTunnelPoolOptions,
+    count: usize,
+    active: usize,
+) -> bool {
+    let smaller =
+        |count: usize, threshold: i64| threshold > 0 && (count as u128) < threshold as u128;
+    active == 0
+        || if options.max_connections > 0 {
+            !smaller(count, options.max_connections) || smaller(active, options.min_streams)
+        } else {
+            smaller(active, options.max_streams)
+        }
+}
+
+struct CountedStream {
+    io: crate::dispatch::BoxStream,
+    lease: Option<ClientLease>,
+}
+impl AsyncRead for CountedStream {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buffer: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.io).poll_read(cx, buffer)
+    }
+}
+impl AsyncWrite for CountedStream {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        bytes: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        Pin::new(&mut self.io).poll_write(cx, bytes)
+    }
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.io).poll_flush(cx)
+    }
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let result = Pin::new(&mut self.io).poll_shutdown(cx);
+        if result.is_ready() {
+            self.lease.take();
+        }
+        result
+    }
+}
+
+#[cfg(test)]
+fn connect_request(target: &Destination, authorization: &str) -> io::Result<http::Request<()>> {
+    let authority = match target {
+        Destination::Ip(address) => address.to_string(),
+        Destination::Domain { host, port } => format!("{host}:{port}"),
+    };
+    authority_request(
+        &authority,
+        authorization,
+        &format!(
+            "{} Vole/{}",
+            std::env::consts::OS,
+            env!("CARGO_PKG_VERSION")
+        ),
+    )
+}
+fn authority_request(
+    authority: &str,
+    authorization: &str,
+    user_agent: &str,
+) -> io::Result<http::Request<()>> {
+    // Ordinary CONNECT uses only :authority in both H2 and H3.
+    let uri = http::Uri::builder()
+        .authority(authority)
+        .build()
+        .map_err(|_| io::Error::from(io::ErrorKind::InvalidInput))?;
+    http::Request::builder()
+        .method(http::Method::CONNECT)
+        .uri(uri)
+        .header("proxy-authorization", authorization)
+        .header("user-agent", user_agent)
+        .body(())
+        .map_err(|_| io::Error::from(io::ErrorKind::InvalidInput))
+}
+
+#[async_trait]
+impl OutboundConnector for TrustTunnelOutbound {
+    async fn connect_stream(
+        &self,
+        session: StreamSession,
+        context: &EstablishContext,
+    ) -> Result<ConnectedStream, DispatchError> {
+        let target = session.destination.clone();
+        let authority = match &target {
+            Destination::Ip(address) => address.to_string(),
+            Destination::Domain { host, port } => format!("{host}:{port}"),
+        };
+        let io = context
+            .run_io(
+                "TrustTunnel CONNECT",
+                self.connect(session, &authority, context),
+            )
+            .await?;
+        Ok(ConnectedStream {
+            io,
+            effective_peer: target,
+        })
+    }
+    async fn open_datagram(
+        &self,
+        request: DatagramRequest,
+        context: &EstablishContext,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        if !self.udp {
+            return Err(DispatchError::NotAllowed);
+        }
+        let session = StreamSession {
+            metadata: request.session.metadata.clone(),
+            inbound: request.session.inbound,
+            source: request.session.source,
+            destination: self.connection.server.clone(),
+            sniffed_domain: None,
+        };
+        let io = context
+            .run_io(
+                "TrustTunnel UDP CONNECT",
+                self.connect(session, "_udp2", context),
+            )
+            .await?;
+        let transport = packet::PacketTransport::new(
+            io,
+            &request,
+            context,
+            self.owned.cancellation.clone(),
+            |reader| self.owned.spawn(reader),
+        )?;
+        Ok(crate::dispatch::bound_datagram(
+            Box::new(transport),
+            request.budget(),
+        ))
+    }
+    fn begin_shutdown(&self) {
+        self.owned.close();
+        for client in self.clients.lock().unwrap().iter() {
+            client.transport.begin_shutdown();
+        }
+    }
+    async fn shutdown(&self) {
+        self.begin_shutdown();
+        self.owned.tasks.wait().await;
+        let clients = std::mem::take(&mut *self.clients.lock().unwrap());
+        for client in clients {
+            client.transport.shutdown().await;
+        }
+    }
+}
+impl Drop for TrustTunnelOutbound {
+    fn drop(&mut self) {
+        self.begin_shutdown();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::config::GrpcOptions;
+    use crate::resources::observation::ResourceProbe;
+    use std::sync::{
+        Arc,
+        atomic::{AtomicUsize, Ordering},
+    };
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+    use tokio_util::task::TaskTracker;
+
+    struct NoNetwork;
+    #[async_trait]
+    impl OutboundConnector for NoNetwork {
+        async fn connect_stream(
+            &self,
+            _: StreamSession,
+            _: &EstablishContext,
+        ) -> Result<ConnectedStream, DispatchError> {
+            Err(DispatchError::NotAllowed)
+        }
+        async fn open_datagram(
+            &self,
+            _: DatagramRequest,
+            _: &EstablishContext,
+        ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+            Err(DispatchError::NotAllowed)
+        }
+    }
+    fn make_node(options: &str) -> TrustTunnelOutbound {
+        let config = crate::config::Config::parse_yaml(format!("proxies:\n  - name: tunnel\n    type: trusttunnel\n    server: fixture.invalid\n    port: 443\n{options}").as_bytes()).unwrap();
+        let crate::config::ProxyProtocol::TrustTunnel(config) = &config.proxies[0].protocol else {
+            panic!("TrustTunnel");
+        };
+        TrustTunnelOutbound::with_shared_security(
+            config,
+            UpstreamPath::proxy(Arc::new(NoNetwork)),
+            &SecurityContext::new(),
+            1,
+            65536,
+        )
+        .unwrap()
+    }
+
+    #[tokio::test]
+    async fn trusttunnel_logical_slots_release_leases_and_keep_threshold_priority() {
+        let node = make_node("    max-connections: 2\n    min-streams: 1\n    max-streams: 1\n");
+        let first = node.select_client().unwrap();
+        let second = node.select_client().unwrap();
+        let third = node.select_client().unwrap();
+        assert_eq!(node.clients.lock().unwrap().len(), 2);
+        assert!(Arc::ptr_eq(&first.0, &third.0));
+        assert!(!Arc::ptr_eq(&first.0, &second.0));
+        drop(second);
+        let fourth = node.select_client().unwrap();
+        assert_eq!(fourth.0.active.load(Ordering::Acquire), 1);
+        assert!(!Arc::ptr_eq(&first.0, &fourth.0));
+        drop((first, third, fourth));
+        // A transport can retire independently of its persistent logical slot.
+        assert_eq!(node.clients.lock().unwrap().len(), 2);
+        node.shutdown().await;
+        assert!(node.select_client().is_err());
+        assert!(node.owned.spawn(async {}).is_err());
+
+        let node = make_node("    max-connections: -1\n    max-streams: 1\n");
+        let first = node.select_client().unwrap();
+        let second = node.select_client().unwrap();
+        assert_eq!(node.clients.lock().unwrap().len(), 2);
+        drop(first);
+        let third = node.select_client().unwrap();
+        assert_ne!(Arc::as_ptr(&second.0), Arc::as_ptr(&third.0));
+        drop((second, third));
+        node.shutdown().await;
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn trusttunnel_health_is_lazy_bodyless_and_does_not_count_business_streams() {
+        let observation = ResourceProbe::default();
+        observation
+            .scope(async {
+                let node = make_node("    health-check: true\n");
+                assert!(node.owned.tasks.is_empty());
+                let lease = node.select_client().unwrap();
+                let peers = TaskTracker::new();
+                let (checked, mut checks) = tokio::sync::mpsc::channel(1);
+                let ready = Arc::new(tokio::sync::Notify::new());
+                let (raw, peer) = tokio::io::duplex(65536);
+                let streams = peers.clone();
+                peers.spawn(async move {
+                    let mut connection = h2::server::handshake(peer).await.unwrap();
+                    while let Some(Ok((request, mut response))) = connection.accept().await {
+                        if request.uri().authority().unwrap().as_str() == "_check" {
+                            assert_eq!(request.headers()["user-agent"], std::env::consts::OS);
+                            assert_eq!(request.headers()["proxy-authorization"], "Basic Og==");
+                            assert!(request.body().is_end_stream());
+                            response
+                                .send_response(http::Response::new(()), true)
+                                .unwrap();
+                            checked.send(()).await.unwrap();
+                        } else {
+                            let send = response
+                                .send_response(http::Response::new(()), false)
+                                .unwrap();
+                            streams.spawn(async move {
+                                let _send = send;
+                                let mut receive = request.into_body();
+                                while let Some(Ok(data)) = receive.data().await {
+                                    receive.flow_control().release_capacity(data.len()).unwrap();
+                                }
+                            });
+                        }
+                    }
+                });
+                let session = StreamSession {
+                    metadata: Default::default(),
+                    inbound: crate::session::InboundKind::Socks5,
+                    source: "127.0.0.1:1000".parse().unwrap(),
+                    destination: Destination::Domain {
+                        host: "target.invalid".into(),
+                        port: 443,
+                    },
+                    sniffed_domain: None,
+                };
+                let context = EstablishContext::with_timeout(Duration::from_secs(5));
+                node.start_health(&lease.0, &session, &context).unwrap();
+                let observed_client = Arc::downgrade(&lease.0);
+                let observed_ready = ready.clone();
+                let ClientTransport::H2(transport) = &lease.0.transport else {
+                    unreachable!();
+                };
+                let mut stream = transport
+                    .open_connect_observed(
+                        connect_request(&session.destination, &node.connection.authorization)
+                            .unwrap(),
+                        context.deadline(),
+                        Arc::new(move || {
+                            if let Some(client) = observed_client.upgrade() {
+                                client.last_success.send_replace(Instant::now());
+                            }
+                            observed_ready.notify_one();
+                        }),
+                        || async { Ok(Box::new(raw) as crate::dispatch::BoxStream) },
+                    )
+                    .await
+                    .unwrap();
+                stream.write_all(b"write-only").await.unwrap();
+                stream.flush().await.unwrap();
+                ready.notified().await;
+                tokio::time::advance(Duration::from_secs(6)).await;
+                assert!(checks.try_recv().is_err());
+                tokio::time::advance(Duration::from_secs(1)).await;
+                checks.recv().await.unwrap();
+                assert_eq!(lease.0.active.load(Ordering::Acquire), 1);
+                stream.shutdown().await.unwrap();
+                drop((stream, lease));
+                node.shutdown().await;
+                drop(node);
+                peers.close();
+                peers.wait().await;
+            })
+            .await;
+        assert!(observation.snapshot().is_idle());
+    }
+
+    #[tokio::test]
+    async fn trusttunnel_h2_connect_is_raw_deferred_pooled_and_stopped() {
+        let probe = ResourceProbe::default();
+        probe
+            .scope(async {
+                let peers = TaskTracker::new();
+                let connections = Arc::new(AtomicUsize::new(0));
+                let pool = GrpcPool::new(GrpcOptions::default());
+                let make_connection = || {
+                    connections.fetch_add(1, Ordering::SeqCst);
+                    let (client, peer) = tokio::io::duplex(64 * 1024);
+                    let streams = peers.clone();
+                    peers.spawn(async move {
+                        let mut connection = h2::server::handshake(peer).await.unwrap();
+                        while let Some(Ok((request, mut response))) = connection.accept().await {
+                            assert_eq!(request.method(), http::Method::CONNECT);
+                            assert_eq!(request.uri().authority().unwrap(), "example.invalid:443");
+                            assert_eq!(request.headers()["proxy-authorization"], "Basic dTpw");
+                            assert!(!request.headers().contains_key("content-type"));
+                            streams.spawn(async move {
+                                let mut receive = request.into_body();
+                                let data = receive.data().await.unwrap().unwrap();
+                                assert_eq!(data.as_ref(), b"unframed-client-first");
+                                receive.flow_control().release_capacity(data.len()).unwrap();
+                                let mut send = response
+                                    .send_response(http::Response::new(()), false)
+                                    .unwrap();
+                                send.send_data(data, false).unwrap();
+                                while receive.data().await.is_some_and(|data| data.is_ok()) {}
+                            });
+                        }
+                    });
+                    async move { Ok(Box::new(client) as crate::dispatch::BoxStream) }
+                };
+                let target = Destination::Domain {
+                    host: "example.invalid".into(),
+                    port: 443,
+                };
+                let deadline = tokio::time::Instant::now() + std::time::Duration::from_secs(5);
+                let mut first = pool
+                    .open_connect(
+                        connect_request(&target, "Basic dTpw").unwrap(),
+                        deadline,
+                        make_connection,
+                    )
+                    .await
+                    .unwrap();
+                let mut second = pool
+                    .open_connect(
+                        connect_request(&target, "Basic dTpw").unwrap(),
+                        deadline,
+                        make_connection,
+                    )
+                    .await
+                    .unwrap();
+                assert_eq!(connections.load(Ordering::SeqCst), 1);
+                for stream in [&mut first, &mut second] {
+                    stream.write_all(b"unframed-client-first").await.unwrap();
+                    stream.flush().await.unwrap();
+                    let mut response = [0; 21];
+                    stream.read_exact(&mut response).await.unwrap();
+                    assert_eq!(&response, b"unframed-client-first");
+                }
+                first.shutdown().await.unwrap();
+                pool.shutdown().await;
+                assert!(second.write_all(b"after-stop").await.is_err());
+                drop((first, second));
+                peers.close();
+                peers.wait().await;
+            })
+            .await;
+        assert!(probe.snapshot().is_idle());
+    }
+}
diff --git a/src/outbound/trusttunnel/packet.rs b/src/outbound/trusttunnel/packet.rs
new file mode 100644
index 0000000..1d38035
--- /dev/null
+++ b/src/outbound/trusttunnel/packet.rs
@@ -0,0 +1,677 @@
+//! TrustTunnel UDP frames over an owned reliable CONNECT stream.
+//! The wire layout follows Mihomo's TrustTunnel packet protocol; this module
+//! creates no sockets and keeps parsing independent of receive-future lifetime.
+
+use std::{
+    io,
+    net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr},
+    sync::{
+        Arc,
+        atomic::{AtomicBool, Ordering},
+    },
+};
+
+use async_trait::async_trait;
+use bytes::{BufMut, Bytes, BytesMut};
+use futures_util::future::BoxFuture;
+use tokio::{
+    io::{AsyncRead, AsyncReadExt, AsyncWriteExt, WriteHalf},
+    sync::mpsc,
+    task::JoinHandle,
+    time::{Instant, timeout_at},
+};
+use tokio_util::sync::CancellationToken;
+
+use crate::{
+    dispatch::{BoxStream, DatagramBudget, DatagramTransport, DispatchError},
+    dns::resolution::ResolutionContext,
+    outbound::{DEFAULT_ESTABLISH_TIMEOUT, DatagramRequest, EstablishContext},
+    resources::observation::{Guard, ResourceKind, track},
+    session::{Datagram, Destination},
+};
+
+const ADDRESS_BYTES: usize = 36;
+const APP_NAME: &[u8] = b"Vole";
+const RESPONSE_QUEUE_CAPACITY: usize = 1;
+const DRAIN_BUFFER_BYTES: usize = 2_048;
+
+pub(super) struct PacketTransport {
+    writer: Option<WriteHalf<BoxStream>>,
+    responses: mpsc::Receiver<io::Result<Datagram>>,
+    cancellation: CancellationToken,
+    reader: Option<JoinHandle<()>>,
+    reader_alive: Arc<AtomicBool>,
+    resolution: ResolutionContext,
+    initial_deadline: Option<Instant>,
+    budget: DatagramBudget,
+    closed: bool,
+    _observation: Guard,
+}
+
+impl PacketTransport {
+    /// `spawn` is the node's synchronous admission seam. It rejects work after
+    /// shutdown begins and includes the reader in the node's stop barrier.
+    pub(super) fn new<F>(
+        io: BoxStream,
+        request: &DatagramRequest,
+        context: &EstablishContext,
+        parent_cancellation: CancellationToken,
+        spawn: F,
+    ) -> io::Result<Self>
+    where
+        F: FnOnce(BoxFuture<'static, ()>) -> io::Result<JoinHandle<()>>,
+    {
+        if parent_cancellation.is_cancelled() {
+            return Err(io::ErrorKind::ConnectionAborted.into());
+        }
+        let cancellation = parent_cancellation.child_token();
+        let (reader, writer) = tokio::io::split(io);
+        let (responses, receiver) = mpsc::channel(RESPONSE_QUEUE_CAPACITY);
+        let reader_alive = Arc::new(AtomicBool::new(true));
+        // The guard also runs when admission rejects and drops the future.
+        let lifetime = ReaderLifetime(reader_alive.clone());
+        let reader = spawn(Box::pin(read_loop(
+            reader,
+            responses,
+            request.budget().receive(),
+            cancellation.clone(),
+            lifetime,
+        )))?;
+        Ok(Self {
+            writer: Some(writer),
+            responses: receiver,
+            cancellation,
+            reader: Some(reader),
+            reader_alive,
+            resolution: context.resolution(),
+            initial_deadline: Some(context.deadline()),
+            budget: request.budget(),
+            closed: false,
+            _observation: track(ResourceKind::Association),
+        })
+    }
+
+    fn check_open(&mut self) -> Result<(), DispatchError> {
+        if self.closed || self.cancellation.is_cancelled() || self.writer.is_none() {
+            self.writer.take();
+            self.closed = true;
+            return Err(DispatchError::NotAllowed);
+        }
+        Ok(())
+    }
+}
+
+struct ReaderLifetime(Arc<AtomicBool>);
+
+impl Drop for ReaderLifetime {
+    fn drop(&mut self) {
+        self.0.store(false, Ordering::Release);
+    }
+}
+
+/// A cancelled or failed partial write cannot be retried as a fresh UDP frame.
+struct SendGuard<'a> {
+    writer: &'a mut Option<WriteHalf<BoxStream>>,
+    cancellation: CancellationToken,
+    committed: bool,
+}
+
+impl Drop for SendGuard<'_> {
+    fn drop(&mut self) {
+        if !self.committed {
+            self.cancellation.cancel();
+            self.writer.take();
+        }
+    }
+}
+
+#[async_trait]
+impl DatagramTransport for PacketTransport {
+    fn supports_shared_destinations(&self) -> bool {
+        // The _udp2 stream encodes and returns an address on every frame.
+        true
+    }
+
+    fn payload_budget(&self, _: &Destination) -> DatagramBudget {
+        self.budget
+    }
+
+    async fn send(&mut self, datagram: Datagram) -> Result<(), DispatchError> {
+        self.check_open()?;
+        if !self.reader_alive.load(Ordering::Acquire) {
+            self.writer.take();
+            self.closed = true;
+            return Err(DispatchError::NotAllowed);
+        }
+        if datagram.payload.len() > usize::from(self.budget.transmit()) {
+            return Err(DispatchError::from(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "TrustTunnel UDP payload exceeds its send budget",
+            )));
+        }
+        let deadline = self
+            .initial_deadline
+            .unwrap_or_else(|| Instant::now() + DEFAULT_ESTABLISH_TIMEOUT);
+        if Instant::now() >= deadline {
+            self.cancellation.cancel();
+            self.writer.take();
+            self.closed = true;
+            return Err(DispatchError::TimedOut);
+        }
+        let address = tokio::select! {
+            biased;
+            () = self.cancellation.cancelled() => return Err(DispatchError::NotAllowed),
+            result = self.resolution.resolve_ip(&datagram.remote, deadline) => result?,
+        };
+        let packet = encode_packet(address, &datagram.payload);
+        let mut guard = SendGuard {
+            writer: &mut self.writer,
+            cancellation: self.cancellation.clone(),
+            committed: false,
+        };
+        let initial_deadline = self.initial_deadline;
+        tokio::select! {
+            biased;
+            () = guard.cancellation.cancelled() => return Err(DispatchError::NotAllowed),
+            result = async {
+                let writing = async {
+                    let writer = guard.writer.as_mut().ok_or(io::ErrorKind::BrokenPipe)?;
+                    writer.write_all(&packet).await?;
+                    writer.flush().await
+                };
+                if let Some(deadline) = initial_deadline {
+                    timeout_at(deadline, writing).await
+                        .map_err(|_| DispatchError::TimedOut)?
+                        .map_err(DispatchError::from)
+                } else {
+                    writing.await.map_err(DispatchError::from)
+                }
+            } => result?,
+        }
+        guard.committed = true;
+        drop(guard);
+        self.initial_deadline = None;
+        Ok(())
+    }
+
+    async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+        self.check_open()?;
+        let response = tokio::select! {
+            biased;
+            () = self.cancellation.cancelled() => return Err(DispatchError::NotAllowed),
+            response = self.responses.recv() => response,
+        };
+        match response {
+            Some(Ok(datagram)) => Ok(datagram),
+            Some(Err(error)) => {
+                self.closed = true;
+                self.cancellation.cancel();
+                self.writer.take();
+                Err(DispatchError::from(error))
+            }
+            None => {
+                self.closed = true;
+                self.cancellation.cancel();
+                self.writer.take();
+                Err(DispatchError::from(io::Error::new(
+                    io::ErrorKind::UnexpectedEof,
+                    "TrustTunnel UDP response stream ended",
+                )))
+            }
+        }
+    }
+
+    async fn close(&mut self) -> Result<(), DispatchError> {
+        self.closed = true;
+        self.cancellation.cancel();
+        let result = match self.reader.take() {
+            Some(reader) => reader.await.map_err(|_| {
+                DispatchError::from(io::Error::other("TrustTunnel UDP reader stopped"))
+            }),
+            None => Ok(()),
+        };
+        // Every successful send was flushed. Failed/cancelled partial writes
+        // are unusable; releasing both halves closes the whole CONNECT stream
+        // without waiting for a stalled peer to supply additional flow credit.
+        self.writer.take();
+        self.responses.close();
+        while self.responses.try_recv().is_ok() {}
+        result
+    }
+}
+
+impl Drop for PacketTransport {
+    fn drop(&mut self) {
+        self.cancellation.cancel();
+        self.writer.take();
+        if let Some(reader) = self.reader.take() {
+            reader.abort();
+        }
+    }
+}
+
+fn encode_packet(address: SocketAddr, payload: &[u8]) -> Bytes {
+    let metadata_length = ADDRESS_BYTES + 1 + APP_NAME.len();
+    let mut packet = BytesMut::with_capacity(4 + metadata_length + payload.len());
+    packet.put_u32((metadata_length + payload.len()) as u32);
+    packet.extend_from_slice(&[0; 18]); // Unknown local source IP and port.
+    packet.extend_from_slice(&padded_ip(address.ip()));
+    packet.put_u16(address.port());
+    packet.put_u8(APP_NAME.len() as u8);
+    packet.extend_from_slice(APP_NAME);
+    packet.extend_from_slice(payload);
+    packet.freeze()
+}
+
+fn padded_ip(address: IpAddr) -> [u8; 16] {
+    match address {
+        IpAddr::V4(address) => {
+            let mut padded = [0; 16];
+            padded[12..].copy_from_slice(&address.octets());
+            padded
+        }
+        IpAddr::V6(address) => address.octets(),
+    }
+}
+
+fn parse_ip(address: [u8; 16]) -> IpAddr {
+    // The reference reserves ::1 for IPv6 despite the zero-padded IPv4 layout.
+    if address[..12] == [0; 12] && address != Ipv6Addr::LOCALHOST.octets() {
+        IpAddr::V4(Ipv4Addr::new(
+            address[12],
+            address[13],
+            address[14],
+            address[15],
+        ))
+    } else {
+        IpAddr::V6(Ipv6Addr::from(address))
+    }
+}
+
+async fn read_loop<R>(
+    mut reader: R,
+    responses: mpsc::Sender<io::Result<Datagram>>,
+    budget: u16,
+    cancellation: CancellationToken,
+    lifetime: ReaderLifetime,
+) where
+    R: AsyncRead + Unpin,
+{
+    loop {
+        let response = tokio::select! {
+            biased;
+            () = cancellation.cancelled() => return,
+            result = read_packet(&mut reader, budget) => result,
+        };
+        let response = match response {
+            Ok(Some(datagram)) => Ok(datagram),
+            Ok(None) => {
+                tokio::task::yield_now().await;
+                continue;
+            }
+            Err(error) => {
+                lifetime.0.store(false, Ordering::Release);
+                tokio::select! {
+                    biased;
+                    () = cancellation.cancelled() => {},
+                    _ = responses.send(Err(error)) => {},
+                }
+                return;
+            }
+        };
+        tokio::select! {
+            biased;
+            () = cancellation.cancelled() => return,
+            result = responses.send(response) => {
+                if result.is_err() { return; }
+            },
+        }
+    }
+}
+
+async fn read_packet<R>(reader: &mut R, budget: u16) -> io::Result<Option<Datagram>>
+where
+    R: AsyncRead + Unpin,
+{
+    let length = reader.read_u32().await? as usize;
+    let payload_length = length
+        .checked_sub(ADDRESS_BYTES)
+        .filter(|length| *length <= usize::from(u16::MAX))
+        .ok_or_else(|| {
+            io::Error::new(io::ErrorKind::InvalidData, "invalid TrustTunnel UDP length")
+        })?;
+    let mut addresses = [0; ADDRESS_BYTES];
+    reader.read_exact(&mut addresses).await?;
+    if payload_length > usize::from(budget) {
+        let mut remaining = payload_length;
+        let mut buffer = [0; DRAIN_BUFFER_BYTES];
+        while remaining > 0 {
+            let length = remaining.min(buffer.len());
+            reader.read_exact(&mut buffer[..length]).await?;
+            remaining -= length;
+        }
+        return Ok(None);
+    }
+    let mut payload = vec![0; payload_length];
+    reader.read_exact(&mut payload).await?;
+    Ok(Some(Datagram {
+        remote: Destination::Ip(SocketAddr::new(
+            parse_ip(addresses[..16].try_into().expect("fixed IP field")),
+            u16::from_be_bytes(addresses[16..18].try_into().expect("fixed port field")),
+        )),
+        payload: Bytes::from(payload),
+        sniffed_domain: None,
+    }))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        dialer::{ResolvedEndpoint, Resolver},
+        resources::observation::ResourceProbe,
+        session::{DatagramSession, InboundKind},
+    };
+    use std::sync::atomic::AtomicUsize;
+    use tokio::sync::oneshot;
+    use tokio_util::task::TaskTracker;
+
+    struct FixedResolver(AtomicUsize);
+
+    #[async_trait]
+    impl Resolver for FixedResolver {
+        async fn resolve(&self, host: &str, port: u16) -> io::Result<ResolvedEndpoint> {
+            self.0.fetch_add(1, Ordering::Relaxed);
+            Ok(ResolvedEndpoint {
+                logical_host: host.into(),
+                port,
+                addresses: vec![SocketAddr::from(([192, 0, 2, 10], port))],
+            })
+        }
+    }
+
+    fn request(budget: u16) -> DatagramRequest {
+        DatagramRequest::new(DatagramSession::new(
+            InboundKind::InternalDns,
+            "127.0.0.1:10000".parse().unwrap(),
+        ))
+        .with_budget(DatagramBudget::new(budget, budget))
+    }
+
+    fn datagram(payload: &'static [u8]) -> Datagram {
+        Datagram {
+            remote: Destination::Domain {
+                host: "example.invalid".into(),
+                port: 53,
+            },
+            payload: Bytes::from_static(payload),
+            sniffed_domain: None,
+        }
+    }
+
+    fn server_packet(address: SocketAddr, payload: &[u8]) -> Vec<u8> {
+        let mut wire = Vec::new();
+        wire.extend_from_slice(&((ADDRESS_BYTES + payload.len()) as u32).to_be_bytes());
+        wire.extend_from_slice(&padded_ip(address.ip()));
+        wire.extend_from_slice(&address.port().to_be_bytes());
+        wire.extend_from_slice(&[0; 18]);
+        wire.extend_from_slice(payload);
+        wire
+    }
+
+    async fn assert_client_packet<R: AsyncRead + Unpin>(reader: &mut R, payload: &[u8]) {
+        assert_client_packet_to(reader, "192.0.2.10:53".parse().unwrap(), payload).await;
+    }
+
+    async fn assert_client_packet_to<R: AsyncRead + Unpin>(
+        reader: &mut R,
+        remote: SocketAddr,
+        payload: &[u8],
+    ) {
+        let length = reader.read_u32().await.unwrap() as usize;
+        assert_eq!(length, 37 + APP_NAME.len() + payload.len());
+        let mut body = vec![0; length];
+        reader.read_exact(&mut body).await.unwrap();
+        assert_eq!(&body[..18], &[0; 18]);
+        assert_eq!(&body[18..34], &padded_ip(remote.ip()));
+        assert_eq!(&body[34..36], &remote.port().to_be_bytes());
+        assert_eq!(body[36] as usize, APP_NAME.len());
+        assert_eq!(&body[37..37 + APP_NAME.len()], APP_NAME);
+        assert_eq!(&body[37 + APP_NAME.len()..], payload);
+    }
+
+    #[tokio::test]
+    async fn trusttunnel_udp_shared_stream_preserves_targets_and_independent_close() {
+        let probe = ResourceProbe::default();
+        tokio::time::timeout(
+            std::time::Duration::from_secs(5),
+            probe.scope(async {
+                let tasks = TaskTracker::new();
+                let context = EstablishContext::default();
+                let parent = CancellationToken::new();
+                let (first, mut peer) = tokio::io::duplex(4096);
+                let mut shared = PacketTransport::new(
+                    Box::new(first),
+                    &request(128),
+                    &context,
+                    parent.clone(),
+                    |future| Ok(tasks.spawn(crate::resources::observation::task(future))),
+                )
+                .unwrap();
+                let targets: [SocketAddr; 2] = [
+                    "198.51.100.1:53".parse().unwrap(),
+                    "[2001:db8::1]:5353".parse().unwrap(),
+                ];
+                let (resume, resumed) = oneshot::channel();
+                let remote = tokio::spawn(async move {
+                    for target in targets {
+                        assert_client_packet_to(&mut peer, target, b"request").await;
+                    }
+                    resumed.await.unwrap();
+                    // Responses need not arrive in send order.
+                    for target in targets.into_iter().rev() {
+                        peer.write_all(&server_packet(target, b"reply"))
+                            .await
+                            .unwrap();
+                    }
+                    let mut remaining = Vec::new();
+                    peer.read_to_end(&mut remaining).await.unwrap();
+                    assert!(remaining.is_empty());
+                });
+                assert!(shared.supports_shared_destinations());
+                for target in targets {
+                    shared
+                        .send(Datagram {
+                            remote: Destination::Ip(target),
+                            payload: Bytes::from_static(b"request"),
+                            sniffed_domain: None,
+                        })
+                        .await
+                        .unwrap();
+                }
+                // Dropping a pending read cannot lose either addressed response.
+                let mut waiting = Box::pin(shared.receive());
+                assert!(futures_util::poll!(&mut waiting).is_pending());
+                drop(waiting);
+                resume.send(()).unwrap();
+                for target in targets.into_iter().rev() {
+                    let response = shared.receive().await.unwrap();
+                    assert_eq!(response.remote, Destination::Ip(target));
+                    assert_eq!(response.payload, Bytes::from_static(b"reply"));
+                }
+                shared.close().await.unwrap();
+                assert!(
+                    shared
+                        .send(Datagram {
+                            remote: Destination::Ip(targets[0]),
+                            payload: Bytes::from_static(b"closed"),
+                            sniffed_domain: None,
+                        })
+                        .await
+                        .is_err()
+                );
+                drop(shared);
+                remote.await.unwrap();
+                assert!(!parent.is_cancelled());
+
+                // Closing one association must not revoke the node's parent or a
+                // new association, even when it uses exactly the same target.
+                let (second, mut peer) = tokio::io::duplex(4096);
+                let mut sibling = PacketTransport::new(
+                    Box::new(second),
+                    &request(128),
+                    &context,
+                    parent.clone(),
+                    |future| Ok(tasks.spawn(crate::resources::observation::task(future))),
+                )
+                .unwrap();
+                sibling
+                    .send(Datagram {
+                        remote: Destination::Ip(targets[0]),
+                        payload: Bytes::from_static(b"sibling"),
+                        sniffed_domain: None,
+                    })
+                    .await
+                    .unwrap();
+                assert_client_packet_to(&mut peer, targets[0], b"sibling").await;
+                peer.write_all(&server_packet(targets[0], b"live"))
+                    .await
+                    .unwrap();
+                let response = sibling.receive().await.unwrap();
+                assert_eq!(response.remote, Destination::Ip(targets[0]));
+                assert_eq!(response.payload, Bytes::from_static(b"live"));
+                sibling.close().await.unwrap();
+                drop((sibling, peer));
+                tasks.close();
+                tasks.wait().await;
+            }),
+        )
+        .await
+        .expect("TrustTunnel multi-target memory operation must finish");
+        assert!(probe.snapshot().is_idle());
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn trusttunnel_udp_cancelled_receive_keeps_frames_and_refreshes_dns_deadline() {
+        let probe = ResourceProbe::default();
+        tokio::time::timeout(
+            std::time::Duration::from_secs(5),
+            probe.scope(async {
+                let tasks = TaskTracker::new();
+                let resolver = Arc::new(FixedResolver(AtomicUsize::new(0)));
+                let context = EstablishContext::with_resolution(
+                    std::time::Duration::from_secs(1),
+                    ResolutionContext::measurement(resolver.clone(), true),
+                );
+                let cancellation = CancellationToken::new();
+                let (io, mut peer) = tokio::io::duplex(4_096);
+                let mut transport = PacketTransport::new(
+                    Box::new(io),
+                    &request(3),
+                    &context,
+                    cancellation.clone(),
+                    |future| Ok(tasks.spawn(crate::resources::observation::task(future))),
+                )
+                .unwrap();
+                let (partial_sent, partial_ready) = oneshot::channel();
+                let (resume, resumed) = oneshot::channel();
+                let remote = tokio::spawn(async move {
+                    assert_client_packet(&mut peer, b"one").await;
+                    let mut wire = server_packet("198.51.100.8:53".parse().unwrap(), b"discard");
+                    wire.extend(server_packet("[::1]:54".parse().unwrap(), b""));
+                    wire.extend(server_packet("198.51.100.9:55".parse().unwrap(), b"one"));
+                    peer.write_all(&wire[..13]).await.unwrap();
+                    partial_sent.send(()).unwrap();
+                    resumed.await.unwrap();
+                    peer.write_all(&wire[13..]).await.unwrap();
+                    assert_client_packet(&mut peer, b"two").await;
+                });
+                assert!(transport.send(datagram(b"four")).await.is_err());
+                assert_eq!(resolver.0.load(Ordering::Relaxed), 0);
+                transport.send(datagram(b"one")).await.unwrap();
+                partial_ready.await.unwrap();
+                let mut receive = Box::pin(transport.receive());
+                assert!(futures_util::poll!(&mut receive).is_pending());
+                drop(receive);
+                resume.send(()).unwrap();
+                let empty = transport.receive().await.unwrap();
+                assert_eq!(empty.remote, Destination::Ip("[::1]:54".parse().unwrap()));
+                assert!(empty.payload.is_empty());
+                let response = transport.receive().await.unwrap();
+                assert_eq!(
+                    response.remote,
+                    Destination::Ip("198.51.100.9:55".parse().unwrap())
+                );
+                assert_eq!(response.payload.as_ref(), b"one");
+                tokio::time::advance(std::time::Duration::from_secs(2)).await;
+                transport.send(datagram(b"two")).await.unwrap();
+                assert_eq!(resolver.0.load(Ordering::Relaxed), 2);
+                remote.await.unwrap();
+                transport.close().await.unwrap();
+                transport.close().await.unwrap();
+                assert!(!cancellation.is_cancelled());
+                drop(transport);
+                tasks.close();
+                tasks.wait().await;
+            }),
+        )
+        .await
+        .expect("TrustTunnel UDP memory operation must finish");
+        assert!(probe.snapshot().is_idle());
+    }
+
+    #[tokio::test]
+    async fn trusttunnel_udp_invalid_length_and_partial_send_release_owned_io() {
+        let probe = ResourceProbe::default();
+        tokio::time::timeout(
+            std::time::Duration::from_secs(5),
+            probe.scope(async {
+                let tasks = TaskTracker::new();
+                let context = EstablishContext::default();
+                let parent = CancellationToken::new();
+                let (io, mut peer) = tokio::io::duplex(64);
+                let mut malformed = PacketTransport::new(
+                    Box::new(io),
+                    &request(3),
+                    &context,
+                    parent.clone(),
+                    |future| Ok(tasks.spawn(crate::resources::observation::task(future))),
+                )
+                .unwrap();
+                // A huge length is rejected immediately, without waiting for or
+                // allocating the claimed body.
+                peer.write_all(&u32::MAX.to_be_bytes()).await.unwrap();
+                assert!(malformed.receive().await.is_err());
+                malformed.close().await.unwrap();
+                drop(malformed);
+
+                let (io, mut peer) = tokio::io::duplex(1);
+                let mut cancelled = PacketTransport::new(
+                    Box::new(io),
+                    &request(3),
+                    &context,
+                    parent.clone(),
+                    |future| Ok(tasks.spawn(crate::resources::observation::task(future))),
+                )
+                .unwrap();
+                let mut packet = datagram(b"one");
+                packet.remote = Destination::Ip("192.0.2.10:53".parse().unwrap());
+                let mut send = Box::pin(cancelled.send(packet.clone()));
+                assert!(futures_util::poll!(&mut send).is_pending());
+                drop(send);
+                let mut partial = Vec::new();
+                peer.read_to_end(&mut partial).await.unwrap();
+                assert_eq!(partial.len(), 1);
+                assert!(cancelled.send(packet).await.is_err());
+                cancelled.close().await.unwrap();
+                drop(cancelled);
+                assert!(!parent.is_cancelled());
+                tasks.close();
+                tasks.wait().await;
+            }),
+        )
+        .await
+        .expect("TrustTunnel UDP memory operation must finish");
+        assert!(probe.snapshot().is_idle());
+    }
+}
diff --git a/src/outbound/tuic/activity.rs b/src/outbound/tuic/activity.rs
index 2ca76ed..a17282d 100644
--- a/src/outbound/tuic/activity.rs
+++ b/src/outbound/tuic/activity.rs
@@ -18,6 +18,14 @@ impl Activity {
         self.state.lock().unwrap().active += 1;
         Lease(self.clone())
     }
+    pub fn try_acquire(self: &Arc<Self>, limit: usize) -> Option<Lease> {
+        let mut state = self.state.lock().unwrap();
+        if state.retired || state.active >= limit {
+            return None;
+        }
+        state.active += 1;
+        Some(Lease(self.clone()))
+    }
     pub fn retire(&self) {
         self.state.lock().unwrap().retired = true;
         self.changed.notify_one();
@@ -41,3 +49,29 @@ impl Drop for Lease {
         self.0.changed.notify_one();
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[tokio::test]
+    async fn logical_limit_retirement_waits_for_existing_owners() {
+        let activity = Arc::new(Activity::default());
+        assert!(activity.try_acquire(0).is_none());
+        let first = activity.try_acquire(2).unwrap();
+        let second = activity.try_acquire(2).unwrap();
+        assert!(activity.try_acquire(2).is_none());
+        activity.retire();
+        assert!(activity.try_acquire(2).is_none());
+        drop(first);
+        assert!(
+            tokio::time::timeout(
+                std::time::Duration::from_millis(1),
+                activity.retired_and_idle()
+            )
+            .await
+            .is_err()
+        );
+        drop(second);
+        activity.retired_and_idle().await;
+    }
+}
diff --git a/src/outbound/tuic/datagram.rs b/src/outbound/tuic/datagram.rs
index 8f5afc5..007b99d 100644
--- a/src/outbound/tuic/datagram.rs
+++ b/src/outbound/tuic/datagram.rs
@@ -24,10 +24,13 @@ use tokio::{
 use tokio_util::sync::CancellationToken;
 
 const TTL: Duration = Duration::from_secs(crate::limits::TUIC_FRAGMENT_TTL_SECONDS as u64);
+const NATIVE_RECEIVE_EVENTS: usize = 512;
 
 pub(super) struct Registry {
     state: Mutex<State>,
     mode: TuicUdpMode,
+    native_payload_limit: u16,
+    native_send_message_limit: usize,
 }
 #[derive(Default)]
 struct State {
@@ -43,10 +46,58 @@ struct Registration {
     _observation: observation::Guard,
 }
 impl Registry {
+    #[cfg(test)]
     pub fn new(mode: TuicUdpMode) -> Self {
+        Self::with_limit(
+            mode,
+            1252,
+            crate::transport::quic::datagram_payload_limit(1281),
+        )
+    }
+    pub fn with_limit(
+        mode: TuicUdpMode,
+        native_payload_limit: u16,
+        native_send_message_limit: usize,
+    ) -> Self {
         Self {
             state: Mutex::new(State::default()),
             mode,
+            native_payload_limit,
+            native_send_message_limit,
+        }
+    }
+    fn payload_budget(&self, address_len: usize, message_limit: usize) -> DatagramBudget {
+        let space = message_limit.saturating_sub(10 + address_len);
+        DatagramBudget::new(
+            space
+                .min(if self.mode == TuicUdpMode::Quic {
+                    usize::MAX
+                } else {
+                    self.native_payload_limit as usize
+                })
+                .saturating_mul(255)
+                .min(u16::MAX as usize) as u16,
+            u16::MAX,
+        )
+    }
+    fn payload_limit(
+        &self,
+        address_len: usize,
+        payload_size: usize,
+        message_limit: usize,
+    ) -> usize {
+        if self.mode == TuicUdpMode::Quic {
+            return usize::MAX;
+        }
+        let configured = self.native_payload_limit as usize;
+        if payload_size <= configured
+            && payload_size.saturating_add(10 + address_len) <= message_limit
+        {
+            configured
+        } else {
+            // A path-limited native retry reserves the IPv6 worst-case header,
+            // independently of the actual first packet destination family.
+            configured.min(message_limit.saturating_sub(29))
         }
     }
     pub fn open(
@@ -181,7 +232,11 @@ impl Transport {
     }
     fn message_limit(&self) -> usize {
         match self.registry.mode {
-            TuicUdpMode::Native => self.connection.max_datagram_size().unwrap_or(0),
+            TuicUdpMode::Native => self
+                .connection
+                .max_datagram_size()
+                .unwrap_or(0)
+                .min(self.registry.native_send_message_limit),
             TuicUdpMode::Quic => u16::MAX as usize + 10 + 259,
         }
     }
@@ -194,32 +249,45 @@ impl Drop for Transport {
 
 #[async_trait]
 impl DatagramTransport for Transport {
+    fn supports_shared_destinations(&self) -> bool {
+        // Both modes carry a per-packet address and consume an ID before
+        // awaiting capacity. Cancelling a partial QUIC send resets that stream;
+        // the router owns target and cancellation identity.
+        true
+    }
+
     fn payload_budget(&self, peer: &Destination) -> DatagramBudget {
-        let mut address = Vec::new();
-        let space = if wire::address(peer, &mut address).is_ok() {
-            self.message_limit().saturating_sub(10 + address.len())
-        } else {
-            0
+        let budget = match wire::address_len(peer) {
+            Ok(address_len) => self
+                .registry
+                .payload_budget(address_len, self.message_limit()),
+            Err(_) => DatagramBudget::new(0, u16::MAX),
         };
-        DatagramBudget::new(
-            space.saturating_mul(255).min(u16::MAX as usize) as u16,
-            u16::MAX,
-        )
-        .intersect(self.budget)
+        budget.intersect(self.budget)
     }
     async fn send(&mut self, datagram: Datagram) -> Result<(), DispatchError> {
         if self.closed || self.cancel.is_cancelled() {
             return Err(DispatchError::NotAllowed);
         }
-        if datagram.payload.len() > self.payload_budget(&datagram.remote).transmit() as usize {
+        let address_len = wire::address_len(&datagram.remote)?;
+        // Snapshot this logical send once; Quinn still validates the current
+        // path when each fragment is sent. Never cache the limit across sends.
+        let message_limit = self.message_limit();
+        let budget = self
+            .registry
+            .payload_budget(address_len, message_limit)
+            .intersect(self.budget);
+        if datagram.payload.len() > budget.transmit() as usize {
             return Err(io::Error::from(io::ErrorKind::InvalidInput).into());
         }
-        let packets = wire::packets(
+        let packets = wire::packets_with_payload_limit(
             self.id,
             self.packet,
             &datagram.remote,
             &datagram.payload,
-            self.message_limit(),
+            message_limit,
+            self.registry
+                .payload_limit(address_len, datagram.payload.len(), message_limit),
         )?;
         // Consume the ID before the first await: cancelling a partial send
         // never reuses that unfinished packet or replays its business bytes.
@@ -285,22 +353,34 @@ struct Pending {
 struct Reassembly {
     packets: HashMap<u16, Pending>,
     bytes: usize,
+    next_expiry: Option<Instant>,
 }
 impl Reassembly {
     fn remove(&mut self, id: u16) -> Option<Pending> {
         let p = self.packets.remove(&id)?;
         self.bytes -= p.bytes;
+        if self.packets.is_empty() {
+            self.next_expiry = None;
+        }
         Some(p)
     }
     fn expire(&mut self, now: Instant) {
+        // A removed earliest partial may leave a conservative earlier deadline.
+        // It can cause an extra scan, but must never postpone actual expiry.
+        if self.next_expiry.is_none_or(|deadline| now < deadline) {
+            return;
+        }
+        let mut next_expiry: Option<Instant> = None;
         self.packets.retain(|_, p| {
             if p.expires <= now {
                 self.bytes -= p.bytes;
                 false
             } else {
+                next_expiry = Some(next_expiry.map_or(p.expires, |next| next.min(p.expires)));
                 true
             }
         });
+        self.next_expiry = next_expiry;
     }
     fn push(&mut self, f: Fragment, now: Instant, budget: usize) -> Option<Datagram> {
         self.expire(now);
@@ -317,8 +397,20 @@ impl Reassembly {
         }
         if !self.packets.contains_key(&f.packet) {
             if self.packets.len() >= crate::limits::TUIC_PENDING_PACKETS {
-                return None;
+                // An abandoned partial must not block fresh packets until TTL.
+                // Expiry is fixed at admission, so its order also identifies
+                // the oldest retained partial without another queue or clock.
+                let oldest = self
+                    .packets
+                    .iter()
+                    .min_by_key(|(packet, pending)| (pending.expires, **packet))
+                    .map(|(&packet, _)| packet);
+                if let Some(packet) = oldest {
+                    self.remove(packet);
+                }
             }
+            let expires = now + TTL;
+            self.next_expiry = Some(self.next_expiry.map_or(expires, |next| next.min(expires)));
             self.packets.insert(
                 f.packet,
                 Pending {
@@ -326,7 +418,7 @@ impl Reassembly {
                     pieces: vec![None; f.count as usize],
                     bytes: 0,
                     received: 0,
-                    expires: now + TTL,
+                    expires,
                     _observation: observation::track(ResourceKind::Reassembly),
                 },
             );
@@ -380,15 +472,30 @@ pub(super) async fn receive(
     let mut streams = FuturesUnordered::new();
     let mut expiry = tokio::time::interval(Duration::from_secs(1));
     expiry.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
+    let poll_budget = if registry.mode == TuicUdpMode::Native {
+        NATIVE_RECEIVE_EVENTS
+    } else {
+        crate::limits::IO_POLL_BUDGET
+    };
     let mut count = 0;
     loop {
         tokio::select! {
             _=expiry.tick()=>registry.expire(),
             result=connection.read_datagram()=>{
                 let raw=result.map_err(|_|DispatchError::ConnectionRefused)?;
-                if registry.mode==TuicUdpMode::Native && let Ok(fragment)=wire::decode(raw) { registry.deliver(fragment); }
+                // A peer's fragmentation is independent of our send frame
+                // limit. The physical adapter already enforces its RX budget.
+                // Reject unknown associations and excess declared payload
+                // before allocating an address or reassembly state.
+                if registry.mode==TuicUdpMode::Native
+                    && raw.len()<=crate::limits::TUIC_QUIC_PAYLOAD
+                    && let Some(header)=raw.get(..10)
+                    && let Some(budget)=registry.budget(u16::from_be_bytes([header[2],header[3]]))
+                    && u16::from_be_bytes([header[8],header[9]])<=budget
+                    && let Ok(fragment)=wire::decode(raw)
+                { registry.deliver(fragment); }
             },
-            stream=connection.accept_uni(),if streams.len()<crate::limits::TUIC_UNI_STREAMS=>{
+            stream=connection.accept_uni(),if streams.len()<crate::limits::TUIC_CONTROL_READERS=>{
                 let stream=stream.map_err(|_|DispatchError::ConnectionRefused)?;
                 if registry.mode==TuicUdpMode::Quic {
                     streams.push(tokio::time::timeout(TTL,wire::read_packet(stream,|id|registry.budget(id))));
@@ -399,7 +506,7 @@ pub(super) async fn receive(
             },
         }
         count += 1;
-        if count % crate::limits::IO_POLL_BUDGET == 0 {
+        if count % poll_budget == 0 {
             tokio::task::yield_now().await;
         }
     }
@@ -408,6 +515,109 @@ pub(super) async fn receive(
 #[cfg(test)]
 mod tests {
     use super::*;
+
+    #[test]
+    fn message_snapshot_preserves_native_path_retry_and_configured_fragment_limits() {
+        let registry = Registry::with_limit(TuicUdpMode::Native, 1252, 1200);
+        for (peer, length, expected) in [
+            (
+                Destination::Ip("192.0.2.1:53".parse().unwrap()),
+                1183,
+                vec![1183],
+            ),
+            (
+                Destination::Ip("192.0.2.1:53".parse().unwrap()),
+                1184,
+                vec![1171, 13],
+            ),
+            (
+                Destination::Ip("[::1]:53".parse().unwrap()),
+                1171,
+                vec![1171],
+            ),
+            (
+                Destination::Ip("[::1]:53".parse().unwrap()),
+                1172,
+                vec![1171, 1],
+            ),
+        ] {
+            let address_len = wire::address_len(&peer).unwrap();
+            let payload = vec![0x5a; length];
+            let packets = wire::packets_with_payload_limit(
+                7,
+                u16::MAX,
+                &peer,
+                &payload,
+                1200,
+                registry.payload_limit(address_len, length, 1200),
+            )
+            .unwrap();
+            let decoded: Vec<_> = packets
+                .into_iter()
+                .map(|p| wire::decode(p).unwrap())
+                .collect();
+            assert_eq!(
+                decoded.iter().map(|p| p.payload.len()).collect::<Vec<_>>(),
+                expected
+            );
+            assert_eq!(decoded[0].peer.as_ref(), Some(&peer));
+            assert!(decoded.iter().skip(1).all(|p| p.peer.is_none()));
+            assert!(
+                decoded
+                    .iter()
+                    .all(|p| p.association == 7 && p.packet == u16::MAX)
+            );
+            assert_eq!(
+                decoded
+                    .iter()
+                    .flat_map(|p| p.payload.iter().copied())
+                    .collect::<Vec<_>>(),
+                payload
+            );
+        }
+        let configured = Registry::with_limit(TuicUdpMode::Native, 1000, 1200);
+        assert_eq!(configured.payload_limit(7, 1001, 1200), 1000);
+        let conservative = Registry::with_limit(TuicUdpMode::Native, 1252, 30);
+        assert_eq!(conservative.payload_limit(7, 13, 30), 1252);
+        assert_eq!(conservative.payload_limit(7, 14, 30), 1);
+    }
+
+    #[test]
+    fn message_snapshot_preserves_directional_budgets_empty_frames_and_quic_limit() {
+        let native = Registry::with_limit(TuicUdpMode::Native, 1, 1200);
+        assert_eq!(
+            native.payload_budget(7, 1200),
+            DatagramBudget::new(255, u16::MAX)
+        );
+        assert_eq!(
+            native.payload_budget(7, 17),
+            DatagramBudget::new(0, u16::MAX)
+        );
+        let caller = DatagramBudget::new(200, 1200);
+        assert_eq!(
+            native.payload_budget(7, 1200).intersect(caller),
+            DatagramBudget::new(200, 1200)
+        );
+        let peer = Destination::Ip("192.0.2.1:53".parse().unwrap());
+        let empty =
+            wire::packets_with_payload_limit(1, 2, &peer, &[], 17, native.payload_limit(7, 0, 17))
+                .unwrap();
+        assert_eq!(empty.len(), 1);
+        assert_eq!(
+            empty[0].as_ref(),
+            b"\x05\x02\x00\x01\x00\x02\x01\x00\x00\x00\x01\xc0\x00\x02\x01\x00\x35"
+        );
+        assert!(
+            wire::packets_with_payload_limit(1, 2, &peer, &[], 16, native.payload_limit(7, 0, 16),)
+                .is_err()
+        );
+        let quic = Registry::with_limit(TuicUdpMode::Quic, 1, 1200);
+        assert_eq!(
+            quic.payload_budget(259, u16::MAX as usize + 10 + 259),
+            DatagramBudget::new(u16::MAX, u16::MAX)
+        );
+        assert_eq!(quic.payload_limit(259, u16::MAX as usize, 1200), usize::MAX);
+    }
     fn fragment(id: u16, index: u8, payload: Bytes) -> Fragment {
         Fragment {
             association: 0,
@@ -422,9 +632,46 @@ mod tests {
             payload,
         }
     }
+    #[test]
+    fn shared_native_partial_fragments_keep_destination_and_packet_id_boundaries() {
+        let first = Destination::Ip("198.51.100.1:443".parse().unwrap());
+        let second = Destination::Ip("[2001:db8::2]:8443".parse().unwrap());
+        let old =
+            wire::packets_with_payload_limit(7, u16::MAX, &first, b"old-tail", 64, 4).unwrap();
+        let fresh = wire::packets_with_payload_limit(7, 0, &second, b"new-body", 64, 4).unwrap();
+        let now = Instant::now();
+        let mut reassembly = Reassembly::default();
+        // Model a send cancelled after its first complete native fragment.
+        // The next ID may wrap, but must retain its independent destination.
+        assert!(
+            reassembly
+                .push(wire::decode(old[0].clone()).unwrap(), now, 8)
+                .is_none()
+        );
+        assert!(
+            reassembly
+                .push(wire::decode(fresh[1].clone()).unwrap(), now, 8)
+                .is_none()
+        );
+        let packet = reassembly
+            .push(wire::decode(fresh[0].clone()).unwrap(), now, 8)
+            .unwrap();
+        assert_eq!(packet.remote, second);
+        assert_eq!(packet.payload, b"new-body"[..]);
+        assert_eq!(reassembly.packets.len(), 1);
+        reassembly.expire(now + TTL);
+        assert!(reassembly.packets.is_empty());
+        assert_eq!(reassembly.bytes, 0);
+        // A late tail cannot borrow the later packet's address or payload.
+        assert!(
+            reassembly
+                .push(wire::decode(old[1].clone()).unwrap(), now + TTL, 8)
+                .is_none()
+        );
+    }
+
     #[test]
     fn reassembly_releases_completed_ids_and_orders_duplicates_without_cross_packet_mix() {
-        let _case = crate::resources::case_events::Case::new("TUIC-UNIT", "reassembly_order");
         let mut r = Reassembly::default();
         let now = Instant::now();
         for id in [65535, 0, 65535] {
@@ -450,8 +697,43 @@ mod tests {
         assert!(r.packets.is_empty());
     }
     #[test]
+    fn fresh_packet_progresses_when_old_partial_slots_are_full() {
+        let now = Instant::now();
+        let mut r = Reassembly::default();
+        for id in 0..crate::limits::TUIC_PENDING_PACKETS {
+            assert!(
+                r.push(
+                    fragment(id as u16, 0, Bytes::from_static(b"x")),
+                    now + Duration::from_nanos(id as u64),
+                    1200,
+                )
+                .is_none()
+            );
+        }
+        assert_eq!(r.packets.len(), crate::limits::TUIC_PENDING_PACKETS);
+        assert_eq!(r.bytes, crate::limits::TUIC_PENDING_PACKETS);
+        let id = crate::limits::TUIC_PENDING_PACKETS as u16;
+        let target = Destination::Ip("198.51.100.2:443".parse().unwrap());
+        let mut head = fragment(id, 0, Bytes::from_static(b"fresh-"));
+        head.peer = Some(target.clone());
+        assert!(r.push(head, now + Duration::from_millis(1), 1200).is_none());
+        let packet = r
+            .push(
+                fragment(id, 1, Bytes::from_static(b"payload")),
+                now + Duration::from_millis(2),
+                1200,
+            )
+            .expect("a fresh complete packet must progress before old partials expire");
+        assert_eq!(packet.remote, target);
+        assert_eq!(packet.payload, b"fresh-payload"[..]);
+        assert!(!r.packets.contains_key(&0));
+        assert!(r.packets.contains_key(&1));
+        assert!(!r.packets.contains_key(&id));
+        assert_eq!(r.packets.len(), crate::limits::TUIC_PENDING_PACKETS - 1);
+        assert_eq!(r.bytes, crate::limits::TUIC_PENDING_PACKETS - 1);
+    }
+    #[test]
     fn partial_packets_expire_and_both_resource_bounds_are_per_association() {
-        let _case = crate::resources::case_events::Case::new("TUIC-UNIT", "reassembly_limits");
         let now = Instant::now();
         let mut r = Reassembly::default();
         for id in 0..65 {
@@ -484,10 +766,56 @@ mod tests {
         assert!(!other.packets.contains_key(&3));
         r.expire(now + TTL);
         assert_eq!(r.bytes, 0);
+        // Completing the earliest partial must not delay another partial's
+        // original deadline or let an expired ID borrow a later generation.
+        let mut staggered = Reassembly::default();
+        let later = now + Duration::from_secs(1);
+        assert!(
+            staggered
+                .push(fragment(10, 0, Bytes::from_static(b"old")), now, 8)
+                .is_none()
+        );
+        assert!(
+            staggered
+                .push(fragment(11, 0, Bytes::from_static(b"next")), later, 8)
+                .is_none()
+        );
+        let completed = staggered
+            .push(
+                fragment(10, 1, Bytes::from_static(b"-x")),
+                now + Duration::from_secs(2),
+                8,
+            )
+            .unwrap();
+        assert_eq!(completed.payload, b"old-x"[..]);
+        staggered.expire(now + TTL);
+        assert!(staggered.packets.contains_key(&11));
+        assert_eq!(staggered.bytes, 4);
+        staggered.expire(later + TTL - Duration::from_nanos(1));
+        assert!(staggered.packets.contains_key(&11));
+        staggered.expire(later + TTL);
+        assert!(staggered.packets.is_empty());
+        assert_eq!(staggered.bytes, 0);
+        let fresh = later + TTL;
+        assert!(
+            staggered
+                .push(fragment(11, 1, Bytes::from_static(b"tail")), fresh, 8)
+                .is_none()
+        );
+        let reused = staggered
+            .push(
+                fragment(11, 0, Bytes::from_static(b"new-")),
+                fresh + Duration::from_nanos(1),
+                8,
+            )
+            .unwrap();
+        assert_eq!(reused.payload, b"new-tail"[..]);
+        assert_eq!(reused.remote, Destination::domain("x", 80).unwrap());
+        assert!(staggered.packets.is_empty());
+        assert_eq!(staggered.bytes, 0);
     }
     #[test]
     fn unknown_associations_do_not_allocate_and_full_queues_drop_complete_packets() {
-        let _case = crate::resources::case_events::Case::new("TUIC-UNIT", "delivery_limits");
         let probe = observation::ResourceProbe::default();
         probe.scope_sync(|| {
             let registry = Registry::new(TuicUdpMode::Native);
diff --git a/src/outbound/tuic/outbound.rs b/src/outbound/tuic/outbound.rs
index 36c0a36..439f260 100644
--- a/src/outbound/tuic/outbound.rs
+++ b/src/outbound/tuic/outbound.rs
@@ -18,6 +18,8 @@ use crate::{
 };
 use async_trait::async_trait;
 use std::{
+    collections::hash_map::DefaultHasher,
+    hash::{Hash, Hasher},
     io,
     sync::{Arc, Mutex},
     time::Duration,
@@ -32,8 +34,10 @@ pub struct TuicOutbound {
     config: Arc<TuicOutboundConfig>,
     server: Destination,
     upstream: UpstreamPath,
-    tls: Arc<rustls::ClientConfig>,
-    current: AsyncMutex<Option<Arc<Session>>>,
+    tls: StandardTlsClient,
+    // Lazy native source stripes, or isolated quic TCP/UDP business lanes.
+    // UoT keeps the original shared lane.
+    current: AsyncMutex<[Option<Arc<Session>>; 2]>,
     cancel: CancellationToken,
     admission: Mutex<()>,
     tasks: TaskTracker,
@@ -47,6 +51,38 @@ struct Session {
     activity: Arc<Activity>,
 }
 
+fn active_congestion(connection: &quinn::Connection) -> Option<TuicCongestion> {
+    let controller = connection.congestion_state().into_any();
+    if controller.is::<quinn::congestion::Cubic>() {
+        Some(TuicCongestion::Cubic)
+    } else if controller.is::<quinn::congestion::NewReno>() {
+        Some(TuicCongestion::NewReno)
+    } else if controller.is::<quinn::congestion::Bbr>() {
+        Some(TuicCongestion::Bbr)
+    } else {
+        None
+    }
+}
+
+fn log_active_congestion(connection: &quinn::Connection) {
+    // Fixed targets survive the CLI's restricted field renderer without
+    // exposing peer, credential or traffic metadata.
+    match active_congestion(connection) {
+        Some(TuicCongestion::Cubic) => {
+            tracing::debug!(target: "vole::outbound::tuic::congestion::cubic", "TUIC controller ready");
+        }
+        Some(TuicCongestion::NewReno) => {
+            tracing::debug!(target: "vole::outbound::tuic::congestion::new_reno", "TUIC controller ready");
+        }
+        Some(TuicCongestion::Bbr) => {
+            tracing::debug!(target: "vole::outbound::tuic::congestion::bbr", "TUIC controller ready");
+        }
+        None => {
+            tracing::debug!(target: "vole::outbound::tuic::congestion::unknown", "TUIC controller ready");
+        }
+    }
+}
+
 impl std::fmt::Debug for TuicOutbound {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("TuicOutbound").finish_non_exhaustive()
@@ -54,30 +90,45 @@ impl std::fmt::Debug for TuicOutbound {
 }
 
 impl TuicOutbound {
-    /// Remaining actual Quinn datagram buffer, for bounded-backpressure checks.
+    fn native_source_stripes(&self) -> bool {
+        self.config.udp_mode == crate::config::TuicUdpMode::Native && !self.config.udp_over_stream
+    }
+
+    fn datagram_lane(&self) -> usize {
+        usize::from(
+            self.config.udp_mode == crate::config::TuicUdpMode::Quic
+                && !self.config.udp_over_stream,
+        )
+    }
+
+    /// One actual Quinn datagram buffer, never a native stripe aggregate.
     #[cfg(feature = "interop-test")]
     pub async fn datagram_buffer_space(&self) -> Option<usize> {
-        self.current
-            .lock()
-            .await
-            .as_ref()
-            .map(|s| s.connection.datagram_send_buffer_space())
+        let current = self.current.lock().await;
+        let session = if self.native_source_stripes() {
+            current[0].as_ref().or(current[1].as_ref())
+        } else {
+            // In quic mode a TCP lane is never a UDP-buffer witness.
+            current[self.datagram_lane()].as_ref()
+        };
+        session.map(|s| s.connection.datagram_send_buffer_space())
     }
 
     /// Actual Quinn controller identity for acceptance; no peer or credential data.
     #[cfg(feature = "interop-test")]
     pub async fn congestion_observation(&self) -> Option<TuicCongestion> {
         let current = self.current.lock().await;
-        let controller = current.as_ref()?.connection.congestion_state().into_any();
-        if controller.is::<quinn::congestion::Cubic>() {
-            Some(TuicCongestion::Cubic)
-        } else if controller.is::<quinn::congestion::NewReno>() {
-            Some(TuicCongestion::NewReno)
-        } else if controller.is::<quinn::congestion::Bbr>() {
-            Some(TuicCongestion::Bbr)
-        } else {
-            None
-        }
+        // Report one actual lane/stripe, not an owner or aggregate observation.
+        let session = current[1].as_ref().or(current[0].as_ref())?;
+        active_congestion(&session.connection)
+    }
+
+    /// One actual path; never an aggregate or a specified owner's stripe.
+    #[cfg(feature = "interop-test")]
+    pub async fn path_observation(&self) -> Option<quinn::PathStats> {
+        let current = self.current.lock().await;
+        let session = current[1].as_ref().or(current[0].as_ref())?;
+        Some(session.connection.stats().path)
     }
 
     pub fn new_with_path(config: &TuicOutboundConfig, upstream: UpstreamPath) -> io::Result<Self> {
@@ -98,19 +149,31 @@ impl TuicOutbound {
                 versions: TlsVersions::Tls13,
                 alpn: config.tls.alpn.clone(),
                 certificate: config.tls.certificate.clone(),
+                identity: config
+                    .tls
+                    .identity
+                    .as_ref()
+                    .map(|identity| {
+                        crate::security::TlsClientIdentity::from_config(identity, security)
+                    })
+                    .transpose()?,
                 ..Default::default()
             },
             0,
             buffer_limit,
-        )?
-        .quic_config()?
-        .0;
+        )?;
+        // Validate the QUIC policy now, but snapshot the current file identity
+        // only when a new physical connection is constructed.
+        tls.quic_config()?;
         Ok(Self {
             config: Arc::new(config.clone()),
-            server: server_destination(&config.address, config.port)?,
+            server: server_destination(
+                config.ip.as_deref().unwrap_or(&config.address),
+                config.port,
+            )?,
             upstream,
             tls,
-            current: AsyncMutex::new(None),
+            current: AsyncMutex::new([None, None]),
             cancel: CancellationToken::new(),
             admission: Mutex::new(()),
             tasks: TaskTracker::new(),
@@ -121,18 +184,35 @@ impl TuicOutbound {
         &self,
         datagram: DatagramSession,
         context: &EstablishContext,
+        datagram_business: bool,
     ) -> Result<(Arc<Session>, Lease), DispatchError> {
         if tokio::time::Instant::now() >= context.deadline() {
             return Err(DispatchError::TimedOut);
         }
+        // The reference admits only counters strictly below its threshold.
+        // A configured threshold of one is valid, but permits no logical owner.
+        if self.config.max_open_streams == 0 {
+            return Err(DispatchError::NotAllowed);
+        }
+        let lane = if self.native_source_stripes() {
+            // Keep TCP and UDP from the same source on the same physical
+            // stripe without constraining the configured per-session owners.
+            let mut source = DefaultHasher::new();
+            datagram.source.hash(&mut source);
+            (source.finish() & 1) as usize
+        } else if datagram_business {
+            self.datagram_lane()
+        } else {
+            0
+        };
         let _waiter = observation::track(ResourceKind::Waiter);
         tokio::select! { biased;
             () = self.cancel.cancelled() => Err(DispatchError::NotAllowed),
             result = context.run("TUIC session", async {
-                let mut current = self.current.lock().await;
-                if let Some(session) = current.as_ref().filter(|s| !s.cancel.is_cancelled() && s.connection.close_reason().is_none() && !s.datagrams.exhausted()) {
-                    return Ok((session.clone(),session.activity.acquire()));
-                }
+                let mut lanes = self.current.lock().await;
+                let current = &mut lanes[lane];
+                if let Some(session) = current.as_ref().filter(|s| !s.cancel.is_cancelled() && s.connection.close_reason().is_none() && !s.datagrams.exhausted())
+                    && let Some(lease) = session.activity.try_acquire(self.config.max_open_streams) { return Ok((session.clone(),lease)); }
                 if let Some(previous)=current.take() { previous.activity.retire(); }
                 let cancel = self.cancel.child_token();
                 let guard = cancel.clone().drop_guard();
@@ -173,6 +253,7 @@ impl OutboundConnector for TuicOutbound {
             .session(
                 DatagramSession::new(session.inbound, session.source),
                 context,
+                false,
             )
             .await?;
         tokio::select! { biased;
@@ -192,8 +273,40 @@ impl OutboundConnector for TuicOutbound {
         request: DatagramRequest,
         context: &EstablishContext,
     ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        if self.config.udp_over_stream {
+            let connected = self
+                .connect_stream(
+                    StreamSession {
+                        metadata: request.session.metadata.clone(),
+                        inbound: request.session.inbound,
+                        source: request.session.source,
+                        destination: crate::outbound::uot::magic_destination(),
+                        sniffed_domain: None,
+                    },
+                    context,
+                )
+                .await?;
+            let _admission = self.admission.lock().unwrap();
+            if self.cancel.is_cancelled() {
+                return Err(DispatchError::NotAllowed);
+            }
+            let (reader, writer) = tokio::io::split(connected.io);
+            return Ok(crate::dispatch::bound_datagram(
+                Box::new(
+                    crate::outbound::uot::UotTransport::new(
+                        reader,
+                        writer,
+                        request.max_response_payload_size(),
+                        self.cancel.clone(),
+                        &self.tasks,
+                    )
+                    .with_initial_deadline(context.deadline()),
+                ),
+                request.budget(),
+            ));
+        }
         loop {
-            let (shared, lease) = self.session(request.session.clone(), context).await?;
+            let (shared, lease) = self.session(request.session.clone(), context, true).await?;
             if let Some(transport) = shared.datagrams.open(
                 shared.connection.clone(),
                 shared.cancel.clone(),
@@ -216,7 +329,9 @@ impl OutboundConnector for TuicOutbound {
     async fn shutdown(&self) {
         self.begin_shutdown();
         self.tasks.wait().await;
-        self.current.lock().await.take();
+        for current in self.current.lock().await.iter_mut() {
+            let _ = current.take();
+        }
     }
 }
 impl Drop for TuicOutbound {
@@ -230,7 +345,7 @@ async fn drive(
     config: Arc<TuicOutboundConfig>,
     upstream: UpstreamPath,
     server: Destination,
-    tls: Arc<rustls::ClientConfig>,
+    tls: StandardTlsClient,
     datagram: DatagramSession,
     context: EstablishContext,
     cancel: CancellationToken,
@@ -241,42 +356,69 @@ async fn drive(
     let mut endpoint = None;
     let mut driver = None;
     let _pool = observation::track(ResourceKind::Pool);
-    let datagrams = Arc::new(super::datagram::Registry::new(config.udp_mode));
+    let datagrams = Arc::new(super::datagram::Registry::with_limit(
+        config.udp_mode,
+        config.max_udp_relay_packet_size,
+        quic::datagram_payload_limit(config.max_datagram_frame_size),
+    ));
     let activity = Arc::new(Activity::default());
     let operation = async {
         let handshake = observation::track(ResourceKind::Handshake);
-        let destination = upstream.datagram_server(&server, &context)?;
+        let destination = upstream.datagram_server(&server, &context).await?;
         let peer = context.resolve_ip(&destination).await?;
         let budget = DatagramBudget::new(
             crate::limits::TUIC_QUIC_PAYLOAD as u16,
             crate::limits::TUIC_QUIC_PAYLOAD as u16,
         );
-        let raw = upstream
-            .open_datagram(DatagramRequest::new(datagram).with_budget(budget), &context)
-            .await?;
-        let (socket, owned) = quic::attach(raw, peer, budget)?;
+        let request = DatagramRequest::new(datagram).with_budget(budget);
+        let request =
+            if config.udp_mode == crate::config::TuicUdpMode::Native && !config.udp_over_stream {
+                request.with_udp_receive_buffer_size(512 * 1024)
+            } else {
+                request
+            };
+        let raw = upstream.open_datagram(request, &context).await?;
+        let (socket, owned) = quic::attach_quinn(raw, peer, budget).await?;
         driver = Some(owned);
         let mtu = socket.budget().quic_payload_limit()?;
         let mut limits = quinn::TransportConfig::default();
+        socket.configure_transport(&mut limits);
+        quic::configure_receive_windows(
+            &mut limits,
+            config.stream_window,
+            config.connection_window,
+            quic::RECEIVE_WINDOW_POLICY,
+        )?;
+        let discovery = if config.disable_mtu_discovery {
+            None
+        } else {
+            let mut discovery = quinn::MtuDiscoveryConfig::default();
+            discovery.upper_bound(mtu);
+            Some(discovery)
+        };
+        let initial_mtu = if discovery.is_some() { 1200 } else { mtu };
         limits
-            .initial_mtu(mtu)
-            .min_mtu(mtu)
-            .mtu_discovery_config(None)
+            .initial_mtu(initial_mtu)
+            .min_mtu(1200)
+            .mtu_discovery_config(discovery)
+            // Business owner thresholds never flow into Quinn's eager maps.
+            // The decoder already bounds concurrent remote uni streams to 32.
             .max_concurrent_bidi_streams(0_u8.into())
-            .max_concurrent_uni_streams((crate::limits::TUIC_UNI_STREAMS as u32).into())
-            .stream_receive_window((crate::limits::TUIC_STREAM_WINDOW as u32).into())
-            .receive_window((crate::limits::TUIC_CONNECTION_WINDOW as u32).into())
-            .send_window(crate::limits::TUIC_CONNECTION_WINDOW as u64)
+            .max_concurrent_uni_streams((crate::limits::TUIC_CONTROL_READERS as u32).into())
+            .send_window(crate::limits::TUIC_SEND_WINDOW as u64)
             .datagram_receive_buffer_size(Some(crate::limits::TUIC_DATAGRAM_BUFFER))
             .datagram_send_buffer_size(crate::limits::TUIC_DATAGRAM_BUFFER)
             .max_idle_timeout(Some(Duration::from_secs(30).try_into().map_err(failure)?))
-            .keep_alive_interval(Some(Duration::from_secs(10)))
+            .keep_alive_interval(Some(config.heartbeat_interval))
             .congestion_controller_factory(match config.congestion {
                 TuicCongestion::Cubic => Arc::new(quinn::congestion::CubicConfig::default()),
                 TuicCongestion::NewReno => Arc::new(quinn::congestion::NewRenoConfig::default()),
                 TuicCongestion::Bbr => Arc::new(quinn::congestion::BbrConfig::default()),
             });
-        let crypto = quinn::crypto::rustls::QuicClientConfig::try_from(tls).map_err(failure)?;
+        let crypto = quinn::crypto::rustls::QuicClientConfig::try_from(
+            current_tls(&tls, config.disable_sni).map_err(failure)?,
+        )
+        .map_err(failure)?;
         let mut client = quinn::ClientConfig::new(Arc::new(crypto));
         client.transport_config(Arc::new(limits));
         let mut options = quinn::EndpointConfig::default();
@@ -318,6 +460,7 @@ async fn drive(
             .map_err(failure)?;
         send.finish().map_err(failure)?;
         auth.fill(0);
+        log_active_congestion(&connection);
         drop(handshake);
         let session = Arc::new(Session {
             connection: connection.clone(),
@@ -331,7 +474,8 @@ async fn drive(
             .unwrap()
             .send(Ok(session))
             .map_err(|_| DispatchError::ConnectionRefused)?;
-        let mut beat = tokio::time::interval(Duration::from_secs(10));
+        let mut beat = tokio::time::interval(config.heartbeat_interval);
+        beat.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
         beat.tick().await;
         tokio::select! {
             _=connection.closed()=>{},
@@ -361,3 +505,128 @@ async fn drive(
         let _ = driver.stop().await;
     }
 }
+
+fn current_tls(
+    tls: &StandardTlsClient,
+    disable_sni: bool,
+) -> io::Result<Arc<rustls::ClientConfig>> {
+    let (mut config, _) = tls.quic_config()?;
+    // The verifier still receives Quinn's immutable server name.
+    if disable_sni {
+        Arc::make_mut(&mut config).enable_sni = false;
+    }
+    Ok(config)
+}
+
+#[cfg(test)]
+mod p08_tests {
+    use super::*;
+    #[tokio::test]
+    async fn tuic_cold_connection_cannot_publish_an_early_quinn_handle_without_resumption() {
+        struct Discard;
+        #[async_trait]
+        impl DatagramTransport for Discard {
+            fn supports_shared_destinations(&self) -> bool {
+                false
+            }
+
+            async fn send(&mut self, _: crate::session::Datagram) -> Result<(), DispatchError> {
+                Ok(())
+            }
+            async fn receive(&mut self) -> Result<crate::session::Datagram, DispatchError> {
+                std::future::pending().await
+            }
+        }
+        let parsed = crate::config::Config::parse_yaml(
+            br#"proxies: [{name: edge, type: tuic, server: peer.invalid, port: 443, uuid: 01234567-89ab-cdef-0123-456789abcdef}]"#,
+        ).unwrap();
+        let crate::config::ProxyProtocol::Tuic(config) = &parsed.proxies[0].protocol else {
+            panic!("TUIC");
+        };
+        let node = TuicOutbound::new_with_path(
+            config,
+            UpstreamPath::LazyDirect {
+                dialer: crate::dialer::Dialer::default(),
+            },
+        )
+        .unwrap();
+        // A request for early data alone cannot make a cold client connection
+        // available. No sockets, system resolver, peers, or ticket cache exist.
+        let mut tls = (*current_tls(&node.tls, config.disable_sni).unwrap()).clone();
+        tls.enable_early_data = true;
+        let crypto = quinn::crypto::rustls::QuicClientConfig::try_from(tls).unwrap();
+        let peer = "192.0.2.1:443".parse().unwrap();
+        let (socket, driver) =
+            quic::attach(Box::new(Discard), peer, DatagramBudget::new(1400, 1400)).unwrap();
+        let runtime = Arc::new(OwnedRuntime::new(CancellationToken::new()));
+        let mut endpoint = quinn::Endpoint::new_with_abstract_socket(
+            quinn::EndpointConfig::default(),
+            None,
+            socket,
+            runtime.clone(),
+        )
+        .unwrap();
+        endpoint.set_default_client_config(quinn::ClientConfig::new(Arc::new(crypto)));
+        let connecting = endpoint.connect(peer, "peer.invalid").unwrap();
+        assert!(
+            connecting.into_0rtt().is_err(),
+            "a cold client obtained an early handle"
+        );
+        endpoint.close(0_u8.into(), b"");
+        runtime.stop().await;
+        drop(endpoint);
+        driver.stop().await.unwrap();
+    }
+
+    fn sni_extension(hello: &[u8]) -> bool {
+        assert_eq!(hello[0], 1);
+        let mut at = 4 + 2 + 32;
+        at += 1 + usize::from(hello[at]);
+        let ciphers = usize::from(u16::from_be_bytes([hello[at], hello[at + 1]]));
+        at += 2 + ciphers;
+        at += 1 + usize::from(hello[at]);
+        let end = at + 2 + usize::from(u16::from_be_bytes([hello[at], hello[at + 1]]));
+        at += 2;
+        while at < end {
+            let kind = u16::from_be_bytes([hello[at], hello[at + 1]]);
+            let len = usize::from(u16::from_be_bytes([hello[at + 2], hello[at + 3]]));
+            if kind == 0 {
+                return true;
+            }
+            at += 4 + len;
+        }
+        false
+    }
+    #[test]
+    fn tuic_disable_sni_changes_real_quic_hello_without_changing_verification_policy() {
+        for disable in [false, true] {
+            let config=crate::config::Config::parse_yaml(serde_json::json!({"proxies":[{"name":"edge","type":"tuic","server":"peer.invalid","port":443,"uuid":"01234567-89ab-cdef-0123-456789abcdef","disable-sni":disable,"name-cert-verify":"identity.example","fingerprint":"12".repeat(32)}]}).to_string().as_bytes()).unwrap();
+            let crate::config::ProxyProtocol::Tuic(config) = &config.proxies[0].protocol else {
+                panic!("TUIC")
+            };
+            assert!(!config.tls.certificate.skip_cert_verify);
+            assert_eq!(
+                config.tls.certificate.verification_name.as_deref(),
+                Some("identity.example")
+            );
+            assert_eq!(config.tls.certificate.fingerprint, Some([0x12; 32]));
+            let node = TuicOutbound::new_with_path(
+                config,
+                UpstreamPath::LazyDirect {
+                    dialer: crate::dialer::Dialer::default(),
+                },
+            )
+            .unwrap();
+            let mut connection = rustls::quic::ClientConnection::new(
+                current_tls(&node.tls, config.disable_sni).unwrap(),
+                rustls::quic::Version::V1,
+                rustls::pki_types::ServerName::try_from(config.tls.server_name.clone()).unwrap(),
+                Vec::new(),
+            )
+            .unwrap();
+            let mut hello = Vec::new();
+            connection.write_hs(&mut hello);
+            assert_eq!(sni_extension(&hello), !disable);
+        }
+    }
+}
diff --git a/src/outbound/tuic/wire.rs b/src/outbound/tuic/wire.rs
index d059eaa..bf292b2 100644
--- a/src/outbound/tuic/wire.rs
+++ b/src/outbound/tuic/wire.rs
@@ -4,10 +4,25 @@ use bytes::{Buf, Bytes};
 use std::io;
 use tokio::io::{AsyncRead, AsyncReadExt};
 
-pub(super) fn address(peer: &Destination, out: &mut Vec<u8>) -> io::Result<()> {
-    if peer.port() == 0 {
+pub(super) fn address_len(peer: &Destination) -> io::Result<usize> {
+    if peer.port() == 0
+        && !matches!(peer, Destination::Domain { host, .. } if host == crate::outbound::uot::MAGIC_DESTINATION)
+    {
         return Err(io::ErrorKind::InvalidInput.into());
     }
+    match peer {
+        Destination::Ip(peer) => Ok(if peer.is_ipv4() { 7 } else { 19 }),
+        Destination::Domain { host, .. } => {
+            if host.is_empty() || host.len() > 255 || host.bytes().any(|v| v.is_ascii_control()) {
+                return Err(io::ErrorKind::InvalidInput.into());
+            }
+            Ok(4 + host.len())
+        }
+    }
+}
+
+pub(super) fn address(peer: &Destination, out: &mut Vec<u8>) -> io::Result<()> {
+    address_len(peer)?;
     match peer {
         Destination::Ip(peer) => match peer.ip() {
             std::net::IpAddr::V4(ip) => {
@@ -20,9 +35,6 @@ pub(super) fn address(peer: &Destination, out: &mut Vec<u8>) -> io::Result<()> {
             }
         },
         Destination::Domain { host, .. } => {
-            if host.is_empty() || host.len() > 255 || host.bytes().any(|v| v.is_ascii_control()) {
-                return Err(io::ErrorKind::InvalidInput.into());
-            }
             out.extend_from_slice(&[0, host.len() as u8]);
             out.extend_from_slice(host.as_bytes());
         }
@@ -37,12 +49,24 @@ pub(super) fn connect(peer: &Destination) -> io::Result<Vec<u8>> {
     Ok(bytes)
 }
 
+#[cfg(test)]
 pub(super) fn packets(
     association: u16,
     packet: u16,
     peer: &Destination,
     payload: &[u8],
     limit: usize,
+) -> io::Result<Vec<Bytes>> {
+    packets_with_payload_limit(association, packet, peer, payload, limit, usize::MAX)
+}
+
+pub(super) fn packets_with_payload_limit(
+    association: u16,
+    packet: u16,
+    peer: &Destination,
+    payload: &[u8],
+    limit: usize,
+    payload_limit: usize,
 ) -> io::Result<Vec<Bytes>> {
     if payload.len() > u16::MAX as usize {
         return Err(io::ErrorKind::InvalidInput.into());
@@ -51,7 +75,8 @@ pub(super) fn packets(
     address(peer, &mut target)?;
     let space = limit
         .checked_sub(10 + target.len())
-        .ok_or(io::ErrorKind::InvalidInput)?;
+        .ok_or(io::ErrorKind::InvalidInput)?
+        .min(payload_limit);
     if space == 0 && !payload.is_empty() {
         return Err(io::ErrorKind::InvalidInput.into());
     }
@@ -202,16 +227,90 @@ pub(super) async fn read_packet(
     let start = raw.len();
     raw.resize(start + size, 0);
     stream.read_exact(&mut raw[start..]).await?;
-    let mut extra = [0];
-    if stream.read(&mut extra).await? != 0 {
-        return Err(invalid());
-    }
-    decode(raw.into())
+    let fragment = decode(raw.into())?;
+    // Consume an already-ready EOF so Quinn need not send STOP_SENDING for a
+    // completed stream. A pending FIN, extra byte or tail error never delays or
+    // revokes the complete declared payload; the original Drop path remains.
+    let mut tail = [0; 1];
+    std::future::poll_fn(|cx| {
+        let mut buffer = tokio::io::ReadBuf::new(&mut tail);
+        let _ = std::pin::Pin::new(&mut stream).poll_read(cx, &mut buffer);
+        std::task::Poll::Ready(())
+    })
+    .await;
+    Ok(fragment)
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+
+    #[test]
+    fn address_length_validates_the_existing_wire_peer_boundaries() {
+        for (peer, expected_len) in [
+            (Destination::Ip("192.0.2.1:53".parse().unwrap()), 7),
+            (Destination::Ip("[::1]:53".parse().unwrap()), 19),
+            (
+                Destination::Domain {
+                    host: "x".into(),
+                    port: 80,
+                },
+                5,
+            ),
+            (
+                Destination::Domain {
+                    host: "x".repeat(255),
+                    port: 80,
+                },
+                259,
+            ),
+            (
+                Destination::Domain {
+                    host: "é".into(),
+                    port: 80,
+                },
+                6,
+            ),
+            (crate::outbound::uot::magic_destination(), 27),
+        ] {
+            assert_eq!(address_len(&peer).unwrap(), expected_len);
+            let mut bytes = Vec::new();
+            address(&peer, &mut bytes).unwrap();
+            assert_eq!(bytes.len(), expected_len);
+        }
+        for peer in [
+            Destination::Domain {
+                host: "".into(),
+                port: 80,
+            },
+            Destination::Domain {
+                host: "x".repeat(256),
+                port: 80,
+            },
+            Destination::Domain {
+                host: "bad\0name".into(),
+                port: 80,
+            },
+            Destination::Domain {
+                host: "bad\x7fname".into(),
+                port: 80,
+            },
+            Destination::Domain {
+                host: "peer.invalid".into(),
+                port: 0,
+            },
+            Destination::Ip("192.0.2.1:0".parse().unwrap()),
+            Destination::Ip("[::1]:0".parse().unwrap()),
+        ] {
+            assert_eq!(
+                address_len(&peer).unwrap_err().kind(),
+                io::ErrorKind::InvalidInput
+            );
+            let mut unchanged = vec![0xa5];
+            assert!(address(&peer, &mut unchanged).is_err());
+            assert_eq!(unchanged, [0xa5]);
+        }
+    }
     use tokio::io::AsyncWriteExt;
     #[test]
     fn native_packet_has_one_address_and_exact_fragment_lengths() {
@@ -272,8 +371,60 @@ mod tests {
         }
     }
 
+    #[test]
+    fn only_uot_v2_connect_allows_a_zero_port() {
+        assert_eq!(
+            connect(&crate::outbound::uot::magic_destination()).unwrap(),
+            b"\x05\x01\x00\x17sp.v2.udp-over-tcp.arpa\x00\x00"
+        );
+        for peer in [
+            Destination::Domain {
+                host: "sp.udp-over-tcp.arpa".into(),
+                port: 0,
+            },
+            Destination::Domain {
+                host: "peer.invalid".into(),
+                port: 0,
+            },
+            Destination::Ip("192.0.2.1:0".parse().unwrap()),
+        ] {
+            assert!(connect(&peer).is_err());
+        }
+    }
+
+    #[test]
+    fn configured_native_fragment_payload_and_quic_unfragmented_packet() {
+        let peer = Destination::Ip("[::1]:53".parse().unwrap());
+        for message_limit in [1200, 65535 + 512] {
+            let packets =
+                packets_with_payload_limit(1, 2, &peer, b"abcdefgh", message_limit, 3).unwrap();
+            assert_eq!(packets.len(), 3);
+            let pieces: Vec<_> = packets
+                .into_iter()
+                .map(|packet| decode(packet).unwrap())
+                .collect();
+            assert_eq!(
+                pieces
+                    .iter()
+                    .map(|piece| piece.payload.as_ref())
+                    .collect::<Vec<_>>(),
+                vec![&b"abc"[..], &b"def"[..], &b"gh"[..]]
+            );
+            assert!(pieces.iter().all(|piece| piece.count == 3));
+            assert_eq!(pieces[0].peer, Some(peer.clone()));
+            assert!(pieces[1].peer.is_none());
+            let quic =
+                packets_with_payload_limit(1, 2, &peer, b"abcdefgh", 65535 + 512, usize::MAX)
+                    .unwrap();
+            assert_eq!(quic.len(), 1);
+            let packet = decode(quic.into_iter().next().unwrap()).unwrap();
+            assert_eq!(packet.payload.as_ref(), b"abcdefgh");
+            assert_eq!(packet.count, 1);
+        }
+    }
+
     #[tokio::test]
-    async fn uni_parser_rejects_unknown_owner_before_reading_body_and_requires_fin() {
+    async fn uni_parser_rejects_unknown_owner_before_reading_body_and_declared_limit() {
         let (client, mut peer) = tokio::io::duplex(64);
         peer.write_all(b"\x05\x02\xff\xff\x00\x00\x01\x00\xff\xff")
             .await
@@ -287,21 +438,46 @@ mod tests {
             .unwrap()
             .is_err()
         );
+        let literal = &b"\x05\x02\x00\x01\x00\x00\x01\x00\x00\x01\x00\x01x\x00\x35a"[..];
+        assert!(read_packet(literal, |_| Some(0)).await.is_err());
+    }
+
+    #[tokio::test]
+    async fn uni_parser_delivers_declared_payload_without_fin() {
         let literal = &b"\x05\x02\x00\x01\x00\x00\x01\x00\x00\x01\x00\x01x\x00\x35a"[..];
         for suffix in [&b""[..], &b"x"[..]] {
-            let (client, mut peer) = tokio::io::duplex(1);
-            let suffix = suffix.to_vec();
-            let invalid = !suffix.is_empty();
-            let sent = tokio::spawn(async move {
-                for byte in literal {
-                    peer.write_all(&[*byte]).await.unwrap();
-                }
-                let _ = peer.write_all(&suffix).await;
-            });
-            let result = read_packet(client, |id| if id == 1 { Some(1) } else { None }).await;
-            assert_eq!(result.is_err(), invalid);
-            sent.await.unwrap();
+            let (client, mut peer) = tokio::io::duplex(64);
+            peer.write_all(literal).await.unwrap();
+            peer.write_all(suffix).await.unwrap();
+            let result = tokio::time::timeout(
+                std::time::Duration::from_millis(20),
+                read_packet(client, |id| if id == 1 { Some(1) } else { None }),
+            )
+            .await;
+            // Keep the real writer open until parsing completes; no FIN or
+            // background task can make the old EOF-waiting parser pass.
+            drop(peer);
+            let fragment = result
+                .expect("declared UDP payload waited for FIN")
+                .unwrap();
+            assert_eq!(fragment.association, 1);
+            assert_eq!(fragment.packet, 0);
+            assert_eq!(fragment.count, 1);
+            assert_eq!(fragment.index, 0);
+            assert_eq!(
+                fragment.peer,
+                Some(Destination::Domain {
+                    host: "x".into(),
+                    port: 53,
+                })
+            );
+            assert_eq!(fragment.payload.as_ref(), b"a");
         }
-        assert!(read_packet(literal, |_| Some(0)).await.is_err());
+    }
+
+    #[tokio::test]
+    async fn uni_parser_rejects_truncated_declared_payload() {
+        let truncated = &b"\x05\x02\x00\x01\x00\x00\x01\x00\x00\x01\x00\x01x\x00\x35"[..];
+        assert!(read_packet(truncated, |_| Some(1)).await.is_err());
     }
 }
diff --git a/src/outbound/uot.rs b/src/outbound/uot.rs
index 6014b03..7819d8e 100644
--- a/src/outbound/uot.rs
+++ b/src/outbound/uot.rs
@@ -46,30 +46,9 @@ enum ReceiveEvent {
     Failed(ReceiveFailure),
 }
 
-struct SendGuard {
-    cancellation: CancellationToken,
-    committed: bool,
-}
-
-impl SendGuard {
-    fn new(cancellation: CancellationToken) -> Self {
-        Self {
-            cancellation,
-            committed: false,
-        }
-    }
-
-    fn commit(&mut self) {
-        self.committed = true;
-    }
-}
-
-impl Drop for SendGuard {
-    fn drop(&mut self) {
-        if !self.committed {
-            self.cancellation.cancel();
-        }
-    }
+struct PendingWrite {
+    packet: Bytes,
+    offset: usize,
 }
 
 pub(crate) struct UotTransport {
@@ -78,6 +57,8 @@ pub(crate) struct UotTransport {
     cancellation: CancellationToken,
     reader_task: Option<JoinHandle<()>>,
     first_write: bool,
+    initial_deadline: Option<tokio::time::Instant>,
+    pending_write: Option<PendingWrite>,
     closed: bool,
 }
 
@@ -118,40 +99,96 @@ impl UotTransport {
             cancellation,
             reader_task: Some(reader_task),
             first_write: true,
+            initial_deadline: None,
+            pending_write: None,
             closed: false,
         }
     }
-}
+    #[cfg(feature = "outbound-tuic")]
+    pub(crate) fn with_initial_deadline(mut self, deadline: tokio::time::Instant) -> Self {
+        self.initial_deadline = Some(deadline);
+        self
+    }
 
-#[async_trait]
-impl DatagramTransport for UotTransport {
-    async fn send(&mut self, datagram: Datagram) -> Result<(), DispatchError> {
+    fn check_open(&mut self) -> Result<(), DispatchError> {
         if self.closed || self.cancellation.is_cancelled() {
             return Err(DispatchError::Other("UoT association is closed".to_owned()));
         }
-        let packet = if self.first_write {
-            encode_first_packet(&datagram).map_err(DispatchError::from)?
-        } else {
-            encode_datagram(&datagram).map_err(DispatchError::from)?
+        if self
+            .initial_deadline
+            .is_some_and(|deadline| tokio::time::Instant::now() >= deadline)
+        {
+            self.fail();
+            return Err(DispatchError::TimedOut);
+        }
+        Ok(())
+    }
+
+    fn fail(&mut self) {
+        self.closed = true;
+        self.pending_write = None;
+        self.cancellation.cancel();
+    }
+
+    async fn flush_pending(&mut self) -> Result<(), DispatchError> {
+        let Some(pending) = &mut self.pending_write else {
+            return Ok(());
+        };
+        let cancellation = self.cancellation.clone();
+        let initial_deadline = self.initial_deadline;
+        let writing = async {
+            while pending.offset < pending.packet.len() {
+                let written = self.writer.write(&pending.packet[pending.offset..]).await?;
+                if written == 0 {
+                    return Err(io::Error::from(io::ErrorKind::WriteZero));
+                }
+                pending.offset += written;
+            }
+            self.writer.flush().await
         };
-        let mut send_guard = SendGuard::new(self.cancellation.clone());
-        tokio::select! {
+        let result = tokio::select! {
             biased;
-            () = self.cancellation.cancelled() => return Err(DispatchError::NotAllowed),
+            () = cancellation.cancelled() => Err(DispatchError::NotAllowed),
             result = async {
-                self.writer.write_all(&packet).await?;
-                self.writer.flush().await
-            } => result.map_err(DispatchError::from)?,
+                if let Some(deadline) = initial_deadline {
+                    tokio::time::timeout_at(deadline, writing).await.map_err(|_| DispatchError::TimedOut)?
+                        .map_err(DispatchError::from)
+                } else { writing.await.map_err(DispatchError::from) }
+            } => result,
+        };
+        if let Err(error) = result {
+            self.fail();
+            return Err(error);
         }
+        self.pending_write = None;
         self.first_write = false;
-        send_guard.commit();
+        self.initial_deadline = None;
         Ok(())
     }
+}
+
+#[async_trait]
+impl DatagramTransport for UotTransport {
+    fn supports_shared_destinations(&self) -> bool {
+        // Datagram mode carries a destination in every packet.
+        true
+    }
+
+    async fn send(&mut self, datagram: Datagram) -> Result<(), DispatchError> {
+        self.check_open()?;
+        self.flush_pending().await?;
+        let packet = if self.first_write {
+            encode_first_packet(&datagram).map_err(DispatchError::from)?
+        } else {
+            encode_datagram(&datagram).map_err(DispatchError::from)?
+        };
+        self.pending_write = Some(PendingWrite { packet, offset: 0 });
+        self.flush_pending().await
+    }
 
     async fn receive(&mut self) -> Result<Datagram, DispatchError> {
-        if self.closed || self.cancellation.is_cancelled() {
-            return Err(DispatchError::Other("UoT association is closed".to_owned()));
-        }
+        self.check_open()?;
+        self.flush_pending().await?;
         match self.responses.recv().await {
             Some(ReceiveEvent::Datagram(datagram)) => Ok(datagram),
             Some(ReceiveEvent::Failed(error)) => {
@@ -173,6 +210,7 @@ impl DatagramTransport for UotTransport {
             return Ok(());
         }
         self.cancellation.cancel();
+        self.pending_write = None;
         if let Some(reader_task) = self.reader_task.take() {
             let _ = reader_task.await;
         }
@@ -482,6 +520,68 @@ mod tests {
         assert!(encode_first_packet(&packet).is_err());
     }
 
+    #[cfg(feature = "outbound-tuic")]
+    #[tokio::test]
+    async fn tuic_uot_v2_writes_independent_vectors_and_joins_after_stop() {
+        let tracker = TaskTracker::new();
+        let cancellation = CancellationToken::new();
+        let (io, mut peer) = tokio::io::duplex(128);
+        let (reader, writer) = tokio::io::split(io);
+        let mut transport = UotTransport::new(reader, writer, 8, cancellation.clone(), &tracker)
+            .with_initial_deadline(tokio::time::Instant::now() + Duration::from_secs(1));
+        let packet = datagram(
+            Destination::Ip((Ipv4Addr::new(1, 2, 3, 4), 53).into()),
+            b"q",
+        );
+        transport.send(packet).await.unwrap();
+        let expected: &[u8] = &[0, 1, 1, 2, 3, 4, 0, 53, 0, 1, 2, 3, 4, 0, 53, 0, 1, b'q'];
+        let mut actual = vec![0; expected.len()];
+        peer.read_exact(&mut actual).await.unwrap();
+        assert_eq!(actual, expected);
+        // The response codec is supplied independently of the request encoder.
+        peer.write_all(&[0, 8, 8, 8, 8, 0, 53, 0, 1, b'a'])
+            .await
+            .unwrap();
+        let reply = transport.receive().await.unwrap();
+        assert_eq!(
+            reply.remote,
+            Destination::Ip((Ipv4Addr::new(8, 8, 8, 8), 53).into())
+        );
+        assert_eq!(reply.payload.as_ref(), b"a");
+        cancellation.cancel();
+        tracker.close();
+        tokio::time::timeout(Duration::from_secs(1), transport.close())
+            .await
+            .unwrap()
+            .unwrap();
+        tokio::time::timeout(Duration::from_secs(1), tracker.wait())
+            .await
+            .unwrap();
+    }
+
+    #[cfg(feature = "outbound-tuic")]
+    #[tokio::test]
+    async fn tuic_uot_expired_original_first_packet_deadline_sends_no_bytes() {
+        let tracker = TaskTracker::new();
+        let (io, mut peer) = tokio::io::duplex(128);
+        let (reader, writer) = tokio::io::split(io);
+        let mut transport =
+            UotTransport::new(reader, writer, 8, CancellationToken::new(), &tracker)
+                .with_initial_deadline(tokio::time::Instant::now());
+        assert!(matches!(
+            transport
+                .send(datagram(Destination::domain("dns.test", 53).unwrap(), b"q"))
+                .await,
+            Err(DispatchError::TimedOut)
+        ));
+        tracker.close();
+        transport.close().await.unwrap();
+        let mut received = Vec::new();
+        peer.read_to_end(&mut received).await.unwrap();
+        assert!(received.is_empty());
+        tracker.wait().await;
+    }
+
     #[tokio::test]
     async fn malformed_and_truncated_responses_are_rejected_without_a_datagram() {
         // Independent wire vectors, including a length-prefixed invalid UTF-8
@@ -539,20 +639,119 @@ mod tests {
         assert_eq!(decoded.payload, expected.payload);
     }
 
-    #[test]
-    fn cancelled_send_transaction_poisons_the_association() {
-        let cancellation = CancellationToken::new();
-        {
-            let _guard = SendGuard::new(cancellation.clone());
-        }
-        assert!(cancellation.is_cancelled());
+    #[tokio::test]
+    async fn cancelled_partial_write_finishes_before_the_next_datagram() {
+        assert_cancelled_frame_progress(true).await;
+    }
 
-        let committed = CancellationToken::new();
-        {
-            let mut guard = SendGuard::new(committed.clone());
-            guard.commit();
+    #[tokio::test]
+    async fn receive_finishes_a_cancelled_partial_write_without_another_send() {
+        assert_cancelled_frame_progress(false).await;
+    }
+
+    #[cfg(feature = "outbound-tuic")]
+    #[tokio::test(start_paused = true)]
+    async fn cancelled_first_write_keeps_its_original_deadline() {
+        let tracker = TaskTracker::new();
+        let (io, mut peer) = tokio::io::duplex(1);
+        let (reader, writer) = tokio::io::split(io);
+        let mut transport =
+            UotTransport::new(reader, writer, 64, CancellationToken::new(), &tracker)
+                .with_initial_deadline(tokio::time::Instant::now() + Duration::from_secs(1));
+        let packet = datagram(
+            "192.0.2.1:53".parse::<SocketAddr>().unwrap().into(),
+            b"request",
+        );
+        assert!(futures_util::poll!(transport.send(packet)).is_pending());
+        assert_eq!(peer.read_u8().await.unwrap(), 0);
+        tokio::time::advance(Duration::from_secs(2)).await;
+        assert!(matches!(
+            transport.receive().await,
+            Err(DispatchError::TimedOut)
+        ));
+        transport.close().await.unwrap();
+        let mut extra = Vec::new();
+        peer.read_to_end(&mut extra).await.unwrap();
+        assert!(extra.is_empty());
+        tracker.close();
+        tracker.wait().await;
+    }
+
+    #[tokio::test]
+    async fn close_discards_a_pending_frame_without_waiting_for_write_capacity() {
+        let tracker = TaskTracker::new();
+        let (io, mut peer) = tokio::io::duplex(1);
+        let (reader, writer) = tokio::io::split(io);
+        let mut transport =
+            UotTransport::new(reader, writer, 64, CancellationToken::new(), &tracker);
+        let packet = datagram(
+            "192.0.2.1:53".parse::<SocketAddr>().unwrap().into(),
+            b"request",
+        );
+        assert!(futures_util::poll!(transport.send(packet)).is_pending());
+        tokio::time::timeout(Duration::from_secs(1), transport.close())
+            .await
+            .unwrap()
+            .unwrap();
+        tracker.close();
+        tokio::time::timeout(Duration::from_secs(1), tracker.wait())
+            .await
+            .unwrap();
+        let mut prefix = Vec::new();
+        peer.read_to_end(&mut prefix).await.unwrap();
+        assert_eq!(prefix, [0]);
+        assert!(transport.receive().await.is_err());
+    }
+
+    async fn assert_cancelled_frame_progress(send_another: bool) {
+        let tracker = TaskTracker::new();
+        let (io, mut peer) = tokio::io::duplex(1);
+        let (reader, writer) = tokio::io::split(io);
+        let mut transport =
+            UotTransport::new(reader, writer, 64, CancellationToken::new(), &tracker);
+        let first = datagram(
+            "192.0.2.1:53".parse::<SocketAddr>().unwrap().into(),
+            b"first",
+        );
+        let second = datagram(
+            "[2001:db8::2]:853".parse::<SocketAddr>().unwrap().into(),
+            b"second",
+        );
+        let mut expected = encode_first_packet(&first).unwrap().to_vec();
+        if send_another {
+            expected.extend_from_slice(&encode_datagram(&second).unwrap());
         }
-        assert!(!committed.is_cancelled());
+        assert!(futures_util::poll!(transport.send(first.clone())).is_pending());
+        assert!(
+            !transport.cancellation.is_cancelled(),
+            "dropping one partial send must preserve the shared wire"
+        );
+        let prefix = peer.read_u8().await.unwrap();
+        assert_eq!(prefix, expected[0]);
+        let remaining = expected.len() - 1;
+        let reply = encode_datagram(&datagram(first.remote.clone(), b"reply")).unwrap();
+        let server = tokio::spawn(async move {
+            let mut received = vec![prefix; 1];
+            received.resize(remaining + 1, 0);
+            peer.read_exact(&mut received[1..]).await.unwrap();
+            peer.write_all(&reply).await.unwrap();
+            received
+        });
+        if send_another {
+            transport.send(second).await.unwrap();
+        }
+        let reply = tokio::time::timeout(Duration::from_secs(1), transport.receive())
+            .await
+            .expect("pending frame prevented receive progress")
+            .unwrap();
+        assert_eq!(reply.remote, first.remote);
+        assert_eq!(reply.payload.as_ref(), b"reply");
+        assert_eq!(server.await.unwrap(), expected);
+        transport.close().await.unwrap();
+        tracker.close();
+        tokio::time::timeout(Duration::from_secs(1), tracker.wait())
+            .await
+            .unwrap();
     }
 
     #[tokio::test]
diff --git a/src/outbound/vless/codec.rs b/src/outbound/vless/codec.rs
index face1a7..67aab26 100644
--- a/src/outbound/vless/codec.rs
+++ b/src/outbound/vless/codec.rs
@@ -144,7 +144,7 @@ impl VlessStream {
         if self.inner.is_none() {
             return Err(io::ErrorKind::BrokenPipe.into());
         }
-        if !self.response_header_done
+        if !self.request_header_flushed
             && self
                 .deadline
                 .as_mut()
@@ -185,6 +185,10 @@ impl VlessStream {
         if !self.request_header_flushed {
             std::task::ready!(Pin::new(self.inner.as_mut().expect("checked open")).poll_flush(cx))?;
             self.request_header_flushed = true;
+            // The authenticated transport and VLESS request are established.
+            // A valid upload-only target may send its response header much
+            // later; its silence must not expire ongoing payload writes.
+            self.deadline = None;
         }
         Poll::Ready(Ok(()))
     }
@@ -385,4 +389,47 @@ mod tests {
         .await
         .expect("lazy VLESS exchange timed out");
     }
+
+    #[tokio::test(start_paused = true)]
+    async fn upload_survives_setup_deadline_when_response_is_delayed() {
+        let header = encode_request_header(
+            uuid(),
+            VlessCommand::Tcp,
+            Some(&Destination::domain("example.com", 80).unwrap()),
+        )
+        .unwrap();
+        let (client, mut server) = tokio::io::duplex(256);
+        let mut stream = VlessStream::with_deadline(
+            Box::new(client),
+            header.clone(),
+            tokio::time::Instant::now() + Duration::from_secs(10),
+        );
+        stream.write_all(b"before").await.unwrap();
+        tokio::time::advance(Duration::from_secs(11)).await;
+        stream
+            .write_all(b"after")
+            .await
+            .expect("active upload must outlive setup");
+        let mut request = vec![0; header.len() + 11];
+        server.read_exact(&mut request).await.unwrap();
+        assert_eq!(&request[..header.len()], header.as_ref());
+        assert_eq!(&request[header.len()..], b"beforeafter");
+        server.write_all(&[0, 0, 42]).await.unwrap();
+        let mut response = [0];
+        stream.read_exact(&mut response).await.unwrap();
+        assert_eq!(response, [42]);
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn blocked_request_header_still_obeys_setup_deadline() {
+        let header = encode_request_header(uuid(), VlessCommand::Mux, None).unwrap();
+        let (client, _server) = tokio::io::duplex(1);
+        let mut stream = VlessStream::with_deadline(
+            Box::new(client),
+            header,
+            tokio::time::Instant::now() + Duration::from_secs(10),
+        );
+        let error = stream.write_all(b"payload").await.unwrap_err();
+        assert_eq!(error.kind(), io::ErrorKind::TimedOut);
+    }
 }
diff --git a/src/outbound/vless/datagram.rs b/src/outbound/vless/datagram.rs
index 6e93a13..0ab13c8 100644
--- a/src/outbound/vless/datagram.rs
+++ b/src/outbound/vless/datagram.rs
@@ -17,8 +17,10 @@ use tokio::time::Instant;
 
 pub(super) struct VlessDatagram {
     io: Option<BoxStream>,
+    pending_write: Option<PendingWrite>,
     pending: Option<PreparedStream>,
     packet_addr: bool,
+    autonomous_writes: bool,
     peer: Option<Destination>,
     initialized: bool,
     deadline: Instant,
@@ -28,10 +30,14 @@ pub(super) struct VlessDatagram {
     cancellation: tokio_util::sync::CancellationToken,
 }
 
+struct PendingWrite {
+    wire: Bytes,
+    offset: usize,
+}
+
 impl VlessDatagram {
     pub(super) fn new(
         prepared: PreparedStream,
-        packet_addr: bool,
         budget: DatagramBudget,
         resolution: ResolutionContext,
     ) -> Self {
@@ -39,8 +45,10 @@ impl VlessDatagram {
         let cancellation = prepared.token.clone();
         Self {
             io: None,
+            pending_write: None,
             pending: Some(prepared),
-            packet_addr,
+            packet_addr: false,
+            autonomous_writes: false,
             peer: None,
             initialized: false,
             deadline,
@@ -50,6 +58,122 @@ impl VlessDatagram {
             cancellation,
         }
     }
+    pub(super) async fn packet_addr(
+        prepared: PreparedStream,
+        budget: DatagramBudget,
+        resolution: ResolutionContext,
+    ) -> Result<Self, DispatchError> {
+        let deadline = prepared.deadline;
+        let cancellation = prepared.token.clone();
+        // This protocol destination is fixed before the first business packet.
+        // Finish transport setup before publishing a shared association, so a
+        // cancelled send can never consume and drop its PreparedStream owner.
+        let target = Destination::domain("sp.packet-addr.v2fly.arpa", 443)?;
+        let io = prepared.finish(VlessCommand::Udp, Some(&target)).await?;
+        Ok(Self {
+            io: Some(io),
+            pending_write: None,
+            pending: None,
+            packet_addr: true,
+            autonomous_writes: false,
+            peer: None,
+            initialized: false,
+            deadline,
+            resolution,
+            budget,
+            input: BytesMut::new(),
+            cancellation,
+        })
+    }
+
+    pub(super) fn with_autonomous_writes(mut self) -> Self {
+        self.autonomous_writes = true;
+        self
+    }
+
+    async fn flush_packet_addr_pending(&mut self) -> io::Result<()> {
+        if self.pending_write.is_none() {
+            return Ok(());
+        }
+        let first = !self.initialized;
+        let autonomous_writes = self.autonomous_writes;
+        let deadline = self.deadline;
+        if first && Instant::now() >= deadline {
+            return Err(io::ErrorKind::TimedOut.into());
+        }
+        let cancellation = self.cancellation.clone();
+        // Keep both the stream and each successful write's offset in self.
+        // A cancelled send/receive resumes this exact frame before any new one.
+        let write = async {
+            let pending = self
+                .pending_write
+                .as_mut()
+                .expect("pending packetaddr frame");
+            let io = self.io.as_mut().ok_or(io::ErrorKind::BrokenPipe)?;
+            while pending.offset < pending.wire.len() {
+                let written = io.write(&pending.wire[pending.offset..]).await?;
+                if written == 0 {
+                    return Err(io::ErrorKind::WriteZero.into());
+                }
+                pending.offset += written;
+            }
+            // The first datagram retains its setup flush. On an independently
+            // driven transport, later complete frames are already owned by its
+            // bounded writer; waiting for each POST response prevents batching.
+            if first || !autonomous_writes {
+                io.flush().await
+            } else {
+                Ok(())
+            }
+        };
+        tokio::select! { biased;
+            () = cancellation.cancelled() => return Err(io::ErrorKind::ConnectionAborted.into()),
+            result = async {
+                if first {
+                    tokio::time::timeout_at(deadline, write)
+                        .await.map_err(|_| io::ErrorKind::TimedOut)?
+                } else {
+                    write.await
+                }
+            } => result?,
+        }
+        self.pending_write = None;
+        self.initialized = true;
+        Ok(())
+    }
+
+    async fn send_packet_addr(&mut self, packet: Datagram) -> Result<(), DispatchError> {
+        let result = async {
+            self.flush_packet_addr_pending().await?;
+            let deadline = if self.initialized {
+                Instant::now() + DEFAULT_ESTABLISH_TIMEOUT
+            } else {
+                self.deadline
+            };
+            let peer = tokio::select! { biased;
+                () = self.cancellation.cancelled() => return Err(DispatchError::NotAllowed),
+                peer = self.resolution.resolve_ip(&packet.remote, deadline) => peer?,
+            };
+            let mut wire = BytesMut::with_capacity(packet.payload.len() + 21);
+            wire.put_u16(0);
+            encode_packet_addr(&peer.into(), &mut wire)?;
+            wire.extend_from_slice(&packet.payload);
+            let length = (wire.len() - 2) as u16;
+            wire[..2].copy_from_slice(&length.to_be_bytes());
+            self.pending_write = Some(PendingWrite {
+                wire: wire.freeze(),
+                offset: 0,
+            });
+            self.flush_packet_addr_pending().await?;
+            Ok(())
+        }
+        .await;
+        if result.is_err() {
+            self.close().await?;
+        }
+        result
+    }
+
     async fn fill(&mut self, required: usize) -> io::Result<()> {
         if required > crate::limits::VLESS_UDP_FRAME_BYTES {
             return Err(io::ErrorKind::InvalidData.into());
@@ -92,6 +216,10 @@ impl VlessDatagram {
 
 #[async_trait]
 impl DatagramTransport for VlessDatagram {
+    fn supports_shared_destinations(&self) -> bool {
+        self.packet_addr
+    }
+
     fn payload_budget(&self, peer: &Destination) -> DatagramBudget {
         let overhead = if !self.packet_addr {
             0
@@ -117,11 +245,13 @@ impl DatagramTransport for VlessDatagram {
         {
             return Err(io::Error::from(io::ErrorKind::InvalidInput).into());
         }
-        if !self.packet_addr
-            && self
-                .peer
-                .as_ref()
-                .is_some_and(|peer| *peer != packet.remote)
+        if self.packet_addr {
+            return self.send_packet_addr(packet).await;
+        }
+        if self
+            .peer
+            .as_ref()
+            .is_some_and(|peer| *peer != packet.remote)
         {
             return Err(DispatchError::NotAllowed);
         }
@@ -133,33 +263,12 @@ impl DatagramTransport for VlessDatagram {
         }
         let mut wire = BytesMut::with_capacity(packet.payload.len() + 21);
         wire.put_u16(0);
-        if self.packet_addr {
-            let deadline = if first {
-                self.deadline
-            } else {
-                Instant::now() + DEFAULT_ESTABLISH_TIMEOUT
-            };
-            let peer = tokio::select! {
-                biased;
-                () = self.cancellation.cancelled() => {
-                    self.close().await?;
-                    return Err(DispatchError::NotAllowed);
-                }
-                result = self.resolution.resolve_ip(&packet.remote, deadline) => result?,
-            };
-            encode_packet_addr(&peer.into(), &mut wire)?;
-        }
         wire.extend_from_slice(&packet.payload);
         let length = (wire.len() - 2) as u16;
         wire[..2].copy_from_slice(&length.to_be_bytes());
         let mut stream = if let Some(prepared) = self.pending.take() {
-            let destination = if self.packet_addr {
-                Destination::domain("sp.packet-addr.v2fly.arpa", 443)?
-            } else {
-                packet.remote.clone()
-            };
             prepared
-                .finish(VlessCommand::Udp, Some(&destination))
+                .finish(VlessCommand::Udp, Some(&packet.remote))
                 .await?
         } else {
             self.io
@@ -186,6 +295,12 @@ impl DatagramTransport for VlessDatagram {
         if self.io.is_none() && self.pending.is_none() {
             return Err(io::Error::from(io::ErrorKind::BrokenPipe).into());
         }
+        if self.packet_addr
+            && let Err(error) = self.flush_packet_addr_pending().await
+        {
+            self.close().await?;
+            return Err(error.into());
+        }
         if !self.initialized {
             self.cancellation.cancelled().await;
             self.close().await?;
@@ -217,7 +332,390 @@ impl DatagramTransport for VlessDatagram {
     async fn close(&mut self) -> Result<(), DispatchError> {
         self.io.take();
         self.pending.take();
+        self.pending_write = None;
         self.input.clear();
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::{
+        pin::Pin,
+        sync::{
+            Arc,
+            atomic::{AtomicUsize, Ordering},
+        },
+        task::{Context, Poll},
+        time::Duration,
+    };
+    use tokio::io::{AsyncRead, AsyncWrite, DuplexStream, ReadBuf};
+
+    #[derive(Clone)]
+    struct Gates {
+        write_bytes: Arc<AtomicUsize>,
+        flushes: Arc<AtomicUsize>,
+        drops: Arc<AtomicUsize>,
+    }
+    impl Gates {
+        fn release(&self) {
+            self.write_bytes.store(usize::MAX, Ordering::SeqCst);
+            self.flushes.store(usize::MAX, Ordering::SeqCst);
+        }
+    }
+    struct GatedIo {
+        raw: DuplexStream,
+        gates: Gates,
+    }
+    impl Drop for GatedIo {
+        fn drop(&mut self) {
+            self.gates.drops.fetch_add(1, Ordering::SeqCst);
+        }
+    }
+    impl AsyncRead for GatedIo {
+        fn poll_read(
+            mut self: Pin<&mut Self>,
+            cx: &mut Context<'_>,
+            out: &mut ReadBuf<'_>,
+        ) -> Poll<io::Result<()>> {
+            Pin::new(&mut self.raw).poll_read(cx, out)
+        }
+    }
+    impl AsyncWrite for GatedIo {
+        fn poll_write(
+            mut self: Pin<&mut Self>,
+            cx: &mut Context<'_>,
+            data: &[u8],
+        ) -> Poll<io::Result<usize>> {
+            let available = self.gates.write_bytes.load(Ordering::SeqCst);
+            if available == 0 {
+                return Poll::Pending;
+            }
+            let size = data.len().min(available);
+            let result = Pin::new(&mut self.raw).poll_write(cx, &data[..size]);
+            if let Poll::Ready(Ok(written)) = result
+                && available != usize::MAX
+            {
+                self.gates.write_bytes.fetch_sub(written, Ordering::SeqCst);
+            }
+            result
+        }
+        fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            let available = self.gates.flushes.load(Ordering::SeqCst);
+            if available == 0 {
+                return Poll::Pending;
+            }
+            let result = Pin::new(&mut self.raw).poll_flush(cx);
+            if matches!(result, Poll::Ready(Ok(()))) && available != usize::MAX {
+                self.gates.flushes.fetch_sub(1, Ordering::SeqCst);
+            }
+            result
+        }
+        fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Pin::new(&mut self.raw).poll_shutdown(cx)
+        }
+    }
+    async fn fixture(packet_addr: bool) -> (VlessDatagram, DuplexStream, Gates) {
+        let (raw, peer) = tokio::io::duplex(4096);
+        let gates = Gates {
+            write_bytes: Arc::new(AtomicUsize::new(usize::MAX)),
+            flushes: Arc::new(AtomicUsize::new(usize::MAX)),
+            drops: Arc::default(),
+        };
+        let prepared = PreparedStream::for_memory_test(
+            Box::new(GatedIo {
+                raw,
+                gates: gates.clone(),
+            }),
+            Instant::now() + Duration::from_secs(5),
+            tokio_util::sync::CancellationToken::new(),
+        );
+        let budget = DatagramBudget::new(1452, 1452);
+        let resolution = ResolutionContext::default();
+        let transport = if packet_addr {
+            VlessDatagram::packet_addr(prepared, budget, resolution)
+                .await
+                .unwrap()
+        } else {
+            VlessDatagram::new(prepared, budget, resolution)
+        };
+        (transport, peer, gates)
+    }
+    fn packet(remote: &str, payload: &'static [u8]) -> Datagram {
+        Datagram {
+            remote: remote.parse::<std::net::SocketAddr>().unwrap().into(),
+            payload: Bytes::from_static(payload),
+            sniffed_domain: None,
+        }
+    }
+    fn header(remote: &Destination) -> Vec<u8> {
+        super::super::codec::encode_header(
+            uuid::Uuid::from_bytes([7; 16]),
+            VlessCommand::Udp,
+            Some(remote),
+            false,
+        )
+        .unwrap()
+        .to_vec()
+    }
+    fn magic_header() -> Vec<u8> {
+        header(&Destination::domain("sp.packet-addr.v2fly.arpa", 443).unwrap())
+    }
+    fn wire(packet: &Datagram) -> Vec<u8> {
+        let mut output = BytesMut::new();
+        output.put_u16(0);
+        encode_packet_addr(&packet.remote, &mut output).unwrap();
+        output.extend_from_slice(&packet.payload);
+        let length = (output.len() - 2) as u16;
+        output[..2].copy_from_slice(&length.to_be_bytes());
+        output.to_vec()
+    }
+
+    #[tokio::test]
+    async fn packetaddr_shares_one_magic_request_and_preserves_response_sources() {
+        let (mut transport, mut peer, _) = fixture(true).await;
+        assert!(transport.supports_shared_destinations());
+        let first = packet("192.0.2.1:53", b"first");
+        let second = packet("[2001:db8::2]:54", b"second");
+        transport.send(first.clone()).await.unwrap();
+        transport.send(second.clone()).await.unwrap();
+        let mut expected = magic_header();
+        expected.extend(wire(&first));
+        expected.extend(wire(&second));
+        let mut actual = vec![0; expected.len()];
+        peer.read_exact(&mut actual).await.unwrap();
+        assert_eq!(actual, expected, "the magic VLESS request must occur once");
+        let mut responses = vec![0, 0];
+        responses.extend(wire(&second));
+        responses.extend(wire(&first));
+        peer.write_all(&responses).await.unwrap();
+        for expected in [second, first] {
+            let actual = transport.receive().await.unwrap();
+            assert_eq!(actual.remote, expected.remote);
+            assert_eq!(actual.payload, expected.payload);
+        }
+    }
+
+    #[tokio::test]
+    async fn raw_remains_lazy_fixed_target_and_closes_after_partial_send_cancel() {
+        let (mut transport, mut peer, gates) = fixture(false).await;
+        assert!(!transport.supports_shared_destinations());
+        assert!(transport.io.is_none() && transport.pending.is_some());
+        let first = packet("192.0.2.1:53", b"first");
+        let second = packet("198.51.100.1:54", b"second");
+        transport.send(first.clone()).await.unwrap();
+        assert!(matches!(
+            transport.send(second).await,
+            Err(DispatchError::NotAllowed)
+        ));
+        let mut expected = header(&first.remote);
+        expected.extend_from_slice(&(first.payload.len() as u16).to_be_bytes());
+        expected.extend_from_slice(&first.payload);
+        let mut actual = vec![0; expected.len()];
+        peer.read_exact(&mut actual).await.unwrap();
+        assert_eq!(actual, expected);
+        transport.close().await.unwrap();
+        assert_eq!(gates.drops.load(Ordering::SeqCst), 1);
+
+        let (mut raw, mut peer, gates) = fixture(false).await;
+        gates.write_bytes.store(1, Ordering::SeqCst);
+        assert!(futures_util::poll!(raw.send(first)).is_pending());
+        assert!(raw.io.is_none() && raw.pending.is_none());
+        let mut prefix = Vec::new();
+        peer.read_to_end(&mut prefix).await.unwrap();
+        assert_eq!(prefix.len(), 1);
+        assert_eq!(gates.drops.load(Ordering::SeqCst), 1);
+    }
+
+    #[tokio::test]
+    async fn cancelled_packetaddr_header_payload_and_flush_resume_without_replay() {
+        let first = packet("192.0.2.1:53", b"first");
+        let second = packet("198.51.100.1:54", b"second");
+        let header_len = magic_header().len();
+        for autonomous in [false, true] {
+            for (write_bytes, flushes) in [
+                (1, usize::MAX),
+                (header_len + 3, usize::MAX),
+                (header_len + wire(&first).len() - 1, usize::MAX),
+                // The header consumes this flush; first DATA must still wait
+                // for its own flush, including when autonomous is enabled.
+                (usize::MAX, 1),
+            ] {
+                for resume_receive in [false, true] {
+                    let (mut transport, mut peer, gates) = fixture(true).await;
+                    if autonomous {
+                        transport = transport.with_autonomous_writes();
+                    }
+                    gates.write_bytes.store(write_bytes, Ordering::SeqCst);
+                    gates.flushes.store(flushes, Ordering::SeqCst);
+                    assert!(futures_util::poll!(transport.send(first.clone())).is_pending());
+                    assert!(transport.io.is_some() && transport.pending_write.is_some());
+                    assert_eq!(gates.drops.load(Ordering::SeqCst), 0);
+                    gates.release();
+                    let mut expected = magic_header();
+                    expected.extend(wire(&first));
+                    if resume_receive {
+                        let mut response = vec![0, 0];
+                        response.extend(wire(&second));
+                        peer.write_all(&response).await.unwrap();
+                        let actual = transport.receive().await.unwrap();
+                        assert_eq!(actual.remote, second.remote);
+                        assert_eq!(actual.payload, second.payload);
+                    } else {
+                        transport.send(second.clone()).await.unwrap();
+                        expected.extend(wire(&second));
+                    }
+                    assert!(transport.pending_write.is_none());
+                    transport.close().await.unwrap();
+                    let mut actual = Vec::new();
+                    peer.read_to_end(&mut actual).await.unwrap();
+                    assert_eq!(
+                        actual, expected,
+                        "first-frame cancelled bytes must occur exactly once; autonomous={autonomous}, receive={resume_receive}",
+                    );
+                    assert_eq!(gates.drops.load(Ordering::SeqCst), 1);
+                }
+            }
+        }
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn established_packetaddr_partial_write_resumes_by_send_or_receive_without_replay() {
+        let first = packet("192.0.2.1:53", b"first");
+        let second = packet("[2001:db8::2]:54", b"second");
+        let third = packet("198.51.100.3:55", b"third");
+        let second_wire = wire(&second);
+        for autonomous in [false, true] {
+            // Each cancellation is inside an actually written frame, not an
+            // established flush barrier that autonomous mode intentionally skips.
+            for prefix_len in [1, second_wire.len() - 1] {
+                for resume_receive in [false, true] {
+                    let (mut transport, mut peer, gates) = fixture(true).await;
+                    if autonomous {
+                        transport = transport.with_autonomous_writes();
+                    }
+                    transport.send(first.clone()).await.unwrap();
+                    let mut established_wire = magic_header();
+                    established_wire.extend(wire(&first));
+                    let mut actual = vec![0; established_wire.len()];
+                    peer.read_exact(&mut actual).await.unwrap();
+                    assert_eq!(actual, established_wire);
+
+                    gates.write_bytes.store(prefix_len, Ordering::SeqCst);
+                    assert!(futures_util::poll!(transport.send(second.clone())).is_pending());
+                    assert!(transport.pending_write.is_some());
+                    assert_eq!(gates.drops.load(Ordering::SeqCst), 0);
+                    let mut prefix = vec![0; prefix_len];
+                    peer.read_exact(&mut prefix).await.unwrap();
+                    assert_eq!(prefix, second_wire[..prefix_len]);
+
+                    // Expiring the original first-frame deadline must not turn
+                    // an established frame's cancelled continuation into setup.
+                    tokio::time::advance(Duration::from_secs(6)).await;
+                    gates.release();
+                    let mut expected = second_wire[prefix_len..].to_vec();
+                    if resume_receive {
+                        let mut response = vec![0, 0];
+                        response.extend(wire(&third));
+                        peer.write_all(&response).await.unwrap();
+                        let actual = transport.receive().await.unwrap();
+                        assert_eq!(actual.remote, third.remote);
+                        assert_eq!(actual.payload, third.payload);
+                    } else {
+                        transport.send(third.clone()).await.unwrap();
+                        expected.extend(wire(&third));
+                    }
+                    assert!(transport.pending_write.is_none());
+                    transport.close().await.unwrap();
+                    let mut tail = Vec::new();
+                    peer.read_to_end(&mut tail).await.unwrap();
+                    assert_eq!(
+                        tail, expected,
+                        "established frame lost/replayed bytes; autonomous={autonomous}, receive={resume_receive}, prefix={prefix_len}",
+                    );
+                    assert_eq!(gates.drops.load(Ordering::SeqCst), 1);
+                }
+            }
+        }
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn cancelled_first_frame_keeps_deadline_and_established_frames_outlive_it() {
+        let first = packet("192.0.2.1:53", b"first");
+        let second = packet("198.51.100.1:54", b"second");
+        let (mut transport, mut peer, gates) = fixture(true).await;
+        gates.write_bytes.store(1, Ordering::SeqCst);
+        assert!(futures_util::poll!(transport.send(first.clone())).is_pending());
+        tokio::time::advance(Duration::from_secs(6)).await;
+        gates.release();
+        assert!(matches!(
+            transport.send(second.clone()).await,
+            Err(DispatchError::TimedOut)
+        ));
+        assert!(transport.io.is_none() && transport.pending_write.is_none());
+        let mut prefix = Vec::new();
+        peer.read_to_end(&mut prefix).await.unwrap();
+        assert_eq!(prefix, magic_header()[..1]);
+        assert_eq!(gates.drops.load(Ordering::SeqCst), 1);
+
+        let (mut established, mut peer, _) = fixture(true).await;
+        established.send(first.clone()).await.unwrap();
+        tokio::time::advance(Duration::from_secs(6)).await;
+        established.send(second.clone()).await.unwrap();
+        let mut expected = magic_header();
+        expected.extend(wire(&first));
+        expected.extend(wire(&second));
+        let mut actual = vec![0; expected.len()];
+        peer.read_exact(&mut actual).await.unwrap();
+        assert_eq!(actual, expected);
+    }
+
+    #[tokio::test]
+    async fn close_and_stop_discard_pending_frame_and_release_the_only_stream() {
+        for stop in [false, true] {
+            let (mut transport, mut peer, gates) = fixture(true).await;
+            gates
+                .write_bytes
+                .store(magic_header().len() + 3, Ordering::SeqCst);
+            let first = packet("192.0.2.1:53", b"first");
+            assert!(futures_util::poll!(transport.send(first.clone())).is_pending());
+            if stop {
+                transport.cancellation.cancel();
+                assert!(transport.receive().await.is_err());
+            } else {
+                transport.close().await.unwrap();
+            }
+            assert!(transport.io.is_none() && transport.pending_write.is_none());
+            assert_eq!(gates.drops.load(Ordering::SeqCst), 1);
+            assert!(transport.send(first.clone()).await.is_err());
+            let mut actual = Vec::new();
+            peer.read_to_end(&mut actual).await.unwrap();
+            let mut expected = magic_header();
+            expected.extend_from_slice(&wire(&first)[..3]);
+            assert_eq!(
+                actual, expected,
+                "close must not append to an unfinished frame"
+            );
+            assert_eq!(gates.drops.load(Ordering::SeqCst), 1);
+        }
+    }
+
+    #[tokio::test]
+    async fn fragmented_response_keeps_parser_progress_after_cancellation() {
+        let first = packet("192.0.2.1:53", b"first");
+        let second = packet("198.51.100.1:54", b"second");
+        let mut response = vec![0, 0];
+        response.extend(wire(&second));
+        for split in [1, 3, response.len() - 1] {
+            let (mut transport, mut peer, _) = fixture(true).await;
+            transport.send(first.clone()).await.unwrap();
+            peer.write_all(&response[..split]).await.unwrap();
+            assert!(futures_util::poll!(transport.receive()).is_pending());
+            peer.write_all(&response[split..]).await.unwrap();
+            let actual = transport.receive().await.unwrap();
+            assert_eq!(actual.remote, second.remote);
+            assert_eq!(actual.payload, second.payload);
+        }
+    }
+}
diff --git a/src/outbound/vless/fingerprint_leg_tests.rs b/src/outbound/vless/fingerprint_leg_tests.rs
index 487dfed..b09254b 100644
--- a/src/outbound/vless/fingerprint_leg_tests.rs
+++ b/src/outbound/vless/fingerprint_leg_tests.rs
@@ -74,7 +74,7 @@ fn outbound(
     runtime: bool,
 ) -> VlessOutbound {
     let config = Config::parse_yaml(json!({
-        "port": 1080,
+        "mixed-port": 1080,
         "proxies": [{
             "name": "p", "type": "vless", "server": "192.0.2.1", "port": 443,
             "uuid": "07070707-0707-0707-0707-070707070707", "tls": true,
@@ -169,9 +169,9 @@ async fn selected_xhttp_legs_isolate_tickets_and_client_identities() {
     let upload_identity = identity();
     let download_identity = identity();
     for runtime in [false, true] {
-        for profile in ["chrome", "chrome120", "firefox", "safari"] {
+        for profile in ["chrome", "firefox", "safari", "ios"] {
             for variant in ["inherit", "different", "clear"] {
-                let other = if profile.starts_with("chrome") {
+                let other = if profile == "chrome" {
                     "firefox"
                 } else {
                     "chrome"
diff --git a/src/outbound/vless/outbound.rs b/src/outbound/vless/outbound.rs
index 7e604e8..24e2ee4 100644
--- a/src/outbound/vless/outbound.rs
+++ b/src/outbound/vless/outbound.rs
@@ -58,6 +58,83 @@ struct VlessTransportLeg {
     security: SecurityClient,
 }
 
+fn static_h2_security(config: &crate::config::SecurityConfig) -> bool {
+    match config {
+        crate::config::SecurityConfig::Jls(_) => true,
+        crate::config::SecurityConfig::Reality(_) => true,
+        crate::config::SecurityConfig::Tls(tls) => {
+            tls.identity
+                .as_ref()
+                .is_none_or(|identity| identity.origin.is_none())
+                && tls.ech.as_ref().is_none_or(|ech| !ech.is_dynamic())
+        }
+        _ => false,
+    }
+}
+
+impl VlessTransportLeg {
+    async fn h2_lease<'a>(
+        &self,
+        client: &'a XHttpClient,
+        context: &EstablishContext,
+    ) -> Result<(std::borrow::Cow<'a, XHttpClient>, Option<CancellationToken>), DispatchError> {
+        if !client.uses_active_h2_reuse() || context.captures_tcp_control() {
+            return Ok((client.h2_lease(false), None));
+        }
+        let Some(dialer) = self.upstream.static_h2_dialer(&self.server) else {
+            return Ok((client.h2_lease(false), None));
+        };
+        let cancellation = dialer.h2_reuse_cancellation();
+        let preflight = async {
+            dialer.validate_egress().map_err(DispatchError::from)?;
+            if tokio::time::Instant::now() >= context.deadline() {
+                return Err(DispatchError::TimedOut);
+            }
+            // Prepared Direct never used the resolver; preserve that contract.
+            let endpoint = match &self.upstream {
+                UpstreamPath::Direct { endpoint, .. } => endpoint.clone(),
+                _ => {
+                    context
+                        .resolution()
+                        .with_ip_version(dialer.ip_version())
+                        .with_physical_dialer(dialer)
+                        .resolve_proxy(&self.server, context.deadline())
+                        .await?
+                }
+            };
+            dialer
+                .validate_connected_endpoint(&endpoint)
+                .map_err(DispatchError::from)?;
+            if dialer
+                .ordered_connected_addresses(&endpoint.addresses)
+                .is_empty()
+            {
+                return Err(DispatchError::HostUnreachable);
+            }
+            Ok((client.h2_lease(true), Some(cancellation.clone())))
+        };
+        tokio::select! { biased;
+            () = cancellation.cancelled() => Err(h2_scope_closed()),
+            result = preflight => result,
+        }
+    }
+}
+
+fn h2_scope_closed() -> DispatchError {
+    io::Error::new(
+        io::ErrorKind::Interrupted,
+        "socket initialization cancelled",
+    )
+    .into()
+}
+
+async fn h2_scope_cancelled(scope: Option<&CancellationToken>) {
+    match scope {
+        Some(scope) => scope.cancelled().await,
+        None => std::future::pending().await,
+    }
+}
+
 impl std::fmt::Debug for VlessTransportLeg {
     fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         formatter
@@ -96,8 +173,7 @@ pub struct VlessOutbound {
     stream_options: crate::config::VlessStreamOptions,
     cancellation: CancellationToken,
     tasks: TaskTracker,
-    grpc_pool: crate::transport::GrpcPool,
-    sing_mux: Option<crate::transport::sing_mux::Pool>,
+    grpc_pool: Option<crate::transport::GrpcPool>,
     vision: bool,
     vision_stats: Arc<crate::security::vision::SpliceStats>,
 }
@@ -237,6 +313,35 @@ impl VlessOutbound {
         )
     }
 
+    /// Set immutable carrier context before publishing the node or using its pool.
+    #[cfg(any(feature = "invoke", test))]
+    pub(crate) fn configure_shared_xhttp_transport(
+        &mut self,
+        smux: Option<&crate::config::SingMuxConfig>,
+    ) {
+        let shared = self.encryption.is_none()
+            && self.download.is_none()
+            && smux.is_some_and(|options| {
+                options.enabled
+                    && options.protocol == crate::config::SingMuxProtocol::H2Mux
+                    && !options.only_tcp
+                    && !options.padding
+            });
+        if let Some(upload) = &mut self.xhttp {
+            upload.set_shared_packet_up_transport(shared);
+        }
+    }
+
+    #[cfg(test)]
+    pub(crate) fn test_xhttp_clients(&self) -> Option<(XHttpClient, Option<XHttpClient>)> {
+        self.xhttp.as_ref().map(|upload| {
+            (
+                upload.clone(),
+                self.download.as_ref().map(|leg| leg.xhttp.clone()),
+            )
+        })
+    }
+
     /// Builds a standard-TLS outbound with local interoperability-test roots.
     ///
     /// This constructor is absent from normal and release builds. It must only
@@ -282,6 +387,7 @@ impl VlessOutbound {
                 }
                 crate::config::SecurityConfig::Reality(_)
                 | crate::config::SecurityConfig::Jls(_)
+                | crate::config::SecurityConfig::ShadowTls(_)
                 | crate::config::SecurityConfig::None => {
                     SecurityClient::from_security(&download.security)
                 }
@@ -360,7 +466,7 @@ impl VlessOutbound {
             return Ok(None);
         };
         match primary {
-            UpstreamPath::Proxy(_) => Ok(Some(primary.clone())),
+            UpstreamPath::Proxy(_) | UpstreamPath::LazyDirect { .. } => Ok(Some(primary.clone())),
             UpstreamPath::Direct { endpoint, .. }
             | UpstreamPath::Group {
                 endpoint: Some(endpoint),
@@ -477,7 +583,11 @@ impl VlessOutbound {
                 ));
             }
         };
-        Ok(Self {
+        let transport = match &config.transport {
+            VlessTransport::Stream(transport) => transport.clone(),
+            VlessTransport::Xhttp(_) => StreamTransport::Tcp,
+        };
+        let mut outbound = Self {
             uuid: config.id,
             encryption,
             upload: VlessTransportLeg {
@@ -488,22 +598,49 @@ impl VlessOutbound {
             xhttp,
             download,
             encoding: config.packet_encoding,
-            transport: match &config.transport {
-                VlessTransport::Stream(transport) => transport.clone(),
-                VlessTransport::Xhttp(_) => StreamTransport::Tcp,
-            },
             cancellation: CancellationToken::new(),
             stream_options: config.stream_options.clone(),
             tasks: TaskTracker::new(),
-            grpc_pool: crate::transport::GrpcPool::new(config.stream_options.grpc.clone()),
-            sing_mux: config
-                .stream_options
-                .sing_mux
-                .clone()
-                .map(crate::transport::sing_mux::Pool::new),
+            grpc_pool: match &transport {
+                StreamTransport::Grpc { options, .. } => Some(
+                    crate::transport::GrpcPool::new_client_first(options.clone()),
+                ),
+                _ => None,
+            },
+            transport,
             vision: config.flow == "xtls-rprx-vision",
             vision_stats: Arc::default(),
-        })
+        };
+        let active_h2_pair = mode == XHttpMode::PacketUp
+            && static_h2_security(&config.security)
+            && config.xhttp().is_some_and(|settings| {
+                settings.http_version == crate::config::XHttpVersion::Http2
+            })
+            && config.download().is_some_and(|settings| {
+                settings.http_version == crate::config::XHttpVersion::Http2
+                    && static_h2_security(&settings.security)
+            });
+        if active_h2_pair {
+            if outbound
+                .upload
+                .upstream
+                .static_h2_dialer(&outbound.upload.server)
+                .is_some()
+                && let Some(client) = &mut outbound.xhttp
+            {
+                client.enable_active_h2_reuse();
+            }
+            if let Some(download) = &mut outbound.download
+                && download
+                    .transport
+                    .upstream
+                    .static_h2_dialer(&download.transport.server)
+                    .is_some()
+            {
+                download.xhttp.enable_active_h2_reuse();
+            }
+        }
+        Ok(outbound)
     }
 
     fn connect_transport<'a>(
@@ -515,51 +652,80 @@ impl VlessOutbound {
             let Some(xhttp) = &self.xhttp else {
                 return Self::connect_transport_leg(&self.upload, session, context).await;
             };
-            let upload = || {
-                let session = session.clone();
-                async move {
-                    Self::connect_xhttp_leg(&self.upload, xhttp.http_version(), session, context)
-                        .await
-                        .map_err(io::Error::other)
+            let (upload_client, upload_scope) = self.upload.h2_lease(xhttp, context).await?;
+            let xhttp = upload_client.as_ref();
+            let (download_client, download_scope) = match &self.download {
+                Some(download) => {
+                    let (client, scope) = download
+                        .transport
+                        .h2_lease(&download.xhttp, context)
+                        .await?;
+                    (Some(client), scope)
                 }
+                None => (None, None),
             };
-            let Some(download) = &self.download else {
+            let operation = async {
+                let upload = || {
+                    let session = session.clone();
+                    async move {
+                        Self::connect_xhttp_leg(
+                            &self.upload,
+                            xhttp.http_version(),
+                            session,
+                            context,
+                        )
+                        .await
+                        .map_err(io::Error::other)
+                    }
+                };
+                let Some(download) = &self.download else {
+                    let connected = context
+                        .run_io("VLESS XHTTP handshake", async {
+                            #[cfg(feature = "sing-mux")]
+                            if let Some(capture) = context.h3_udp_capture() {
+                                return xhttp
+                                    .open_transport_captured(context.deadline(), upload, capture)
+                                    .await;
+                            }
+                            xhttp.open_transport(context.deadline(), upload).await
+                        })
+                        .await?;
+                    tracing::debug!(stage = "xhttp", "VLESS transport stage completed");
+                    return Ok(connected);
+                };
+
+                let download_stream = || {
+                    let session = session.clone();
+                    async move {
+                        Self::connect_xhttp_leg(
+                            &download.transport,
+                            download.xhttp.http_version(),
+                            session,
+                            context,
+                        )
+                        .await
+                        .map_err(io::Error::other)
+                    }
+                };
                 let connected = context
                     .run_io(
                         "VLESS XHTTP handshake",
-                        xhttp.open_transport(context.deadline(), upload),
+                        xhttp.open_with_download_transports(
+                            context.deadline(),
+                            download_client.as_deref().expect("download client"),
+                            upload,
+                            download_stream,
+                        ),
                     )
                     .await?;
-                tracing::debug!(stage = "xhttp", "VLESS transport stage completed");
-                return Ok(connected);
-            };
-
-            let download_stream = || {
-                let session = session.clone();
-                async move {
-                    Self::connect_xhttp_leg(
-                        &download.transport,
-                        download.xhttp.http_version(),
-                        session,
-                        context,
-                    )
-                    .await
-                    .map_err(io::Error::other)
-                }
+                tracing::debug!(stage = "xhttp-split", "VLESS transport stage completed");
+                Ok(connected)
             };
-            let connected = context
-                .run_io(
-                    "VLESS XHTTP handshake",
-                    xhttp.open_with_download_transports(
-                        context.deadline(),
-                        &download.xhttp,
-                        upload,
-                        download_stream,
-                    ),
-                )
-                .await?;
-            tracing::debug!(stage = "xhttp-split", "VLESS transport stage completed");
-            Ok(connected)
+            tokio::select! { biased;
+                () = h2_scope_cancelled(upload_scope.as_ref()) => Err(h2_scope_closed()),
+                () = h2_scope_cancelled(download_scope.as_ref()) => Err(h2_scope_closed()),
+                result = operation => result,
+            }
         })
     }
 
@@ -580,8 +746,8 @@ impl VlessOutbound {
                     let (raw,control)=context.run_io("Vision TLS handshake",self.upload.security.connect_vision(raw,self.vision_stats.clone())).await?;
                     vision_control=Some(control);
                     (raw,StreamTransport::Tcp)
-                } else if let StreamTransport::Grpc{uri}=&self.transport {
-                    let io=self.grpc_pool.open(uri,context.deadline(),||async {
+                } else if let StreamTransport::Grpc{uri,..}=&self.transport {
+                    let io=self.grpc_pool.as_ref().expect("gRPC pool").open(uri,context.deadline(),||async {
                         self.connect_transport(session,context).await.map_err(io::Error::other)
                     }).await?;
                     (io,StreamTransport::Tcp)
@@ -632,7 +798,10 @@ impl VlessOutbound {
             .await?;
         tracing::debug!(stage = "upstream", "VLESS transport stage completed");
         let secured = context
-            .run_io("VLESS TLS/REALITY handshake", leg.security.connect(raw.io))
+            .run_io(
+                "VLESS TLS/REALITY handshake",
+                leg.security.connect_with_context(raw.io, context),
+            )
             .await?;
         tracing::debug!(stage = "security", "VLESS transport stage completed");
         Ok(secured)
@@ -660,8 +829,8 @@ impl VlessOutbound {
                     .await
                     .map(TransportIo::Stream);
             }
-            let (tls, server_name) = leg.security.quic_config()?;
-            let server = leg.upstream.datagram_server(&leg.server, context)?;
+            let (tls, server_name) = leg.security.quic_config_with_context(context).await?;
+            let server = leg.upstream.datagram_server(&leg.server, context).await?;
             let peer = context.resolve_ip(&server).await?;
             let budget = DatagramBudget::new(1400, 1400);
             let request =
@@ -690,6 +859,25 @@ pub(super) struct PreparedStream {
     pub(super) token: CancellationToken,
 }
 impl PreparedStream {
+    #[cfg(test)]
+    pub(super) fn for_memory_test(
+        raw: BoxStream,
+        deadline: tokio::time::Instant,
+        token: CancellationToken,
+    ) -> Self {
+        Self {
+            raw,
+            encryption: None,
+            id: uuid::Uuid::from_bytes([7; 16]),
+            transport: StreamTransport::Tcp,
+            options: Default::default(),
+            vision_control: None,
+            deadline,
+            tasks: TaskTracker::new(),
+            token,
+        }
+    }
+
     pub(super) async fn finish(
         self,
         command: VlessCommand,
@@ -750,11 +938,7 @@ impl PreparedStream {
                         header = bytes::Bytes::new();
                     }
                 }
-                StreamTransport::Grpc { uri } => {
-                    let connected = crate::transport::grpc(raw, uri, deadline).await?;
-                    raw = connected.0;
-                    driver = Some(connected.1);
-                }
+                StreamTransport::Grpc { .. } => unreachable!("gRPC opened during prepare"),
                 StreamTransport::H2 { uris } => {
                     let connected = crate::transport::legacy_h2(
                         raw,
@@ -811,22 +995,6 @@ impl OutboundConnector for VlessOutbound {
         context: &EstablishContext,
     ) -> Result<ConnectedStream, DispatchError> {
         let effective_peer = session.destination.clone();
-        if let Some(mux) = &self.sing_mux {
-            let io = mux
-                .open(&effective_peer, false, context.deadline(), || async {
-                    let target = crate::session::Destination::domain("sp.mux.sing-box.arpa", 444)?;
-                    let prepared = self
-                        .prepare(session, context)
-                        .await
-                        .map_err(io::Error::other)?;
-                    prepared
-                        .finish(VlessCommand::Tcp, Some(&target))
-                        .await
-                        .map_err(io::Error::other)
-                })
-                .await?;
-            return Ok(ConnectedStream { io, effective_peer });
-        }
         let prepared = self.prepare(session, context).await?;
         let io = prepared
             .finish(VlessCommand::Tcp, Some(&effective_peer))
@@ -838,42 +1006,10 @@ impl OutboundConnector for VlessOutbound {
         request: DatagramRequest,
         context: &EstablishContext,
     ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
-        if let Some(mux) = &self.sing_mux
-            && !mux.only_tcp()
-        {
-            let target = crate::session::Destination::domain("sp.mux.sing-box.arpa", 444)?;
-            let session = StreamSession {
-                inbound: request.session.inbound,
-                source: request.session.source,
-                destination: target.clone(),
-                sniffed_domain: None,
-            };
-            let io = mux
-                .open(&target, true, context.deadline(), || async {
-                    let prepared = self
-                        .prepare(session, context)
-                        .await
-                        .map_err(io::Error::other)?;
-                    prepared
-                        .finish(VlessCommand::Tcp, Some(&target))
-                        .await
-                        .map_err(io::Error::other)
-                })
-                .await?;
-            return Ok(crate::dispatch::bound_datagram(
-                Box::new(crate::transport::sing_mux::datagram::DatagramIo::new(
-                    io,
-                    request.budget(),
-                    context.resolution(),
-                    context.deadline(),
-                    self.cancellation.clone(),
-                )),
-                request.budget(),
-            ));
-        }
         let prepared = self
             .prepare(
                 StreamSession {
+                    metadata: request.session.metadata.clone(),
                     inbound: request.session.inbound,
                     source: request.session.source,
                     destination: self.upload.server.clone(),
@@ -885,11 +1021,31 @@ impl OutboundConnector for VlessOutbound {
         let transport: Box<dyn DatagramTransport> = if self.encoding == VlessPacketEncoding::Xudp {
             let mut io = prepared.finish(VlessCommand::Mux, None).await?;
             context.run_io("VLESS XUDP request", io.flush()).await?;
-            Box::new(XudpTransport::with_budget(io, [0; 8], request.budget()))
+            let transport = XudpTransport::with_budget(io, [0; 8], request.budget());
+            // Every XHTTP version independently drives accepted body writes
+            // through bounded queues. Per-frame flush would serialize XUDP
+            // packets into separate timer-delayed packet-up POSTs. Encryption
+            // may add a buffered writer, so retain its conservative contract.
+            Box::new(if self.encryption.is_none() && self.xhttp.is_some() {
+                transport.with_autonomous_writes()
+            } else {
+                transport
+            })
+        } else if self.encoding == VlessPacketEncoding::PacketAddr {
+            let transport = super::datagram::VlessDatagram::packet_addr(
+                prepared,
+                request.budget(),
+                context.resolution(),
+            )
+            .await?;
+            Box::new(if self.encryption.is_none() && self.xhttp.is_some() {
+                transport.with_autonomous_writes()
+            } else {
+                transport
+            })
         } else {
             Box::new(super::datagram::VlessDatagram::new(
                 prepared,
-                self.encoding == VlessPacketEncoding::PacketAddr,
                 request.budget(),
                 context.resolution(),
             ))
@@ -901,9 +1057,8 @@ impl OutboundConnector for VlessOutbound {
         if let Some(encryption) = &self.encryption {
             encryption.close();
         }
-        self.grpc_pool.begin_shutdown();
-        if let Some(mux) = &self.sing_mux {
-            mux.begin_stop();
+        if let Some(pool) = &self.grpc_pool {
+            pool.begin_shutdown();
         }
         if let Some(xhttp) = &self.xhttp {
             xhttp.begin_stop();
@@ -916,9 +1071,8 @@ impl OutboundConnector for VlessOutbound {
         self.begin_shutdown();
         self.tasks.close();
         self.tasks.wait().await;
-        self.grpc_pool.shutdown().await;
-        if let Some(mux) = &self.sing_mux {
-            mux.stop().await;
+        if let Some(pool) = &self.grpc_pool {
+            pool.shutdown().await;
         }
         if let Some(xhttp) = &self.xhttp {
             xhttp.stop().await;
@@ -1016,6 +1170,7 @@ mod connector_composition_tests {
 
     fn socks_config(address: &str) -> Socks5OutboundConfig {
         Socks5OutboundConfig {
+            tls: None,
             address: address.to_owned(),
             port: 1080,
             username: None,
@@ -1052,11 +1207,6 @@ mod connector_composition_tests {
 
     #[test]
     fn all_two_hop_protocol_combinations_build_as_connector_graphs() {
-        #[cfg(feature = "interop-test")]
-        let _case = crate::resources::case_events::Case::new(
-            "VLESS-REGRESSION",
-            "all_two_hop_protocol_combinations_build_as_connector_graphs",
-        );
         let physical: Arc<dyn OutboundConnector> = Arc::new(NeverConnector);
         let vless_leaf: Arc<dyn OutboundConnector> = Arc::new(
             VlessOutbound::new_with_upstream(&vless_config("vless-leaf.example"), physical.clone())
@@ -1102,11 +1252,6 @@ mod connector_composition_tests {
 
     #[test]
     fn direct_download_constructor_reuses_or_requires_the_precise_prepared_endpoint() {
-        #[cfg(feature = "interop-test")]
-        let _case = crate::resources::case_events::Case::new(
-            "VLESS-REGRESSION",
-            "direct_download_constructor_reuses_or_requires_the_precise_prepared_endpoint",
-        );
         let same = split_vless_config("same.example", "same.example", 443);
         let outbound =
             VlessOutbound::new(&same, endpoint("same.example", 443), Dialer::default()).unwrap();
@@ -1148,11 +1293,6 @@ mod connector_composition_tests {
 
     #[test]
     fn split_node_over_a_proxy_automatically_reuses_its_parent_for_both_legs() {
-        #[cfg(feature = "interop-test")]
-        let _case = crate::resources::case_events::Case::new(
-            "VLESS-REGRESSION",
-            "split_node_over_a_proxy_automatically_reuses_its_parent_for_both_legs",
-        );
         let parent: Arc<dyn OutboundConnector> = Arc::new(NeverConnector);
         let config = split_vless_config("upload.example", "download.example", 8443);
         let outbound = VlessOutbound::new_with_upstream(&config, parent).unwrap();
@@ -1167,3 +1307,396 @@ mod connector_composition_tests {
         assert!(Arc::ptr_eq(upload_parent, download_parent));
     }
 }
+
+#[cfg(test)]
+mod active_h2_memory_tests {
+    use super::*;
+    use std::{
+        collections::HashMap,
+        sync::{
+            Mutex,
+            atomic::{AtomicUsize, Ordering},
+        },
+        time::Duration,
+    };
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+    type Downloads = Arc<Mutex<HashMap<String, h2::SendStream<bytes::Bytes>>>>;
+
+    // Config -> production pool selection only. The memory peer below does
+    // not perform native REALITY authentication; real TUN verifies it separately.
+    fn with_static_reality(mut raw: serde_json::Value, reality: bool) -> serde_json::Value {
+        if reality {
+            raw["proxies"][0]["servername"] = serde_json::json!("memory.invalid");
+            raw["proxies"][0]["reality-opts"] = serde_json::json!({
+                "public-key": "BwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwc",
+                "short-id": "00"
+            });
+        }
+        raw
+    }
+
+    // The two physical legs share one synthetic handler, never a host socket.
+    async fn peer(
+        calls: &AtomicUsize,
+        tasks: &TaskTracker,
+        downloads: Downloads,
+        max_concurrent_streams: Option<u32>,
+    ) -> io::Result<BoxStream> {
+        calls.fetch_add(1, Ordering::Relaxed);
+        let (io, remote) = tokio::io::duplex(16384);
+        tasks.spawn(async move {
+            let mut builder = h2::server::Builder::new();
+            if let Some(maximum) = max_concurrent_streams {
+                builder.max_concurrent_streams(maximum);
+            }
+            let mut connection = builder.handshake(remote).await.unwrap();
+            let requests = TaskTracker::new();
+            while let Some(Ok((request, mut reply))) = connection.accept().await {
+                let path = request.uri().path().to_owned();
+                if request.method() == http::Method::GET {
+                    let mut body = reply.send_response(http::Response::new(()), false).unwrap();
+                    body.send_data(bytes::Bytes::from_static(b"ready"), false)
+                        .unwrap();
+                    downloads.lock().unwrap().insert(path, body);
+                } else {
+                    let downloads = downloads.clone();
+                    requests.spawn(async move {
+                        let session = path.rsplit_once('/').unwrap().0;
+                        let mut body = request.into_body();
+                        while let Some(Ok(data)) = body.data().await {
+                            body.flow_control().release_capacity(data.len()).unwrap();
+                            downloads
+                                .lock()
+                                .unwrap()
+                                .get_mut(session)
+                                .unwrap()
+                                .send_data(data, false)
+                                .unwrap();
+                        }
+                        reply.send_response(http::Response::new(()), true).unwrap();
+                    });
+                }
+            }
+            requests.close();
+            requests.wait().await;
+        });
+        Ok(Box::new(io))
+    }
+
+    // Apply only after the production scope helper; not part of the old-source RED.
+    #[cfg(all(target_os = "linux", feature = "sing-mux"))]
+    #[tokio::test]
+    async fn private_split_h2_control_fallback_and_dialer_stop_do_not_take_cached_sender() {
+        run_private_split_h2_control_case(false).await;
+    }
+
+    #[cfg(all(target_os = "linux", feature = "sing-mux"))]
+    #[tokio::test]
+    async fn private_split_h2_reality_control_fallback_and_dialer_stop_do_not_take_cached_sender() {
+        run_private_split_h2_control_case(true).await;
+    }
+
+    #[cfg(all(target_os = "linux", feature = "sing-mux"))]
+    async fn run_private_split_h2_control_case(reality: bool) {
+        tokio::time::timeout(Duration::from_secs(5), async {
+            let probe = crate::resources::observation::ResourceProbe::default();
+            let result = probe.scope(async {
+                let raw = serde_json::json!({"mixed-port":1080,"proxies":[{"name":"peer","type":"vless","server":"192.0.2.1","port":443,"uuid":"07070707-0707-0707-0707-070707070707","network":"xhttp","tls":true,"alpn":["h2"],"xhttp-opts":{"mode":"packet-up","path":"/x","download-settings":{"server":"192.0.2.2","path":"/x"}}}],"rules":["MATCH,peer"]});
+                let raw = with_static_reality(raw, reality);
+                let config = crate::config::Config::parse_yaml(raw.to_string().as_bytes()).unwrap();
+                let crate::config::ProxyProtocol::Vless(config) = &config.proxies[0].protocol else { unreachable!() };
+                let outbound = VlessOutbound::new_with_path(config, UpstreamPath::LazyDirect { dialer: Dialer::default() }).unwrap();
+                let client = outbound.xhttp.as_ref().unwrap();
+                let download = &outbound.download.as_ref().unwrap().xhttp;
+                let tasks = TaskTracker::new();
+                let uploads = AtomicUsize::new(0);
+                let downloads = AtomicUsize::new(0);
+                let handler: Downloads = Default::default();
+                let context = EstablishContext::default();
+                let (warm_client, _) = outbound.upload.h2_lease(client, &context).await.unwrap();
+                let mut warm = warm_client.open_with_download(context.deadline(), download,
+                    || peer(&uploads, &tasks, handler.clone(), None), || peer(&downloads, &tasks, handler.clone(), None)).await.unwrap();
+                let mut greeting = [0; 5];
+                warm.read_exact(&mut greeting).await.unwrap();
+                warm.write_all(b"prime").await.unwrap();
+                warm.flush().await.unwrap();
+                let mut prime = [0; 5];
+                warm.read_exact(&mut prime).await.unwrap();
+                let warm_count = (uploads.load(Ordering::Relaxed), downloads.load(Ordering::Relaxed));
+                let controlled = context.capture_tcp_control(crate::dialer::tcp_control::Capture::default());
+                let mut streams = Vec::new();
+                for _ in 0..2 {
+                    let (fresh, _) = outbound.upload.h2_lease(client, &controlled).await.unwrap();
+                    let mut stream = fresh.open_with_download(controlled.deadline(), download,
+                        || peer(&uploads, &tasks, handler.clone(), None), || peer(&downloads, &tasks, handler.clone(), None)).await.unwrap();
+                    stream.read_exact(&mut greeting).await.unwrap();
+                    streams.push(stream);
+                }
+                let fallback_count = (uploads.load(Ordering::Relaxed), downloads.load(Ordering::Relaxed));
+                let UpstreamPath::LazyDirect { dialer } = &outbound.upload.upstream else { unreachable!() };
+                dialer.begin_shutdown();
+                let attempt = async {
+                    let (leased, _) = outbound.upload.h2_lease(client, &context).await?;
+                    leased.open_with_download(context.deadline(), download,
+                        || peer(&uploads, &tasks, handler.clone(), None), || peer(&downloads, &tasks, handler.clone(), None)).await.map_err(DispatchError::from)
+                }.await;
+                let cancelled = matches!(attempt, Err(DispatchError::Other(message)) if message == "socket initialization cancelled");
+                let after_stop = (uploads.load(Ordering::Relaxed), downloads.load(Ordering::Relaxed));
+                let mut first = streams.remove(0);
+                first.shutdown().await.unwrap();
+                drop(first);
+                warm.write_all(b"alive").await.unwrap();
+                warm.flush().await.unwrap();
+                let mut echo = [0; 5];
+                warm.read_exact(&mut echo).await.unwrap();
+                outbound.shutdown().await;
+                let stopped = warm.read(&mut [0; 1]).await;
+                drop(warm);
+                drop(streams);
+                tasks.close();
+                tasks.wait().await;
+                (warm_count, fallback_count, after_stop, cancelled, greeting, prime, echo, stopped, probe.snapshot().is_idle())
+            }).await;
+            let (warm, fallback, after_stop, cancelled, greeting, prime, echo, stopped, idle) = result;
+            assert_eq!(&greeting, b"ready", "fallback H2 fixture failed");
+            assert_eq!(&prime, b"prime", "warm upload SETTINGS/POST fixture failed");
+            assert_eq!(&echo, b"alive", "fallback close or initializer Stop killed an established sibling");
+            assert!(matches!(stopped, Ok(0) | Err(_)) && idle, "node Stop did not release its fallback owners");
+            assert!(cancelled, "stopped Dialer took a cached H2 sender");
+            assert_eq!((warm, fallback, after_stop), ((1, 1), (3, 1), (3, 1)), "TCP-control acquisition reused a physical socket or stopped Dialer dialed again");
+        }).await.expect("fallback H2 owners did not stop");
+    }
+
+    #[tokio::test]
+    async fn private_split_h2_shares_four_active_leases_and_stops_both_legs() {
+        run_private_split_h2_share_case(false).await;
+    }
+
+    #[tokio::test]
+    async fn private_split_h2_reality_qualification_shares_four_active_leases_and_stops_both_legs()
+    {
+        run_private_split_h2_share_case(true).await;
+    }
+
+    async fn run_private_split_h2_share_case(reality: bool) {
+        tokio::time::timeout(Duration::from_secs(8), async {
+            // Explicit reuse is the existing control; omitted reuse is the new behavior.
+            for explicit in [true, false] {
+                let probe = crate::resources::observation::ResourceProbe::default();
+                let result = probe.scope(async {
+                    let mut options = serde_json::json!({"mode":"packet-up", "path":"/x", "download-settings":{"server":"192.0.2.2", "path":"/x"}});
+                    if explicit {
+                        let reuse = serde_json::json!({"max-concurrency":"4"});
+                        options["reuse-settings"] = reuse.clone();
+                        options["download-settings"]["reuse-settings"] = reuse;
+                    }
+                    let raw = serde_json::json!({"mixed-port":1080, "proxies":[{"name":"peer", "type":"vless", "server":"192.0.2.1", "port":443, "uuid":"07070707-0707-0707-0707-070707070707", "network":"xhttp", "tls":true, "alpn":["h2"], "xhttp-opts":options}], "rules":["MATCH,peer"]});
+                    let raw = with_static_reality(raw, reality);
+                    let config = crate::config::Config::parse_yaml(raw.to_string().as_bytes()).unwrap();
+                    let crate::config::ProxyProtocol::Vless(config) = &config.proxies[0].protocol else { unreachable!() };
+                    let outbound = VlessOutbound::new_with_path(config, UpstreamPath::LazyDirect { dialer: Dialer::default() }).unwrap();
+                    let client = outbound.xhttp.as_ref().unwrap();
+                    let download = &outbound.download.as_ref().unwrap().xhttp;
+                    let tasks = TaskTracker::new();
+                    let uploads = AtomicUsize::new(0);
+                    let downloads = AtomicUsize::new(0);
+                    let handler: Downloads = Default::default();
+                    let open = || client.open_with_download(
+                        tokio::time::Instant::now() + Duration::from_secs(2), download,
+                        || peer(&uploads, &tasks, handler.clone(), None),
+                        || peer(&downloads, &tasks, handler.clone(), None),
+                    );
+                    let count = || (uploads.load(Ordering::Relaxed), downloads.load(Ordering::Relaxed));
+                    let mut streams = Vec::new();
+                    let mut four = (0, 0);
+                    for index in 0..5 {
+                        let mut stream = open().await.unwrap();
+                        let mut greeting = [0; 5];
+                        stream.read_exact(&mut greeting).await.unwrap();
+                        assert_eq!(&greeting, b"ready", "synthetic H2 peer fixture failed");
+                        if index == 0 {
+                            // Negotiate both physical legs before expecting warm sharing.
+                            stream.write_all(b"prime").await.unwrap();
+                            stream.flush().await.unwrap();
+                            let mut echo = [0; 5];
+                            stream.read_exact(&mut echo).await.unwrap();
+                            assert_eq!(&echo, b"prime", "two-leg priming fixture failed");
+                        }
+                        streams.push(stream);
+                        if index == 3 { four = count(); }
+                    }
+                    let five = count();
+                    let mut first = streams.remove(0);
+                    first.shutdown().await.unwrap();
+                    drop(first);
+                    streams[0].write_all(b"alive").await.unwrap();
+                    streams[0].flush().await.unwrap();
+                    let mut echo = [0; 5];
+                    streams[0].read_exact(&mut echo).await.unwrap();
+                    for stream in &mut streams { stream.shutdown().await.unwrap(); }
+                    drop(streams);
+                    let mut fresh = open().await.unwrap();
+                    let mut greeting = [0; 5];
+                    fresh.read_exact(&mut greeting).await.unwrap();
+                    let after_idle = count();
+                    outbound.shutdown().await;
+                    let stopped = fresh.read(&mut [0; 1]).await;
+                    drop(fresh);
+                    tasks.close();
+                    tasks.wait().await;
+                    (four, five, after_idle, echo, greeting, stopped, probe.snapshot().is_idle())
+                }).await;
+                let (four, five, after_idle, echo, greeting, stopped, idle) = result;
+                assert_eq!(&echo, b"alive", "closing one request killed its sibling");
+                assert_eq!(&greeting, b"ready", "fresh physical handshake fixture failed");
+                assert!(matches!(stopped, Ok(0) | Err(_)), "Stop left a readable logical stream");
+                assert!(idle, "Stop did not join both private H2 owners");
+                let expected_idle = if explicit { (2, 2) } else { (3, 3) };
+                assert_eq!((four, five, after_idle), ((1, 1), (2, 2), expected_idle), "private split H2 must share four active leases; explicit={explicit}");
+            }
+        }).await.expect("memory H2 owners did not stop");
+    }
+
+    #[tokio::test]
+    async fn private_split_h2_peer_stream_credit_opens_new_download_physicals() {
+        run_private_split_h2_peer_credit_case(false).await;
+    }
+
+    #[tokio::test]
+    async fn private_split_h2_reality_peer_stream_credit_opens_new_download_physicals() {
+        run_private_split_h2_peer_credit_case(true).await;
+    }
+
+    async fn run_private_split_h2_peer_credit_case(reality: bool) {
+        let probe = crate::resources::observation::ResourceProbe::default();
+        let (business, before_stop, idle) = probe
+            .scope(async {
+                let raw = serde_json::json!({
+                    "mixed-port":1080,
+                    "proxies":[{"name":"peer","type":"vless","server":"192.0.2.1",
+                        "port":443,"uuid":"07070707-0707-0707-0707-070707070707",
+                        "network":"xhttp","tls":true,"alpn":["h2"],
+                        "xhttp-opts":{"mode":"packet-up","path":"/x",
+                            "download-settings":{"server":"192.0.2.2","path":"/x"}}}],
+                    "rules":["MATCH,peer"]
+                });
+                let raw = with_static_reality(raw, reality);
+                let config = crate::config::Config::parse_yaml(raw.to_string().as_bytes()).unwrap();
+                let crate::config::ProxyProtocol::Vless(config) = &config.proxies[0].protocol
+                else {
+                    unreachable!()
+                };
+                let outbound = VlessOutbound::new_with_path(
+                    config,
+                    UpstreamPath::LazyDirect {
+                        dialer: Dialer::default(),
+                    },
+                )
+                .unwrap();
+                let client = outbound.xhttp.as_ref().unwrap();
+                let download = &outbound.download.as_ref().unwrap().xhttp;
+                let tasks = TaskTracker::new();
+                let uploads = AtomicUsize::new(0);
+                let downloads = AtomicUsize::new(0);
+                let handler: Downloads = Default::default();
+                let open = || {
+                    client.open_with_download(
+                        tokio::time::Instant::now() + Duration::from_secs(2),
+                        download,
+                        || peer(&uploads, &tasks, handler.clone(), None),
+                        || peer(&downloads, &tasks, handler.clone(), Some(1)),
+                    )
+                };
+                let count = || {
+                    (
+                        uploads.load(Ordering::Relaxed),
+                        downloads.load(Ordering::Relaxed),
+                    )
+                };
+                let mut streams = Vec::new();
+                // The deadline is only a broken-fixture fail-safe, never the RED oracle.
+                let business = tokio::time::timeout(Duration::from_secs(3), async {
+                    let mut first = open().await?;
+                    let mut greeting = [0; 5];
+                    first.read_exact(&mut greeting).await?;
+                    if &greeting != b"ready" {
+                        return Err(io::Error::other("first physical H2 fixture was not ready"));
+                    }
+                    // Prime the upload leg too, not only the download GET: initial
+                    // private credit=1 may still be correct until its SETTINGS arrives.
+                    first.write_all(b"prime").await?;
+                    first.flush().await?;
+                    let mut primed = [0; 5];
+                    first.read_exact(&mut primed).await?;
+                    if &primed != b"prime" {
+                        return Err(io::Error::other("two-leg priming fixture failed"));
+                    }
+                    // Keep this GET active while both later logical opens are attempted.
+                    streams.push(first);
+                    let mut open_errors = Vec::new();
+                    for _ in 0..2 {
+                        match open().await {
+                            Ok(stream) => streams.push(stream),
+                            Err(error) => open_errors.push((error.kind(), error.to_string())),
+                        }
+                    }
+                    let observed = count();
+                    streams[0].write_all(b"alive").await?;
+                    streams[0].flush().await?;
+                    let mut sibling_echo = [0; 5];
+                    streams[0].read_exact(&mut sibling_echo).await?;
+                    let mut verified_extra = 0;
+                    // Old code already has a non-time-based RED: wrong factory count.
+                    // Do not wait for its queued GETs behind the intentionally long first GET.
+                    if observed == (1, 3) && streams.len() == 3 {
+                        for stream in streams.iter_mut().skip(1) {
+                            let mut greeting = [0; 5];
+                            stream.read_exact(&mut greeting).await?;
+                            if &greeting != b"ready" {
+                                return Err(io::Error::other("new physical H2 greeting differs"));
+                            }
+                            stream.write_all(b"extra").await?;
+                            stream.flush().await?;
+                            let mut echo = [0; 5];
+                            stream.read_exact(&mut echo).await?;
+                            if &echo != b"extra" {
+                                return Err(io::Error::other("new physical H2 echo differs"));
+                            }
+                            verified_extra += 1;
+                        }
+                    }
+                    Ok::<_, io::Error>((observed, open_errors, sibling_echo, verified_extra))
+                })
+                .await;
+                let before_stop = count();
+                // This runs for I/O failure and deadline expiry too, before assertions.
+                outbound.shutdown().await;
+                drop(streams);
+                handler.lock().unwrap().clear();
+                tasks.close();
+                tasks.wait().await;
+                (business, before_stop, probe.snapshot().is_idle())
+            })
+            .await;
+        assert!(
+            idle,
+            "Stop did not join peer/physical owners; factories={before_stop:?}"
+        );
+        let business = business.expect("fixture timed out: not a valid factory-count RED");
+        let (observed, open_errors, sibling_echo, verified_extra) =
+            business.expect("fixture/first-sibling I/O failed: not a valid count RED");
+        assert_eq!(&sibling_echo, b"alive", "existing sibling stopped echoing");
+        assert_eq!(
+            observed,
+            (1, 3),
+            "peer MAX_CONCURRENT_STREAMS=1 must select new download physicals; \
+             before_stop={before_stop:?}; open_errors={open_errors:?}"
+        );
+        assert!(
+            open_errors.is_empty(),
+            "logical opens failed: {open_errors:?}"
+        );
+        assert_eq!(verified_extra, 2, "new physicals did not both deliver/echo");
+    }
+}
diff --git a/src/outbound/vless/vision.rs b/src/outbound/vless/vision.rs
index ca1f200..f10c770 100644
--- a/src/outbound/vless/vision.rs
+++ b/src/outbound/vless/vision.rs
@@ -275,10 +275,6 @@ mod tests {
 
     #[tokio::test]
     async fn vision_fragmented_headers_content_padding_and_cancelled_reads_keep_raw_tail() {
-        let _case = crate::resources::case_events::Case::new(
-            "VLESS-UNIT",
-            "vision_fragmented_headers_content_padding_and_cancelled_reads_keep_raw_tail",
-        );
         let mut wire = frame(true, 0, b"abc", 7);
         wire.extend(frame(false, 2, b"def", 3));
         wire.extend(b"raw-tail");
@@ -305,10 +301,6 @@ mod tests {
 
     #[tokio::test]
     async fn vision_invalid_uuid_command_and_truncation_poison_the_stream() {
-        let _case = crate::resources::case_events::Case::new(
-            "VLESS-UNIT",
-            "vision_invalid_uuid_command_and_truncation_poison_the_stream",
-        );
         let good = frame(true, 0, b"content", 4);
         let mut invalid_uuid = good.clone();
         invalid_uuid[0] ^= 1;
@@ -334,10 +326,6 @@ mod tests {
 
     #[tokio::test]
     async fn vision_bounded_partial_writes_flush_and_close_preserve_all_plaintext() {
-        let _case = crate::resources::case_events::Case::new(
-            "VLESS-UNIT",
-            "vision_bounded_partial_writes_flush_and_close_preserve_all_plaintext",
-        );
         let (io, mut peer) = tokio::io::duplex(31);
         let mut stream = VisionStream::new(
             Box::new(io),
diff --git a/src/outbound/vless/vision_filter.rs b/src/outbound/vless/vision_filter.rs
index 8af79f0..11fb6bd 100644
--- a/src/outbound/vless/vision_filter.rs
+++ b/src/outbound/vless/vision_filter.rs
@@ -159,10 +159,6 @@ mod tests {
     }
     #[test]
     fn fragmented_server_hello_distinguishes_tls12_tls13_and_non_tls() {
-        let _case = crate::resources::case_events::Case::new(
-            "VLESS-UNIT",
-            "fragmented_server_hello_distinguishes_tls12_tls13_and_non_tls",
-        );
         for tls13 in [false, true] {
             for chunk in [1, 3, 8192] {
                 let mut filter = Filter::default();
diff --git a/src/outbound/vmess/crypto.rs b/src/outbound/vmess/crypto.rs
index 4292b78..a8183bf 100644
--- a/src/outbound/vmess/crypto.rs
+++ b/src/outbound/vmess/crypto.rs
@@ -94,11 +94,6 @@ mod tests {
     use super::*;
     #[test]
     fn independently_published_nested_hmac_vectors() {
-        #[cfg(feature = "interop-test")]
-        let _evidence = crate::resources::case_events::Case::new(
-            "VMESS-CODEC",
-            "independently_published_nested_hmac_vectors",
-        );
         assert_eq!(
             kdf(b"test", &[b"AES Auth ID Encryption"]),
             [
diff --git a/src/outbound/vmess/datagram.rs b/src/outbound/vmess/datagram.rs
index ad21a3c..abd3d64 100644
--- a/src/outbound/vmess/datagram.rs
+++ b/src/outbound/vmess/datagram.rs
@@ -1,4 +1,7 @@
-use std::io;
+use std::{
+    io,
+    task::{Context, Poll, ready},
+};
 
 use super::{MAX_PACKET_BYTES, VmessStream};
 use crate::{
@@ -57,6 +60,10 @@ impl VmessDatagram {
 
 #[async_trait]
 impl DatagramTransport for VmessDatagram {
+    fn supports_shared_destinations(&self) -> bool {
+        matches!(self.encoding, Encoding::PacketAddr(_)) && self.stream.is_some()
+    }
+
     fn payload_budget(&self, peer: &Destination) -> DatagramBudget {
         let overhead = match (&self.encoding, peer) {
             (Encoding::Raw(_), _) => 0,
@@ -103,21 +110,32 @@ impl DatagramTransport for VmessDatagram {
         Ok(())
     }
 
-    async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+    fn supports_poll_receive(&self) -> bool {
+        true
+    }
+
+    fn poll_receive(
+        &mut self,
+        context: &mut Context<'_>,
+        _scratch: &mut Vec<u8>,
+    ) -> Poll<Result<Datagram, DispatchError>> {
         self.check()?;
-        let mut discarded = 0;
-        loop {
-            let received = self
-                .stream
-                .as_mut()
-                .expect("checked open")
-                .receive_packet()
-                .await;
+        for _ in 0..crate::limits::IO_POLL_BUDGET {
+            let received = ready!(
+                self.stream
+                    .as_mut()
+                    .expect("checked open")
+                    .poll_packet(context)
+            );
             let packet = match received {
-                Ok(packet) => packet,
+                Ok(Some(packet)) => packet,
+                Ok(None) => {
+                    self.stream.take();
+                    return Poll::Ready(Err(io::Error::from(io::ErrorKind::UnexpectedEof).into()));
+                }
                 Err(error) => {
                     self.stream.take();
-                    return Err(error.into());
+                    return Poll::Ready(Err(error.into()));
                 }
             };
             let (remote, consumed) = match &self.encoding {
@@ -126,24 +144,26 @@ impl DatagramTransport for VmessDatagram {
                     Ok(address) => address,
                     Err(error) => {
                         self.stream.take();
-                        return Err(error.into());
+                        return Poll::Ready(Err(error.into()));
                     }
                 },
             };
             let payload = packet.slice(consumed..);
             if payload.len() <= usize::from(self.payload_budget(&remote).receive()) {
-                return Ok(Datagram {
+                return Poll::Ready(Ok(Datagram {
                     remote,
                     payload,
                     sniffed_domain: None,
-                });
-            }
-            discarded += 1;
-            if discarded == crate::limits::IO_POLL_BUDGET {
-                tokio::task::yield_now().await;
-                discarded = 0;
+                }));
             }
         }
+        context.waker().wake_by_ref();
+        Poll::Pending
+    }
+
+    async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+        let mut scratch = Vec::new();
+        std::future::poll_fn(|context| self.poll_receive(context, &mut scratch)).await
     }
 
     async fn close(&mut self) -> Result<(), DispatchError> {
diff --git a/src/outbound/vmess/header.rs b/src/outbound/vmess/header.rs
index 5f2cd4b..b5415ca 100644
--- a/src/outbound/vmess/header.rs
+++ b/src/outbound/vmess/header.rs
@@ -215,3 +215,483 @@ impl ClientHandshake {
         )
     }
 }
+
+#[cfg(test)]
+mod datagram_memory_tests {
+    use super::*;
+    use crate::{
+        dispatch::{DatagramBudget, DatagramTransport},
+        dns::resolution::ResolutionContext,
+        outbound::{
+            address::encode_packet_addr,
+            vmess::{VmessDatagram, VmessStream},
+        },
+        session::Datagram,
+    };
+    use bytes::Bytes;
+    use tokio::io::{AsyncReadExt, AsyncWriteExt, DuplexStream};
+
+    fn fixture(capacity: usize, packetaddr: bool) -> (VmessDatagram, DuplexStream, Vec<u8>) {
+        fixture_with_cipher(capacity, packetaddr, BodyCipher::None)
+    }
+
+    fn fixture_with_cipher(
+        capacity: usize,
+        packetaddr: bool,
+        cipher: BodyCipher,
+    ) -> (VmessDatagram, DuplexStream, Vec<u8>) {
+        let peer = Destination::Ip("192.0.2.1:53".parse().unwrap());
+        let handshake = ClientHandshake::new(
+            &VmessIdentity::new(uuid::Uuid::from_bytes([7; 16])),
+            Command::Udp,
+            &peer,
+            BodyOptions::new(cipher, false, false).unwrap(),
+        )
+        .unwrap();
+        // Body encryption is independent of this genuine authenticated VMess
+        // response header; Body None must authenticate the header too.
+        let mut response = Vec::new();
+        for (mut data, key_salt, iv_salt) in [
+            (
+                4u16.to_be_bytes().to_vec(),
+                b"AEAD Resp Header Len Key".as_slice(),
+                b"AEAD Resp Header Len IV".as_slice(),
+            ),
+            (
+                vec![handshake.response_tag, 0, 0, 0],
+                b"AEAD Resp Header Key".as_slice(),
+                b"AEAD Resp Header IV".as_slice(),
+            ),
+        ] {
+            let key = kdf(&handshake.response_key, &[key_salt]);
+            let iv = kdf(&handshake.response_iv, &[iv_salt]);
+            seal(
+                &aead_key(BodyCipher::Aes128Gcm, key[..16].try_into().unwrap()),
+                iv[..12].try_into().unwrap(),
+                &[],
+                &mut data,
+            )
+            .unwrap();
+            response.extend_from_slice(&data);
+        }
+        let (io, peer_io) = tokio::io::duplex(capacity);
+        let stream = VmessStream::new(Box::new(io), handshake);
+        let budget = DatagramBudget::new(128, 128);
+        let datagram = if packetaddr {
+            VmessDatagram::packet_addr(stream, budget, ResolutionContext::default())
+        } else {
+            VmessDatagram::raw(stream, peer, budget)
+        };
+        (datagram, peer_io, response)
+    }
+
+    fn packet(remote: Destination, payload: &'static [u8]) -> Datagram {
+        Datagram {
+            remote,
+            payload: Bytes::from_static(payload),
+            sniffed_domain: None,
+        }
+    }
+
+    #[tokio::test]
+    async fn vmess_packetaddr_memory_shares_multiple_targets_and_preserves_reply_addresses() {
+        let (mut client, mut peer, response) = fixture(1024, true);
+        assert!(client.supports_shared_destinations());
+        let targets = [
+            Destination::Ip("192.0.2.1:53".parse().unwrap()),
+            Destination::Ip("[2001:db8::2]:443".parse().unwrap()),
+        ];
+        peer.write_all(&response).await.unwrap();
+        for target in targets {
+            let datagram = packet(target.clone(), b"target-specific payload");
+            client.send(datagram.clone()).await.unwrap();
+            let mut expected = BytesMut::new();
+            encode_packet_addr(&target, &mut expected).unwrap();
+            expected.extend_from_slice(&datagram.payload);
+            let length = peer.read_u16().await.unwrap();
+            let mut body = vec![0; usize::from(length)];
+            peer.read_exact(&mut body).await.unwrap();
+            assert_eq!(body, expected);
+            peer.write_u16(length).await.unwrap();
+            peer.write_all(&body).await.unwrap();
+            let reply = client.receive().await.unwrap();
+            assert_eq!(reply.remote, target);
+            assert_eq!(reply.payload, datagram.payload);
+        }
+        client.close().await.unwrap();
+        assert_eq!(
+            peer.read_u8().await.unwrap_err().kind(),
+            io::ErrorKind::UnexpectedEof
+        );
+        assert!(client.receive().await.is_err());
+    }
+
+    #[tokio::test]
+    async fn vmess_raw_memory_keeps_fixed_target_without_poisoning_valid_send() {
+        let (mut client, mut peer, response) = fixture(1024, false);
+        assert!(!client.supports_shared_destinations());
+        let target = Destination::Ip("192.0.2.1:53".parse().unwrap());
+        assert!(
+            client
+                .send(packet(
+                    Destination::Ip("192.0.2.2:53".parse().unwrap()),
+                    b"wrong target"
+                ))
+                .await
+                .is_err()
+        );
+        client
+            .send(packet(target.clone(), b"fixed target"))
+            .await
+            .unwrap();
+        let length = peer.read_u16().await.unwrap();
+        let mut body = vec![0; usize::from(length)];
+        peer.read_exact(&mut body).await.unwrap();
+        assert_eq!(body, b"fixed target");
+        peer.write_all(&response).await.unwrap();
+        peer.write_u16(length).await.unwrap();
+        peer.write_all(&body).await.unwrap();
+        let reply = client.receive().await.unwrap();
+        assert_eq!(reply.remote, target);
+        assert_eq!(reply.payload, body);
+        client.close().await.unwrap();
+    }
+
+    #[tokio::test]
+    async fn vmess_datagram_memory_cancelled_partial_send_closes_each_encoding() {
+        for cipher in [
+            BodyCipher::Auto,
+            BodyCipher::None,
+            BodyCipher::Aes128Gcm,
+            BodyCipher::Chacha20Poly1305,
+        ] {
+            for packetaddr in [false, true] {
+                let (mut client, mut peer, _) = fixture_with_cipher(1, packetaddr, cipher);
+                assert_eq!(
+                    client.supports_shared_destinations(),
+                    packetaddr,
+                    "packetaddr={packetaddr}, cipher={cipher:?}",
+                );
+                {
+                    let sending = client.send(packet(
+                        Destination::Ip("192.0.2.1:53".parse().unwrap()),
+                        b"partial payload",
+                    ));
+                    tokio::pin!(sending);
+                    assert!(futures_util::poll!(sending.as_mut()).is_pending());
+                }
+                let mut partial = Vec::new();
+                peer.read_to_end(&mut partial).await.unwrap();
+                assert_eq!(partial.len(), 1);
+                assert!(
+                    client
+                        .send(packet(
+                            Destination::Ip("192.0.2.1:53".parse().unwrap()),
+                            b"must not replay"
+                        ))
+                        .await
+                        .is_err()
+                );
+                assert!(client.receive().await.is_err());
+                client.close().await.unwrap();
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod delayed_response_memory_tests {
+    use super::*;
+    use crate::outbound::vmess::VmessStream;
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+    #[derive(serde::Deserialize)]
+    struct OfficialVector {
+        cipher: String,
+        alter_id: u32,
+        global_padding: bool,
+        authenticated_length: bool,
+        request: Vec<u8>,
+        request_key: [u8; 16],
+        request_iv: [u8; 16],
+        response_tag: u8,
+        response: Vec<u8>,
+        payload: Vec<u8>,
+        response_empty_before_first_server_write: bool,
+        official_client_response_roundtrip: bool,
+    }
+
+    fn fixture() -> (ClientHandshake, OfficialVector) {
+        let vector: OfficialVector = serde_json::from_str(include_str!(
+            "../../../tests/fixtures/vmess-delayed-response.json"
+        ))
+        .unwrap();
+        assert_eq!(vector.cipher, "aes-128-gcm");
+        assert_eq!(vector.alter_id, 0);
+        assert!(!vector.global_padding && !vector.authenticated_length);
+        assert!(vector.response_empty_before_first_server_write);
+        assert!(vector.official_client_response_roundtrip);
+        assert!(vector.response.len() > 38 && !vector.payload.is_empty());
+        // The actual official client/Service produced and independently decoded
+        // these synthetic bytes. Core's normal response authenticator/body
+        // codec consumes them; no replacement AsyncRead parser is used.
+        let handshake = ClientHandshake {
+            request: vector.request.clone(),
+            key: vector.request_key,
+            iv: vector.request_iv,
+            response_key: Sha256::digest(vector.request_key)[..16].try_into().unwrap(),
+            response_iv: Sha256::digest(vector.request_iv)[..16].try_into().unwrap(),
+            response_tag: vector.response_tag,
+            options: BodyOptions::new(BodyCipher::Aes128Gcm, false, false).unwrap(),
+            command: Command::Tcp,
+        };
+        (handshake, vector)
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn vmess_committed_request_accepts_official_response_after_setup_deadline() {
+        let (handshake, vector) = fixture();
+        let (mut raw, mut peer) = tokio::io::duplex(4096);
+        // This is the real call-site contract: the complete request prefix was
+        // successfully written and flushed before business IO was returned.
+        raw.write_all(handshake.request()).await.unwrap();
+        raw.flush().await.unwrap();
+        let mut request = vec![0; handshake.request().len()];
+        peer.read_exact(&mut request).await.unwrap();
+        assert_eq!(request, vector.request);
+        let stream = VmessStream::new(Box::new(raw), handshake);
+        let (mut reader, mut writer) = tokio::io::split(stream);
+        writer
+            .write_all(b"upload before delayed response")
+            .await
+            .unwrap();
+        writer.flush().await.unwrap();
+        let mut reply = vec![0; vector.payload.len()];
+        {
+            let pending = reader.read_exact(&mut reply);
+            tokio::pin!(pending);
+            assert!(futures_util::poll!(pending.as_mut()).is_pending());
+            tokio::time::advance(std::time::Duration::from_secs(11)).await;
+            assert!(
+                futures_util::poll!(pending.as_mut()).is_pending(),
+                "submitted request cannot expire while a one-way upload legitimately has no response header"
+            );
+            writer
+                .write_all(b"upload continues after setup deadline")
+                .await
+                .unwrap();
+            writer.flush().await.unwrap();
+            peer.write_all(&vector.response).await.unwrap();
+            pending.await.unwrap();
+        }
+        assert_eq!(reply, vector.payload);
+        drop(reader);
+        drop(writer);
+        let mut remaining_upload = Vec::new();
+        peer.read_to_end(&mut remaining_upload).await.unwrap();
+        assert!(!remaining_upload.is_empty());
+    }
+
+    async fn expect_committed_http_request(peer: &mut tokio::io::DuplexStream, request: &[u8]) {
+        let mut head = Vec::new();
+        while !head.ends_with(b"\r\n\r\n") {
+            head.push(peer.read_u8().await.unwrap());
+        }
+        assert!(
+            String::from_utf8(head)
+                .unwrap()
+                .contains(&format!("content-length: {}\r\n", request.len()))
+        );
+        let mut prefix = vec![0; request.len()];
+        peer.read_exact(&mut prefix).await.unwrap();
+        assert_eq!(prefix, request);
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn vmess_committed_http_request_accepts_official_response_after_setup_deadline() {
+        use crate::transport::{HttpObfsOptions, http_obfs};
+        use std::task::Poll;
+        use tokio::time::{Duration, Instant};
+
+        let (handshake, vector) = fixture();
+        let (raw, mut peer) = tokio::io::duplex(4096);
+        let options = HttpObfsOptions::new(
+            http::Method::GET,
+            "http://fixture.invalid/cover",
+            Default::default(),
+        )
+        .unwrap();
+        let deadline = Instant::now() + Duration::from_secs(10);
+        let transport = http_obfs(Box::new(raw), &options, handshake.request(), deadline)
+            .await
+            .unwrap();
+
+        // Observe the real HTTP header and complete authenticated request before
+        // advancing the clock. An unread or partial request is not this case.
+        expect_committed_http_request(&mut peer, &vector.request).await;
+
+        let stream = VmessStream::new(transport, handshake).with_whole_close();
+        let (mut reader, mut writer) = tokio::io::split(stream);
+        let before = b"upload before delayed HTTP response";
+        writer.write_all(before).await.unwrap();
+        writer.flush().await.unwrap();
+        // The fixture is AES-GCM, without padding or authenticated lengths:
+        // consume its actual two-byte length and tag-bearing encoded record.
+        let mut uploaded = vec![0; before.len() + 2 + 16];
+        peer.read_exact(&mut uploaded).await.unwrap();
+
+        let mut reply = vec![0; vector.payload.len()];
+        let mut pending = Box::pin(reader.read_exact(&mut reply));
+        assert!(futures_util::poll!(pending.as_mut()).is_pending());
+        tokio::time::advance(Duration::from_secs(11)).await;
+        let after_deadline = futures_util::poll!(pending.as_mut());
+        let remained_pending = after_deadline.is_pending();
+        let result = match after_deadline {
+            Poll::Ready(result) => result,
+            Poll::Pending => {
+                let after = b"upload continues after setup deadline";
+                writer.write_all(after).await.unwrap();
+                writer.flush().await.unwrap();
+                uploaded.resize(after.len() + 2 + 16, 0);
+                peer.read_exact(&mut uploaded).await.unwrap();
+                peer.write_all(
+                    b"HTTP/1.1 200 OK\r\nContent-Type: application/octet-stream\r\n\r\n",
+                )
+                .await
+                .unwrap();
+                peer.write_all(&vector.response).await.unwrap();
+                pending.as_mut().await
+            }
+        };
+        drop(pending);
+
+        // Clean up both outcomes before asserting the regression. Old code
+        // must report TimedOut here, rather than hanging the fixture or relying
+        // on a task abort to make its peer disappear.
+        let closed = writer.shutdown().await;
+        drop(reader);
+        drop(writer);
+        let mut byte = [0; 1];
+        let peer_eof = tokio::time::timeout(Duration::from_secs(1), peer.read(&mut byte))
+            .await
+            .unwrap()
+            .unwrap();
+        assert_eq!(peer_eof, 0);
+        assert!(
+            remained_pending,
+            "committed HTTP request expired before the peer's first response: {:?}",
+            result.as_ref().err().map(std::io::Error::kind)
+        );
+        result.unwrap();
+        assert_eq!(reply, vector.payload);
+        closed.unwrap();
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn vmess_committed_http_response_wait_is_cancelled_by_node_stop() {
+        use crate::{
+            outbound::owned_stream::OwnedStream,
+            transport::{HttpObfsOptions, http_obfs},
+        };
+        use std::{
+            future::Future,
+            sync::{
+                Arc,
+                atomic::{AtomicUsize, Ordering},
+            },
+            task::{Context, Wake, Waker},
+        };
+        use tokio::time::{Duration, Instant};
+        use tokio_util::sync::CancellationToken;
+
+        #[derive(Default)]
+        struct ReaderWake(AtomicUsize);
+        impl Wake for ReaderWake {
+            fn wake(self: Arc<Self>) {
+                self.0.fetch_add(1, Ordering::SeqCst);
+            }
+            fn wake_by_ref(self: &Arc<Self>) {
+                self.0.fetch_add(1, Ordering::SeqCst);
+            }
+        }
+
+        let (handshake, vector) = fixture();
+        let (raw, mut peer) = tokio::io::duplex(4096);
+        let node = CancellationToken::new();
+        let owned = OwnedStream::new(Box::new(raw), node.clone());
+        let options = HttpObfsOptions::new(
+            http::Method::GET,
+            "http://fixture.invalid/cover",
+            Default::default(),
+        )
+        .unwrap();
+        let transport = http_obfs(
+            Box::new(owned),
+            &options,
+            handshake.request(),
+            Instant::now() + Duration::from_secs(10),
+        )
+        .await
+        .unwrap();
+        expect_committed_http_request(&mut peer, &vector.request).await;
+        let mut stream = VmessStream::new(transport, handshake).with_whole_close();
+        let mut pending = Box::pin(stream.read_u8());
+        let reader_wake = Arc::new(ReaderWake::default());
+        let waker = Waker::from(reader_wake.clone());
+        let mut context = Context::from_waker(&waker);
+        assert!(pending.as_mut().poll(&mut context).is_pending());
+        tokio::time::advance(Duration::from_secs(11)).await;
+        let waiting = pending.as_mut().poll(&mut context).is_pending();
+        reader_wake.0.store(0, Ordering::SeqCst);
+        node.cancel();
+        let reader_woken = reader_wake.0.load(Ordering::SeqCst) > 0;
+        let cancelled = tokio::time::timeout(Duration::from_secs(1), pending.as_mut()).await;
+        drop(pending);
+        // Verify cancellation released the physical IO while its outer
+        // VmessStream remains alive; dropping it must not create this EOF.
+        let peer_eof = tokio::time::timeout(Duration::from_secs(1), peer.read(&mut [0; 1])).await;
+        drop(stream);
+        assert_eq!(peer_eof.unwrap().unwrap(), 0);
+        assert!(
+            reader_woken,
+            "node Stop did not wake the pending HTTP reader"
+        );
+        assert!(
+            waiting,
+            "committed response wait still used the setup deadline"
+        );
+        assert_eq!(
+            cancelled.unwrap().unwrap_err().kind(),
+            io::ErrorKind::ConnectionAborted
+        );
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn vmess_delayed_official_response_still_authenticates_before_delivery() {
+        let (handshake, mut vector) = fixture();
+        let (mut raw, mut peer) = tokio::io::duplex(4096);
+        raw.write_all(handshake.request()).await.unwrap();
+        raw.flush().await.unwrap();
+        let mut request = vec![0; handshake.request().len()];
+        peer.read_exact(&mut request).await.unwrap();
+        assert_eq!(request, vector.request);
+        let mut stream = VmessStream::new(Box::new(raw), handshake);
+        tokio::time::advance(std::time::Duration::from_secs(11)).await;
+        // Alter the actual response header's AEAD tag, preserving all lengths.
+        vector.response[17] ^= 1;
+        peer.write_all(&vector.response).await.unwrap();
+        let mut reply = [0; 128];
+        assert_eq!(
+            stream.read(&mut reply).await.unwrap_err().kind(),
+            io::ErrorKind::InvalidData
+        );
+        assert!(reply.iter().all(|byte| *byte == 0));
+        assert!(
+            stream
+                .write_all(b"cannot continue after authentication failure")
+                .await
+                .is_err()
+        );
+        assert_eq!(peer.read(&mut [0; 1]).await.unwrap(), 0);
+    }
+}
diff --git a/src/outbound/vmess/mod.rs b/src/outbound/vmess/mod.rs
index bda5159..eb857e9 100644
--- a/src/outbound/vmess/mod.rs
+++ b/src/outbound/vmess/mod.rs
@@ -76,11 +76,6 @@ mod tests {
     use super::*;
     #[test]
     fn auto_uses_detected_hardware_not_architecture_name() {
-        #[cfg(feature = "interop-test")]
-        let _evidence = crate::resources::case_events::Case::new(
-            "VMESS-CODEC",
-            "auto_uses_detected_hardware_not_architecture_name",
-        );
         assert_eq!(
             BodyCipher::Auto.with_aes_hardware(true),
             BodyCipher::Aes128Gcm
diff --git a/src/outbound/vmess/outbound.rs b/src/outbound/vmess/outbound.rs
index a124833..8e8ed4a 100644
--- a/src/outbound/vmess/outbound.rs
+++ b/src/outbound/vmess/outbound.rs
@@ -10,17 +10,23 @@ use crate::{
         owned_stream::OwnedStream, server_destination,
     },
     resources::observation::{self, ResourceKind},
-    security::{
-        SecurityContext, StandardTlsClient, TLS_RESUMPTION_SESSION_BUDGET, TlsCertificatePolicy,
-        TlsClientOptions,
-    },
+    security::{SecurityClient, SecurityContext, TLS_RESUMPTION_SESSION_BUDGET},
     session::{Datagram, Destination, StreamSession},
-    transport::{connect_websocket, grpc, http_obfs, legacy_h2},
+    transport::{GrpcPool, connect_websocket, http_obfs, legacy_h2},
 };
 use async_trait::async_trait;
-use std::{io, sync::Arc};
+use std::{
+    future::Future,
+    io,
+    pin::Pin,
+    sync::{Arc, Mutex},
+    task::{Context, Poll, Waker},
+};
 use tokio::{io::AsyncWriteExt, time::Instant};
-use tokio_util::{sync::CancellationToken, task::TaskTracker};
+use tokio_util::{
+    sync::{CancellationToken, WaitForCancellationFutureOwned},
+    task::TaskTracker,
+};
 
 struct SessionOptions {
     identity: VmessIdentity,
@@ -31,11 +37,13 @@ struct SessionOptions {
 pub struct VmessOutbound {
     server: Destination,
     upstream: UpstreamPath,
-    tls: Option<StandardTlsClient>,
+    security: SecurityClient,
     options: Arc<SessionOptions>,
     encoding: VmessPacketEncoding,
+    grpc_pool: Option<GrpcPool>,
     cancellation: CancellationToken,
     tasks: TaskTracker,
+    driver_admission: Arc<Mutex<()>>,
 }
 
 impl std::fmt::Debug for VmessOutbound {
@@ -67,43 +75,50 @@ impl VmessOutbound {
             VmessCipher::Chacha20Poly1305 => BodyCipher::Chacha20Poly1305,
             VmessCipher::None => BodyCipher::None,
         };
-        let tls = config
-            .tls
-            .as_ref()
-            .map(|tls| {
-                StandardTlsClient::with_options(
-                    security,
-                    &config.server_name,
-                    TlsClientOptions {
-                        client_fingerprint: tls.client_fingerprint,
-                        alpn: tls.alpn.clone(),
-                        required_alpn: config.transport.required_alpn().map(<[u8]>::to_vec),
-                        certificate: TlsCertificatePolicy {
-                            skip_cert_verify: tls.skip_cert_verify,
-                            fingerprint: tls.fingerprint,
-                            ..Default::default()
-                        },
-                        ..Default::default()
-                    },
-                    sessions,
-                    buffer,
-                )
-            })
-            .transpose()?;
+        let security = SecurityClient::from_security_with_context(
+            &config.security,
+            security,
+            sessions,
+            buffer,
+        )?;
         Ok(Self {
             server: server_destination(&config.address, config.port)?,
             upstream,
-            tls,
+            security,
             options: Arc::new(SessionOptions {
                 identity: VmessIdentity::new(config.id),
                 body: BodyOptions::new(cipher, config.global_padding, config.authenticated_length)?,
                 transport: config.transport.clone(),
             }),
             encoding: config.packet_encoding,
+            grpc_pool: match &config.transport {
+                VmessTransport::Grpc { options, .. } => {
+                    Some(GrpcPool::new_client_first(options.clone()))
+                }
+                _ => None,
+            },
             cancellation: CancellationToken::new(),
             tasks: TaskTracker::new(),
+            driver_admission: Arc::new(Mutex::new(())),
         })
     }
+    async fn connect_transport(
+        &self,
+        session: StreamSession,
+        context: &EstablishContext,
+    ) -> Result<BoxStream, DispatchError> {
+        let raw = self
+            .upstream
+            .connect_server(session, &self.server, context)
+            .await?
+            .io;
+        context
+            .run_io(
+                "VMess transport handshake",
+                self.security.connect_with_context(raw, context),
+            )
+            .await
+    }
     async fn prepare(
         &self,
         session: StreamSession,
@@ -115,10 +130,13 @@ impl VmessOutbound {
         tokio::select! { biased;
             ()=self.cancellation.cancelled()=>Err(DispatchError::NotAllowed),
             result=async {
-                let raw=self.upstream.connect_server(session,&self.server,context).await?.io;
-                let raw=if let Some(tls)=&self.tls { context.run_io("VMess TLS handshake",tls.connect(raw)).await? } else {raw};
+                let raw=if let VmessTransport::Grpc { uri, .. }=&self.options.transport {
+                    self.grpc_pool.as_ref().expect("gRPC pool").open(uri,context.deadline(),||async {
+                        self.connect_transport(session,context).await.map_err(io::Error::other)
+                    }).await?
+                } else { self.connect_transport(session,context).await? };
                 let token=self.cancellation.child_token();
-                Ok(PreparedStream { raw:Box::new(OwnedStream::new(raw,token.clone())),options:self.options.clone(),deadline:context.deadline(),tasks:self.tasks.clone(),token })
+                Ok(PreparedStream { raw:Box::new(OwnedStream::new(raw,token.clone())),options:self.options.clone(),deadline:context.deadline(),tasks:self.tasks.clone(),token,driver_admission:self.driver_admission.clone() })
             }=>result,
         }
     }
@@ -130,6 +148,7 @@ struct PreparedStream {
     deadline: Instant,
     tasks: TaskTracker,
     token: CancellationToken,
+    driver_admission: Arc<Mutex<()>>,
 }
 impl PreparedStream {
     async fn finish(
@@ -181,11 +200,9 @@ impl PreparedStream {
                     .await?;
                     sent = true;
                 }
-                VmessTransport::Grpc { uri } => {
-                    let connected = grpc(raw, uri, deadline).await?;
-                    raw = connected.0;
-                    driver = Some(connected.1);
-                }
+                // prepare already opened this logical gRPC stream. Authentication
+                // is fresh here, without wrapping or dialing the transport again.
+                VmessTransport::Grpc { .. } => {}
                 VmessTransport::H2 { uris } => {
                     let uri = &uris[rand::random_range(0..uris.len())];
                     let connected = legacy_h2(raw, uri, deadline).await?;
@@ -196,11 +213,27 @@ impl PreparedStream {
             if let Some(driver) = driver {
                 let token = self.token.clone();
                 let observation = observation::track(ResourceKind::Task);
-                self.tasks.spawn(observation::bind(async move {
+                let task = observation::bind(async move {
                     let _observation = observation;
                     token.cancelled().await;
                     let _ = driver.stop().await;
-                }));
+                });
+                let unregistered = {
+                    let _admission = self
+                        .driver_admission
+                        .lock()
+                        .unwrap_or_else(std::sync::PoisonError::into_inner);
+                    if self.token.is_cancelled() {
+                        Some(task)
+                    } else {
+                        self.tasks.spawn(task);
+                        None
+                    }
+                };
+                if let Some(task) = unregistered {
+                    task.await;
+                    return Err(io::ErrorKind::ConnectionAborted.into());
+                }
             }
             // Dropping setup after a partial header must also stop an H2 driver.
             let guard = self.token.clone().drop_guard();
@@ -208,7 +241,9 @@ impl PreparedStream {
                 raw.write_all(handshake.request()).await?;
                 raw.flush().await?;
             }
-            let stream = VmessStream::new(raw, handshake, deadline);
+            // Complete request submission uses the setup deadline. A peer can
+            // send its response header with the first application reply.
+            let stream = VmessStream::new(raw, handshake);
             guard.disarm();
             Ok::<_, io::Error>(if whole_close {
                 stream.with_whole_close()
@@ -244,6 +279,7 @@ impl OutboundConnector for VmessOutbound {
         context: &EstablishContext,
     ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
         let session = StreamSession {
+            metadata: request.session.metadata.clone(),
             inbound: request.session.inbound,
             source: request.session.source,
             destination: self.server.clone(),
@@ -284,22 +320,28 @@ impl OutboundConnector for VmessOutbound {
             (None, Some(inner))
         };
         Ok(crate::dispatch::bound_datagram(
-            Box::new(SessionDatagram {
-                pending,
-                inner,
-                budget,
-                token,
-            }),
+            Box::new(SessionDatagram::new(pending, inner, budget, token)),
             request.budget(),
         ))
     }
     fn begin_shutdown(&self) {
+        let _admission = self
+            .driver_admission
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
         self.cancellation.cancel();
+        self.tasks.close();
+        if let Some(pool) = &self.grpc_pool {
+            pool.begin_shutdown();
+        }
     }
     async fn shutdown(&self) {
         self.begin_shutdown();
         self.tasks.close();
         self.tasks.wait().await;
+        if let Some(pool) = &self.grpc_pool {
+            pool.shutdown().await;
+        }
     }
 }
 impl Drop for VmessOutbound {
@@ -313,6 +355,33 @@ struct SessionDatagram {
     inner: Option<Box<dyn DatagramTransport>>,
     budget: DatagramBudget,
     token: CancellationToken,
+    read_cancel: Option<Pin<Box<WaitForCancellationFutureOwned>>>,
+    pending_reader: Option<Waker>,
+}
+impl SessionDatagram {
+    fn new(
+        pending: Option<PreparedStream>,
+        inner: Option<Box<dyn DatagramTransport>>,
+        budget: DatagramBudget,
+        token: CancellationToken,
+    ) -> Self {
+        // Keep one read-only cancellation registration for the whole polled
+        // session: OwnedStream's registration can be replaced by a writer waker.
+        // Lazy raw must advertise this capability before installing its inner.
+        let polled = pending.is_some()
+            || inner
+                .as_ref()
+                .is_some_and(|inner| inner.supports_poll_receive());
+        let read_cancel = polled.then(|| Box::pin(token.clone().cancelled_owned()));
+        Self {
+            pending,
+            inner,
+            budget,
+            token,
+            read_cancel,
+            pending_reader: None,
+        }
+    }
 }
 impl Drop for SessionDatagram {
     fn drop(&mut self) {
@@ -321,6 +390,49 @@ impl Drop for SessionDatagram {
 }
 #[async_trait]
 impl DatagramTransport for SessionDatagram {
+    fn supports_poll_receive(&self) -> bool {
+        self.read_cancel.is_some()
+    }
+
+    fn poll_receive(
+        &mut self,
+        context: &mut Context<'_>,
+        scratch: &mut Vec<u8>,
+    ) -> Poll<Result<Datagram, DispatchError>> {
+        let cancelled = self.token.is_cancelled()
+            || self
+                .read_cancel
+                .as_mut()
+                .is_some_and(|cancelled| cancelled.as_mut().poll(context).is_ready());
+        if cancelled {
+            self.pending.take();
+            self.inner.take();
+            self.read_cancel.take();
+            self.pending_reader.take();
+            return Poll::Ready(Err(DispatchError::NotAllowed));
+        }
+        if self.pending.is_some() {
+            if self
+                .pending_reader
+                .as_ref()
+                .is_none_or(|reader| !reader.will_wake(context.waker()))
+            {
+                self.pending_reader = Some(context.waker().clone());
+            }
+            return Poll::Pending;
+        }
+        match self.inner.as_mut() {
+            Some(inner) => inner.poll_receive(context, scratch),
+            None => Poll::Ready(Err(DispatchError::NotAllowed)),
+        }
+    }
+
+    fn supports_shared_destinations(&self) -> bool {
+        self.inner
+            .as_ref()
+            .is_some_and(|inner| inner.supports_shared_destinations())
+    }
+
     fn payload_budget(&self, peer: &Destination) -> DatagramBudget {
         self.inner.as_ref().map_or(self.budget, |inner| {
             self.budget.intersect(inner.payload_budget(peer))
@@ -334,7 +446,7 @@ impl DatagramTransport for SessionDatagram {
         {
             return Err(io::Error::from(io::ErrorKind::InvalidInput).into());
         }
-        tokio::select! {biased;
+        let result = tokio::select! {biased;
             ()=self.token.cancelled()=>Err(DispatchError::NotAllowed),
             result=async {
                 if let Some(prepared)=self.pending.take() {
@@ -343,9 +455,21 @@ impl DatagramTransport for SessionDatagram {
                 }
                 self.inner.as_mut().ok_or(DispatchError::NotAllowed)?.send(datagram).await
             }=>result,
+        };
+        // Wake a reader waiting for lazy raw setup, but retain the independent
+        // read cancellation waiter across every later read/write handoff.
+        if result.is_ok()
+            && let Some(reader) = self.pending_reader.take()
+        {
+            reader.wake();
         }
+        result
     }
     async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+        if self.supports_poll_receive() {
+            let mut scratch = Vec::new();
+            return std::future::poll_fn(|context| self.poll_receive(context, &mut scratch)).await;
+        }
         let pending = self.pending.is_some();
         let inner = &mut self.inner;
         tokio::select! {biased;
@@ -360,6 +484,247 @@ impl DatagramTransport for SessionDatagram {
         self.token.cancel();
         self.pending.take();
         self.inner.take();
+        self.read_cancel.take();
+        if let Some(reader) = self.pending_reader.take() {
+            reader.wake();
+        }
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod polled_datagram_memory_tests {
+    use super::*;
+    use bytes::Bytes;
+    use futures_util::task::{ArcWake, waker};
+    use std::{
+        sync::atomic::{AtomicUsize, Ordering},
+        time::Duration,
+    };
+    use tokio::io::{AsyncReadExt, DuplexStream};
+
+    #[derive(Default)]
+    struct WakeCount(AtomicUsize);
+    impl ArcWake for WakeCount {
+        fn wake_by_ref(owner: &Arc<Self>) {
+            owner.0.fetch_add(1, Ordering::Relaxed);
+        }
+    }
+
+    fn prepared(capacity: usize) -> (PreparedStream, DuplexStream, CancellationToken) {
+        prepared_with_cipher(capacity, BodyCipher::None)
+    }
+
+    fn prepared_with_cipher(
+        capacity: usize,
+        cipher: BodyCipher,
+    ) -> (PreparedStream, DuplexStream, CancellationToken) {
+        let (raw, peer) = tokio::io::duplex(capacity);
+        // Match the node -> physical session hierarchy; the routing flow's
+        // cancellation is deliberately a different token in the test below.
+        let node = CancellationToken::new();
+        let token = node.child_token();
+        let prepared = PreparedStream {
+            raw: Box::new(OwnedStream::new(Box::new(raw), token.clone())),
+            options: Arc::new(SessionOptions {
+                identity: VmessIdentity::new(uuid::Uuid::from_bytes([7; 16])),
+                body: BodyOptions::new(cipher, false, false).unwrap(),
+                transport: VmessTransport::Tcp,
+            }),
+            deadline: Instant::now() + Duration::from_secs(10),
+            tasks: TaskTracker::new(),
+            token,
+            driver_admission: Arc::new(Mutex::new(())),
+        };
+        (prepared, peer, node)
+    }
+
+    fn pending_raw(capacity: usize) -> (SessionDatagram, DuplexStream, CancellationToken) {
+        let (prepared, peer, node) = prepared(capacity);
+        let token = prepared.token.clone();
+        (
+            SessionDatagram::new(Some(prepared), None, DatagramBudget::new(128, 128), token),
+            peer,
+            node,
+        )
+    }
+
+    async fn installed_packetaddr(
+        cipher: BodyCipher,
+    ) -> (SessionDatagram, DuplexStream, CancellationToken) {
+        let (prepared, peer, node) = prepared_with_cipher(4096, cipher);
+        let token = prepared.token.clone();
+        let budget = DatagramBudget::new(128, 128);
+        let stream = prepared
+            .finish(
+                Command::Udp,
+                &Destination::domain("sp.packet-addr.v2fly.arpa", 443).unwrap(),
+            )
+            .await
+            .unwrap();
+        let inner = VmessDatagram::packet_addr(
+            stream,
+            budget,
+            crate::dns::resolution::ResolutionContext::default(),
+        );
+        (
+            SessionDatagram::new(None, Some(Box::new(inner)), budget, token),
+            peer,
+            node,
+        )
+    }
+
+    fn packet() -> Datagram {
+        Datagram {
+            remote: Destination::Ip("192.0.2.1:53".parse().unwrap()),
+            payload: Bytes::from_static(b"one application datagram"),
+            sniffed_domain: None,
+        }
+    }
+
+    #[tokio::test]
+    async fn vmess_polled_receive_keeps_reader_wake_after_write_and_node_cancellation() {
+        for (packetaddr, cipher) in [
+            (false, BodyCipher::None),
+            (true, BodyCipher::None),
+            (true, BodyCipher::Aes128Gcm),
+            (true, BodyCipher::Chacha20Poly1305),
+        ] {
+            let (mut transport, mut peer, node) = if packetaddr {
+                installed_packetaddr(cipher).await
+            } else {
+                pending_raw(4096)
+            };
+            let reader = Arc::new(WakeCount::default());
+            let writer = Arc::new(WakeCount::default());
+            let reader_wake = waker(reader.clone());
+            let writer_wake = waker(writer.clone());
+            let mut scratch = Vec::new();
+            assert!(transport.supports_poll_receive());
+            assert_eq!(transport.supports_shared_destinations(), packetaddr);
+            if !packetaddr {
+                // A lazy raw association is polled before its authenticated
+                // destination exists, and must wake its latest reader on setup.
+                let stale = Arc::new(WakeCount::default());
+                let stale_wake = waker(stale.clone());
+                assert!(
+                    transport
+                        .poll_receive(&mut Context::from_waker(&stale_wake), &mut scratch,)
+                        .is_pending()
+                );
+                assert!(
+                    transport
+                        .poll_receive(&mut Context::from_waker(&reader_wake), &mut scratch,)
+                        .is_pending()
+                );
+                let count = reader.0.load(Ordering::Relaxed);
+                transport.send(packet()).await.unwrap();
+                assert!(
+                    reader.0.load(Ordering::Relaxed) > count,
+                    "first committed raw send must wake the latest reader"
+                );
+                assert_eq!(stale.0.load(Ordering::Relaxed), 0);
+            }
+            // ReadyQueue also listens to an independent flow/connection token.
+            // Node cancellation must wake the read key without cancelling it.
+            let flow = CancellationToken::new();
+            let mut flow_cancelled = Box::pin(flow.clone().cancelled_owned());
+            assert!(
+                flow_cancelled
+                    .as_mut()
+                    .poll(&mut Context::from_waker(&reader_wake),)
+                    .is_pending()
+            );
+            assert!(
+                transport
+                    .poll_receive(&mut Context::from_waker(&reader_wake), &mut scratch,)
+                    .is_pending()
+            );
+            let read_count = reader.0.load(Ordering::Relaxed);
+            // This is a subsequent normal send for raw, and a normal packetaddr
+            // send after installation. Both replace OwnedStream's read waker.
+            {
+                let mut sending = Box::pin(transport.send(packet()));
+                assert!(matches!(
+                    sending
+                        .as_mut()
+                        .poll(&mut Context::from_waker(&writer_wake),),
+                    Poll::Ready(Ok(()))
+                ));
+            }
+            assert_eq!(reader.0.load(Ordering::Relaxed), read_count);
+            let write_count = writer.0.load(Ordering::Relaxed);
+            node.cancel();
+            assert!(
+                reader.0.load(Ordering::Relaxed) > read_count,
+                "normal send must not steal the read key's node-cancel wake"
+            );
+            assert!(
+                writer.0.load(Ordering::Relaxed) > write_count,
+                "the lower OwnedStream waiter should hold the writer waker"
+            );
+            assert!(
+                !flow.is_cancelled(),
+                "flow cancellation must not rescue this wake"
+            );
+            assert!(
+                flow_cancelled
+                    .as_mut()
+                    .poll(&mut Context::from_waker(&reader_wake),)
+                    .is_pending()
+            );
+            assert!(matches!(
+                transport.poll_receive(&mut Context::from_waker(&reader_wake), &mut scratch,),
+                Poll::Ready(Err(_))
+            ));
+            let mut submitted = Vec::new();
+            tokio::time::timeout(Duration::from_secs(1), peer.read_to_end(&mut submitted))
+                .await
+                .unwrap()
+                .unwrap();
+            assert!(!submitted.is_empty());
+            transport.close().await.unwrap();
+        }
+    }
+
+    #[tokio::test]
+    async fn vmess_raw_polled_receive_survives_cancelled_pending_or_partial_first_send() {
+        for partial in [false, true] {
+            let (mut transport, mut peer, node) = pending_raw(1);
+            let owner = Arc::new(WakeCount::default());
+            let wake = waker(owner.clone());
+            let mut scratch = Vec::new();
+            assert!(
+                transport
+                    .poll_receive(&mut Context::from_waker(&wake), &mut scratch,)
+                    .is_pending()
+            );
+            if partial {
+                let sending = transport.send(packet());
+                tokio::pin!(sending);
+                assert!(futures_util::poll!(sending.as_mut()).is_pending());
+            } else {
+                node.cancel();
+            }
+            assert!(
+                owner.0.load(Ordering::Relaxed) > 0,
+                "pending reader lost cancellation wake"
+            );
+            assert!(matches!(
+                transport.poll_receive(&mut Context::from_waker(&wake), &mut scratch,),
+                Poll::Ready(Err(_))
+            ));
+            assert!(
+                transport.send(packet()).await.is_err(),
+                "partial first request must not replay"
+            );
+            let mut submitted = Vec::new();
+            tokio::time::timeout(Duration::from_secs(1), peer.read_to_end(&mut submitted))
+                .await
+                .unwrap()
+                .unwrap();
+            assert_eq!(submitted.len(), usize::from(partial));
+            transport.close().await.unwrap();
+        }
+    }
+}
diff --git a/src/outbound/vmess/stream.rs b/src/outbound/vmess/stream.rs
index 6240568..95cbaf9 100644
--- a/src/outbound/vmess/stream.rs
+++ b/src/outbound/vmess/stream.rs
@@ -7,15 +7,11 @@ use bytes::{Buf, Bytes, BytesMut};
 use ring::aead;
 use shake::{ExtendableOutput, Shake128, Update, XofReader};
 use std::{
-    future::Future,
     io,
     pin::Pin,
     task::{Context, Poll, ready},
 };
-use tokio::{
-    io::{AsyncRead, AsyncWrite, ReadBuf},
-    time::{Instant, Sleep},
-};
+use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
 
 pub const MAX_BODY_WIRE: usize = 16 * 1024;
 // Keep TCP chunks within the native Mihomo listener's initial copy buffer.
@@ -31,9 +27,9 @@ struct BodyCodec {
     iv: [u8; 16],
     length_iv: [u8; 16],
     body: aead::LessSafeKey,
-    length: aead::LessSafeKey,
+    length: Option<Box<aead::LessSafeKey>>,
     mask: shake::Shake128Reader,
-    counter: u32,
+    counter: u16,
     framed: bool,
     write_limit: usize,
 }
@@ -49,13 +45,18 @@ impl BodyCodec {
     ) -> Self {
         let mut mask = Shake128::default();
         mask.update(&iv);
-        let length_key = kdf(request_key, &[b"auth_len"]);
+        // Most streams do not authenticate lengths. Keep that expanded key
+        // out of each direction's resident codec unless it is actually used.
+        let length = options.authenticated_length.then(|| {
+            let key = kdf(request_key, &[b"auth_len"]);
+            Box::new(aead_key(options.cipher, key[..16].try_into().unwrap()))
+        });
         Self {
             options,
             iv,
             length_iv: request_iv,
             body: aead_key(options.cipher, key),
-            length: aead_key(options.cipher, length_key[..16].try_into().unwrap()),
+            length,
             mask: mask.finalize_xof(),
             counter: 0,
             framed: options.cipher != BodyCipher::None || command == Command::Udp,
@@ -80,14 +81,12 @@ impl BodyCodec {
             2
         }
     }
-    fn nonce(&self, iv: &[u8; 16]) -> io::Result<[u8; 12]> {
-        // The wire counter is only 16 bits. Never reuse a nonce under the same
-        // key: an exhausted encrypted session must be re-established by caller.
-        let counter = u16::try_from(self.counter)
-            .map_err(|_| io::Error::other("VMess nonce sequence exhausted"))?;
+    fn nonce(&self, iv: &[u8; 16]) -> [u8; 12] {
+        // Match Mihomo/sing-vmess and V2Ray's 16-bit wire counter. VMess
+        // does not negotiate a larger counter or rekey at the wrap boundary.
         let mut nonce: [u8; 12] = iv[..12].try_into().unwrap();
-        nonce[..2].copy_from_slice(&counter.to_be_bytes());
-        Ok(nonce)
+        nonce[..2].copy_from_slice(&self.counter.to_be_bytes());
+        nonce
     }
     fn next_mask(&mut self) -> u16 {
         let mut bytes = [0; 2];
@@ -114,17 +113,12 @@ impl BodyCodec {
         let padding = self.padding();
         let mut body = plain.to_vec();
         if self.overhead() != 0 {
-            seal(&self.body, self.nonce(&self.iv)?, &[], &mut body)?;
+            seal(&self.body, self.nonce(&self.iv), &[], &mut body)?;
         }
         let mut length = (body.len() + padding) as u16;
-        let mut wire = if self.options.authenticated_length {
+        let mut wire = if let Some(key) = self.length.as_deref() {
             let mut encoded = (length - 16).to_be_bytes().to_vec();
-            seal(
-                &self.length,
-                self.nonce(&self.length_iv)?,
-                &[],
-                &mut encoded,
-            )?;
+            seal(key, self.nonce(&self.length_iv), &[], &mut encoded)?;
             encoded
         } else {
             if self.options.cipher != BodyCipher::None {
@@ -136,13 +130,13 @@ impl BodyCodec {
         let start = wire.len();
         wire.resize(start + padding, 0);
         random(&mut wire[start..])?;
-        self.counter += 1;
+        self.counter = self.counter.wrapping_add(1);
         Ok(wire.into())
     }
     fn decode_length(&mut self, wire: &mut [u8]) -> io::Result<(usize, usize)> {
         let padding = self.padding();
-        let length = if self.options.authenticated_length {
-            let plain = open(&self.length, self.nonce(&self.length_iv)?, &[], wire)?;
+        let length = if let Some(key) = self.length.as_deref() {
+            let plain = open(key, self.nonce(&self.length_iv), &[], wire)?;
             usize::from(u16::from_be_bytes(plain.try_into().map_err(|_| error())?)) + 16
         } else {
             let mut length = u16::from_be_bytes(wire.try_into().map_err(|_| error())?);
@@ -159,10 +153,10 @@ impl BodyCodec {
     fn decode_body(&mut self, mut wire: BytesMut, padding: usize) -> io::Result<Bytes> {
         wire.truncate(wire.len().checked_sub(padding).ok_or_else(error)?);
         if self.overhead() != 0 {
-            let length = open(&self.body, self.nonce(&self.iv)?, &[], &mut wire)?.len();
+            let length = open(&self.body, self.nonce(&self.iv), &[], &mut wire)?.len();
             wire.truncate(length);
         }
-        self.counter += 1;
+        self.counter = self.counter.wrapping_add(1);
         Ok(wire.freeze())
     }
 }
@@ -175,13 +169,13 @@ enum ReadStage {
     Eof,
 }
 
-/// Bounded, cancellation-safe framed IO. The caller writes `handshake.request()`
-/// before wrapping (including WS early data). Response authentication is lazy so
-/// both server-first and client-first protocols work; it shares setup's deadline.
+/// Bounded, cancellation-safe framed IO after the caller has written and
+/// flushed `handshake.request()` (including WS early data) within setup's
+/// deadline. Response authentication is lazy and does not expire active business
+/// IO while a peer legitimately waits for upload before its first response.
 pub struct VmessStream {
     io: Option<BoxStream>,
     handshake: Option<ClientHandshake>,
-    deadline: Pin<Box<Sleep>>,
     read: BodyCodec,
     write: BodyCodec,
     stage: ReadStage,
@@ -195,7 +189,7 @@ pub struct VmessStream {
 }
 
 impl VmessStream {
-    pub fn new(io: BoxStream, handshake: ClientHandshake, deadline: Instant) -> Self {
+    pub fn new(io: BoxStream, handshake: ClientHandshake) -> Self {
         Self {
             io: Some(io),
             read: BodyCodec::new(
@@ -215,7 +209,6 @@ impl VmessStream {
                 handshake.iv,
             ),
             handshake: Some(handshake),
-            deadline: Box::pin(tokio::time::sleep_until(deadline)),
             stage: ReadStage::ResponseLength,
             input: BytesMut::new(),
             plain: Bytes::new(),
@@ -232,17 +225,10 @@ impl VmessStream {
         self.whole_close = true;
         self
     }
-    fn check(&mut self, cx: &mut Context<'_>) -> io::Result<()> {
+    fn check(&self) -> io::Result<()> {
         if self.io.is_none() {
             return Err(io::ErrorKind::BrokenPipe.into());
         }
-        if self.handshake.is_some() && self.deadline.as_mut().poll(cx).is_ready() {
-            self.io.take();
-            return Err(io::Error::new(
-                io::ErrorKind::TimedOut,
-                "VMess response deadline",
-            ));
-        }
         Ok(())
     }
     fn fail<T>(&mut self, result: io::Result<T>) -> io::Result<T> {
@@ -281,7 +267,7 @@ impl VmessStream {
         if self.closed {
             return Poll::Ready(Ok(None));
         }
-        self.check(cx)?;
+        self.check()?;
         loop {
             match self.stage {
                 ReadStage::ResponseLength => {
@@ -345,12 +331,12 @@ impl VmessStream {
             .await?
             .ok_or(io::ErrorKind::UnexpectedEof.into())
     }
-    fn poll_packet(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<Option<Bytes>>> {
+    pub(super) fn poll_packet(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<Option<Bytes>>> {
         let result = ready!(self.poll_packet_inner(cx));
         Poll::Ready(self.fail(result))
     }
     fn drain(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        self.check(cx)?;
+        self.check()?;
         while !self.output.is_empty() {
             let n = ready!(Pin::new(self.io.as_mut().unwrap()).poll_write(cx, &self.output))?;
             if n == 0 {
@@ -358,6 +344,8 @@ impl VmessStream {
             }
             self.output.advance(n);
         }
+        // advance() keeps the allocation owner even when no bytes remain.
+        self.output = Bytes::new();
         Poll::Ready(Ok(()))
     }
     pub async fn send_packet(&mut self, payload: &[u8]) -> io::Result<()> {
@@ -464,13 +452,180 @@ mod tests {
         )
     }
 
+    #[tokio::test]
+    async fn encrypted_packetaddr_preserves_targets_and_reply_sources_on_one_wire() {
+        use super::super::{VmessDatagram, VmessIdentity};
+        use crate::{
+            dispatch::{DatagramBudget, DatagramTransport},
+            dns::resolution::ResolutionContext,
+            outbound::address::{decode_packet_addr, encode_packet_addr},
+            session::{Datagram, Destination},
+        };
+        use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+        let mut capabilities = Vec::new();
+        for cipher in [BodyCipher::Aes128Gcm, BodyCipher::Chacha20Poly1305] {
+            let targets = [
+                Destination::Ip("192.0.2.1:53".parse().unwrap()),
+                Destination::Ip("[2001:db8::2]:443".parse().unwrap()),
+            ];
+            let handshake = ClientHandshake::new(
+                &VmessIdentity::new(uuid::Uuid::from_bytes([7; 16])),
+                Command::Udp,
+                &Destination::domain("sp.packet-addr.v2fly.arpa", 443).unwrap(),
+                BodyOptions::new(cipher, false, false).unwrap(),
+            )
+            .unwrap();
+            let (raw, mut peer) = tokio::io::duplex(4096);
+            let mut stream = VmessStream::new(Box::new(raw), handshake);
+            // Existing post-response-authentication seam; actual frame parsing,
+            // AEAD, packetaddr encoding and per-packet source delivery remain.
+            stream.read = codec(cipher, false, false);
+            stream.write = codec(cipher, false, false);
+            stream.stage = ReadStage::Length;
+            stream.handshake = None;
+            let mut transport = VmessDatagram::packet_addr(
+                stream,
+                DatagramBudget::new(128, 128),
+                ResolutionContext::default(),
+            );
+            let shareable = transport.supports_shared_destinations();
+            let mut decoder = codec(cipher, false, false);
+            let mut received = Vec::new();
+            for (index, target) in targets.iter().enumerate() {
+                transport
+                    .send(Datagram {
+                        remote: target.clone(),
+                        payload: Bytes::from(vec![b'a' + u8::try_from(index).unwrap(); 3]),
+                        sniffed_domain: None,
+                    })
+                    .await
+                    .unwrap();
+                let mut header = [0; 2];
+                peer.read_exact(&mut header).await.unwrap();
+                let (length, padding) = decoder.decode_length(&mut header).unwrap();
+                let mut wire = BytesMut::new();
+                wire.resize(length, 0);
+                peer.read_exact(&mut wire).await.unwrap();
+                let plain = decoder.decode_body(wire, padding).unwrap();
+                let (target, offset) = decode_packet_addr(&plain).unwrap();
+                received.push((target, plain.slice(offset..)));
+            }
+            let mut encoder = codec(cipher, false, false);
+            for (index, target) in targets.iter().enumerate().rev() {
+                let mut plain = BytesMut::new();
+                encode_packet_addr(target, &mut plain).unwrap();
+                plain.extend_from_slice(if index == 0 { b"first" } else { b"second" });
+                peer.write_all(&encoder.encode(&plain).unwrap())
+                    .await
+                    .unwrap();
+            }
+            let replies = [
+                transport.receive().await.unwrap(),
+                transport.receive().await.unwrap(),
+            ];
+            transport.close().await.unwrap();
+            let closed = peer.read(&mut [0; 1]).await.unwrap();
+            assert_eq!(received[0].0, targets[0]);
+            assert_eq!(received[0].1.as_ref(), b"aaa");
+            assert_eq!(received[1].0, targets[1]);
+            assert_eq!(received[1].1.as_ref(), b"bbb");
+            assert_eq!(replies[0].remote, targets[1]);
+            assert_eq!(replies[0].payload.as_ref(), b"second");
+            assert_eq!(replies[1].remote, targets[0]);
+            assert_eq!(replies[1].payload.as_ref(), b"first");
+            assert_eq!(closed, 0);
+            assert!(!transport.supports_shared_destinations());
+            capabilities.push((cipher, shareable));
+        }
+        assert!(
+            capabilities.iter().all(|(_, shareable)| *shareable),
+            "encrypted packetaddr must expose its multi-target wire: {capabilities:?}",
+        );
+    }
+
+    #[tokio::test]
+    async fn drained_output_releases_owner_only_after_all_partial_writes_complete() {
+        use super::super::VmessIdentity;
+        use crate::session::Destination;
+        use std::{
+            sync::{
+                Arc,
+                atomic::{AtomicUsize, Ordering},
+            },
+            time::Duration,
+        };
+        use tokio::io::AsyncReadExt;
+
+        struct WireOwner {
+            wire: Box<[u8]>,
+            dropped: Arc<AtomicUsize>,
+        }
+        impl AsRef<[u8]> for WireOwner {
+            fn as_ref(&self) -> &[u8] {
+                &self.wire
+            }
+        }
+        impl Drop for WireOwner {
+            fn drop(&mut self) {
+                self.dropped.fetch_add(1, Ordering::Relaxed);
+            }
+        }
+
+        let (raw, mut peer) = tokio::io::duplex(3);
+        let handshake = ClientHandshake::new(
+            &VmessIdentity::new(uuid::Uuid::from_bytes([7; 16])),
+            Command::Udp,
+            &Destination::Ip("192.0.2.1:53".parse().unwrap()),
+            BodyOptions::new(BodyCipher::Aes128Gcm, false, false).unwrap(),
+        )
+        .unwrap();
+        let mut stream = VmessStream::new(Box::new(raw), handshake);
+        let expected = stream.write.encode(b"owned framed datagram").unwrap();
+        let dropped = Arc::new(AtomicUsize::new(0));
+        // The stream holds the only reference to this real allocation owner.
+        // expected is a separate allocation and cannot hide premature release.
+        stream.output = Bytes::from_owner(WireOwner {
+            wire: expected.to_vec().into_boxed_slice(),
+            dropped: dropped.clone(),
+        });
+        let mut context = Context::from_waker(futures_util::task::noop_waker_ref());
+        assert!(stream.drain(&mut context).is_pending());
+        assert_eq!(stream.output.len(), expected.len() - 3);
+        assert_eq!(
+            dropped.load(Ordering::Relaxed),
+            0,
+            "a partial write must retain its unsubmitted bytes"
+        );
+
+        let mut received = vec![0; expected.len()];
+        let (drained, read) = tokio::time::timeout(Duration::from_secs(1), async {
+            tokio::join!(
+                std::future::poll_fn(|context| stream.drain(context)),
+                peer.read_exact(&mut received),
+            )
+        })
+        .await
+        .unwrap();
+        drained.unwrap();
+        read.unwrap();
+        assert_eq!(received.as_slice(), expected.as_ref());
+        assert!(stream.output.is_empty());
+        // This fails on the old drain: len is zero, but Bytes still owns WireOwner.
+        // Keep the stream alive so destruction cannot make the assertion pass.
+        assert_eq!(
+            dropped.load(Ordering::Relaxed),
+            1,
+            "a completely drained frame must release its last output owner"
+        );
+        assert!(matches!(stream.drain(&mut context), Poll::Ready(Ok(()))));
+        assert_eq!(dropped.load(Ordering::Relaxed), 1);
+        drop(stream);
+        assert_eq!(dropped.load(Ordering::Relaxed), 1);
+    }
+
     #[test]
     fn chunks_preserve_boundaries_masks_padding_and_authenticated_eof() {
-        #[cfg(feature = "interop-test")]
-        let _evidence = crate::resources::case_events::Case::new(
-            "VMESS-CODEC",
-            "chunks_preserve_boundaries_masks_padding_and_authenticated_eof",
-        );
         for cipher in [BodyCipher::Aes128Gcm, BodyCipher::Chacha20Poly1305] {
             for padding in [false, true] {
                 for length in [false, true] {
@@ -490,12 +645,7 @@ mod tests {
     }
 
     #[test]
-    fn tags_lengths_and_nonce_exhaustion_fail_closed() {
-        #[cfg(feature = "interop-test")]
-        let _evidence = crate::resources::case_events::Case::new(
-            "VMESS-CODEC",
-            "tags_lengths_and_nonce_exhaustion_fail_closed",
-        );
+    fn tags_and_lengths_fail_closed() {
         for cipher in [BodyCipher::Aes128Gcm, BodyCipher::Chacha20Poly1305] {
             let mut tx = codec(cipher, false, true);
             let wire = tx.encode(b"synthetic-payload").unwrap();
@@ -511,10 +661,6 @@ mod tests {
                     assert!(rx.decode_body(tampered, padding).is_err());
                 }
             }
-            let mut tx = codec(cipher, false, false);
-            tx.counter = u32::from(u16::MAX);
-            assert!(tx.encode(b"last-nonce").is_ok());
-            assert!(tx.encode(b"must-not-repeat").is_err());
             let mut rx = codec(cipher, false, false);
             let mask = rx.next_mask();
             let mut rx = codec(cipher, false, false);
@@ -526,4 +672,287 @@ mod tests {
             );
         }
     }
+
+    #[test]
+    fn encrypted_records_continue_across_the_official_counter_wrap() {
+        for cipher in [BodyCipher::Aes128Gcm, BodyCipher::Chacha20Poly1305] {
+            for padding in [false, true] {
+                for authenticated_length in [false, true] {
+                    let mut tx = codec(cipher, padding, authenticated_length);
+                    let mut rx = codec(cipher, padding, authenticated_length);
+                    for record in 0..65538u32 {
+                        let payload = record.to_be_bytes();
+                        let mut wire = BytesMut::from(tx.encode(&payload).unwrap().as_ref());
+                        let mut header = wire.split_to(rx.length_size());
+                        let (length, pad) = rx.decode_length(&mut header).unwrap();
+                        assert_eq!(wire.len(), length);
+                        assert_eq!(rx.decode_body(wire, pad).unwrap().as_ref(), payload);
+                    }
+                    assert_eq!(u32::from(tx.counter), 2);
+                    assert_eq!(u32::from(rx.counter), 2);
+                    let mut eof = BytesMut::from(tx.encode(&[]).unwrap().as_ref());
+                    let mut header = eof.split_to(rx.length_size());
+                    let (_, pad) = rx.decode_length(&mut header).unwrap();
+                    assert!(rx.decode_body(eof, pad).unwrap().is_empty());
+                }
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn stream_receives_the_wrapped_peer_record_and_closes_normally() {
+        use super::super::VmessIdentity;
+        use crate::session::Destination;
+        use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+        for cipher in [BodyCipher::Aes128Gcm, BodyCipher::Chacha20Poly1305] {
+            for padding in [false, true] {
+                for authenticated_length in [false, true] {
+                    let handshake = ClientHandshake::new(
+                        &VmessIdentity::new(uuid::Uuid::from_bytes([7; 16])),
+                        Command::Tcp,
+                        &Destination::Ip("192.0.2.1:443".parse().unwrap()),
+                        BodyOptions::new(cipher, padding, authenticated_length).unwrap(),
+                    )
+                    .unwrap();
+                    let (raw, mut peer) = tokio::io::duplex(4096);
+                    let mut stream = VmessStream::new(Box::new(raw), handshake).with_whole_close();
+                    // Post-response-authentication seam, with the production
+                    // parser/AEAD and the final pre-wrap record still intact.
+                    stream.read = codec(cipher, padding, authenticated_length);
+                    stream.read.counter = u16::MAX.into();
+                    stream.stage = ReadStage::Length;
+                    stream.handshake = None;
+                    let mut encoder = codec(cipher, padding, authenticated_length);
+                    encoder.counter = u16::MAX.into();
+                    peer.write_all(&encoder.encode(b"before wrap").unwrap())
+                        .await
+                        .unwrap();
+                    let mut before = [0; 11];
+                    stream.read_exact(&mut before).await.unwrap();
+                    assert_eq!(&before, b"before wrap");
+
+                    // Model the official peer's uint16 counter explicitly,
+                    // independently of the receiver's boundary handling.
+                    encoder.counter = 0;
+                    peer.write_all(&encoder.encode(b"after wrap").unwrap())
+                        .await
+                        .unwrap();
+                    let mut after = [0; 10];
+                    stream.read_exact(&mut after).await.unwrap();
+                    assert_eq!(&after, b"after wrap");
+                    assert_eq!(u32::from(stream.read.counter), 1);
+                    peer.write_all(&encoder.encode(&[]).unwrap()).await.unwrap();
+                    assert_eq!(stream.read(&mut [0; 1]).await.unwrap(), 0);
+                    stream.shutdown().await.unwrap();
+                    assert!(stream.io.is_none());
+                    assert_eq!(
+                        tokio::time::timeout(
+                            std::time::Duration::from_secs(1),
+                            peer.read(&mut [0; 1]),
+                        )
+                        .await
+                        .unwrap()
+                        .unwrap(),
+                        0
+                    );
+                }
+            }
+        }
+    }
+
+    #[derive(Default)]
+    struct ReceiveWake(std::sync::atomic::AtomicUsize);
+
+    impl futures_util::task::ArcWake for ReceiveWake {
+        fn wake_by_ref(owner: &std::sync::Arc<Self>) {
+            owner.0.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+        }
+    }
+
+    #[derive(Default)]
+    struct ByteGate {
+        permit: std::sync::atomic::AtomicBool,
+        reader: std::sync::Mutex<Option<std::task::Waker>>,
+    }
+
+    struct OneByteStream {
+        bytes: Bytes,
+        gate: std::sync::Arc<ByteGate>,
+    }
+
+    impl AsyncRead for OneByteStream {
+        fn poll_read(
+            mut self: Pin<&mut Self>,
+            context: &mut Context<'_>,
+            destination: &mut ReadBuf<'_>,
+        ) -> Poll<io::Result<()>> {
+            if self.bytes.is_empty() || destination.remaining() == 0 {
+                return Poll::Ready(Ok(()));
+            }
+            *self.gate.reader.lock().unwrap() = Some(context.waker().clone());
+            if !self
+                .gate
+                .permit
+                .swap(false, std::sync::atomic::Ordering::AcqRel)
+            {
+                return Poll::Pending;
+            }
+            destination.put_slice(&self.bytes.split_to(1));
+            Poll::Ready(Ok(()))
+        }
+    }
+
+    impl AsyncWrite for OneByteStream {
+        fn poll_write(
+            self: Pin<&mut Self>,
+            _context: &mut Context<'_>,
+            bytes: &[u8],
+        ) -> Poll<io::Result<usize>> {
+            Poll::Ready(Ok(bytes.len()))
+        }
+        fn poll_flush(self: Pin<&mut Self>, _context: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Poll::Ready(Ok(()))
+        }
+        fn poll_shutdown(self: Pin<&mut Self>, _context: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Poll::Ready(Ok(()))
+        }
+    }
+
+    #[test]
+    fn vmess_datagram_polled_receive_keeps_frames_across_byte_gates_and_waker_changes() {
+        use crate::{
+            dispatch::{DatagramBudget, DatagramTransport},
+            dns::resolution::ResolutionContext,
+            outbound::{
+                address::encode_packet_addr,
+                vmess::{VmessDatagram, VmessIdentity},
+            },
+            session::Destination,
+        };
+        use std::sync::{Arc, atomic::Ordering};
+
+        for cipher in [BodyCipher::Aes128Gcm, BodyCipher::Chacha20Poly1305] {
+            for padding in [false, true] {
+                for authenticated_length in [false, true] {
+                    for packetaddr in [false, true] {
+                        let targets = [
+                            Destination::Ip("192.0.2.1:53".parse().unwrap()),
+                            Destination::Ip(if packetaddr {
+                                "[2001:db8::2]:443".parse().unwrap()
+                            } else {
+                                "192.0.2.1:53".parse().unwrap()
+                            }),
+                        ];
+                        let mut encoder = codec(cipher, padding, authenticated_length);
+                        let mut wire = Vec::new();
+                        // A discarded oversize packet must consume its complete
+                        // record once, then deliver two distinct authenticated
+                        // records with their original addresses and payloads.
+                        for (target, payload) in [
+                            (&targets[0], &[0x5a; 32][..]),
+                            (&targets[0], b"one".as_slice()),
+                            (&targets[1], b"two".as_slice()),
+                        ] {
+                            let mut packet = BytesMut::new();
+                            if packetaddr {
+                                encode_packet_addr(target, &mut packet).unwrap();
+                            }
+                            packet.extend_from_slice(payload);
+                            wire.extend_from_slice(&encoder.encode(&packet).unwrap());
+                        }
+                        wire.extend_from_slice(&encoder.encode(&[]).unwrap());
+                        let poll_bound = wire.len() + 1;
+                        let gate = Arc::new(ByteGate::default());
+                        let handshake = ClientHandshake::new(
+                            &VmessIdentity::new(uuid::Uuid::from_bytes([7; 16])),
+                            Command::Udp,
+                            &targets[0],
+                            BodyOptions::new(cipher, padding, authenticated_length).unwrap(),
+                        )
+                        .unwrap();
+                        let mut stream = VmessStream::new(
+                            Box::new(OneByteStream {
+                                bytes: wire.into(),
+                                gate: gate.clone(),
+                            }),
+                            handshake,
+                        );
+                        // This seam begins after response authentication. The
+                        // existing official-response tests cover that header;
+                        // no replacement body parser or cipher is used here.
+                        stream.read = codec(cipher, padding, authenticated_length);
+                        stream.stage = ReadStage::Length;
+                        stream.handshake = None;
+                        let budget = DatagramBudget::new(128, 8);
+                        let mut transport = if packetaddr {
+                            VmessDatagram::packet_addr(stream, budget, ResolutionContext::default())
+                        } else {
+                            VmessDatagram::raw(stream, targets[0].clone(), budget)
+                        };
+                        assert!(transport.supports_poll_receive());
+                        let owners = [
+                            Arc::new(ReceiveWake::default()),
+                            Arc::new(ReceiveWake::default()),
+                        ];
+                        let wakes = owners
+                            .each_ref()
+                            .map(|owner| futures_util::task::waker(owner.clone()));
+                        let mut scratch = Vec::new();
+                        let mut step = 0;
+                        for expected in 0..3 {
+                            let result = loop {
+                                assert!(step < poll_bound, "byte-gated receive made no progress");
+                                let old = step % 2;
+                                let fresh = 1 - old;
+                                assert!(
+                                    transport
+                                        .poll_receive(
+                                            &mut Context::from_waker(&wakes[old]),
+                                            &mut scratch,
+                                        )
+                                        .is_pending()
+                                );
+                                assert!(
+                                    transport
+                                        .poll_receive(
+                                            &mut Context::from_waker(&wakes[fresh]),
+                                            &mut scratch,
+                                        )
+                                        .is_pending()
+                                );
+                                let count = owners[fresh].0.load(Ordering::Relaxed);
+                                gate.permit.store(true, Ordering::Release);
+                                gate.reader.lock().unwrap().take().unwrap().wake();
+                                assert_eq!(owners[fresh].0.load(Ordering::Relaxed), count + 1);
+                                step += 1;
+                                match transport.poll_receive(
+                                    &mut Context::from_waker(&wakes[fresh]),
+                                    &mut scratch,
+                                ) {
+                                    Poll::Pending => {}
+                                    Poll::Ready(result) => break result,
+                                }
+                            };
+                            if expected < 2 {
+                                let packet = result.unwrap();
+                                assert_eq!(packet.remote, targets[expected]);
+                                assert_eq!(
+                                    &packet.payload[..],
+                                    if expected == 0 { b"one" } else { b"two" }
+                                );
+                            } else {
+                                assert!(result.is_err(), "UDP EOF must not remain Pending");
+                            }
+                        }
+                        assert!(matches!(
+                            transport
+                                .poll_receive(&mut Context::from_waker(&wakes[0]), &mut scratch,),
+                            Poll::Ready(Err(_))
+                        ));
+                    }
+                }
+            }
+        }
+    }
 }
diff --git a/src/outbound/wireguard/channel.rs b/src/outbound/wireguard/channel.rs
new file mode 100644
index 0000000..e399675
--- /dev/null
+++ b/src/outbound/wireguard/channel.rs
@@ -0,0 +1,142 @@
+use super::{datagram::Registry, peer, routes::Routes};
+use crate::{
+    config::WireGuardOutboundConfig,
+    dispatch::DispatchError,
+    outbound::{EstablishContext, UpstreamPath},
+    resources::observation,
+    session::DatagramSession,
+};
+use std::{
+    sync::{Arc, Mutex},
+    time::Duration,
+};
+use tokio::{
+    sync::{Mutex as AsyncMutex, mpsc, oneshot, watch},
+    task::JoinHandle,
+    time::Instant,
+};
+use tokio_util::sync::CancellationToken;
+use vole_netstack::{Packet, PacketSink};
+#[derive(Clone, Copy)]
+pub(super) enum Ready {
+    Waiting,
+    Established,
+    Failed,
+}
+pub(super) struct Refresh {
+    pub context: EstablishContext,
+    pub reply: oneshot::Sender<()>,
+}
+pub(super) struct Channel {
+    pub tx: mpsc::Sender<Packet>,
+    pub cancel: CancellationToken,
+    ready: watch::Receiver<Ready>,
+    commands: mpsc::Sender<Refresh>,
+    initial: EstablishContext,
+    updated: Arc<Mutex<Instant>>,
+    refresh: AsyncMutex<()>,
+    task: Mutex<Option<JoinHandle<()>>>,
+    stop: AsyncMutex<()>,
+}
+impl Channel {
+    #[cfg(test)]
+    pub(super) fn memory_ready(cancel: CancellationToken) -> (Arc<Self>, mpsc::Receiver<Packet>) {
+        let (tx, rx) = mpsc::channel(32);
+        let (_, ready) = watch::channel(Ready::Established);
+        let (commands, _) = mpsc::channel(1);
+        let channel = Arc::new(Self {
+            tx,
+            cancel,
+            ready,
+            commands,
+            initial: EstablishContext::default(),
+            updated: Arc::new(Mutex::new(Instant::now())),
+            refresh: AsyncMutex::new(()),
+            task: Mutex::new(None),
+            stop: AsyncMutex::new(()),
+        });
+        (channel, rx)
+    }
+    #[allow(clippy::too_many_arguments)]
+    pub fn start(
+        config: Arc<WireGuardOutboundConfig>,
+        index: usize,
+        upstream: UpstreamPath,
+        session: DatagramSession,
+        context: EstablishContext,
+        cancel: CancellationToken,
+        sink: PacketSink,
+        registry: Arc<Registry>,
+        routes: Arc<Routes>,
+    ) -> Arc<Self> {
+        let (tx, rx) = mpsc::channel(32);
+        let (ready, state) = watch::channel(Ready::Waiting);
+        let (commands, requests) = mpsc::channel(1);
+        let updated = Arc::new(Mutex::new(Instant::now()));
+        let channel = Arc::new(Self {
+            tx,
+            cancel: cancel.clone(),
+            ready: state,
+            commands,
+            initial: context.clone(),
+            updated: updated.clone(),
+            refresh: AsyncMutex::new(()),
+            task: Mutex::new(None),
+            stop: AsyncMutex::new(()),
+        });
+        let task = observation::spawn(peer::drive(
+            config, index, upstream, session, context, cancel, rx, requests, ready, sink, registry,
+            routes, updated,
+        ));
+        *channel.task.lock().unwrap() = Some(task);
+        channel
+    }
+    pub fn is_ready(&self) -> bool {
+        !self.cancel.is_cancelled() && matches!(*self.ready.borrow(), Ready::Established)
+    }
+    pub async fn wait_ready(&self, context: &EstablishContext) -> Result<(), DispatchError> {
+        let mut ready = self.ready.clone();
+        context.run("WireGuard handshake",async{
+            loop {
+                match *ready.borrow_and_update(){Ready::Established=>return Ok(()),Ready::Failed=>return Err(DispatchError::ConnectionRefused),Ready::Waiting=>{}}
+                tokio::select!{biased;()=self.cancel.cancelled()=>return Err(DispatchError::ConnectionRefused),result=ready.changed()=>if result.is_err(){return Err(DispatchError::ConnectionRefused);}}
+            }
+        }).await
+    }
+    pub async fn refresh_if_due(&self, interval: i64, caller: &EstablishContext) {
+        if interval == 0 || !self.is_ready() {
+            return;
+        }
+        let Ok(_guard) = self.refresh.try_lock() else {
+            return;
+        };
+        if self.updated.lock().unwrap().elapsed() < Duration::from_secs(interval.max(0) as u64) {
+            return;
+        }
+        let context = self
+            .initial
+            .authenticated_continuation()
+            .capped_by(caller.deadline());
+        let (reply, done) = oneshot::channel();
+        let _ = tokio::select! {biased;()=self.cancel.cancelled()=>Err(DispatchError::ConnectionRefused),result=caller.run("WireGuard endpoint refresh",async{
+            self.commands.send(Refresh{context,reply}).await.map_err(|_|DispatchError::ConnectionRefused)?;
+            done.await.map_err(|_|DispatchError::ConnectionRefused)
+        })=>result};
+    }
+    pub async fn stop(&self) {
+        let _guard = self.stop.lock().await;
+        self.cancel.cancel();
+        let task = self.task.lock().unwrap().take();
+        if let Some(task) = task {
+            let _ = task.await;
+        }
+    }
+}
+impl Drop for Channel {
+    fn drop(&mut self) {
+        self.cancel.cancel();
+        if let Some(task) = self.task.get_mut().unwrap().take() {
+            task.abort();
+        }
+    }
+}
diff --git a/src/outbound/wireguard/datagram.rs b/src/outbound/wireguard/datagram.rs
new file mode 100644
index 0000000..c77b090
--- /dev/null
+++ b/src/outbound/wireguard/datagram.rs
@@ -0,0 +1,295 @@
+use super::engine::Engine;
+use crate::{
+    dispatch::{DatagramBudget, DatagramTransport, DispatchError},
+    dns::resolution::ResolutionContext,
+    outbound::DEFAULT_ESTABLISH_TIMEOUT,
+    resources::observation::{self, ResourceKind},
+    session::{Datagram, DatagramSession, Destination},
+};
+use async_trait::async_trait;
+use bytes::Bytes;
+use std::{
+    collections::HashMap,
+    net::{IpAddr, SocketAddr},
+    sync::{Arc, Mutex, Weak},
+};
+use tokio::sync::mpsc;
+use tokio::time::Instant;
+use vole_netstack::{Packet, UdpDatagram, encode_udp_packet_into};
+
+const FIRST_PORT: u16 = 1024;
+const RESPONSE_QUEUE: usize = 64;
+struct Entry {
+    id: u64,
+    slot: Weak<Slot>,
+}
+struct State {
+    next: u16,
+    id: u64,
+    entries: HashMap<u16, Entry>,
+}
+impl Default for State {
+    fn default() -> Self {
+        Self {
+            next: 49152,
+            id: 0,
+            entries: HashMap::new(),
+        }
+    }
+}
+#[derive(Default)]
+pub(super) struct Registry(Mutex<State>);
+pub(super) struct Slot {
+    pub port: u16,
+    id: u64,
+    registry: Arc<Registry>,
+    sender: mpsc::Sender<Datagram>,
+    maximum: u16,
+    _observation: observation::Guard,
+}
+impl Registry {
+    fn open(
+        self: &Arc<Self>,
+        maximum: u16,
+    ) -> Result<(Arc<Slot>, mpsc::Receiver<Datagram>), DispatchError> {
+        let mut state = self.0.lock().unwrap();
+        for _ in FIRST_PORT..=u16::MAX {
+            let port = state.next;
+            state.next = if port == u16::MAX {
+                FIRST_PORT
+            } else {
+                port + 1
+            };
+            if state
+                .entries
+                .get(&port)
+                .is_some_and(|entry| entry.slot.strong_count() > 0)
+            {
+                continue;
+            }
+            state.id = state.id.checked_add(1).ok_or_else(|| {
+                DispatchError::Other("WireGuard UDP lease identifiers exhausted".into())
+            })?;
+            let id = state.id;
+            let (sender, receiver) = mpsc::channel(RESPONSE_QUEUE);
+            let slot = Arc::new(Slot {
+                port,
+                id,
+                registry: self.clone(),
+                sender,
+                maximum,
+                _observation: observation::track(ResourceKind::Association),
+            });
+            state.entries.insert(
+                port,
+                Entry {
+                    id,
+                    slot: Arc::downgrade(&slot),
+                },
+            );
+            return Ok((slot, receiver));
+        }
+        Err(DispatchError::Other(
+            "WireGuard UDP source ports exhausted".into(),
+        ))
+    }
+    pub fn deliver(&self, source: SocketAddr, destination: SocketAddr, payload: &[u8]) {
+        let slot = self
+            .0
+            .lock()
+            .unwrap()
+            .entries
+            .get(&destination.port())
+            .and_then(|entry| entry.slot.upgrade());
+        if let Some(slot) = slot.filter(|slot| payload.len() <= usize::from(slot.maximum)) {
+            let _ = slot.sender.try_send(Datagram {
+                remote: Destination::Ip(source),
+                payload: Bytes::copy_from_slice(payload),
+                sniffed_domain: None,
+            });
+        }
+    }
+}
+impl Drop for Slot {
+    fn drop(&mut self) {
+        let mut state = self.registry.0.lock().unwrap();
+        if state
+            .entries
+            .get(&self.port)
+            .is_some_and(|entry| entry.id == self.id)
+        {
+            state.entries.remove(&self.port);
+        }
+        if state.entries.capacity() > state.entries.len().saturating_mul(4).max(64) {
+            state.entries.shrink_to_fit();
+        }
+    }
+}
+pub(super) struct Datagrams {
+    engine: Arc<Engine>,
+    slot: Option<Arc<Slot>>,
+    receiver: mpsc::Receiver<Datagram>,
+    resolution: ResolutionContext,
+    session: DatagramSession,
+    budget: DatagramBudget,
+    frame: Vec<u8>,
+}
+impl Datagrams {
+    pub fn new(
+        engine: Arc<Engine>,
+        request: DatagramBudget,
+        resolution: ResolutionContext,
+        session: DatagramSession,
+    ) -> Result<Self, DispatchError> {
+        let overhead = if engine.ipv6.is_some() { 48 } else { 28 };
+        let maximum = (engine.mtu - overhead) as u16;
+        let budget = DatagramBudget::new(
+            maximum.min(request.transmit()),
+            maximum.min(request.receive()),
+        );
+        let (slot, receiver) = engine.registry.open(budget.receive())?;
+        let mtu = engine.mtu;
+        Ok(Self {
+            engine,
+            slot: Some(slot),
+            receiver,
+            resolution,
+            session,
+            budget,
+            frame: Vec::with_capacity(mtu),
+        })
+    }
+    fn port(&self) -> Result<u16, DispatchError> {
+        self.slot
+            .as_ref()
+            .map(|slot| slot.port)
+            .ok_or(DispatchError::ConnectionRefused)
+    }
+}
+#[async_trait]
+impl DatagramTransport for Datagrams {
+    fn supports_shared_destinations(&self) -> bool {
+        // The lease owns an inner source port; each packet selects its own
+        // destination/peer and replies retain their actual source address.
+        true
+    }
+    fn payload_budget(&self, _: &Destination) -> DatagramBudget {
+        self.budget
+    }
+    async fn send(&mut self, datagram: Datagram) -> Result<(), DispatchError> {
+        let port = self.port()?;
+        if datagram.payload.len() > usize::from(self.budget.transmit()) {
+            return Err(DispatchError::Other(
+                "WireGuard datagram exceeds transmit budget".into(),
+            ));
+        }
+        let deadline = Instant::now() + DEFAULT_ESTABLISH_TIMEOUT;
+        let destination =
+            super::resolver::resolve(&self.engine, &datagram.remote, &self.resolution, deadline)
+                .await?;
+        let context = crate::outbound::EstablishContext::with_resolution(
+            DEFAULT_ESTABLISH_TIMEOUT,
+            self.resolution.clone(),
+        )
+        .with_metadata(&self.session.metadata)
+        .capped_by(deadline);
+        let channel = self
+            .engine
+            .peer(destination.ip(), self.session.clone(), &context)
+            .await?;
+        let source = SocketAddr::new(self.engine.local(destination.ip())?, port);
+        encode_udp_packet_into(
+            &UdpDatagram::new(source, destination, datagram.payload),
+            self.engine.mtu,
+            &mut self.frame,
+        )
+        .map_err(|_| DispatchError::Other("invalid WireGuard datagram".into()))?;
+        let packet = Packet::new(Bytes::copy_from_slice(&self.frame));
+        tokio::select! {biased;
+            ()=self.engine.cancel.cancelled()=>Err(DispatchError::ConnectionRefused),
+            result=tokio::time::timeout_at(deadline,channel.tx.send(packet))=>result.map_err(|_|DispatchError::TimedOut)?.map_err(|_|DispatchError::ConnectionRefused),
+        }
+    }
+    async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+        self.port()?;
+        tokio::select! {biased;()=self.engine.cancel.cancelled()=>Err(DispatchError::ConnectionRefused),datagram=self.receiver.recv()=>datagram.ok_or(DispatchError::ConnectionRefused)}
+    }
+    async fn close(&mut self) -> Result<(), DispatchError> {
+        self.slot.take();
+        self.receiver.close();
+        while self.receiver.try_recv().is_ok() {}
+        self.frame = Vec::new();
+        Ok(())
+    }
+}
+
+pub(super) fn local_destination(
+    config: &crate::config::WireGuardOutboundConfig,
+    destination: IpAddr,
+) -> bool {
+    match destination {
+        IpAddr::V4(ip) => config.ipv4 == Some(ip),
+        IpAddr::V6(ip) => config.ipv6 == Some(ip),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::outbound::OutboundConnector;
+    use crate::{
+        outbound::EstablishContext, resources::observation::ResourceProbe, session::InboundKind,
+    };
+
+    #[tokio::test]
+    async fn wireguard_memory_closed_udp_releases_queued_replies_and_frame() {
+        let probe = ResourceProbe::default();
+        probe
+            .scope(async {
+                let (outbound, _, _) = super::super::tests::outbound(false);
+                let engine = outbound.engine(&EstablishContext::default()).await.unwrap();
+                let open = || {
+                    Datagrams::new(
+                        engine.clone(),
+                        DatagramBudget::new(1200, 1200),
+                        ResolutionContext::default(),
+                        DatagramSession::new(InboundKind::Tun, "192.0.2.1:23000".parse().unwrap()),
+                    )
+                    .unwrap()
+                };
+                let mut closed = open();
+                let mut sibling = open();
+                let remote = "10.0.0.1:53".parse().unwrap();
+                let destination =
+                    SocketAddr::new("10.0.0.2".parse().unwrap(), closed.port().unwrap());
+                for _ in 0..RESPONSE_QUEUE {
+                    engine.registry.deliver(remote, destination, b"queued");
+                }
+                assert_eq!(closed.receiver.len(), RESPONSE_QUEUE);
+                assert!(closed.frame.capacity() >= engine.mtu);
+                closed.close().await.unwrap();
+                closed.close().await.unwrap();
+                assert!(closed.slot.is_none());
+                assert_eq!(closed.receiver.len(), 0);
+                assert_eq!(closed.frame.capacity(), 0);
+                engine.registry.deliver(remote, destination, b"late");
+                assert_eq!(closed.receiver.len(), 0);
+                assert!(closed.receive().await.is_err());
+                engine.registry.deliver(
+                    remote,
+                    SocketAddr::new(destination.ip(), sibling.port().unwrap()),
+                    b"sibling",
+                );
+                let response = sibling.receive().await.unwrap();
+                assert_eq!(response.remote, Destination::Ip(remote));
+                assert_eq!(response.payload.as_ref(), b"sibling");
+                assert_eq!(engine.registry.0.lock().unwrap().entries.len(), 1);
+                sibling.close().await.unwrap();
+                assert!(engine.registry.0.lock().unwrap().entries.is_empty());
+                drop((closed, sibling, engine));
+                outbound.shutdown().await;
+                assert!(probe.snapshot().is_idle());
+            })
+            .await;
+    }
+}
diff --git a/src/outbound/wireguard/engine.rs b/src/outbound/wireguard/engine.rs
new file mode 100644
index 0000000..8a0ac44
--- /dev/null
+++ b/src/outbound/wireguard/engine.rs
@@ -0,0 +1,521 @@
+use super::{channel::Channel, datagram::Registry, peer, routes::Routes};
+use crate::{
+    config::WireGuardOutboundConfig,
+    dispatch::DispatchError,
+    dns::resolution::ResolutionContext,
+    outbound::{EstablishContext, UpstreamPath},
+    resources::observation,
+    session::DatagramSession,
+};
+use std::{
+    net::{IpAddr, Ipv4Addr, Ipv6Addr},
+    sync::{Arc, Mutex, OnceLock},
+};
+use tokio::{sync::Mutex as AsyncMutex, task::JoinHandle};
+use tokio_util::{sync::CancellationToken, task::TaskTracker};
+use vole_netstack::{
+    ClientAddresses, ClientNetStackParts, NetStack, NetStackConfig, NetStackControl, PacketSink,
+    PacketStream, TcpConnector,
+};
+#[derive(Default)]
+struct PeerSlot {
+    gate: AsyncMutex<()>,
+    current: Mutex<Option<Arc<Channel>>>,
+}
+pub(super) struct Engine {
+    pub security: crate::security::SecurityContext,
+    pub cancel: CancellationToken,
+    pub tcp: TcpConnector,
+    pub registry: Arc<Registry>,
+    pub ipv4: Option<Ipv4Addr>,
+    pub ipv6: Option<Ipv6Addr>,
+    pub mtu: usize,
+    pub resolution: ResolutionContext,
+    pub remote: OnceLock<Arc<crate::dns::runtime::RuntimeDns>>,
+    pub config: Arc<WireGuardOutboundConfig>,
+    routes: Arc<Routes>,
+    upstream: UpstreamPath,
+    slots: Arc<[PeerSlot]>,
+    sink: PacketSink,
+    control: NetStackControl,
+    router: Mutex<Option<JoinHandle<()>>>,
+    retired: TaskTracker,
+    admission: Mutex<()>,
+    stop: AsyncMutex<()>,
+}
+impl Engine {
+    pub fn start(
+        config: Arc<WireGuardOutboundConfig>,
+        upstream: UpstreamPath,
+        context: EstablishContext,
+        cancel: CancellationToken,
+        security: crate::security::SecurityContext,
+    ) -> Result<Arc<Self>, DispatchError> {
+        let ClientNetStackParts {
+            packet_sink,
+            packet_stream,
+            tcp_connector,
+            control,
+            ..
+        } = NetStack::start_client(
+            NetStackConfig {
+                mtu: usize::from(config.mtu),
+                packet_queue: 32,
+                tcp_send_buffer: 64 * 1024,
+                ..Default::default()
+            },
+            ClientAddresses {
+                ipv4: config.ipv4,
+                ipv6: config.ipv6,
+            },
+        )
+        .map_err(|_| DispatchError::Other("WireGuard stack initialization failed".into()))?;
+        let routes = Arc::new(Routes::new(&config));
+        let slots: Arc<[PeerSlot]> = (0..config.peers.len())
+            .map(|_| PeerSlot::default())
+            .collect();
+        let engine = Arc::new(Self {
+            security,
+            cancel: cancel.clone(),
+            tcp: tcp_connector,
+            registry: Arc::new(Registry::default()),
+            ipv4: config.ipv4,
+            ipv6: config.ipv6,
+            mtu: usize::from(config.mtu),
+            resolution: context.resolution(),
+            remote: OnceLock::new(),
+            config,
+            routes: routes.clone(),
+            upstream,
+            slots: slots.clone(),
+            sink: packet_sink,
+            control,
+            router: Mutex::new(None),
+            retired: TaskTracker::new(),
+            admission: Mutex::new(()),
+            stop: AsyncMutex::new(()),
+        });
+        *engine.router.lock().unwrap() = Some(observation::spawn(pump_output(
+            packet_stream,
+            slots,
+            routes,
+            cancel,
+        )));
+        Ok(engine)
+    }
+    pub fn local(&self, ip: IpAddr) -> Result<IpAddr, DispatchError> {
+        match ip {
+            IpAddr::V4(_) => self.ipv4.map(IpAddr::V4),
+            IpAddr::V6(_) => self.ipv6.map(IpAddr::V6),
+        }
+        .ok_or(DispatchError::HostUnreachable)
+    }
+    pub async fn peer(
+        &self,
+        ip: IpAddr,
+        session: DatagramSession,
+        context: &EstablishContext,
+    ) -> Result<Arc<Channel>, DispatchError> {
+        self.local(ip)?;
+        let index = self
+            .routes
+            .select(ip)
+            .ok_or(DispatchError::HostUnreachable)?;
+        let slot = &self.slots[index];
+        let channel = tokio::select! {biased;()=self.cancel.cancelled()=>return Err(DispatchError::NotAllowed),result=context.run("WireGuard peer initialize",async{
+            let _gate=slot.gate.lock().await;let mut current=slot.current.lock().unwrap();
+            if let Some(channel)=current.as_ref().filter(|c|!c.cancel.is_cancelled()){return Ok(channel.clone());}
+            let _admission=self.admission.lock().unwrap();if self.cancel.is_cancelled(){return Err(DispatchError::NotAllowed);}
+            if let Some(old)=current.take(){self.retired.spawn(observation::task(async move{old.stop().await;}));}
+            let channel=Channel::start(self.config.clone(),index,self.upstream.clone(),session,context.clone(),self.cancel.child_token(),self.sink.clone(),self.registry.clone(),self.routes.clone());
+            *current=Some(channel.clone());Ok(channel)
+        })=>result?};
+        channel.wait_ready(context).await?;
+        self.refresh_active(context).await;
+        channel.wait_ready(context).await?;
+        Ok(channel)
+    }
+    async fn refresh_active(&self, context: &EstablishContext) {
+        let interval = self.config.refresh_server_ip_interval;
+        if interval == 0 {
+            return;
+        }
+        // A business call can refresh every live peer, including one whose
+        // route has not recently carried traffic. Unused peers stay lazy.
+        let channels = self
+            .slots
+            .iter()
+            .filter_map(|slot| {
+                slot.current
+                    .lock()
+                    .unwrap()
+                    .as_ref()
+                    .filter(|channel| channel.is_ready())
+                    .cloned()
+            })
+            .collect::<Vec<_>>();
+        futures_util::future::join_all(
+            channels
+                .iter()
+                .map(|channel| channel.refresh_if_due(interval, context)),
+        )
+        .await;
+    }
+
+    pub async fn stop(&self) {
+        let _stop = self.stop.lock().await;
+        {
+            let _admission = self.admission.lock().unwrap();
+            self.cancel.cancel();
+            self.retired.close();
+        }
+        if let Some(remote) = self.remote.get() {
+            remote.shutdown().await;
+        }
+        let channels = self
+            .slots
+            .iter()
+            .filter_map(|slot| slot.current.lock().unwrap().take())
+            .collect::<Vec<_>>();
+        for channel in channels {
+            channel.stop().await;
+        }
+        self.retired.wait().await;
+        let router = self.router.lock().unwrap().take();
+        if let Some(router) = router {
+            let _ = router.await;
+        }
+        self.control.stop().await;
+    }
+}
+impl Drop for Engine {
+    fn drop(&mut self) {
+        if let Some(remote) = self.remote.get() {
+            remote.begin_shutdown();
+        }
+        self.cancel.cancel();
+        self.control.cancel();
+        if let Some(router) = self.router.get_mut().unwrap().take() {
+            router.abort();
+        }
+    }
+}
+async fn pump_output(
+    mut packets: PacketStream,
+    slots: Arc<[PeerSlot]>,
+    routes: Arc<Routes>,
+    cancel: CancellationToken,
+) {
+    loop {
+        let packet = tokio::select! {biased;()=cancel.cancelled()=>break,packet=packets.recv()=>match packet{Some(p)=>p,None=>break}};
+        let Some((_, dst)) = peer::addresses(packet.data()) else {
+            continue;
+        };
+        let Some(index) = routes.select(dst) else {
+            continue;
+        };
+        let pending = {
+            let current = slots[index].current.lock().unwrap();
+            let Some(channel) = current.as_ref().filter(|c| c.is_ready()) else {
+                continue;
+            };
+            match channel.tx.try_send(packet) {
+                Err(tokio::sync::mpsc::error::TrySendError::Full(packet)) => {
+                    Some((channel.clone(), packet))
+                }
+                _ => None,
+            }
+        };
+        if let Some((channel, packet)) = pending {
+            // Keep only this Full packet and its original peer generation.
+            // One peer can wait for space; multiple peers get one cooperative
+            // handoff so a full peer cannot block a sibling.
+            let offer = async {
+                let send = channel.tx.send(packet);
+                if slots.len() == 1 {
+                    let _ = send.await;
+                    return;
+                }
+                tokio::pin!(send);
+                if futures_util::poll!(send.as_mut()).is_ready() {
+                    return;
+                }
+                tokio::task::yield_now().await;
+                let _ = futures_util::poll!(send.as_mut());
+            };
+            tokio::select! { biased;
+                () = cancel.cancelled() => break,
+                () = channel.cancel.cancelled() => {},
+                () = offer => {},
+            }
+        }
+    }
+    cancel.cancel();
+}
+
+#[cfg(test)]
+mod full_handoff_memory_tests {
+    use super::*;
+    use bytes::Bytes;
+    use futures_util::task::noop_waker;
+    use std::{
+        future::Future,
+        net::SocketAddr,
+        task::{Context, Poll, Wake, Waker},
+        time::Duration,
+    };
+    use tokio::sync::Notify;
+    use vole_netstack::Packet;
+
+    #[derive(Default)]
+    struct PumpWake(Notify);
+    impl Wake for PumpWake {
+        fn wake(self: Arc<Self>) {
+            self.wake_by_ref();
+        }
+        fn wake_by_ref(self: &Arc<Self>) {
+            self.0.notify_one();
+        }
+    }
+    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
+    enum Case {
+        Release,
+        StillFull,
+        PeerStop,
+        GlobalStop,
+    }
+
+    fn is_syn(packet: &Packet, destination: SocketAddr) -> bool {
+        let bytes = packet.data();
+        if bytes.len() < 40 || bytes[0] >> 4 != 4 || bytes[9] != 6 {
+            return false;
+        }
+        let offset = usize::from(bytes[0] & 15) * 4;
+        offset >= 20
+            && bytes.len() >= offset + 20
+            && peer::addresses(bytes).is_some_and(|(_, dst)| dst == destination.ip())
+            && u16::from_be_bytes([bytes[offset + 2], bytes[offset + 3]]) == destination.port()
+            && bytes[offset + 13] & 0x17 == 2
+    }
+
+    async fn exercise(case: Case, single_peer: bool) -> usize {
+        let first: SocketAddr = "10.0.0.1:443".parse().unwrap();
+        let other: SocketAddr = "10.1.0.1:443".parse().unwrap();
+        let mut config = super::super::tests::config();
+        config.routes = vec![
+            (
+                crate::config::IpCidr {
+                    network: first.ip(),
+                    prefix_len: 32,
+                },
+                0,
+            ),
+            (
+                crate::config::IpCidr {
+                    network: other.ip(),
+                    prefix_len: 32,
+                },
+                1,
+            ),
+        ];
+        if single_peer {
+            config.routes.truncate(1);
+        }
+        let routes = Arc::new(Routes::new(&config));
+        assert_eq!(routes.select(first.ip()), Some(0));
+        assert_eq!(routes.select(other.ip()), (!single_peer).then_some(1));
+        let cancel = CancellationToken::new();
+        let (a, mut a_rx) = Channel::memory_ready(cancel.child_token());
+        let (b, mut b_rx) = Channel::memory_ready(cancel.child_token());
+        let slots: Arc<[PeerSlot]> = if single_peer {
+            vec![PeerSlot::default()].into()
+        } else {
+            vec![PeerSlot::default(), PeerSlot::default()].into()
+        };
+        *slots[0].current.lock().unwrap() = Some(a.clone());
+        if !single_peer {
+            *slots[1].current.lock().unwrap() = Some(b.clone());
+        }
+        let filler = Packet::new(Bytes::from_static(b"existing-queued-packet"));
+        for _ in 0..32 {
+            a.tx.try_send(filler.clone()).unwrap();
+        }
+        assert!(a.is_ready() && b.is_ready());
+        assert_eq!(
+            a.tx.capacity(),
+            0,
+            "fixture did not fill the actual 32-slot peer"
+        );
+        let ClientNetStackParts {
+            packet_sink,
+            packet_stream,
+            tcp_connector,
+            control,
+            stats,
+        } = NetStack::start_client(
+            NetStackConfig {
+                mtu: 1408,
+                packet_queue: 32,
+                ..Default::default()
+            },
+            ClientAddresses {
+                ipv4: config.ipv4,
+                ipv6: None,
+            },
+        )
+        .unwrap();
+        let wake = Arc::new(PumpWake::default());
+        let waker = Waker::from(wake.clone());
+        let mut cx = Context::from_waker(&waker);
+        let caller = noop_waker();
+        let mut caller_cx = Context::from_waker(&caller);
+        let mut pump = Box::pin(pump_output(
+            packet_stream,
+            slots.clone(),
+            routes,
+            cancel.clone(),
+        ));
+        assert!(
+            pump.as_mut().poll(&mut cx).is_pending(),
+            "fixture empty pump ended"
+        );
+        let deadline = tokio::time::Instant::now() + Duration::from_secs(10);
+        let mut connect = Box::pin(tcp_connector.connect(first, deadline));
+        let mut connect_other = Box::pin(tcp_connector.connect(other, deadline));
+        assert!(
+            connect.as_mut().poll(&mut caller_cx).is_pending(),
+            "fixture TCP connect did not pend"
+        );
+        tokio::time::timeout(Duration::from_secs(2), wake.0.notified())
+            .await
+            .expect("fixture never emitted the first SYN into PacketStream");
+
+        // Current-thread runtime: no await from the packet-ready barrier through
+        // the captured result. The netstack cannot run again to retransmit here.
+        let single_socket = stats.snapshot().active_tcp == 1;
+        let first_pending = pump.as_mut().poll(&mut cx).is_pending();
+        // Keep the actual queue Full across more polls than the multi-peer
+        // cooperative offer permits. No await can let TCP retransmit the SYN.
+        let retained_pending =
+            !single_peer || (0..3).all(|_| pump.as_mut().poll(&mut cx).is_pending());
+        let slot_unlocked = slots[0].current.try_lock().is_ok();
+        let release_slot = case != Case::StillFull && (!single_peer || case == Case::Release);
+        if release_slot {
+            assert_eq!(a_rx.try_recv().unwrap(), filler);
+        }
+        if case == Case::PeerStop {
+            a.cancel.cancel();
+        }
+        if case == Case::GlobalStop {
+            cancel.cancel();
+        }
+        let after = if first_pending {
+            pump.as_mut().poll(&mut cx)
+        } else {
+            Poll::Ready(())
+        };
+        let already_joined = after.is_ready();
+        let continuing = case == Case::GlobalStop || after.is_pending();
+        let global_joined = case != Case::GlobalStop || already_joined;
+        let mut seen = Vec::new();
+        while let Ok(packet) = a_rx.try_recv() {
+            seen.push(packet);
+        }
+        let admitted = seen.iter().filter(|packet| is_syn(packet, first)).count();
+        let fifo = seen.iter().take_while(|packet| **packet == filler).count()
+            == if release_slot { 31 } else { 32 };
+        let exact_packets = seen
+            .iter()
+            .all(|packet| *packet == filler || is_syn(packet, first));
+        // Do not free a Full peer and accidentally admit A while testing B.
+        if case == Case::StillFull && !single_peer {
+            for packet in seen.iter().cloned() {
+                a.tx.try_send(packet).unwrap();
+            }
+        }
+        let mut other_progress = true;
+        if !single_peer && matches!(case, Case::StillFull | Case::PeerStop) {
+            // Re-arm PacketStream with a fresh waker after A's offer ended;
+            // an old deferred yield wake cannot impersonate B's output barrier.
+            let sibling_wake = Arc::new(PumpWake::default());
+            let sibling_waker = Waker::from(sibling_wake.clone());
+            let mut sibling_cx = Context::from_waker(&sibling_waker);
+            assert!(
+                pump.as_mut().poll(&mut sibling_cx).is_pending(),
+                "fixture sibling re-arm ended pump"
+            );
+            assert!(
+                connect_other.as_mut().poll(&mut caller_cx).is_pending(),
+                "fixture sibling connect did not pend"
+            );
+            tokio::time::timeout(Duration::from_secs(2), sibling_wake.0.notified())
+                .await
+                .expect("fixture never emitted the sibling SYN");
+            for _ in 0..4 {
+                let _ = pump.as_mut().poll(&mut sibling_cx);
+            }
+            let mut sibling = Vec::new();
+            while let Ok(packet) = b_rx.try_recv() {
+                sibling.push(packet);
+            }
+            other_progress = sibling.iter().any(|packet| is_syn(packet, other));
+        }
+        cancel.cancel();
+        let joined = already_joined || pump.as_mut().poll(&mut cx).is_ready();
+        drop((pump, connect, connect_other));
+        a.stop().await;
+        b.stop().await;
+        control.stop().await;
+        let sockets_released = stats.snapshot().active_tcp == 0;
+        drop((a_rx, b_rx, slots, a, b, tcp_connector, packet_sink));
+        assert!(
+            joined && global_joined && sockets_released,
+            "fixture did not join/release: {case:?}"
+        );
+        assert!(
+            single_socket
+                && first_pending
+                && retained_pending
+                && continuing
+                && slot_unlocked
+                && fifo
+                && exact_packets,
+            "fixture/lock/FIFO boundary failed: {case:?}"
+        );
+        assert!(
+            other_progress,
+            "still-full/stopped peer blocked a sibling: {case:?}"
+        );
+        if case != Case::Release {
+            assert_eq!(
+                admitted, 0,
+                "full/cancelled peer unexpectedly admitted A: {case:?}"
+            );
+        }
+        admitted
+    }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn full_packet_gets_one_cooperative_handoff_without_blocking_stop_or_sibling() {
+        let admitted = exercise(Case::Release, false).await;
+        for case in [Case::StillFull, Case::PeerStop, Case::GlobalStop] {
+            exercise(case, false).await;
+        }
+        assert_eq!(
+            admitted, 1,
+            "a ready WireGuard peer must retain its Full SYN for one cooperative handoff when one slot opens"
+        );
+    }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn single_peer_full_packet_waits_for_space_without_blocking_cancel_or_release() {
+        let admitted = exercise(Case::Release, true).await;
+        for case in [Case::StillFull, Case::PeerStop, Case::GlobalStop] {
+            exercise(case, true).await;
+        }
+        assert_eq!(
+            admitted, 1,
+            "a single WireGuard peer must retain the original Full SYN until a slot opens"
+        );
+    }
+}
diff --git a/src/outbound/wireguard/mod.rs b/src/outbound/wireguard/mod.rs
new file mode 100644
index 0000000..6e25e93
--- /dev/null
+++ b/src/outbound/wireguard/mod.rs
@@ -0,0 +1,152 @@
+//! Standard WireGuard over shared controlled UDP and the active raw-IP stack.
+mod channel;
+mod datagram;
+mod engine;
+mod peer;
+mod resolver;
+mod routes;
+#[cfg(test)]
+mod tests;
+
+use crate::{
+    config::WireGuardOutboundConfig,
+    dispatch::{DatagramTransport, DispatchError},
+    outbound::{
+        ConnectedStream, DatagramRequest, EstablishContext, OutboundConnector, UpstreamPath,
+        owned_stream::OwnedStream,
+    },
+    resources::observation,
+    session::{DatagramSession, Destination, StreamSession},
+};
+use async_trait::async_trait;
+use engine::Engine;
+use std::{
+    io,
+    sync::{Arc, Mutex},
+};
+use tokio::sync::Mutex as AsyncMutex;
+use tokio_util::{sync::CancellationToken, task::TaskTracker};
+
+pub struct WireGuardOutbound {
+    security: crate::security::SecurityContext,
+    config: Arc<WireGuardOutboundConfig>,
+    upstream: UpstreamPath,
+    current: AsyncMutex<Option<Arc<Engine>>>,
+    cancel: CancellationToken,
+    admission: Mutex<()>,
+    retired: TaskTracker,
+}
+impl std::fmt::Debug for WireGuardOutbound {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("WireGuardOutbound").finish_non_exhaustive()
+    }
+}
+impl WireGuardOutbound {
+    pub fn new_with_path(
+        config: &WireGuardOutboundConfig,
+        upstream: UpstreamPath,
+    ) -> io::Result<Self> {
+        Self::with_shared_security(config, upstream, &crate::security::SecurityContext::new())
+    }
+    pub(crate) fn with_shared_security(
+        config: &WireGuardOutboundConfig,
+        upstream: UpstreamPath,
+        security: &crate::security::SecurityContext,
+    ) -> io::Result<Self> {
+        config.validate().map_err(|_| {
+            io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "invalid WireGuard configuration",
+            )
+        })?;
+        Ok(Self {
+            security: security.clone(),
+            config: Arc::new(config.clone()),
+            upstream,
+            current: AsyncMutex::new(None),
+            cancel: CancellationToken::new(),
+            admission: Mutex::new(()),
+            retired: TaskTracker::new(),
+        })
+    }
+    async fn engine(&self, context: &EstablishContext) -> Result<Arc<Engine>, DispatchError> {
+        let engine = tokio::select! { biased;
+            ()=self.cancel.cancelled()=>return Err(DispatchError::NotAllowed),
+            result=context.run("WireGuard initialize",async {
+                let mut current=self.current.lock().await;
+                if let Some(engine)=current.as_ref().filter(|engine|!engine.cancel.is_cancelled()) { return Ok(engine.clone()); }
+                let _admission=self.admission.lock().unwrap();
+                if self.cancel.is_cancelled() {return Err(DispatchError::NotAllowed);}
+                if let Some(old)=current.take() {self.retired.spawn(observation::task(async move {old.stop().await;}));}
+                let engine=Engine::start(self.config.clone(),self.upstream.clone(),context.clone(),self.cancel.child_token(),self.security.clone())?;
+                // Publish ownership before waiting for network setup or authentication.
+                *current=Some(engine.clone());
+                Ok(engine)
+            })=>result?,
+        };
+        Ok(engine)
+    }
+}
+#[async_trait]
+impl OutboundConnector for WireGuardOutbound {
+    async fn connect_stream(
+        &self,
+        session: StreamSession,
+        context: &EstablishContext,
+    ) -> Result<ConnectedStream, DispatchError> {
+        let datagram =
+            DatagramSession::new(session.inbound, session.source).with_metadata(session.metadata);
+        let engine = self.engine(context).await?;
+        let remote = resolver::resolve(
+            &engine,
+            &session.destination,
+            &context.resolution(),
+            context.deadline(),
+        )
+        .await?;
+        let channel = engine.peer(remote.ip(), datagram, context).await?;
+        engine.local(remote.ip())?;
+        let stream = tokio::select! {biased;
+            ()=channel.cancel.cancelled()=>return Err(DispatchError::ConnectionRefused),
+            result=context.run_io("WireGuard TCP",engine.tcp.connect(remote,context.deadline()))=>result?,
+        };
+        Ok(ConnectedStream {
+            io: Box::new(OwnedStream::new(
+                Box::new(stream),
+                channel.cancel.child_token(),
+            )),
+            effective_peer: Destination::Ip(remote),
+        })
+    }
+    async fn open_datagram(
+        &self,
+        request: DatagramRequest,
+        context: &EstablishContext,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        let engine = self.engine(context).await?;
+        Ok(Box::new(datagram::Datagrams::new(
+            engine,
+            request.budget(),
+            context.resolution(),
+            request.session,
+        )?))
+    }
+    fn begin_shutdown(&self) {
+        let _admission = self.admission.lock().unwrap();
+        self.cancel.cancel();
+        self.retired.close();
+    }
+    async fn shutdown(&self) {
+        self.begin_shutdown();
+        self.retired.wait().await;
+        let engine = self.current.lock().await.take();
+        if let Some(engine) = engine {
+            engine.stop().await;
+        }
+    }
+}
+impl Drop for WireGuardOutbound {
+    fn drop(&mut self) {
+        self.cancel.cancel();
+    }
+}
diff --git a/src/outbound/wireguard/peer.rs b/src/outbound/wireguard/peer.rs
new file mode 100644
index 0000000..136eaf7
--- /dev/null
+++ b/src/outbound/wireguard/peer.rs
@@ -0,0 +1,361 @@
+use super::{
+    channel::{Ready, Refresh},
+    datagram::{Registry, local_destination},
+    routes::Routes,
+};
+use crate::{
+    config::{WireGuardOutboundConfig, WireGuardPeerConfig},
+    dispatch::{DatagramBudget, DatagramTransport, DispatchError},
+    outbound::{
+        DEFAULT_ESTABLISH_TIMEOUT, DatagramRequest, EstablishContext, UpstreamPath,
+        server_destination,
+    },
+    session::{Datagram, DatagramSession, Destination},
+};
+use boringtun::{
+    noise::{Tunn, TunnResult, errors::WireGuardError},
+    x25519,
+};
+use bytes::Bytes;
+use std::{
+    net::{IpAddr, SocketAddr},
+    sync::{Arc, Mutex},
+    time::Duration,
+};
+use tokio::{
+    sync::{mpsc, watch},
+    time::{Instant, MissedTickBehavior},
+};
+use tokio_util::sync::CancellationToken;
+use vole_netstack::{Packet, PacketSink, parse_udp_packet_view};
+struct Driver {
+    config: Arc<WireGuardOutboundConfig>,
+    index: usize,
+    upstream: UpstreamPath,
+    session: DatagramSession,
+    cancel: CancellationToken,
+    ready: watch::Sender<Ready>,
+    sink: PacketSink,
+    registry: Arc<Registry>,
+    routes: Arc<Routes>,
+    updated: Arc<Mutex<Instant>>,
+}
+impl Driver {
+    fn peer(&self) -> &WireGuardPeerConfig {
+        &self.config.peers[self.index]
+    }
+    async fn endpoint(
+        &self,
+        context: &EstablishContext,
+        refresh: bool,
+    ) -> Result<(SocketAddr, UpstreamPath), DispatchError> {
+        let server = server_destination(&self.peer().address, self.peer().port)
+            .map_err(|_| DispatchError::HostUnreachable)?;
+        let path = self.upstream.for_server(&server, refresh);
+        let server = path.ip4p_datagram_server(&server, context).await?;
+        let endpoint = context
+            .resolution()
+            .resolve_proxy(&server, context.deadline())
+            .await?
+            .addresses
+            .into_iter()
+            .next()
+            .ok_or(DispatchError::HostUnreachable)?;
+        Ok((endpoint, path))
+    }
+    async fn transport(
+        &self,
+        endpoint: SocketAddr,
+        path: &UpstreamPath,
+        context: &EstablishContext,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        let size = self.config.mtu + 32;
+        let request = DatagramRequest::new(self.session.clone())
+            .with_budget(DatagramBudget::new(size, size))
+            .with_udp_receive_buffer_size(512 * 1024);
+        let mut transport = path.open_datagram(request, context).await?;
+        let budget = transport.payload_budget(&Destination::Ip(endpoint));
+        if budget.transmit() < size || budget.receive() < size {
+            let _ = tokio::time::timeout(Duration::from_secs(1), transport.close()).await;
+            return Err(DispatchError::Other(
+                "WireGuard MTU exceeds upstream UDP budget".into(),
+            ));
+        }
+        Ok(transport)
+    }
+    async fn handle(
+        &self,
+        result: TunnResult<'_>,
+        endpoint: SocketAddr,
+        transport: &mut dyn DatagramTransport,
+        deadline: Instant,
+    ) -> Result<(), DispatchError> {
+        match result {
+            TunnResult::Done => Ok(()),
+            TunnResult::Err(WireGuardError::ConnectionExpired) => {
+                Err(DispatchError::ConnectionRefused)
+            }
+            TunnResult::Err(_) => Ok(()),
+            TunnResult::WriteToNetwork(packet) => {
+                let mut wire = packet.to_vec();
+                wire[1..4].copy_from_slice(&self.peer().reserved);
+                let datagram = Datagram {
+                    remote: Destination::Ip(endpoint),
+                    payload: Bytes::from(wire),
+                    sniffed_domain: None,
+                };
+                tokio::select! {biased;()=self.cancel.cancelled()=>Err(DispatchError::ConnectionRefused),result=tokio::time::timeout_at(deadline,transport.send(datagram))=>result.map_err(|_|DispatchError::TimedOut)?}
+            }
+            TunnResult::WriteToTunnelV4(packet, _) | TunnResult::WriteToTunnelV6(packet, _) => {
+                let Some((src, dst)) = addresses(packet) else {
+                    return Ok(());
+                };
+                if !local_destination(&self.config, dst)
+                    || src.is_ipv4() != dst.is_ipv4()
+                    || self.routes.select(src) != Some(self.index)
+                {
+                    return Ok(());
+                }
+                if let Some(udp) = parse_udp_packet_view(packet) {
+                    self.registry
+                        .deliver(udp.source, udp.destination, udp.payload);
+                } else {
+                    let _ = self
+                        .sink
+                        .try_send(Packet::new(Bytes::copy_from_slice(packet)));
+                }
+                Ok(())
+            }
+        }
+    }
+}
+#[allow(clippy::too_many_arguments)]
+pub(super) async fn drive(
+    config: Arc<WireGuardOutboundConfig>,
+    index: usize,
+    upstream: UpstreamPath,
+    session: DatagramSession,
+    context: EstablishContext,
+    cancel: CancellationToken,
+    mut packets: mpsc::Receiver<Packet>,
+    mut commands: mpsc::Receiver<Refresh>,
+    ready: watch::Sender<Ready>,
+    sink: PacketSink,
+    registry: Arc<Registry>,
+    routes: Arc<Routes>,
+    updated: Arc<Mutex<Instant>>,
+) {
+    let driver = Driver {
+        config,
+        index,
+        upstream,
+        session,
+        cancel,
+        ready,
+        sink,
+        registry,
+        routes,
+        updated,
+    };
+    let setup = async {
+        let (endpoint, path) = driver.endpoint(&context, false).await?;
+        Ok((endpoint, driver.transport(endpoint, &path, &context).await?))
+    };
+    let result = tokio::select! {biased;()=driver.cancel.cancelled()=>Err(DispatchError::NotAllowed),result=context.run("WireGuard outer UDP",setup)=>result};
+    if let Ok((endpoint, mut transport)) = result {
+        *driver.updated.lock().unwrap() = Instant::now();
+        let mut tunn = Tunn::new(
+            x25519::StaticSecret::from(driver.config.private_key.bytes()),
+            x25519::PublicKey::from(driver.peer().public_key.bytes()),
+            driver.peer().pre_shared_key.as_ref().map(|key| key.bytes()),
+            Some(driver.config.persistent_keepalive),
+            rand::random::<u32>() >> 8,
+            None,
+        );
+        let size = usize::from(driver.config.mtu + 32).max(148);
+        let mut scratch = vec![0; size];
+        let mut network = vec![0; size];
+        let first = tunn.format_handshake_initiation(&mut scratch, true);
+        if driver
+            .handle(first, endpoint, transport.as_mut(), context.deadline())
+            .await
+            .is_ok()
+        {
+            let _ = run_peer(
+                &driver,
+                &mut tunn,
+                endpoint,
+                &mut transport,
+                &context,
+                &mut packets,
+                &mut commands,
+                &mut scratch,
+                &mut network,
+            )
+            .await;
+        }
+        driver.cancel.cancel();
+        let _ = tokio::time::timeout(Duration::from_secs(1), transport.close()).await;
+    }
+    driver.ready.send_replace(Ready::Failed);
+    driver.cancel.cancel();
+}
+#[allow(clippy::too_many_arguments)]
+async fn run_peer(
+    driver: &Driver,
+    tunn: &mut Tunn,
+    mut endpoint: SocketAddr,
+    transport: &mut Box<dyn DatagramTransport>,
+    context: &EstablishContext,
+    packets: &mut mpsc::Receiver<Packet>,
+    commands: &mut mpsc::Receiver<Refresh>,
+    scratch: &mut [u8],
+    network: &mut [u8],
+) -> Result<(), DispatchError> {
+    enum Event {
+        Datagram(Result<Datagram, DispatchError>),
+        Packet(Option<Packet>),
+        Command(Option<Refresh>),
+        Timer,
+    }
+    let mut timer = tokio::time::interval(Duration::from_millis(250));
+    timer.set_missed_tick_behavior(MissedTickBehavior::Skip);
+    let mut established = false;
+    let mut handshake_deadline = context.deadline();
+    loop {
+        let deadline = if established {
+            Instant::now() + DEFAULT_ESTABLISH_TIMEOUT
+        } else {
+            handshake_deadline
+        };
+        // Cancellation and the original handshake deadline stay ahead of all
+        // work. Ready network input must not starve output, refresh or timers.
+        let event = tokio::select! {biased;
+            ()=driver.cancel.cancelled()=>return Err(DispatchError::ConnectionRefused),
+            ()=tokio::time::sleep_until(handshake_deadline),if !established=>return Err(DispatchError::TimedOut),
+            event=async {
+                tokio::select! {
+                    datagram=transport.receive()=>Event::Datagram(datagram),
+                    packet=packets.recv(),if established=>Event::Packet(packet),
+                    command=commands.recv(),if established=>Event::Command(command),
+                    _=timer.tick()=>Event::Timer,
+                }
+            }=>event,
+        };
+        match event {
+            Event::Datagram(datagram) => {
+                let datagram = datagram?;
+                let len = datagram.payload.len();
+                if datagram.remote != Destination::Ip(endpoint)
+                    || !(4..=network.len()).contains(&len)
+                {
+                    continue;
+                }
+                // Standard packets already have zero reserved bytes. BoringTun
+                // borrows its input and returns only scratch-backed output.
+                let input: &[u8] = if datagram.payload[1..4] == [0, 0, 0] {
+                    datagram.payload.as_ref()
+                } else {
+                    // Preserve compatibility with a peer's nonzero reserved
+                    // bytes using the same existing normalization buffer.
+                    network[..len].copy_from_slice(&datagram.payload);
+                    network[1..4].fill(0);
+                    &network[..len]
+                };
+                let result = tunn.decapsulate(Some(endpoint.ip()), input, scratch);
+                let authenticated = matches!(input[0], 1 | 2)
+                    && matches!(result, TunnResult::WriteToNetwork(_))
+                    && tunn.time_since_last_handshake().is_some();
+                driver
+                    .handle(result, endpoint, transport.as_mut(), deadline)
+                    .await?;
+                loop {
+                    let result = tunn.decapsulate(None, &[], scratch);
+                    if matches!(result, TunnResult::Done) {
+                        break;
+                    }
+                    driver
+                        .handle(result, endpoint, transport.as_mut(), deadline)
+                        .await?;
+                }
+                if !established && authenticated {
+                    established = true;
+                    driver.ready.send_replace(Ready::Established);
+                    tracing::debug!("WireGuard handshake ready");
+                }
+            }
+            Event::Packet(packet) => {
+                let packet = packet.ok_or(DispatchError::ConnectionRefused)?;
+                driver
+                    .handle(
+                        tunn.encapsulate(packet.data(), scratch),
+                        endpoint,
+                        transport.as_mut(),
+                        deadline,
+                    )
+                    .await?;
+            }
+            Event::Command(command) => {
+                let Some(command) = command else {
+                    return Err(DispatchError::ConnectionRefused);
+                };
+                let refresh = async {
+                    let (next, path) = driver.endpoint(&command.context, true).await?;
+                    if next == endpoint {
+                        return Ok(None);
+                    }
+                    Ok(Some((
+                        next,
+                        driver.transport(next, &path, &command.context).await?,
+                    )))
+                };
+                let update = tokio::select! {biased;()=driver.cancel.cancelled()=>return Err(DispatchError::ConnectionRefused),result=command.context.run("WireGuard refresh",refresh)=>result};
+                if let Ok(next) = update {
+                    *driver.updated.lock().unwrap() = Instant::now();
+                    if let Some((next, new)) = next {
+                        let mut old = std::mem::replace(transport, new);
+                        endpoint = next;
+                        established = false;
+                        handshake_deadline = command.context.deadline();
+                        driver.ready.send_replace(Ready::Waiting);
+                        let _ = tokio::time::timeout(Duration::from_secs(1), old.close()).await;
+                        driver
+                            .handle(
+                                tunn.format_handshake_initiation(scratch, true),
+                                endpoint,
+                                transport.as_mut(),
+                                handshake_deadline,
+                            )
+                            .await?;
+                    }
+                }
+                // DNS/setup failure retains the old endpoint and is retried by
+                // a later business call, as in reference updateServerAddr.
+                let _ = command.reply.send(());
+            }
+            Event::Timer => {
+                driver
+                    .handle(
+                        tunn.update_timers(scratch),
+                        endpoint,
+                        transport.as_mut(),
+                        deadline,
+                    )
+                    .await?;
+            }
+        }
+    }
+}
+pub(super) fn addresses(packet: &[u8]) -> Option<(IpAddr, IpAddr)> {
+    match packet.first()? >> 4 {
+        4 if packet.len() >= 20 => Some((
+            IpAddr::from(<[u8; 4]>::try_from(&packet[12..16]).ok()?),
+            IpAddr::from(<[u8; 4]>::try_from(&packet[16..20]).ok()?),
+        )),
+        6 if packet.len() >= 40 => Some((
+            IpAddr::from(<[u8; 16]>::try_from(&packet[8..24]).ok()?),
+            IpAddr::from(<[u8; 16]>::try_from(&packet[24..40]).ok()?),
+        )),
+        _ => None,
+    }
+}
diff --git a/src/outbound/wireguard/resolver.rs b/src/outbound/wireguard/resolver.rs
new file mode 100644
index 0000000..e4437ed
--- /dev/null
+++ b/src/outbound/wireguard/resolver.rs
@@ -0,0 +1,75 @@
+//! Node DNS has a weak engine link; endpoint bootstrap never enters this resolver.
+use super::{datagram::Datagrams, engine::Engine};
+use crate::{
+    config::DnsConfig,
+    dispatch::{BoxStream, DatagramBudget, DatagramTransport, DispatchError, Dispatcher},
+    dns::{resolution::ResolutionContext, runtime::RuntimeDns},
+    outbound::{DEFAULT_ESTABLISH_TIMEOUT, EstablishContext, owned_stream::OwnedStream},
+    session::{DatagramSession, Destination, StreamSession},
+};
+use async_trait::async_trait;
+use std::{
+    net::SocketAddr,
+    sync::{Arc, Weak},
+};
+use tokio::time::Instant;
+pub(super) async fn resolve(
+    engine: &Arc<Engine>,
+    target: &Destination,
+    resolution: &ResolutionContext,
+    deadline: Instant,
+) -> Result<SocketAddr, DispatchError> {
+    tokio::select! {biased;()=engine.cancel.cancelled()=>Err(DispatchError::ConnectionRefused),result=async{
+        if engine.config.dns.is_empty(){return resolution.resolve_local_family(target,deadline,engine.ipv4.is_some(),engine.ipv6.is_some()).await;}
+        let dns=engine.remote.get_or_init(||{
+            let mut config=DnsConfig{enable:true,ipv6:engine.ipv6.is_some()&&resolution.ipv6_allowed(),nameservers:engine.config.dns.clone(),use_hosts:false,use_system_hosts:false,..Default::default()};
+            config.hosts.clear();config.default_nameservers.clear();
+            let dns=Arc::new(RuntimeDns::new_for_node(&config,Arc::new(NodeDns{engine:Arc::downgrade(engine)}),engine.resolution.clone(),engine.security.clone()));
+            dns.enable_refresh(None);
+            if engine.cancel.is_cancelled(){dns.begin_shutdown();}
+            dns
+        });
+        resolution.resolve_node_local(target,deadline,dns,engine.ipv4.is_some(),engine.ipv6.is_some()).await
+    }=>result}
+}
+struct NodeDns {
+    engine: Weak<Engine>,
+}
+#[async_trait]
+impl Dispatcher for NodeDns {
+    async fn connect_tcp(&self, session: StreamSession) -> Result<BoxStream, DispatchError> {
+        let engine = self
+            .engine
+            .upgrade()
+            .ok_or(DispatchError::ConnectionRefused)?;
+        let Destination::Ip(remote) = session.destination else {
+            return Err(DispatchError::HostUnreachable);
+        };
+        let context =
+            EstablishContext::with_resolution(DEFAULT_ESTABLISH_TIMEOUT, engine.resolution.clone());
+        let datagram =
+            DatagramSession::new(session.inbound, session.source).with_metadata(session.metadata);
+        let channel = engine.peer(remote.ip(), datagram, &context).await?;
+        let stream = tokio::select! {biased;()=channel.cancel.cancelled()=>return Err(DispatchError::ConnectionRefused),result=context.run_io("WireGuard DNS TCP",engine.tcp.connect(remote,context.deadline()))=>result?};
+        Ok(Box::new(OwnedStream::new(
+            Box::new(stream),
+            channel.cancel.child_token(),
+        )))
+    }
+    async fn open_datagram(
+        &self,
+        session: DatagramSession,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        let engine = self
+            .engine
+            .upgrade()
+            .ok_or(DispatchError::ConnectionRefused)?;
+        let resolution = engine.resolution.clone();
+        Ok(Box::new(Datagrams::new(
+            engine,
+            DatagramBudget::new(u16::MAX, session.max_response_payload_size()),
+            resolution,
+            session,
+        )?))
+    }
+}
diff --git a/src/outbound/wireguard/routes.rs b/src/outbound/wireguard/routes.rs
new file mode 100644
index 0000000..cc9d911
--- /dev/null
+++ b/src/outbound/wireguard/routes.rs
@@ -0,0 +1,206 @@
+//! Immutable longest-prefix ownership, shared by send and authenticated receive.
+use crate::config::WireGuardOutboundConfig;
+use std::{collections::HashMap, net::IpAddr};
+pub(super) struct Routes {
+    v4: HashMap<(u32, u8), usize>,
+    v6: HashMap<(u128, u8), usize>,
+}
+impl Routes {
+    pub fn new(config: &WireGuardOutboundConfig) -> Self {
+        let mut routes = Self {
+            v4: HashMap::new(),
+            v6: HashMap::new(),
+        };
+        for (cidr, index) in &config.routes {
+            match cidr.network {
+                IpAddr::V4(ip) => {
+                    let network = if cidr.prefix_len == 0 {
+                        0
+                    } else {
+                        u32::from(ip) & (u32::MAX << (32 - cidr.prefix_len))
+                    };
+                    routes.v4.insert((network, cidr.prefix_len), *index);
+                }
+                IpAddr::V6(ip) => {
+                    let network = if cidr.prefix_len == 0 {
+                        0
+                    } else {
+                        u128::from(ip) & (u128::MAX << (128 - cidr.prefix_len))
+                    };
+                    routes.v6.insert((network, cidr.prefix_len), *index);
+                }
+            }
+        }
+        routes
+    }
+    pub fn select(&self, ip: IpAddr) -> Option<usize> {
+        match ip {
+            IpAddr::V4(ip) => {
+                let ip = u32::from(ip);
+                if self.v4.is_empty() {
+                    return None;
+                }
+                if self.v4.len() == 1 {
+                    let (&(network, prefix), &owner) = self.v4.iter().next()?;
+                    let masked = if prefix == 0 {
+                        0
+                    } else {
+                        ip & (u32::MAX << (32 - prefix))
+                    };
+                    return (masked == network).then_some(owner);
+                }
+                (0..=32).rev().find_map(|prefix| {
+                    self.v4
+                        .get(&(
+                            if prefix == 0 {
+                                0
+                            } else {
+                                ip & (u32::MAX << (32 - prefix))
+                            },
+                            prefix,
+                        ))
+                        .copied()
+                })
+            }
+            IpAddr::V6(ip) => {
+                let ip = u128::from(ip);
+                if self.v6.is_empty() {
+                    return None;
+                }
+                if self.v6.len() == 1 {
+                    let (&(network, prefix), &owner) = self.v6.iter().next()?;
+                    let masked = if prefix == 0 {
+                        0
+                    } else {
+                        ip & (u128::MAX << (128 - prefix))
+                    };
+                    return (masked == network).then_some(owner);
+                }
+                (0..=128).rev().find_map(|prefix| {
+                    self.v6
+                        .get(&(
+                            if prefix == 0 {
+                                0
+                            } else {
+                                ip & (u128::MAX << (128 - prefix))
+                            },
+                            prefix,
+                        ))
+                        .copied()
+                })
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn table(entries: &[(&str, u8, usize)]) -> Routes {
+        let mut config = crate::outbound::wireguard::tests::config();
+        let peer = config.peers[0].clone();
+        let owners = entries.iter().map(|entry| entry.2).max().unwrap_or(0) + 1;
+        config.peers.resize(owners, peer);
+        config.routes = entries
+            .iter()
+            .map(|&(network, prefix_len, owner)| {
+                (
+                    crate::config::IpCidr {
+                        network: network.parse().unwrap(),
+                        prefix_len,
+                    },
+                    owner,
+                )
+            })
+            .collect();
+        config.validate().unwrap();
+        Routes::new(&config)
+    }
+
+    #[test]
+    fn wireguard_single_ipv4_route_keeps_prefix_and_host_boundaries() {
+        let narrow = table(&[("192.0.2.129", 24, 2)]);
+        for ip in ["192.0.2.0", "192.0.2.255"] {
+            assert_eq!(narrow.select(ip.parse().unwrap()), Some(2));
+        }
+        assert_eq!(narrow.select("192.0.3.0".parse().unwrap()), None);
+        assert_eq!(narrow.select("2001:db8::1".parse().unwrap()), None);
+
+        let default = table(&[("0.0.0.0", 0, 1)]);
+        for ip in ["0.0.0.0", "255.255.255.255"] {
+            assert_eq!(default.select(ip.parse().unwrap()), Some(1));
+        }
+        let host = table(&[("203.0.113.9", 32, 0)]);
+        assert_eq!(host.select("203.0.113.9".parse().unwrap()), Some(0));
+        for ip in ["203.0.113.8", "203.0.113.10"] {
+            assert_eq!(host.select(ip.parse().unwrap()), None);
+        }
+    }
+
+    #[test]
+    fn wireguard_single_ipv6_route_keeps_prefix_and_host_boundaries() {
+        let narrow = table(&[("2001:db8:1:2::99", 64, 2)]);
+        for ip in ["2001:db8:1:2::", "2001:db8:1:2:ffff:ffff:ffff:ffff"] {
+            assert_eq!(narrow.select(ip.parse().unwrap()), Some(2));
+        }
+        assert_eq!(narrow.select("2001:db8:1:3::".parse().unwrap()), None);
+        assert_eq!(narrow.select("192.0.2.1".parse().unwrap()), None);
+
+        let default = table(&[("::", 0, 1)]);
+        for ip in ["::", "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"] {
+            assert_eq!(default.select(ip.parse().unwrap()), Some(1));
+        }
+        let host = table(&[("2001:db8::9", 128, 0)]);
+        assert_eq!(host.select("2001:db8::9".parse().unwrap()), Some(0));
+        for ip in ["2001:db8::8", "2001:db8::10"] {
+            assert_eq!(host.select(ip.parse().unwrap()), None);
+        }
+    }
+
+    #[test]
+    fn wireguard_route_tables_preserve_lpm_and_last_prefix_owner() {
+        let routes = table(&[
+            ("0.0.0.0", 0, 0),
+            ("192.0.0.0", 16, 1),
+            ("192.0.2.1", 24, 1),
+            ("192.0.2.129", 24, 2),
+            ("::", 0, 0),
+            ("2001:db8::", 32, 1),
+            ("2001:db8:1:2::", 64, 1),
+            ("2001:db8:1:2::99", 64, 2),
+        ]);
+        for (ip, owner) in [
+            ("192.0.2.255", 2),
+            ("192.0.3.1", 1),
+            ("198.51.100.1", 0),
+            ("2001:db8:1:2::1", 2),
+            ("2001:db8:1:3::1", 1),
+            ("2001:db9::1", 0),
+        ] {
+            assert_eq!(routes.select(ip.parse().unwrap()), Some(owner));
+        }
+
+        let repeated = table(&[
+            ("192.0.2.1", 24, 1),
+            ("192.0.2.129", 24, 2),
+            ("2001:db8:1:2::", 64, 1),
+            ("2001:db8:1:2::99", 64, 2),
+        ]);
+        assert_eq!(repeated.v4.len(), 1);
+        assert_eq!(repeated.v6.len(), 1);
+        assert_eq!(repeated.select("192.0.2.1".parse().unwrap()), Some(2));
+        assert_eq!(repeated.select("2001:db8:1:2::1".parse().unwrap()), Some(2));
+    }
+
+    #[test]
+    fn wireguard_empty_family_tables_never_cross_route() {
+        let empty = table(&[]);
+        assert_eq!(empty.select("192.0.2.1".parse().unwrap()), None);
+        assert_eq!(empty.select("2001:db8::1".parse().unwrap()), None);
+        let v4_only = table(&[("0.0.0.0", 0, 0)]);
+        assert_eq!(v4_only.select("2001:db8::1".parse().unwrap()), None);
+        let v6_only = table(&[("::", 0, 0)]);
+        assert_eq!(v6_only.select("192.0.2.1".parse().unwrap()), None);
+    }
+}
diff --git a/src/outbound/wireguard/tests.rs b/src/outbound/wireguard/tests.rs
new file mode 100644
index 0000000..fe9e368
--- /dev/null
+++ b/src/outbound/wireguard/tests.rs
@@ -0,0 +1,893 @@
+//! Actual Noise handshake and raw TCP/UDP over bounded memory IO.
+use super::*;
+use crate::{
+    dispatch::DatagramBudget,
+    resources::observation::{ResourceKind, ResourceProbe},
+    session::{Datagram, InboundKind, InboundMetadata},
+};
+use base64::{Engine as _, engine::general_purpose::STANDARD};
+use boringtun::{
+    noise::{Tunn, TunnResult},
+    x25519,
+};
+use bytes::Bytes;
+use std::{
+    collections::VecDeque,
+    future::pending,
+    sync::atomic::{AtomicBool, AtomicUsize, Ordering},
+    time::Duration,
+};
+use tokio::{
+    io::{AsyncReadExt, AsyncWriteExt},
+    task::JoinHandle,
+};
+use vole_netstack::{
+    NetStack, NetStackConfig, NetStackControl, Packet, PacketSink, PacketStream, TcpNetStackParts,
+    UdpDatagram, encode_udp_packet_into, parse_udp_packet_view,
+};
+
+const ENDPOINT: &str = "198.51.100.1:51820";
+const SECOND: &str = "198.51.100.2:51820";
+pub(super) fn config() -> WireGuardOutboundConfig {
+    config_with_peer(2)
+}
+fn config_with_peer(peer_secret: u8) -> WireGuardOutboundConfig {
+    let client = STANDARD.encode([1u8; 32]);
+    let peer = STANDARD
+        .encode(x25519::PublicKey::from(&x25519::StaticSecret::from([peer_secret; 32])).as_bytes());
+    let yaml = format!(
+        "mixed-port: 1080\nproxies: [{{name: wg, type: wireguard, server: 198.51.100.1, port: 51820, ip: 10.0.0.2/24, ipv6: 'fd00::2/64', private-key: '{client}', public-key: '{peer}', udp: true}}]\nrules: ['MATCH,wg']"
+    );
+    let parsed = crate::config::Config::parse_yaml(yaml.as_bytes()).unwrap();
+    let crate::config::ProxyProtocol::WireGuard(config) = parsed.proxies[0].protocol.clone() else {
+        panic!()
+    };
+    config
+}
+fn session() -> StreamSession {
+    StreamSession {
+        metadata: InboundMetadata::new(1080),
+        inbound: InboundKind::Https,
+        source: "192.0.2.1:20000".parse().unwrap(),
+        destination: Destination::Ip("10.0.0.1:80".parse().unwrap()),
+        sniffed_domain: None,
+    }
+}
+
+#[derive(Default)]
+struct ReceiveFlood {
+    remaining: AtomicUsize,
+    sent_while_ready: AtomicBool,
+    armed: tokio::sync::Notify,
+}
+
+struct Peer {
+    multi: bool,
+    reserved: bool,
+    records: Arc<Mutex<Vec<Destination>>>,
+    dns_queries: Arc<AtomicUsize>,
+    silent: bool,
+    silent_first: bool,
+    sends: Arc<AtomicUsize>,
+    closes: Arc<AtomicUsize>,
+    flood: Arc<ReceiveFlood>,
+}
+#[async_trait]
+impl OutboundConnector for Peer {
+    async fn connect_stream(
+        &self,
+        _: StreamSession,
+        _: &EstablishContext,
+    ) -> Result<ConnectedStream, DispatchError> {
+        Err(DispatchError::NotAllowed)
+    }
+    async fn open_datagram(
+        &self,
+        _: DatagramRequest,
+        _: &EstablishContext,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        let TcpNetStackParts {
+            packet_sink,
+            packet_stream,
+            mut tcp_listener,
+            control,
+            ..
+        } = NetStack::start_tcp(NetStackConfig {
+            mtu: 1408,
+            ..Default::default()
+        })
+        .unwrap();
+        let echo = observation::spawn(async move {
+            if let Some(mut stream) = tcp_listener.accept().await {
+                let mut bytes = [0; 4];
+                if stream.read_exact(&mut bytes).await.is_ok() {
+                    stream.write_all(&bytes).await.unwrap();
+                    stream.shutdown().await.unwrap();
+                }
+            }
+        });
+        Ok(Box::new(MemoryPeer {
+            endpoint: None,
+            multi: self.multi,
+            reserved: self.reserved,
+            records: self.records.clone(),
+            dns_queries: self.dns_queries.clone(),
+            tunn: Tunn::new(
+                x25519::StaticSecret::from([2; 32]),
+                x25519::PublicKey::from(&x25519::StaticSecret::from([1; 32])),
+                None,
+                None,
+                2,
+                None,
+            ),
+            sink: packet_sink,
+            packets: packet_stream,
+            control,
+            echo: Some(echo),
+            network: VecDeque::new(),
+            silent: self.silent,
+            silent_first: self.silent_first,
+            sends: self.sends.clone(),
+            closes: self.closes.clone(),
+            flood: self.flood.clone(),
+            scratch: vec![0; 1440],
+        }))
+    }
+}
+struct MemoryPeer {
+    endpoint: Option<Destination>,
+    multi: bool,
+    reserved: bool,
+    records: Arc<Mutex<Vec<Destination>>>,
+    dns_queries: Arc<AtomicUsize>,
+    tunn: Tunn,
+    sink: PacketSink,
+    packets: PacketStream,
+    control: NetStackControl,
+    echo: Option<JoinHandle<()>>,
+    network: VecDeque<Bytes>,
+    silent: bool,
+    silent_first: bool,
+    sends: Arc<AtomicUsize>,
+    closes: Arc<AtomicUsize>,
+    flood: Arc<ReceiveFlood>,
+    scratch: Vec<u8>,
+}
+impl MemoryPeer {
+    fn network(&mut self, result: TunnResult<'_>) -> Option<Vec<u8>> {
+        match result {
+            TunnResult::WriteToNetwork(packet) => {
+                let mut packet = packet.to_vec();
+                if self.reserved {
+                    packet[1..4].copy_from_slice(&[7, 8, 9]);
+                }
+                self.network.push_back(Bytes::from(packet));
+                None
+            }
+            TunnResult::WriteToTunnelV4(packet, _) | TunnResult::WriteToTunnelV6(packet, _) => {
+                Some(packet.to_vec())
+            }
+            TunnResult::Done => None,
+            TunnResult::Err(error) => panic!("memory peer rejected protocol: {error:?}"),
+        }
+    }
+    async fn decrypt(&mut self, packet: &[u8]) -> Result<(), DispatchError> {
+        // Separate scratch permits the result borrow while updating fixture queues.
+        let mut scratch = std::mem::take(&mut self.scratch);
+        let result = self.tunn.decapsulate(None, packet, &mut scratch);
+        let raw = self.network(result);
+        self.scratch = scratch;
+        if let Some(raw) = raw {
+            if let Some(udp) = parse_udp_packet_view(&raw) {
+                let payload = if self.multi && udp.destination.port() == 53 {
+                    self.dns_queries.fetch_add(1, Ordering::Relaxed);
+                    let query = crate::dns::parse_query(udp.payload).unwrap();
+                    assert_eq!(query.question.name, "remote.example");
+                    assert_eq!(
+                        &udp.payload[udp.payload.len() - 12..],
+                        &[0, 8, 0, 8, 0, 1, 25, 0, 192, 0, 2, 128],
+                        "private DNS ECS reaches the real encrypted raw-IP data plane"
+                    );
+                    let classified = crate::dns::classify_query(udp.payload).unwrap();
+                    let mut wire = crate::dns::synthesize_empty_response(&classified, 0).unwrap();
+                    wire[6..8].copy_from_slice(&1u16.to_be_bytes());
+                    wire.extend_from_slice(&[
+                        0xc0, 0x0c, 0, 1, 0, 1, 0, 0, 0, 30, 0, 4, 10, 1, 0, 1,
+                    ]);
+                    Bytes::from(wire)
+                } else {
+                    Bytes::copy_from_slice(udp.payload)
+                };
+                let datagram = UdpDatagram::new(udp.destination, udp.source, payload);
+                let mut response = Vec::with_capacity(1408);
+                encode_udp_packet_into(&datagram, 1408, &mut response).unwrap();
+                self.encrypt(&response);
+            } else {
+                self.sink
+                    .send(Packet::new(raw))
+                    .await
+                    .map_err(|_| DispatchError::ConnectionRefused)?;
+            }
+        }
+        loop {
+            let mut scratch = std::mem::take(&mut self.scratch);
+            let result = self.tunn.decapsulate(None, &[], &mut scratch);
+            let done = matches!(result, TunnResult::Done);
+            let _ = self.network(result);
+            self.scratch = scratch;
+            if done {
+                break;
+            }
+        }
+        Ok(())
+    }
+    fn encrypt(&mut self, packet: &[u8]) {
+        let mut scratch = std::mem::take(&mut self.scratch);
+        let result = self.tunn.encapsulate(packet, &mut scratch);
+        let _ = self.network(result);
+        self.scratch = scratch;
+    }
+}
+#[async_trait]
+impl DatagramTransport for MemoryPeer {
+    fn supports_shared_destinations(&self) -> bool {
+        // This Noise fixture binds its identity to the first outer endpoint.
+        false
+    }
+    fn payload_budget(&self, _: &Destination) -> DatagramBudget {
+        DatagramBudget::new(1440, 1440)
+    }
+    async fn send(&mut self, datagram: Datagram) -> Result<(), DispatchError> {
+        if self.flood.remaining.load(Ordering::Relaxed) != 0 {
+            self.flood.sent_while_ready.store(true, Ordering::Relaxed);
+        }
+        if self.endpoint.is_none() {
+            assert!(
+                datagram.remote == Destination::Ip(ENDPOINT.parse().unwrap())
+                    || datagram.remote == Destination::Ip(SECOND.parse().unwrap())
+            );
+            self.endpoint = Some(datagram.remote.clone());
+            if self.multi && datagram.remote == Destination::Ip(SECOND.parse().unwrap()) {
+                self.tunn = Tunn::new(
+                    x25519::StaticSecret::from([3; 32]),
+                    x25519::PublicKey::from(&x25519::StaticSecret::from([1; 32])),
+                    None,
+                    None,
+                    3,
+                    None,
+                );
+            }
+        }
+        assert_eq!(self.endpoint.as_ref(), Some(&datagram.remote));
+        if self.reserved {
+            assert_eq!(
+                &datagram.payload[1..4],
+                if self.multi && datagram.remote == Destination::Ip(SECOND.parse().unwrap()) {
+                    &[4, 5, 6]
+                } else {
+                    &[1, 2, 3]
+                }
+            );
+        }
+        self.records.lock().unwrap().push(datagram.remote.clone());
+        self.sends.fetch_add(1, Ordering::Relaxed);
+        if !self.silent
+            && !(self.silent_first && datagram.remote == Destination::Ip(ENDPOINT.parse().unwrap()))
+        {
+            let mut wire = datagram.payload.to_vec();
+            wire[1..4].fill(0);
+            self.decrypt(&wire).await?;
+        }
+        Ok(())
+    }
+    async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+        loop {
+            if self.flood.remaining.load(Ordering::Relaxed) != 0 {
+                self.flood.remaining.fetch_sub(1, Ordering::Relaxed);
+                self.encrypt(&[]);
+            }
+            if let Some(payload) = self.network.pop_front() {
+                return Ok(Datagram {
+                    remote: self.endpoint.clone().unwrap(),
+                    payload,
+                    sniffed_domain: None,
+                });
+            }
+            if self.silent
+                || (self.silent_first
+                    && self.endpoint == Some(Destination::Ip(ENDPOINT.parse().unwrap())))
+            {
+                return pending().await;
+            }
+            let packet = tokio::select! {
+                biased;
+                () = self.flood.armed.notified() => continue,
+                packet = self.packets.recv() => packet.ok_or(DispatchError::ConnectionRefused)?,
+            };
+            self.encrypt(packet.data());
+        }
+    }
+    async fn close(&mut self) -> Result<(), DispatchError> {
+        self.control.stop().await;
+        if let Some(echo) = self.echo.take() {
+            let _ = echo.await;
+        }
+        self.closes.fetch_add(1, Ordering::Relaxed);
+        Ok(())
+    }
+}
+impl Drop for MemoryPeer {
+    fn drop(&mut self) {
+        self.control.cancel();
+        if let Some(echo) = self.echo.take() {
+            echo.abort();
+        }
+    }
+}
+
+pub(super) fn outbound(
+    silent: bool,
+) -> (Arc<WireGuardOutbound>, Arc<AtomicUsize>, Arc<AtomicUsize>) {
+    outbound_with_flood(silent, Arc::default())
+}
+
+fn outbound_with_flood(
+    silent: bool,
+    flood: Arc<ReceiveFlood>,
+) -> (Arc<WireGuardOutbound>, Arc<AtomicUsize>, Arc<AtomicUsize>) {
+    let sends = Arc::new(AtomicUsize::new(0));
+    let closes = Arc::new(AtomicUsize::new(0));
+    let peer = Arc::new(Peer {
+        multi: false,
+        reserved: false,
+        records: Arc::default(),
+        dns_queries: Arc::default(),
+        silent,
+        silent_first: false,
+        sends: sends.clone(),
+        closes: closes.clone(),
+        flood,
+    });
+    (
+        Arc::new(WireGuardOutbound::new_with_path(&config(), UpstreamPath::Proxy(peer)).unwrap()),
+        sends,
+        closes,
+    )
+}
+
+#[tokio::test(flavor = "current_thread")]
+async fn wireguard_memory_ready_receive_does_not_starve_send_or_stop() {
+    let probe = ResourceProbe::default();
+    probe
+        .scope(async {
+            let flood = Arc::new(ReceiveFlood::default());
+            let (outbound, _, closes) = outbound_with_flood(false, flood.clone());
+            let context = EstablishContext::with_timeout(Duration::from_secs(2));
+            let request =
+                DatagramRequest::new(DatagramSession::new(InboundKind::Socks5, session().source));
+            let mut udp = outbound.open_datagram(request, &context).await.unwrap();
+            let remote = Destination::Ip("10.0.0.1:53".parse().unwrap());
+            let send = |payload| Datagram {
+                remote: remote.clone(),
+                payload: Bytes::from_static(payload),
+                sniffed_domain: None,
+            };
+            udp.send(send(b"warmup")).await.unwrap();
+            assert_eq!(udp.receive().await.unwrap().payload.as_ref(), b"warmup");
+
+            // On this current-thread runtime, enqueue before the peer resumes.
+            // Both a real encrypted inbound keepalive and outgoing data are
+            // then ready; a receive-first driver exhausts this finite flood.
+            flood.remaining.store(1024, Ordering::Relaxed);
+            flood.armed.notify_one();
+            udp.send(send(b"fair")).await.unwrap();
+            let echoed = tokio::time::timeout(Duration::from_secs(2), udp.receive())
+                .await
+                .unwrap()
+                .unwrap();
+            assert_eq!(echoed.payload.as_ref(), b"fair");
+            let progressed_while_ready = flood.sent_while_ready.load(Ordering::Relaxed);
+
+            flood.remaining.store(1024, Ordering::Relaxed);
+            tokio::time::timeout(Duration::from_secs(1), outbound.shutdown())
+                .await
+                .unwrap();
+            assert_eq!(closes.load(Ordering::Relaxed), 1);
+            assert_eq!(flood.remaining.load(Ordering::Relaxed), 1024);
+            drop(udp);
+            assert!(probe.snapshot().is_idle());
+            assert!(
+                progressed_while_ready,
+                "queued outbound data waited until every ready inbound keepalive was consumed"
+            );
+        })
+        .await;
+}
+
+#[tokio::test]
+async fn wireguard_memory_noise_tcp_dual_stack_udp_and_stop_release() {
+    let probe = ResourceProbe::default();
+    probe
+        .scope(async {
+            let (outbound, _, closes) = outbound(false);
+            let context = EstablishContext::with_timeout(Duration::from_secs(2));
+            let mut connected = outbound.connect_stream(session(), &context).await.unwrap();
+            connected.io.write_all(b"test").await.unwrap();
+            let mut echoed = [0; 4];
+            tokio::time::timeout(Duration::from_secs(2), connected.io.read_exact(&mut echoed))
+                .await
+                .unwrap()
+                .unwrap();
+            assert_eq!(&echoed, b"test");
+            assert_eq!(connected.effective_peer, session().destination);
+            let request =
+                DatagramRequest::new(DatagramSession::new(InboundKind::Socks5, session().source))
+                    .with_max_response_payload_size(1200);
+            let mut udp = outbound.open_datagram(request, &context).await.unwrap();
+            assert_eq!(udp.payload_budget(&session().destination).receive(), 1200);
+            for remote in ["10.0.0.1:53", "[fd00::1]:53"] {
+                let remote = Destination::Ip(remote.parse().unwrap());
+                udp.send(Datagram {
+                    remote: remote.clone(),
+                    payload: Bytes::from_static(b"udp"),
+                    sniffed_domain: None,
+                })
+                .await
+                .unwrap();
+                let reply = tokio::time::timeout(Duration::from_secs(2), udp.receive())
+                    .await
+                    .unwrap()
+                    .unwrap();
+                assert_eq!(reply.remote, remote);
+                assert_eq!(reply.payload.as_ref(), b"udp");
+            }
+            udp.close().await.unwrap();
+            drop(udp);
+            drop(connected);
+            let weak = Arc::downgrade(outbound.current.lock().await.as_ref().unwrap());
+            outbound.shutdown().await;
+            assert_eq!(closes.load(Ordering::Relaxed), 1);
+            assert!(weak.upgrade().is_none());
+            assert_eq!(probe.snapshot().current(ResourceKind::Task), 0);
+            assert!(probe.snapshot().is_idle());
+        })
+        .await;
+}
+
+#[tokio::test]
+async fn wireguard_memory_shared_udp_targets_cancel_and_close_independently() {
+    let probe = ResourceProbe::default();
+    probe
+        .scope(async {
+            let (outbound, _, closes) = outbound(false);
+            let context = EstablishContext::with_timeout(Duration::from_secs(2));
+            let source = "192.0.2.1:23000".parse().unwrap();
+            let request = || {
+                DatagramRequest::new(DatagramSession::new(InboundKind::Tun, source))
+                    .with_max_response_payload_size(1200)
+            };
+            let mut shared = outbound.open_datagram(request(), &context).await.unwrap();
+            assert!(shared.supports_shared_destinations());
+            let mut waiting = Box::pin(shared.receive());
+            assert!(futures_util::poll!(waiting.as_mut()).is_pending());
+            drop(waiting);
+
+            let targets = ["10.0.0.1:53", "10.0.0.3:443", "[fd00::1]:443"];
+            for (index, target) in targets.into_iter().enumerate() {
+                shared
+                    .send(Datagram {
+                        remote: Destination::Ip(target.parse().unwrap()),
+                        payload: Bytes::from(vec![u8::try_from(index).unwrap()]),
+                        sniffed_domain: None,
+                    })
+                    .await
+                    .unwrap();
+            }
+            for (index, target) in targets.into_iter().enumerate() {
+                let reply = tokio::time::timeout(Duration::from_secs(2), shared.receive())
+                    .await
+                    .unwrap()
+                    .unwrap();
+                assert_eq!(reply.remote, Destination::Ip(target.parse().unwrap()));
+                assert_eq!(reply.payload.as_ref(), &[u8::try_from(index).unwrap()]);
+            }
+
+            let mut sibling = outbound
+                .open_datagram(
+                    DatagramRequest::new(DatagramSession::new(
+                        InboundKind::Tun,
+                        "192.0.2.2:23000".parse().unwrap(),
+                    )),
+                    &context,
+                )
+                .await
+                .unwrap();
+            let send = |payload| Datagram {
+                remote: Destination::Ip(targets[0].parse().unwrap()),
+                payload: Bytes::from_static(payload),
+                sniffed_domain: None,
+            };
+            sibling.send(send(b"sibling")).await.unwrap();
+            let reply = tokio::time::timeout(Duration::from_secs(2), sibling.receive())
+                .await
+                .unwrap()
+                .unwrap();
+            assert_eq!(reply.payload.as_ref(), b"sibling");
+            let mut waiting = Box::pin(shared.receive());
+            assert!(futures_util::poll!(waiting.as_mut()).is_pending());
+            drop(waiting);
+
+            shared.close().await.unwrap();
+            assert!(shared.send(send(b"closed")).await.is_err());
+            assert!(shared.receive().await.is_err());
+            let mut rebuilt = outbound.open_datagram(request(), &context).await.unwrap();
+            rebuilt.send(send(b"rebuilt")).await.unwrap();
+            sibling.send(send(b"still-live")).await.unwrap();
+            for (transport, payload) in [
+                (&mut rebuilt, b"rebuilt".as_slice()),
+                (&mut sibling, b"still-live".as_slice()),
+            ] {
+                let reply = tokio::time::timeout(Duration::from_secs(2), transport.receive())
+                    .await
+                    .unwrap()
+                    .unwrap();
+                assert_eq!(reply.payload.as_ref(), payload);
+                transport.close().await.unwrap();
+            }
+            drop((shared, rebuilt, sibling));
+            outbound.shutdown().await;
+            assert_eq!(closes.load(Ordering::Relaxed), 1);
+            assert!(probe.snapshot().is_idle());
+        })
+        .await;
+}
+
+#[tokio::test]
+async fn wireguard_memory_unanswered_handshake_deadline_drop_and_stop() {
+    let probe = ResourceProbe::default();
+    probe
+        .scope(async {
+            let (outbound, sends, closes) = outbound(true);
+            let result = outbound
+                .connect_stream(
+                    session(),
+                    &EstablishContext::with_timeout(Duration::from_millis(30)),
+                )
+                .await;
+            assert!(matches!(
+                result,
+                Err(DispatchError::TimedOut) | Err(DispatchError::ConnectionRefused)
+            ));
+            assert!(sends.load(Ordering::Relaxed) >= 1);
+            // A new generation is published and owned even if its caller disappears.
+            tokio::time::sleep(Duration::from_millis(5)).await;
+            let second = outbound.clone();
+            let task = tokio::spawn(async move {
+                second
+                    .connect_stream(
+                        session(),
+                        &EstablishContext::with_timeout(Duration::from_secs(30)),
+                    )
+                    .await
+            });
+            // Boringtun uses a real monotonic clock: witness one actual timer retry.
+            tokio::time::timeout(Duration::from_secs(7), async {
+                while sends.load(Ordering::Relaxed) < 3 {
+                    tokio::time::sleep(Duration::from_millis(10)).await;
+                }
+            })
+            .await
+            .unwrap();
+            task.abort();
+            let _ = task.await;
+            assert!(outbound.current.lock().await.is_some());
+            tokio::time::timeout(Duration::from_secs(1), outbound.shutdown())
+                .await
+                .unwrap();
+            assert_eq!(closes.load(Ordering::Relaxed), 2);
+            assert!(probe.snapshot().is_idle());
+        })
+        .await;
+}
+
+#[test]
+fn wireguard_configuration_keys_prefixes_defaults_and_redaction() {
+    let config = config();
+    assert_eq!(config.ipv4, Some("10.0.0.2".parse().unwrap()));
+    assert_eq!(config.ipv6, Some("fd00::2".parse().unwrap()));
+    assert_eq!(config.mtu, 1408);
+    assert_eq!(config.refresh_server_ip_interval, 0);
+    assert!(config.dns.is_empty());
+    let first_key = STANDARD.encode([2; 32]);
+    let second_key = STANDARD.encode([3; 32]);
+    let shared_key = STANDARD.encode([4; 32]);
+    let private_key = STANDARD.encode([1; 32]);
+    let yaml = format!(
+        "mixed-port: 1080\nproxies:\n  - name: wg\n    type: wireguard\n    ip: 10.0.0.2\n    private-key: '{private_key}'\n    reserved: [1, 2, 3]\n    remote-dns-resolve: true\n    dns: ['dns.example#unused-route']\n    refresh-server-ip-interval: -1\n    peers:\n      - {{server: 198.51.100.1, port: 51820, public-key: '{first_key}', pre-shared-key: '{shared_key}', allowed-ips: ['0.0.0.0/0']}}\n      - {{server: 198.51.100.2, port: 51820, public-key: '{second_key}', reserved: [4, 5, 6], allowed-ips: ['10.1.0.0/16']}}\n      - {{server: 198.51.100.3, port: 51821, public-key: '{first_key}', allowed-ips: ['10.1.7.9/16']}}\nrules: ['MATCH,wg']"
+    );
+    let parse = |yaml: &str| {
+        let parsed = crate::config::Config::parse_yaml(yaml.as_bytes()).unwrap();
+        let crate::config::ProxyProtocol::WireGuard(config) = parsed.proxies[0].protocol.clone()
+        else {
+            panic!()
+        };
+        config
+    };
+    let peers = parse(&yaml);
+    assert_eq!(peers.peers.len(), 2);
+    assert_eq!(peers.address, "198.51.100.3");
+    assert_eq!(peers.port, 51821);
+    assert_eq!(
+        peers.peers[0].pre_shared_key.as_ref().unwrap().bytes(),
+        [4; 32]
+    );
+    assert_eq!(peers.peers[0].reserved, [1, 2, 3]);
+    assert_eq!(peers.peers[1].reserved, [4, 5, 6]);
+    assert_eq!(peers.refresh_server_ip_interval, -1);
+    assert_eq!(peers.dns[0].route, crate::config::DnsRoute::Direct);
+    let routes = super::routes::Routes::new(&peers);
+    assert_eq!(routes.select("10.1.0.1".parse().unwrap()), Some(0));
+    assert_eq!(routes.select("10.2.0.1".parse().unwrap()), Some(0));
+    let disabled = parse(
+        &yaml
+            .replace("remote-dns-resolve: true", "remote-dns-resolve: false")
+            .replace("dns.example#unused-route", "invalid://ignored"),
+    );
+    assert!(disabled.dns.is_empty());
+    assert!(!format!("{config:?}").contains(&STANDARD.encode([1u8; 32])));
+    let yaml = "mixed-port: 1080\nproxies: [{name: wg, type: wireguard, server: 198.51.100.1, port: 51820, ip: 10.0.0.2, private-key: secret-sentinel, public-key: secret-sentinel}]";
+    let error = crate::config::Config::parse_yaml(yaml.as_bytes())
+        .unwrap_err()
+        .to_string();
+    assert!(!error.contains("secret-sentinel"));
+}
+
+struct Bootstrap {
+    calls: Arc<AtomicUsize>,
+    rotating: bool,
+}
+#[async_trait]
+impl crate::dialer::Resolver for Bootstrap {
+    async fn resolve(&self, host: &str, port: u16) -> io::Result<crate::dialer::ResolvedEndpoint> {
+        self.calls.fetch_add(1, Ordering::Relaxed);
+        let ip = if self.rotating {
+            assert_eq!(host, "rotate.example");
+            if self.calls.load(Ordering::Relaxed) == 1 {
+                "198.51.100.1"
+            } else {
+                "198.51.100.2"
+            }
+        } else {
+            assert_eq!(host, "dns.example");
+            "10.0.0.1"
+        };
+        Ok(crate::dialer::ResolvedEndpoint {
+            logical_host: host.into(),
+            port,
+            addresses: vec![std::net::SocketAddr::new(ip.parse().unwrap(), port)],
+        })
+    }
+}
+#[tokio::test]
+async fn wireguard_peers_longest_prefix_reserved_and_remote_dns_have_owned_io() {
+    let probe = ResourceProbe::default();
+    probe.scope(async {
+        let mut config = config();
+        config.ipv6 = None;
+        config.peers[0].allowed_ips.retain(|p| p.network.is_ipv4());
+        config.routes.retain(|(p, _)| p.network.is_ipv4());
+        config.peers[0].reserved = [1, 2, 3];
+        let private = STANDARD.encode([1; 32]);
+        let public = STANDARD.encode(x25519::PublicKey::from(&x25519::StaticSecret::from([3; 32])).as_bytes());
+        let yaml = format!(
+            "mixed-port: 1080\nproxies: [{{name: wg, type: wireguard, server: 198.51.100.2, port: 51820, ip: 10.0.0.2, private-key: '{private}', public-key: '{public}'}}]\nrules: ['MATCH,wg']"
+        );
+        let second = crate::config::Config::parse_yaml(yaml.as_bytes()).unwrap();
+        let crate::config::ProxyProtocol::WireGuard(mut second) = second.proxies[0].protocol.clone() else { panic!() };
+        let mut peer = second.peers.remove(0);
+        peer.reserved = [4, 5, 6];
+        peer.allowed_ips = vec![crate::config::IpCidr {
+            network: "10.1.0.0".parse().unwrap(), prefix_len: 16,
+        }];
+        config.routes.push((peer.allowed_ips[0], 1));
+        config.peers.push(peer);
+        let parsed_dns = crate::config::Config::parse_yaml(format!(
+            "mixed-port: 1080\ndns: {{prefer-h3: {}}}\nproxies: [{{name: wg, type: wireguard, server: 198.51.100.1, port: 51820, ip: 10.0.0.2, private-key: '{private}', public-key: '{}', remote-dns-resolve: true, dns: ['dns.example#undeclared%26ecs=192.0.2.255/25%26disable-qtype-16=true']}}]",
+            cfg!(feature = "dns-quic"), STANDARD.encode(x25519::PublicKey::from(&x25519::StaticSecret::from([2; 32])).as_bytes())
+        ).as_bytes()).unwrap();
+        let crate::config::ProxyProtocol::WireGuard(node) = &parsed_dns.proxies[0].protocol else { panic!() };
+        config.dns = node.dns.clone();
+        let records = Arc::<Mutex<Vec<Destination>>>::default();
+        let closes = Arc::<AtomicUsize>::default();
+        let queries = Arc::<AtomicUsize>::default();
+        let carrier = Arc::new(Peer {
+            multi: true, reserved: true, records: records.clone(),
+            dns_queries: queries.clone(), silent: false, silent_first: false,
+            sends: Arc::default(), closes: closes.clone(), flood: Arc::default(),
+        });
+        let outbound = WireGuardOutbound::new_with_path(&config, UpstreamPath::Proxy(carrier)).unwrap();
+        let calls = Arc::<AtomicUsize>::default();
+        let resolution = crate::dns::resolution::ResolutionContext::measurement(
+            Arc::new(Bootstrap { calls: calls.clone(), rotating: false }), true,
+        );
+        let context = EstablishContext::with_resolution(Duration::from_secs(3), resolution);
+        let mut request = session();
+        request.destination = Destination::domain("remote.example", 80).unwrap();
+        let mut connected = outbound.connect_stream(request, &context).await.unwrap();
+        connected.io.write_all(b"peer").await.unwrap();
+        let mut echoed = [0; 4];
+        tokio::time::timeout(Duration::from_secs(2), connected.io.read_exact(&mut echoed)).await.unwrap().unwrap();
+        assert_eq!(&echoed, b"peer");
+        assert_eq!(connected.effective_peer, Destination::Ip("10.1.0.1:80".parse().unwrap()));
+        assert_eq!(queries.load(Ordering::Relaxed), 1);
+        let engine = outbound.current.lock().await.as_ref().unwrap().clone();
+        let mut blocked = crate::dns::build_query(77, "blocked.example", crate::dns::QueryType::A).unwrap();
+        let qtype = blocked.len() - 4;
+        blocked[qtype..qtype + 2].copy_from_slice(&16_u16.to_be_bytes());
+        let blocked = engine.remote.get().unwrap().exchange(&blocked).await.unwrap();
+        assert_eq!(&blocked[6..12], &[0; 6]);
+        assert_eq!(blocked[2] & 0x04, 0x04);
+        assert_eq!(queries.load(Ordering::Relaxed), 1, "disabled TXT does not enter WireGuard");
+        assert_eq!(calls.load(Ordering::Relaxed), 1);
+        assert!(records.lock().unwrap().contains(&Destination::Ip(ENDPOINT.parse().unwrap())));
+        assert!(records.lock().unwrap().contains(&Destination::Ip(SECOND.parse().unwrap())));
+        drop(connected);
+        drop(engine);
+        outbound.shutdown().await;
+        assert_eq!(closes.load(Ordering::Relaxed), 2);
+        assert!(probe.snapshot().is_idle());
+    }).await;
+}
+#[tokio::test]
+async fn wireguard_endpoint_refresh_keeps_the_stack_and_releases_old_peer_io() {
+    let probe = ResourceProbe::default();
+    probe
+        .scope(async {
+            let mut config = config();
+            config.address = "rotate.example".into();
+            config.peers[0].address = config.address.clone();
+            config.peers[0].reserved = [1, 2, 3];
+            config.refresh_server_ip_interval = 1;
+            let records = Arc::<Mutex<Vec<Destination>>>::default();
+            let closes = Arc::<AtomicUsize>::default();
+            let carrier = Arc::new(Peer {
+                multi: false,
+                reserved: true,
+                records: records.clone(),
+                dns_queries: Arc::default(),
+                silent: false,
+                silent_first: false,
+                sends: Arc::default(),
+                closes: closes.clone(),
+                flood: Arc::default(),
+            });
+            let outbound =
+                WireGuardOutbound::new_with_path(&config, UpstreamPath::Proxy(carrier)).unwrap();
+            let calls = Arc::<AtomicUsize>::default();
+            let resolution = crate::dns::resolution::ResolutionContext::measurement(
+                Arc::new(Bootstrap {
+                    calls: calls.clone(),
+                    rotating: true,
+                }),
+                true,
+            );
+            let context = EstablishContext::with_resolution(Duration::from_secs(4), resolution);
+            let request = DatagramRequest::new(DatagramSession::new(
+                InboundKind::Socks5,
+                "192.0.2.1:23000".parse().unwrap(),
+            ));
+            let mut udp = outbound.open_datagram(request, &context).await.unwrap();
+            let engine = Arc::downgrade(outbound.current.lock().await.as_ref().unwrap());
+            let remote = Destination::Ip("10.0.0.1:53".parse().unwrap());
+            for payload in [b"old", b"new"] {
+                if payload == b"new" {
+                    tokio::time::sleep(Duration::from_millis(1010)).await;
+                }
+                udp.send(Datagram {
+                    remote: remote.clone(),
+                    payload: Bytes::copy_from_slice(payload),
+                    sniffed_domain: None,
+                })
+                .await
+                .unwrap();
+                let reply = tokio::time::timeout(Duration::from_secs(2), udp.receive())
+                    .await
+                    .unwrap()
+                    .unwrap();
+                assert_eq!(reply.payload.as_ref(), payload);
+            }
+            assert!(engine.ptr_eq(&Arc::downgrade(
+                outbound.current.lock().await.as_ref().unwrap()
+            )));
+            assert_eq!(calls.load(Ordering::Relaxed), 2);
+            assert_eq!(closes.load(Ordering::Relaxed), 1);
+            assert!(
+                records
+                    .lock()
+                    .unwrap()
+                    .contains(&Destination::Ip(SECOND.parse().unwrap()))
+            );
+            udp.close().await.unwrap();
+            drop(udp);
+            outbound.shutdown().await;
+            assert_eq!(closes.load(Ordering::Relaxed), 2);
+            assert!(probe.snapshot().is_idle());
+        })
+        .await;
+}
+
+#[tokio::test]
+async fn wireguard_failed_peer_keeps_other_peer_and_shared_stack_live() {
+    let probe = ResourceProbe::default();
+    probe
+        .scope(async {
+            let mut config = config();
+            let mut second = config_with_peer(3).peers.remove(0);
+            second.address = "198.51.100.2".into();
+            second.allowed_ips = vec![crate::config::IpCidr {
+                network: "10.1.0.0".parse().unwrap(),
+                prefix_len: 16,
+            }];
+            config.routes.push((second.allowed_ips[0], 1));
+            config.peers.push(second);
+            let closes = Arc::<AtomicUsize>::default();
+            let carrier = Arc::new(Peer {
+                multi: true,
+                reserved: false,
+                records: Arc::default(),
+                dns_queries: Arc::default(),
+                silent: false,
+                silent_first: true,
+                sends: Arc::default(),
+                closes: closes.clone(),
+                flood: Arc::default(),
+            });
+            let outbound =
+                WireGuardOutbound::new_with_path(&config, UpstreamPath::Proxy(carrier)).unwrap();
+            let failed = outbound
+                .connect_stream(
+                    session(),
+                    &EstablishContext::with_timeout(Duration::from_millis(30)),
+                )
+                .await;
+            assert!(matches!(
+                failed,
+                Err(DispatchError::TimedOut) | Err(DispatchError::ConnectionRefused)
+            ));
+            let engine = Arc::downgrade(outbound.current.lock().await.as_ref().unwrap());
+            let mut request = session();
+            request.destination = Destination::Ip("10.1.0.1:80".parse().unwrap());
+            let mut stream = outbound
+                .connect_stream(
+                    request,
+                    &EstablishContext::with_timeout(Duration::from_secs(2)),
+                )
+                .await
+                .unwrap();
+            stream.io.write_all(b"live").await.unwrap();
+            let mut reply = [0; 4];
+            tokio::time::timeout(Duration::from_secs(2), stream.io.read_exact(&mut reply))
+                .await
+                .unwrap()
+                .unwrap();
+            assert_eq!(&reply, b"live");
+            assert!(engine.ptr_eq(&Arc::downgrade(
+                outbound.current.lock().await.as_ref().unwrap()
+            )));
+            assert!(
+                !outbound
+                    .current
+                    .lock()
+                    .await
+                    .as_ref()
+                    .unwrap()
+                    .cancel
+                    .is_cancelled()
+            );
+            drop(stream);
+            outbound.shutdown().await;
+            assert_eq!(closes.load(Ordering::Relaxed), 2);
+            assert!(probe.snapshot().is_idle());
+        })
+        .await;
+}
diff --git a/src/platform/linux_network/mod.rs b/src/platform/linux_network/mod.rs
new file mode 100644
index 0000000..b127eb5
--- /dev/null
+++ b/src/platform/linux_network/mod.rs
@@ -0,0 +1,146 @@
+//! Transactional system network changes for one core-owned Linux TUN.
+use std::io;
+
+mod plan;
+use plan::{Route, Rule};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) enum Change {
+    Route(Route),
+    Rule(Rule),
+    DnsServers,
+    DnsDomains,
+    DnsDefaultRoute,
+}
+
+pub(crate) trait Backend {
+    fn apply(&mut self, change: &Change) -> io::Result<()>;
+    fn remove(&mut self, change: &Change) -> io::Result<()>;
+}
+
+pub(crate) struct Lease<B: Backend> {
+    backend: B,
+    applied: Vec<Change>,
+}
+impl<B: Backend> Lease<B> {
+    fn new(backend: B) -> Self {
+        Self {
+            backend,
+            applied: Vec::new(),
+        }
+    }
+    fn apply(&mut self, change: Change) -> io::Result<()> {
+        self.backend.apply(&change)?;
+        self.applied.push(change);
+        Ok(())
+    }
+    pub(crate) fn restore(&mut self) -> io::Result<()> {
+        let mut error = None;
+        while let Some(change) = self.applied.pop() {
+            if let Err(failure) = self.backend.remove(&change) {
+                error.get_or_insert(failure);
+            }
+        }
+        error.map_or(Ok(()), Err)
+    }
+}
+impl<B: Backend> Drop for Lease<B> {
+    fn drop(&mut self) {
+        if self.restore().is_err() {
+            tracing::error!("Linux network cleanup failed");
+        }
+    }
+}
+
+#[cfg(target_os = "linux")]
+mod native;
+#[cfg(target_os = "linux")]
+mod netlink;
+#[cfg(target_os = "linux")]
+pub(crate) use native::{LinuxBackend, SocketPolicy, open};
+#[cfg(target_os = "linux")]
+pub(crate) type NetworkLease = Lease<LinuxBackend>;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::{Arc, Mutex};
+    struct Mock {
+        events: Arc<Mutex<Vec<(bool, Change)>>>,
+        fail: Option<Change>,
+    }
+    impl Backend for Mock {
+        fn apply(&mut self, change: &Change) -> io::Result<()> {
+            if self.fail.as_ref() == Some(change) {
+                return Err(io::Error::other("fixture"));
+            }
+            self.events.lock().unwrap().push((true, change.clone()));
+            Ok(())
+        }
+        fn remove(&mut self, change: &Change) -> io::Result<()> {
+            self.events.lock().unwrap().push((false, change.clone()));
+            Ok(())
+        }
+    }
+    #[test]
+    fn failed_start_and_normal_stop_restore_only_completed_changes_in_reverse() {
+        let changes = [
+            Change::Route(Route {
+                ipv6: false,
+                index: 7,
+                table: 2022,
+                destination: crate::config::IpCidr {
+                    network: "0.0.0.0".parse().unwrap(),
+                    prefix_len: 0,
+                },
+            }),
+            Change::Rule(Rule {
+                ipv6: false,
+                priority: 9000,
+                selector: plan::Selector::Local,
+                action: plan::Action::MainNonDefault,
+            }),
+            Change::Rule(Rule {
+                ipv6: false,
+                priority: 9001,
+                selector: plan::Selector::Local,
+                action: plan::Action::Table(2022),
+            }),
+            Change::Rule(Rule {
+                ipv6: true,
+                priority: 9002,
+                selector: plan::Selector::Ingress(*b"absent-dev\0\0\0\0\0\0"),
+                action: plan::Action::Goto(9004),
+            }),
+            Change::DnsServers,
+            Change::DnsDomains,
+            Change::DnsDefaultRoute,
+        ];
+        for fail_at in 0..=changes.len() {
+            let events = Arc::new(Mutex::new(Vec::new()));
+            {
+                let mut lease = Lease::new(Mock {
+                    events: events.clone(),
+                    fail: changes.get(fail_at).cloned(),
+                });
+                for change in &changes {
+                    if lease.apply(change.clone()).is_err() {
+                        break;
+                    }
+                }
+                if fail_at == changes.len() {
+                    lease.restore().unwrap();
+                    lease.restore().unwrap();
+                }
+            }
+            let events = events.lock().unwrap();
+            let expected: Vec<_> = changes[..fail_at]
+                .iter()
+                .cloned()
+                .map(|c| (true, c))
+                .chain(changes[..fail_at].iter().rev().cloned().map(|c| (false, c)))
+                .collect();
+            assert_eq!(*events, expected);
+        }
+    }
+}
diff --git a/src/platform/linux_network/native.rs b/src/platform/linux_network/native.rs
new file mode 100644
index 0000000..1c41b2c
--- /dev/null
+++ b/src/platform/linux_network/native.rs
@@ -0,0 +1,366 @@
+use super::{
+    Backend, Change, Lease, NetworkLease, netlink,
+    plan::{Plan, Route},
+};
+use crate::{
+    config::{DnsConfig, TunConfig},
+    dialer::Dialer,
+    platform::TunIo,
+};
+use std::{
+    ffi::CString,
+    io,
+    net::SocketAddr,
+    os::fd::{AsRawFd, FromRawFd, OwnedFd},
+    process::{Command, Stdio},
+    sync::{Arc, Mutex},
+    time::{Duration, Instant},
+};
+
+struct Interfaces {
+    refreshed: Instant,
+    ipv4: Option<String>,
+    ipv6: Option<String>,
+}
+pub(crate) struct SocketPolicy {
+    detect: bool,
+    mark: bool,
+    interfaces: Mutex<Option<Interfaces>>,
+}
+impl SocketPolicy {
+    // A kernel-created subflow can replace its inherited bound interface with
+    // the path manager's endpoint. SO_MARK is inherited; interface discovery
+    // requires ordinary TCP until all subflows can be constrained as well.
+    pub(crate) fn permits_mptcp(&self) -> bool {
+        !self.detect
+    }
+
+    pub(crate) fn detects_interface(&self) -> bool {
+        self.detect
+    }
+
+    fn default_mark(&self, configured_mark: u32) -> Option<u32> {
+        // Every capture rule matches only mark zero. A nonzero public mark
+        // already bypasses this lease and must retain its own RPDB meaning.
+        (self.mark && configured_mark == 0).then_some(netlink::MARK)
+    }
+    fn new(detect: bool, mark: bool) -> Self {
+        Self {
+            detect,
+            mark,
+            interfaces: Mutex::new(None),
+        }
+    }
+    pub(crate) fn apply(
+        &self,
+        socket: &impl AsRawFd,
+        destination: SocketAddr,
+        configured_mark: u32,
+    ) -> io::Result<()> {
+        self.apply_with_interface(socket, destination, configured_mark, None)
+    }
+    pub(crate) fn apply_with_interface(
+        &self,
+        socket: &impl AsRawFd,
+        destination: SocketAddr,
+        configured_mark: u32,
+        interface: Option<&str>,
+    ) -> io::Result<()> {
+        if let Some(value) = self.default_mark(configured_mark) {
+            // SAFETY: socket is live and the option points to a u32 mark.
+            if unsafe {
+                libc::setsockopt(
+                    socket.as_raw_fd(),
+                    libc::SOL_SOCKET,
+                    libc::SO_MARK,
+                    (&raw const value).cast(),
+                    std::mem::size_of_val(&value) as libc::socklen_t,
+                )
+            } < 0
+            {
+                return Err(io::Error::last_os_error());
+            }
+        }
+        if let Some(interface) = interface {
+            let name = CString::new(interface).map_err(|_| io::ErrorKind::InvalidInput)?;
+            // SAFETY: live socket, terminated interface name and a u32 index.
+            let index = unsafe { libc::if_nametoindex(name.as_ptr()) };
+            if index == 0 {
+                return Err(io::ErrorKind::NotFound.into());
+            }
+            if let SocketAddr::V6(address) = destination
+                && address.scope_id() != 0
+                && address.scope_id() != index
+            {
+                return Err(io::ErrorKind::InvalidInput.into());
+            }
+            // SAFETY: name remains live and socket is owned by its initializer.
+            if unsafe {
+                libc::setsockopt(
+                    socket.as_raw_fd(),
+                    libc::SOL_SOCKET,
+                    libc::SO_BINDTODEVICE,
+                    name.as_ptr().cast(),
+                    name.as_bytes_with_nul().len() as libc::socklen_t,
+                )
+            } < 0
+            {
+                return Err(io::Error::last_os_error());
+            }
+            return Ok(());
+        }
+        if !self.detect || destination.ip().is_loopback() {
+            return Ok(());
+        }
+        let mut state = self
+            .interfaces
+            .lock()
+            .map_err(|_| io::Error::other("Linux egress state unavailable"))?;
+        if state
+            .as_ref()
+            .is_none_or(|state| state.refreshed.elapsed() >= Duration::from_secs(1))
+        {
+            *state = Some(Interfaces {
+                ipv4: netlink::default_interface(false)?,
+                ipv6: netlink::default_interface(true)?,
+                refreshed: Instant::now(),
+            });
+        }
+        let state = state.as_ref().unwrap();
+        let interface = if destination.is_ipv6() {
+            &state.ipv6
+        } else {
+            &state.ipv4
+        };
+        let name = CString::new(
+            interface
+                .as_ref()
+                .ok_or_else(|| {
+                    io::Error::new(
+                        io::ErrorKind::NetworkUnreachable,
+                        "no physical default interface for address family",
+                    )
+                })?
+                .as_str(),
+        )
+        .map_err(|_| io::Error::other("invalid Linux interface"))?;
+        // SAFETY: name is NUL terminated and socket is still owned by its initializer.
+        if unsafe {
+            libc::setsockopt(
+                socket.as_raw_fd(),
+                libc::SOL_SOCKET,
+                libc::SO_BINDTODEVICE,
+                name.as_ptr().cast(),
+                name.as_bytes_with_nul().len() as libc::socklen_t,
+            )
+        } < 0
+        {
+            return Err(io::Error::last_os_error());
+        }
+        Ok(())
+    }
+}
+
+pub(crate) struct LinuxBackend {
+    name: String,
+    // Keep the newly created interface alive until DNS and routing cleanup ends.
+    _tun_owner: OwnedFd,
+    dns_reverted: bool,
+    dns_server: String,
+}
+impl LinuxBackend {
+    fn resolved(&self, operation: &str, values: &[&str]) -> io::Result<()> {
+        let mut child = Command::new("/usr/bin/resolvectl")
+            .arg("--no-ask-password")
+            .arg(operation)
+            .arg(&self.name)
+            .args(values)
+            .stdin(Stdio::null())
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .spawn()
+            .map_err(|_| {
+                io::Error::new(
+                    io::ErrorKind::NotFound,
+                    "Linux DNS takeover requires systemd-resolved and resolvectl",
+                )
+            })?;
+        let deadline = Instant::now() + Duration::from_secs(5);
+        loop {
+            match child.try_wait() {
+                Ok(Some(status)) => {
+                    return if status.success() {
+                        Ok(())
+                    } else {
+                        Err(io::Error::new(
+                            io::ErrorKind::PermissionDenied,
+                            "Linux per-link DNS setup failed; check installed resolve1 authorization",
+                        ))
+                    };
+                }
+                Ok(None) if Instant::now() < deadline => {
+                    std::thread::sleep(Duration::from_millis(10))
+                }
+                result => {
+                    let _ = child.kill();
+                    let _ = child.wait();
+                    return Err(result.err().unwrap_or_else(|| {
+                        io::Error::new(io::ErrorKind::TimedOut, "Linux DNS configuration timed out")
+                    }));
+                }
+            }
+        }
+    }
+}
+impl Backend for LinuxBackend {
+    fn apply(&mut self, change: &Change) -> io::Result<()> {
+        match change {
+            Change::DnsServers => self.resolved("dns", &[&self.dns_server]),
+            Change::DnsDomains => self.resolved("domain", &["~."]),
+            Change::DnsDefaultRoute => self.resolved("default-route", &["yes"]),
+            other => netlink::change(other, true),
+        }
+    }
+    fn remove(&mut self, change: &Change) -> io::Result<()> {
+        match change {
+            Change::DnsServers | Change::DnsDomains | Change::DnsDefaultRoute => {
+                if self.dns_reverted {
+                    return Ok(());
+                }
+                self.resolved("revert", &[])?;
+                self.dns_reverted = true;
+                Ok(())
+            }
+            other => match netlink::change(other, false) {
+                Err(error)
+                    if matches!(
+                        error.raw_os_error(),
+                        Some(libc::ENOENT | libc::ESRCH | libc::ENODEV)
+                    ) =>
+                {
+                    Ok(())
+                }
+                result => result,
+            },
+        }
+    }
+}
+
+pub(crate) fn open(
+    config: &TunConfig,
+    dns: &DnsConfig,
+    ipv6: bool,
+    dialer: Dialer,
+) -> io::Result<(TunIo, Dialer, Option<NetworkLease>)> {
+    if !config.auto_route && !config.auto_detect_interface {
+        return Ok((
+            TunIo::open(&config.device, config.mtu).map_err(io::Error::other)?,
+            dialer,
+            None,
+        ));
+    }
+    let dialer = dialer.with_linux_policy(Arc::new(SocketPolicy::new(
+        config.auto_detect_interface,
+        config.auto_route,
+    )));
+    if !config.auto_route {
+        return Ok((
+            TunIo::open(&config.device, config.mtu).map_err(io::Error::other)?,
+            dialer,
+            None,
+        ));
+    }
+    // Plan and collision checks precede creating any interface or network object.
+    let plan = Plan::new(config, ipv6)?;
+    for family in [false, true] {
+        if !family || plan.ipv6 || config.network.strict_route {
+            netlink::ensure_available(
+                family,
+                config.network.table_index,
+                config.network.rule_index,
+            )?;
+        }
+    }
+    let tun = TunIo::open_exclusive(&config.device, config.mtu).map_err(io::Error::other)?;
+    let device = tun.linux_device();
+    let name = device.name()?;
+    let c_name =
+        CString::new(name.as_str()).map_err(|_| io::Error::other("invalid Linux TUN name"))?;
+    // SAFETY: name is a valid terminated device name.
+    let index = unsafe { libc::if_nametoindex(c_name.as_ptr()) };
+    if index == 0 {
+        return Err(io::Error::last_os_error());
+    }
+    // SAFETY: duplicate preserves ownership while cleanup runs after the reader exits.
+    let owner = unsafe { libc::fcntl(device.as_raw_fd(), libc::F_DUPFD_CLOEXEC, 0) };
+    if owner < 0 {
+        return Err(io::Error::last_os_error());
+    }
+    let owner = unsafe { OwnedFd::from_raw_fd(owner) };
+    let address = dns
+        .fake_ip
+        .range
+        .map(|range| range.interface_address)
+        .unwrap_or("198.18.0.1".parse().unwrap());
+    let std::net::IpAddr::V4(address) = address else {
+        unreachable!("validated IPv4 range")
+    };
+    let dns_address = std::net::Ipv4Addr::from(
+        u32::from(address)
+            .checked_add(1)
+            .ok_or_else(|| io::Error::other("TUN DNS address is outside IPv4"))?,
+    );
+    let mut lease = Lease::new(LinuxBackend {
+        name,
+        _tun_owner: owner,
+        dns_reverted: false,
+        dns_server: dns_address.to_string(),
+    });
+    device.set_network_address(address, 30, None::<std::net::Ipv4Addr>)?;
+    if plan.ipv6 {
+        for address in &config.network.inet6_address {
+            device.add_address_v6(address.address, address.prefix_len)?;
+        }
+    }
+    device.enabled(true)?;
+    for destination in plan.routes {
+        lease.apply(Change::Route(Route {
+            ipv6: destination.network.is_ipv6(),
+            index,
+            table: config.network.table_index,
+            destination,
+        }))?;
+    }
+    for rule in plan.rules {
+        lease.apply(Change::Rule(rule))?;
+    }
+    if dns.enable && config.hijacks_dns(SocketAddr::new(dns_address.into(), 53)) {
+        lease.apply(Change::DnsServers)?;
+        lease.apply(Change::DnsDomains)?;
+        lease.apply(Change::DnsDefaultRoute)?;
+    }
+    Ok((tun, dialer, Some(lease)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn auto_route_injects_only_a_default_mark_and_preserves_public_marks() {
+        for detect in [false, true] {
+            let protected = SocketPolicy::new(detect, true);
+            assert_eq!(protected.default_mark(0), Some(netlink::MARK));
+            for mark in [1, 7, 42, netlink::MARK, u32::MAX] {
+                assert_eq!(protected.default_mark(mark), None);
+            }
+            let unmanaged = SocketPolicy::new(detect, false);
+            for mark in [0, 1, netlink::MARK, u32::MAX] {
+                assert_eq!(unmanaged.default_mark(mark), None);
+            }
+            // Loopback callers deliberately pass zero rather than the public
+            // mark, keeping local proxies on the existing private bypass.
+            assert_eq!(protected.default_mark(0), Some(netlink::MARK));
+        }
+    }
+}
diff --git a/src/platform/linux_network/netlink.rs b/src/platform/linux_network/netlink.rs
new file mode 100644
index 0000000..cb56663
--- /dev/null
+++ b/src/platform/linux_network/netlink.rs
@@ -0,0 +1,521 @@
+//! Minimal bounded rtnetlink requests. Constants and layouts follow Linux UAPI.
+use super::{
+    Change,
+    plan::{Action, Selector},
+};
+use std::{
+    ffi::CStr,
+    io,
+    os::fd::{AsRawFd, FromRawFd, OwnedFd},
+};
+pub(super) const MARK: u32 = 0x564f4c45;
+const REQUEST: u16 = 1;
+const ACK: u16 = 4;
+const CREATE_EXCL: u16 = 0x600;
+const DUMP: u16 = 0x300;
+const GET_ROUTE: u16 = 26;
+const NEW_ROUTE: u16 = 24;
+const DEL_ROUTE: u16 = 25;
+const GET_RULE: u16 = 34;
+const NEW_RULE: u16 = 32;
+const DEL_RULE: u16 = 33;
+
+fn invalid() -> io::Error {
+    io::Error::new(io::ErrorKind::InvalidData, "invalid Linux route response")
+}
+fn u32_at(bytes: &[u8]) -> io::Result<u32> {
+    Ok(u32::from_ne_bytes(bytes.try_into().map_err(|_| invalid())?))
+}
+fn attr(out: &mut Vec<u8>, kind: u16, value: &[u8]) {
+    out.extend_from_slice(&((4 + value.len()) as u16).to_ne_bytes());
+    out.extend_from_slice(&kind.to_ne_bytes());
+    out.extend_from_slice(value);
+    out.resize((out.len() + 3) & !3, 0);
+}
+fn attribute(mut bytes: &[u8], kind: u16) -> io::Result<Option<&[u8]>> {
+    let mut found = None;
+    while !bytes.is_empty() {
+        if bytes.len() < 4 {
+            return Err(invalid());
+        }
+        let length = u16::from_ne_bytes([bytes[0], bytes[1]]) as usize;
+        let aligned = (length + 3) & !3;
+        if length < 4 || aligned > bytes.len() {
+            return Err(invalid());
+        }
+        if u16::from_ne_bytes([bytes[2], bytes[3]]) & 0x3fff == kind {
+            if found.is_some() {
+                return Err(invalid());
+            }
+            found = Some(&bytes[4..length]);
+        }
+        bytes = &bytes[aligned..];
+    }
+    Ok(found)
+}
+fn property(bytes: &[u8], kind: u16, default: u32) -> io::Result<u32> {
+    attribute(bytes, kind)?.map_or(Ok(default), u32_at)
+}
+
+fn exchange(kind: u16, flags: u16, payload: &[u8]) -> io::Result<Vec<Vec<u8>>> {
+    // SAFETY: successful socket returns a fresh owned descriptor.
+    let raw = unsafe {
+        libc::socket(
+            libc::AF_NETLINK,
+            libc::SOCK_RAW | libc::SOCK_CLOEXEC,
+            libc::NETLINK_ROUTE,
+        )
+    };
+    if raw < 0 {
+        return Err(io::Error::last_os_error());
+    }
+    let fd = unsafe { OwnedFd::from_raw_fd(raw) };
+    let limit = libc::timeval {
+        tv_sec: 1,
+        tv_usec: 0,
+    };
+    for option in [libc::SO_SNDTIMEO, libc::SO_RCVTIMEO] {
+        // SAFETY: limit is a valid timeval and fd remains owned.
+        if unsafe {
+            libc::setsockopt(
+                fd.as_raw_fd(),
+                libc::SOL_SOCKET,
+                option,
+                (&raw const limit).cast(),
+                std::mem::size_of_val(&limit) as libc::socklen_t,
+            )
+        } < 0
+        {
+            return Err(io::Error::last_os_error());
+        }
+    }
+    let mut request = vec![0; 16];
+    request[4..6].copy_from_slice(&kind.to_ne_bytes());
+    request[6..8].copy_from_slice(&(flags | REQUEST).to_ne_bytes());
+    request[8..12].copy_from_slice(&1u32.to_ne_bytes());
+    request.extend_from_slice(payload);
+    let length = request.len() as u32;
+    request[..4].copy_from_slice(&length.to_ne_bytes());
+    // SAFETY: kernel pid/groups zero is the rtnetlink destination.
+    let mut address: libc::sockaddr_nl = unsafe { std::mem::zeroed() };
+    address.nl_family = libc::AF_NETLINK as u16;
+    let sent = unsafe {
+        libc::sendto(
+            fd.as_raw_fd(),
+            request.as_ptr().cast(),
+            request.len(),
+            0,
+            (&raw const address).cast(),
+            std::mem::size_of_val(&address) as libc::socklen_t,
+        )
+    };
+    if sent < 0 {
+        return Err(io::Error::last_os_error());
+    }
+    if sent as usize != request.len() {
+        return Err(invalid());
+    }
+    let mut messages = Vec::new();
+    let mut total = 0usize;
+    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(2);
+    loop {
+        if std::time::Instant::now() >= deadline {
+            return Err(io::Error::new(
+                io::ErrorKind::TimedOut,
+                "Linux route query timed out",
+            ));
+        }
+        let mut buffer = [0u8; 65536];
+        let mut size = std::mem::size_of_val(&address) as libc::socklen_t;
+        // SAFETY: buffers are writable for the lengths passed; MSG_TRUNC detects oversized datagrams.
+        let received = unsafe {
+            libc::recvfrom(
+                fd.as_raw_fd(),
+                buffer.as_mut_ptr().cast(),
+                buffer.len(),
+                libc::MSG_TRUNC,
+                (&raw mut address).cast(),
+                &mut size,
+            )
+        };
+        if received < 0 {
+            return Err(io::Error::last_os_error());
+        }
+        if received == 0
+            || received as usize > buffer.len()
+            || address.nl_pid != 0
+            || address.nl_groups != 0
+            || size as usize != std::mem::size_of_val(&address)
+        {
+            return Err(invalid());
+        }
+        total += received as usize;
+        if total > 4 * 1024 * 1024 {
+            return Err(invalid());
+        }
+        let mut bytes = &buffer[..received as usize];
+        while !bytes.is_empty() {
+            if bytes.len() < 16 {
+                return Err(invalid());
+            }
+            let len = u32_at(&bytes[..4])? as usize;
+            let aligned = (len + 3) & !3;
+            if len < 16 || aligned > bytes.len() || u32_at(&bytes[8..12])? != 1 {
+                return Err(invalid());
+            }
+            let kind = u16::from_ne_bytes([bytes[4], bytes[5]]);
+            let flags = u16::from_ne_bytes([bytes[6], bytes[7]]);
+            let payload = &bytes[16..len];
+            if flags & 0x10 != 0 {
+                return Err(io::Error::new(
+                    io::ErrorKind::Interrupted,
+                    "Linux route dump changed",
+                ));
+            }
+            match kind {
+                2 => {
+                    let code = i32::from_ne_bytes(
+                        payload
+                            .get(..4)
+                            .ok_or_else(invalid)?
+                            .try_into()
+                            .map_err(|_| invalid())?,
+                    );
+                    if code < 0 && code != i32::MIN {
+                        return Err(io::Error::from_raw_os_error(-code));
+                    }
+                    if code != 0 {
+                        return Err(invalid());
+                    }
+                    return Ok(messages);
+                }
+                3 => {
+                    if payload.len() >= 4 && u32_at(&payload[..4])? != 0 {
+                        return Err(invalid());
+                    }
+                    return Ok(messages);
+                }
+                _ => messages.push(payload.to_vec()),
+            }
+            bytes = &bytes[aligned..];
+        }
+    }
+}
+fn dump(kind: u16, ipv6: bool) -> io::Result<Vec<Vec<u8>>> {
+    let mut header = [0; 12];
+    header[0] = if ipv6 { 10 } else { 2 };
+    exchange(kind, DUMP, &header)
+}
+
+pub(super) fn default_interface(ipv6: bool) -> io::Result<Option<String>> {
+    let mut selected: Option<(u32, u32)> = None;
+    for route in dump(GET_ROUTE, ipv6)? {
+        if route.len() < 12 {
+            return Err(invalid());
+        }
+        if route[1] != 0 || route[7] != 1 || property(&route[12..], 15, u32::from(route[4]))? != 254
+        {
+            continue;
+        }
+        let index = property(&route[12..], 4, 0)?;
+        let metric = property(&route[12..], 6, 0)?;
+        if index > 0 && selected.is_none_or(|(previous, _)| metric < previous) {
+            selected = Some((metric, index));
+        }
+    }
+    selected
+        .map(|(_, index)| {
+            let mut name = [0 as libc::c_char; libc::IF_NAMESIZE];
+            // SAFETY: name has IF_NAMESIZE writable bytes; successful output is NUL terminated.
+            if unsafe { libc::if_indextoname(index, name.as_mut_ptr()) }.is_null() {
+                return Err(io::Error::last_os_error());
+            }
+            Ok(unsafe { CStr::from_ptr(name.as_ptr()) }
+                .to_string_lossy()
+                .into_owned())
+        })
+        .transpose()
+}
+pub(super) fn ensure_available(ipv6: bool, table: u32, priority: u32) -> io::Result<()> {
+    for route in dump(GET_ROUTE, ipv6)? {
+        if route.len() < 12 {
+            return Err(invalid());
+        }
+        if property(&route[12..], 15, u32::from(route[4]))? == table {
+            return Err(io::Error::new(
+                io::ErrorKind::AlreadyExists,
+                "Linux TUN routing table is occupied",
+            ));
+        }
+    }
+    for rule in dump(GET_RULE, ipv6)? {
+        if rule.len() < 12 {
+            return Err(invalid());
+        }
+        let found_priority = property(&rule[12..], 6, 0)?;
+        if priority_occupied(priority, found_priority) {
+            return Err(io::Error::new(
+                io::ErrorKind::AlreadyExists,
+                "Linux TUN rule priority is occupied",
+            ));
+        }
+    }
+    Ok(())
+}
+fn priority_occupied(base: u32, found: u32) -> bool {
+    found
+        .checked_sub(base)
+        .is_some_and(|offset| offset <= super::plan::RULE_SPAN)
+}
+fn prefix_attribute(payload: &mut Vec<u8>, kind: u16, prefix: crate::config::IpCidr) {
+    match prefix.network {
+        std::net::IpAddr::V4(address) => attr(payload, kind, &address.octets()),
+        std::net::IpAddr::V6(address) => attr(payload, kind, &address.octets()),
+    }
+}
+fn port_attribute(payload: &mut Vec<u8>, kind: u16, range: crate::config::PortRange) {
+    let mut value = [0; 4];
+    value[..2].copy_from_slice(&range.start.to_ne_bytes());
+    value[2..].copy_from_slice(&range.end.to_ne_bytes());
+    attr(payload, kind, &value);
+}
+fn message(change: &Change, add: bool) -> io::Result<(u16, Vec<u8>)> {
+    let mut payload = vec![0; 12];
+    let kind = match change {
+        Change::Route(route) => {
+            payload[0] = if route.ipv6 { 10 } else { 2 };
+            payload[1] = route.destination.prefix_len;
+            payload[5] = 4;
+            payload[7] = 1; // RTPROT_STATIC / RTN_UNICAST
+            attr(&mut payload, 15, &route.table.to_ne_bytes());
+            attr(&mut payload, 4, &route.index.to_ne_bytes());
+            if route.destination.prefix_len != 0 {
+                prefix_attribute(&mut payload, 1, route.destination);
+            }
+            if add { NEW_ROUTE } else { DEL_ROUTE }
+        }
+        Change::Rule(rule) => {
+            payload[0] = if rule.ipv6 { 10 } else { 2 };
+            payload[7] = match rule.action {
+                Action::Goto(_) => 2,
+                Action::Nop => 3,
+                Action::Unreachable => 7,
+                _ => 1,
+            };
+            match rule.action {
+                Action::Table(table) => attr(&mut payload, 15, &table.to_ne_bytes()),
+                Action::MainNonDefault => {
+                    payload[4] = 254;
+                    attr(&mut payload, 14, &0u32.to_ne_bytes());
+                }
+                Action::Goto(priority) => attr(&mut payload, 4, &priority.to_ne_bytes()),
+                Action::Unreachable | Action::Nop => {}
+            }
+            // Core physical sockets carry the configured nonzero mark or
+            // private MARK. Gate all capture operations on zero so both marks
+            // retain their bypass without an extra rule or a replaced RPDB.
+            // Interface selectors always name input, not physical output.
+            if rule.action != Action::Nop {
+                attr(&mut payload, 10, &0u32.to_ne_bytes());
+                attr(&mut payload, 16, &u32::MAX.to_ne_bytes());
+            }
+            match rule.selector {
+                Selector::Ingress(name) => {
+                    let end = name
+                        .iter()
+                        .position(|byte| *byte == 0)
+                        .ok_or_else(invalid)?;
+                    attr(&mut payload, 3, &name[..=end]);
+                }
+                Selector::Local | Selector::Uid(_) => attr(&mut payload, 3, b"lo\0"),
+                Selector::SourcePort(_) | Selector::DestinationPort(_) | Selector::Any => {}
+            }
+            match rule.selector {
+                Selector::Uid(range) => {
+                    let mut bytes = [0; 8];
+                    bytes[..4].copy_from_slice(&range.start.to_ne_bytes());
+                    bytes[4..].copy_from_slice(&range.end.to_ne_bytes());
+                    attr(&mut payload, 20, &bytes);
+                }
+                Selector::SourcePort(range) => port_attribute(&mut payload, 23, range),
+                Selector::DestinationPort(range) => port_attribute(&mut payload, 24, range),
+                Selector::Local | Selector::Ingress(_) | Selector::Any => {}
+            }
+            attr(&mut payload, 6, &rule.priority.to_ne_bytes());
+            if add { NEW_RULE } else { DEL_RULE }
+        }
+        _ => return Err(invalid()),
+    };
+    Ok((kind, payload))
+}
+pub(super) fn change(change: &Change, add: bool) -> io::Result<()> {
+    let (kind, payload) = message(change, add)?;
+    exchange(kind, ACK | if add { CREATE_EXCL } else { 0 }, &payload).map(|_| ())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn route_attributes_preserve_native_endian_and_padding() {
+        let mut bytes = Vec::new();
+        attr(&mut bytes, 15, &2022u32.to_ne_bytes());
+        attr(&mut bytes, 3, b"lo\0");
+        assert_eq!(property(&bytes, 15, 0).unwrap(), 2022);
+        assert_eq!(attribute(&bytes, 3).unwrap(), Some(b"lo\0".as_slice()));
+        for len in [1, 3, 7, 9] {
+            assert!(attribute(&bytes[..len], 15).is_err());
+        }
+    }
+    #[test]
+    fn capture_wire_matches_zero_marks_for_both_families_and_every_action() {
+        use super::super::plan::Rule;
+        for ipv6 in [false, true] {
+            for action in [
+                Action::Goto(9008),
+                Action::Table(2022),
+                Action::MainNonDefault,
+                Action::Unreachable,
+                Action::Nop,
+            ] {
+                let change = Change::Rule(Rule {
+                    ipv6,
+                    priority: 9004,
+                    selector: Selector::Any,
+                    action,
+                });
+                let (_, bytes) = message(&change, true).unwrap();
+                let attrs = &bytes[12..];
+                if action == Action::Nop {
+                    assert!(attribute(attrs, 10).unwrap().is_none());
+                    assert!(attribute(attrs, 16).unwrap().is_none());
+                } else {
+                    let value = property(attrs, 10, u32::MAX).unwrap();
+                    let mask = property(attrs, 16, 0).unwrap();
+                    assert_eq!((value, mask), (0, u32::MAX));
+                    for mark in [1, 7, 42, MARK, u32::MAX] {
+                        assert_ne!(mark & mask, value);
+                    }
+                }
+                assert_eq!(message(&change, false).unwrap().1, bytes);
+            }
+        }
+    }
+
+    #[test]
+    fn native_tun_wire_uses_exact_indices_cidrs_uid_and_native_port_attributes() {
+        use super::super::plan::{Route, Rule};
+        let route = Change::Route(Route {
+            ipv6: false,
+            index: 17,
+            table: 2500,
+            destination: crate::config::IpCidr {
+                network: "203.0.113.0".parse().unwrap(),
+                prefix_len: 24,
+            },
+        });
+        let (kind, bytes) = message(&route, true).unwrap();
+        assert_eq!(kind, NEW_ROUTE);
+        assert_eq!(bytes[1], 24);
+        assert_eq!(property(&bytes[12..], 15, 0).unwrap(), 2500);
+        assert_eq!(
+            attribute(&bytes[12..], 1).unwrap(),
+            Some(&[203, 0, 113, 0][..])
+        );
+        assert_eq!(message(&route, false).unwrap().1, bytes);
+        for selector in [
+            Selector::Uid(crate::config::UidRange {
+                start: 1001,
+                end: 1003,
+            }),
+            Selector::SourcePort(crate::config::PortRange {
+                start: 20000,
+                end: 20003,
+            }),
+            Selector::DestinationPort(crate::config::PortRange {
+                start: 443,
+                end: 443,
+            }),
+        ] {
+            let rule = Change::Rule(Rule {
+                ipv6: true,
+                priority: 8500,
+                selector,
+                action: Action::Goto(8504),
+            });
+            let (_, bytes) = message(&rule, true).unwrap();
+            assert_eq!(bytes[7], 2);
+            assert_eq!(property(&bytes[12..], 4, 0).unwrap(), 8504);
+            assert_eq!(
+                attribute(&bytes[12..], 3).unwrap(),
+                matches!(selector, Selector::Uid(_)).then_some(b"lo\0".as_slice())
+            );
+            assert_eq!(property(&bytes[12..], 16, 0).unwrap(), u32::MAX);
+            match selector {
+                Selector::Uid(range) => {
+                    let data = attribute(&bytes[12..], 20).unwrap().unwrap();
+                    assert_eq!(u32_at(&data[..4]).unwrap(), range.start);
+                    assert_eq!(u32_at(&data[4..]).unwrap(), range.end);
+                }
+                Selector::SourcePort(range) | Selector::DestinationPort(range) => {
+                    let kind = if matches!(selector, Selector::SourcePort(_)) {
+                        23
+                    } else {
+                        24
+                    };
+                    let data = attribute(&bytes[12..], kind).unwrap().unwrap();
+                    assert_eq!(
+                        u16::from_ne_bytes(data[..2].try_into().unwrap()),
+                        range.start
+                    );
+                    assert_eq!(u16::from_ne_bytes(data[2..].try_into().unwrap()), range.end);
+                }
+                _ => unreachable!(),
+            }
+            assert_eq!(message(&rule, false).unwrap().1, bytes);
+        }
+    }
+    #[test]
+    fn native_tun_ingress_wire_and_reserved_span_restore_exact_name_selectors() {
+        use super::super::plan::Rule;
+        for family in [false, true] {
+            let mut name = [0; 16];
+            name[..10].copy_from_slice(b"absent-dev");
+            let rule = Change::Rule(Rule {
+                ipv6: family,
+                priority: 9002,
+                selector: Selector::Ingress(name),
+                action: Action::Goto(9004),
+            });
+            let (_, bytes) = message(&rule, true).unwrap();
+            assert_eq!(bytes[0], if family { 10 } else { 2 });
+            assert_eq!(
+                attribute(&bytes[12..], 3).unwrap(),
+                Some(b"absent-dev\0".as_slice())
+            );
+            assert_eq!(property(&bytes[12..], 16, 0).unwrap(), u32::MAX);
+            assert_eq!(message(&rule, false).unwrap().1, bytes);
+            let any = Change::Rule(Rule {
+                selector: Selector::Any,
+                action: Action::Table(2022),
+                ..match rule {
+                    Change::Rule(rule) => rule,
+                    _ => unreachable!(),
+                }
+            });
+            let (_, bytes) = message(&any, true).unwrap();
+            assert!(attribute(&bytes[12..], 3).unwrap().is_none());
+            assert_eq!(property(&bytes[12..], 10, 1).unwrap(), 0);
+        }
+        for (priority, expected) in [
+            (8999, false),
+            (9000, true),
+            (9007, true),
+            (9008, true),
+            (9009, false),
+            (u32::MAX, false),
+        ] {
+            assert_eq!(priority_occupied(9000, priority), expected);
+        }
+    }
+}
diff --git a/src/platform/linux_network/plan.rs b/src/platform/linux_network/plan.rs
new file mode 100644
index 0000000..f63be2d
--- /dev/null
+++ b/src/platform/linux_network/plan.rs
@@ -0,0 +1,447 @@
+//! Pure route/rule plan. No sockets, interfaces or process state are inspected.
+use crate::config::{IpCidr, PortRange, TunConfig, UidRange};
+use std::{
+    io,
+    net::{IpAddr, Ipv4Addr, Ipv6Addr},
+};
+
+pub(super) const MAX_ROUTES: usize = 4096;
+pub(super) const RULE_SPAN: u32 = 8;
+const MAX_RULES: usize = 2 * (2 * 256 + 16);
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) struct Route {
+    pub ipv6: bool,
+    pub index: u32,
+    pub table: u32,
+    pub destination: IpCidr,
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum Selector {
+    Local,
+    /// NUL-terminated Linux input-interface name; not an egress binding.
+    Ingress([u8; 16]),
+    Uid(UidRange),
+    SourcePort(PortRange),
+    DestinationPort(PortRange),
+    Any,
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum Action {
+    Table(u32),
+    MainNonDefault,
+    Goto(u32),
+    Unreachable,
+    Nop,
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) struct Rule {
+    pub ipv6: bool,
+    pub priority: u32,
+    pub selector: Selector,
+    pub action: Action,
+}
+pub(super) struct Plan {
+    pub routes: Vec<IpCidr>,
+    pub rules: Vec<Rule>,
+    pub ipv6: bool,
+}
+fn invalid() -> io::Error {
+    io::Error::new(
+        io::ErrorKind::InvalidInput,
+        "TUN route plan exceeds its bounded system-object budget",
+    )
+}
+impl Plan {
+    pub(super) fn new(config: &TunConfig, ipv6: bool) -> io::Result<Self> {
+        let options = &config.network;
+        let ipv6 = ipv6 && !options.inet6_address.is_empty();
+        let mut routes = Vec::new();
+        for family in [false, true].into_iter().take(if ipv6 { 2 } else { 1 }) {
+            let mut include: Vec<_> = options
+                .route_address
+                .iter()
+                .filter(|p| p.network.is_ipv6() == family)
+                .copied()
+                .collect();
+            if include.is_empty() {
+                include.push(IpCidr {
+                    network: if family {
+                        Ipv6Addr::UNSPECIFIED.into()
+                    } else {
+                        Ipv4Addr::UNSPECIFIED.into()
+                    },
+                    prefix_len: 0,
+                });
+            }
+            let exclude: Vec<_> = options
+                .route_exclude_address
+                .iter()
+                .filter(|p| p.network.is_ipv6() == family)
+                .copied()
+                .collect();
+            let selected = route_ranges(include, exclude)?;
+            if routes.len() + selected.len() > MAX_ROUTES {
+                return Err(invalid());
+            }
+            routes.extend(selected);
+        }
+        let excluded = excluded_uids(&options.include_uid, &options.exclude_uid);
+        let mut rules = Vec::new();
+        let base = options.rule_index;
+        base.checked_add(RULE_SPAN).ok_or_else(invalid)?;
+        for family in [false, true] {
+            let available = !family || ipv6;
+            if !available && !options.strict_route {
+                continue;
+            }
+            let capture_priority = base + if available { 4 } else { 6 };
+            let mut push = |offset, selector, action| {
+                rules.push(Rule {
+                    ipv6: family,
+                    priority: base + offset,
+                    selector,
+                    action,
+                })
+            };
+            for &range in &options.exclude_src_port {
+                push(
+                    0,
+                    Selector::SourcePort(range),
+                    Action::Goto(base + RULE_SPAN),
+                );
+            }
+            for &range in &options.exclude_dst_port {
+                push(
+                    0,
+                    Selector::DestinationPort(range),
+                    Action::Goto(base + RULE_SPAN),
+                );
+            }
+            for &range in &excluded {
+                push(0, Selector::Uid(range), Action::Goto(base + RULE_SPAN));
+            }
+            // TUN egress must never be captured a second time. Kernel name
+            // selectors survive interface deletion and become dormant; no
+            // interface discovery, index cache or background watcher is needed.
+            push(
+                1,
+                ingress(if config.device.is_empty() {
+                    "Vole"
+                } else {
+                    &config.device
+                })?,
+                Action::Goto(base + RULE_SPAN),
+            );
+            if !options.include_interface.is_empty() {
+                // Fixed sing-tun reference gives include precedence over exclude.
+                // Local output has Iif=lo and must be included explicitly.
+                for name in &options.include_interface {
+                    push(2, ingress(name)?, Action::Goto(capture_priority));
+                }
+                push(3, Selector::Any, Action::Goto(base + RULE_SPAN));
+            } else if !options.exclude_interface.is_empty() {
+                for name in &options.exclude_interface {
+                    push(2, ingress(name)?, Action::Goto(base + RULE_SPAN));
+                }
+            } else {
+                // Preserve the existing local-only default when no interface
+                // scope is requested, rather than expanding the capture domain.
+                push(2, Selector::Local, Action::Goto(capture_priority));
+                push(3, Selector::Any, Action::Goto(base + RULE_SPAN));
+            }
+            if available {
+                // LAN routes stay usable; DNS is first offered to the capture
+                // table. The preceding Iif gate scopes every later lookup.
+                push(
+                    4,
+                    Selector::DestinationPort(PortRange { start: 53, end: 53 }),
+                    Action::Table(options.table_index),
+                );
+                push(5, Selector::Any, Action::MainNonDefault);
+                push(6, Selector::Any, Action::Table(options.table_index));
+            } else {
+                // Strict-route applies to the same selected input scope,
+                // but never the core's protected physical sockets.
+                push(6, Selector::Any, Action::Unreachable);
+            }
+            push(RULE_SPAN, Selector::Any, Action::Nop);
+        }
+        if rules.len() > MAX_RULES {
+            return Err(invalid());
+        }
+        Ok(Self {
+            routes,
+            rules,
+            ipv6,
+        })
+    }
+}
+fn ingress(name: &str) -> io::Result<Selector> {
+    if name.is_empty() || name.len() >= 16 || name.as_bytes().contains(&0) {
+        return Err(invalid());
+    }
+    let mut bytes = [0; 16];
+    bytes[..name.len()].copy_from_slice(name.as_bytes());
+    Ok(Selector::Ingress(bytes))
+}
+
+fn key(prefix: IpCidr) -> (bool, u8, u128) {
+    (
+        prefix.network.is_ipv6(),
+        prefix.prefix_len,
+        match prefix.network {
+            IpAddr::V4(ip) => u128::from(u32::from(ip)),
+            IpAddr::V6(ip) => u128::from(ip),
+        },
+    )
+}
+fn canonical(mut prefixes: Vec<IpCidr>) -> Vec<IpCidr> {
+    prefixes.sort_unstable_by_key(|prefix| key(*prefix));
+    let mut output: Vec<IpCidr> = Vec::new();
+    for prefix in prefixes {
+        if !output.iter().any(|old| old.contains(prefix.network)) {
+            output.push(prefix);
+        }
+    }
+    output
+}
+fn split(prefix: IpCidr) -> (IpCidr, IpCidr) {
+    let length = prefix.prefix_len + 1;
+    let second = match prefix.network {
+        IpAddr::V4(ip) => IpAddr::V4(Ipv4Addr::from(u32::from(ip) | (1u32 << (32 - length)))),
+        IpAddr::V6(ip) => IpAddr::V6(Ipv6Addr::from(u128::from(ip) | (1u128 << (128 - length)))),
+    };
+    (
+        IpCidr {
+            network: prefix.network,
+            prefix_len: length,
+        },
+        IpCidr {
+            network: second,
+            prefix_len: length,
+        },
+    )
+}
+fn route_ranges(include: Vec<IpCidr>, exclude: Vec<IpCidr>) -> io::Result<Vec<IpCidr>> {
+    let mut result = canonical(include);
+    for excluded in canonical(exclude) {
+        let mut next = Vec::new();
+        for mut prefix in result {
+            if excluded.contains(prefix.network) && excluded.prefix_len <= prefix.prefix_len {
+                continue;
+            }
+            if !prefix.contains(excluded.network)
+                || prefix.network.is_ipv6() != excluded.network.is_ipv6()
+            {
+                next.push(prefix);
+                continue;
+            }
+            while prefix.prefix_len < excluded.prefix_len {
+                let (left, right) = split(prefix);
+                let (keep, descend) = if left.contains(excluded.network) {
+                    (right, left)
+                } else {
+                    (left, right)
+                };
+                if next.len() >= MAX_ROUTES {
+                    return Err(invalid());
+                }
+                next.push(keep);
+                prefix = descend;
+            }
+        }
+        if next.len() > MAX_ROUTES {
+            return Err(invalid());
+        }
+        result = next;
+    }
+    Ok(result)
+}
+fn merge(mut ranges: Vec<UidRange>) -> Vec<UidRange> {
+    ranges.sort_unstable_by_key(|r| (r.start, r.end));
+    let mut output: Vec<UidRange> = Vec::new();
+    for range in ranges {
+        if let Some(last) = output.last_mut()
+            && u64::from(range.start) <= u64::from(last.end) + 1
+        {
+            last.end = last.end.max(range.end);
+        } else {
+            output.push(range);
+        }
+    }
+    output
+}
+fn excluded_uids(include: &[UidRange], exclude: &[UidRange]) -> Vec<UidRange> {
+    let mut output = exclude.to_vec();
+    if !include.is_empty() {
+        let mut next = 0u64;
+        for range in merge(include.to_vec()) {
+            if next < u64::from(range.start) {
+                output.push(UidRange {
+                    start: next as u32,
+                    end: range.start - 1,
+                });
+            }
+            next = next.max(u64::from(range.end) + 1);
+        }
+        // uid_t(-1) is not a real Linux UID; reference uses MAX-1 too.
+        if next < u64::from(u32::MAX) {
+            output.push(UidRange {
+                start: next as u32,
+                end: u32::MAX - 1,
+            });
+        }
+    }
+    merge(output)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn cidr(value: &str) -> IpCidr {
+        let (ip, bits) = value.split_once('/').unwrap();
+        IpCidr {
+            network: ip.parse().unwrap(),
+            prefix_len: bits.parse().unwrap(),
+        }
+    }
+    #[test]
+    fn native_tun_plan_cidr_exclusions_override_more_specific_capture_routes() {
+        let output = route_ranges(
+            vec![
+                cidr("10.0.0.0/8"),
+                cidr("10.0.1.0/24"),
+                cidr("2001:db8::/32"),
+            ],
+            vec![cidr("10.0.0.0/16"), cidr("2001:db8:1::/48")],
+        )
+        .unwrap();
+        for (ip, expected) in [
+            ("10.0.1.4", false),
+            ("10.1.1.4", true),
+            ("11.1.1.4", false),
+            ("2001:db8:1::4", false),
+            ("2001:db8:2::4", true),
+        ] {
+            assert_eq!(
+                output.iter().any(|r| r.contains(ip.parse().unwrap())),
+                expected
+            );
+        }
+        assert!(output.len() < 128);
+        assert!(
+            route_ranges(vec![cidr("0.0.0.0/0")], vec![cidr("0.0.0.0/0")])
+                .unwrap()
+                .is_empty()
+        );
+    }
+    #[test]
+    fn native_tun_plan_uid_port_and_strict_family_match_only_local_apps() {
+        let mut config = TunConfig::default();
+        config.network.include_uid = vec![UidRange {
+            start: 1001,
+            end: 1003,
+        }];
+        config.network.exclude_uid = vec![UidRange {
+            start: 1002,
+            end: 1002,
+        }];
+        config.network.exclude_src_port = vec![PortRange {
+            start: 20000,
+            end: 20001,
+        }];
+        config.network.strict_route = true;
+        let plan = Plan::new(&config, false).unwrap();
+        assert!(
+            plan.rules
+                .iter()
+                .any(|r| r.ipv6 && r.action == Action::Unreachable && r.selector == Selector::Any)
+        );
+        for uid in [0, 1000, 1001, 1002, 1003, 1004] {
+            let excluded=plan.rules.iter().any(|r|!r.ipv6 && matches!(r.selector,Selector::Uid(range) if (range.start..=range.end).contains(&uid)));
+            assert_eq!(excluded, ![1001, 1003].contains(&uid));
+        }
+        assert!(plan.rules.iter().any(|r| matches!(
+            r.selector,
+            Selector::SourcePort(PortRange {
+                start: 20000,
+                end: 20001
+            })
+        )));
+        config.network.inet6_address.clear();
+        assert!(!Plan::new(&config, true).unwrap().ipv6);
+    }
+    fn captured(plan: &Plan, ipv6: bool, input: &str, mark: u32, uid: u32, source: u16) -> bool {
+        if mark != 0 {
+            return false;
+        }
+        let mut next = 0;
+        while let Some(rule) = plan
+            .rules
+            .iter()
+            .filter(|rule| rule.ipv6 == ipv6 && rule.priority >= next)
+            .find(|rule| match rule.selector {
+                Selector::Local => input == "lo",
+                Selector::Ingress(name) => {
+                    name[..input.len().min(16)] == *input.as_bytes()
+                        && name.get(input.len()) == Some(&0)
+                }
+                Selector::Uid(range) => input == "lo" && (range.start..=range.end).contains(&uid),
+                Selector::SourcePort(range) => (range.start..=range.end).contains(&source),
+                Selector::DestinationPort(range) => (range.start..=range.end).contains(&443),
+                Selector::Any => true,
+            })
+        {
+            match rule.action {
+                Action::Goto(priority) => next = priority,
+                Action::Table(_) => return true,
+                Action::Unreachable => return true,
+                Action::MainNonDefault | Action::Nop => next = rule.priority + 1,
+            }
+        }
+        false
+    }
+    #[test]
+    fn native_tun_input_interfaces_scope_local_and_ingress_with_reference_precedence() {
+        let mut config = TunConfig::default();
+        let default = Plan::new(&config, true).unwrap();
+        for family in [false, true] {
+            assert!(captured(&default, family, "lo", 0, 1000, 42000));
+            assert!(!captured(&default, family, "veth-a", 0, 1000, 42000));
+        }
+        config.network.include_interface =
+            vec!["lo".into(), "veth-a".into(), "missing-input".into()];
+        config.network.exclude_interface = vec!["lo".into(), "veth-a".into()];
+        config.network.exclude_src_port = vec![PortRange {
+            start: 5353,
+            end: 5353,
+        }];
+        config.network.exclude_uid = vec![UidRange {
+            start: 1005,
+            end: 1005,
+        }];
+        let plan = Plan::new(&config, true).unwrap();
+        for family in [false, true] {
+            for input in ["lo", "veth-a", "missing-input"] {
+                assert!(captured(&plan, family, input, 0, 1000, 42000));
+                assert!(!captured(&plan, family, input, 9, 1000, 42000));
+                assert!(!captured(&plan, family, input, 0, 1000, 5353));
+            }
+            assert!(!captured(&plan, family, "veth-b", 0, 1000, 42000));
+            assert!(!captured(&plan, family, "lo", 0, 1005, 42000));
+            assert!(captured(&plan, family, "veth-a", 0, 1005, 42000));
+            assert!(!captured(&plan, family, "Vole", 0, 1000, 42000));
+        }
+        // No OS lookup occurs. A named device disappearing removes matching
+        // packets, without mutating the lease or falling back to another Iif.
+        assert_eq!(plan.rules, Plan::new(&config, true).unwrap().rules);
+        config.network.include_interface.clear();
+        config.network.exclude_interface = vec!["lo".into(), "veth-b".into()];
+        let plan = Plan::new(&config, true).unwrap();
+        for family in [false, true] {
+            assert!(!captured(&plan, family, "lo", 0, 1000, 42000));
+            assert!(!captured(&plan, family, "veth-b", 0, 1000, 42000));
+            assert!(captured(&plan, family, "veth-a", 0, 1000, 42000));
+        }
+    }
+}
diff --git a/src/platform/linux_tun.rs b/src/platform/linux_tun.rs
index 769c38c..7c0028d 100644
--- a/src/platform/linux_tun.rs
+++ b/src/platform/linux_tun.rs
@@ -12,6 +12,10 @@ use std::{
     thread,
 };
 
+#[path = "linux_tun_echo.rs"]
+mod echo;
+pub(super) use echo::interface_prefixes;
+
 const NETLINK_HEADER: usize = 16;
 const LINK_HEADER: usize = 16;
 const MAX_LINK_MESSAGE: usize = 8192;
diff --git a/src/platform/linux_tun_echo.rs b/src/platform/linux_tun_echo.rs
new file mode 100644
index 0000000..a4ff8a7
--- /dev/null
+++ b/src/platform/linux_tun_echo.rs
@@ -0,0 +1,212 @@
+//! Child of linux_tun: read addresses in the borrowed TUN's owning namespace.
+use super::*;
+use crate::config::IpCidr;
+use std::{
+    net::{IpAddr, Ipv4Addr, Ipv6Addr},
+    time::{Duration, Instant},
+};
+const ADDRESS_HEADER: usize = 8;
+const MAX_PREFIXES: usize = 64;
+const MAX_DUMP_BYTES: usize = 1024 * 1024;
+
+pub(crate) fn interface_prefixes(fd: BorrowedFd<'_>) -> io::Result<Vec<IpCidr>> {
+    let mut request: libc::ifreq = unsafe { std::mem::zeroed() };
+    if unsafe { libc::ioctl(fd.as_raw_fd(), libc::TUNGETIFF, &mut request) } < 0 {
+        return Err(os_error("Linux TUN Echo interface query"));
+    }
+    validate_flags(unsafe { request.ifr_ifru.ifru_flags } as u16)?;
+    if request.ifr_name[0] == 0 || !request.ifr_name.contains(&0) {
+        return Err(invalid("Linux TUN Echo interface name is invalid"));
+    }
+    let namespace_fd = unsafe { libc::ioctl(fd.as_raw_fd(), libc::TUNGETDEVNETNS) };
+    if namespace_fd < 0 {
+        return Err(os_error("Linux TUN Echo namespace query"));
+    }
+    let namespace = File::from(unsafe { OwnedFd::from_raw_fd(namespace_fd) });
+    let target = namespace.metadata()?;
+    let current = File::open("/proc/thread-self/ns/net")?.metadata()?;
+    let name = request.ifr_name;
+    if target.dev() == current.dev() && target.ino() == current.ino() {
+        return address_snapshot(name);
+    }
+    // Same disposable-thread namespace boundary as borrowed-fd validation.
+    thread::Builder::new()
+        .name("vole-tun-echo-prefix".into())
+        .spawn(move || {
+            if unsafe { libc::setns(namespace.as_raw_fd(), libc::CLONE_NEWNET) } < 0 {
+                return Err(os_error("Linux TUN Echo namespace entry"));
+            }
+            address_snapshot(name)
+        })?
+        .join()
+        .map_err(|_| io::Error::other("TUN Echo prefix worker panicked"))?
+}
+fn address_snapshot(name: [libc::c_char; libc::IFNAMSIZ]) -> io::Result<Vec<IpCidr>> {
+    let control = socket(libc::AF_INET, libc::SOCK_DGRAM, 0)?;
+    let mut request: libc::ifreq = unsafe { std::mem::zeroed() };
+    request.ifr_name = name;
+    if unsafe { libc::ioctl(control.as_raw_fd(), libc::SIOCGIFINDEX, &mut request) } < 0 {
+        return Err(os_error("Linux TUN Echo interface index"));
+    }
+    let index = unsafe { request.ifr_ifru.ifru_ifindex };
+    if index <= 0 {
+        return Err(invalid("Linux TUN Echo interface index is invalid"));
+    }
+    let fd = socket(libc::AF_NETLINK, libc::SOCK_RAW, libc::NETLINK_ROUTE)?;
+    let timeout = libc::timeval {
+        tv_sec: 1,
+        tv_usec: 0,
+    };
+    for option in [libc::SO_RCVTIMEO, libc::SO_SNDTIMEO] {
+        if unsafe {
+            libc::setsockopt(
+                fd.as_raw_fd(),
+                libc::SOL_SOCKET,
+                option,
+                (&raw const timeout).cast(),
+                std::mem::size_of_val(&timeout) as libc::socklen_t,
+            )
+        } < 0
+        {
+            return Err(os_error("Linux TUN Echo address query timeout"));
+        }
+    }
+    let mut query = [0u8; NETLINK_HEADER + ADDRESS_HEADER];
+    let len = query.len() as u32;
+    query[..4].copy_from_slice(&len.to_ne_bytes());
+    query[4..6].copy_from_slice(&libc::RTM_GETADDR.to_ne_bytes());
+    query[6..8].copy_from_slice(&((libc::NLM_F_REQUEST | libc::NLM_F_DUMP) as u16).to_ne_bytes());
+    query[8..12].copy_from_slice(&QUERY_SEQUENCE.to_ne_bytes());
+    query[NETLINK_HEADER] = libc::AF_UNSPEC as u8;
+    query[NETLINK_HEADER + 4..NETLINK_HEADER + 8].copy_from_slice(&index.to_ne_bytes());
+    let mut kernel: libc::sockaddr_nl = unsafe { std::mem::zeroed() };
+    kernel.nl_family = libc::AF_NETLINK as libc::sa_family_t;
+    let sent = unsafe {
+        libc::sendto(
+            fd.as_raw_fd(),
+            query.as_ptr().cast(),
+            query.len(),
+            0,
+            (&raw const kernel).cast(),
+            std::mem::size_of_val(&kernel) as libc::socklen_t,
+        )
+    };
+    if sent < 0 {
+        return Err(os_error("Linux TUN Echo address query"));
+    }
+    if sent as usize != query.len() {
+        return Err(invalid("short Linux TUN address query"));
+    }
+    let mut buffer = [0u8; 32768];
+    let mut total = 0usize;
+    let deadline = Instant::now() + Duration::from_secs(2);
+    let mut prefixes = Vec::with_capacity(MAX_PREFIXES);
+    loop {
+        if Instant::now() >= deadline {
+            return Err(io::ErrorKind::TimedOut.into());
+        }
+        let mut peer = kernel;
+        let mut peer_len = std::mem::size_of_val(&peer) as libc::socklen_t;
+        let n = unsafe {
+            libc::recvfrom(
+                fd.as_raw_fd(),
+                buffer.as_mut_ptr().cast(),
+                buffer.len(),
+                libc::MSG_TRUNC,
+                (&raw mut peer).cast(),
+                &mut peer_len,
+            )
+        };
+        if n < 0 {
+            return Err(os_error("Linux TUN Echo address response"));
+        }
+        total = total.saturating_add(n as usize);
+        if n == 0
+            || n as usize > buffer.len()
+            || total > MAX_DUMP_BYTES
+            || peer_len as usize != std::mem::size_of_val(&peer)
+            || peer.nl_family != libc::AF_NETLINK as libc::sa_family_t
+            || peer.nl_pid != 0
+            || peer.nl_groups != 0
+        {
+            return Err(invalid(
+                "Linux TUN Echo address response is invalid or oversized",
+            ));
+        }
+        let mut messages = &buffer[..n as usize];
+        while !messages.is_empty() {
+            if messages.len() < NETLINK_HEADER {
+                return Err(invalid("short TUN address message"));
+            }
+            let len = native_u32(&messages[..4])? as usize;
+            let aligned = (len + 3) & !3;
+            if len < NETLINK_HEADER
+                || aligned > messages.len()
+                || native_u32(&messages[8..12])? != QUERY_SEQUENCE
+                || native_u16(&messages[6..8])? & 0x10 != 0
+            {
+                // NLM_F_DUMP_INTR
+                return Err(invalid("interrupted or malformed TUN address dump"));
+            }
+            let body = &messages[NETLINK_HEADER..len];
+            match i32::from(native_u16(&messages[4..6])?) {
+                libc::NLMSG_DONE => {
+                    if body.len() >= 4 && i32::from_ne_bytes(body[..4].try_into().unwrap()) != 0 {
+                        return Err(invalid("TUN address dump completion reported an error"));
+                    }
+                    return Ok(prefixes);
+                }
+                libc::NLMSG_ERROR => {
+                    if body.len() < 4 {
+                        return Err(invalid("short TUN address errno"));
+                    }
+                    let errno = i32::from_ne_bytes(body[..4].try_into().unwrap());
+                    if errno < 0 && errno != i32::MIN {
+                        return Err(io::Error::from_raw_os_error(-errno));
+                    }
+                    if errno != 0 {
+                        return Err(invalid("invalid TUN address errno"));
+                    }
+                }
+                kind if kind == i32::from(libc::RTM_NEWADDR) => {
+                    if body.len() < ADDRESS_HEADER {
+                        return Err(invalid("short TUN address header"));
+                    }
+                    if native_u32(&body[4..8])? == index as u32 {
+                        let attrs = &body[ADDRESS_HEADER..];
+                        let address = match i32::from(body[0]) {
+                            libc::AF_INET if body[1] <= 32 => {
+                                let local = attribute(attrs, libc::IFA_LOCAL)?
+                                    .or(attribute(attrs, libc::IFA_ADDRESS)?);
+                                local
+                                    .and_then(|b| <[u8; 4]>::try_from(b).ok())
+                                    .map(Ipv4Addr::from)
+                                    .map(IpAddr::V4)
+                            }
+                            libc::AF_INET6 if body[1] <= 128 => {
+                                attribute(attrs, libc::IFA_ADDRESS)?
+                                    .and_then(|b| <[u8; 16]>::try_from(b).ok())
+                                    .map(Ipv6Addr::from)
+                                    .map(IpAddr::V6)
+                            }
+                            _ => None,
+                        }
+                        .ok_or_else(|| invalid("invalid TUN interface address"))?;
+                        let prefix = IpCidr {
+                            network: address,
+                            prefix_len: body[1],
+                        };
+                        if !prefixes.contains(&prefix) {
+                            if prefixes.len() == MAX_PREFIXES {
+                                return Err(invalid("too many TUN interface prefixes"));
+                            }
+                            prefixes.push(prefix);
+                        }
+                    }
+                }
+                _ => {}
+            }
+            messages = &messages[aligned..];
+        }
+    }
+}
diff --git a/src/platform/mod.rs b/src/platform/mod.rs
index cf3de2a..47343a7 100644
--- a/src/platform/mod.rs
+++ b/src/platform/mod.rs
@@ -3,13 +3,12 @@
     any(target_os = "ios", target_os = "tvos", target_os = "macos")
 ))]
 pub(crate) mod apple_logging;
+#[cfg(all(feature = "tun", any(target_os = "linux", test)))]
+#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
+pub(crate) mod linux_network;
 #[cfg(all(target_os = "linux", feature = "tun"))]
 mod linux_tun;
-#[cfg(all(
-    feature = "invoke",
-    any(target_os = "ios", target_os = "tvos", target_os = "macos")
-))]
-#[cfg_attr(target_os = "macos", allow(dead_code))]
+#[cfg(feature = "invoke")]
 pub(crate) mod process_memory;
 #[cfg(all(unix, feature = "tun"))]
 mod tun_fd;
diff --git a/src/platform/process_memory.rs b/src/platform/process_memory.rs
index ffd4f6b..2e62055 100644
--- a/src/platform/process_memory.rs
+++ b/src/platform/process_memory.rs
@@ -1,57 +1,43 @@
 use std::{
-    ffi::c_void,
-    io, mem, ptr,
+    io,
     sync::atomic::{AtomicBool, AtomicU8, Ordering},
     time::Duration,
 };
 
-use crate::limits::{
-    IOS_TUN_PEAK_OBSERVATION_TARGET_BYTES, IOS_TUN_START_OBSERVATION_TARGET_BYTES,
-};
+#[cfg(any(target_os = "ios", target_os = "tvos", target_os = "macos"))]
+use std::{ffi::c_void, mem, ptr};
+
+use crate::limits::{MEMORY_OBSERVATION_1GBPS_BYTES, MEMORY_OBSERVATION_CEILING_BYTES};
 
 pub(crate) const TELEMETRY_INTERVAL: Duration = Duration::from_secs(30);
 
+#[cfg(any(target_os = "ios", target_os = "tvos", target_os = "macos"))]
 const TASK_VM_INFO: libc::task_flavor_t = 22;
-const FORTY_MIB: u64 = 40 * 1024 * 1024;
-const THRESHOLDS: [MemoryThreshold; 3] = [
+const THRESHOLDS: [MemoryThreshold; 2] = [
     MemoryThreshold {
-        bytes: IOS_TUN_START_OBSERVATION_TARGET_BYTES,
+        bytes: MEMORY_OBSERVATION_1GBPS_BYTES,
         bit: 1 << 0,
-        mib: 35,
+        mib: 43,
     },
     MemoryThreshold {
-        bytes: FORTY_MIB,
+        bytes: MEMORY_OBSERVATION_CEILING_BYTES,
         bit: 1 << 1,
-        mib: 40,
-    },
-    MemoryThreshold {
-        bytes: IOS_TUN_PEAK_OBSERVATION_TARGET_BYTES,
-        bit: 1 << 2,
         mib: 45,
     },
 ];
 
 static TELEMETRY_POLICY: MemoryTelemetryPolicy = MemoryTelemetryPolicy::new();
 
-// Preserve existing iOS event identifiers for consumers, without labelling
-// tvOS samples as iOS. These are diagnostics, not platform memory quotas.
-const MEMORY_EVENTS: [&str; 3] = if cfg!(target_os = "tvos") {
-    [
-        "tvos_memory_snapshot",
-        "tvos_memory_observation_target_crossed",
-        "tvos_memory_measurement_failed",
-    ]
-} else {
-    [
-        "ios_memory_snapshot",
-        "ios_memory_observation_target_crossed",
-        "ios_memory_measurement_failed",
-    ]
-};
+const MEMORY_EVENTS: [&str; 3] = [
+    "memory_snapshot",
+    "memory_observation_threshold_crossed",
+    "memory_measurement_failed",
+];
 
 /// Public `TASK_VM_INFO` layout through revision 3. Revision 3 is the first
 /// revision that contains `ledger_phys_footprint_peak`; using that fixed,
 /// documented prefix avoids depending on newer SDK-only tail fields.
+#[cfg(any(target_os = "ios", target_os = "tvos", target_os = "macos"))]
 #[repr(C)]
 #[derive(Debug, Clone, Copy, Default)]
 struct TaskVmInfoRev3 {
@@ -83,8 +69,9 @@ struct TaskVmInfoRev3 {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) struct ProcessMemorySnapshot {
-    pub current_phys_footprint: u64,
-    pub lifetime_peak_phys_footprint: u64,
+    pub current_bytes: u64,
+    pub lifetime_peak_bytes: u64,
+    pub metric: &'static str,
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -94,8 +81,8 @@ struct MemoryThreshold {
     mib: u8,
 }
 
-/// Platform-neutral decision state. The Mach provider is intentionally kept
-/// outside this type so host tests can inject arbitrary snapshots and errors.
+/// The platform measurement provider is kept outside the policy so memory
+/// observation stays non-fatal and can be tested without process sampling.
 struct MemoryTelemetryPolicy {
     crossed_thresholds: AtomicU8,
     measurement_failure_warned: AtomicBool,
@@ -114,7 +101,7 @@ impl MemoryTelemetryPolicy {
             Ok(snapshot) => {
                 let crossed = THRESHOLDS
                     .iter()
-                    .filter(|threshold| snapshot.current_phys_footprint >= threshold.bytes)
+                    .filter(|threshold| snapshot.current_bytes >= threshold.bytes)
                     .fold(0_u8, |mask, threshold| mask | threshold.bit);
                 let already_crossed = self.crossed_thresholds.fetch_or(crossed, Ordering::Relaxed);
                 TelemetryObservation::Snapshot {
@@ -155,9 +142,10 @@ pub(crate) fn observe(stage: &'static str) {
                 event = MEMORY_EVENTS[0],
                 platform = std::env::consts::OS,
                 stage,
-                current_phys_footprint_bytes = snapshot.current_phys_footprint,
-                process_lifetime_peak_phys_footprint_bytes = snapshot.lifetime_peak_phys_footprint,
-                "Apple TUN memory telemetry"
+                metric = snapshot.metric,
+                current_bytes = snapshot.current_bytes,
+                process_lifetime_peak_bytes = snapshot.lifetime_peak_bytes,
+                "TUN memory telemetry"
             );
             for threshold in THRESHOLDS
                 .iter()
@@ -167,12 +155,12 @@ pub(crate) fn observe(stage: &'static str) {
                     event = MEMORY_EVENTS[1],
                     platform = std::env::consts::OS,
                     stage,
-                    current_phys_footprint_bytes = snapshot.current_phys_footprint,
-                    process_lifetime_peak_phys_footprint_bytes =
-                        snapshot.lifetime_peak_phys_footprint,
+                    metric = snapshot.metric,
+                    current_bytes = snapshot.current_bytes,
+                    process_lifetime_peak_bytes = snapshot.lifetime_peak_bytes,
                     threshold_bytes = threshold.bytes,
                     threshold_mib = threshold.mib,
-                    "Apple TUN current memory crossed an observation threshold"
+                    "TUN current memory crossed an observation threshold"
                 );
             }
         }
@@ -183,7 +171,7 @@ pub(crate) fn observe(stage: &'static str) {
                     platform = std::env::consts::OS,
                     stage,
                     error = %error,
-                    "unable to sample Apple TUN memory telemetry"
+                    "unable to sample TUN memory telemetry"
                 );
             }
         }
@@ -192,6 +180,7 @@ pub(crate) fn observe(stage: &'static str) {
 
 /// Reads current and process-lifetime physical footprint using public
 /// `TASK_VM_INFO` fields. Callers must treat failure as telemetry loss only.
+#[cfg(any(target_os = "ios", target_os = "tvos", target_os = "macos"))]
 #[allow(deprecated)] // libc recommends mach2 for the thin mach_task_self accessor.
 pub(crate) fn snapshot() -> io::Result<ProcessMemorySnapshot> {
     let mut info = TaskVmInfoRev3::default();
@@ -226,22 +215,115 @@ pub(crate) fn snapshot() -> io::Result<ProcessMemorySnapshot> {
     }
     let peak = u64::try_from(info.ledger_phys_footprint_peak).unwrap_or(0);
     Ok(ProcessMemorySnapshot {
-        current_phys_footprint: info.phys_footprint,
-        lifetime_peak_phys_footprint: peak,
+        current_bytes: info.phys_footprint,
+        lifetime_peak_bytes: peak,
+        metric: "physical_footprint",
     })
 }
 
-/// Best-effort release of free pages held by Apple's malloc zones after a TUN
-/// consumer has stopped. It has no bearing on lifecycle success.
+/// Best-effort release after the TUN consumer stops; never a lifecycle result.
+#[cfg(any(target_os = "ios", target_os = "tvos", target_os = "macos"))]
 pub(crate) fn relieve_allocator_pressure() {
     unsafe extern "C" {
         fn malloc_zone_pressure_relief(zone: *mut c_void, goal: usize) -> usize;
     }
     // SAFETY: a null zone asks the allocator to inspect all zones; goal zero
-    // requests best-effort pressure relief. Available on supported iOS/tvOS targets.
+    // requests best-effort pressure relief. Available on supported Apple targets.
     let _released = unsafe { malloc_zone_pressure_relief(ptr::null_mut(), 0) };
 }
 
+/// Apply GNU allocator hints once, after TUN lifecycle admission and before
+/// Core workers start. Existing allocator overrides retain all system defaults.
+#[cfg(all(target_os = "linux", target_env = "gnu"))]
+pub(crate) fn configure_allocator() {
+    static CONFIGURED: std::sync::Once = std::sync::Once::new();
+    CONFIGURED.call_once(|| {
+        if allocator_hints_allowed(
+            std::env::var_os("MALLOC_ARENA_MAX").is_some(),
+            std::env::var_os("MALLOC_MMAP_THRESHOLD_").is_some(),
+            std::env::var_os("GLIBC_TUNABLES").is_some(),
+        ) {
+            // SAFETY: glibc's process-wide hint interface takes integer values
+            // and retains no caller-owned memory. Failure preserves defaults.
+            let _ = unsafe { libc::mallopt(libc::M_ARENA_MAX, 1) };
+            let _ = unsafe { libc::mallopt(libc::M_MMAP_THRESHOLD, 32 * 1024) };
+        }
+    });
+}
+
+#[cfg(all(target_os = "linux", target_env = "gnu"))]
+fn allocator_hints_allowed(
+    arena_override: bool,
+    mmap_override: bool,
+    tunables_override: bool,
+) -> bool {
+    !(arena_override || mmap_override || tunables_override)
+}
+
+#[cfg(not(all(target_os = "linux", target_env = "gnu")))]
+pub(crate) fn configure_allocator() {}
+
+#[cfg(target_os = "linux")]
+pub(crate) fn snapshot() -> io::Result<ProcessMemorySnapshot> {
+    parse_linux_status(&std::fs::read_to_string("/proc/self/status")?)
+}
+
+#[cfg(target_os = "linux")]
+fn parse_linux_status(status: &str) -> io::Result<ProcessMemorySnapshot> {
+    fn bytes(status: &str, field: &str) -> io::Result<u64> {
+        status
+            .lines()
+            .find_map(|line| {
+                let value = line.strip_prefix(field)?;
+                let mut words = value.split_ascii_whitespace();
+                let kib = words.next()?.parse::<u64>().ok()?;
+                if words.next()? != "kB" || words.next().is_some() {
+                    return None;
+                }
+                kib.checked_mul(1024)
+            })
+            .ok_or_else(|| {
+                io::Error::new(
+                    io::ErrorKind::InvalidData,
+                    "procfs memory metric is unavailable",
+                )
+            })
+    }
+    Ok(ProcessMemorySnapshot {
+        current_bytes: bytes(status, "VmRSS:")?,
+        lifetime_peak_bytes: bytes(status, "VmHWM:")?,
+        metric: "resident_set",
+    })
+}
+
+#[cfg(not(any(
+    target_os = "linux",
+    target_os = "ios",
+    target_os = "tvos",
+    target_os = "macos"
+)))]
+pub(crate) fn snapshot() -> io::Result<ProcessMemorySnapshot> {
+    Err(io::Error::new(
+        io::ErrorKind::Unsupported,
+        "process memory measurement is unavailable on this target",
+    ))
+}
+
+#[cfg(all(target_os = "linux", target_env = "gnu"))]
+pub(crate) fn relieve_allocator_pressure() {
+    // SAFETY: glibc's public allocator trim takes no caller-owned pointers;
+    // refusing or releasing no pages does not affect lifecycle completion.
+    let _ = unsafe { libc::malloc_trim(0) };
+}
+
+#[cfg(not(any(
+    all(target_os = "linux", target_env = "gnu"),
+    target_os = "ios",
+    target_os = "tvos",
+    target_os = "macos"
+)))]
+pub(crate) fn relieve_allocator_pressure() {}
+
 #[cfg(test)]
 mod tests {
     use std::{sync::Arc, thread};
@@ -250,8 +332,9 @@ mod tests {
 
     fn snapshot_at(current: u64, lifetime_peak: u64) -> io::Result<ProcessMemorySnapshot> {
         Ok(ProcessMemorySnapshot {
-            current_phys_footprint: current,
-            lifetime_peak_phys_footprint: lifetime_peak,
+            current_bytes: current,
+            lifetime_peak_bytes: lifetime_peak,
+            metric: "injected",
         })
     }
 
@@ -272,16 +355,16 @@ mod tests {
     #[test]
     fn thresholds_use_current_and_are_reported_only_once() {
         let policy = MemoryTelemetryPolicy::new();
-        let (snapshot, crossed) = sampled(&policy, 35 * 1024 * 1024 - 1, 100 * 1024 * 1024);
-        assert_eq!(snapshot.lifetime_peak_phys_footprint, 100 * 1024 * 1024);
+        let (snapshot, crossed) = sampled(&policy, 43 * 1024 * 1024 - 1, 100 * 1024 * 1024);
+        assert_eq!(snapshot.lifetime_peak_bytes, 100 * 1024 * 1024);
         assert_eq!(crossed, 0);
         assert_eq!(
-            sampled(&policy, 35 * 1024 * 1024, 100 * 1024 * 1024).1,
+            sampled(&policy, 43 * 1024 * 1024, 100 * 1024 * 1024).1,
             1 << 0
         );
         assert_eq!(
-            sampled(&policy, 46 * 1024 * 1024, 100 * 1024 * 1024).1,
-            (1 << 1) | (1 << 2)
+            sampled(&policy, 45 * 1024 * 1024, 100 * 1024 * 1024).1,
+            1 << 1
         );
         assert_eq!(sampled(&policy, 46 * 1024 * 1024, 101 * 1024 * 1024).1, 0);
     }
@@ -320,9 +403,10 @@ mod tests {
                 assert_eq!(mask & crossed, 0);
                 mask | crossed
             });
-        assert_eq!(newly_crossed, (1 << 0) | (1 << 1) | (1 << 2));
+        assert_eq!(newly_crossed, (1 << 0) | (1 << 1));
     }
 
+    #[cfg(any(target_os = "ios", target_os = "tvos", target_os = "macos"))]
     #[test]
     fn apple_process_snapshot_is_nonzero() {
         assert_eq!(mem::size_of::<TaskVmInfoRev3>(), 336);
@@ -332,10 +416,41 @@ mod tests {
             168
         );
         let snapshot = snapshot().unwrap();
-        assert!(snapshot.current_phys_footprint > 0);
+        assert!(snapshot.current_bytes > 0);
         assert!(
-            snapshot.lifetime_peak_phys_footprint == 0
-                || snapshot.lifetime_peak_phys_footprint >= snapshot.current_phys_footprint
+            snapshot.lifetime_peak_bytes == 0
+                || snapshot.lifetime_peak_bytes >= snapshot.current_bytes
         );
     }
+    #[cfg(target_os = "linux")]
+    #[test]
+    fn linux_status_reports_rss_without_relabelling_footprint() {
+        let snapshot = parse_linux_status("VmRSS:\t123 kB\nVmHWM:\t456 kB\n").unwrap();
+        assert_eq!(snapshot.current_bytes, 123 * 1024);
+        assert_eq!(snapshot.lifetime_peak_bytes, 456 * 1024);
+        assert_eq!(snapshot.metric, "resident_set");
+        assert!(parse_linux_status("VmRSS: 12 kB\n").is_err());
+        assert!(parse_linux_status("VmRSS: 12 B\nVmHWM: 13 kB\n").is_err());
+        assert!(parse_linux_status("VmRSS: 18446744073709551615 kB\nVmHWM: 13 kB\n").is_err());
+    }
+
+    #[cfg(all(target_os = "linux", target_env = "gnu"))]
+    #[test]
+    fn explicit_allocator_overrides_preserve_system_policy() {
+        assert!(allocator_hints_allowed(false, false, false));
+        assert!(!allocator_hints_allowed(true, false, false));
+        assert!(!allocator_hints_allowed(false, true, false));
+        assert!(!allocator_hints_allowed(false, false, true));
+    }
+
+    #[cfg(not(any(
+        target_os = "linux",
+        target_os = "ios",
+        target_os = "tvos",
+        target_os = "macos"
+    )))]
+    #[test]
+    fn unsupported_memory_provider_is_non_fatal() {
+        assert_eq!(snapshot().unwrap_err().kind(), io::ErrorKind::Unsupported);
+    }
 }
diff --git a/src/platform/tun_rs_io.rs b/src/platform/tun_rs_io.rs
index 76f9416..6829347 100644
--- a/src/platform/tun_rs_io.rs
+++ b/src/platform/tun_rs_io.rs
@@ -6,6 +6,11 @@ use crate::{IpVersion, Result, TunFraming, VoleError};
 
 use super::{TUN_PACKET_BATCH_SIZE, TunFd};
 
+#[cfg(all(test, target_os = "linux"))]
+use tests::Device;
+#[cfg(not(all(test, target_os = "linux")))]
+use tun_rs::SyncDevice as Device;
+
 #[cfg(test)]
 const TUN_MTU: usize = 1_500;
 
@@ -17,11 +22,19 @@ const TUN_MTU: usize = 1_500;
 /// of using its async constructor: a duplicated descriptor shares file-status
 /// flags with the host descriptor, and Vole must never change those flags.
 pub struct TunRsIo {
-    device: AsyncFd<tun_rs::SyncDevice>,
+    device: AsyncFd<Device>,
     framing: TunFraming,
     mtu: usize,
 }
 
+fn register_device(device: tun_rs::SyncDevice) -> io::Result<AsyncFd<Device>> {
+    #[cfg(all(test, target_os = "linux"))]
+    let device = Device::Native(device);
+    // SAFETY: SyncDevice owns the open descriptor, and registration preserves
+    // its file-status flags. The device remains owned until AsyncFd drops it.
+    unsafe { AsyncFd::register(device) }.map_err(io::Error::from)
+}
+
 impl fmt::Debug for TunRsIo {
     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
         formatter
@@ -52,12 +65,95 @@ impl TunRsIo {
         let device = unsafe { tun_rs::SyncDevice::from_fd(fd.into_raw_fd()) }?;
         configure_platform_framing(&device, framing);
         Ok(Self {
-            device: AsyncFd::new(device)?,
+            device: register_device(device)?,
             framing,
             mtu: usize::from(mtu),
         })
     }
 
+    // Socketpair fixtures share the production packet algorithms without
+    // presenting an ordinary socket as a Linux TUN. This entry does not exist
+    // in production; Apple still uses SyncDevice for actual PI handling.
+    #[cfg(test)]
+    pub(crate) fn new_mock(fd: TunFd, framing: TunFraming) -> Result<Self> {
+        Self::new_mock_with_mtu(fd, framing, 1500)
+    }
+
+    #[cfg(test)]
+    pub(crate) fn new_mock_with_mtu(fd: TunFd, framing: TunFraming, mtu: u16) -> Result<Self> {
+        #[cfg(target_os = "linux")]
+        {
+            validate_mtu(mtu)?;
+            assert_eq!(framing, TunFraming::RawIp);
+            Ok(Self {
+                // SAFETY: the fixture owns the duplicate without changing its
+                // shared nonblocking status; AsyncFd owns it until drop.
+                device: unsafe { AsyncFd::register(Device::SocketPair(fd)) }
+                    .map_err(io::Error::from)?,
+                framing,
+                mtu: usize::from(mtu),
+            })
+        }
+        #[cfg(not(target_os = "linux"))]
+        Self::new_with_mtu(fd, framing, mtu)
+    }
+
+    #[cfg(any(target_os = "linux", target_os = "macos"))]
+    pub(crate) fn interface_name(&self) -> io::Result<String> {
+        self.device.get_ref().name()
+    }
+
+    #[cfg(target_os = "linux")]
+    pub(crate) fn echo_prefixes(&self) -> io::Result<Vec<crate::config::IpCidr>> {
+        use std::os::fd::AsFd;
+        super::linux_tun::interface_prefixes(self.device.get_ref().as_fd())
+    }
+
+    #[cfg(target_os = "linux")]
+    pub(crate) fn linux_device(&self) -> &tun_rs::SyncDevice {
+        #[cfg(test)]
+        {
+            self.device.get_ref().native()
+        }
+        #[cfg(not(test))]
+        {
+            self.device.get_ref()
+        }
+    }
+
+    #[cfg(target_os = "linux")]
+    pub(crate) fn open_exclusive(name: &str, mtu: u16) -> Result<Self> {
+        use std::{ffi::CString, os::fd::AsRawFd};
+        let name = CString::new(if name.is_empty() { "Vole" } else { name })
+            .map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "invalid TUN name"))?;
+        if name.as_bytes().len() >= libc::IFNAMSIZ {
+            return Err(io::Error::new(io::ErrorKind::InvalidInput, "TUN name is too long").into());
+        }
+        let fd = std::fs::OpenOptions::new()
+            .read(true)
+            .write(true)
+            .open("/dev/net/tun")?;
+        // SAFETY: ifreq starts zeroed; copied name includes its terminator.
+        let mut request: libc::ifreq = unsafe { std::mem::zeroed() };
+        for (slot, byte) in request.ifr_name.iter_mut().zip(name.as_bytes_with_nul()) {
+            *slot = *byte as libc::c_char;
+        }
+        request.ifr_ifru.ifru_flags = (libc::IFF_TUN | libc::IFF_NO_PI | 0x8000) as libc::c_short; // IFF_TUN_EXCL
+        // SAFETY: fd points to /dev/net/tun and request is a complete initialized ifreq.
+        if unsafe { libc::ioctl(fd.as_raw_fd(), libc::TUNSETIFF, &request) } < 0 {
+            return Err(io::Error::last_os_error().into());
+        }
+        // SAFETY: ownership moves to SyncDevice only after the exclusive ioctl succeeded.
+        let device = unsafe { tun_rs::SyncDevice::from_fd(fd.into_raw_fd()) }?;
+        device.set_mtu(mtu)?;
+        device.set_nonblocking(true)?;
+        Ok(Self {
+            device: register_device(device)?,
+            framing: TunFraming::RawIp,
+            mtu: usize::from(mtu),
+        })
+    }
+
     /// Open a core-owned local TUN without configuring addresses or routes.
     /// Owned descriptors may be made nonblocking; borrowed ones are never changed.
     pub fn open(name: &str, mtu: u16) -> Result<Self> {
@@ -84,7 +180,7 @@ impl TunRsIo {
             let framing = TunFraming::RawIp;
             configure_platform_framing(&device, framing);
             Ok(Self {
-                device: AsyncFd::new(device)?,
+                device: register_device(device)?,
                 framing,
                 mtu: usize::from(mtu),
             })
@@ -282,6 +378,92 @@ mod tests {
 
     use super::*;
 
+    // Recent tun-rs versions correctly reject socketpairs when adopting a
+    // Linux TUN. Keep the real constructor intact and substitute only the fd
+    // operations for these local packet-I/O fixtures. Apple fixtures continue
+    // through SyncDevice so its packet-information handling remains covered.
+    #[cfg(target_os = "linux")]
+    pub(super) enum Device {
+        Native(tun_rs::SyncDevice),
+        SocketPair(TunFd),
+    }
+
+    #[cfg(target_os = "linux")]
+    impl std::os::fd::AsRawFd for Device {
+        fn as_raw_fd(&self) -> std::os::fd::RawFd {
+            match self {
+                Self::Native(device) => device.as_raw_fd(),
+                Self::SocketPair(fd) => fd.as_raw_fd(),
+            }
+        }
+    }
+
+    #[cfg(target_os = "linux")]
+    impl std::os::fd::AsFd for Device {
+        fn as_fd(&self) -> std::os::fd::BorrowedFd<'_> {
+            match self {
+                Self::Native(device) => std::os::fd::AsFd::as_fd(device),
+                Self::SocketPair(fd) => fd.as_fd(),
+            }
+        }
+    }
+
+    #[cfg(target_os = "linux")]
+    impl Device {
+        pub(super) fn native(&self) -> &tun_rs::SyncDevice {
+            match self {
+                Self::Native(device) => device,
+                Self::SocketPair(_) => panic!("packet fixture has no native TUN interface"),
+            }
+        }
+
+        pub(super) fn name(&self) -> io::Result<String> {
+            match self {
+                Self::Native(device) => device.name(),
+                Self::SocketPair(_) => Err(io::Error::new(
+                    io::ErrorKind::Unsupported,
+                    "packet fixture has no native TUN interface",
+                )),
+            }
+        }
+
+        pub(super) fn recv(&self, packet: &mut [u8]) -> io::Result<usize> {
+            match self {
+                Self::Native(device) => device.recv(packet),
+                Self::SocketPair(fd) => {
+                    // SAFETY: the fixture owns this open duplicate, and the
+                    // mutable slice supplies its full writable byte range.
+                    let size = unsafe {
+                        libc::read(fd.as_raw_fd(), packet.as_mut_ptr().cast(), packet.len())
+                    };
+                    if size < 0 {
+                        Err(io::Error::last_os_error())
+                    } else {
+                        Ok(size as usize)
+                    }
+                }
+            }
+        }
+
+        pub(super) fn send(&self, packet: &[u8]) -> io::Result<usize> {
+            match self {
+                Self::Native(device) => device.send(packet),
+                Self::SocketPair(fd) => {
+                    // SAFETY: the fixture owns this open duplicate, and the
+                    // immutable slice remains live for the synchronous write.
+                    let size = unsafe {
+                        libc::write(fd.as_raw_fd(), packet.as_ptr().cast(), packet.len())
+                    };
+                    if size < 0 {
+                        Err(io::Error::last_os_error())
+                    } else {
+                        Ok(size as usize)
+                    }
+                }
+            }
+        }
+    }
+
     const IPV4: [u8; 20] = [
         0x45, 0, 0, 20, 0, 0, 0, 0, 64, 17, 0, 0, 127, 0, 0, 1, 127, 0, 0, 1,
     ];
@@ -290,12 +472,40 @@ mod tests {
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
     ];
 
+    #[cfg(target_os = "linux")]
+    #[tokio::test]
+    async fn real_constructor_rejects_socketpair_and_closes_only_its_duplicate() {
+        let (mut host, mut peer) = UnixStream::pair().unwrap();
+        host.set_nonblocking(true).unwrap();
+        // SAFETY: host remains open before and after the failed adoption.
+        let before = unsafe { libc::fcntl(host.as_raw_fd(), libc::F_GETFL) };
+        let fd = TunFd::duplicate_mock(host.as_raw_fd()).unwrap();
+        assert_ne!(fd.as_raw_fd(), host.as_raw_fd());
+        let error = TunRsIo::new(fd, TunFraming::RawIp).unwrap_err();
+        assert!(matches!(
+            error,
+            VoleError::Io(ref error) if error.raw_os_error() == Some(libc::ENOTTY)
+        ));
+        // SAFETY: the original host descriptor is still owned by this test.
+        let after = unsafe { libc::fcntl(host.as_raw_fd(), libc::F_GETFL) };
+        assert_eq!(before, after);
+        host.write_all(b"ok").unwrap();
+        let mut bytes = [0; 2];
+        peer.read_exact(&mut bytes).unwrap();
+        assert_eq!(&bytes, b"ok");
+        peer.set_nonblocking(true).unwrap();
+        drop(host);
+        // EOF proves that failed adoption released the duplicate, without
+        // depending on a numeric fd that another parallel test could reuse.
+        assert_eq!(peer.read(&mut bytes).unwrap(), 0);
+    }
+
     #[tokio::test]
     async fn raw_ip_read_reuses_caller_buffer_for_ipv4_and_ipv6() {
         let (host, peer) = UnixDatagram::pair().unwrap();
         host.set_nonblocking(true).unwrap();
         let fd = TunFd::duplicate_mock(host.as_raw_fd()).unwrap();
-        let io = TunRsIo::new(fd, TunFraming::RawIp).unwrap();
+        let io = TunRsIo::new_mock(fd, TunFraming::RawIp).unwrap();
 
         let mut packet = Vec::with_capacity(1500);
         for (expected, version) in [(&IPV4[..], IpVersion::V4), (&IPV6[..], IpVersion::V6)] {
@@ -310,7 +520,7 @@ mod tests {
     async fn batch_read_preserves_valid_neighbours_of_an_invalid_packet() {
         let (host, peer) = UnixDatagram::pair().unwrap();
         host.set_nonblocking(true).unwrap();
-        let io = TunRsIo::new(
+        let io = TunRsIo::new_mock(
             TunFd::duplicate_mock(host.as_raw_fd()).unwrap(),
             TunFraming::RawIp,
         )
@@ -338,7 +548,7 @@ mod tests {
         let (host, peer) = UnixDatagram::pair().unwrap();
         host.set_nonblocking(true).unwrap();
         peer.set_nonblocking(true).unwrap();
-        let io = TunRsIo::new(
+        let io = TunRsIo::new_mock(
             TunFd::duplicate_mock(host.as_raw_fd()).unwrap(),
             TunFraming::RawIp,
         )
@@ -365,7 +575,7 @@ mod tests {
     async fn batch_read_waits_for_first_packet_and_can_be_cancelled() {
         let (host, peer) = UnixDatagram::pair().unwrap();
         host.set_nonblocking(true).unwrap();
-        let io = TunRsIo::new(
+        let io = TunRsIo::new_mock(
             TunFd::duplicate_mock(host.as_raw_fd()).unwrap(),
             TunFraming::RawIp,
         )
@@ -391,7 +601,7 @@ mod tests {
     async fn batch_read_preserves_consumed_prefix_on_eof() {
         let (host, mut peer) = UnixStream::pair().unwrap();
         host.set_nonblocking(true).unwrap();
-        let io = TunRsIo::new(
+        let io = TunRsIo::new_mock(
             TunFd::duplicate_mock(host.as_raw_fd()).unwrap(),
             TunFraming::RawIp,
         )
@@ -414,7 +624,7 @@ mod tests {
         let (host, peer) = UnixDatagram::pair().unwrap();
         host.set_nonblocking(true).unwrap();
         peer.set_nonblocking(true).unwrap();
-        let io = TunRsIo::new(
+        let io = TunRsIo::new_mock(
             TunFd::duplicate_mock(host.as_raw_fd()).unwrap(),
             TunFraming::RawIp,
         )
@@ -447,20 +657,17 @@ mod tests {
         // SAFETY: host remains open for both flag reads.
         let before = unsafe { libc::fcntl(host.as_raw_fd(), libc::F_GETFL) };
         let fd = TunFd::duplicate_mock(host.as_raw_fd()).unwrap();
-        let io = TunRsIo::new(fd, TunFraming::RawIp).unwrap();
+        let io = TunRsIo::new_mock(fd, TunFraming::RawIp).unwrap();
         let duplicate = io.device.get_ref().as_raw_fd();
         assert_ne!(duplicate, host.as_raw_fd());
         // SAFETY: both descriptors are open while the adapter is alive.
         let constructed_flags = unsafe { libc::fcntl(host.as_raw_fd(), libc::F_GETFL) };
         assert_eq!(constructed_flags, before);
-        // SAFETY: the duplicate is owned by the live SyncDevice.
+        // SAFETY: the duplicate is owned by the live adapter.
         let descriptor_flags = unsafe { libc::fcntl(duplicate, libc::F_GETFD) };
         assert_ne!(descriptor_flags & libc::FD_CLOEXEC, 0);
         drop(io);
-        // SAFETY: F_GETFD only inspects the numeric descriptor after drop.
-        assert_eq!(unsafe { libc::fcntl(duplicate, libc::F_GETFD) }, -1);
-        assert_eq!(io::Error::last_os_error().raw_os_error(), Some(libc::EBADF));
-        // SAFETY: tun-rs owns only the duplicate; host remains open.
+        // SAFETY: the adapter owns only the duplicate; host remains open.
         let after = unsafe { libc::fcntl(host.as_raw_fd(), libc::F_GETFL) };
         assert_eq!(after, before);
 
@@ -468,6 +675,10 @@ mod tests {
         let mut bytes = [0; 2];
         peer.read_exact(&mut bytes).unwrap();
         assert_eq!(&bytes, b"ok");
+        peer.set_nonblocking(true).unwrap();
+        drop(host);
+        // EOF checks release without racing reuse of the numeric duplicate fd.
+        assert_eq!(peer.read(&mut bytes).unwrap(), 0);
     }
 
     #[tokio::test]
@@ -475,7 +686,7 @@ mod tests {
         let (host, peer) = UnixDatagram::pair().unwrap();
         host.set_nonblocking(true).unwrap();
         let fd = TunFd::duplicate_mock(host.as_raw_fd()).unwrap();
-        let io = TunRsIo::new(fd, TunFraming::RawIp).unwrap();
+        let io = TunRsIo::new_mock(fd, TunFraming::RawIp).unwrap();
 
         peer.send(&[0x70]).unwrap();
         assert!(matches!(
@@ -495,7 +706,7 @@ mod tests {
         let (host, peer) = UnixStream::pair().unwrap();
         host.set_nonblocking(true).unwrap();
         let fd = TunFd::duplicate_mock(host.as_raw_fd()).unwrap();
-        let io = TunRsIo::new(fd, TunFraming::RawIp).unwrap();
+        let io = TunRsIo::new_mock(fd, TunFraming::RawIp).unwrap();
         drop(peer);
 
         let error = io.read_packet(&mut Vec::new()).await.unwrap_err();
@@ -511,7 +722,7 @@ mod tests {
         let (host, peer) = UnixDatagram::pair().unwrap();
         host.set_nonblocking(true).unwrap();
         peer.set_nonblocking(true).unwrap();
-        let io = TunRsIo::new(
+        let io = TunRsIo::new_mock(
             TunFd::duplicate_mock(host.as_raw_fd()).unwrap(),
             TunFraming::Utun,
         )
@@ -589,7 +800,7 @@ mod tests {
         let (host, peer) = UnixDatagram::pair().unwrap();
         host.set_nonblocking(true).unwrap();
         peer.set_nonblocking(true).unwrap();
-        let io = TunRsIo::new(
+        let io = TunRsIo::new_mock(
             TunFd::duplicate_mock(host.as_raw_fd()).unwrap(),
             TunFraming::Utun,
         )
@@ -644,7 +855,7 @@ mod tests {
     async fn utun_batches_keep_each_packet_information_header_independent() {
         let (host, peer) = UnixDatagram::pair().unwrap();
         host.set_nonblocking(true).unwrap();
-        let io = TunRsIo::new(
+        let io = TunRsIo::new_mock(
             TunFd::duplicate_mock(host.as_raw_fd()).unwrap(),
             TunFraming::Utun,
         )
@@ -675,7 +886,7 @@ mod tests {
         let (host, peer) = UnixDatagram::pair().unwrap();
         host.set_nonblocking(true).unwrap();
         let fd = TunFd::duplicate_mock(host.as_raw_fd()).unwrap();
-        let io = TunRsIo::new(fd, TunFraming::Utun).unwrap();
+        let io = TunRsIo::new_mock(fd, TunFraming::Utun).unwrap();
 
         for (packet, family, version) in [
             (&IPV4[..], 2_u32, IpVersion::V4),
@@ -695,7 +906,7 @@ mod tests {
         let (host, peer) = UnixDatagram::pair().unwrap();
         host.set_nonblocking(true).unwrap();
         let fd = TunFd::duplicate_mock(host.as_raw_fd()).unwrap();
-        let io = TunRsIo::new(fd, TunFraming::Utun).unwrap();
+        let io = TunRsIo::new_mock(fd, TunFraming::Utun).unwrap();
 
         let mut packet = Vec::new();
         for (expected, family, version) in [
diff --git a/src/process.rs b/src/process.rs
new file mode 100644
index 0000000..48a5560
--- /dev/null
+++ b/src/process.rs
@@ -0,0 +1,192 @@
+//! Bounded, exact socket-owner discovery. No cache, shell or privilege changes.
+use crate::{config::Network, session::InboundSnapshot};
+use std::{
+    io,
+    net::SocketAddr,
+    sync::Arc,
+    time::{Duration, Instant},
+};
+
+#[derive(Clone, Default, PartialEq, Eq)]
+pub(crate) struct Identity {
+    pub uid: Option<u32>,
+    pub name: Option<Arc<str>>,
+    pub path: Option<Arc<str>>,
+}
+impl std::fmt::Debug for Identity {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Identity")
+            .field("known_uid", &self.uid.is_some())
+            .field("known_process", &self.path.is_some())
+            .finish()
+    }
+}
+impl Identity {
+    fn from_path(path: String) -> Option<Self> {
+        if path.is_empty() || path.len() > MAX_PATH || path.contains('\0') {
+            return None;
+        }
+        let name = std::path::Path::new(&path).file_name()?.to_str()?;
+        Some(Self {
+            uid: None,
+            name: Some(Arc::from(name)),
+            path: Some(Arc::from(path)),
+        })
+    }
+}
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct Query {
+    pub network: Network,
+    pub source: SocketAddr,
+    pub destination: SocketAddr,
+}
+impl Query {
+    pub fn from_snapshot(network: Network, origin: &InboundSnapshot) -> Option<Self> {
+        let destination = origin.socket_destination?;
+        if origin.source.is_ipv4() != destination.is_ipv4()
+            || origin.source.ip().is_unspecified()
+            || destination.ip().is_unspecified()
+            || origin.source.port() == 0
+            || destination.port() == 0
+        {
+            return None;
+        }
+        Some(Self {
+            network,
+            source: origin.source,
+            destination,
+        })
+    }
+}
+const MAX_PATH: usize = 32 * 1024;
+#[cfg(any(
+    target_os = "linux",
+    target_os = "android",
+    all(windows, any(feature = "windows-uwp", feature = "windows-wintun"))
+))]
+const MAX_TABLE: usize = 1024 * 1024;
+const MAX_ENTRIES: usize = 16_384;
+pub(crate) const LOOKUP_TIME: Duration = Duration::from_millis(100);
+struct Budget<'a> {
+    check: &'a dyn Fn() -> io::Result<()>,
+    until: Instant,
+    entries: usize,
+}
+impl Budget<'_> {
+    fn check(&self) -> io::Result<()> {
+        (self.check)()?;
+        if Instant::now() >= self.until {
+            Err(io::Error::new(
+                io::ErrorKind::TimedOut,
+                "process lookup budget exhausted",
+            ))
+        } else {
+            Ok(())
+        }
+    }
+    fn visit(&mut self) -> io::Result<()> {
+        self.check()?;
+        self.entries = self
+            .entries
+            .checked_sub(1)
+            .ok_or_else(|| io::Error::other("process lookup scan exhausted"))?;
+        Ok(())
+    }
+}
+pub(crate) fn lookup(query: Query, check: &dyn Fn() -> io::Result<()>) -> io::Result<Identity> {
+    let mut budget = Budget {
+        check,
+        until: Instant::now() + LOOKUP_TIME,
+        entries: MAX_ENTRIES,
+    };
+    budget.check()?;
+    platform(query, &mut budget)
+}
+
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[path = "process/linux.rs"]
+mod linux;
+#[cfg(any(target_os = "linux", target_os = "android"))]
+use linux::platform;
+#[cfg(target_os = "macos")]
+#[path = "process/macos.rs"]
+mod macos;
+#[cfg(target_os = "macos")]
+use macos::platform;
+#[cfg(all(windows, any(feature = "windows-uwp", feature = "windows-wintun")))]
+#[path = "process/windows.rs"]
+mod windows;
+#[cfg(all(windows, any(feature = "windows-uwp", feature = "windows-wintun")))]
+use windows::platform;
+#[cfg(not(any(
+    target_os = "linux",
+    target_os = "android",
+    target_os = "macos",
+    all(windows, any(feature = "windows-uwp", feature = "windows-wintun"))
+)))]
+fn platform(_: Query, _: &mut Budget<'_>) -> io::Result<Identity> {
+    Ok(Identity::default())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn query_uses_preserved_ingress_tuple_not_sniff_or_proxy_target() {
+        let mut session = crate::session::StreamSession {
+            metadata: crate::session::InboundMetadata::new(443),
+            inbound: crate::session::InboundKind::Tun,
+            source: "198.18.0.2:1234".parse().unwrap(),
+            destination: crate::session::Destination::Ip("192.0.2.3:443".parse().unwrap()),
+            sniffed_domain: None,
+        };
+        session.capture_original();
+        let origin = session.metadata.original.clone().unwrap();
+        session.destination = crate::session::Destination::domain("sniff.example", 443).unwrap();
+        session.capture_original();
+        assert!(Arc::ptr_eq(
+            &origin,
+            session.metadata.original.as_ref().unwrap()
+        ));
+        assert_eq!(
+            Query::from_snapshot(Network::Tcp, &origin)
+                .unwrap()
+                .destination,
+            "192.0.2.3:443".parse::<SocketAddr>().unwrap()
+        );
+        session.metadata.original = None;
+        session.metadata.local_address = Some("127.0.0.1:1080".parse().unwrap());
+        session.inbound = crate::session::InboundKind::Https;
+        session.capture_original();
+        assert_eq!(
+            Query::from_snapshot(Network::Tcp, session.metadata.original.as_ref().unwrap())
+                .unwrap()
+                .destination
+                .port(),
+            1080
+        );
+        assert!(!format!("{origin:?}").contains("192.0.2"));
+    }
+    #[test]
+    fn inspection_budget_is_bounded_and_cancelled_before_platform_access() {
+        let query = Query {
+            network: Network::Tcp,
+            source: "127.0.0.1:1".parse().unwrap(),
+            destination: "127.0.0.1:2".parse().unwrap(),
+        };
+        assert!(
+            lookup(query, &|| Err(io::Error::new(
+                io::ErrorKind::Interrupted,
+                "cancelled"
+            )))
+            .is_err()
+        );
+        let mut budget = Budget {
+            check: &|| Ok(()),
+            until: Instant::now() + LOOKUP_TIME,
+            entries: 1,
+        };
+        budget.visit().unwrap();
+        assert!(budget.visit().is_err());
+    }
+}
diff --git a/src/process/linux.rs b/src/process/linux.rs
new file mode 100644
index 0000000..48cbf2d
--- /dev/null
+++ b/src/process/linux.rs
@@ -0,0 +1,216 @@
+//! Linux procfs socket tables: exact local AND remote tuple, then inode ownership.
+use super::*;
+use std::{
+    fs,
+    io::Read,
+    net::{IpAddr, Ipv4Addr, Ipv6Addr},
+    os::unix::fs::MetadataExt,
+};
+
+fn bounded(path: &std::path::Path, limit: usize) -> io::Result<String> {
+    let mut value = String::new();
+    fs::File::open(path)?
+        .take(limit as u64 + 1)
+        .read_to_string(&mut value)?;
+    if value.len() > limit {
+        return Err(io::Error::other("process table exceeds budget"));
+    }
+    Ok(value)
+}
+fn address(value: &str) -> Option<SocketAddr> {
+    let (host, port) = value.split_once(':')?;
+    let port = u16::from_str_radix(port, 16).ok()?;
+    let host = match host.len() {
+        8 => IpAddr::V4(Ipv4Addr::from(
+            u32::from_str_radix(host, 16).ok()?.to_ne_bytes(),
+        )),
+        32 => {
+            let mut bytes = [0; 16];
+            for (word, out) in host
+                .as_bytes()
+                .as_chunks::<8>()
+                .0
+                .iter()
+                .zip(bytes.as_chunks_mut::<4>().0.iter_mut())
+            {
+                out.copy_from_slice(
+                    &u32::from_str_radix(std::str::from_utf8(word).ok()?, 16)
+                        .ok()?
+                        .to_ne_bytes(),
+                );
+            }
+            IpAddr::V6(Ipv6Addr::from(bytes))
+        }
+        _ => return None,
+    };
+    Some(SocketAddr::new(host, port))
+}
+fn socket_row(text: &str, query: Query, budget: &mut Budget<'_>) -> io::Result<Option<(u32, u64)>> {
+    let mut found = None;
+    for row in text.lines().skip(1) {
+        budget.visit()?;
+        let mut fields = row.split_ascii_whitespace();
+        let Some(local) = fields.nth(1) else {
+            continue;
+        };
+        let Some(remote) = fields.next() else {
+            continue;
+        };
+        if address(local) != Some(query.source) || address(remote) != Some(query.destination) {
+            continue;
+        }
+        // State, queues, timer, retransmits precede the kernel UID.
+        let Some(uid) = fields.nth(4).and_then(|value| value.parse::<u32>().ok()) else {
+            continue;
+        };
+        let Some(inode) = fields
+            .nth(1)
+            .and_then(|value| value.parse::<u64>().ok())
+            .filter(|value| *value != 0)
+        else {
+            continue;
+        };
+        if found.is_some() {
+            return Ok(None);
+        }
+        found = Some((uid, inode));
+    }
+    Ok(found)
+}
+fn start_time(path: &std::path::Path) -> Option<u64> {
+    let stat = bounded(&path.join("stat"), 4096).ok()?;
+    stat.rsplit_once(')')?
+        .1
+        .split_ascii_whitespace()
+        .nth(19)?
+        .parse()
+        .ok()
+}
+pub(super) fn platform(query: Query, budget: &mut Budget<'_>) -> io::Result<Identity> {
+    let table = match (query.network, query.source.is_ipv6()) {
+        (Network::Tcp, false) => "tcp",
+        (Network::Tcp, true) => "tcp6",
+        (Network::Udp, false) => "udp",
+        (Network::Udp, true) => "udp6",
+    };
+    let text = match bounded(&std::path::Path::new("/proc/net").join(table), MAX_TABLE) {
+        Ok(value) => value,
+        Err(_) => return Ok(Identity::default()),
+    };
+    let Some((uid, inode)) = socket_row(&text, query, budget)? else {
+        return Ok(Identity::default());
+    };
+    drop(text);
+    let mut identity = Identity {
+        uid: Some(uid),
+        ..Default::default()
+    };
+    let expected = format!("socket:[{inode}]");
+    let mut owner = None;
+    for entry in fs::read_dir("/proc")? {
+        budget.visit()?;
+        let Ok(entry) = entry else {
+            continue;
+        };
+        if entry
+            .file_name()
+            .to_str()
+            .and_then(|value| value.parse::<u32>().ok())
+            .is_none()
+        {
+            continue;
+        }
+        let path = entry.path();
+        if fs::metadata(&path)
+            .ok()
+            .is_none_or(|metadata| metadata.uid() != uid)
+        {
+            continue;
+        }
+        let Some(start) = start_time(&path) else {
+            continue;
+        };
+        let Ok(fds) = fs::read_dir(path.join("fd")) else {
+            continue;
+        };
+        for fd in fds {
+            budget.visit()?;
+            let Ok(fd) = fd else {
+                continue;
+            };
+            if fs::read_link(fd.path()).ok().as_deref() != Some(std::path::Path::new(&expected)) {
+                continue;
+            }
+            let Ok(exe) = fs::read_link(path.join("exe")) else {
+                continue;
+            };
+            budget.check()?;
+            if start_time(&path) != Some(start)
+                || fs::read_link(fd.path()).ok().as_deref() != Some(std::path::Path::new(&expected))
+            {
+                continue;
+            }
+            let Some(value) = exe
+                .to_str()
+                .and_then(|value| Identity::from_path(value.to_owned()))
+            else {
+                continue;
+            };
+            if owner.as_ref().is_some_and(|old| old != &path) {
+                return Ok(Identity {
+                    uid: Some(uid),
+                    ..Default::default()
+                });
+            }
+            owner = Some(path.clone());
+            identity.name = value.name;
+            identity.path = value.path;
+            break;
+        }
+    }
+    // Revalidate the kernel tuple/inode after walking mutable /proc entries.
+    let current = bounded(&std::path::Path::new("/proc/net").join(table), MAX_TABLE).ok();
+    if current
+        .as_deref()
+        .map(|text| socket_row(text, query, budget))
+        .transpose()?
+        .flatten()
+        != Some((uid, inode))
+    {
+        return Ok(Identity::default());
+    }
+    Ok(identity)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn proc_socket_oracle_requires_full_tuple_and_unique_inode() {
+        let query = Query {
+            network: Network::Tcp,
+            source: "127.0.0.1:1234".parse().unwrap(),
+            destination: "192.0.2.3:443".parse().unwrap(),
+        };
+        let row = "0: 0100007F:04D2 030200C0:01BB 01 0:0 0:0 0 1001 0 987 0";
+        let check = || Ok(());
+        let mut budget = Budget {
+            check: &check,
+            until: Instant::now() + LOOKUP_TIME,
+            entries: MAX_ENTRIES,
+        };
+        assert_eq!(
+            socket_row(&format!("header\n{row}\n"), query, &mut budget).unwrap(),
+            Some((1001, 987))
+        );
+        let wrong = row.replace("0100007F", "0200007F");
+        assert_eq!(
+            socket_row(&format!("header\n{wrong}\n"), query, &mut budget).unwrap(),
+            None
+        );
+        assert_eq!(
+            socket_row(&format!("header\n{row}\n{row}\n"), query, &mut budget).unwrap(),
+            None
+        );
+    }
+}
diff --git a/src/process/macos.rs b/src/process/macos.rs
new file mode 100644
index 0000000..6e013aa
--- /dev/null
+++ b/src/process/macos.rs
@@ -0,0 +1,235 @@
+//! Public libproc socket-fd API, using the SDK sys/proc_info.h ABI.
+//! No private version-dependent pcblist offsets or elevated privileges.
+use super::*;
+use std::{
+    mem::{size_of, zeroed},
+    net::{IpAddr, Ipv4Addr, Ipv6Addr},
+};
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+struct FileInfo {
+    flags: u32,
+    status: u32,
+    offset: i64,
+    kind: i32,
+    guard: u32,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+struct SockBuf {
+    bytes: u32,
+    high: u32,
+    count: u32,
+    maximum: u32,
+    low: u32,
+    flags: i16,
+    timeout: i16,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+struct Inet6 {
+    hop: u8,
+    checksum: i32,
+    index: u16,
+    hops: i16,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+struct InetInfo {
+    foreign_port: i32,
+    local_port: i32,
+    generation: u64,
+    flags: u32,
+    flow: u32,
+    version: u8,
+    ttl: u8,
+    reserved: u32,
+    foreign: [u8; 16],
+    local: [u8; 16],
+    tos: u8,
+    ipv6: Inet6,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+union Protocol {
+    inet: InetInfo,
+    opaque: [u64; 66],
+}
+#[repr(C)]
+struct SocketInfo {
+    stat: libc::vinfo_stat,
+    socket: u64,
+    pcb: u64,
+    kind: i32,
+    protocol: i32,
+    family: i32,
+    options: [i16; 8],
+    oob: u32,
+    receive: SockBuf,
+    send: SockBuf,
+    info_kind: i32,
+    reserved: u32,
+    info: Protocol,
+}
+#[repr(C)]
+struct SocketFd {
+    file: FileInfo,
+    socket: SocketInfo,
+}
+
+fn socket(pid: i32, fd: i32) -> Option<SocketFd> {
+    let mut value: SocketFd = unsafe { zeroed() };
+    let bytes = unsafe {
+        libc::proc_pidfdinfo(
+            pid,
+            fd,
+            3,
+            (&mut value as *mut SocketFd).cast(),
+            size_of::<SocketFd>() as i32,
+        )
+    };
+    (bytes as usize == size_of::<SocketFd>()).then_some(value)
+}
+fn matches(value: &SocketFd, query: Query) -> bool {
+    let protocol = match query.network {
+        Network::Tcp => libc::IPPROTO_TCP,
+        Network::Udp => libc::IPPROTO_UDP,
+    };
+    if value.socket.protocol != protocol
+        || value.socket.family
+            != if query.source.is_ipv4() {
+                libc::AF_INET
+            } else {
+                libc::AF_INET6
+            }
+        || !matches!(value.socket.info_kind, 1 | 2)
+    {
+        return false;
+    }
+    let inet = unsafe { value.socket.info.inet };
+    let ip = |bytes: [u8; 16]| {
+        if query.source.is_ipv4() {
+            IpAddr::V4(Ipv4Addr::new(bytes[12], bytes[13], bytes[14], bytes[15]))
+        } else {
+            IpAddr::V6(Ipv6Addr::from(bytes))
+        }
+    };
+    query.source == SocketAddr::new(ip(inet.local), u16::from_be(inet.local_port as u16))
+        && query.destination
+            == SocketAddr::new(ip(inet.foreign), u16::from_be(inet.foreign_port as u16))
+}
+pub(super) fn platform(query: Query, budget: &mut Budget<'_>) -> io::Result<Identity> {
+    let mut pids = vec![0i32; MAX_ENTRIES];
+    let bytes = unsafe {
+        libc::proc_listpids(
+            1, // PROC_ALL_PIDS, public sys/proc_info.h
+            0,
+            pids.as_mut_ptr().cast(),
+            (pids.len() * size_of::<i32>()) as i32,
+        )
+    };
+    if bytes <= 0 || bytes as usize >= pids.len() * size_of::<i32>() {
+        return Ok(Default::default());
+    }
+    let mut identity = None;
+    let mut owner = None;
+    for pid in pids
+        .into_iter()
+        .take(bytes as usize / size_of::<i32>())
+        .filter(|pid| *pid > 0)
+    {
+        budget.visit()?;
+        let mut fds = vec![unsafe { zeroed::<libc::proc_fdinfo>() }; 1024];
+        let bytes = unsafe {
+            libc::proc_pidinfo(
+                pid,
+                libc::PROC_PIDLISTFDS,
+                0,
+                fds.as_mut_ptr().cast(),
+                (fds.len() * size_of::<libc::proc_fdinfo>()) as i32,
+            )
+        };
+        if bytes <= 0 || bytes as usize >= fds.len() * size_of::<libc::proc_fdinfo>() {
+            continue;
+        }
+        for fd in fds
+            .into_iter()
+            .take(bytes as usize / size_of::<libc::proc_fdinfo>())
+            .filter(|fd| fd.proc_fdtype == 2)
+        {
+            budget.visit()?;
+            let Some(before) = socket(pid, fd.proc_fd) else {
+                continue;
+            };
+            if !matches(&before, query) {
+                continue;
+            }
+            let mut path = vec![0u8; libc::PROC_PIDPATHINFO_MAXSIZE as usize];
+            let bytes =
+                unsafe { libc::proc_pidpath(pid, path.as_mut_ptr().cast(), path.len() as u32) };
+            if bytes <= 0 || bytes as usize >= path.len() {
+                continue;
+            }
+            budget.check()?;
+            let Some(after) = socket(pid, fd.proc_fd) else {
+                continue;
+            };
+            if !matches(&after, query)
+                || before.socket.socket != after.socket.socket
+                || before.socket.pcb != after.socket.pcb
+                || unsafe { before.socket.info.inet.generation }
+                    != unsafe { after.socket.info.inet.generation }
+            {
+                continue;
+            }
+            path.truncate(bytes as usize);
+            if path.last() == Some(&0) {
+                path.pop();
+            }
+            let Some(found) = String::from_utf8(path).ok().and_then(Identity::from_path) else {
+                continue;
+            };
+            if owner.is_some_and(|owner| owner != pid) {
+                return Ok(Default::default());
+            }
+            owner = Some(pid);
+            identity = Some(found);
+        }
+    }
+    Ok(identity.unwrap_or_default())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn public_libproc_layout_and_exact_tuple_are_checked() {
+        // macOS public 64-bit SDK ABI, not private kernel PCB layout.
+        assert_eq!(size_of::<InetInfo>(), 80);
+        assert_eq!(size_of::<SocketFd>(), 792);
+        let mut value: SocketFd = unsafe { zeroed() };
+        value.socket.protocol = libc::IPPROTO_TCP;
+        value.socket.family = libc::AF_INET;
+        value.socket.info_kind = 2;
+        let mut inet: InetInfo = unsafe { zeroed() };
+        inet.local[12..].copy_from_slice(&[127, 0, 0, 1]);
+        inet.foreign[12..].copy_from_slice(&[192, 0, 2, 3]);
+        inet.local_port = u16::to_be(1234) as i32;
+        inet.foreign_port = u16::to_be(443) as i32;
+        value.socket.info.inet = inet;
+        let query = Query {
+            network: Network::Tcp,
+            source: "127.0.0.1:1234".parse().unwrap(),
+            destination: "192.0.2.3:443".parse().unwrap(),
+        };
+        assert!(matches(&value, query));
+        assert!(!matches(
+            &value,
+            Query {
+                destination: "192.0.2.4:443".parse().unwrap(),
+                ..query
+            }
+        ));
+    }
+}
diff --git a/src/process/windows.rs b/src/process/windows.rs
new file mode 100644
index 0000000..bf26105
--- /dev/null
+++ b/src/process/windows.rs
@@ -0,0 +1,188 @@
+//! Windows owner-PID tables and ordinary limited-information process handles.
+use super::*;
+use ::windows::{
+    Win32::{
+        Foundation::{CloseHandle, HANDLE},
+        NetworkManagement::IpHelper::*,
+        System::Threading::{
+            OpenProcess, PROCESS_NAME_WIN32, PROCESS_QUERY_LIMITED_INFORMATION,
+            QueryFullProcessImageNameW,
+        },
+    },
+    core::PWSTR,
+};
+use std::{
+    mem::size_of,
+    net::{IpAddr, Ipv4Addr, Ipv6Addr},
+};
+
+struct Process(HANDLE);
+impl Drop for Process {
+    fn drop(&mut self) {
+        let _ = unsafe { CloseHandle(self.0) };
+    }
+}
+fn table(query: Query, budget: &Budget<'_>) -> io::Result<Vec<u8>> {
+    let mut size = 0u32;
+    let call = |buffer: Option<*mut std::ffi::c_void>, size: &mut u32| unsafe {
+        let family = if query.source.is_ipv4() { 2 } else { 23 };
+        match query.network {
+            Network::Tcp => {
+                GetExtendedTcpTable(buffer, size, false, family, TCP_TABLE_OWNER_PID_ALL, 0)
+            }
+            Network::Udp => {
+                GetExtendedUdpTable(buffer, size, false, family, UDP_TABLE_OWNER_PID, 0)
+            }
+        }
+    };
+    call(None, &mut size);
+    for _ in 0..2 {
+        budget.check()?;
+        if !(4..=MAX_TABLE as u32).contains(&size) {
+            return Err(io::Error::other("process table exceeds budget"));
+        }
+        let mut bytes = vec![0u8; size as usize];
+        let status = call(Some(bytes.as_mut_ptr().cast()), &mut size);
+        if status == 0 && size as usize <= bytes.len() {
+            bytes.truncate(size as usize);
+            return Ok(bytes);
+        }
+        if status != 122 {
+            break;
+        } // ERROR_INSUFFICIENT_BUFFER, one bounded retry.
+    }
+    Err(io::Error::other("process owner table unavailable"))
+}
+fn ip4(value: u32) -> IpAddr {
+    IpAddr::V4(Ipv4Addr::from(value.to_ne_bytes()))
+}
+fn port(value: u32) -> u16 {
+    u16::from_be(value as u16)
+}
+fn owner(query: Query, budget: &mut Budget<'_>) -> io::Result<Option<u32>> {
+    let bytes = table(query, budget)?;
+    let count = u32::from_ne_bytes(
+        bytes
+            .get(..4)
+            .and_then(|bytes| bytes.try_into().ok())
+            .ok_or_else(|| io::Error::other("invalid owner table"))?,
+    ) as usize;
+    let width = match (query.network, query.source.is_ipv6()) {
+        (Network::Tcp, false) => size_of::<MIB_TCPROW_OWNER_PID>(),
+        (Network::Tcp, true) => size_of::<MIB_TCP6ROW_OWNER_PID>(),
+        (Network::Udp, false) => size_of::<MIB_UDPROW_OWNER_PID>(),
+        (Network::Udp, true) => size_of::<MIB_UDP6ROW_OWNER_PID>(),
+    };
+    if count > MAX_ENTRIES
+        || count
+            .checked_mul(width)
+            .and_then(|size| size.checked_add(4))
+            .is_none_or(|size| size > bytes.len())
+    {
+        return Ok(None);
+    }
+    let mut found = None;
+    for row in bytes[4..].chunks_exact(width).take(count) {
+        budget.visit()?;
+        // SDK row types contain only integers and byte arrays; unaligned reads
+        // do not borrow the byte allocation at the C structure's alignment.
+        let (local, remote, pid) = unsafe {
+            match (query.network, query.source.is_ipv6()) {
+                (Network::Tcp, false) => {
+                    let row = row.as_ptr().cast::<MIB_TCPROW_OWNER_PID>().read_unaligned();
+                    (
+                        SocketAddr::new(ip4(row.dwLocalAddr), port(row.dwLocalPort)),
+                        Some(SocketAddr::new(
+                            ip4(row.dwRemoteAddr),
+                            port(row.dwRemotePort),
+                        )),
+                        row.dwOwningPid,
+                    )
+                }
+                (Network::Tcp, true) => {
+                    let row = row
+                        .as_ptr()
+                        .cast::<MIB_TCP6ROW_OWNER_PID>()
+                        .read_unaligned();
+                    (
+                        SocketAddr::new(
+                            IpAddr::V6(Ipv6Addr::from(row.ucLocalAddr)),
+                            port(row.dwLocalPort),
+                        ),
+                        Some(SocketAddr::new(
+                            IpAddr::V6(Ipv6Addr::from(row.ucRemoteAddr)),
+                            port(row.dwRemotePort),
+                        )),
+                        row.dwOwningPid,
+                    )
+                }
+                (Network::Udp, false) => {
+                    let row = row.as_ptr().cast::<MIB_UDPROW_OWNER_PID>().read_unaligned();
+                    (
+                        SocketAddr::new(ip4(row.dwLocalAddr), port(row.dwLocalPort)),
+                        None,
+                        row.dwOwningPid,
+                    )
+                }
+                (Network::Udp, true) => {
+                    let row = row
+                        .as_ptr()
+                        .cast::<MIB_UDP6ROW_OWNER_PID>()
+                        .read_unaligned();
+                    (
+                        SocketAddr::new(
+                            IpAddr::V6(Ipv6Addr::from(row.ucLocalAddr)),
+                            port(row.dwLocalPort),
+                        ),
+                        None,
+                        row.dwOwningPid,
+                    )
+                }
+            }
+        };
+        // A wildcard/port-only row does not prove that a LAN source is local.
+        if local != query.source
+            || remote.is_some_and(|remote| remote != query.destination)
+            || pid == 0
+        {
+            continue;
+        }
+        if found.is_some() {
+            return Ok(None);
+        }
+        found = Some(pid);
+    }
+    Ok(found)
+}
+pub(super) fn platform(query: Query, budget: &mut Budget<'_>) -> io::Result<Identity> {
+    let Some(pid) = owner(query, budget)? else {
+        return Ok(Default::default());
+    };
+    let Ok(handle) = (unsafe { OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, false, pid) }) else {
+        return Ok(Default::default());
+    };
+    let handle = Process(handle);
+    let mut path = vec![0u16; MAX_PATH / 2];
+    let mut size = path.len() as u32;
+    if unsafe {
+        QueryFullProcessImageNameW(
+            handle.0,
+            PROCESS_NAME_WIN32,
+            PWSTR(path.as_mut_ptr()),
+            &mut size,
+        )
+    }
+    .is_err()
+        || size as usize >= path.len()
+    {
+        return Ok(Default::default());
+    }
+    budget.check()?;
+    if owner(query, budget)? != Some(pid) {
+        return Ok(Default::default());
+    }
+    Ok(String::from_utf16(&path[..size as usize])
+        .ok()
+        .and_then(Identity::from_path)
+        .unwrap_or_default())
+}
diff --git a/src/quic_sniffer.rs b/src/quic_sniffer.rs
index cc06b7b..6bb4bb0 100644
--- a/src/quic_sniffer.rs
+++ b/src/quic_sniffer.rs
@@ -1,4 +1,4 @@
-//! Bounded QUIC Initial sniffing for the TUN UDP inbound.
+//! Bounded QUIC Initial sniffing shared by TUN and authorized SOCKS5 UDP.
 //!
 //! Only public QUIC Initial keys are used. Decryption is advisory and operates
 //! on scratch buffers; the intercepted datagram remains owned by the caller for
diff --git a/src/resource/age_provider.rs b/src/resource/age_provider.rs
new file mode 100644
index 0000000..1127a67
--- /dev/null
+++ b/src/resource/age_provider.rs
@@ -0,0 +1,395 @@
+//! Native subscription decryption; standard AGE authentication/STREAM belongs to age.
+use crate::{Result, VoleError};
+use age_core::format::{FileKey, Stanza};
+use base64::{Engine as _, engine::general_purpose::STANDARD_NO_PAD};
+use hpke::{Deserializable, aead::ChaCha20Poly1305, kdf::HkdfSha256, kem::XWing};
+use serde_yaml_ng::Value;
+use sha2::{Digest, Sha256};
+use std::{
+    cell::Cell,
+    fmt,
+    io::{self, Read},
+    sync::Arc,
+    time::Instant,
+};
+use tokio_util::sync::CancellationToken;
+use zeroize::Zeroizing;
+
+pub(crate) const ARMOR_HEADER: &[u8] = b"-----BEGIN AGE ENCRYPTED FILE-----";
+const SECRET_BYTES: usize = 16 * 1024;
+const IDENTITIES: usize = 128;
+const HEADER_BYTES: usize = 64 * 1024;
+const UNWRAP_ATTEMPTS: usize = 1024;
+const HYBRID_TAG: &str = "mlkem768x25519";
+const HYBRID_INFO: &[u8] = b"age-encryption.org/mlkem768x25519";
+
+fn invalid(message: &'static str) -> VoleError {
+    VoleError::InvalidConfig(message.into())
+}
+
+/// Immutable parsed identities, shared by template/spec clones. No source key text is kept.
+#[derive(Clone)]
+pub(crate) struct Identities {
+    entries: Arc<[Identity]>,
+    fingerprint: [u8; 32],
+}
+enum Identity {
+    X25519(age::x25519::Identity),
+    Hybrid(Box<<XWing as hpke::Kem>::PrivateKey>),
+}
+impl fmt::Debug for Identities {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("AgeIdentities { .. }")
+    }
+}
+impl PartialEq for Identities {
+    fn eq(&self, other: &Self) -> bool {
+        self.fingerprint == other.fingerprint
+    }
+}
+impl Eq for Identities {}
+impl Identities {
+    pub(crate) fn from_value(value: Value) -> Result<Option<Self>> {
+        let secret = match value {
+            Value::Null => return Ok(None),
+            Value::String(secret) => Zeroizing::new(secret),
+            _ => return Err(invalid("age-secret-key requires a string")),
+        };
+        Self::parse(&secret).map(Some)
+    }
+    pub(crate) fn parse(secret: &str) -> Result<Self> {
+        if secret.len() > SECRET_BYTES {
+            return Err(invalid("AGE identity budget exceeded"));
+        }
+        let mut entries = Vec::new();
+        for line in secret.lines() {
+            if line.is_empty() || line.starts_with('#') {
+                continue;
+            }
+            if entries.len() >= IDENTITIES {
+                return Err(invalid("AGE identity budget exceeded"));
+            }
+            if line.starts_with("AGE-SECRET-KEY-PQ-1") {
+                let parsed =
+                    bech32::primitives::decode::CheckedHrpstring::new::<bech32::Bech32>(line)
+                        .map_err(|_| invalid("invalid AGE provider identity"))?;
+                if !parsed
+                    .hrp()
+                    .to_string()
+                    .eq_ignore_ascii_case("AGE-SECRET-KEY-PQ-")
+                {
+                    return Err(invalid("invalid AGE provider identity"));
+                }
+                let seed = Zeroizing::new(parsed.byte_iter().collect::<Vec<u8>>());
+                let key = <XWing as hpke::Kem>::PrivateKey::from_bytes(&seed)
+                    .map_err(|_| invalid("invalid AGE provider identity"))?;
+                entries.push(Identity::Hybrid(Box::new(key)));
+            } else {
+                let key = line
+                    .parse::<age::x25519::Identity>()
+                    .map_err(|_| invalid("invalid AGE provider identity"))?;
+                entries.push(Identity::X25519(key));
+            }
+        }
+        Ok(Self {
+            entries: entries.into(),
+            fingerprint: Sha256::digest(secret.as_bytes()).into(),
+        })
+    }
+}
+
+/// Processing scope is shared by header reads, all identities and plaintext reads.
+pub(crate) struct DecodeControl<'a> {
+    cancellation: Option<&'a CancellationToken>,
+    deadline: Instant,
+    header: Cell<bool>,
+    attempts: Cell<usize>,
+}
+impl<'a> DecodeControl<'a> {
+    pub(crate) fn new(cancellation: Option<&'a CancellationToken>, deadline: Instant) -> Self {
+        Self {
+            cancellation,
+            deadline,
+            header: Cell::new(true),
+            attempts: Cell::new(0),
+        }
+    }
+    pub(crate) fn check(&self) -> Result<()> {
+        if self
+            .cancellation
+            .is_some_and(CancellationToken::is_cancelled)
+        {
+            return Err(invalid("provider decoding cancelled"));
+        }
+        if Instant::now() >= self.deadline {
+            return Err(invalid("provider decoding deadline exceeded"));
+        }
+        Ok(())
+    }
+    fn unwrap(&self) -> std::result::Result<(), age::DecryptError> {
+        if self.check().is_err() || self.attempts.get() >= UNWRAP_ATTEMPTS {
+            return Err(age::DecryptError::DecryptionFailed);
+        }
+        self.attempts.set(self.attempts.get() + 1);
+        Ok(())
+    }
+}
+struct CheckedIdentity<'a> {
+    identity: &'a Identity,
+    control: &'a DecodeControl<'a>,
+}
+impl age::Identity for CheckedIdentity<'_> {
+    fn unwrap_stanza(
+        &self,
+        stanza: &Stanza,
+    ) -> Option<std::result::Result<FileKey, age::DecryptError>> {
+        // Unknown AGE extension stanzas remain skippable without private-key operations.
+        let expected = match self.identity {
+            Identity::X25519(_) => "X25519",
+            Identity::Hybrid(_) => HYBRID_TAG,
+        };
+        if stanza.tag != expected {
+            return None;
+        }
+        if let Err(error) = self.control.unwrap() {
+            return Some(Err(error));
+        }
+        match self.identity {
+            Identity::X25519(identity) => identity.unwrap_stanza(stanza),
+            Identity::Hybrid(secret) => {
+                if stanza.args.len() != 1 || stanza.body.len() != 32 || stanza.args[0].len() != 1494
+                {
+                    return Some(Err(age::DecryptError::InvalidHeader));
+                }
+                let encapsulated = match STANDARD_NO_PAD.decode(&stanza.args[0]) {
+                    Ok(bytes) if bytes.len() == 1120 => bytes,
+                    _ => return Some(Err(age::DecryptError::InvalidHeader)),
+                };
+                let encapped = match <XWing as hpke::Kem>::EncappedKey::from_bytes(&encapsulated) {
+                    Ok(value) => value,
+                    Err(_) => return Some(Err(age::DecryptError::InvalidHeader)),
+                };
+                let mut receiver = match hpke::setup_receiver::<ChaCha20Poly1305, HkdfSha256, XWing>(
+                    &hpke::OpModeR::Base,
+                    secret,
+                    &encapped,
+                    HYBRID_INFO,
+                ) {
+                    Ok(receiver) => receiver,
+                    Err(_) => return None,
+                };
+                let file_key = match receiver.open(&stanza.body, b"") {
+                    Ok(value) => Zeroizing::new(value),
+                    Err(_) => return None,
+                };
+                if file_key.len() != 16 {
+                    return Some(Err(age::DecryptError::InvalidHeader));
+                }
+                Some(Ok(FileKey::init_with_mut(|key| {
+                    key.copy_from_slice(&file_key)
+                })))
+            }
+        }
+    }
+}
+struct CheckedReader<'a, R> {
+    inner: R,
+    control: &'a DecodeControl<'a>,
+    header_read: usize,
+}
+impl<R: Read> Read for CheckedReader<'_, R> {
+    fn read(&mut self, output: &mut [u8]) -> io::Result<usize> {
+        self.control
+            .check()
+            .map_err(|_| io::Error::other("provider decoding stopped"))?;
+        let limit = if self.control.header.get() {
+            HEADER_BYTES
+                .saturating_sub(self.header_read)
+                .saturating_add(1)
+                .min(output.len())
+        } else {
+            output.len()
+        };
+        let count = self.inner.read(&mut output[..limit])?;
+        if self.control.header.get() {
+            self.header_read = self.header_read.saturating_add(count);
+            if self.header_read > HEADER_BYTES {
+                return Err(io::Error::other("AGE header budget exceeded"));
+            }
+        }
+        Ok(count)
+    }
+}
+pub(crate) enum Decoded<'a> {
+    Plain(&'a [u8]),
+    Decrypted(Zeroizing<Vec<u8>>),
+}
+impl AsRef<[u8]> for Decoded<'_> {
+    fn as_ref(&self) -> &[u8] {
+        match self {
+            Self::Plain(bytes) => bytes,
+            Self::Decrypted(bytes) => bytes,
+        }
+    }
+}
+
+pub(crate) fn decode<'a>(
+    bytes: &'a [u8],
+    identities: Option<&Identities>,
+    control: &DecodeControl<'_>,
+    output_limit: usize,
+) -> Result<Decoded<'a>> {
+    control.check()?;
+    // Exactly the reference armor prefix, with no BOM/whitespace/binary sniffing.
+    if !bytes.starts_with(ARMOR_HEADER) {
+        return Ok(Decoded::Plain(bytes));
+    }
+    let identities =
+        identities.ok_or_else(|| invalid("AGE provider requires a matching identity"))?;
+    control.header.set(true);
+    let input = CheckedReader {
+        inner: age::armor::ArmoredReader::new(bytes),
+        control,
+        header_read: 0,
+    };
+    let decryptor =
+        age::Decryptor::new(input).map_err(|_| invalid("invalid AGE provider content"))?;
+    control.header.set(false);
+    let checked: Vec<_> = identities
+        .entries
+        .iter()
+        .map(|identity| CheckedIdentity { identity, control })
+        .collect();
+    let mut plaintext = decryptor
+        .decrypt(
+            checked
+                .iter()
+                .map(|identity| identity as &dyn age::Identity),
+        )
+        .map_err(|_| invalid("AGE provider decryption failed"))?;
+    control.check()?;
+    let mut output = Zeroizing::new(Vec::new());
+    let mut buffer = Zeroizing::new([0_u8; 16 * 1024]);
+    loop {
+        control.check()?;
+        let available = output_limit
+            .saturating_sub(output.len())
+            .saturating_add(1)
+            .min(buffer.len());
+        let count = plaintext
+            .read(&mut buffer[..available])
+            .map_err(|_| invalid("AGE provider decryption failed"))?;
+        if count == 0 {
+            break;
+        }
+        if output
+            .len()
+            .checked_add(count)
+            .is_none_or(|length| length > output_limit)
+        {
+            return Err(invalid("decrypted provider exceeds YAML byte limit"));
+        }
+        let required = output.len() + count;
+        if required > output.capacity() {
+            // Grow geometrically without exceeding the plaintext byte budget.
+            let capacity = output
+                .capacity()
+                .saturating_mul(2)
+                .max(required)
+                .min(output_limit);
+            let additional = capacity - output.len();
+            output
+                .try_reserve_exact(additional)
+                .map_err(|_| invalid("AGE provider output allocation failed"))?;
+        }
+        output.extend_from_slice(&buffer[..count]);
+    }
+    control.check()?;
+    Ok(Decoded::Decrypted(output))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::{io::Write, time::Duration};
+
+    const X_KEY: &str = include_str!("../../tests/fixtures/provider-age/x25519.key");
+    const PQ_KEY: &str = include_str!("../../tests/fixtures/provider-age/hybrid.key");
+    const X_CONTENT: &[u8] = include_bytes!("../../tests/fixtures/provider-age/x25519.age");
+    const PQ_CONTENT: &[u8] = include_bytes!("../../tests/fixtures/provider-age/hybrid.age");
+    const PLAIN: &[u8] = include_bytes!("../../tests/fixtures/provider-age/provider.yaml");
+
+    fn control() -> DecodeControl<'static> {
+        DecodeControl::new(None, Instant::now() + Duration::from_secs(30))
+    }
+
+    #[test]
+    fn age_official_fixtures_multiline_and_plaintext() {
+        let identities = Identities::parse(&format!(
+            "# public fixture identities\n\n{}\n{}\n",
+            X_KEY.trim_end(),
+            PQ_KEY.trim_end()
+        ))
+        .unwrap();
+        for bytes in [X_CONTENT, PQ_CONTENT, PLAIN] {
+            let decoded = decode(bytes, Some(&identities), &control(), PLAIN.len()).unwrap();
+            assert_eq!(decoded.as_ref(), PLAIN);
+        }
+        assert!(matches!(
+            decode(PLAIN, None, &control(), 0).unwrap(),
+            Decoded::Plain(_)
+        ));
+        let prefixed = [b" ".as_slice(), X_CONTENT].concat();
+        assert!(matches!(
+            decode(&prefixed, None, &control(), 0).unwrap(),
+            Decoded::Plain(_)
+        ));
+        assert!(!format!("{identities:?}").contains(X_KEY.trim_end()));
+    }
+
+    #[test]
+    fn age_authentication_and_processing_budget_fail_closed() {
+        let identities = Identities::parse(X_KEY.trim_end()).unwrap();
+        assert!(decode(PQ_CONTENT, Some(&identities), &control(), PLAIN.len()).is_err());
+        assert!(decode(X_CONTENT, Some(&identities), &control(), PLAIN.len() - 1).is_err());
+        let mut binary = Vec::new();
+        age::armor::ArmoredReader::new(X_CONTENT)
+            .read_to_end(&mut binary)
+            .unwrap();
+        *binary.last_mut().unwrap() ^= 1;
+        let mut damaged = Vec::new();
+        let mut armor =
+            age::armor::ArmoredWriter::wrap_output(&mut damaged, age::armor::Format::AsciiArmor)
+                .unwrap();
+        armor.write_all(&binary).unwrap();
+        armor.finish().unwrap();
+        assert!(decode(&damaged, Some(&identities), &control(), PLAIN.len()).is_err());
+        let cancellation = CancellationToken::new();
+        cancellation.cancel();
+        assert!(
+            decode(
+                X_CONTENT,
+                Some(&identities),
+                &DecodeControl::new(
+                    Some(&cancellation),
+                    Instant::now() + Duration::from_secs(30)
+                ),
+                PLAIN.len()
+            )
+            .is_err()
+        );
+        assert!(
+            decode(
+                X_CONTENT,
+                Some(&identities),
+                &DecodeControl::new(None, Instant::now()),
+                PLAIN.len()
+            )
+            .is_err()
+        );
+        let error = Identities::parse(&format!("{}\ninvalid-private-fixture", X_KEY.trim_end()))
+            .unwrap_err();
+        assert!(!error.to_string().contains("invalid-private-fixture"));
+        assert!(!error.to_string().contains(X_KEY.trim_end()));
+    }
+}
diff --git a/src/resource/bundle.rs b/src/resource/bundle.rs
new file mode 100644
index 0000000..8776f0b
--- /dev/null
+++ b/src/resource/bundle.rs
@@ -0,0 +1,221 @@
+//! Bounded, streamed access to one member of the user's offline rules bundle.
+use super::bundle_limits::{CheckedSource, inspect, inspect_block};
+use std::{
+    io::{self, Read, Seek},
+    path::Path,
+};
+use tokio_util::sync::CancellationToken;
+
+const MAX_MEMBER: u64 = 64 * 1024 * 1024;
+
+pub(crate) fn valid_member(name: &str) -> bool {
+    !name.is_empty()
+        && name.len() <= 1024
+        && !name.contains('\0')
+        && name.split('/').all(|part| !matches!(part, "" | "." | ".."))
+}
+
+pub(crate) fn read_member(
+    root: &Path,
+    name: &str,
+    configured_limit: u64,
+    cancellation: &CancellationToken,
+) -> io::Result<Vec<u8>> {
+    let path = super::cache::resource_path(root, "BundleMRS.7z", false)?;
+    let file = std::fs::File::open(path)?;
+    if !file.metadata()?.is_file() {
+        return Err(io::Error::other("rule bundle must be a regular file"));
+    }
+    decode_member(file, name, configured_limit, cancellation)
+}
+
+fn decode_member(
+    source: impl Read + Seek,
+    name: &str,
+    configured_limit: u64,
+    cancellation: &CancellationToken,
+) -> io::Result<Vec<u8>> {
+    if !valid_member(name) {
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidInput,
+            "invalid bundle member",
+        ));
+    }
+    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(30);
+    let flag = || cancellation.is_cancelled();
+    let mut source = CheckedSource::new(source, &flag)?;
+    let admission = inspect(&mut source)?;
+    let password = sevenz_rust2::Password::empty();
+    // Header dictionary admission occurs before this call allocates a decoder.
+    let archive = sevenz_rust2::Archive::read(&mut source, &password).map_err(|_| invalid())?;
+    source.check()?;
+    let mut matches = archive
+        .files
+        .iter()
+        .enumerate()
+        .filter(|(_, entry)| entry.name == name);
+    let (file_index, target) = matches
+        .next()
+        .ok_or_else(|| io::Error::new(io::ErrorKind::NotFound, "bundle member unavailable"))?;
+    if matches.next().is_some() || !target.has_stream || target.is_directory || target.is_anti_item
+    {
+        return Err(invalid());
+    }
+    let limit = if configured_limit == 0 {
+        MAX_MEMBER
+    } else {
+        configured_limit.min(MAX_MEMBER)
+    };
+    if target.size > limit {
+        return Err(invalid());
+    }
+    let block = archive
+        .stream_map
+        .file_block_index
+        .get(file_index)
+        .copied()
+        .flatten()
+        .ok_or_else(invalid)?;
+    // Charge retained output together with this decode's dictionary/metadata.
+    inspect_block(&archive, block, admission, target.size)?;
+    let mut output = Vec::new();
+    output
+        .try_reserve_exact(usize::try_from(target.size).map_err(|_| invalid())?)
+        .map_err(|_| invalid())?;
+    let mut decoded = 0u64;
+    let mut found = false;
+    sevenz_rust2::BlockDecoder::new(1, block, &archive, &password, &mut source)
+        .for_each_entries(&mut |entry, input| {
+            let keep = entry.name == name;
+            let mut chunk = [0; 8192];
+            loop {
+                if cancellation.is_cancelled() {
+                    return Err(io::Error::from(io::ErrorKind::ConnectionAborted).into());
+                }
+                if std::time::Instant::now() >= deadline {
+                    return Err(io::Error::from(io::ErrorKind::TimedOut).into());
+                }
+                let count = input.read(&mut chunk)?;
+                if std::time::Instant::now() >= deadline {
+                    return Err(io::Error::from(io::ErrorKind::TimedOut).into());
+                }
+                if count == 0 {
+                    break;
+                }
+                decoded = decoded.checked_add(count as u64).ok_or_else(invalid)?;
+                if decoded > 256 * 1024 * 1024 || keep && output.len() as u64 + count as u64 > limit
+                {
+                    return Err(invalid().into());
+                }
+                if keep {
+                    output.extend_from_slice(&chunk[..count]);
+                }
+            }
+            if keep {
+                found = true;
+            }
+            // Reading to EOF verifies this member's CRC before stopping. Prefix
+            // members have been streamed and discarded, never retained.
+            Ok(!keep)
+        })
+        .map_err(|_| invalid())?;
+    source.check()?;
+    if !found || output.len() as u64 != target.size {
+        return Err(invalid());
+    }
+    Ok(output)
+}
+
+fn invalid() -> io::Error {
+    io::Error::new(
+        io::ErrorKind::InvalidData,
+        "invalid or over-budget rule bundle",
+    )
+}
+
+#[cfg(test)]
+pub(super) mod tests {
+    use super::*;
+    use crate::config::{
+        RuleCollection,
+        providers::{RuleBehavior, RuleFormat},
+    };
+    use sevenz_rust2::{ArchiveEntry, ArchiveWriter, SourceReader};
+    use std::io::Cursor;
+
+    pub(crate) fn mrs() -> Vec<u8> {
+        let mut wire = b"MRS\x01".to_vec();
+        wire.push(1);
+        wire.extend_from_slice(&1i64.to_be_bytes());
+        wire.extend_from_slice(&0i64.to_be_bytes());
+        wire.push(1);
+        wire.extend_from_slice(&1i64.to_be_bytes());
+        for ip in [
+            std::net::Ipv4Addr::new(192, 0, 2, 0),
+            std::net::Ipv4Addr::new(192, 0, 2, 255),
+        ] {
+            wire.extend_from_slice(&ip.to_ipv6_mapped().octets());
+        }
+        zstd::encode_all(wire.as_slice(), 1).unwrap()
+    }
+
+    pub(crate) fn archive(member: &[u8], encoded: bool) -> Vec<u8> {
+        let mut writer = ArchiveWriter::new(Cursor::new(Vec::new())).unwrap();
+        writer.set_encrypt_header(encoded);
+        writer
+            .push_archive_entries(
+                vec![
+                    ArchiveEntry::new_file("prefix"),
+                    ArchiveEntry::new_file("rules/cn.mrs"),
+                ],
+                vec![
+                    SourceReader::new(Cursor::new(b"discard without retaining".to_vec())),
+                    SourceReader::new(Cursor::new(member.to_vec())),
+                ],
+            )
+            .unwrap();
+        writer.finish().unwrap().into_inner()
+    }
+
+    #[test]
+    fn bundle_member_streams_real_mrs_and_observes_output_and_cancellation() {
+        let member = mrs();
+        for encoded in [false, true] {
+            let wire = archive(&member, encoded);
+            let cancellation = CancellationToken::new();
+            let data = decode_member(Cursor::new(&wire), "rules/cn.mrs", 0, &cancellation).unwrap();
+            assert_eq!(data, member);
+            let rules =
+                RuleCollection::parse(&data, RuleBehavior::Ipcidr, RuleFormat::Mrs).unwrap();
+            assert!(
+                rules
+                    .matches_ip(
+                        "192.0.2.1".parse().unwrap(),
+                        &crate::routing::EmptyGeoMatcher,
+                        &crate::config::RuleDecision::default(),
+                    )
+                    .unwrap()
+            );
+            assert!(
+                !rules
+                    .matches_ip(
+                        "198.51.100.1".parse().unwrap(),
+                        &crate::routing::EmptyGeoMatcher,
+                        &crate::config::RuleDecision::default(),
+                    )
+                    .unwrap()
+            );
+            assert!(
+                decode_member(
+                    Cursor::new(&wire),
+                    "rules/cn.mrs",
+                    member.len() as u64 - 1,
+                    &cancellation
+                )
+                .is_err()
+            );
+            cancellation.cancel();
+            assert!(decode_member(Cursor::new(&wire), "rules/cn.mrs", 0, &cancellation).is_err());
+        }
+    }
+}
diff --git a/src/resource/bundle_limits.rs b/src/resource/bundle_limits.rs
new file mode 100644
index 0000000..8552640
--- /dev/null
+++ b/src/resource/bundle_limits.rs
@@ -0,0 +1,423 @@
+//! Independent admission parser for the public 7z header format.
+//! Inspects the same opened source used by the official archive decoder.
+use std::{
+    io::{self, Read, Seek, SeekFrom},
+    time::{Duration, Instant},
+};
+
+const HEADER_BYTES: u64 = 128 * 1024;
+const HEADER_PACKED: u64 = 16 * 1024 * 1024;
+const DECODER_BYTES: u64 = 96 * 1024 * 1024;
+const METADATA_AMPLIFICATION: u64 = 1024;
+const MAX_CODERS: usize = 8;
+const SIGNATURE: &[u8; 6] = b"7z\xbc\xaf\x27\x1c";
+
+#[derive(Debug, Clone, Copy)]
+pub struct Admission {
+    pub file_len: u64,
+    pub metadata_bytes: u64,
+}
+
+/// One opened handle for inspection and decode. Cooperative cancellation is
+/// checked inside decoder reads, never by discarding a blocking JoinHandle.
+pub struct CheckedSource<'a, R> {
+    inner: R,
+    length: u64,
+    read_bytes: u64,
+    operations: u32,
+    deadline: Instant,
+    cancelled: &'a dyn Fn() -> bool,
+}
+impl<'a, R: Read + Seek> CheckedSource<'a, R> {
+    pub fn new(mut inner: R, cancelled: &'a dyn Fn() -> bool) -> io::Result<Self> {
+        let length = inner.seek(SeekFrom::End(0))?;
+        inner.seek(SeekFrom::Start(0))?;
+        Ok(Self {
+            inner,
+            length,
+            read_bytes: 0,
+            operations: 0,
+            deadline: Instant::now() + Duration::from_secs(30),
+            cancelled,
+        })
+    }
+    pub(super) fn check(&mut self) -> io::Result<()> {
+        // Interrupted is deliberately avoided: Read::read_exact retries it.
+        if (self.cancelled)() {
+            return Err(io::ErrorKind::ConnectionAborted.into());
+        }
+        if Instant::now() >= self.deadline || self.operations >= 65536 {
+            return Err(io::ErrorKind::TimedOut.into());
+        }
+        self.operations += 1;
+        Ok(())
+    }
+}
+impl<R: Read + Seek> Read for CheckedSource<'_, R> {
+    fn read(&mut self, bytes: &mut [u8]) -> io::Result<usize> {
+        self.check()?;
+        if bytes.is_empty() {
+            return Ok(0);
+        }
+        let remaining = (256 * 1024 * 1024u64)
+            .checked_sub(self.read_bytes)
+            .ok_or_else(invalid)?;
+        if remaining == 0 {
+            return Err(invalid());
+        }
+        let length = bytes.len().min(8192).min(remaining as usize);
+        let read = self.inner.read(&mut bytes[..length])?;
+        self.read_bytes = add(self.read_bytes, read as u64)?;
+        Ok(read)
+    }
+}
+impl<R: Read + Seek> Seek for CheckedSource<'_, R> {
+    fn seek(&mut self, position: SeekFrom) -> io::Result<u64> {
+        self.check()?;
+        let absolute = match position {
+            SeekFrom::Start(value) => i128::from(value),
+            SeekFrom::End(offset) => i128::from(self.length) + i128::from(offset),
+            SeekFrom::Current(offset) => {
+                i128::from(self.inner.stream_position()?) + i128::from(offset)
+            }
+        };
+        if absolute < 0 || absolute > i128::from(self.length) {
+            return Err(invalid());
+        }
+        self.inner.seek(SeekFrom::Start(absolute as u64))
+    }
+}
+
+fn invalid() -> io::Error {
+    io::Error::new(io::ErrorKind::InvalidData, "rule bundle failed admission")
+}
+
+fn add(a: u64, b: u64) -> io::Result<u64> {
+    a.checked_add(b).ok_or_else(invalid)
+}
+
+/// Validate signature, both CRCs and any encoded-header decoder before
+/// permitting the official library to instantiate its header decoder.
+pub fn inspect(reader: &mut (impl Read + Seek)) -> io::Result<Admission> {
+    let file_len = reader.seek(SeekFrom::End(0))?;
+    reader.seek(SeekFrom::Start(0))?;
+    let mut signature = [0u8; 32];
+    reader.read_exact(&mut signature)?;
+    if &signature[..6] != SIGNATURE || signature[6] != 0 {
+        return Err(invalid());
+    }
+    let number = |offset| u64::from_le_bytes(signature[offset..offset + 8].try_into().unwrap());
+    let crc = u32::from_le_bytes(signature[8..12].try_into().unwrap());
+    if crc32fast::hash(&signature[12..]) != crc {
+        return Err(invalid());
+    }
+    let offset = add(32, number(12))?;
+    let size = number(20);
+    if size == 0 || size > HEADER_BYTES || add(offset, size)? > file_len {
+        return Err(invalid());
+    }
+    reader.seek(SeekFrom::Start(offset))?;
+    let mut bytes = vec![0; size as usize];
+    reader.read_exact(&mut bytes)?;
+    if crc32fast::hash(&bytes) != u32::from_le_bytes(signature[28..32].try_into().unwrap()) {
+        return Err(invalid());
+    }
+    let mut input = Input(&bytes);
+    let metadata_bytes = match input.byte()? {
+        1 => add(8 * 1024 * 1024, size * METADATA_AMPLIFICATION)?,
+        23 => encoded_header(&mut input, file_len)?,
+        _ => return Err(invalid()),
+    };
+    if metadata_bytes > DECODER_BYTES {
+        return Err(invalid());
+    }
+    reader.seek(SeekFrom::Start(0))?;
+    Ok(Admission {
+        file_len,
+        metadata_bytes,
+    })
+}
+
+struct Input<'a>(&'a [u8]);
+impl<'a> Input<'a> {
+    fn bytes(&mut self, n: usize) -> io::Result<&'a [u8]> {
+        let (part, remainder) = self.0.split_at_checked(n).ok_or_else(invalid)?;
+        self.0 = remainder;
+        Ok(part)
+    }
+    fn byte(&mut self) -> io::Result<u8> {
+        Ok(self.bytes(1)?[0])
+    }
+    fn expect(&mut self, value: u8) -> io::Result<()> {
+        if self.byte()? == value {
+            Ok(())
+        } else {
+            Err(invalid())
+        }
+    }
+    // 7z integers carry low bytes after a prefix byte, not LEB128.
+    fn integer(&mut self) -> io::Result<u64> {
+        let prefix = self.byte()?;
+        let mut value = 0;
+        for count in 0..8 {
+            let mask = 0x80u8 >> count;
+            if prefix & mask == 0 {
+                value |= u64::from(prefix & (mask - 1)) << (count * 8);
+                return Ok(value);
+            }
+            value |= u64::from(self.byte()?) << (count * 8);
+        }
+        Ok(value)
+    }
+    fn count(&mut self, maximum: usize) -> io::Result<usize> {
+        usize::try_from(self.integer()?)
+            .ok()
+            .filter(|n| *n <= maximum)
+            .ok_or_else(invalid)
+    }
+    fn crc(&mut self, count: usize) -> io::Result<usize> {
+        let all = self.byte()?;
+        let present = if all == 0 {
+            self.bytes(count.div_ceil(8))?
+                .iter()
+                .enumerate()
+                .map(|(index, byte)| {
+                    let remaining = count.saturating_sub(index * 8).min(8);
+                    (byte & (0xff << (8 - remaining))).count_ones() as usize
+                })
+                .sum()
+        } else if all == 1 {
+            count
+        } else {
+            return Err(invalid());
+        };
+        self.bytes(present * 4)?;
+        Ok(present)
+    }
+}
+
+fn encoded_header(input: &mut Input<'_>, file_len: u64) -> io::Result<u64> {
+    input.expect(6)?; // PackInfo
+    let offset = add(32, input.integer()?)?;
+    // Metadata headers only require a single packed stream. Additional
+    // archived codecs/forms can later be audited without expanding admission.
+    if input.count(1)? != 1 {
+        return Err(invalid());
+    }
+    input.expect(9)?;
+    let packed = input.integer()?;
+    if packed > HEADER_PACKED || add(offset, packed)? > file_len {
+        return Err(invalid());
+    }
+    let mut tag = input.byte()?;
+    if tag == 10 {
+        input.crc(1)?;
+        tag = input.byte()?;
+    }
+    if tag != 0 {
+        return Err(invalid());
+    }
+    input.expect(7)?; // UnpackInfo
+    input.expect(11)?; // Folder
+    if input.count(1)? != 1 {
+        return Err(invalid());
+    }
+    input.expect(0)?; // no external folder metadata
+    let coders = input.count(MAX_CODERS)?;
+    if coders == 0 {
+        return Err(invalid());
+    }
+    let mut memory = 8 * 1024 * 1024;
+    for _ in 0..coders {
+        let descriptor = input.byte()?;
+        let id_length = usize::from(descriptor & 15);
+        if id_length == 0 || descriptor & 0xc0 != 0 {
+            return Err(invalid());
+        }
+        let method = input.bytes(id_length)?;
+        if descriptor & 16 != 0 && (input.integer()? != 1 || input.integer()? != 1) {
+            return Err(invalid());
+        }
+        let properties = if descriptor & 32 != 0 {
+            let length = input.count(16)?;
+            input.bytes(length)?
+        } else {
+            &[]
+        };
+        memory = add(memory, codec_memory(method, properties)?)?;
+    }
+    let mut inputs = 0u16;
+    let mut outputs = 0u16;
+    for _ in 1..coders {
+        let source = input.count(coders - 1)?;
+        let destination = input.count(coders - 1)?;
+        let source = 1u16 << source;
+        let destination = 1u16 << destination;
+        if inputs & source != 0 || outputs & destination != 0 {
+            return Err(invalid());
+        }
+        inputs |= source;
+        outputs |= destination;
+    }
+    input.expect(12)?; // CodersUnpackSize
+    let mut unpacked = 0;
+    for _ in 0..coders {
+        let size = input.integer()?;
+        if size > HEADER_BYTES {
+            return Err(invalid());
+        }
+        unpacked = unpacked.max(size);
+        memory = add(memory, size)?;
+    }
+    memory = add(memory, unpacked * METADATA_AMPLIFICATION)?;
+    if memory > DECODER_BYTES {
+        return Err(invalid());
+    }
+    let mut tag = input.byte()?;
+    let has_folder_crc = if tag == 10 {
+        let present = input.crc(1)?;
+        tag = input.byte()?;
+        present != 0
+    } else {
+        false
+    };
+    if tag != 0 {
+        return Err(invalid());
+    }
+    // With one folder and one substream the CRC can reside in UnpackInfo.
+    let tag = input.byte()?;
+    if tag == 8 {
+        let mut tag = input.byte()?;
+        if tag == 13 {
+            if input.count(1)? != 1 {
+                return Err(invalid());
+            }
+            tag = input.byte()?;
+        }
+        if tag == 10 {
+            input.crc(usize::from(!has_folder_crc))?;
+            tag = input.byte()?;
+        }
+        if tag != 0 {
+            return Err(invalid());
+        }
+        input.expect(0)?;
+    } else if tag != 0 {
+        return Err(invalid());
+    }
+    if !input.0.is_empty() {
+        return Err(invalid());
+    }
+    Ok(memory)
+}
+
+fn codec_memory(method: &[u8], props: &[u8]) -> io::Result<u64> {
+    // These constants describe publicly specified codec identifiers/properties.
+    match method {
+        [0] if props.is_empty() => Ok(64 * 1024), // COPY
+        [0x21] if props.len() == 1 && props[0] <= 40 => {
+            let property = props[0];
+            let dictionary = if property == 40 {
+                u32::MAX as u64
+            } else {
+                (2u64 | u64::from(property & 1)) << (property / 2 + 11)
+            };
+            add(dictionary, 2 * 1024 * 1024)
+        }
+        [3, 1, 1] if props.len() == 5 && props[0] < 225 => {
+            let lc = u32::from(props[0] % 9);
+            let lp = u32::from(props[0] / 9 % 5);
+            let dictionary =
+                u64::from(u32::from_le_bytes(props[1..].try_into().unwrap())).max(4096);
+            add(
+                add(dictionary, (0x300u64 << (lc + lp)) * 2)?,
+                2 * 1024 * 1024,
+            )
+        }
+        [3, 3, 1, 3] | [3, 3, 5, 1] | [3, 3, 7, 1] if props.is_empty() || props.len() == 4 => {
+            Ok(64 * 1024)
+        } // BCJ filters
+        [3] if props.len() == 1 => Ok(64 * 1024), // Delta
+        _ => Err(invalid()),
+    }
+}
+
+/// Validate the selected solid block before member decoder construction.
+pub fn inspect_block(
+    archive: &sevenz_rust2::Archive,
+    index: usize,
+    admission: Admission,
+    retained_bytes: u64,
+) -> io::Result<()> {
+    let block = archive.blocks.get(index).ok_or_else(invalid)?;
+    if block.coders.is_empty() || block.coders.len() > MAX_CODERS || archive.files.len() > 4096 {
+        return Err(invalid());
+    }
+    let mut memory = add(admission.metadata_bytes, retained_bytes)?;
+    let mut visited = 0u16;
+    for (coder_index, _) in block.ordered_coder_iter() {
+        let bit = 1u16 << coder_index;
+        if visited & bit != 0 {
+            return Err(invalid());
+        }
+        visited |= bit;
+    }
+    if visited.count_ones() as usize != block.coders.len() {
+        return Err(invalid());
+    }
+    for (index, coder) in block.coders.iter().enumerate() {
+        memory = add(
+            memory,
+            codec_memory(coder.encoder_method_id(), coder.properties())?,
+        )?;
+        if block.get_unpack_size_at_index(index) > 256 * 1024 * 1024 {
+            return Err(invalid());
+        }
+    }
+    if memory > DECODER_BYTES {
+        return Err(invalid());
+    }
+    let first = *archive
+        .stream_map
+        .block_first_pack_stream_index()
+        .get(index)
+        .ok_or_else(invalid)?;
+    let after = archive
+        .stream_map
+        .block_first_pack_stream_index()
+        .get(index + 1)
+        .copied()
+        .unwrap_or(archive.pack_sizes().len());
+    if after.checked_sub(first) != Some(1) {
+        return Err(invalid());
+    }
+    // Only one packed input and an acyclic chain of audited codecs proceed.
+    // The library additionally rejects non-1:1 coder descriptors before decode.
+    let packed = *archive.pack_sizes().get(first).ok_or_else(invalid)?;
+    if packed > 128 * 1024 * 1024 {
+        return Err(invalid());
+    }
+    let relative = archive.pack_sizes()[..first]
+        .iter()
+        .try_fold(archive.pack_pos(), |sum, n| add(sum, *n))?;
+    if add(add(32, relative)?, packed)? > admission.file_len {
+        return Err(invalid());
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn hostile_encoded_header_dictionary_fails_before_a_decoder_exists() {
+        // Public 7z encoded-header shape, no library decoder constructed here.
+        let wire = [
+            6, 0, 1, 9, 1, 0, 7, 11, 1, 0, 1, 0x21, 0x21, 1, 40, 12, 1, 0, 0,
+        ];
+        assert!(encoded_header(&mut Input(&wire), 33).is_err());
+        let mut safe = wire;
+        safe[14] = 0;
+        assert!(encoded_header(&mut Input(&safe), 33).is_ok());
+    }
+}
diff --git a/src/resource/cache.rs b/src/resource/cache.rs
new file mode 100644
index 0000000..816f5b7
--- /dev/null
+++ b/src/resource/cache.rs
@@ -0,0 +1,820 @@
+//! Provider files and candidate updates. Publication belongs to the runtime graph owner.
+use super::http::{self, DownloadOutcome, DownloadRequest, HttpOptions};
+use super::paths::{Access, ProviderPaths};
+use super::subscription::SubscriptionInfo;
+use crate::{
+    config::providers::{
+        ProviderContent, ProviderContents, ProviderSpec, ProviderTemplate, ProviderType,
+    },
+    dispatch::Dispatcher,
+};
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+use std::{
+    fs,
+    io::{self, Read},
+    path::{Path, PathBuf},
+    sync::{
+        Arc,
+        atomic::{AtomicU64, Ordering},
+    },
+    time::{Duration, SystemTime, UNIX_EPOCH},
+};
+use tokio_util::sync::CancellationToken;
+
+static NEXT_FILE: AtomicU64 = AtomicU64::new(1);
+const MAX_PARSE_BYTES: u64 = 64 * 1024 * 1024;
+const MAX_METADATA_BYTES: u64 = 64 * 1024;
+
+fn request_options(spec: &ProviderSpec, user_agent: String) -> HttpOptions {
+    HttpOptions {
+        user_agent,
+        headers: spec.headers(),
+        size_limit: (spec.size_limit > 0).then_some(spec.size_limit),
+        allow_http: true,
+        allow_ip: true,
+    }
+}
+fn source_key(spec: &ProviderSpec, user_agent: &str) -> io::Result<String> {
+    if spec.kind == ProviderType::Http {
+        http::request_identity(&spec.url, &request_options(spec, user_agent.into()))
+            .map_err(|_| io::Error::other("invalid provider request identity"))
+    } else {
+        Ok(http::source_identity(&spec.url))
+    }
+}
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+struct Metadata {
+    url: String,
+    etag: Option<String>,
+    hash: String,
+    checked: u64,
+    #[serde(default)]
+    bundled: bool,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    subscription_info: Option<SubscriptionInfo>,
+}
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct ProviderState {
+    pub name: String,
+    pub vehicle_type: &'static str,
+    pub rule: bool,
+    pub available: bool,
+    pub downloaded: bool,
+    pub updating: bool,
+    pub updated_at: Option<u64>,
+    pub error: Option<&'static str>,
+    pub count: usize,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub subscription_info: Option<SubscriptionInfo>,
+}
+#[derive(Clone)]
+pub(crate) struct ResourceEntry {
+    pub key: String,
+    pub spec: ProviderSpec,
+    pub state: ProviderState,
+    path: Option<PathBuf>,
+    metadata: Metadata,
+    pub next: tokio::time::Instant,
+    modified: Option<SystemTime>,
+    failures: u32,
+}
+#[derive(Clone)]
+pub(crate) struct ProviderCache {
+    root: PathBuf,
+    pub template: Arc<ProviderTemplate>,
+    pub entries: Vec<ResourceEntry>,
+    pub contents: ProviderContents,
+}
+pub(crate) struct Candidate {
+    pub content: ProviderContent,
+    temporary: Option<PathBuf>,
+    metadata: Metadata,
+    modified: Option<SystemTime>,
+}
+impl Drop for Candidate {
+    fn drop(&mut self) {
+        if let Some(path) = &self.temporary {
+            let _ = fs::remove_file(path);
+        }
+    }
+}
+impl ProviderCache {
+    pub fn open(root: &Path, template: Arc<ProviderTemplate>) -> io::Result<Self> {
+        Self::open_with_cancel(root, template, None)
+    }
+    pub fn open_with_cancel(
+        root: &Path,
+        template: Arc<ProviderTemplate>,
+        cancellation: Option<&CancellationToken>,
+    ) -> io::Result<Self> {
+        Self::open_mode(root, template, cancellation, true)
+    }
+    #[cfg(any(feature = "invoke", test))]
+    pub(crate) fn open_candidate(
+        root: &Path,
+        template: Arc<ProviderTemplate>,
+        cancellation: &CancellationToken,
+    ) -> io::Result<Self> {
+        Self::open_mode(root, template, Some(cancellation), false)
+    }
+    fn open_mode(
+        root: &Path,
+        template: Arc<ProviderTemplate>,
+        cancellation: Option<&CancellationToken>,
+        persist_bundle: bool,
+    ) -> io::Result<Self> {
+        let root = fs::canonicalize(root)?;
+        let mut entries = Vec::new();
+        let mut contents = ProviderContents::new();
+        let user_agent = template.request_user_agent();
+        for (rule, (name, spec)) in template
+            .proxies
+            .iter()
+            .map(|item| (false, item))
+            .chain(template.rules.iter().map(|item| (true, item)))
+        {
+            if cancellation.is_some_and(CancellationToken::is_cancelled) {
+                return Err(io::ErrorKind::Interrupted.into());
+            }
+            let key = ProviderTemplate::key(rule, name);
+            let mut entry = ResourceEntry {
+                key: key.clone(),
+                spec: spec.clone(),
+                state: ProviderState {
+                    name: name.clone(),
+                    rule,
+                    vehicle_type: match spec.kind {
+                        ProviderType::Http => "HTTP",
+                        ProviderType::File => "File",
+                        ProviderType::Inline => "Inline",
+                    },
+                    available: spec.kind == ProviderType::Inline || !spec.payload.is_empty(),
+                    downloaded: false,
+                    updating: false,
+                    updated_at: None,
+                    error: None,
+                    count: spec.payload.len(),
+                    subscription_info: None,
+                },
+                path: None,
+                metadata: Metadata::default(),
+                next: tokio::time::Instant::now(),
+                modified: None,
+                failures: 0,
+            };
+            if spec.kind != ProviderType::Inline {
+                let cache_identity = if spec.kind == ProviderType::Http && spec.path.is_empty() {
+                    source_key(spec, &user_agent)?
+                } else {
+                    spec.url.clone()
+                };
+                let fallback = format!(
+                    "{}/{}",
+                    if rule { "rules" } else { "proxies" },
+                    hex(&Sha256::digest(cache_identity.as_bytes()))
+                );
+                let access = match spec.kind {
+                    ProviderType::File => Access::FileRead,
+                    _ if persist_bundle => Access::CacheWrite,
+                    _ => Access::CacheRead,
+                };
+                let path = template.resource_paths.resolve(
+                    &root,
+                    Path::new(if spec.path.is_empty() {
+                        &fallback
+                    } else {
+                        &spec.path
+                    }),
+                    access,
+                )?;
+                let sidecar = template.resource_paths.resolve(
+                    &root,
+                    &metadata_path(&path),
+                    Access::CacheRead,
+                )?;
+                let control = super::age_provider::DecodeControl::new(
+                    cancellation,
+                    std::time::Instant::now() + http::DEFAULT_DOWNLOAD_TIMEOUT,
+                );
+                let metadata = read_bounded(&sidecar, MAX_METADATA_BYTES, &control)
+                    .ok()
+                    .and_then(|bytes| serde_json::from_slice::<Metadata>(&bytes).ok())
+                    .unwrap_or_default();
+                if let Ok((bytes, modified)) =
+                    read_bounded_with_modified(&path, spec.size_limit, &control)
+                {
+                    match template.parse_content_with_control(spec, &bytes, &control) {
+                        Ok(content) => {
+                            entry.state.available = true;
+                            entry.state.downloaded = spec.kind == ProviderType::Http;
+                            entry.state.count = content_len(&content);
+                            entry.state.updated_at = modified.map(unix_time);
+                            entry.modified = modified;
+                            let source_identity = source_key(spec, &user_agent)?;
+                            if metadata.url == source_identity
+                                && metadata.hash == hex(&Sha256::digest(&bytes))
+                            {
+                                entry.state.downloaded &= !metadata.bundled;
+                                entry.metadata = metadata;
+                                if !rule && spec.kind == ProviderType::Http {
+                                    entry.state.subscription_info =
+                                        entry.metadata.subscription_info;
+                                } else {
+                                    entry.metadata.subscription_info = None;
+                                }
+                            } else if spec.kind == ProviderType::Http {
+                                // Old content can keep the session usable, but a new
+                                // source/auth identity owes an unconditional refresh.
+                                entry.state.downloaded = false;
+                            }
+                            contents.insert(key.clone(), content);
+                            if spec.kind == ProviderType::Http && entry.state.downloaded {
+                                entry.next = next_update(
+                                    spec.interval,
+                                    entry
+                                        .metadata
+                                        .checked
+                                        .max(entry.state.updated_at.unwrap_or(0)),
+                                );
+                            }
+                        }
+                        Err(_) => entry.state.error = Some("invalid cached content"),
+                    }
+                }
+                if rule && !spec.path_in_bundle.is_empty() && !contents.contains_key(&key) {
+                    let fallback_cancellation = CancellationToken::new();
+                    let cancellation = cancellation.unwrap_or(&fallback_cancellation);
+                    if let Ok((bytes, content)) = super::bundle::read_member(
+                        &root,
+                        &spec.path_in_bundle,
+                        spec.size_limit,
+                        cancellation,
+                    )
+                    .and_then(|bytes| {
+                        template
+                            .parse_content_with_control(spec, &bytes, &control)
+                            .map(|content| (bytes, content))
+                            .map_err(|_| io::Error::other("invalid bundled rule content"))
+                    }) {
+                        if cancellation.is_cancelled() {
+                            return Err(io::ErrorKind::Interrupted.into());
+                        }
+                        // Extra roots grant file reads, never a bundle write to that source.
+                        let persist_fallback = persist_bundle
+                            && (spec.kind == ProviderType::Http || path.starts_with(&root));
+                        let access = if persist_fallback {
+                            Access::CacheWrite
+                        } else {
+                            Access::FileRead
+                        };
+                        let write_path = template.resource_paths.resolve(
+                            &root,
+                            Path::new(if spec.path.is_empty() {
+                                &fallback
+                            } else {
+                                &spec.path
+                            }),
+                            access,
+                        )?;
+                        if persist_fallback {
+                            template.resource_paths.resolve(
+                                &root,
+                                &metadata_path(&write_path),
+                                Access::CacheWrite,
+                            )?;
+                        }
+                        let metadata = Metadata {
+                            url: source_key(spec, &user_agent)?,
+                            etag: None,
+                            hash: hex(&Sha256::digest(&bytes)),
+                            checked: 0,
+                            bundled: true,
+                            subscription_info: None,
+                        };
+                        if persist_fallback {
+                            let temporary = TemporaryFile(Some(temporary_path(&write_path)));
+                            fs::write(temporary.0.as_ref().unwrap(), &bytes)?;
+                            if cancellation.is_cancelled() {
+                                return Err(io::ErrorKind::Interrupted.into());
+                            }
+                            commit_download(&write_path, temporary.0.as_ref().unwrap(), &metadata)?;
+                        }
+                        entry.state.available = true;
+                        entry.state.downloaded = false;
+                        entry.state.count = content_len(&content);
+                        entry.modified = persist_fallback
+                            .then(|| {
+                                fs::metadata(&write_path)
+                                    .ok()
+                                    .and_then(|m| m.modified().ok())
+                            })
+                            .flatten();
+                        entry.state.updated_at = entry.modified.map(unix_time);
+                        entry.state.error = None;
+                        entry.metadata = metadata;
+                        contents.insert(key.clone(), content);
+                        // A bundle is an initial local source, never an ETag or
+                        // proof that the HTTP vehicle has already been fetched.
+                        entry.next = tokio::time::Instant::now();
+                    }
+                }
+                if cancellation.is_some_and(CancellationToken::is_cancelled) {
+                    return Err(io::ErrorKind::Interrupted.into());
+                }
+                entry.path = Some(path);
+            }
+            entries.push(entry);
+        }
+        if cancellation.is_some_and(CancellationToken::is_cancelled) {
+            return Err(io::ErrorKind::Interrupted.into());
+        }
+        Ok(Self {
+            root,
+            template,
+            entries,
+            contents,
+        })
+    }
+    #[cfg(any(feature = "invoke", test))]
+    pub(crate) fn prepare_paths(&self, root: &Path, cancel: &CancellationToken) -> io::Result<()> {
+        for entry in &self.entries {
+            if cancel.is_cancelled() {
+                return Err(io::ErrorKind::Interrupted.into());
+            }
+            if entry.spec.kind == ProviderType::Http {
+                let path = entry.path.as_ref().expect("HTTP cache path");
+                self.template
+                    .resource_paths
+                    .resolve(root, path, Access::CacheWrite)?;
+                self.template.resource_paths.resolve(
+                    root,
+                    &metadata_path(path),
+                    Access::CacheWrite,
+                )?;
+            }
+        }
+        Ok(())
+    }
+    pub fn next_due(&self) -> Option<usize> {
+        self.next_refresh()
+            .filter(|(_, deadline)| *deadline <= tokio::time::Instant::now())
+            .map(|(index, _)| index)
+    }
+    pub fn next_refresh(&self) -> Option<(usize, tokio::time::Instant)> {
+        self.entries
+            .iter()
+            .enumerate()
+            .filter(|(_, entry)| {
+                entry.spec.kind != ProviderType::Inline
+                    && !(entry.spec.kind == ProviderType::Http
+                        && entry.spec.interval == 0
+                        && entry.state.downloaded)
+            })
+            .min_by_key(|(_, entry)| entry.next)
+            .map(|(index, entry)| (index, entry.next))
+    }
+    pub async fn fetch(
+        &mut self,
+        index: usize,
+        dispatcher: Arc<dyn Dispatcher>,
+        user_agent: String,
+        etag_support: bool,
+        security: crate::security::SecurityContext,
+        cancellation: CancellationToken,
+    ) -> io::Result<Option<Candidate>> {
+        let deadline = std::time::Instant::now() + http::DEFAULT_DOWNLOAD_TIMEOUT;
+        let entry = &mut self.entries[index];
+        if cancellation.is_cancelled() {
+            return Err(io::ErrorKind::Interrupted.into());
+        }
+        if entry.spec.kind == ProviderType::Inline {
+            return Ok(None);
+        }
+        entry.state.updating = true;
+        let operation = async {
+            let access = if entry.spec.kind == ProviderType::File {
+                Access::FileRead
+            } else {
+                Access::CacheWrite
+            };
+            let path = self.template.resource_paths.resolve(
+                &self.root,
+                entry.path.as_ref().expect("file resource path"),
+                access,
+            )?;
+            if entry.spec.kind == ProviderType::Http {
+                self.template.resource_paths.resolve(
+                    &self.root,
+                    &metadata_path(&path),
+                    Access::CacheWrite,
+                )?;
+            }
+            if entry.spec.kind == ProviderType::File {
+                let modified = match fs::metadata(&path) {
+                    Err(error)
+                        if error.kind() == io::ErrorKind::NotFound
+                            && entry.metadata.bundled
+                            && entry.modified.is_none() =>
+                    {
+                        return Ok(None);
+                    }
+                    value => value?.modified()?,
+                };
+                if Some(modified) == entry.modified && entry.state.available {
+                    return Ok(None);
+                }
+                let spec = entry.spec.clone();
+                let template = self.template.clone();
+                let path = path.clone();
+                let parse_cancellation = cancellation.clone();
+                let (content, modified) = tokio::task::spawn_blocking(move || {
+                    let control = super::age_provider::DecodeControl::new(
+                        Some(&parse_cancellation),
+                        deadline,
+                    );
+                    let (bytes, modified) =
+                        read_bounded_with_modified(&path, spec.size_limit, &control)?;
+                    template
+                        .parse_content_with_control(&spec, &bytes, &control)
+                        .map(|content| (content, modified))
+                        .map_err(|_| {
+                            io::Error::new(io::ErrorKind::InvalidData, "invalid provider content")
+                        })
+                })
+                .await
+                .map_err(io::Error::other)??;
+                return Ok(Some(Candidate {
+                    content,
+                    temporary: None,
+                    metadata: Metadata::default(),
+                    modified,
+                }));
+            }
+            let temporary = temporary_path(&path);
+            let options = request_options(&entry.spec, user_agent);
+            let source_identity = http::request_identity(&entry.spec.url, &options)
+                .map_err(|_| io::Error::other("invalid provider request identity"))?;
+            let same_source = entry.metadata.url == source_identity;
+            let previous_subscription = if same_source {
+                entry.metadata.subscription_info
+            } else {
+                None
+            };
+            let outcome = http::download(DownloadRequest {
+                security,
+                dispatcher,
+                url: entry.spec.url.clone(),
+                etag: (etag_support && same_source)
+                    .then(|| entry.metadata.etag.clone())
+                    .flatten(),
+                temporary_path: temporary.clone(),
+                timeout: deadline.saturating_duration_since(std::time::Instant::now()),
+                cancellation: cancellation.clone(),
+                options,
+            })
+            .await
+            .map_err(|_| io::Error::other("provider download failed"))?;
+            match outcome {
+                DownloadOutcome::NotModified { subscription_info } => {
+                    if cancellation.is_cancelled() {
+                        return Err(io::ErrorKind::Interrupted.into());
+                    }
+                    let mut metadata = entry.metadata.clone();
+                    metadata.url = source_identity;
+                    metadata.checked = unix_time(SystemTime::now());
+                    if !entry.state.rule {
+                        metadata.subscription_info =
+                            subscription_info.or(metadata.subscription_info);
+                    } else {
+                        metadata.subscription_info = None;
+                    }
+                    write_metadata(&path, &metadata)?;
+                    entry.state.subscription_info = metadata.subscription_info;
+                    entry.metadata = metadata;
+                    Ok(None)
+                }
+                DownloadOutcome::Downloaded {
+                    etag,
+                    sha256,
+                    subscription_info,
+                    ..
+                } => {
+                    let mut cleanup = TemporaryFile(Some(temporary.clone()));
+                    let spec = entry.spec.clone();
+                    let template = self.template.clone();
+                    let input = temporary.clone();
+                    let parse_cancellation = cancellation.clone();
+                    let parsed = tokio::task::spawn_blocking(move || {
+                        let control = super::age_provider::DecodeControl::new(
+                            Some(&parse_cancellation),
+                            deadline,
+                        );
+                        let bytes = read_bounded(&input, spec.size_limit, &control)?;
+                        template
+                            .parse_content_with_control(&spec, &bytes, &control)
+                            .map_err(|_| {
+                                io::Error::new(
+                                    io::ErrorKind::InvalidData,
+                                    "invalid provider content",
+                                )
+                            })
+                    })
+                    .await
+                    .map_err(io::Error::other)?;
+                    match parsed {
+                        Ok(content) => {
+                            cleanup.0 = None;
+                            Ok(Some(Candidate {
+                                content,
+                                temporary: Some(temporary),
+                                metadata: Metadata {
+                                    url: source_identity,
+                                    etag,
+                                    hash: sha256.iter().map(|byte| format!("{byte:02x}")).collect(),
+                                    checked: unix_time(SystemTime::now()),
+                                    bundled: false,
+                                    subscription_info: if entry.state.rule {
+                                        None
+                                    } else {
+                                        subscription_info.or(previous_subscription)
+                                    },
+                                },
+                                modified: None,
+                            }))
+                        }
+                        Err(error) => {
+                            let _ = fs::remove_file(temporary);
+                            Err(error)
+                        }
+                    }
+                }
+            }
+        }
+        .await;
+        entry.state.updating = false;
+        if cancellation.is_cancelled() {
+            drop(operation);
+            return Err(io::ErrorKind::Interrupted.into());
+        }
+        if operation.is_err() {
+            Self::failed_entry(entry, "resource fetch or parse failed");
+        } else if matches!(operation, Ok(None)) {
+            Self::schedule(entry);
+            entry.state.error = None;
+        }
+        operation
+    }
+    pub fn reject(&mut self, index: usize) {
+        Self::failed_entry(&mut self.entries[index], "candidate graph rejected");
+    }
+    pub fn commit(
+        &mut self,
+        index: usize,
+        mut candidate: Candidate,
+        cancellation: &CancellationToken,
+    ) -> io::Result<()> {
+        if cancellation.is_cancelled() {
+            return Err(io::ErrorKind::Interrupted.into());
+        }
+        let entry = &mut self.entries[index];
+        if let Some(temporary) = &candidate.temporary {
+            let path = entry.path.as_ref().expect("cache path");
+            self.template
+                .resource_paths
+                .resolve(&self.root, path, Access::CacheWrite)?;
+            self.template.resource_paths.resolve(
+                &self.root,
+                &metadata_path(path),
+                Access::CacheWrite,
+            )?;
+            commit_download(path, temporary, &candidate.metadata)?;
+            candidate.temporary = None;
+            entry.metadata = candidate.metadata.clone();
+            entry.state.downloaded = true;
+            entry.state.subscription_info = entry.metadata.subscription_info;
+        }
+        // A file can be replaced while the candidate graph is being built.
+        // Retain the timestamp of the bytes we read, so the new file stays due.
+        entry.modified = if entry.spec.kind == ProviderType::File {
+            candidate.modified
+        } else {
+            entry
+                .path
+                .as_ref()
+                .and_then(|path| fs::metadata(path).ok())
+                .and_then(|m| m.modified().ok())
+        };
+        entry.state.available = true;
+        entry.state.updated_at = Some(unix_time(SystemTime::now()));
+        entry.state.error = None;
+        entry.state.count = content_len(&candidate.content);
+        self.contents
+            .insert(entry.key.clone(), candidate.content.clone());
+        Self::schedule(entry);
+        Ok(())
+    }
+    fn failed_entry(entry: &mut ResourceEntry, error: &'static str) {
+        entry.state.error = Some(error);
+        entry.failures = entry.failures.saturating_add(1);
+        entry.next = tokio::time::Instant::now()
+            + Duration::from_secs(
+                (10u64.saturating_mul(1u64.checked_shl(entry.failures.min(8) - 1).unwrap_or(256)))
+                    .min(3600),
+            );
+    }
+    fn schedule(entry: &mut ResourceEntry) {
+        entry.failures = 0;
+        let seconds = if entry.spec.kind == ProviderType::File {
+            1
+        } else if entry.spec.interval == 0 {
+            365 * 24 * 3600
+        } else {
+            entry.spec.interval.min(i64::MAX as u64 / 1_000_000_000)
+        };
+        entry.next = tokio::time::Instant::now() + Duration::from_secs(seconds);
+    }
+}
+fn content_len(content: &ProviderContent) -> usize {
+    match content {
+        ProviderContent::Proxies(values) => values.len(),
+        ProviderContent::Rules(set) => set.len(),
+    }
+}
+fn next_update(interval: u64, checked: u64) -> tokio::time::Instant {
+    let seconds = if interval == 0 {
+        365 * 24 * 3600
+    } else {
+        checked
+            .saturating_add(interval)
+            .saturating_sub(unix_time(SystemTime::now()))
+            .min(i64::MAX as u64 / 1_000_000_000)
+    };
+    tokio::time::Instant::now() + Duration::from_secs(seconds)
+}
+fn unix_time(time: SystemTime) -> u64 {
+    time.duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_secs()
+}
+fn read_bounded(
+    path: &Path,
+    limit: u64,
+    control: &super::age_provider::DecodeControl<'_>,
+) -> io::Result<Vec<u8>> {
+    read_bounded_with_modified(path, limit, control).map(|(bytes, _)| bytes)
+}
+fn read_bounded_with_modified(
+    path: &Path,
+    limit: u64,
+    control: &super::age_provider::DecodeControl<'_>,
+) -> io::Result<(Vec<u8>, Option<SystemTime>)> {
+    let limit = if limit == 0 {
+        MAX_PARSE_BYTES
+    } else {
+        limit.min(MAX_PARSE_BYTES)
+    };
+    control
+        .check()
+        .map_err(|_| io::Error::other("provider read stopped"))?;
+    let mut options = fs::OpenOptions::new();
+    options.read(true);
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::OpenOptionsExt;
+        options.custom_flags(libc::O_NONBLOCK);
+    }
+    let mut file = options.open(path)?;
+    let metadata = file.metadata()?;
+    if !metadata.is_file() {
+        return Err(io::Error::other("provider path must be a regular file"));
+    }
+    let modified = metadata.modified().ok();
+    let mut bytes = Vec::new();
+    let mut buffer = [0_u8; 16 * 1024];
+    loop {
+        control
+            .check()
+            .map_err(|_| io::Error::other("provider read stopped"))?;
+        let available = (limit + 1 - bytes.len() as u64).min(buffer.len() as u64) as usize;
+        let count = file.read(&mut buffer[..available])?;
+        if count == 0 {
+            break;
+        }
+        if bytes.len() as u64 + count as u64 > limit {
+            return Err(io::Error::other("provider exceeds parser byte limit"));
+        }
+        let required = bytes.len() + count;
+        if required > bytes.capacity() {
+            let capacity = bytes
+                .capacity()
+                .saturating_mul(2)
+                .max(required)
+                .min(limit as usize);
+            bytes
+                .try_reserve_exact(capacity - bytes.len())
+                .map_err(|_| io::Error::other("provider input allocation failed"))?;
+        }
+        bytes.extend_from_slice(&buffer[..count]);
+    }
+    control
+        .check()
+        .map_err(|_| io::Error::other("provider read stopped"))?;
+    Ok((bytes, modified))
+}
+fn metadata_path(path: &Path) -> PathBuf {
+    let mut name = path.as_os_str().to_owned();
+    name.push(".metadata.json");
+    PathBuf::from(name)
+}
+fn temporary_path(path: &Path) -> PathBuf {
+    let mut name = path.as_os_str().to_owned();
+    name.push(format!(
+        ".{}.{}.tmp",
+        std::process::id(),
+        NEXT_FILE.fetch_add(1, Ordering::Relaxed)
+    ));
+    PathBuf::from(name)
+}
+fn write_metadata(path: &Path, metadata: &Metadata) -> io::Result<()> {
+    let staged = stage_metadata(path, metadata)?;
+    fs::rename(staged.0.as_ref().unwrap(), metadata_path(path))
+}
+
+fn stage_metadata(path: &Path, metadata: &Metadata) -> io::Result<TemporaryFile> {
+    let staged = TemporaryFile(Some(temporary_path(&metadata_path(path))));
+    fs::write(
+        staged.0.as_ref().unwrap(),
+        serde_json::to_vec(metadata).map_err(io::Error::other)?,
+    )?;
+    Ok(staged)
+}
+
+fn commit_download(path: &Path, temporary: &Path, metadata: &Metadata) -> io::Result<()> {
+    let staged = stage_metadata(path, metadata)?;
+    let mut previous = TemporaryFile(None);
+    match fs::metadata(path) {
+        Ok(file) if file.is_file() => {
+            let backup = temporary_path(path);
+            fs::rename(path, &backup)?;
+            previous.0 = Some(backup);
+        }
+        Ok(_) => return Err(io::Error::other("provider cache must be a regular file")),
+        Err(error) if error.kind() == io::ErrorKind::NotFound => {}
+        Err(error) => return Err(error),
+    }
+    let mut installed = false;
+    let result = fs::rename(temporary, path).and_then(|()| {
+        installed = true;
+        fs::rename(staged.0.as_ref().unwrap(), metadata_path(path))
+    });
+    if let Err(error) = result {
+        // Keep the old body and sidecar paired if either publication fails.
+        // A rollback failure retains its backup for recovery instead of deleting it.
+        if let Some(backup) = previous.0.take() {
+            fs::rename(backup, path)
+                .map_err(|_| io::Error::other("provider cache rollback failed"))?;
+        } else if installed {
+            fs::remove_file(path)?;
+        }
+        return Err(error);
+    }
+    Ok(())
+}
+pub(crate) fn resource_path(root: &Path, path: &str, create: bool) -> io::Result<PathBuf> {
+    ProviderPaths::default().resolve(
+        root,
+        Path::new(path),
+        if create {
+            Access::CacheWrite
+        } else {
+            Access::FileRead
+        },
+    )
+}
+
+impl std::fmt::Debug for ProviderCache {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ProviderCache")
+            .field("entries", &self.entries.len())
+            .finish_non_exhaustive()
+    }
+}
+
+fn hex(bytes: &[u8]) -> String {
+    bytes.iter().map(|byte| format!("{byte:02x}")).collect()
+}
+
+struct TemporaryFile(Option<PathBuf>);
+impl Drop for TemporaryFile {
+    fn drop(&mut self) {
+        if let Some(path) = &self.0 {
+            let _ = fs::remove_file(path);
+        }
+    }
+}
+
+#[cfg(test)]
+#[path = "cache_tests.rs"]
+mod tests;
diff --git a/src/resource/cache_tests.rs b/src/resource/cache_tests.rs
new file mode 100644
index 0000000..d7240bc
--- /dev/null
+++ b/src/resource/cache_tests.rs
@@ -0,0 +1,964 @@
+//! Provider state transactions using in-memory HTTP streams and temporary files.
+use super::*;
+use crate::{
+    config::Config,
+    dispatch::{BoxStream, DatagramTransport, DispatchError},
+    session::{DatagramSession, StreamSession},
+};
+use async_trait::async_trait;
+use std::{collections::VecDeque, sync::Mutex};
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+struct Responses(Mutex<VecDeque<Vec<u8>>>);
+
+#[async_trait]
+impl Dispatcher for Responses {
+    async fn connect_tcp(&self, _: StreamSession) -> Result<BoxStream, DispatchError> {
+        let response = self
+            .0
+            .lock()
+            .unwrap()
+            .pop_front()
+            .expect("scripted response");
+        let (client, mut peer) = tokio::io::duplex(16 * 1024);
+        tokio::spawn(async move {
+            let mut request = Vec::new();
+            let mut byte = [0];
+            while peer.read_exact(&mut byte).await.is_ok() {
+                request.push(byte[0]);
+                if request.ends_with(b"\r\n\r\n") {
+                    break;
+                }
+            }
+            let _ = peer.write_all(&response).await;
+            let _ = peer.shutdown().await;
+        });
+        Ok(Box::new(client))
+    }
+
+    async fn open_datagram(
+        &self,
+        _: DatagramSession,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        Err(DispatchError::NotAllowed)
+    }
+}
+
+fn response(status: u16, header: &str, body: &str) -> Vec<u8> {
+    format!(
+        "HTTP/1.1 {status} fixture\r\nETag: \"fixture\"\r\n{header}Content-Length: {}\r\n\r\n{body}",
+        body.len()
+    )
+    .into_bytes()
+}
+
+fn template() -> Arc<ProviderTemplate> {
+    Config::parse_yaml(
+        br#"
+mixed-port: 1080
+proxy-providers:
+  remote: {type: http, url: 'http://subscription.invalid/nodes.yaml', path: nodes.yaml}
+proxy-groups:
+  - {name: choice, type: select, use: [remote]}
+"#,
+    )
+    .unwrap()
+    .providers
+    .unwrap()
+}
+
+async fn fetch(cache: &mut ProviderCache, response: Vec<u8>) -> io::Result<Option<Candidate>> {
+    let user_agent = cache.template.request_user_agent();
+    cache
+        .fetch(
+            0,
+            Arc::new(Responses(Mutex::new([response].into()))),
+            user_agent,
+            true,
+            crate::security::SecurityContext::new(),
+            CancellationToken::new(),
+        )
+        .await
+}
+
+fn commit_valid(cache: &mut ProviderCache, candidate: Candidate) {
+    let mut contents = cache.contents.clone();
+    contents.insert(cache.entries[0].key.clone(), candidate.content.clone());
+    cache.template.materialize(&contents).unwrap();
+    cache
+        .commit(0, candidate, &CancellationToken::new())
+        .unwrap();
+}
+
+#[tokio::test]
+async fn default_http_cache_paths_isolate_effective_requests_across_restart_and_fetch_failure() {
+    for rule in [false, true] {
+        let root = tempfile::tempdir().unwrap();
+        let configured = |user_agent| {
+            let kind = if rule { "rule" } else { "proxy" };
+            let behavior = if rule { ", behavior: domain" } else { "" };
+            let usage = if rule {
+                "rules: ['RULE-SET,first,DIRECT', 'RULE-SET,second,REJECT']"
+            } else {
+                "proxy-groups: [{name: choice, type: select, use: [first, second]}]"
+            };
+            Config::parse_yaml(
+                format!(
+                    "global-ua: {user_agent}\n{kind}-providers:\n  first: {{type: http, url: 'http://subscription.invalid/shared', header: {{Authorization: ['Bearer first']}}{behavior}}}\n  second: {{type: http, url: 'http://subscription.invalid/shared', header: {{Authorization: ['Bearer second']}}{behavior}}}\n{usage}\n"
+                )
+                .as_bytes(),
+            )
+            .unwrap()
+            .providers
+            .unwrap()
+        };
+        let template = configured("fixture-agent");
+        let mut cache = ProviderCache::open(root.path(), template.clone()).unwrap();
+        let paths = cache
+            .entries
+            .iter()
+            .map(|entry| entry.path.clone().unwrap())
+            .collect::<Vec<_>>();
+        let payloads = if rule {
+            ["payload: [first.example]", "payload: [second.example]"]
+        } else {
+            [
+                "proxies: [{name: first-node, type: direct}]",
+                "proxies: [{name: second-node, type: direct}]",
+            ]
+        };
+        for (index, body) in payloads.iter().enumerate() {
+            let candidate = cache
+                .fetch(
+                    index,
+                    Arc::new(Responses(Mutex::new([response(200, "", body)].into()))),
+                    template.request_user_agent(),
+                    true,
+                    crate::security::SecurityContext::new(),
+                    CancellationToken::new(),
+                )
+                .await
+                .unwrap()
+                .unwrap();
+            cache
+                .commit(index, candidate, &CancellationToken::new())
+                .unwrap();
+        }
+        template.materialize(&cache.contents).unwrap();
+        let expected = cache.contents.clone();
+        let mut restored = ProviderCache::open(root.path(), template.clone()).unwrap();
+        assert_eq!(restored.contents, expected);
+        assert_ne!(paths[0], paths[1]);
+        for (index, body) in payloads.iter().enumerate() {
+            let entry = &restored.entries[index];
+            assert_eq!(entry.path.as_ref(), Some(&paths[index]));
+            assert!(entry.state.downloaded);
+            assert_eq!(fs::read_to_string(&paths[index]).unwrap(), *body);
+            let metadata: Metadata =
+                serde_json::from_slice(&fs::read(metadata_path(&paths[index])).unwrap()).unwrap();
+            assert_eq!(
+                metadata.url,
+                source_key(&entry.spec, &template.request_user_agent()).unwrap()
+            );
+            assert!(
+                restored
+                    .fetch(
+                        index,
+                        Arc::new(Responses(Mutex::new([response(503, "", "")].into()))),
+                        template.request_user_agent(),
+                        true,
+                        crate::security::SecurityContext::new(),
+                        CancellationToken::new(),
+                    )
+                    .await
+                    .is_err()
+            );
+        }
+        assert_eq!(restored.contents, expected);
+        template.materialize(&restored.contents).unwrap();
+
+        let changed = ProviderCache::open(root.path(), configured("other-agent")).unwrap();
+        for (index, entry) in changed.entries.iter().enumerate() {
+            assert_ne!(entry.path.as_ref(), Some(&paths[index]));
+            assert!(!entry.state.available);
+        }
+    }
+}
+
+#[tokio::test]
+async fn file_candidate_keeps_read_mtime_when_source_is_replaced_before_commit() {
+    for rules in [false, true] {
+        let root = tempfile::tempdir().unwrap();
+        let path = root.path().join("provider.yaml");
+        let template = Config::parse_yaml(
+            if rules {
+                "rule-providers: {remote: {type: file, path: provider.yaml, behavior: domain}}\nrules: ['RULE-SET,remote,DIRECT']\n"
+            } else {
+                "proxy-providers: {remote: {type: file, path: provider.yaml}}\nproxy-groups: [{name: choice, type: select, use: [remote]}]\n"
+            }
+            .as_bytes(),
+        )
+        .unwrap()
+        .providers
+        .unwrap();
+        let write = |file: &Path, count, seconds| {
+            let items = (0..count)
+                .map(|index| {
+                    if rules {
+                        format!("domain{index}.example")
+                    } else {
+                        format!("{{name: node{index}, type: direct}}")
+                    }
+                })
+                .collect::<Vec<_>>()
+                .join(", ");
+            fs::write(
+                file,
+                format!("{}: [{items}]", if rules { "payload" } else { "proxies" }),
+            )
+            .unwrap();
+            let modified = UNIX_EPOCH + Duration::from_secs(seconds);
+            fs::OpenOptions::new()
+                .write(true)
+                .open(file)
+                .unwrap()
+                .set_modified(modified)
+                .unwrap();
+            assert_eq!(fs::metadata(file).unwrap().modified().unwrap(), modified);
+            modified
+        };
+        let initial_time = write(&path, 1, 1000);
+        let mut cache = ProviderCache::open(root.path(), template).unwrap();
+        assert_eq!(cache.entries[0].modified, Some(initial_time));
+        let fetched_time = write(&path, 2, 2000);
+        let candidate = fetch(&mut cache, Vec::new()).await.unwrap().unwrap();
+        assert_eq!(content_len(&candidate.content), 2);
+
+        // Graph preparation can yield while an editor atomically replaces the file.
+        let replacement = root.path().join("replacement.yaml");
+        let replacement_time = write(&replacement, 3, 3000);
+        fs::rename(&replacement, &path).unwrap();
+        commit_valid(&mut cache, candidate);
+        assert_eq!(content_len(&cache.contents[&cache.entries[0].key]), 2);
+        assert_eq!(cache.entries[0].modified, Some(fetched_time));
+
+        let replacement = fetch(&mut cache, Vec::new())
+            .await
+            .unwrap()
+            .expect("the replacement must remain detectable after the older candidate commits");
+        assert_eq!(content_len(&replacement.content), 3);
+        commit_valid(&mut cache, replacement);
+        assert_eq!(cache.entries[0].modified, Some(replacement_time));
+        assert_eq!(content_len(&cache.contents[&cache.entries[0].key]), 3);
+        assert!(fetch(&mut cache, Vec::new()).await.unwrap().is_none());
+    }
+}
+
+#[tokio::test]
+async fn uri_provider_candidate_keeps_filters_override_and_authenticated_cache_identity() {
+    let root = tempfile::tempdir().unwrap();
+    let configured = |password: &str| {
+        Config::parse_yaml(
+            format!(
+                r#"
+proxy-providers:
+  remote:
+    type: http
+    url: 'http://subscriber:{password}@subscription.invalid/nodes?token=private'
+    path: nodes
+    filter: '^edge$'
+    override: {{additional-prefix: 'chosen-', interface-name: eth0}}
+proxy-groups:
+  - {{name: choice, type: select, use: [remote]}}
+"#
+            )
+            .as_bytes(),
+        )
+        .unwrap()
+        .providers
+        .unwrap()
+    };
+    let source = configured("first");
+    let mut cache = ProviderCache::open(root.path(), source.clone()).unwrap();
+    let uri = "socks5://candidate-user:candidate-password@192.0.2.1:1080#edge\nsocks5://192.0.2.2:1080#other\n";
+    let candidate = fetch(
+        &mut cache,
+        response(200, "Subscription-Userinfo: upload=7\r\n", uri),
+    )
+    .await
+    .unwrap()
+    .unwrap();
+    let debug = format!("{:?}", candidate.content);
+    assert!(!debug.contains("candidate-password"));
+    assert!(!debug.contains("192.0.2.1"));
+    let mut contents = cache.contents.clone();
+    contents.insert(cache.entries[0].key.clone(), candidate.content.clone());
+    let config = cache.template.materialize(&contents).unwrap();
+    assert_eq!(config.proxies.len(), 1);
+    assert_eq!(config.proxies[0].tag, "chosen-edge");
+    commit_valid(&mut cache, candidate);
+    let path = root.path().join("nodes");
+    let sidecar = metadata_path(&path);
+    let old_body = fs::read(&path).unwrap();
+    let old_metadata = fs::read(&sidecar).unwrap();
+    let visible = String::from_utf8(old_metadata.clone()).unwrap();
+    for secret in ["subscriber", "first", "private", "subscription.invalid"] {
+        assert!(!visible.contains(secret));
+    }
+    let mut legacy: serde_json::Value = serde_json::from_slice(&old_metadata).unwrap();
+    legacy["url"] = serde_json::json!(http::source_identity(&source.proxies[0].1.url));
+    fs::write(&sidecar, serde_json::to_vec(&legacy).unwrap()).unwrap();
+    let upgraded = ProviderCache::open(root.path(), source.clone()).unwrap();
+    assert!(upgraded.entries[0].state.available);
+    assert!(!upgraded.entries[0].state.downloaded);
+    assert_eq!(upgraded.entries[0].metadata.etag, None);
+    fs::write(&sidecar, &old_metadata).unwrap();
+    let mut header_source = source.as_ref().clone();
+    header_source.proxies[0]
+        .1
+        .header
+        .insert("Authorization".into(), vec!["Bearer changed".into()]);
+    // URL Basic wins over this unused header, so its actual request is unchanged.
+    assert!(
+        ProviderCache::open(root.path(), Arc::new(header_source))
+            .unwrap()
+            .entries[0]
+            .state
+            .downloaded
+    );
+    let mut cookie_source = source.as_ref().clone();
+    cookie_source.proxies[0]
+        .1
+        .header
+        .insert("Cookie".into(), vec!["subscription=different".into()]);
+    let cookie_cache = ProviderCache::open(root.path(), Arc::new(cookie_source)).unwrap();
+    assert!(cookie_cache.entries[0].state.available);
+    assert!(!cookie_cache.entries[0].state.downloaded);
+    assert_eq!(cookie_cache.entries[0].metadata.etag, None);
+    let mut cache = ProviderCache::open(root.path(), configured("second")).unwrap();
+    assert!(cache.entries[0].state.available);
+    assert!(!cache.entries[0].state.downloaded);
+    assert_eq!(cache.entries[0].metadata.etag, None);
+    assert_eq!(cache.entries[0].state.subscription_info, None);
+    // A validator from a different credential identity cannot authorize 304.
+    assert!(fetch(&mut cache, response(304, "", "")).await.is_err());
+    assert_eq!(fs::read(&path).unwrap(), old_body);
+    assert_eq!(fs::read(&sidecar).unwrap(), old_metadata);
+    assert!(
+        fetch(
+            &mut cache,
+            response(
+                200,
+                "Subscription-Userinfo: upload=99\r\n",
+                "socks5://private-password@invalid"
+            )
+        )
+        .await
+        .is_err()
+    );
+    assert_eq!(fs::read(&path).unwrap(), old_body);
+    assert_eq!(fs::read(&sidecar).unwrap(), old_metadata);
+    let mut restored = ProviderCache::open(root.path(), source).unwrap();
+    assert_eq!(
+        restored.entries[0].state.subscription_info.unwrap().upload,
+        7
+    );
+    assert!(
+        fetch(
+            &mut restored,
+            response(304, "Subscription-Userinfo: upload=9\r\n", "")
+        )
+        .await
+        .unwrap()
+        .is_none()
+    );
+    assert_eq!(
+        restored.entries[0].state.subscription_info.unwrap().upload,
+        9
+    );
+}
+
+#[test]
+fn age_then_base64_uri_provider_uses_the_existing_candidate_parser() {
+    use base64::Engine as _;
+    use std::io::Write;
+    let secret = include_str!("../../tests/fixtures/provider-age/x25519.key").trim();
+    let identity = secret.parse::<age::x25519::Identity>().unwrap();
+    let encryptor = age::Encryptor::with_recipients(std::iter::once(
+        &identity.to_public() as &dyn age::Recipient
+    ))
+    .unwrap();
+    let mut encrypted = Vec::new();
+    let armor =
+        age::armor::ArmoredWriter::wrap_output(&mut encrypted, age::armor::Format::AsciiArmor)
+            .unwrap();
+    let mut writer = encryptor.wrap_output(armor).unwrap();
+    writer
+        .write_all(
+            base64::engine::general_purpose::STANDARD
+                .encode("socks5://192.0.2.1:1080#edge")
+                .as_bytes(),
+        )
+        .unwrap();
+    writer.finish().unwrap().finish().unwrap();
+    let mut template = template();
+    Arc::make_mut(&mut template).proxies[0].1.age_identities =
+        super::super::age_provider::Identities::from_value(serde_yaml_ng::Value::String(
+            secret.into(),
+        ))
+        .unwrap();
+    let content = template
+        .parse_content(&template.proxies[0].1, &encrypted)
+        .unwrap();
+    assert!(
+        matches!(content,ProviderContent::Proxies(ref proxies) if proxies.len()==1 && proxies[0]["name"].as_str()==Some("edge"))
+    );
+    let mut contents = ProviderContents::new();
+    contents.insert(
+        ProviderTemplate::key(false, &template.proxies[0].0),
+        content,
+    );
+    assert_eq!(template.materialize(&contents).unwrap().proxies.len(), 1);
+}
+
+#[tokio::test]
+async fn bundle_cache_precedes_archive_and_bad_cache_falls_back_before_http() {
+    let root = tempfile::tempdir().unwrap();
+    let template = Config::parse_yaml(br#"
+mixed-port: 1080
+rule-providers:
+  offline: {type: http, url: 'http://rules.invalid/current.mrs', path: rules.mrs, behavior: ipcidr, format: mrs, path-in-bundle: rules/cn.mrs}
+rules: ['RULE-SET,offline,DIRECT']
+"#).unwrap().providers.unwrap();
+    let member = crate::resource::bundle::tests::mrs();
+    let bundle = crate::resource::bundle::tests::archive(&member, true);
+    let archive_path = root.path().join("BundleMRS.7z");
+    let cache_path = root.path().join("rules.mrs");
+    fs::write(&archive_path, &bundle).unwrap();
+    fs::write(&cache_path, b"invalid cached MRS").unwrap();
+    let mut cache = ProviderCache::open(root.path(), template.clone()).unwrap();
+    assert!(cache.entries[0].state.available);
+    assert!(!cache.entries[0].state.downloaded);
+    assert!(cache.entries[0].metadata.bundled);
+    assert_eq!(cache.entries[0].metadata.etag, None);
+    assert_eq!(cache.next_due(), Some(0));
+    assert_eq!(fs::read(&cache_path).unwrap(), member);
+    assert_eq!(cache.entries[0].state.error, None);
+    cache.template.materialize(&cache.contents).unwrap();
+
+    // A valid local cache avoids archive parsing and still owes its first real
+    // HTTP fetch when the cached bytes were extracted from the bundle.
+    fs::write(&archive_path, b"broken archive").unwrap();
+    cache = ProviderCache::open(root.path(), template.clone()).unwrap();
+    assert!(!cache.entries[0].state.downloaded);
+    assert_eq!(cache.next_due(), Some(0));
+
+    // Bad cache and invalid bundled MRS leave the HTTP vehicle available.
+    fs::write(&cache_path, b"bad cache").unwrap();
+    fs::write(
+        &archive_path,
+        crate::resource::bundle::tests::archive(b"bad MRS", false),
+    )
+    .unwrap();
+    cache = ProviderCache::open(root.path(), template.clone()).unwrap();
+    assert!(!cache.entries[0].state.available);
+    assert_eq!(cache.next_due(), Some(0));
+    let mut reply = format!(
+        "HTTP/1.1 200 fixture\r\nETag: \"remote\"\r\nContent-Length: {}\r\n\r\n",
+        member.len()
+    )
+    .into_bytes();
+    reply.extend_from_slice(&member);
+    let candidate = fetch(&mut cache, reply).await.unwrap().unwrap();
+    commit_valid(&mut cache, candidate);
+    assert!(cache.entries[0].state.downloaded);
+    assert!(!cache.entries[0].metadata.bundled);
+    assert_eq!(
+        cache.entries[0].metadata.etag.as_deref(),
+        Some("\"remote\"")
+    );
+    assert_eq!(cache.next_refresh(), None);
+    let cache = ProviderCache::open(root.path(), template).unwrap();
+    assert!(cache.entries[0].state.downloaded);
+    assert!(!cache.entries[0].metadata.bundled);
+}
+
+#[tokio::test(start_paused = true)]
+async fn refresh_deadline_preserves_fetch_completion_phase_and_zero_disables_polling() {
+    let root = tempfile::tempdir().unwrap();
+    let mut cache = ProviderCache::open(root.path(), template()).unwrap();
+    cache.entries[0].spec.interval = 1;
+    let started = tokio::time::Instant::now();
+    let candidate = fetch(
+        &mut cache,
+        response(
+            200,
+            "",
+            "proxies: [{name: edge, type: socks5, server: 192.0.2.1, port: 1080}]",
+        ),
+    )
+    .await
+    .unwrap()
+    .unwrap();
+    // Publication completes just after a fixed one-second poll boundary.
+    tokio::time::advance(Duration::from_millis(20)).await;
+    commit_valid(&mut cache, candidate);
+    let deadline = started + Duration::from_millis(1020);
+    assert_eq!(cache.next_refresh(), Some((0, deadline)));
+    tokio::time::advance(Duration::from_millis(980)).await;
+    assert_eq!(cache.next_due(), None);
+    tokio::time::sleep_until(cache.next_refresh().unwrap().1).await;
+    assert_eq!(tokio::time::Instant::now(), deadline);
+    assert_eq!(cache.next_due(), Some(0));
+    assert!(
+        fetch(&mut cache, response(304, "", ""))
+            .await
+            .unwrap()
+            .is_none()
+    );
+    assert_eq!(
+        cache.next_refresh(),
+        Some((0, deadline + Duration::from_secs(1)))
+    );
+    cache.entries[0].spec.interval = 0;
+    assert_eq!(cache.next_refresh(), None);
+    assert_eq!(cache.next_due(), None);
+}
+
+#[tokio::test(start_paused = true)]
+async fn refresh_deadline_selects_oldest_due_provider_and_keeps_failure_backoff() {
+    let root = tempfile::tempdir().unwrap();
+    let template = Config::parse_yaml(
+        br#"
+mixed-port: 1080
+proxy-providers:
+  a: {type: http, url: 'http://subscription.invalid/a', interval: 1}
+  b: {type: http, url: 'http://subscription.invalid/b', interval: 1}
+proxy-groups:
+  - {name: choice, type: select, use: [a, b]}
+"#,
+    )
+    .unwrap()
+    .providers
+    .unwrap();
+    let mut cache = ProviderCache::open(root.path(), template).unwrap();
+    let started = tokio::time::Instant::now();
+    cache.entries[0].next = started + Duration::from_secs(2);
+    cache.entries[1].next = started + Duration::from_secs(1);
+    assert_eq!(
+        cache.next_refresh(),
+        Some((1, started + Duration::from_secs(1)))
+    );
+    tokio::time::advance(Duration::from_secs(2)).await;
+    assert_eq!(cache.next_due(), Some(1));
+    cache.reject(1);
+    assert_eq!(cache.next_due(), Some(0));
+    cache.entries[0].state.downloaded = true;
+    cache.entries[0].spec.interval = 0;
+    assert_eq!(cache.next_due(), None);
+    assert_eq!(
+        cache.next_refresh(),
+        Some((1, started + Duration::from_secs(12)))
+    );
+    cache.entries[1].spec.kind = ProviderType::Inline;
+    assert_eq!(cache.next_refresh(), None);
+}
+
+#[tokio::test]
+async fn subscription_metadata_follows_successful_candidates_304_and_verified_disk_cache() {
+    let root = tempfile::tempdir().unwrap();
+    let template = template();
+    let mut cache = ProviderCache::open(root.path(), template.clone()).unwrap();
+    assert!(
+        serde_json::to_value(&cache.entries[0].state)
+            .unwrap()
+            .get("subscriptionInfo")
+            .is_none()
+    );
+    let old = "proxies: [{name: old, type: socks5, server: 192.0.2.1, port: 1080}]";
+    let new = "proxies: [{name: new, type: socks5, server: 192.0.2.2, port: 1080}]";
+    let info = |upload| SubscriptionInfo {
+        upload,
+        ..Default::default()
+    };
+    let candidate = fetch(
+        &mut cache,
+        response(200, "Subscription-Userinfo: upload=1\r\n", old),
+    )
+    .await
+    .unwrap()
+    .unwrap();
+    assert_eq!(cache.entries[0].state.subscription_info, None);
+    commit_valid(&mut cache, candidate);
+    assert_eq!(cache.entries[0].state.subscription_info, Some(info(1)));
+    assert_eq!(
+        serde_json::to_value(&cache.entries[0].state).unwrap()["subscriptionInfo"],
+        serde_json::json!({"Upload":1,"Download":0,"Total":0,"Expire":0})
+    );
+
+    let previous_content = cache.contents[&cache.entries[0].key].clone();
+    assert!(
+        fetch(
+            &mut cache,
+            response(304, "Subscription-Userinfo: upload=2\r\n", "")
+        )
+        .await
+        .unwrap()
+        .is_none()
+    );
+    assert_eq!(cache.entries[0].state.subscription_info, Some(info(2)));
+    assert_eq!(
+        fs::read_to_string(root.path().join("nodes.yaml")).unwrap(),
+        old
+    );
+    assert_eq!(content_len(&previous_content), cache.entries[0].state.count);
+    let restored = ProviderCache::open(root.path(), template.clone()).unwrap();
+    assert_eq!(restored.entries[0].state.subscription_info, Some(info(2)));
+
+    assert!(
+        fetch(&mut cache, response(304, "", ""))
+            .await
+            .unwrap()
+            .is_none()
+    );
+    let candidate = fetch(&mut cache, response(200, "", new))
+        .await
+        .unwrap()
+        .unwrap();
+    commit_valid(&mut cache, candidate);
+    assert_eq!(cache.entries[0].state.subscription_info, Some(info(2)));
+    let saved_metadata = fs::read(metadata_path(&root.path().join("nodes.yaml"))).unwrap();
+
+    let candidate = fetch(
+        &mut cache,
+        response(200, "Subscription-Userinfo: upload=77\r\n", old),
+    )
+    .await
+    .unwrap()
+    .unwrap();
+    fs::remove_file(candidate.temporary.as_ref().unwrap()).unwrap();
+    assert!(
+        cache
+            .commit(0, candidate, &CancellationToken::new())
+            .is_err()
+    );
+    assert_eq!(
+        fs::read(metadata_path(&root.path().join("nodes.yaml"))).unwrap(),
+        saved_metadata
+    );
+    assert_eq!(
+        fs::read_to_string(root.path().join("nodes.yaml")).unwrap(),
+        new
+    );
+    assert!(
+        fetch(
+            &mut cache,
+            response(500, "Subscription-Userinfo: upload=66\r\n", "")
+        )
+        .await
+        .is_err()
+    );
+
+    assert!(
+        fetch(
+            &mut cache,
+            response(
+                200,
+                "Subscription-Userinfo: upload=99\r\n",
+                "not a provider"
+            )
+        )
+        .await
+        .is_err()
+    );
+    let candidate = fetch(&mut cache, response(200, "Subscription-Userinfo: upload=88\r\n", "proxies: [{name: cycle, type: socks5, server: 192.0.2.1, port: 1080, dialer-proxy: cycle}]")).await.unwrap().unwrap();
+    let mut proposed = cache.contents.clone();
+    proposed.insert(cache.entries[0].key.clone(), candidate.content.clone());
+    assert!(template.materialize(&proposed).is_err());
+    cache.reject(0);
+    drop(candidate);
+    assert_eq!(cache.entries[0].state.subscription_info, Some(info(2)));
+    assert_eq!(
+        fs::read(metadata_path(&root.path().join("nodes.yaml"))).unwrap(),
+        saved_metadata
+    );
+    assert_eq!(
+        fs::read_to_string(root.path().join("nodes.yaml")).unwrap(),
+        new
+    );
+    assert_eq!(
+        ProviderCache::open(root.path(), template.clone())
+            .unwrap()
+            .entries[0]
+            .state
+            .subscription_info,
+        Some(info(2))
+    );
+
+    // A valid file with a stale sidecar is usable, but its subscription data is untrusted.
+    fs::write(root.path().join("nodes.yaml"), old).unwrap();
+    let restored = ProviderCache::open(root.path(), template.clone()).unwrap();
+    assert!(restored.entries[0].state.available);
+    assert_eq!(restored.entries[0].state.subscription_info, None);
+
+    fs::write(root.path().join("nodes.yaml"), new).unwrap();
+    let mut legacy: serde_json::Value = serde_json::from_slice(&saved_metadata).unwrap();
+    legacy.as_object_mut().unwrap().remove("subscription_info");
+    fs::write(
+        metadata_path(&root.path().join("nodes.yaml")),
+        serde_json::to_vec(&legacy).unwrap(),
+    )
+    .unwrap();
+    let legacy = ProviderCache::open(root.path(), template).unwrap();
+    assert!(legacy.entries[0].state.available);
+    assert_eq!(legacy.entries[0].state.subscription_info, None);
+}
+
+#[tokio::test]
+async fn failed_304_sidecar_write_does_not_publish_subscription_metadata() {
+    let root = tempfile::tempdir().unwrap();
+    let mut cache = ProviderCache::open(root.path(), template()).unwrap();
+    let body = "proxies: [{name: edge, type: socks5, server: 192.0.2.1, port: 1080}]";
+    let candidate = fetch(
+        &mut cache,
+        response(200, "Subscription-Userinfo: upload=1\r\n", body),
+    )
+    .await
+    .unwrap()
+    .unwrap();
+    commit_valid(&mut cache, candidate);
+    let path = metadata_path(&root.path().join("nodes.yaml"));
+    fs::remove_file(&path).unwrap();
+    fs::create_dir(&path).unwrap();
+    assert!(
+        fetch(
+            &mut cache,
+            response(304, "Subscription-Userinfo: upload=99\r\n", "")
+        )
+        .await
+        .is_err()
+    );
+    assert_eq!(
+        cache.entries[0].metadata.subscription_info.unwrap().upload,
+        1
+    );
+    assert_eq!(cache.entries[0].state.subscription_info.unwrap().upload, 1);
+    let candidate = fetch(
+        &mut cache,
+        response(
+            200,
+            "Subscription-Userinfo: upload=88\r\n",
+            "proxies: [{name: replacement, type: socks5, server: 192.0.2.2, port: 1080}]",
+        ),
+    )
+    .await
+    .unwrap()
+    .unwrap();
+    assert!(
+        cache
+            .commit(0, candidate, &CancellationToken::new())
+            .is_err()
+    );
+    assert_eq!(cache.entries[0].state.subscription_info.unwrap().upload, 1);
+    assert_eq!(
+        fs::read_to_string(root.path().join("nodes.yaml")).unwrap(),
+        body
+    );
+}
+
+#[tokio::test]
+async fn age_provider_cache_and_file_refresh_preserve_candidate_contract() {
+    let root = tempfile::tempdir().unwrap();
+    let mut template = template();
+    Arc::make_mut(&mut template).proxies[0].1.age_identities =
+        super::super::age_provider::Identities::from_value(serde_yaml_ng::Value::String(
+            include_str!("../../tests/fixtures/provider-age/x25519.key").into(),
+        ))
+        .unwrap();
+    let ciphertext = include_str!("../../tests/fixtures/provider-age/x25519.age");
+    let mut cache = ProviderCache::open(root.path(), template.clone()).unwrap();
+    let candidate = fetch(&mut cache, response(200, "", ciphertext))
+        .await
+        .unwrap()
+        .unwrap();
+    assert_eq!(
+        candidate.metadata.hash,
+        hex(&Sha256::digest(ciphertext.as_bytes()))
+    );
+    commit_valid(&mut cache, candidate);
+    let old = cache.contents.clone();
+    let cache_path = cache.entries[0].path.as_ref().unwrap().clone();
+    assert_eq!(fs::read(&cache_path).unwrap(), ciphertext.as_bytes());
+    let recovered = ProviderCache::open(root.path(), template).unwrap();
+    assert_eq!(recovered.contents, old);
+    assert_eq!(
+        recovered.entries[0].metadata.etag.as_deref(),
+        Some("\"fixture\"")
+    );
+    let wrong_recipient = include_str!("../../tests/fixtures/provider-age/hybrid.age");
+    assert!(
+        fetch(&mut cache, response(200, "", wrong_recipient))
+            .await
+            .is_err()
+    );
+    assert_eq!(cache.contents, old);
+    assert_eq!(fs::read(&cache_path).unwrap(), ciphertext.as_bytes());
+    assert!(cache.entries[0].state.available);
+    assert_eq!(
+        cache.entries[0].metadata.etag.as_deref(),
+        Some("\"fixture\"")
+    );
+    let cancellation = CancellationToken::new();
+    cancellation.cancel();
+    let stopped =
+        ProviderCache::open_with_cancel(root.path(), cache.template.clone(), Some(&cancellation));
+    assert_eq!(stopped.err().unwrap().kind(), io::ErrorKind::Interrupted);
+    let mut file_template = cache.template.as_ref().clone();
+    file_template.proxies[0].1.kind = ProviderType::File;
+    file_template.proxies[0].1.url.clear();
+    let mut file_cache = ProviderCache::open(root.path(), Arc::new(file_template)).unwrap();
+    assert_eq!(file_cache.contents, old);
+    file_cache.entries[0].modified = None;
+    let candidate = fetch(&mut file_cache, Vec::new()).await.unwrap().unwrap();
+    commit_valid(&mut file_cache, candidate);
+    assert_eq!(file_cache.contents, old);
+    fs::write(&cache_path, wrong_recipient).unwrap();
+    file_cache.entries[0].modified = None;
+    assert!(fetch(&mut file_cache, Vec::new()).await.is_err());
+    assert_eq!(file_cache.contents, old);
+    assert!(file_cache.entries[0].state.available);
+}
+
+#[test]
+fn configuration_candidate_reads_bundle_without_persisting_body_or_metadata() {
+    let root = tempfile::tempdir().unwrap();
+    let configured=Config::parse_yaml(br#"
+rule-providers:
+  offline: {type: http, url: 'http://rules.invalid/current.mrs', path: nested/rules.mrs, behavior: ipcidr, format: mrs, path-in-bundle: rules/cn.mrs}
+rules: ['RULE-SET,offline,DIRECT', 'MATCH,DIRECT']
+"#).unwrap().providers.unwrap();
+    let archive =
+        crate::resource::bundle::tests::archive(&crate::resource::bundle::tests::mrs(), true);
+    fs::write(root.path().join("BundleMRS.7z"), archive).unwrap();
+    let cache =
+        ProviderCache::open_candidate(root.path(), configured.clone(), &CancellationToken::new())
+            .unwrap();
+    assert!(cache.entries[0].state.available);
+    assert!(!root.path().join("nested").exists());
+    assert!(cache.template.materialize(&cache.contents).is_ok());
+    cache
+        .prepare_paths(root.path(), &CancellationToken::new())
+        .unwrap();
+    assert!(root.path().join("nested").is_dir());
+    assert!(!root.path().join("nested/rules.mrs").exists());
+    fs::write(
+        root.path().join("nested/rules.mrs"),
+        b"invalid existing body",
+    )
+    .unwrap();
+    let metadata = metadata_path(&root.path().join("nested/rules.mrs"));
+    fs::write(&metadata, b"existing sidecar").unwrap();
+    let second =
+        ProviderCache::open_candidate(root.path(), configured, &CancellationToken::new()).unwrap();
+    assert!(second.entries[0].state.available);
+    assert_eq!(
+        fs::read(root.path().join("nested/rules.mrs")).unwrap(),
+        b"invalid existing body"
+    );
+    assert_eq!(fs::read(metadata).unwrap(), b"existing sidecar");
+}
+
+#[test]
+fn provider_metadata_requires_bounded_regular_files() {
+    let root = tempfile::tempdir().unwrap();
+    let body = root.path().join("nodes.yaml");
+    fs::write(&body, b"proxies: [{name: cached, type: direct}]").unwrap();
+    let sidecar = metadata_path(&body);
+    fs::File::create(&sidecar)
+        .unwrap()
+        .set_len(MAX_METADATA_BYTES + 1)
+        .unwrap();
+    let control = super::super::age_provider::DecodeControl::new(
+        None,
+        std::time::Instant::now() + http::DEFAULT_DOWNLOAD_TIMEOUT,
+    );
+    assert!(read_bounded(&sidecar, MAX_METADATA_BYTES, &control).is_err());
+    let cache = ProviderCache::open(root.path(), template()).unwrap();
+    assert!(cache.entries[0].state.available);
+    assert!(!cache.entries[0].state.downloaded);
+    #[cfg(unix)]
+    {
+        use std::os::unix::ffi::OsStrExt;
+        fs::remove_file(&sidecar).unwrap();
+        let name = std::ffi::CString::new(sidecar.as_os_str().as_bytes()).unwrap();
+        assert_eq!(unsafe { libc::mkfifo(name.as_ptr(), 0o600) }, 0);
+        let cache = ProviderCache::open(root.path(), template()).unwrap();
+        assert!(cache.entries[0].state.available);
+        assert!(!cache.entries[0].state.downloaded);
+    }
+}
+
+#[test]
+fn authorized_provider_roots_read_file_sources_and_write_only_http_caches() {
+    use crate::resource::paths::ProviderPaths;
+    let root = tempfile::tempdir().unwrap();
+    let data = root.path().join("data");
+    let shared = root.path().join("shared");
+    fs::create_dir(&data).unwrap();
+    fs::create_dir(&shared).unwrap();
+    let source = shared.join("source.yaml");
+    let cache_path = shared.join("http/nodes.yaml");
+    let source_bytes = b"proxies: [{name: from-file, type: direct}]";
+    fs::write(&source, source_bytes).unwrap();
+    let document = serde_json::json!({"proxy-providers":{
+        "file":{"type":"file","path":source.to_str().unwrap()},
+        "http":{"type":"http","url":"https://fixture.invalid/nodes","path":cache_path.to_str().unwrap()}
+    },"rules":["MATCH,DIRECT"]}).to_string();
+    let mut template = crate::config::Config::parse_yaml(document.as_bytes())
+        .unwrap()
+        .providers
+        .unwrap();
+    assert!(ProviderCache::open(&data, template.clone()).is_err());
+    let paths =
+        ProviderPaths::from_os_value(Some(std::env::join_paths([&shared]).unwrap()), root.path())
+            .unwrap();
+    Arc::make_mut(&mut template).resource_paths = Arc::new(paths);
+    let mut cache = ProviderCache::open(&data, template.clone()).unwrap();
+    assert!(cache.contents.contains_key("proxies/file"));
+    cache
+        .prepare_paths(&data, &CancellationToken::new())
+        .unwrap();
+    assert_eq!(fs::read(&source).unwrap(), source_bytes);
+    assert!(!metadata_path(&source).exists());
+    let body = b"proxies: [{name: from-http, type: direct}]";
+    let temporary = cache_path.parent().unwrap().join("owned-download.tmp");
+    fs::write(&temporary, body).unwrap();
+    let index = cache
+        .entries
+        .iter()
+        .position(|entry| entry.state.name == "http")
+        .unwrap();
+    let content = template
+        .parse_content(&cache.entries[index].spec, body)
+        .unwrap();
+    cache
+        .commit(
+            index,
+            Candidate {
+                content,
+                temporary: Some(temporary),
+                modified: None,
+                metadata: Metadata {
+                    url: source_key(&cache.entries[index].spec, &template.request_user_agent())
+                        .unwrap(),
+                    hash: hex(&Sha256::digest(body)),
+                    ..Metadata::default()
+                },
+            },
+            &CancellationToken::new(),
+        )
+        .unwrap();
+    assert_eq!(fs::read(&cache_path).unwrap(), body);
+    assert!(metadata_path(&cache_path).is_file());
+    assert_eq!(fs::read(&source).unwrap(), source_bytes);
+}
diff --git a/src/resource/config_apply.rs b/src/resource/config_apply.rs
new file mode 100644
index 0000000..f895623
--- /dev/null
+++ b/src/resource/config_apply.rs
@@ -0,0 +1,310 @@
+//! One bounded configuration-application admission, shared by adapters.
+use serde::Deserialize;
+use std::sync::{Arc, mpsc};
+use tokio::sync::{OwnedSemaphorePermit, Semaphore, mpsc as async_mpsc, oneshot};
+use tokio_util::sync::CancellationToken;
+
+#[derive(Clone)]
+pub(crate) struct ConfigApplyHandle {
+    slots: Arc<Semaphore>,
+    requests: async_mpsc::Sender<ApplyRequest>,
+    cancel: CancellationToken,
+}
+pub(crate) enum ConfigUpdate {
+    #[cfg(any(
+        feature = "outbound-http",
+        feature = "outbound-anytls",
+        feature = "outbound-socks5",
+        feature = "outbound-shadowsocks",
+        feature = "outbound-vless",
+        feature = "outbound-trojan",
+        feature = "outbound-trusttunnel",
+        feature = "outbound-mieru",
+        feature = "outbound-masque",
+        feature = "outbound-vmess",
+        feature = "outbound-hysteria2",
+        feature = "outbound-tuic",
+        feature = "outbound-wireguard"
+    ))]
+    RecoverySnapshot(mpsc::SyncSender<Box<crate::runtime::RecoverySnapshot>>),
+    Replace(String),
+    // An already decoded foreground input uses the same candidate worker.
+    ReplaceTemplate(Arc<crate::config::providers::ProviderTemplate>),
+    ReplaceWithHttp {
+        yaml: String,
+        http: String,
+        base_dir: Option<Option<std::path::PathBuf>>,
+    },
+    Patch(ConfigPatch),
+    RefreshGeoData,
+    RefreshHttp {
+        document: Arc<crate::http_processing::config::Document>,
+        context: crate::http_processing::providers::SourceContext,
+        store: Arc<tokio::sync::Mutex<crate::http_processing::providers::Store>>,
+        force: bool,
+        security: Option<crate::security::SecurityContext>,
+        reply: Option<mpsc::SyncSender<Arc<crate::http_processing::config::PolicyCandidate>>>,
+    },
+    FlushFakeIp,
+}
+#[derive(Deserialize, Default)]
+#[serde(deny_unknown_fields, rename_all = "kebab-case")]
+pub(crate) struct ConfigPatch {
+    pub mode: Option<String>,
+    pub log_level: Option<String>,
+    pub sniffing: Option<bool>,
+    pub tcp_concurrent: Option<bool>,
+    pub find_process_mode: Option<String>,
+    pub interface_name: Option<String>,
+}
+impl ConfigPatch {
+    pub(crate) fn is_empty(&self) -> bool {
+        self.mode.is_none()
+            && self.log_level.is_none()
+            && self.sniffing.is_none()
+            && self.tcp_concurrent.is_none()
+            && self.find_process_mode.is_none()
+            && self.interface_name.is_none()
+    }
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum ApplyError {
+    Busy,
+    Stopped,
+    InvalidConfig,
+    RestartRequired,
+    PreparationFailed,
+    TimedOut,
+}
+impl ApplyError {
+    pub(crate) fn message(self) -> &'static str {
+        match self {
+            Self::Busy => "configuration application is busy",
+            Self::Stopped => "runtime stopped",
+            Self::InvalidConfig => "invalid configuration candidate",
+            Self::RestartRequired => "configuration changes startup resources; reconnect required",
+            Self::PreparationFailed => "configuration candidate preparation failed",
+            Self::TimedOut => "configuration application timed out",
+        }
+    }
+}
+pub(crate) struct ConfigAdmission {
+    requests: async_mpsc::Sender<ApplyRequest>,
+    _slot: OwnedSemaphorePermit,
+    cancel: CancellationToken,
+}
+pub(crate) struct ApplyRequest {
+    update: ConfigUpdate,
+    completion: Completion,
+    cancellation: CancellationToken,
+    _slot: OwnedSemaphorePermit,
+}
+pub(crate) struct PendingApply {
+    asynchronous: Option<oneshot::Receiver<Result<(), ApplyError>>>,
+    synchronous: Option<mpsc::Receiver<Result<(), ApplyError>>>,
+    cancellation: CancellationToken,
+}
+struct Completion {
+    asynchronous: Option<oneshot::Sender<Result<(), ApplyError>>>,
+    synchronous: Option<mpsc::SyncSender<Result<(), ApplyError>>>,
+}
+impl ConfigApplyHandle {
+    // config_apply already requires invoke or test; the outbound condition
+    // completes the same gate used by the runtime module in lib.rs.
+    #[cfg(any(
+        feature = "outbound-http",
+        feature = "outbound-anytls",
+        feature = "outbound-socks5",
+        feature = "outbound-shadowsocks",
+        feature = "outbound-vless",
+        feature = "outbound-trojan",
+        feature = "outbound-trusttunnel",
+        feature = "outbound-mieru",
+        feature = "outbound-masque",
+        feature = "outbound-vmess",
+        feature = "outbound-hysteria2",
+        feature = "outbound-tuic",
+        feature = "outbound-wireguard"
+    ))]
+    pub(crate) fn recovery_snapshot(
+        &self,
+    ) -> Result<Box<crate::runtime::RecoverySnapshot>, ApplyError> {
+        let (send, receive) = mpsc::sync_channel(1);
+        self.try_admit()?
+            .submit(ConfigUpdate::RecoverySnapshot(send))?
+            .wait_blocking()?;
+        receive.recv().map_err(|_| ApplyError::Stopped)
+    }
+    pub(crate) fn channel(cancel: CancellationToken) -> (Self, async_mpsc::Receiver<ApplyRequest>) {
+        let (requests, receiver) = async_mpsc::channel(1);
+        (
+            Self {
+                slots: Arc::new(Semaphore::new(1)),
+                requests,
+                cancel,
+            },
+            receiver,
+        )
+    }
+    pub(crate) fn try_admit(&self) -> Result<ConfigAdmission, ApplyError> {
+        if self.cancel.is_cancelled() {
+            return Err(ApplyError::Stopped);
+        }
+        let slot = self
+            .slots
+            .clone()
+            .try_acquire_owned()
+            .map_err(|_| ApplyError::Busy)?;
+        Ok(ConfigAdmission {
+            requests: self.requests.clone(),
+            _slot: slot,
+            cancel: self.cancel.clone(),
+        })
+    }
+}
+impl ConfigAdmission {
+    pub(crate) fn submit(self, update: ConfigUpdate) -> Result<PendingApply, ApplyError> {
+        if self.cancel.is_cancelled() {
+            return Err(ApplyError::Stopped);
+        }
+        let (async_send, asynchronous) = oneshot::channel();
+        let (sync_send, synchronous) = mpsc::sync_channel(1);
+        let cancellation = self.cancel.child_token();
+        let request = ApplyRequest {
+            update,
+            completion: Completion {
+                asynchronous: Some(async_send),
+                synchronous: Some(sync_send),
+            },
+            cancellation: cancellation.clone(),
+            _slot: self._slot,
+        };
+        self.requests
+            .try_send(request)
+            .map_err(|error| match error {
+                async_mpsc::error::TrySendError::Full(_) => ApplyError::Busy,
+                async_mpsc::error::TrySendError::Closed(_) => ApplyError::Stopped,
+            })?;
+        Ok(PendingApply {
+            asynchronous: Some(asynchronous),
+            synchronous: Some(synchronous),
+            cancellation,
+        })
+    }
+}
+impl ApplyRequest {
+    pub(crate) fn cancellation(&self) -> CancellationToken {
+        self.cancellation.clone()
+    }
+    pub(crate) fn take_update(&mut self) -> ConfigUpdate {
+        std::mem::replace(
+            &mut self.update,
+            ConfigUpdate::Patch(ConfigPatch::default()),
+        )
+    }
+    pub(crate) fn complete(self, result: Result<(), ApplyError>) {
+        self.completion.complete(result);
+    }
+}
+impl PendingApply {
+    #[cfg(feature = "invoke")]
+    pub(crate) fn cancellation(&self) -> CancellationToken {
+        self.cancellation.clone()
+    }
+
+    pub(crate) async fn wait(mut self) -> Result<(), ApplyError> {
+        match tokio::time::timeout(
+            std::time::Duration::from_secs(90),
+            self.asynchronous.take().unwrap(),
+        )
+        .await
+        {
+            Ok(result) => result.unwrap_or(Err(ApplyError::Stopped)),
+            Err(_) => Err(ApplyError::TimedOut),
+        }
+    }
+    pub(crate) fn wait_blocking(mut self) -> Result<(), ApplyError> {
+        match self
+            .synchronous
+            .take()
+            .unwrap()
+            .recv_timeout(std::time::Duration::from_secs(90))
+        {
+            Ok(result) => result,
+            Err(mpsc::RecvTimeoutError::Disconnected) => Err(ApplyError::Stopped),
+            Err(mpsc::RecvTimeoutError::Timeout) => Err(ApplyError::TimedOut),
+        }
+    }
+}
+impl Drop for PendingApply {
+    fn drop(&mut self) {
+        self.cancellation.cancel();
+    }
+}
+
+impl Completion {
+    pub(crate) fn complete(mut self, result: Result<(), ApplyError>) {
+        if let Some(sender) = self.asynchronous.take() {
+            let _ = sender.send(result);
+        }
+        if let Some(sender) = self.synchronous.take() {
+            let _ = sender.try_send(result);
+        }
+    }
+}
+impl Drop for Completion {
+    fn drop(&mut self) {
+        if let Some(sender) = self.asynchronous.take() {
+            let _ = sender.send(Err(ApplyError::Stopped));
+        }
+        if let Some(sender) = self.synchronous.take() {
+            let _ = sender.try_send(Err(ApplyError::Stopped));
+        }
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[tokio::test]
+    async fn application_admission_is_single_before_reading_and_survives_caller_cancellation() {
+        let cancel = CancellationToken::new();
+        let (handle, mut receiver) = ConfigApplyHandle::channel(cancel.clone());
+        let admission = handle.try_admit().unwrap();
+        assert!(matches!(handle.try_admit(), Err(ApplyError::Busy)));
+        let pending = admission
+            .submit(ConfigUpdate::Replace("rules: [MATCH,DIRECT]".into()))
+            .unwrap();
+        drop(pending);
+        assert!(matches!(handle.try_admit(), Err(ApplyError::Busy)));
+        let request = receiver.recv().await.unwrap();
+        assert!(request.cancellation.is_cancelled());
+        request.completion.complete(Ok(()));
+        drop(request._slot);
+        assert!(handle.try_admit().is_ok());
+        cancel.cancel();
+        assert!(matches!(handle.try_admit(), Err(ApplyError::Stopped)));
+    }
+    #[tokio::test]
+    async fn asynchronous_and_foreign_thread_results_use_the_same_bounded_completion() {
+        let (handle, mut receiver) = ConfigApplyHandle::channel(CancellationToken::new());
+        let pending = handle
+            .try_admit()
+            .unwrap()
+            .submit(ConfigUpdate::Patch(ConfigPatch::default()))
+            .unwrap();
+        let request = receiver.recv().await.unwrap();
+        request
+            .completion
+            .complete(Err(ApplyError::RestartRequired));
+        assert_eq!(pending.wait().await, Err(ApplyError::RestartRequired));
+        drop(request._slot);
+        let pending = handle
+            .try_admit()
+            .unwrap()
+            .submit(ConfigUpdate::Patch(ConfigPatch::default()))
+            .unwrap();
+        let thread = std::thread::spawn(move || pending.wait_blocking());
+        drop(receiver.recv().await.unwrap());
+        assert_eq!(thread.join().unwrap(), Err(ApplyError::Stopped));
+    }
+}
diff --git a/src/resource/control.rs b/src/resource/control.rs
new file mode 100644
index 0000000..bee0f24
--- /dev/null
+++ b/src/resource/control.rs
@@ -0,0 +1,79 @@
+use crate::{
+    dns::runtime::RuntimeDns,
+    routing::{ProxyGroupError, ProxyGroups},
+};
+use async_trait::async_trait;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio_util::sync::CancellationToken;
+
+pub(crate) struct DelayRequest {
+    pub url: String,
+    pub timeout: Duration,
+    pub expected: Vec<(u16, u16)>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum ProbeError {
+    NotFound,
+    Timeout,
+    Failed,
+    Stopped,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum RuleUpdateError {
+    NotFound,
+    InvalidIndex,
+}
+
+/// A query holds its resource generation through completion and output admission.
+pub(crate) struct DnsSnapshot {
+    pub dns: Arc<RuntimeDns>,
+    pub _generation: Option<Arc<dyn Send + Sync>>,
+}
+#[async_trait]
+pub(crate) trait RuntimeResources: Send + Sync {
+    fn connections(&self) -> Arc<crate::connections::Registry>;
+    #[cfg(any(feature = "invoke", test))]
+    fn config_apply(&self) -> Option<crate::resource::config_apply::ConfigApplyHandle> {
+        None
+    }
+    fn configs(&self) -> serde_json::Value;
+    fn rules(&self) -> serde_json::Value;
+    fn disable_rules(&self, _changes: &[(usize, bool)]) -> Result<(), RuleUpdateError> {
+        Err(RuleUpdateError::NotFound)
+    }
+    fn groups(&self) -> Arc<ProxyGroups>;
+    fn select(&self, group: &str, member: &str) -> Result<(), ProxyGroupError>;
+    fn clear_fixed(&self, _group: &str) -> Result<(), ProxyGroupError> {
+        Err(ProxyGroupError::NotSelectable)
+    }
+    fn health(&self) -> serde_json::Value;
+    fn providers(&self, rules: bool) -> serde_json::Value;
+    fn dns(&self) -> Option<DnsSnapshot>;
+    async fn refresh(&self, rules: bool, name: &str) -> Result<(), &'static str>;
+    async fn node_delay(
+        &self,
+        _name: &str,
+        _request: &DelayRequest,
+        _cancel: &CancellationToken,
+    ) -> Result<u64, ProbeError> {
+        Err(ProbeError::NotFound)
+    }
+    async fn group_delay(
+        &self,
+        _name: &str,
+        _request: &DelayRequest,
+        _cancel: &CancellationToken,
+    ) -> Result<std::collections::BTreeMap<String, u64>, ProbeError> {
+        Err(ProbeError::NotFound)
+    }
+    async fn provider_healthcheck(
+        &self,
+        _name: &str,
+        _cancel: &CancellationToken,
+    ) -> Result<(), ProbeError> {
+        Err(ProbeError::NotFound)
+    }
+}
diff --git a/src/resource/http.rs b/src/resource/http.rs
new file mode 100644
index 0000000..2ae856f
--- /dev/null
+++ b/src/resource/http.rs
@@ -0,0 +1,1991 @@
+//! Shared streaming resource transport. Callers own content validation and
+//! publication; every HTTP hop uses the supplied Core dispatcher.
+
+use std::{
+    fs::{self, File, OpenOptions},
+    io::{self, Write},
+    net::SocketAddr,
+    path::PathBuf,
+    sync::Arc,
+    time::{Duration, Instant},
+};
+
+use async_trait::async_trait;
+use base64::Engine as _;
+use bytes::BytesMut;
+use flate2::write::MultiGzDecoder;
+use sha2::{Digest, Sha256};
+use thiserror::Error;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio_util::sync::CancellationToken;
+use url::{Host, Url};
+
+use super::subscription::SubscriptionInfo;
+use crate::{
+    dispatch::{BoxStream, DispatchError, Dispatcher},
+    session::{Destination, InboundKind, StreamSession},
+};
+
+pub(crate) const DEFAULT_DOWNLOAD_TIMEOUT: Duration = Duration::from_secs(90);
+
+const MAX_REDIRECTS: usize = 5;
+const MAX_URL_BYTES: usize = 4 * 1024;
+const MAX_REQUEST_ETAG_BYTES: usize = 1024;
+const MAX_RESPONSE_HEAD_BYTES: usize = 32 * 1024;
+const MAX_RESPONSE_HEADERS: usize = 64;
+const MAX_INFORMATIONAL_RESPONSES: usize = 4;
+const MAX_CHUNK_LINE_BYTES: usize = 1024;
+const MAX_TRAILER_BYTES: usize = 8 * 1024;
+const MAX_TRAILER_HEADERS: usize = 32;
+const IO_BUFFER_BYTES: usize = 16 * 1024;
+
+pub(crate) struct DownloadRequest {
+    pub security: crate::security::SecurityContext,
+    pub dispatcher: Arc<dyn Dispatcher>,
+    pub url: String,
+    pub etag: Option<String>,
+    /// A new temporary file. The downloader refuses to replace an existing
+    /// path; publishing the completed file is the manager's responsibility.
+    pub temporary_path: PathBuf,
+    pub timeout: Duration,
+    pub cancellation: CancellationToken,
+    pub options: HttpOptions,
+}
+
+#[derive(Clone)]
+pub(crate) struct HttpOptions {
+    pub user_agent: String,
+    pub headers: Vec<(String, String)>,
+    pub size_limit: Option<u64>,
+    pub allow_http: bool,
+    pub allow_ip: bool,
+}
+impl std::fmt::Debug for HttpOptions {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("HttpOptions")
+            .field("header_count", &self.headers.len())
+            .field("size_limit", &self.size_limit)
+            .field("allow_http", &self.allow_http)
+            .field("allow_ip", &self.allow_ip)
+            .finish_non_exhaustive()
+    }
+}
+impl Default for HttpOptions {
+    fn default() -> Self {
+        Self {
+            user_agent: concat!("Vole/", env!("CARGO_PKG_VERSION")).into(),
+            headers: Vec::new(),
+            size_limit: None,
+            allow_http: false,
+            allow_ip: false,
+        }
+    }
+}
+
+#[derive(Clone, PartialEq, Eq)]
+pub(crate) enum DownloadOutcome {
+    NotModified {
+        subscription_info: Option<SubscriptionInfo>,
+    },
+    Downloaded {
+        etag: Option<String>,
+        sha256: [u8; 32],
+        size: u64,
+        final_url: String,
+        subscription_info: Option<SubscriptionInfo>,
+    },
+}
+impl std::fmt::Debug for DownloadOutcome {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::NotModified { .. } => f.debug_struct("NotModified").finish_non_exhaustive(),
+            Self::Downloaded { size, .. } => f
+                .debug_struct("Downloaded")
+                .field("size", size)
+                .finish_non_exhaustive(),
+        }
+    }
+}
+
+#[derive(Debug, Error)]
+pub(crate) enum DownloadError {
+    #[error("invalid resource URL: {0}")]
+    InvalidUrl(String),
+    #[error("resource download URL must use HTTPS")]
+    HttpsRequired,
+    #[error("resource download URL must contain a domain host")]
+    DomainRequired,
+    #[error("resource download ETag is not a bounded HTTP header value")]
+    InvalidEtag,
+    #[error("resource proxy dispatch failed: {0}")]
+    Dispatch(#[source] DispatchError),
+    #[error("resource TLS setup failed: {0}")]
+    TlsSetup(String),
+    #[error("resource TLS handshake failed: {0}")]
+    TlsHandshake(String),
+    #[error("resource HTTP protocol error: {0}")]
+    Protocol(String),
+    #[error("resource server returned HTTP status {0}")]
+    HttpStatus(u16),
+    #[error("resource download followed more than {MAX_REDIRECTS} redirects")]
+    TooManyRedirects,
+    #[error("resource download timed out after {0:?}")]
+    TimedOut(Duration),
+    #[error("resource download was cancelled")]
+    Cancelled,
+    #[error("failed to {operation} resource temporary file {path}: {source}")]
+    File {
+        operation: &'static str,
+        path: PathBuf,
+        #[source]
+        source: io::Error,
+    },
+    #[error("resource network I/O failed: {0}")]
+    NetworkIo(#[source] io::Error),
+}
+
+/// Downloads one resource asset exclusively through `request.dispatcher`.
+///
+/// The successful `Downloaded` result leaves a fully flushed temporary file at
+/// `request.temporary_path`. All other outcomes remove the temporary file.
+pub(crate) async fn download(request: DownloadRequest) -> Result<DownloadOutcome, DownloadError> {
+    let connector = WebPkiHttpsConnector {
+        security: request.security.clone(),
+    };
+    download_with_connector(request, &connector).await
+}
+
+#[async_trait]
+trait HttpsConnector: Send + Sync {
+    async fn connect(
+        &self,
+        server_name: &str,
+        stream: BoxStream,
+    ) -> Result<BoxStream, DownloadError>;
+}
+
+struct WebPkiHttpsConnector {
+    security: crate::security::SecurityContext,
+}
+
+#[async_trait]
+impl HttpsConnector for WebPkiHttpsConnector {
+    async fn connect(
+        &self,
+        server_name: &str,
+        stream: BoxStream,
+    ) -> Result<BoxStream, DownloadError> {
+        crate::security::StandardTlsClient::with_options(
+            &self.security,
+            server_name,
+            crate::security::TlsClientOptions {
+                alpn: vec![b"http/1.1".to_vec()],
+                ..Default::default()
+            },
+            0,
+            64 * 1024,
+        )
+        .map_err(|_| DownloadError::TlsSetup("invalid TLS policy".into()))?
+        .connect(stream)
+        .await
+        .map_err(|_| DownloadError::TlsHandshake("TLS handshake failed".into()))
+    }
+}
+
+async fn download_with_connector(
+    request: DownloadRequest,
+    connector: &dyn HttpsConnector,
+) -> Result<DownloadOutcome, DownloadError> {
+    let initial_url = parse_url(&request.url, &request.options)?;
+    validate_options(&request.options)?;
+    validate_etag(request.etag.as_deref())?;
+
+    let temporary_path = request.temporary_path.clone();
+    let file = OpenOptions::new()
+        .write(true)
+        .create_new(true)
+        .open(&temporary_path)
+        .map_err(|source| DownloadError::File {
+            operation: "create",
+            path: temporary_path.clone(),
+            source,
+        })?;
+
+    let mut cleanup = TemporaryDownload(Some(temporary_path.clone()));
+    let cancellation = request.cancellation.clone();
+    let timeout = request.timeout;
+    let deadline = Instant::now().checked_add(timeout).ok_or_else(|| {
+        DownloadError::Protocol("resource deadline exceeds the clock range".into())
+    })?;
+    let result = {
+        let operation = download_inner(request, connector, initial_url, file, deadline);
+        tokio::pin!(operation);
+        tokio::select! {
+            biased;
+            () = cancellation.cancelled() => Err(DownloadError::Cancelled),
+            timed = tokio::time::timeout(timeout, &mut operation) => {
+                match timed {
+                    Ok(result) => result,
+                    Err(_) => Err(DownloadError::TimedOut(timeout)),
+                }
+            }
+        }
+    };
+
+    if matches!(result, Ok(DownloadOutcome::Downloaded { .. })) {
+        cleanup.0 = None;
+    }
+    result
+}
+
+async fn download_inner(
+    request: DownloadRequest,
+    connector: &dyn HttpsConnector,
+    mut current_url: Url,
+    file: File,
+    deadline: Instant,
+) -> Result<DownloadOutcome, DownloadError> {
+    let mut file = Some(file);
+    let initial_origin = current_url.origin();
+    let initial_auth = url_authorization(&current_url)?;
+
+    for redirects_followed in 0..=MAX_REDIRECTS {
+        let endpoint = DownloadEndpoint::from_url(&current_url)?;
+        let session = StreamSession {
+            metadata: Default::default(),
+            inbound: InboundKind::InternalGeoData,
+            source: SocketAddr::from(([0, 0, 0, 0], 0)),
+            destination: match endpoint.host.parse() {
+                Ok(ip) => Destination::Ip(SocketAddr::new(ip, endpoint.port)),
+                Err(_) => Destination::domain(endpoint.host.clone(), endpoint.port)
+                    .map_err(|error| DownloadError::InvalidUrl(error.to_string()))?,
+            },
+            sniffed_domain: None,
+        };
+        let stream = request
+            .dispatcher
+            .connect_tcp(session)
+            .await
+            .map_err(DownloadError::Dispatch)?;
+        let stream = if current_url.scheme() == "http" {
+            stream
+        } else {
+            connector.connect(&endpoint.host, stream).await?
+        };
+        let mut response = HttpReader::new(stream);
+        let same_origin = current_url.origin() == initial_origin;
+        let url_auth = url_authorization(&current_url)?;
+        let authorization = url_auth
+            .as_deref()
+            .or_else(|| same_origin.then_some(initial_auth.as_deref()).flatten());
+
+        response
+            .stream
+            .write_all(&build_request(
+                &endpoint,
+                request.etag.as_deref(),
+                &request.options,
+                same_origin,
+                authorization,
+            ))
+            .await
+            .map_err(DownloadError::NetworkIo)?;
+        response
+            .stream
+            .flush()
+            .await
+            .map_err(DownloadError::NetworkIo)?;
+
+        let head = response.read_final_head().await?;
+        if is_redirect(head.status) {
+            if redirects_followed == MAX_REDIRECTS {
+                return Err(DownloadError::TooManyRedirects);
+            }
+            let location = head.location.ok_or_else(|| {
+                DownloadError::Protocol("redirect response does not contain Location".to_owned())
+            })?;
+            current_url = redirect(&current_url, &location, &request.options)?;
+            continue;
+        }
+
+        match head.status {
+            304 if request.etag.is_some() => {
+                return Ok(DownloadOutcome::NotModified {
+                    subscription_info: head.subscription_info,
+                });
+            }
+            304 => {
+                return Err(DownloadError::Protocol(
+                    "received 304 without sending If-None-Match".to_owned(),
+                ));
+            }
+            200 => {}
+            status => return Err(DownloadError::HttpStatus(status)),
+        }
+
+        let gzip = content_is_gzip(head.content_encoding.as_deref())?;
+        let framing = body_framing(&head)?;
+        let target = file
+            .take()
+            .expect("temporary file must be consumed by one final response");
+        let mut sink = DecodedBody::new(
+            BodySink::new(
+                target,
+                request.options.size_limit,
+                request.cancellation.clone(),
+                deadline,
+            ),
+            gzip,
+        );
+        match framing {
+            BodyFraming::ContentLength(length) => {
+                if !gzip
+                    && request
+                        .options
+                        .size_limit
+                        .is_some_and(|limit| length > limit)
+                {
+                    return Err(DownloadError::Protocol(
+                        "resource exceeds size-limit".into(),
+                    ));
+                }
+                response.copy_exact_body(length, &mut sink).await?;
+            }
+            BodyFraming::Chunked => {
+                response.copy_chunked_body(&mut sink).await?;
+            }
+            BodyFraming::UntilEof => {
+                response.copy_body_until_eof(&mut sink).await?;
+            }
+        }
+        let (sha256, size) = sink.finish(&request.temporary_path)?;
+        return Ok(DownloadOutcome::Downloaded {
+            etag: head.etag,
+            sha256,
+            size,
+            final_url: without_credentials(&current_url),
+            subscription_info: head.subscription_info,
+        });
+    }
+
+    Err(DownloadError::TooManyRedirects)
+}
+
+struct DownloadEndpoint {
+    host: String,
+    port: u16,
+    authority: String,
+    origin_form: String,
+}
+
+impl DownloadEndpoint {
+    fn from_url(url: &Url) -> Result<Self, DownloadError> {
+        let host = match url.host() {
+            Some(host) => match host {
+                Host::Domain(host) => host.to_owned(),
+                Host::Ipv4(ip) => ip.to_string(),
+                Host::Ipv6(ip) => ip.to_string(),
+            },
+            None => return Err(DownloadError::DomainRequired),
+        };
+        let port = url
+            .port_or_known_default()
+            .ok_or_else(|| DownloadError::InvalidUrl("missing HTTP(S) port".to_owned()))?;
+        let default_port = if url.scheme() == "http" { 80 } else { 443 };
+        let authority_host = if host.contains(':') {
+            format!("[{host}]")
+        } else {
+            host.clone()
+        };
+        let authority = if port == default_port {
+            authority_host
+        } else {
+            format!("{authority_host}:{port}")
+        };
+        let mut origin_form = if url.path().is_empty() {
+            "/".to_owned()
+        } else {
+            url.path().to_owned()
+        };
+        if let Some(query) = url.query() {
+            origin_form.push('?');
+            origin_form.push_str(query);
+        }
+        Ok(Self {
+            host,
+            port,
+            authority,
+            origin_form,
+        })
+    }
+}
+
+#[cfg(test)]
+fn parse_resource_url(raw: &str) -> Result<Url, DownloadError> {
+    parse_url(raw, &HttpOptions::default())
+}
+
+pub(crate) fn parse_url(raw: &str, options: &HttpOptions) -> Result<Url, DownloadError> {
+    if raw.len() > MAX_URL_BYTES {
+        return Err(DownloadError::InvalidUrl(format!(
+            "URL exceeds {MAX_URL_BYTES} bytes"
+        )));
+    }
+    let mut url = Url::parse(raw).map_err(|error| DownloadError::InvalidUrl(error.to_string()))?;
+    let allowed_scheme = url.scheme() == "https" || options.allow_http && url.scheme() == "http";
+    if !allowed_scheme {
+        return Err(DownloadError::HttpsRequired);
+    }
+    url_authorization(&url)?;
+    if url.host().is_none() || (!options.allow_ip && !matches!(url.host(), Some(Host::Domain(_)))) {
+        return Err(DownloadError::DomainRequired);
+    }
+    if url.scheme() == "http" && url.fragment().is_some() {
+        return Err(DownloadError::InvalidUrl(
+            "URL must not contain a fragment".to_owned(),
+        ));
+    }
+    url.set_fragment(None);
+    Ok(url)
+}
+
+/// Exact private cache identity, including credentials/query without retaining either.
+pub(crate) fn source_identity(raw: &str) -> String {
+    format!(
+        "sha256:{}",
+        Sha256::digest(raw.as_bytes())
+            .iter()
+            .map(|byte| format!("{byte:02x}"))
+            .collect::<String>()
+    )
+}
+
+pub(crate) fn without_credentials(url: &Url) -> String {
+    let mut safe = url.clone();
+    let _ = safe.set_username("");
+    let _ = safe.set_password(None);
+    safe.to_string()
+}
+
+pub(crate) fn source_origin(raw: &str) -> Option<String> {
+    Url::parse(raw)
+        .ok()
+        .map(|url| url.origin().ascii_serialization())
+}
+
+/// Bind a provider validator to the effective request, never its cleartext secrets.
+pub(crate) fn request_identity(raw: &str, options: &HttpOptions) -> Result<String, DownloadError> {
+    let url = parse_url(raw, options)?;
+    validate_options(options)?;
+    let mut canonical = options.clone();
+    for (name, _) in &mut canonical.headers {
+        name.make_ascii_lowercase();
+    }
+    canonical
+        .headers
+        .sort_by(|left, right| left.0.cmp(&right.0));
+    let authorization = url_authorization(&url)?;
+    let request = build_request(
+        &DownloadEndpoint::from_url(&url)?,
+        None,
+        &canonical,
+        true,
+        authorization.as_deref(),
+    );
+    let mut hash = Sha256::new();
+    hash.update(b"Vole resource request identity v1\0");
+    for value in [raw.as_bytes(), request.as_slice()] {
+        hash.update((value.len() as u64).to_be_bytes());
+        hash.update(value);
+    }
+    Ok(format!(
+        "request-sha256:{}",
+        hash.finalize()
+            .iter()
+            .map(|byte| format!("{byte:02x}"))
+            .collect::<String>()
+    ))
+}
+
+fn unescape_userinfo(value: &str) -> Result<Vec<u8>, DownloadError> {
+    let mut result = Vec::with_capacity(value.len());
+    let mut input = value.bytes();
+    while let Some(byte) = input.next() {
+        if byte == b'%' {
+            let high = input.next().and_then(|byte| (byte as char).to_digit(16));
+            let low = input.next().and_then(|byte| (byte as char).to_digit(16));
+            match (high, low) {
+                (Some(high), Some(low)) => result.push((high * 16 + low) as u8),
+                _ => {
+                    return Err(DownloadError::InvalidUrl(
+                        "invalid HTTP authentication encoding".into(),
+                    ));
+                }
+            }
+        } else {
+            result.push(byte);
+        }
+    }
+    Ok(result)
+}
+
+fn url_authorization(url: &Url) -> Result<Option<String>, DownloadError> {
+    let authority = url
+        .as_str()
+        .split_once("://")
+        .map(|(_, suffix)| suffix)
+        .and_then(|suffix| suffix.split(['/', '?', '#']).next())
+        .unwrap_or_default();
+    if !authority.contains('@') {
+        return Ok(None);
+    }
+    let mut credentials = unescape_userinfo(url.username())?;
+    if credentials.contains(&b':') {
+        return Err(DownloadError::InvalidUrl(
+            "invalid HTTP authentication username".into(),
+        ));
+    }
+    credentials.push(b':');
+    credentials.extend_from_slice(&unescape_userinfo(url.password().unwrap_or_default())?);
+    Ok(Some(format!(
+        "Basic {}",
+        base64::engine::general_purpose::STANDARD.encode(credentials)
+    )))
+}
+
+fn redirect(base: &Url, location: &str, options: &HttpOptions) -> Result<Url, DownloadError> {
+    if location.len() > MAX_URL_BYTES || !is_header_value(location.as_bytes()) {
+        return Err(DownloadError::InvalidUrl(
+            "redirect Location is not a bounded HTTP header value".to_owned(),
+        ));
+    }
+    let joined = base
+        .join(location)
+        .map_err(|error| DownloadError::InvalidUrl(error.to_string()))?;
+    if base.scheme() == "https" && joined.scheme() != "https" {
+        return Err(DownloadError::HttpsRequired);
+    }
+    parse_url(joined.as_str(), options)
+}
+
+fn validate_etag(etag: Option<&str>) -> Result<(), DownloadError> {
+    if let Some(etag) = etag
+        && (etag.len() > MAX_REQUEST_ETAG_BYTES || !is_header_value(etag.as_bytes()))
+    {
+        return Err(DownloadError::InvalidEtag);
+    }
+    Ok(())
+}
+
+pub(crate) fn validate_options(options: &HttpOptions) -> Result<(), DownloadError> {
+    if options.user_agent.len() > 1024 || !is_header_value(options.user_agent.as_bytes()) {
+        return Err(DownloadError::Protocol("invalid User-Agent".into()));
+    }
+    let mut size = 0usize;
+    for (name, value) in &options.headers {
+        size = size.saturating_add(name.len()).saturating_add(value.len());
+        if name.is_empty()
+            || !name
+                .bytes()
+                .all(|b| b.is_ascii_alphanumeric() || b"!#$%&'*+-.^_`|~".contains(&b))
+            || !is_header_value(value.as_bytes())
+            || size > MAX_RESPONSE_HEAD_BYTES
+            || [
+                "host",
+                "connection",
+                "content-length",
+                "transfer-encoding",
+                "if-none-match",
+                "accept-encoding",
+            ]
+            .iter()
+            .any(|reserved| name.eq_ignore_ascii_case(reserved))
+        {
+            return Err(DownloadError::Protocol(
+                "invalid resource request header".into(),
+            ));
+        }
+    }
+    Ok(())
+}
+
+fn build_request(
+    endpoint: &DownloadEndpoint,
+    etag: Option<&str>,
+    options: &HttpOptions,
+    same_origin: bool,
+    authorization: Option<&str>,
+) -> Vec<u8> {
+    let conditional = etag.map_or_else(String::new, |etag| format!("If-None-Match: {etag}\r\n"));
+    let mut headers = String::new();
+    for (name, value) in &options.headers {
+        if authorization.is_some() && name.eq_ignore_ascii_case("authorization") {
+            continue;
+        }
+        if !same_origin
+            && ["authorization", "cookie", "proxy-authorization"]
+                .iter()
+                .any(|s| name.eq_ignore_ascii_case(s))
+        {
+            continue;
+        }
+        headers.push_str(&format!("{name}: {value}\r\n"));
+    }
+    if let Some(authorization) = authorization {
+        headers.push_str(&format!("Authorization: {authorization}\r\n"));
+    }
+    let user_agent = if options
+        .headers
+        .iter()
+        .any(|(name, _)| name.eq_ignore_ascii_case("user-agent"))
+    {
+        String::new()
+    } else {
+        format!("User-Agent: {}\r\n", options.user_agent)
+    };
+    format!(
+        "GET {} HTTP/1.1\r\nHost: {}\r\nAccept: application/octet-stream\r\nAccept-Encoding: gzip\r\n{}Connection: close\r\n{}{}\r\n",
+        endpoint.origin_form, endpoint.authority, user_agent, conditional, headers
+    ).into_bytes()
+}
+
+struct TemporaryDownload(Option<PathBuf>);
+impl Drop for TemporaryDownload {
+    fn drop(&mut self) {
+        if let Some(path) = &self.0 {
+            let _ = fs::remove_file(path);
+        }
+    }
+}
+
+fn is_redirect(status: u16) -> bool {
+    matches!(status, 301 | 302 | 303 | 307 | 308)
+}
+
+struct ResponseHead {
+    status: u16,
+    content_length: Option<u64>,
+    transfer_encoding: Option<String>,
+    content_encoding: Option<String>,
+    etag: Option<String>,
+    location: Option<String>,
+    subscription_info: Option<SubscriptionInfo>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum BodyFraming {
+    ContentLength(u64),
+    Chunked,
+    UntilEof,
+}
+
+fn body_framing(head: &ResponseHead) -> Result<BodyFraming, DownloadError> {
+    if head.transfer_encoding.is_some() && head.content_length.is_some() {
+        return Err(DownloadError::Protocol(
+            "response contains both Transfer-Encoding and Content-Length".to_owned(),
+        ));
+    }
+    if let Some(encoding) = &head.transfer_encoding {
+        if !encoding.eq_ignore_ascii_case("chunked") {
+            return Err(DownloadError::Protocol(
+                "unsupported resource Transfer-Encoding".into(),
+            ));
+        }
+        return Ok(BodyFraming::Chunked);
+    }
+    if let Some(length) = head.content_length {
+        return Ok(BodyFraming::ContentLength(length));
+    }
+    Ok(BodyFraming::UntilEof)
+}
+
+fn content_is_gzip(encoding: Option<&str>) -> Result<bool, DownloadError> {
+    if encoding.is_some_and(|value| value.eq_ignore_ascii_case("gzip")) {
+        return Ok(true);
+    }
+    if encoding.is_some_and(|value| {
+        !value
+            .split(',')
+            .all(|item| item.trim().eq_ignore_ascii_case("identity"))
+    }) {
+        return Err(DownloadError::Protocol(
+            "unsupported resource Content-Encoding".into(),
+        ));
+    }
+    Ok(false)
+}
+
+struct HttpReader {
+    stream: BoxStream,
+    buffered: BytesMut,
+}
+
+impl HttpReader {
+    fn new(stream: BoxStream) -> Self {
+        Self {
+            stream,
+            buffered: BytesMut::with_capacity(4 * 1024),
+        }
+    }
+
+    async fn read_final_head(&mut self) -> Result<ResponseHead, DownloadError> {
+        for informational_count in 0..=MAX_INFORMATIONAL_RESPONSES {
+            let block = self.read_head_block().await?;
+            let head = parse_response_head(&block)?;
+            if !(100..200).contains(&head.status) {
+                return Ok(head);
+            }
+            if head.status == 101 {
+                return Err(DownloadError::Protocol(
+                    "HTTP protocol switching is not supported".to_owned(),
+                ));
+            }
+            if informational_count == MAX_INFORMATIONAL_RESPONSES {
+                return Err(DownloadError::Protocol(
+                    "too many informational responses".to_owned(),
+                ));
+            }
+        }
+        unreachable!("informational response loop always returns");
+    }
+
+    async fn read_head_block(&mut self) -> Result<Vec<u8>, DownloadError> {
+        loop {
+            if let Some(end) = find_bytes(&self.buffered, b"\r\n\r\n") {
+                if end + 4 > MAX_RESPONSE_HEAD_BYTES {
+                    return Err(DownloadError::Protocol(format!(
+                        "response head exceeds {MAX_RESPONSE_HEAD_BYTES} bytes"
+                    )));
+                }
+                let mut block = self.buffered.split_to(end + 4).to_vec();
+                block.truncate(end);
+                return Ok(block);
+            }
+            if self.buffered.len() >= MAX_RESPONSE_HEAD_BYTES {
+                return Err(DownloadError::Protocol(format!(
+                    "response head exceeds {MAX_RESPONSE_HEAD_BYTES} bytes"
+                )));
+            }
+            let mut scratch = [0_u8; 4 * 1024];
+            let read = self
+                .stream
+                .read(&mut scratch)
+                .await
+                .map_err(DownloadError::NetworkIo)?;
+            if read == 0 {
+                return Err(DownloadError::Protocol(
+                    "response ended before its HTTP head".to_owned(),
+                ));
+            }
+            self.buffered.extend_from_slice(&scratch[..read]);
+        }
+    }
+
+    async fn copy_exact_body(
+        &mut self,
+        mut remaining: u64,
+        sink: &mut DecodedBody,
+    ) -> Result<(), DownloadError> {
+        let mut scratch = [0_u8; IO_BUFFER_BYTES];
+        while remaining > 0 {
+            let wanted = usize::try_from(remaining.min(IO_BUFFER_BYTES as u64))
+                .expect("bounded read size fits usize");
+            let read = self.read_some(&mut scratch[..wanted]).await?;
+            if read == 0 {
+                return Err(DownloadError::Protocol(format!(
+                    "response body ended with {remaining} bytes missing"
+                )));
+            }
+            sink.write(&scratch[..read])?;
+            remaining -= read as u64;
+        }
+        Ok(())
+    }
+
+    async fn copy_body_until_eof(&mut self, sink: &mut DecodedBody) -> Result<(), DownloadError> {
+        let mut scratch = [0_u8; IO_BUFFER_BYTES];
+        loop {
+            let read = self.read_some(&mut scratch).await?;
+            if read == 0 {
+                return Ok(());
+            }
+            sink.write(&scratch[..read])?;
+        }
+    }
+
+    async fn copy_chunked_body(&mut self, sink: &mut DecodedBody) -> Result<(), DownloadError> {
+        loop {
+            let line = self.read_line(MAX_CHUNK_LINE_BYTES).await?;
+            if !is_header_value(&line) {
+                return Err(DownloadError::Protocol(
+                    "chunk-size line contains invalid bytes".to_owned(),
+                ));
+            }
+            let size_text = line
+                .split(|byte| *byte == b';')
+                .next()
+                .expect("split always returns one value");
+            let size_text = trim_ascii_whitespace(size_text);
+            if size_text.is_empty() || size_text.len() > 16 {
+                return Err(DownloadError::Protocol("invalid chunk size".to_owned()));
+            }
+            let size_text = std::str::from_utf8(size_text)
+                .map_err(|_| DownloadError::Protocol("chunk size is not ASCII".to_owned()))?;
+            let size = u64::from_str_radix(size_text, 16).map_err(|_| {
+                DownloadError::Protocol("invalid hexadecimal chunk size".to_owned())
+            })?;
+            if size == 0 {
+                self.read_trailers().await?;
+                return Ok(());
+            }
+            self.copy_exact_body(size, sink).await?;
+            let terminator = self.read_exact_small(2).await?;
+            if terminator != b"\r\n" {
+                return Err(DownloadError::Protocol(
+                    "chunk data is not followed by CRLF".to_owned(),
+                ));
+            }
+        }
+    }
+
+    async fn read_trailers(&mut self) -> Result<(), DownloadError> {
+        let mut total = 0_usize;
+        for count in 0..=MAX_TRAILER_HEADERS {
+            let line = self.read_line(MAX_TRAILER_BYTES).await?;
+            total = total
+                .checked_add(line.len() + 2)
+                .ok_or_else(|| DownloadError::Protocol("trailer size overflow".to_owned()))?;
+            if total > MAX_TRAILER_BYTES {
+                return Err(DownloadError::Protocol(format!(
+                    "trailers exceed {MAX_TRAILER_BYTES} bytes"
+                )));
+            }
+            if line.is_empty() {
+                return Ok(());
+            }
+            if count == MAX_TRAILER_HEADERS {
+                return Err(DownloadError::Protocol(format!(
+                    "trailers contain more than {MAX_TRAILER_HEADERS} fields"
+                )));
+            }
+            validate_trailer_line(&line)?;
+        }
+        unreachable!("trailer loop always returns");
+    }
+
+    async fn read_line(&mut self, maximum: usize) -> Result<Vec<u8>, DownloadError> {
+        loop {
+            if let Some(end) = find_bytes(&self.buffered, b"\r\n") {
+                if end > maximum {
+                    return Err(DownloadError::Protocol(format!(
+                        "HTTP line exceeds {maximum} bytes"
+                    )));
+                }
+                let mut line = self.buffered.split_to(end + 2).to_vec();
+                line.truncate(end);
+                return Ok(line);
+            }
+            if self.buffered.len() > maximum {
+                return Err(DownloadError::Protocol(format!(
+                    "HTTP line exceeds {maximum} bytes"
+                )));
+            }
+            let mut scratch = [0_u8; 4 * 1024];
+            let read = self
+                .stream
+                .read(&mut scratch)
+                .await
+                .map_err(DownloadError::NetworkIo)?;
+            if read == 0 {
+                return Err(DownloadError::Protocol(
+                    "response ended in the middle of an HTTP line".to_owned(),
+                ));
+            }
+            self.buffered.extend_from_slice(&scratch[..read]);
+        }
+    }
+
+    async fn read_exact_small(&mut self, length: usize) -> Result<Vec<u8>, DownloadError> {
+        let mut output = vec![0_u8; length];
+        let mut written = 0;
+        while written < length {
+            if self.buffered.is_empty() {
+                let mut scratch = [0_u8; 4 * 1024];
+                let read = self
+                    .stream
+                    .read(&mut scratch)
+                    .await
+                    .map_err(DownloadError::NetworkIo)?;
+                if read == 0 {
+                    return Err(DownloadError::Protocol(
+                        "response body ended unexpectedly".to_owned(),
+                    ));
+                }
+                self.buffered.extend_from_slice(&scratch[..read]);
+            }
+            let take = (length - written).min(self.buffered.len());
+            let bytes = self.buffered.split_to(take);
+            output[written..written + take].copy_from_slice(&bytes);
+            written += take;
+        }
+        Ok(output)
+    }
+
+    async fn read_some(&mut self, output: &mut [u8]) -> Result<usize, DownloadError> {
+        if !self.buffered.is_empty() {
+            let take = output.len().min(self.buffered.len());
+            let bytes = self.buffered.split_to(take);
+            output[..take].copy_from_slice(&bytes);
+            return Ok(take);
+        }
+        self.stream
+            .read(output)
+            .await
+            .map_err(DownloadError::NetworkIo)
+    }
+}
+
+fn parse_response_head(block: &[u8]) -> Result<ResponseHead, DownloadError> {
+    if !block.is_ascii() {
+        return Err(DownloadError::Protocol(
+            "response head contains non-ASCII bytes".to_owned(),
+        ));
+    }
+    let text = std::str::from_utf8(block)
+        .map_err(|_| DownloadError::Protocol("invalid response head".to_owned()))?;
+    let mut lines = text.split("\r\n");
+    let status_line = lines
+        .next()
+        .ok_or_else(|| DownloadError::Protocol("missing HTTP status line".to_owned()))?;
+    let mut status_parts = status_line.splitn(3, ' ');
+    if !matches!(status_parts.next(), Some("HTTP/1.0" | "HTTP/1.1")) {
+        return Err(DownloadError::Protocol(
+            "server did not respond with HTTP/1.0 or HTTP/1.1".to_owned(),
+        ));
+    }
+    let status_text = status_parts
+        .next()
+        .ok_or_else(|| DownloadError::Protocol("missing HTTP status".to_owned()))?;
+    if status_text.len() != 3 || !status_text.bytes().all(|byte| byte.is_ascii_digit()) {
+        return Err(DownloadError::Protocol("invalid HTTP status".to_owned()));
+    }
+    let status = status_text
+        .parse::<u16>()
+        .map_err(|_| DownloadError::Protocol("invalid HTTP status".to_owned()))?;
+
+    let mut content_length = None;
+    let mut transfer_encoding = None;
+    let mut content_encoding = None;
+    let mut etag = None;
+    let mut location = None;
+    let mut subscription_info = None;
+    let mut subscription_seen = false;
+    let mut header_count = 0_usize;
+
+    for line in lines {
+        header_count += 1;
+        if header_count > MAX_RESPONSE_HEADERS {
+            return Err(DownloadError::Protocol(format!(
+                "response contains more than {MAX_RESPONSE_HEADERS} headers"
+            )));
+        }
+        if line.starts_with(' ') || line.starts_with('\t') {
+            return Err(DownloadError::Protocol(
+                "obsolete folded headers are not supported".to_owned(),
+            ));
+        }
+        let (name, value) = line
+            .split_once(':')
+            .ok_or_else(|| DownloadError::Protocol("malformed HTTP response header".to_owned()))?;
+        if !is_header_name(name.as_bytes()) {
+            return Err(DownloadError::Protocol(
+                "invalid HTTP response header name".to_owned(),
+            ));
+        }
+        let value = value.trim_matches([' ', '\t']);
+        if !is_header_value(value.as_bytes()) {
+            return Err(DownloadError::Protocol(
+                "invalid HTTP response header value".to_owned(),
+            ));
+        }
+        if name.eq_ignore_ascii_case("content-length") {
+            set_once(&mut content_length, "Content-Length")?;
+            content_length = Some(
+                value
+                    .parse::<u64>()
+                    .map_err(|_| DownloadError::Protocol("invalid Content-Length".to_owned()))?,
+            );
+        } else if name.eq_ignore_ascii_case("transfer-encoding") {
+            set_string_once(&mut transfer_encoding, value, "Transfer-Encoding")?;
+        } else if name.eq_ignore_ascii_case("content-encoding") {
+            set_string_once(&mut content_encoding, value, "Content-Encoding")?;
+        } else if name.eq_ignore_ascii_case("etag") {
+            set_string_once(&mut etag, value, "ETag")?;
+        } else if name.eq_ignore_ascii_case("location") {
+            set_string_once(&mut location, value, "Location")?;
+        } else if name.eq_ignore_ascii_case("subscription-userinfo") && !subscription_seen {
+            subscription_seen = true;
+            subscription_info = SubscriptionInfo::parse(value);
+        }
+    }
+
+    Ok(ResponseHead {
+        status,
+        content_length,
+        transfer_encoding,
+        content_encoding,
+        etag,
+        location,
+        subscription_info,
+    })
+}
+
+fn set_once<T>(slot: &mut Option<T>, header_name: &'static str) -> Result<(), DownloadError> {
+    if slot.is_some() {
+        return Err(DownloadError::Protocol(format!(
+            "duplicate {header_name} header"
+        )));
+    }
+    Ok(())
+}
+
+fn set_string_once(
+    slot: &mut Option<String>,
+    value: &str,
+    header_name: &'static str,
+) -> Result<(), DownloadError> {
+    set_once(slot, header_name)?;
+    *slot = Some(value.to_owned());
+    Ok(())
+}
+
+fn validate_trailer_line(line: &[u8]) -> Result<(), DownloadError> {
+    if !line.is_ascii()
+        || line
+            .first()
+            .is_some_and(|byte| matches!(byte, b' ' | b'\t'))
+    {
+        return Err(DownloadError::Protocol("invalid HTTP trailer".to_owned()));
+    }
+    let Some(colon) = line.iter().position(|byte| *byte == b':') else {
+        return Err(DownloadError::Protocol("malformed HTTP trailer".to_owned()));
+    };
+    let name = &line[..colon];
+    let value = trim_ascii_whitespace(&line[colon + 1..]);
+    if !is_header_name(name) || !is_header_value(value) {
+        return Err(DownloadError::Protocol("invalid HTTP trailer".to_owned()));
+    }
+    if name.eq_ignore_ascii_case(b"content-length")
+        || name.eq_ignore_ascii_case(b"transfer-encoding")
+        || name.eq_ignore_ascii_case(b"content-encoding")
+        || name.eq_ignore_ascii_case(b"location")
+    {
+        return Err(DownloadError::Protocol(
+            "forbidden framing field in HTTP trailer".to_owned(),
+        ));
+    }
+    Ok(())
+}
+
+fn is_header_name(bytes: &[u8]) -> bool {
+    !bytes.is_empty()
+        && bytes.iter().all(|byte| {
+            byte.is_ascii_alphanumeric()
+                || matches!(
+                    byte,
+                    b'!' | b'#'
+                        | b'$'
+                        | b'%'
+                        | b'&'
+                        | b'\''
+                        | b'*'
+                        | b'+'
+                        | b'-'
+                        | b'.'
+                        | b'^'
+                        | b'_'
+                        | b'`'
+                        | b'|'
+                        | b'~'
+                )
+        })
+}
+
+fn is_header_value(bytes: &[u8]) -> bool {
+    bytes
+        .iter()
+        .all(|byte| *byte == b'\t' || (0x20..=0x7e).contains(byte))
+}
+
+fn trim_ascii_whitespace(mut bytes: &[u8]) -> &[u8] {
+    while bytes.first().is_some_and(u8::is_ascii_whitespace) {
+        bytes = &bytes[1..];
+    }
+    while bytes.last().is_some_and(u8::is_ascii_whitespace) {
+        bytes = &bytes[..bytes.len() - 1];
+    }
+    bytes
+}
+
+fn find_bytes(haystack: &[u8], needle: &[u8]) -> Option<usize> {
+    haystack
+        .windows(needle.len())
+        .position(|window| window == needle)
+}
+
+struct BodySink {
+    file: File,
+    hasher: Sha256,
+    size: u64,
+    limit: Option<u64>,
+    cancellation: CancellationToken,
+    deadline: Instant,
+}
+
+impl BodySink {
+    fn new(
+        file: File,
+        limit: Option<u64>,
+        cancellation: CancellationToken,
+        deadline: Instant,
+    ) -> Self {
+        Self {
+            file,
+            hasher: Sha256::new(),
+            limit,
+            size: 0,
+            cancellation,
+            deadline,
+        }
+    }
+
+    fn write(&mut self, bytes: &[u8]) -> Result<(), DownloadError> {
+        if self.cancellation.is_cancelled() {
+            return Err(DownloadError::Cancelled);
+        }
+        if Instant::now() >= self.deadline {
+            return Err(DownloadError::Protocol(
+                "resource decoding deadline exceeded".into(),
+            ));
+        }
+        let added = u64::try_from(bytes.len()).expect("buffer length fits u64");
+        let next = self
+            .size
+            .checked_add(added)
+            .ok_or_else(|| DownloadError::Protocol("body size overflows u64".to_owned()))?;
+        if self.limit.is_some_and(|limit| next > limit) {
+            return Err(DownloadError::Protocol(
+                "resource exceeds size-limit".into(),
+            ));
+        }
+        self.file
+            .write_all(bytes)
+            .map_err(DownloadError::NetworkIo)?;
+        self.hasher.update(bytes);
+        self.size = next;
+        Ok(())
+    }
+
+    fn finish(mut self, path: &std::path::Path) -> Result<([u8; 32], u64), DownloadError> {
+        self.file
+            .flush()
+            .and_then(|()| self.file.sync_all())
+            .map_err(|source| DownloadError::File {
+                operation: "flush",
+                path: path.to_path_buf(),
+                source,
+            })?;
+        let sha256 = self.hasher.finalize().into();
+        Ok((sha256, self.size))
+    }
+}
+
+impl Write for BodySink {
+    fn write(&mut self, bytes: &[u8]) -> io::Result<usize> {
+        BodySink::write(self, bytes).map_err(io::Error::other)?;
+        Ok(bytes.len())
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        self.file.flush()
+    }
+}
+
+enum DecodedBody {
+    Identity(BodySink),
+    Gzip(Box<MultiGzDecoder<BodySink>>),
+}
+impl DecodedBody {
+    fn new(sink: BodySink, gzip: bool) -> Self {
+        if gzip {
+            Self::Gzip(Box::new(MultiGzDecoder::new(sink)))
+        } else {
+            Self::Identity(sink)
+        }
+    }
+    fn write(&mut self, bytes: &[u8]) -> Result<(), DownloadError> {
+        match self {
+            Self::Identity(sink) => sink.write(bytes),
+            Self::Gzip(decoder) => decoder.write_all(bytes).map_err(|_| {
+                DownloadError::Protocol("invalid or over-budget gzip resource body".into())
+            }),
+        }
+    }
+    fn finish(self, path: &std::path::Path) -> Result<([u8; 32], u64), DownloadError> {
+        let sink = match self {
+            Self::Identity(sink) => sink,
+            Self::Gzip(decoder) => decoder.finish().map_err(|_| {
+                DownloadError::Protocol("invalid or truncated gzip resource body".into())
+            })?,
+        };
+        sink.finish(path)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{
+        collections::VecDeque,
+        sync::{Arc, Mutex},
+    };
+
+    use async_trait::async_trait;
+    use tempfile::tempdir;
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+    use super::*;
+    use crate::{
+        dispatch::{DatagramTransport, DispatchError},
+        session::{DatagramSession, Destination},
+    };
+
+    #[test]
+    fn subscription_header_uses_first_value_including_an_empty_one() {
+        let head = parse_response_head(
+            b"HTTP/1.1 200 OK\r\nSubscription-Userinfo: upload=7\r\nsubscription-userinfo: upload=99",
+        )
+        .unwrap();
+        assert_eq!(head.subscription_info.unwrap().upload, 7);
+        let head = parse_response_head(
+            b"HTTP/1.1 304 Not Modified\r\nSubscription-Userinfo: \r\nsubscription-userinfo: upload=99",
+        )
+        .unwrap();
+        assert_eq!(head.subscription_info, None);
+    }
+
+    struct PlainHttpsConnector;
+
+    #[async_trait]
+    impl HttpsConnector for PlainHttpsConnector {
+        async fn connect(
+            &self,
+            _server_name: &str,
+            stream: BoxStream,
+        ) -> Result<BoxStream, DownloadError> {
+            Ok(stream)
+        }
+    }
+
+    struct ScriptedDispatcher {
+        responses: Mutex<VecDeque<Vec<u8>>>,
+        sessions: Mutex<Vec<StreamSession>>,
+        requests: Arc<Mutex<Vec<Vec<u8>>>>,
+    }
+
+    struct HangingDispatcher;
+
+    #[async_trait]
+    impl Dispatcher for HangingDispatcher {
+        async fn connect_tcp(&self, _session: StreamSession) -> Result<BoxStream, DispatchError> {
+            std::future::pending().await
+        }
+
+        async fn open_datagram(
+            &self,
+            _session: DatagramSession,
+        ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+            Err(DispatchError::NotAllowed)
+        }
+    }
+
+    impl ScriptedDispatcher {
+        fn new(responses: impl IntoIterator<Item = Vec<u8>>) -> Self {
+            Self {
+                responses: Mutex::new(responses.into_iter().collect()),
+                sessions: Mutex::new(Vec::new()),
+                requests: Arc::new(Mutex::new(Vec::new())),
+            }
+        }
+
+        fn sessions(&self) -> Vec<StreamSession> {
+            self.sessions.lock().expect("sessions lock").clone()
+        }
+
+        fn requests(&self) -> Vec<Vec<u8>> {
+            self.requests.lock().expect("requests lock").clone()
+        }
+    }
+
+    #[async_trait]
+    impl Dispatcher for ScriptedDispatcher {
+        async fn connect_tcp(&self, session: StreamSession) -> Result<BoxStream, DispatchError> {
+            self.sessions.lock().expect("sessions lock").push(session);
+            let response = self
+                .responses
+                .lock()
+                .expect("responses lock")
+                .pop_front()
+                .ok_or_else(|| DispatchError::Other("no scripted response".to_owned()))?;
+            let requests = Arc::clone(&self.requests);
+            let (client, mut server) = tokio::io::duplex(128 * 1024);
+            tokio::spawn(async move {
+                let mut request = Vec::new();
+                let mut scratch = [0_u8; 1024];
+                loop {
+                    let read = server.read(&mut scratch).await.expect("read request");
+                    if read == 0 {
+                        break;
+                    }
+                    request.extend_from_slice(&scratch[..read]);
+                    if find_bytes(&request, b"\r\n\r\n").is_some() {
+                        break;
+                    }
+                }
+                requests.lock().expect("requests lock").push(request);
+                server.write_all(&response).await.expect("write response");
+                server.shutdown().await.expect("shutdown response");
+            });
+            Ok(Box::new(client))
+        }
+
+        async fn open_datagram(
+            &self,
+            _session: DatagramSession,
+        ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+            Err(DispatchError::NotAllowed)
+        }
+    }
+
+    fn request(
+        dispatcher: Arc<dyn Dispatcher>,
+        url: &str,
+        temporary_path: PathBuf,
+    ) -> DownloadRequest {
+        DownloadRequest {
+            security: crate::security::SecurityContext::new(),
+            dispatcher,
+            url: url.to_owned(),
+            etag: Some("\"old\"".to_owned()),
+            temporary_path,
+            timeout: Duration::from_secs(2),
+            cancellation: CancellationToken::new(),
+            options: HttpOptions::default(),
+        }
+    }
+
+    #[tokio::test]
+    async fn plaintext_geodata_is_rejected_before_dispatch() {
+        let directory = tempdir().unwrap();
+        let path = directory.path().join("http.new");
+        let dispatcher = Arc::new(ScriptedDispatcher::new([]));
+        let error = download(request(
+            dispatcher.clone(),
+            "http://rules.example.test/geoip.dat",
+            path.clone(),
+        ))
+        .await
+        .unwrap_err();
+        assert!(matches!(error, DownloadError::HttpsRequired));
+        assert!(dispatcher.sessions().is_empty());
+        assert!(!path.exists());
+    }
+
+    #[tokio::test]
+    async fn follows_https_redirect_and_streams_chunked_body_through_raw_proxy() {
+        let directory = tempdir().expect("tempdir");
+        let temporary_path = directory.path().join("geosite.dat.new");
+        let dispatcher = Arc::new(ScriptedDispatcher::new([
+            b"HTTP/1.1 302 Found\r\nLocation: https://cdn.example.test/final.dat?version=2\r\nContent-Length: 0\r\n\r\n".to_vec(),
+            b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\nContent-Encoding: identity\r\nETag: \"new\"\r\n\r\n4\r\ngeo-\r\n4\r\ndata\r\n0\r\nX-Checksum: present\r\n\r\n".to_vec(),
+        ]));
+        let outcome = download_with_connector(
+            request(
+                dispatcher.clone(),
+                "https://rules.example.test/geosite.dat",
+                temporary_path.clone(),
+            ),
+            &PlainHttpsConnector,
+        )
+        .await
+        .expect("download succeeds");
+
+        let expected_sha256: [u8; 32] = Sha256::digest(b"geo-data").into();
+        assert_eq!(
+            outcome,
+            DownloadOutcome::Downloaded {
+                etag: Some("\"new\"".to_owned()),
+                sha256: expected_sha256,
+                size: 8,
+                final_url: "https://cdn.example.test/final.dat?version=2".to_owned(),
+                subscription_info: None,
+            }
+        );
+        assert_eq!(
+            fs::read(&temporary_path).expect("temporary data"),
+            b"geo-data"
+        );
+
+        let sessions = dispatcher.sessions();
+        assert_eq!(sessions.len(), 2);
+        assert!(sessions.iter().all(|session| {
+            session.inbound == InboundKind::InternalGeoData
+                && session.source == SocketAddr::from(([0, 0, 0, 0], 0))
+                && session.sniffed_domain.is_none()
+        }));
+        assert_eq!(
+            sessions[0].destination,
+            Destination::Domain {
+                host: "rules.example.test".to_owned(),
+                port: 443,
+            }
+        );
+        assert_eq!(
+            sessions[1].destination,
+            Destination::Domain {
+                host: "cdn.example.test".to_owned(),
+                port: 443,
+            }
+        );
+
+        let requests = dispatcher.requests();
+        assert_eq!(requests.len(), 2);
+        let first = std::str::from_utf8(&requests[0]).expect("request is ASCII");
+        assert!(first.starts_with("GET /geosite.dat HTTP/1.1\r\n"));
+        assert!(first.contains("\r\nHost: rules.example.test\r\n"));
+        assert!(first.contains("\r\nAccept-Encoding: gzip\r\n"));
+        assert!(first.contains("\r\nIf-None-Match: \"old\"\r\n"));
+    }
+
+    #[tokio::test]
+    async fn not_modified_removes_the_unused_temporary_file() {
+        let directory = tempdir().expect("tempdir");
+        for version in ["HTTP/1.0", "HTTP/1.1"] {
+            let temporary_path = directory.path().join("geoip.dat.new");
+            let dispatcher = Arc::new(ScriptedDispatcher::new([
+                format!("{version} 304 Not Modified\r\nETag: \"old\"\r\nSubscription-Userinfo: upload=7\r\n\r\n").into_bytes(),
+            ]));
+            let outcome = download_with_connector(
+                request(
+                    dispatcher,
+                    "https://rules.example.test/geoip.dat",
+                    temporary_path.clone(),
+                ),
+                &PlainHttpsConnector,
+            )
+            .await
+            .expect("conditional request succeeds");
+            assert_eq!(
+                outcome,
+                DownloadOutcome::NotModified {
+                    subscription_info: Some(SubscriptionInfo {
+                        upload: 7,
+                        ..Default::default()
+                    })
+                }
+            );
+            assert!(!temporary_path.exists());
+        }
+    }
+
+    #[tokio::test]
+    async fn supports_content_length_and_eof_delimited_bodies() {
+        let directory = tempdir().expect("tempdir");
+        for (version, suffix) in [("HTTP/1.0", "1.0"), ("HTTP/1.1", "1.1")] {
+            for (name, headers, body, expected) in [
+                (
+                    "length",
+                    "Content-Length: 5\r\n",
+                    "12345ignored",
+                    b"12345".as_slice(),
+                ),
+                (
+                    "eof",
+                    "Connection: close\r\n",
+                    "eof-body",
+                    b"eof-body".as_slice(),
+                ),
+            ] {
+                let path = directory.path().join(format!("{name}-{suffix}.new"));
+                let dispatcher = Arc::new(ScriptedDispatcher::new([
+                    format!("{version} 200 OK\r\n{headers}ETag: \"new\"\r\nSubscription-Userinfo: download=19\r\n\r\n{body}").into_bytes(),
+                ]));
+                let outcome = download_with_connector(
+                    request(dispatcher, "https://rules.example.test/file", path.clone()),
+                    &PlainHttpsConnector,
+                )
+                .await
+                .expect("download body");
+                let DownloadOutcome::Downloaded {
+                    size,
+                    sha256,
+                    etag,
+                    subscription_info,
+                    ..
+                } = outcome
+                else {
+                    panic!("download outcome")
+                };
+                assert_eq!(size, expected.len() as u64);
+                assert_eq!(sha256.as_slice(), Sha256::digest(expected).as_slice());
+                assert_eq!(etag.as_deref(), Some("\"new\""));
+                assert_eq!(subscription_info.unwrap().download, 19);
+                assert_eq!(fs::read(path).expect("downloaded file"), expected);
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn streams_body_beyond_former_file_size_limits() {
+        let directory = tempdir().unwrap();
+        let temporary_path = directory.path().join("large.new");
+        let length = 32 * 1024 * 1024 + 1;
+        let mut response =
+            format!("HTTP/1.1 200 OK\r\nContent-Length: {length}\r\n\r\n").into_bytes();
+        response.resize(response.len() + length, b'x');
+        let dispatcher = Arc::new(ScriptedDispatcher::new([response]));
+        let mut request = request(
+            dispatcher,
+            "https://rules.example.test/geoip.dat",
+            temporary_path.clone(),
+        );
+        request.timeout = Duration::from_secs(15);
+        let outcome = download_with_connector(request, &PlainHttpsConnector)
+            .await
+            .unwrap();
+        assert!(
+            matches!(outcome, DownloadOutcome::Downloaded { size, .. } if size == length as u64)
+        );
+        assert_eq!(fs::metadata(temporary_path).unwrap().len(), length as u64);
+    }
+
+    #[tokio::test]
+    async fn truncated_body_still_removes_partial_file() {
+        let directory = tempdir().unwrap();
+        let temporary_path = directory.path().join("truncated.new");
+        let dispatcher = Arc::new(ScriptedDispatcher::new([
+            b"HTTP/1.1 200 OK\r\nContent-Length: 8\r\n\r\nshort".to_vec(),
+        ]));
+        let error = download_with_connector(
+            request(
+                dispatcher,
+                "https://rules.example.test/geoip.dat",
+                temporary_path.clone(),
+            ),
+            &PlainHttpsConnector,
+        )
+        .await
+        .unwrap_err();
+        assert!(matches!(error, DownloadError::Protocol(_)));
+        assert!(!temporary_path.exists());
+    }
+
+    #[tokio::test]
+    async fn rejects_redirect_to_http_without_dispatching_the_second_hop() {
+        let directory = tempdir().expect("tempdir");
+        let temporary_path = directory.path().join("redirect.new");
+        let dispatcher = Arc::new(ScriptedDispatcher::new([
+            b"HTTP/1.1 302 Found\r\nLocation: http://unsafe.example.test/file\r\nContent-Length: 0\r\n\r\n".to_vec(),
+        ]));
+        let error = download_with_connector(
+            request(
+                dispatcher.clone(),
+                "https://rules.example.test/geoip.dat",
+                temporary_path.clone(),
+            ),
+            &PlainHttpsConnector,
+        )
+        .await
+        .expect_err("HTTP redirect must be rejected");
+
+        assert!(matches!(error, DownloadError::HttpsRequired));
+        assert_eq!(dispatcher.sessions().len(), 1);
+        assert!(!temporary_path.exists());
+    }
+
+    #[tokio::test]
+    async fn cancellation_wins_before_proxy_dispatch() {
+        let directory = tempdir().expect("tempdir");
+        let temporary_path = directory.path().join("cancelled.new");
+        let dispatcher = Arc::new(ScriptedDispatcher::new([
+            b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n".to_vec(),
+        ]));
+        let request = request(
+            dispatcher.clone(),
+            "https://rules.example.test/geoip.dat",
+            temporary_path.clone(),
+        );
+        request.cancellation.cancel();
+        let error = download_with_connector(request, &PlainHttpsConnector)
+            .await
+            .expect_err("cancelled request");
+
+        assert!(matches!(error, DownloadError::Cancelled));
+        assert!(dispatcher.sessions().is_empty());
+        assert!(!temporary_path.exists());
+    }
+
+    #[tokio::test]
+    async fn timeout_covers_proxy_connection_and_removes_temporary_file() {
+        let directory = tempdir().expect("tempdir");
+        let temporary_path = directory.path().join("timeout.new");
+        let mut request = request(
+            Arc::new(HangingDispatcher),
+            "https://rules.example.test/geoip.dat",
+            temporary_path.clone(),
+        );
+        request.timeout = Duration::from_millis(10);
+        let error = download_with_connector(request, &PlainHttpsConnector)
+            .await
+            .expect_err("request must time out");
+
+        assert!(matches!(
+            error,
+            DownloadError::TimedOut(duration)
+                if duration == Duration::from_millis(10)
+        ));
+        assert!(!temporary_path.exists());
+    }
+
+    #[tokio::test]
+    async fn shared_transport_applies_headers_size_limit_and_drop_cleanup() {
+        let root = tempdir().unwrap();
+        let dispatcher = Arc::new(ScriptedDispatcher::new([
+            b"HTTP/1.1 200 OK\r\nContent-Length: 4\r\n\r\ndata".to_vec(),
+        ]));
+        let path = root.path().join("candidate");
+        let mut input = request(
+            dispatcher.clone(),
+            "http://192.0.2.1/provider",
+            path.clone(),
+        );
+        input.etag = None;
+        input.options = HttpOptions {
+            user_agent: "shared-fixture".into(),
+            headers: vec![("X-Fixture".into(), "enabled".into())],
+            size_limit: Some(3),
+            allow_http: true,
+            allow_ip: true,
+        };
+        assert!(
+            download_with_connector(input, &PlainHttpsConnector)
+                .await
+                .is_err()
+        );
+        assert!(!path.exists());
+        let requests = dispatcher.requests.lock().unwrap();
+        let headers = String::from_utf8_lossy(&requests[0]);
+        assert!(headers.contains("User-Agent: shared-fixture\r\n"));
+        assert!(headers.contains("X-Fixture: enabled\r\n"));
+        assert!(!headers.contains("If-None-Match"));
+        drop(requests);
+        let mut future = Box::pin(download_with_connector(
+            request(
+                Arc::new(HangingDispatcher),
+                "https://rules.example.test/resource",
+                path.clone(),
+            ),
+            &PlainHttpsConnector,
+        ));
+        assert!(futures_util::poll!(&mut future).is_pending());
+        assert!(path.exists());
+        drop(future);
+        assert!(!path.exists());
+    }
+
+    #[test]
+    fn parser_rejects_ambiguous_or_unbounded_framing() {
+        let both = parse_response_head(
+            b"HTTP/1.1 200 OK\r\nContent-Length: 1\r\nTransfer-Encoding: chunked",
+        )
+        .expect("head parses");
+        assert!(matches!(
+            body_framing(&both),
+            Err(DownloadError::Protocol(_))
+        ));
+
+        let length = parse_response_head(b"HTTP/1.1 200 OK\r\nContent-Length: 33554433")
+            .expect("head parses");
+        assert_eq!(
+            body_framing(&length).unwrap(),
+            BodyFraming::ContentLength(33_554_433)
+        );
+        assert!(
+            parse_response_head(b"HTTP/1.1 200 OK\r\nContent-Length: 18446744073709551616")
+                .is_err()
+        );
+    }
+
+    #[test]
+    fn url_and_etag_validation_preserve_the_geodata_contract() {
+        assert!(matches!(
+            parse_resource_url("http://example.test/file"),
+            Err(DownloadError::HttpsRequired)
+        ));
+        assert!(matches!(
+            parse_resource_url("https://127.0.0.1/file"),
+            Err(DownloadError::DomainRequired)
+        ));
+        assert!(parse_resource_url("https://user@example.test/file").is_ok());
+        assert_eq!(
+            parse_resource_url("https://example.test/file#fragment")
+                .unwrap()
+                .as_str(),
+            "https://example.test/file"
+        );
+        assert!(parse_resource_url("ftp://example.test/file").is_err());
+        assert!(matches!(
+            validate_etag(Some("\"ok\"\r\nX-Evil: yes")),
+            Err(DownloadError::InvalidEtag)
+        ));
+    }
+
+    #[test]
+    fn download_endpoints_use_scheme_specific_ports_and_authorities() {
+        for (raw, port, authority) in [
+            ("https://example.test/file", 443, "example.test"),
+            ("https://example.test:80/file", 80, "example.test:80"),
+            ("https://example.test:8443/file", 8443, "example.test:8443"),
+        ] {
+            let endpoint = DownloadEndpoint::from_url(&parse_resource_url(raw).unwrap()).unwrap();
+            assert_eq!(endpoint.port, port);
+            assert_eq!(endpoint.authority, authority);
+        }
+    }
+
+    fn gzip(bytes: &[u8]) -> Vec<u8> {
+        let mut writer = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::fast());
+        writer.write_all(bytes).unwrap();
+        writer.finish().unwrap()
+    }
+
+    #[tokio::test]
+    async fn gzip_streams_all_framing_modes_and_limits_the_decoded_content() {
+        let directory = tempdir().unwrap();
+        let mut compressed = gzip(b"one");
+        compressed.extend_from_slice(&gzip(b"two"));
+        for framing in ["length", "chunked", "eof"] {
+            let body = if framing == "chunked" {
+                let mut body = Vec::new();
+                for part in compressed.chunks(3) {
+                    body.extend_from_slice(format!("{:x}\r\n", part.len()).as_bytes());
+                    body.extend_from_slice(part);
+                    body.extend_from_slice(b"\r\n");
+                }
+                body.extend_from_slice(b"0\r\n\r\n");
+                body
+            } else {
+                compressed.clone()
+            };
+            let head = match framing {
+                "length" => format!("Content-Length: {}\r\n", body.len()),
+                "chunked" => "Transfer-Encoding: chunked\r\n".into(),
+                _ => String::new(),
+            };
+            let mut response = format!(
+                "HTTP/1.1 200 OK\r\n{head}Content-Encoding: gzip\r\nETag: \"gzip\"\r\n\r\n"
+            )
+            .into_bytes();
+            response.extend_from_slice(&body);
+            let path = directory.path().join(framing);
+            let mut input = request(
+                Arc::new(ScriptedDispatcher::new([response])),
+                "https://subscription.example/file",
+                path.clone(),
+            );
+            input.options.size_limit = Some(6);
+            let outcome = download_with_connector(input, &PlainHttpsConnector)
+                .await
+                .unwrap();
+            assert!(
+                matches!(outcome,DownloadOutcome::Downloaded{size:6,sha256,..} if sha256.as_slice()==Sha256::digest(b"onetwo").as_slice())
+            );
+            assert_eq!(fs::read(path).unwrap(), b"onetwo");
+        }
+    }
+
+    #[tokio::test]
+    async fn gzip_corruption_truncation_expansion_and_cancelled_writes_discard_candidates() {
+        let directory = tempdir().unwrap();
+        let encoded = gzip(&vec![b'x'; 64 * 1024]);
+        let mut corrupted = encoded.clone();
+        let end = corrupted.len();
+        corrupted[end - 8] ^= 1;
+        for (index, body, limit) in [
+            (0, encoded.clone(), Some(16)),
+            (1, corrupted, None),
+            (2, encoded[..encoded.len() - 1].to_vec(), None),
+            (3, [encoded.as_slice(), b"junk"].concat(), None),
+        ] {
+            let mut response = format!(
+                "HTTP/1.1 200 OK\r\nContent-Encoding: gzip\r\nContent-Length: {}\r\n\r\n",
+                body.len()
+            )
+            .into_bytes();
+            response.extend_from_slice(&body);
+            let path = directory.path().join(index.to_string());
+            let mut input = request(
+                Arc::new(ScriptedDispatcher::new([response])),
+                "https://subscription.example/file",
+                path.clone(),
+            );
+            input.options.size_limit = limit;
+            assert!(
+                download_with_connector(input, &PlainHttpsConnector)
+                    .await
+                    .is_err()
+            );
+            assert!(!path.exists());
+        }
+        let path = directory.path().join("cancelled-decoder");
+        let cancellation = CancellationToken::new();
+        let sink = BodySink::new(
+            File::create(path).unwrap(),
+            None,
+            cancellation.clone(),
+            Instant::now() + Duration::from_secs(1),
+        );
+        let mut decoder = DecodedBody::new(sink, true);
+        cancellation.cancel();
+        assert!(decoder.write(&encoded).is_err());
+    }
+
+    #[tokio::test]
+    async fn url_basic_auth_is_percent_decoded_overrides_headers_and_never_crosses_origins() {
+        let directory = tempdir().unwrap();
+        let path = directory.path().join("basic");
+        let dispatcher=Arc::new(ScriptedDispatcher::new([
+            b"HTTP/1.1 302 Found\r\nLocation: /same\r\nContent-Length: 0\r\n\r\n".to_vec(),
+            b"HTTP/1.1 302 Found\r\nLocation: https://other.example/final\r\nContent-Length: 0\r\n\r\n".to_vec(),
+            b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n".to_vec(),
+        ]));
+        let mut input = request(
+            dispatcher.clone(),
+            "https://us%40er:pa%3Ass@subscription.example/start",
+            path,
+        );
+        input.options.headers = vec![
+            ("Authorization".into(), "Bearer must-be-replaced".into()),
+            ("Cookie".into(), "private=fixture".into()),
+        ];
+        let result = download_with_connector(input, &PlainHttpsConnector)
+            .await
+            .unwrap();
+        assert!(
+            matches!(result,DownloadOutcome::Downloaded{final_url,..} if final_url=="https://other.example/final")
+        );
+        let requests = dispatcher.requests();
+        for request in &requests[..2] {
+            let text = std::str::from_utf8(request).unwrap();
+            assert!(text.contains("Authorization: Basic dXNAZXI6cGE6c3M=\r\n"));
+            assert!(!text.contains("must-be-replaced"));
+            assert!(!text.contains("%40"));
+        }
+        let last = std::str::from_utf8(&requests[2]).unwrap();
+        assert!(!last.contains("Authorization:"));
+        assert!(!last.contains("Cookie:"));
+        assert!(parse_resource_url("https://user%GG:secret@subscription.example/file").is_err());
+    }
+
+    #[test]
+    fn exact_source_identity_preserves_credential_isolation_without_cleartext() {
+        let a = "https://user:one@subscription.example/file?token=private";
+        let b = "https://user:two@subscription.example/file?token=private";
+        let identity = source_identity(a);
+        assert_eq!(identity, source_identity(a));
+        assert_ne!(identity, source_identity(b));
+        assert_eq!(
+            source_origin(a).as_deref(),
+            Some("https://subscription.example")
+        );
+        assert_eq!(
+            without_credentials(&Url::parse(a).unwrap()),
+            "https://subscription.example/file?token=private"
+        );
+        assert!(!identity.contains("user"));
+        assert!(!identity.contains("private"));
+        let outcome = DownloadOutcome::Downloaded {
+            etag: Some("private-etag".into()),
+            sha256: [0; 32],
+            size: 1,
+            final_url: a.into(),
+            subscription_info: None,
+        };
+        let options = HttpOptions {
+            headers: vec![("Authorization".into(), "private-bearer".into())],
+            ..Default::default()
+        };
+        for debug in [format!("{outcome:?}"), format!("{options:?}")] {
+            assert!(!debug.contains("private"));
+            assert!(!debug.contains("user"));
+            assert!(!debug.contains("subscription.example"));
+        }
+    }
+
+    #[test]
+    fn request_identity_binds_effective_headers_and_ua_without_concat_ambiguity() {
+        let url = "https://subscription.example/file";
+        let options = HttpOptions {
+            headers: vec![
+                ("Cookie".into(), "a=1".into()),
+                ("Authorization".into(), "Bearer first".into()),
+            ],
+            user_agent: "fixture-first".into(),
+            ..Default::default()
+        };
+        let first = request_identity(url, &options).unwrap();
+        let mut reordered = options.clone();
+        reordered.headers.reverse();
+        reordered.headers[0].0.make_ascii_lowercase();
+        assert_eq!(first, request_identity(url, &reordered).unwrap());
+        for (headers, user_agent) in [
+            (
+                vec![
+                    ("Cookie".into(), "a=2".into()),
+                    ("Authorization".into(), "Bearer first".into()),
+                ],
+                options.user_agent.clone(),
+            ),
+            (options.headers.clone(), "fixture-second".into()),
+            (
+                vec![
+                    ("Cookie".into(), "a=1".into()),
+                    ("Authorization".into(), "Bearer second".into()),
+                ],
+                options.user_agent.clone(),
+            ),
+        ] {
+            let changed = HttpOptions {
+                headers,
+                user_agent,
+                ..Default::default()
+            };
+            assert_ne!(first, request_identity(url, &changed).unwrap());
+        }
+        let explicit = HttpOptions {
+            headers: vec![
+                ("User-Agent".into(), "explicit".into()),
+                ("Authorization".into(), "unused".into()),
+            ],
+            ..Default::default()
+        };
+        let mut changed = explicit.clone();
+        changed.user_agent = "unused-global-ua".into();
+        changed.headers[1].1 = "also-unused".into();
+        assert_eq!(
+            request_identity("https://user:pass@subscription.example/file", &explicit).unwrap(),
+            request_identity("https://user:pass@subscription.example/file", &changed).unwrap()
+        );
+        assert_ne!(first, source_identity(url));
+        assert!(!first.contains("Bearer"));
+        assert!(!first.contains("first"));
+    }
+}
diff --git a/src/resource/http_control.rs b/src/resource/http_control.rs
new file mode 100644
index 0000000..198a307
--- /dev/null
+++ b/src/resource/http_control.rs
@@ -0,0 +1,46 @@
+//! HTTP-rule refresh work owned by the shared runtime application worker.
+use crate::http_processing::{
+    config::{Document, PolicyCandidate},
+    providers::{DownloadContext, SourceContext, Store},
+};
+use std::sync::Arc;
+use tokio::sync::Mutex;
+use tokio_util::sync::CancellationToken;
+
+use super::config_apply::ApplyError;
+
+/// The runtime supplies its protected physical dispatcher and the admitted
+/// request's child cancellation token. No separate runtime, task or token can
+/// outlive the application worker's Stop barrier.
+pub(crate) async fn refresh(
+    document: Arc<Document>,
+    context: &SourceContext,
+    store: &Mutex<Store>,
+    network: &DownloadContext,
+    cancellation: &CancellationToken,
+    force: bool,
+) -> Result<Arc<PolicyCandidate>, ApplyError> {
+    if cancellation.is_cancelled() {
+        return Err(ApplyError::Stopped);
+    }
+    let mut store = store.try_lock().map_err(|_| ApplyError::Busy)?;
+    let candidate = store
+        .prepare(document, context, Some(network), cancellation, force)
+        .await
+        .map_err(|_| {
+            if cancellation.is_cancelled() {
+                ApplyError::Stopped
+            } else {
+                ApplyError::PreparationFailed
+            }
+        })?;
+    if cancellation.is_cancelled() {
+        Err(ApplyError::Stopped)
+    } else {
+        Ok(candidate)
+    }
+}
+
+#[cfg(test)]
+#[path = "http_control_tests.rs"]
+mod tests;
diff --git a/src/resource/http_control_tests.rs b/src/resource/http_control_tests.rs
new file mode 100644
index 0000000..86940cf
--- /dev/null
+++ b/src/resource/http_control_tests.rs
@@ -0,0 +1,131 @@
+use super::*;
+use crate::{
+    dispatch::{BoxStream, DatagramTransport, DispatchError, Dispatcher},
+    resource::config_apply::{ConfigApplyHandle, ConfigUpdate},
+    security::SecurityContext,
+    session::{DatagramSession, StreamSession},
+};
+use async_trait::async_trait;
+use std::sync::atomic::{AtomicBool, Ordering};
+use tokio::sync::Notify;
+
+struct PendingDispatcher {
+    entered: Arc<Notify>,
+    released: Arc<AtomicBool>,
+}
+struct ConnectionGuard(Arc<AtomicBool>);
+impl Drop for ConnectionGuard {
+    fn drop(&mut self) {
+        self.0.store(true, Ordering::Release);
+    }
+}
+#[async_trait]
+impl Dispatcher for PendingDispatcher {
+    async fn connect_tcp(&self, _: StreamSession) -> Result<BoxStream, DispatchError> {
+        let _guard = ConnectionGuard(self.released.clone());
+        self.entered.notify_one();
+        std::future::pending().await
+    }
+    async fn open_datagram(
+        &self,
+        _: DatagramSession,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        Err(DispatchError::NotAllowed)
+    }
+}
+fn network() -> (DownloadContext, Arc<Notify>, Arc<AtomicBool>) {
+    let entered = Arc::new(Notify::new());
+    let released = Arc::new(AtomicBool::new(false));
+    let network = DownloadContext {
+        dispatcher: Arc::new(PendingDispatcher {
+            entered: entered.clone(),
+            released: released.clone(),
+        }),
+        security: SecurityContext::new(),
+    };
+    (network, entered, released)
+}
+
+#[tokio::test]
+async fn admitted_http_refresh_uses_supplied_dispatcher_and_joins_cancellation() {
+    let root = tempfile::tempdir().unwrap();
+    let document = Document::parse("rewrite-providers: {remote: {type: http, url: 'http://rules.example.test/rules.yaml', path: rules.yaml}}\nrewrite: {rules: [{rule-set: remote}]}\n").unwrap();
+    let context = SourceContext {
+        data_dir: Some(root.path().into()),
+        ..Default::default()
+    };
+    let store = Arc::new(Mutex::new(Store::new()));
+    let stop = CancellationToken::new();
+    let (handle, mut requests) = ConfigApplyHandle::channel(stop.clone());
+    let pending = handle
+        .try_admit()
+        .unwrap()
+        .submit(ConfigUpdate::RefreshHttp {
+            document: document.clone(),
+            context: context.clone(),
+            store: store.clone(),
+            force: true,
+            security: None,
+            reply: None,
+        })
+        .unwrap();
+    let (network, entered, released) = network();
+    let worker = tokio::spawn(async move {
+        let mut request = requests.recv().await.unwrap();
+        let cancellation = request.cancellation();
+        let ConfigUpdate::RefreshHttp {
+            document,
+            context,
+            store,
+            force,
+            ..
+        } = request.take_update()
+        else {
+            panic!("refresh request");
+        };
+        let result = refresh(document, &context, &store, &network, &cancellation, force)
+            .await
+            .map(|_| ());
+        request.complete(result);
+    });
+    tokio::time::timeout(std::time::Duration::from_secs(5), entered.notified())
+        .await
+        .unwrap();
+    assert!(matches!(handle.try_admit(), Err(ApplyError::Busy)));
+    stop.cancel();
+    assert_eq!(pending.wait().await, Err(ApplyError::Stopped));
+    worker.await.unwrap();
+    assert!(released.load(Ordering::Acquire));
+    assert!(matches!(handle.try_admit(), Err(ApplyError::Stopped)));
+    assert!(
+        store
+            .lock()
+            .await
+            .prepared(&document, &context)
+            .unwrap()
+            .is_none()
+    );
+    assert_eq!(std::fs::read_dir(root.path()).unwrap().count(), 0);
+}
+
+#[tokio::test]
+async fn http_refresh_reports_store_contention_without_starting_more_work() {
+    let document = Document::parse("{}").unwrap();
+    let store = Mutex::new(Store::new());
+    let _busy = store.lock().await;
+    let (network, _, _) = network();
+    let result = tokio::time::timeout(
+        std::time::Duration::from_secs(5),
+        refresh(
+            document,
+            &SourceContext::default(),
+            &store,
+            &network,
+            &CancellationToken::new(),
+            true,
+        ),
+    )
+    .await
+    .unwrap();
+    assert!(matches!(result, Err(ApplyError::Busy)));
+}
diff --git a/src/resource/mod.rs b/src/resource/mod.rs
new file mode 100644
index 0000000..c168a78
--- /dev/null
+++ b/src/resource/mod.rs
@@ -0,0 +1,16 @@
+//! Resource acquisition shared by GeoData and providers.
+pub(crate) mod age_provider;
+pub(crate) mod bundle;
+mod bundle_limits;
+pub(crate) mod cache;
+#[cfg(any(feature = "invoke", test))]
+pub(crate) mod config_apply;
+pub(crate) mod control;
+pub(crate) mod http;
+#[cfg(any(feature = "invoke", test))]
+pub(crate) mod http_control;
+pub(crate) mod paths;
+pub(crate) mod probe;
+pub(crate) mod profile;
+pub(crate) mod provider_input;
+pub(crate) mod subscription;
diff --git a/src/resource/paths.rs b/src/resource/paths.rs
new file mode 100644
index 0000000..5f09d6d
--- /dev/null
+++ b/src/resource/paths.rs
@@ -0,0 +1,319 @@
+//! Session-owned provider authorization. It grants no general filesystem access.
+#[cfg(any(feature = "invoke", test))]
+use std::{env, ffi::OsString};
+use std::{
+    fs, io,
+    path::{Component, Path, PathBuf},
+    sync::Arc,
+};
+
+#[derive(Clone, PartialEq, Eq)]
+struct SafeRoot {
+    requested: PathBuf,
+    canonical: PathBuf,
+}
+#[derive(Clone, PartialEq, Eq)]
+struct ReservedPath {
+    path: PathBuf,
+    private: bool,
+}
+#[derive(Clone, Default, PartialEq, Eq)]
+pub(crate) struct ProviderPaths {
+    roots: Arc<[SafeRoot]>,
+    reserved: Arc<[ReservedPath]>,
+}
+impl std::fmt::Debug for ProviderPaths {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ProviderPaths")
+            .field("roots", &self.roots.len())
+            .finish_non_exhaustive()
+    }
+}
+#[derive(Clone, Copy)]
+pub(crate) enum Access {
+    FileRead,
+    CacheRead,
+    CacheWrite,
+}
+impl ProviderPaths {
+    #[cfg(any(feature = "invoke", test))]
+    pub(crate) fn from_os_value(value: Option<OsString>, cwd: &Path) -> io::Result<Self> {
+        let Some(value) = value.filter(|value| !value.is_empty()) else {
+            return Ok(Self::default());
+        };
+        if value.as_encoded_bytes().len() > 64 * 1024 {
+            return Err(denied());
+        }
+        let mut roots = Vec::new();
+        for root in env::split_paths(&value).filter(|root| !root.as_os_str().is_empty()) {
+            if roots.len() == 64 {
+                return Err(denied());
+            }
+            let requested = if root.is_absolute() {
+                root
+            } else {
+                cwd.join(root)
+            };
+            let canonical = fs::canonicalize(&requested)?;
+            if !fs::metadata(&canonical)?.is_dir() {
+                return Err(denied());
+            }
+            if !roots
+                .iter()
+                .any(|root: &SafeRoot| root.canonical == canonical)
+            {
+                roots.push(SafeRoot {
+                    requested,
+                    canonical,
+                });
+            }
+        }
+        Ok(Self {
+            roots: roots.into(),
+            reserved: Arc::default(),
+        })
+    }
+    #[cfg(feature = "invoke")]
+    pub(crate) fn authorization_only(&self) -> Self {
+        Self {
+            roots: self.roots.clone(),
+            reserved: Arc::default(),
+        }
+    }
+    #[cfg(any(feature = "invoke", test))]
+    pub(crate) fn reserve_inputs(&mut self, paths: impl IntoIterator<Item = (PathBuf, bool)>) {
+        self.reserved = paths
+            .into_iter()
+            .map(|(path, private)| ReservedPath { path, private })
+            .collect::<Vec<_>>()
+            .into();
+    }
+    pub(crate) fn reserved_inputs(&self) -> impl Iterator<Item = (&Path, bool)> {
+        self.reserved
+            .iter()
+            .map(|reserved| (reserved.path.as_path(), reserved.private))
+    }
+    /// Share input protection with resources whose absolute paths have their
+    /// own authorization contract. A snapshot adoption only checks spelling;
+    /// every operation that can touch files also checks canonical aliases.
+    pub(crate) fn check_reserved(
+        &self,
+        target: &Path,
+        access: Access,
+        canonical: bool,
+    ) -> io::Result<()> {
+        let actual = if canonical && !self.reserved.is_empty() {
+            Some(canonical_target(target)?)
+        } else {
+            None
+        };
+        for (path, _) in self
+            .reserved_inputs()
+            .filter(|(_, private)| *private || matches!(access, Access::CacheWrite))
+        {
+            if path == target
+                || actual
+                    .as_ref()
+                    .is_some_and(|actual| canonical_target(path).is_ok_and(|path| path == *actual))
+            {
+                return Err(denied());
+            }
+        }
+        Ok(())
+    }
+    pub(crate) fn resolve(
+        &self,
+        data_dir: &Path,
+        requested: &Path,
+        access: Access,
+    ) -> io::Result<PathBuf> {
+        let default = fs::canonicalize(data_dir)?;
+        let target = if requested.is_absolute() {
+            requested.to_owned()
+        } else {
+            default.join(requested)
+        };
+        let (root, target) = if target.starts_with(&default) {
+            (default.clone(), target)
+        } else {
+            self.roots
+                .iter()
+                .find_map(|root| {
+                    target
+                        .strip_prefix(&root.requested)
+                        .or_else(|_| target.strip_prefix(&root.canonical))
+                        .ok()
+                        .map(|relative| (root.canonical.clone(), root.canonical.join(relative)))
+                })
+                .ok_or_else(denied)?
+        };
+        let relative = target.strip_prefix(&root).map_err(|_| denied())?;
+        if relative
+            .components()
+            .any(|part| matches!(part, Component::ParentDir))
+        {
+            return Err(denied());
+        }
+        let parent = target.parent().ok_or_else(denied)?;
+        let mut ancestor = parent;
+        while !ancestor.exists() {
+            ancestor = ancestor.parent().ok_or_else(denied)?;
+        }
+        if !fs::canonicalize(ancestor)?.starts_with(&root) {
+            return Err(denied());
+        }
+        self.check_reserved(&target, access, true)?;
+        if matches!(access, Access::CacheWrite) {
+            fs::create_dir_all(parent)?;
+            if !fs::canonicalize(parent)?.starts_with(&root) {
+                return Err(denied());
+            }
+        }
+        match fs::symlink_metadata(&target) {
+            Ok(_) if !fs::canonicalize(&target)?.starts_with(&root) => return Err(denied()),
+            Ok(_) => (),
+            Err(error) if error.kind() == io::ErrorKind::NotFound => (),
+            Err(error) => return Err(error),
+        }
+        Ok(target)
+    }
+}
+fn canonical_target(path: &Path) -> io::Result<PathBuf> {
+    let mut ancestor = path;
+    let mut missing = Vec::new();
+    loop {
+        match fs::canonicalize(ancestor) {
+            Ok(mut canonical) => {
+                for name in missing.iter().rev() {
+                    canonical.push(name);
+                }
+                return Ok(canonical);
+            }
+            Err(error) if error.kind() == io::ErrorKind::NotFound => {
+                missing.push(ancestor.file_name().ok_or_else(denied)?.to_os_string());
+                ancestor = ancestor.parent().ok_or_else(denied)?;
+            }
+            Err(error) => return Err(error),
+        }
+    }
+}
+fn denied() -> io::Error {
+    io::Error::new(
+        io::ErrorKind::PermissionDenied,
+        "provider path escapes authorized roots",
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn provider_roots_separate_reads_and_http_cache_writes() {
+        let root = tempfile::tempdir().unwrap();
+        let data = root.path().join("data");
+        let shared = root.path().join("shared");
+        let outside = root.path().join("outside");
+        for directory in [&data, &shared, &outside] {
+            fs::create_dir(directory).unwrap();
+        }
+        let paths =
+            ProviderPaths::from_os_value(Some(env::join_paths([&shared]).unwrap()), root.path())
+                .unwrap();
+        let file = shared.join("source.yaml");
+        fs::write(&file, b"payload: []").unwrap();
+        assert_eq!(
+            paths.resolve(&data, &file, Access::FileRead).unwrap(),
+            fs::canonicalize(&file).unwrap()
+        );
+        assert!(
+            ProviderPaths::default()
+                .resolve(&data, &file, Access::FileRead)
+                .is_err()
+        );
+        let cache = shared.join("cache/resource.yaml");
+        paths.resolve(&data, &cache, Access::CacheRead).unwrap();
+        assert!(!cache.parent().unwrap().exists());
+        paths.resolve(&data, &cache, Access::CacheWrite).unwrap();
+        assert!(cache.parent().unwrap().is_dir());
+        assert!(
+            paths
+                .resolve(&data, &outside.join("resource"), Access::CacheWrite)
+                .is_err()
+        );
+        assert!(!outside.join("resource").exists());
+        let main = shared.join("main.yaml");
+        let private = shared.join("private.json");
+        fs::write(&main, b"rules: []").unwrap();
+        fs::write(&private, b"private-fixture").unwrap();
+        let mut guarded = paths.clone();
+        guarded.reserve_inputs([(main.clone(), false), (private.clone(), true)]);
+        assert!(guarded.resolve(&data, &main, Access::FileRead).is_ok());
+        assert!(guarded.resolve(&data, &main, Access::CacheWrite).is_err());
+        assert!(guarded.resolve(&data, &private, Access::FileRead).is_err());
+        assert!(
+            guarded
+                .resolve(&data, &private, Access::CacheWrite)
+                .is_err()
+        );
+        assert!(
+            paths
+                .resolve(
+                    &data,
+                    &shared.join("../outside/resource"),
+                    Access::CacheWrite
+                )
+                .is_err()
+        );
+    }
+    #[cfg(unix)]
+    #[test]
+    fn provider_roots_preserve_aliases_and_reject_symlink_escapes() {
+        #[cfg(target_os = "linux")]
+        use std::os::unix::ffi::OsStringExt;
+        use std::os::unix::fs::symlink;
+        let root = tempfile::tempdir().unwrap();
+        let data = root.path().join("data");
+        #[cfg(target_os = "linux")]
+        let shared = root.path().join(OsString::from_vec(vec![b's', 255]));
+        #[cfg(not(target_os = "linux"))]
+        let shared = root.path().join("shared-目录");
+        let outside = root.path().join("outside");
+        for directory in [&data, &shared, &outside] {
+            fs::create_dir(directory).unwrap();
+        }
+        let paths =
+            ProviderPaths::from_os_value(Some(env::join_paths([&shared]).unwrap()), root.path())
+                .unwrap();
+        let file = shared.join("source.yaml");
+        fs::write(&file, b"payload: []").unwrap();
+        assert_eq!(
+            paths.resolve(&data, &file, Access::FileRead).unwrap(),
+            fs::canonicalize(&file).unwrap()
+        );
+        symlink(&outside, shared.join("escape")).unwrap();
+        assert!(
+            paths
+                .resolve(&data, &shared.join("escape/cache.yaml"), Access::CacheWrite)
+                .is_err()
+        );
+        let external = outside.join("source.yaml");
+        fs::write(&external, b"private-fixture").unwrap();
+        symlink(&external, shared.join("escaped-file.yaml")).unwrap();
+        assert!(
+            paths
+                .resolve(&data, &shared.join("escaped-file.yaml"), Access::FileRead)
+                .is_err()
+        );
+        let alias = root.path().join("authorized-alias");
+        symlink(&shared, &alias).unwrap();
+        let alias_paths =
+            ProviderPaths::from_os_value(Some(env::join_paths([&alias]).unwrap()), root.path())
+                .unwrap();
+        assert_eq!(
+            alias_paths
+                .resolve(&data, &alias.join("source.yaml"), Access::FileRead)
+                .unwrap(),
+            fs::canonicalize(&file).unwrap()
+        );
+    }
+}
diff --git a/src/resource/probe.rs b/src/resource/probe.rs
new file mode 100644
index 0000000..a81ec0c
--- /dev/null
+++ b/src/resource/probe.rs
@@ -0,0 +1,408 @@
+//! Shared, bounded HTTP(S) health probes through the runtime dispatcher.
+use crate::security::{SecurityContext, StandardTlsClient, TlsClientOptions};
+use crate::{
+    dispatch::{BoxStream, DispatchError, Dispatcher},
+    inbound::DEFAULT_HEADER_LIMIT,
+    outbound::{OutboundDiagnostic, capture_outbound_diagnostic},
+    session::{Destination, InboundKind, StreamSession},
+};
+use std::{
+    io,
+    net::{IpAddr, Ipv4Addr, SocketAddr},
+    sync::Arc,
+    time::{Duration, Instant},
+};
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio_util::sync::CancellationToken;
+use url::{Host, Url};
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum TargetScheme {
+    Http,
+    Https,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum TargetHost {
+    Domain(String),
+    Ip(IpAddr),
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct Target {
+    scheme: TargetScheme,
+    pub(crate) destination: Destination,
+    pub(crate) authority: String,
+    pub(crate) origin_form: String,
+    tls_server_name: String,
+}
+
+impl Target {
+    pub(crate) fn parse(raw: &str) -> io::Result<Self> {
+        let url = Url::parse(raw).map_err(|_| invalid_input("url is not a valid absolute URL"))?;
+        let scheme = match url.scheme() {
+            "http" => TargetScheme::Http,
+            "https" => TargetScheme::Https,
+            _ => {
+                return Err(invalid_input("url scheme must be http or https"));
+            }
+        };
+        if !url.username().is_empty() || url.password().is_some() || url.fragment().is_some() {
+            return Err(invalid_input(
+                "url must not contain authentication or a fragment",
+            ));
+        }
+        let host = match url.host() {
+            Some(Host::Domain(domain)) => {
+                if domain.len() > u8::MAX as usize {
+                    return Err(invalid_input("url host is too long"));
+                }
+                TargetHost::Domain(domain.to_owned())
+            }
+            Some(Host::Ipv4(address)) => TargetHost::Ip(IpAddr::V4(address)),
+            Some(Host::Ipv6(address)) => TargetHost::Ip(IpAddr::V6(address)),
+            None => return Err(invalid_input("url must contain a host")),
+        };
+        let port = url
+            .port_or_known_default()
+            .ok_or_else(|| invalid_input("url must contain a port"))?;
+        let destination = match &host {
+            TargetHost::Domain(domain) => {
+                Destination::domain(domain.clone(), port).map_err(invalid_input)?
+            }
+            TargetHost::Ip(address) => Destination::Ip(SocketAddr::new(*address, port)),
+        };
+        let authority = authority(&host, port);
+        let mut origin_form = url.path().to_owned();
+        if origin_form.is_empty() {
+            origin_form.push('/');
+        }
+        if let Some(query) = url.query() {
+            origin_form.push('?');
+            origin_form.push_str(query);
+        }
+        let tls_server_name = match &host {
+            TargetHost::Domain(domain) => domain.clone(),
+            TargetHost::Ip(address) => address.to_string(),
+        };
+        Ok(Self {
+            scheme,
+            destination,
+            authority,
+            origin_form,
+            tls_server_name,
+        })
+    }
+}
+
+fn authority(host: &TargetHost, port: u16) -> String {
+    match host {
+        TargetHost::Domain(domain) => format!("{domain}:{port}"),
+        TargetHost::Ip(IpAddr::V4(address)) => format!("{address}:{port}"),
+        TargetHost::Ip(IpAddr::V6(address)) => format!("[{address}]:{port}"),
+    }
+}
+
+async fn connect(
+    target: &Target,
+    dispatcher: Arc<dyn Dispatcher>,
+    security: &SecurityContext,
+) -> io::Result<BoxStream> {
+    let session = StreamSession {
+        metadata: Default::default(),
+        inbound: InboundKind::InternalMeasure,
+        source: SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 0),
+        destination: target.destination.clone(),
+        sniffed_domain: None,
+    };
+    let (stream, diagnostic) = capture_outbound_diagnostic(dispatcher.connect_tcp(session)).await;
+    let stream = stream.map_err(|error| outbound_connect_error(error, diagnostic.as_ref()))?;
+    let stream = if target.scheme == TargetScheme::Https {
+        let client = StandardTlsClient::with_options(
+            security,
+            &target.tls_server_name,
+            TlsClientOptions {
+                alpn: vec![b"http/1.1".to_vec()],
+                ..Default::default()
+            },
+            0,
+            64 * 1024,
+        )?;
+        connect_target_tls(&client, stream).await?
+    } else {
+        stream
+    };
+    Ok(stream)
+}
+
+fn outbound_connect_error(
+    error: DispatchError,
+    diagnostic: Option<&OutboundDiagnostic>,
+) -> io::Error {
+    let diagnostic = diagnostic.map_or_else(String::new, |diagnostic| {
+        format!(
+            " (Vole outbound stage={} kind={} error={:?})",
+            diagnostic.stage(),
+            diagnostic.kind(),
+            diagnostic.message()
+        )
+    });
+    io::Error::other(format!("outbound connect failed: {error}{diagnostic}"))
+}
+
+async fn connect_target_tls(
+    connector: &StandardTlsClient,
+    stream: BoxStream,
+) -> io::Result<BoxStream> {
+    connector
+        .connect(stream)
+        .await
+        .map_err(|_| io::Error::other("probe TLS handshake failed"))
+}
+
+async fn head(stream: &mut BoxStream, target: &Target, keep_alive: bool) -> io::Result<u16> {
+    let connection = if keep_alive { "keep-alive" } else { "close" };
+    stream.write_all(format!("HEAD {} HTTP/1.1\r\nHost: {}\r\nAccept: */*\r\nUser-Agent: Vole/{}\r\nConnection: {connection}\r\n\r\n",target.origin_form,target.authority,env!("CARGO_PKG_VERSION")).as_bytes()).await?;
+    stream.flush().await?;
+    read_response_status(stream).await
+}
+#[cfg(test)]
+pub(crate) async fn probe_once(
+    target: &Target,
+    dispatcher: Arc<dyn Dispatcher>,
+    security: &SecurityContext,
+) -> io::Result<()> {
+    let mut stream = connect(target, dispatcher, security).await?;
+    head(&mut stream, target, false).await.map(drop)
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) struct Observation {
+    pub delay: u64,
+    pub status: u16,
+    pub expected_matches: bool,
+}
+
+pub(crate) async fn probe(
+    target: &Target,
+    dispatcher: Arc<dyn Dispatcher>,
+    timeout: Duration,
+    unified: bool,
+    expected: &[(u16, u16)],
+    cancel: &CancellationToken,
+    security: &SecurityContext,
+) -> io::Result<u64> {
+    let observation = observe(
+        target, dispatcher, timeout, unified, expected, cancel, security,
+    )
+    .await?;
+    if observation.expected_matches {
+        Ok(observation.delay)
+    } else {
+        Err(io::Error::other("unexpected health check status"))
+    }
+}
+
+pub(crate) async fn observe(
+    target: &Target,
+    dispatcher: Arc<dyn Dispatcher>,
+    timeout: Duration,
+    unified: bool,
+    expected: &[(u16, u16)],
+    cancel: &CancellationToken,
+    security: &SecurityContext,
+) -> io::Result<Observation> {
+    let operation = async {
+        let mut started = Instant::now();
+        let mut stream = connect(target, dispatcher, security).await?;
+        let mut status = head(&mut stream, target, unified).await?;
+        if unified {
+            let second = Instant::now();
+            if let Ok(next) = head(&mut stream, target, false).await {
+                started = second;
+                status = next;
+            }
+        }
+        Ok(Observation {
+            delay: started.elapsed().as_millis().min(u64::MAX as u128) as u64,
+            status,
+            expected_matches: expected.is_empty()
+                || expected
+                    .iter()
+                    .any(|(start, end)| (*start..=*end).contains(&status)),
+        })
+    };
+    tokio::select! {biased;
+        ()=cancel.cancelled()=>Err(io::ErrorKind::Interrupted.into()),
+        result=tokio::time::timeout(timeout,operation)=>result.map_err(|_| io::Error::new(io::ErrorKind::TimedOut,"health check timed out"))?
+    }
+}
+fn invalid_input(message: impl std::fmt::Display) -> io::Error {
+    io::Error::new(io::ErrorKind::InvalidInput, message.to_string())
+}
+
+pub(crate) async fn read_response_status<R>(reader: &mut R) -> io::Result<u16>
+where
+    R: tokio::io::AsyncRead + Unpin + ?Sized,
+{
+    let mut input = Vec::with_capacity(1024);
+    let mut total_read = 0_usize;
+    loop {
+        if let Some(end) = input.windows(4).position(|window| window == b"\r\n\r\n") {
+            let status = parse_status(&input[..end])?;
+            if (100..200).contains(&status) && status != 101 {
+                input.drain(..end + 4);
+                continue;
+            }
+            return Ok(status);
+        }
+        if total_read >= DEFAULT_HEADER_LIMIT {
+            return Err(io::Error::new(
+                io::ErrorKind::FileTooLarge,
+                "HTTP response heads exceed their aggregate limit",
+            ));
+        }
+        let mut chunk = [0_u8; 1024];
+        let remaining = DEFAULT_HEADER_LIMIT - total_read;
+        let max_read = remaining.min(chunk.len());
+        let length = reader.read(&mut chunk[..max_read]).await?;
+        if length == 0 {
+            return Err(io::Error::new(
+                io::ErrorKind::UnexpectedEof,
+                "HTTP connection closed before the response head",
+            ));
+        }
+        total_read += length;
+        input.extend_from_slice(&chunk[..length]);
+    }
+}
+
+pub(crate) fn parse_status(head: &[u8]) -> io::Result<u16> {
+    let line_end = head
+        .windows(2)
+        .position(|window| window == b"\r\n")
+        .unwrap_or(head.len());
+    let line = &head[..line_end];
+    let mut fields = line.splitn(3, |byte| *byte == b' ');
+    let version = fields.next().unwrap_or_default();
+    let status = fields.next().unwrap_or_default();
+    if (version != b"HTTP/1.0" && version != b"HTTP/1.1")
+        || status.len() != 3
+        || !status.iter().all(u8::is_ascii_digit)
+    {
+        return Err(invalid_data("invalid HTTP response status line"));
+    }
+    let status = u16::from(status[0] - b'0') * 100
+        + u16::from(status[1] - b'0') * 10
+        + u16::from(status[2] - b'0');
+    if !(100..=599).contains(&status) {
+        return Err(invalid_data("HTTP response status is out of range"));
+    }
+    Ok(status)
+}
+
+fn invalid_data(message: &'static str) -> io::Error {
+    io::Error::new(io::ErrorKind::InvalidData, message)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{dispatch::DatagramTransport, session::DatagramSession};
+    use std::sync::Mutex;
+    struct Memory(Mutex<Option<BoxStream>>);
+    #[async_trait::async_trait]
+    impl Dispatcher for Memory {
+        async fn connect_tcp(&self, _: StreamSession) -> Result<BoxStream, DispatchError> {
+            Ok(self.0.lock().unwrap().take().unwrap())
+        }
+        async fn open_datagram(
+            &self,
+            _: DatagramSession,
+        ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+            Err(DispatchError::NotAllowed)
+        }
+    }
+
+    #[tokio::test]
+    async fn observation_retains_final_status_independently_of_expected_policy() {
+        let (client, mut server) = tokio::io::duplex(4096);
+        let dispatcher = Arc::new(Memory(Mutex::new(Some(Box::new(client)))));
+        let peer = tokio::spawn(async move {
+            for status in [204, 500] {
+                let mut head = Vec::new();
+                while !head.ends_with(b"\r\n\r\n") {
+                    head.push(server.read_u8().await.unwrap());
+                }
+                server
+                    .write_all(
+                        format!("HTTP/1.1 {status} Response\r\nContent-Length: 0\r\n\r\n")
+                            .as_bytes(),
+                    )
+                    .await
+                    .unwrap();
+            }
+        });
+        let observation = observe(
+            &Target::parse("http://example.test/").unwrap(),
+            dispatcher,
+            Duration::from_secs(1),
+            true,
+            &[(204, 204)],
+            &CancellationToken::new(),
+            &SecurityContext::new(),
+        )
+        .await
+        .unwrap();
+        assert_eq!(observation.status, 500);
+        assert!(!observation.expected_matches);
+        peer.await.unwrap();
+    }
+
+    #[tokio::test]
+    async fn unified_probe_reuses_stream_checks_status_and_cancels() {
+        let (client, mut server) = tokio::io::duplex(4096);
+        let dispatcher = Arc::new(Memory(Mutex::new(Some(Box::new(client)))));
+        let peer = tokio::spawn(async move {
+            for _ in 0..2 {
+                let mut head = Vec::new();
+                while !head.ends_with(b"\r\n\r\n") {
+                    head.push(server.read_u8().await.unwrap());
+                }
+                assert!(head.starts_with(b"HEAD / HTTP/1.1"));
+                server
+                    .write_all(b"HTTP/1.1 204 No Content\r\nContent-Length: 0\r\n\r\n")
+                    .await
+                    .unwrap();
+            }
+        });
+        let cancel = CancellationToken::new();
+        let target = Target::parse("http://example.test/").unwrap();
+        probe(
+            &target,
+            dispatcher.clone(),
+            Duration::from_secs(1),
+            true,
+            &[(204, 204)],
+            &cancel,
+            &SecurityContext::new(),
+        )
+        .await
+        .unwrap();
+        peer.await.unwrap();
+        cancel.cancel();
+        assert_eq!(
+            probe(
+                &target,
+                dispatcher,
+                Duration::from_secs(1),
+                false,
+                &[],
+                &cancel,
+                &SecurityContext::new(),
+            )
+            .await
+            .unwrap_err()
+            .kind(),
+            io::ErrorKind::Interrupted
+        );
+    }
+}
diff --git a/src/resource/profile.rs b/src/resource/profile.rs
new file mode 100644
index 0000000..c935176
--- /dev/null
+++ b/src/resource/profile.rs
@@ -0,0 +1,60 @@
+//! Runtime-owned selection cache. The source YAML is never rewritten.
+use std::{
+    collections::BTreeMap,
+    fs,
+    io::{self, Read},
+    path::{Path, PathBuf},
+    sync::Mutex,
+};
+#[derive(Debug)]
+pub(crate) struct SelectionStore {
+    path: Option<PathBuf>,
+    values: Mutex<BTreeMap<String, String>>,
+}
+impl SelectionStore {
+    pub fn open(root: &Path, enabled: bool) -> Self {
+        let path = enabled.then(|| root.join("selected.json"));
+        let values = path
+            .as_ref()
+            .and_then(|path| {
+                let file = fs::File::open(path).ok()?;
+                let mut bytes = Vec::new();
+                file.take(8 * 1024 * 1024 + 1)
+                    .read_to_end(&mut bytes)
+                    .ok()?;
+                if bytes.len() > 8 * 1024 * 1024 {
+                    return None;
+                }
+                serde_json::from_slice(&bytes).ok()
+            })
+            .unwrap_or_default();
+        Self {
+            path,
+            values: Mutex::new(values),
+        }
+    }
+    pub fn restore(&self, groups: &crate::routing::ProxyGroups) {
+        for (name, member) in self.values.lock().unwrap().iter() {
+            let _ = groups.select(name, member);
+        }
+    }
+    pub fn save(&self, name: &str, member: &str) -> io::Result<()> {
+        let Some(path) = &self.path else {
+            return Ok(());
+        };
+        let mut values = self.values.lock().unwrap();
+        values.insert(name.into(), member.into());
+        let temporary = path.with_extension(format!("{}.tmp", std::process::id()));
+        let result = (|| {
+            fs::write(
+                &temporary,
+                serde_json::to_vec(&*values).map_err(io::Error::other)?,
+            )?;
+            fs::rename(&temporary, path)
+        })();
+        if result.is_err() {
+            let _ = fs::remove_file(temporary);
+        }
+        result
+    }
+}
diff --git a/src/resource/provider_input.rs b/src/resource/provider_input.rs
new file mode 100644
index 0000000..f4c6399
--- /dev/null
+++ b/src/resource/provider_input.rs
@@ -0,0 +1,1179 @@
+//! Bounded subscription URI conversion into the ordinary strict node schema.
+//! Wire and transport semantics remain owned by configuration and outbounds.
+use std::{
+    borrow::Cow,
+    collections::{BTreeMap, HashSet},
+};
+
+use base64::{
+    Engine as _,
+    engine::general_purpose::{STANDARD, STANDARD_NO_PAD, URL_SAFE, URL_SAFE_NO_PAD},
+};
+use serde_json::{Map, Value, json};
+use url::{Host, Url};
+
+use super::age_provider::DecodeControl;
+use crate::{Result, VoleError, config::MAX_CONFIG_BYTES};
+
+const CONVERSION_BUDGET: usize = MAX_CONFIG_BYTES * 4;
+const MAX_URI_LINE_BYTES: usize = 64 * 1024;
+// Reserve scratch before URL/query parsing, decoded credentials, JSON/YAML
+// conversion and cloned transport options. It is released after each line;
+// retained nodes and name indexes remain charged separately. This deliberately
+// overestimates small-token trees rather than measuring allocator internals.
+fn scratch_allowance(bytes: usize) -> Result<usize> {
+    bytes
+        .checked_mul(256)
+        .and_then(|bytes| bytes.checked_add(64 * 1024))
+        .ok_or_else(invalid)
+}
+
+fn invalid() -> VoleError {
+    VoleError::InvalidConfig("invalid or unsupported proxy subscription content".into())
+}
+
+fn decode64(input: &[u8], url_safe: bool) -> Option<Vec<u8>> {
+    if input.len() > MAX_CONFIG_BYTES
+        || !input.iter().all(|c| {
+            c.is_ascii_alphanumeric() || b"+/=\r\n".contains(c) || url_safe && b"-_".contains(c)
+        })
+    {
+        return None;
+    }
+    let clean: Cow<'_, [u8]> = if input.contains(&b'\r') || input.contains(&b'\n') {
+        Cow::Owned(
+            input
+                .iter()
+                .copied()
+                .filter(|b| !matches!(b, b'\r' | b'\n'))
+                .collect(),
+        )
+    } else {
+        Cow::Borrowed(input)
+    };
+    STANDARD_NO_PAD
+        .decode(&clean)
+        .or_else(|_| STANDARD.decode(&clean))
+        .or_else(|error| {
+            if url_safe {
+                URL_SAFE_NO_PAD
+                    .decode(&clean)
+                    .or_else(|_| URL_SAFE.decode(&clean))
+            } else {
+                Err(error)
+            }
+        })
+        .ok()
+}
+
+fn unescape(input: &str) -> Result<String> {
+    let mut output = Vec::with_capacity(input.len());
+    let mut bytes = input.bytes();
+    while let Some(byte) = bytes.next() {
+        if byte == b'%' {
+            let a = bytes
+                .next()
+                .and_then(|b| (b as char).to_digit(16))
+                .ok_or_else(invalid)?;
+            let b = bytes
+                .next()
+                .and_then(|b| (b as char).to_digit(16))
+                .ok_or_else(invalid)?;
+            output.push((a * 16 + b) as u8);
+        } else {
+            output.push(byte);
+        }
+    }
+    String::from_utf8(output).map_err(|_| invalid())
+}
+
+struct Link {
+    url: Url,
+    port: Option<u16>,
+    query: BTreeMap<String, Vec<String>>,
+}
+impl Link {
+    fn parse(line: &str, budget: &mut usize) -> Result<Self> {
+        let mut url = Url::parse(line).map_err(|_| invalid())?;
+        if url.scheme() == "vless"
+            && url.port().is_none()
+            && let Some(decoded) = url
+                .host_str()
+                .and_then(|host| decode64(host.as_bytes(), false))
+        {
+            let endpoint = std::str::from_utf8(&decoded).map_err(|_| invalid())?;
+            let endpoint = Url::parse(&format!("vless://{endpoint}")).map_err(|_| invalid())?;
+            url.set_host(endpoint.host_str()).map_err(|_| invalid())?;
+            url.set_port(endpoint.port()).map_err(|_| invalid())?;
+        }
+        let mut query = BTreeMap::<String, Vec<String>>::new();
+        for (key, value) in url.query_pairs() {
+            *budget = budget
+                .checked_sub(128 + key.len() + value.len())
+                .ok_or_else(invalid)?;
+            query
+                .entry(key.into_owned())
+                .or_default()
+                .push(value.into_owned());
+        }
+        // Url canonicalizes explicit HTTP(S) default ports away. The subscription
+        // parser must retain that valid explicit endpoint without inventing ports.
+        let authority = line
+            .split_once("://")
+            .map(|(_, suffix)| suffix)
+            .and_then(|suffix| suffix.split(['/', '?', '#']).next())
+            .unwrap_or_default();
+        let port = url.port().or_else(|| {
+            authority
+                .rsplit_once(':')
+                .and_then(|(_, port)| port.parse::<u16>().ok())
+        });
+        Ok(Self { url, port, query })
+    }
+    fn get(&self, name: &str) -> &str {
+        self.query
+            .get(name)
+            .and_then(|v| v.first())
+            .map_or("", String::as_str)
+    }
+    fn user(&self) -> Result<String> {
+        unescape(self.url.username())
+    }
+    fn password(&self) -> Result<Option<String>> {
+        self.url.password().map(unescape).transpose()
+    }
+    fn name(&self) -> Result<String> {
+        unescape(self.url.fragment().unwrap_or_default())
+    }
+    fn host(&self) -> Result<String> {
+        let host = match self.url.host().ok_or_else(invalid)? {
+            Host::Domain(host) => host.to_owned(),
+            Host::Ipv4(ip) => ip.to_string(),
+            Host::Ipv6(ip) => ip.to_string(),
+        };
+        if host.is_empty() {
+            return Err(invalid());
+        }
+        Ok(host)
+    }
+    fn base(&self, kind: &str, default_port: Option<u16>) -> Result<Map<String, Value>> {
+        let host = self.host()?;
+        let port = self
+            .port
+            .or(default_port)
+            .filter(|port| *port > 0)
+            .ok_or_else(invalid)?;
+        let name = self.name()?;
+        Ok(json!({"name": if name.is_empty() { format!("{host}:{port}") } else { name }, "type":kind, "server":host, "port":port}).as_object().unwrap().clone())
+    }
+}
+
+fn copy_query(node: &mut Map<String, Value>, link: &Link, fields: &[(&str, &str)]) {
+    for (source, target) in fields {
+        let value = link.get(source);
+        if !value.is_empty() {
+            node.insert((*target).into(), json!(value));
+        }
+    }
+}
+fn alpn(node: &mut Map<String, Value>, value: &str) {
+    if !value.is_empty() {
+        node.insert("alpn".into(), json!(value.split(',').collect::<Vec<_>>()));
+    }
+}
+fn boolean(value: &str) -> bool {
+    matches!(value, "1" | "t" | "T" | "true" | "TRUE" | "True")
+}
+
+fn transport(
+    node: &mut Map<String, Value>,
+    link: &Link,
+    kind: &str,
+    budget: &mut usize,
+) -> Result<()> {
+    let mut network = link.get("type").to_ascii_lowercase();
+    if network.is_empty() {
+        network = "tcp".into();
+    }
+    if network == "tcp" && link.get("headerType").eq_ignore_ascii_case("http") {
+        network = "http".into();
+    } else if network == "http" && kind != "trojan" {
+        network = "h2".into();
+    }
+    let path = if link.get("path").is_empty() {
+        "/"
+    } else {
+        link.get("path")
+    };
+    match network.as_str() {
+        "tcp" => {}
+        "http" => {
+            let mut options = json!({"path":[path], "headers":{}});
+            if !link.get("host").is_empty() {
+                options["headers"]["Host"] = json!([link.get("host")]);
+            }
+            if !link.get("method").is_empty() {
+                options["method"] = json!(link.get("method"));
+            }
+            node.insert("http-opts".into(), options);
+        }
+        "h2" => {
+            let mut options = json!({"path":path});
+            if !link.get("host").is_empty() {
+                options["host"] = json!([link.get("host")]);
+            }
+            node.insert("h2-opts".into(), options);
+        }
+        "ws" | "httpupgrade" => {
+            let mut options = json!({"path":path,"headers":{}});
+            if !link.get("host").is_empty() {
+                options["headers"]["Host"] = json!(link.get("host"));
+            }
+            if network == "httpupgrade" {
+                options["v2ray-http-upgrade"] = json!(true);
+                options["v2ray-http-upgrade-fast-open"] = json!(!link.get("ed").is_empty());
+                network = "ws".into();
+            } else if !link.get("ed").is_empty() {
+                options["max-early-data"] =
+                    json!(link.get("ed").parse::<u16>().map_err(|_| invalid())?);
+                options["early-data-header-name"] = json!("Sec-WebSocket-Protocol");
+            }
+            if !link.get("eh").is_empty() {
+                options["early-data-header-name"] = json!(link.get("eh"));
+            }
+            node.insert("ws-opts".into(), options);
+        }
+        "grpc" => {
+            node.insert(
+                "grpc-opts".into(),
+                json!({"grpc-service-name":link.get("serviceName")}),
+            );
+        }
+        "xhttp" if kind == "vless" => {
+            let mut options = Map::new();
+            copy_query(
+                &mut options,
+                link,
+                &[("path", "path"), ("host", "host"), ("mode", "mode")],
+            );
+            if !link.get("extra").is_empty() {
+                let extra = parse_json(link.get("extra").as_bytes(), budget)?;
+                xhttp_extra(&mut options, extra.as_object().ok_or_else(invalid)?)?;
+            }
+            node.insert("xhttp-opts".into(), Value::Object(options));
+        }
+        _ => return Err(invalid()),
+    }
+    node.insert("network".into(), json!(network));
+    Ok(())
+}
+
+fn reuse(source: &Map<String, Value>) -> Map<String, Value> {
+    let mut options = Map::new();
+    for (source_key, target) in [
+        ("maxConnections", "max-connections"),
+        ("maxConcurrency", "max-concurrency"),
+        ("cMaxReuseTimes", "c-max-reuse-times"),
+        ("hMaxRequestTimes", "h-max-request-times"),
+        ("hMaxReusableSecs", "h-max-reusable-secs"),
+    ] {
+        if let Some(value) = source.get(source_key)
+            && (value.is_string() || value.is_i64() || value.is_u64())
+        {
+            options.insert(
+                target.into(),
+                json!(
+                    value
+                        .as_str()
+                        .map_or_else(|| value.to_string(), str::to_owned)
+                ),
+            );
+        }
+    }
+    if let Some(value) = source.get("hKeepAlivePeriod") {
+        options.insert("h-keep-alive-period".into(), value.clone());
+    }
+    options
+}
+fn xhttp_extra(options: &mut Map<String, Value>, extra: &Map<String, Value>) -> Result<()> {
+    for (source, target) in [
+        ("headers", "headers"),
+        ("noGRPCHeader", "no-grpc-header"),
+        ("xPaddingBytes", "x-padding-bytes"),
+        ("xPaddingObfsMode", "x-padding-obfs-mode"),
+        ("xPaddingKey", "x-padding-key"),
+        ("xPaddingHeader", "x-padding-header"),
+        ("xPaddingPlacement", "x-padding-placement"),
+        ("xPaddingMethod", "x-padding-method"),
+        ("uplinkHTTPMethod", "uplink-http-method"),
+        ("sessionIDPlacement", "session-placement"),
+        ("sessionPlacement", "session-placement"),
+        ("sessionIDKey", "session-key"),
+        ("sessionKey", "session-key"),
+        ("sessionIDTable", "session-table"),
+        ("sessionIDLength", "session-length"),
+        ("seqPlacement", "seq-placement"),
+        ("seqKey", "seq-key"),
+        ("uplinkDataPlacement", "uplink-data-placement"),
+        ("uplinkDataKey", "uplink-data-key"),
+        ("uplinkChunkSize", "uplink-chunk-size"),
+        ("scMaxEachPostBytes", "sc-max-each-post-bytes"),
+        ("scMinPostsIntervalMs", "sc-min-posts-interval-ms"),
+    ] {
+        if let Some(value) = extra.get(source) {
+            options.entry(target).or_insert_with(|| value.clone());
+        }
+    }
+    if let Some(length) = extra.get("sessionIDLength").and_then(Value::as_i64) {
+        options.insert("session-length".into(), json!(length.to_string()));
+    }
+    if let Some(xmux) = extra.get("xmux").and_then(Value::as_object) {
+        options.insert("reuse-settings".into(), Value::Object(reuse(xmux)));
+    }
+    if let Some(download) = extra.get("downloadSettings").and_then(Value::as_object) {
+        let mut result = Map::new();
+        for (source, target) in [("address", "server"), ("port", "port")] {
+            if let Some(value) = download.get(source) {
+                result.insert(target.into(), value.clone());
+            }
+        }
+        let security = download
+            .get("security")
+            .and_then(Value::as_str)
+            .unwrap_or_default();
+        if matches!(security, "tls" | "reality") {
+            result.insert("tls".into(), json!(true));
+            if let Some(tls) = download.get("tlsSettings").and_then(Value::as_object) {
+                for (source, target) in [
+                    ("serverName", "servername"),
+                    ("fingerprint", "client-fingerprint"),
+                    ("alpn", "alpn"),
+                    ("allowInsecure", "skip-cert-verify"),
+                ] {
+                    if let Some(value) = tls.get(source) {
+                        result.insert(target.into(), value.clone());
+                    }
+                }
+            }
+            if security == "reality"
+                && let Some(reality) = download.get("realitySettings").and_then(Value::as_object)
+            {
+                let mut settings = Map::new();
+                for (source, target) in [("publicKey", "public-key"), ("shortId", "short-id")] {
+                    if let Some(value) = reality.get(source) {
+                        settings.insert(target.into(), value.clone());
+                    }
+                }
+                result.insert("reality-opts".into(), Value::Object(settings));
+            }
+        }
+        if let Some(xhttp) = download.get("xhttpSettings").and_then(Value::as_object) {
+            for field in ["path", "host", "headers"] {
+                if let Some(value) = xhttp.get(field) {
+                    result.insert(field.into(), value.clone());
+                }
+            }
+            if let Some(xmux) = xhttp
+                .get("extra")
+                .and_then(|v| v.get("xmux"))
+                .and_then(Value::as_object)
+            {
+                result.insert("reuse-settings".into(), Value::Object(reuse(xmux)));
+            }
+        }
+        if !result.is_empty() {
+            options.insert("download-settings".into(), Value::Object(result));
+        }
+    }
+    Ok(())
+}
+
+fn v_share(link: &Link, kind: &str, budget: &mut usize) -> Result<Map<String, Value>> {
+    let mut node = link.base(kind, None)?;
+    node.insert("uuid".into(), json!(link.user()?));
+    node.insert("udp".into(), json!(true));
+    let security = link.get("security").to_ascii_lowercase();
+    if security.ends_with("tls") || security == "reality" {
+        node.insert("tls".into(), json!(true));
+        node.insert(
+            "client-fingerprint".into(),
+            json!(if link.get("fp").is_empty() {
+                "chrome"
+            } else {
+                link.get("fp")
+            }),
+        );
+        alpn(&mut node, link.get("alpn"));
+        copy_query(&mut node, link, &[("pcs", "fingerprint")]);
+    }
+    copy_query(&mut node, link, &[("sni", "servername")]);
+    if !link.get("pbk").is_empty() {
+        let mut reality = json!({"public-key":link.get("pbk"),"short-id":link.get("sid")});
+        if !link.get("support-x25519mlkem768").is_empty() {
+            reality["support-x25519mlkem768"] = json!(boolean(link.get("support-x25519mlkem768")));
+        }
+        node.insert("reality-opts".into(), reality);
+    }
+    let packet = match link.get("packetEncoding") {
+        "none" => {
+            if kind == "vless" {
+                "none"
+            } else {
+                ""
+            }
+        }
+        "packet" => "packetaddr",
+        _ => "xudp",
+    };
+    node.insert("packet-encoding".into(), json!(packet));
+    if kind == "vmess" {
+        node.insert("alterId".into(), json!(0));
+        node.insert(
+            "cipher".into(),
+            json!(if link.get("encryption").is_empty() {
+                "auto"
+            } else {
+                link.get("encryption")
+            }),
+        );
+    } else {
+        copy_query(
+            &mut node,
+            link,
+            &[("flow", "flow"), ("encryption", "encryption")],
+        );
+        if let Some(flow) = node.get_mut("flow") {
+            *flow = json!(link.get("flow").to_ascii_lowercase());
+        }
+    }
+    transport(&mut node, link, kind, budget)?;
+    Ok(node)
+}
+
+fn vmess_json(bytes: &[u8], budget: &mut usize) -> Result<Map<String, Value>> {
+    let values = parse_json(bytes, budget)?;
+    let values = values.as_object().ok_or_else(invalid)?;
+    let text = |key: &str| values.get(key).and_then(Value::as_str).unwrap_or_default();
+    let number = |key: &str| -> Result<u64> {
+        values
+            .get(key)
+            .and_then(|v| v.as_u64().or_else(|| v.as_str()?.parse().ok()))
+            .ok_or_else(invalid)
+    };
+    let mut node = json!({"name":text("ps"),"type":"vmess","server":text("add"),"port":number("port")?,"uuid":text("id"),"alterId":if values.contains_key("aid") { number("aid")? } else { 0 },"udp":true,"packet-encoding":"xudp","cipher":if text("scy").is_empty() { "auto" } else { text("scy") },"tls":text("tls").to_ascii_lowercase().ends_with("tls")}).as_object().unwrap().clone();
+    if !text("sni").is_empty() {
+        node.insert("servername".into(), json!(text("sni")));
+    }
+    if node["tls"] == true {
+        alpn(&mut node, text("alpn"));
+    }
+    let mut link = Link {
+        url: Url::parse("vmess://placeholder:1").unwrap(),
+        port: Some(1),
+        query: BTreeMap::new(),
+    };
+    for (source, target) in [("net", "type"), ("host", "host"), ("path", "path")] {
+        if !text(source).is_empty() {
+            link.query.insert(target.into(), vec![text(source).into()]);
+        }
+    }
+    // v2rayN encodes HTTP camouflage separately from its transport name.
+    if text("type") == "http" {
+        link.query.insert("type".into(), vec!["tcp".into()]);
+        link.query.insert("headerType".into(), vec!["http".into()]);
+    }
+    if matches!(link.get("type"), "ws" | "httpupgrade") && !link.get("path").is_empty() {
+        let mut path = Url::parse("https://placeholder")
+            .unwrap()
+            .join(link.get("path"))
+            .map_err(|_| invalid())?;
+        let mut retained = Vec::new();
+        for (key, value) in path.query_pairs() {
+            if matches!(key.as_ref(), "ed" | "eh") {
+                link.query
+                    .entry(key.into_owned())
+                    .or_insert_with(|| vec![value.into_owned()]);
+            } else {
+                retained.push((key.into_owned(), value.into_owned()));
+            }
+        }
+        path.set_query(None);
+        if !retained.is_empty() {
+            path.query_pairs_mut().extend_pairs(retained);
+        }
+        let mut result = path.path().to_owned();
+        if let Some(query) = path.query() {
+            result.push('?');
+            result.push_str(query);
+        }
+        link.query.insert("path".into(), vec![result]);
+    }
+    transport(&mut node, &link, "vmess", budget)?;
+    Ok(node)
+}
+
+// SIP003's URL-encoded plugin string is decoded once by Link. Only the
+// converters actually present in Mihomo common/convert/converter.go are used;
+// this is not a generic bridge from URI queries to plugin YAML fields.
+fn shadowsocks_plugin(node: &mut Map<String, Value>, input: &str) -> Result<()> {
+    if input.is_empty() {
+        return Ok(());
+    }
+    let (name, raw_options) = input.split_once(';').ok_or_else(invalid)?;
+    let encoded = raw_options.replace(';', "&");
+    let mut fields = BTreeMap::new();
+    for (name, value) in url::form_urlencoded::parse(encoded.as_bytes()) {
+        fields
+            .entry(name.into_owned())
+            .or_insert_with(|| value.into_owned());
+    }
+    let get = |key: &str| fields.get(key).map_or("", String::as_str);
+    let (plugin, mut options) = if name.contains("obfs") {
+        ("obfs", json!({"mode":get("obfs")}))
+    } else if name.contains("v2ray-plugin") {
+        let mode = if get("mode").is_empty() {
+            get("obfs")
+        } else {
+            get("mode")
+        };
+        (
+            "v2ray-plugin",
+            json!({"mode":mode,"path":get("path"),"tls":fields.contains_key("tls")}),
+        )
+    } else {
+        return Err(invalid());
+    };
+    let host = if plugin == "obfs" || get("host").is_empty() {
+        get("obfs-host")
+    } else {
+        get("host")
+    };
+    // Preserve the strict plugin schema's documented default for absent host.
+    if !host.is_empty() {
+        options["host"] = json!(host);
+    }
+    node.insert("plugin".into(), json!(plugin));
+    node.insert("plugin-opts".into(), options);
+    Ok(())
+}
+
+fn shadowsocks(line: &str, budget: &mut usize) -> Result<Map<String, Value>> {
+    let mut link = Link::parse(line, budget)?;
+    if link.url.port().is_none() {
+        let body = line
+            .split_once("://")
+            .ok_or_else(invalid)?
+            .1
+            .split(['#', '?'])
+            .next()
+            .unwrap();
+        let decoded = decode64(body.as_bytes(), false).ok_or_else(invalid)?;
+        let content = std::str::from_utf8(&decoded).map_err(|_| invalid())?;
+        let mut parsed = Link::parse(&format!("ss://{content}"), budget)?;
+        parsed.url.set_fragment(link.url.fragment());
+        parsed.query = link.query;
+        link = parsed;
+    }
+    let mut node = link.base("ss", None)?;
+    let (cipher, password) = if let Some(password) = link.password()? {
+        (link.user()?, password)
+    } else {
+        let decoded = decode64(link.user()?.as_bytes(), true).ok_or_else(invalid)?;
+        let text = std::str::from_utf8(&decoded).map_err(|_| invalid())?;
+        let (cipher, password) = text.split_once(':').ok_or_else(invalid)?;
+        (cipher.into(), password.into())
+    };
+    if !matches!(
+        cipher.as_str(),
+        "2022-blake3-aes-128-gcm" | "2022-blake3-aes-256-gcm" | "2022-blake3-chacha20-poly1305"
+    ) {
+        return Err(invalid());
+    }
+    node.insert("cipher".into(), json!(cipher));
+    node.insert("password".into(), json!(password));
+    shadowsocks_plugin(&mut node, link.get("plugin"))?;
+    node.insert("udp".into(), json!(true));
+    if link.get("udp-over-tcp") == "true" || link.get("uot") == "1" {
+        node.insert("udp-over-tcp".into(), json!(true));
+        node.insert("udp-over-tcp-version".into(), json!(2));
+    }
+    Ok(node)
+}
+
+fn convert(line: &str, scheme: &str, parser: &mut Parser<'_>) -> Result<()> {
+    if scheme == "vmess" {
+        let body = line.split_once("://").ok_or_else(invalid)?.1;
+        if let Some(decoded) = decode64(body.as_bytes(), false) {
+            let node = vmess_json(&decoded, &mut parser.budget)?;
+            return parser.push(node);
+        }
+    }
+    if scheme == "ss" {
+        let node = shadowsocks(line, &mut parser.budget)?;
+        return parser.push(node);
+    }
+    let mut normalized = line.to_owned();
+    let mut hopping = None;
+    if matches!(scheme, "hysteria2" | "hy2") {
+        let offset = line.find("://").ok_or_else(invalid)? + 3;
+        let end = line[offset..]
+            .find(['/', '?', '#'])
+            .map_or(line.len(), |n| offset + n);
+        let authority = &line[offset..end];
+        let (userinfo, authority) = authority
+            .rsplit_once('@')
+            .map_or(("", authority), |(user, host)| {
+                (&line[offset..offset + user.len() + 1], host)
+            });
+        if !authority.contains(']')
+            && let Some((host, ports)) = authority.rsplit_once(':')
+            && ports.contains([',', '-'])
+        {
+            let first = ports.split([',', '-']).next().unwrap();
+            if first.is_empty() {
+                return Err(invalid());
+            }
+            normalized = format!(
+                "{}{}{}:{}{}",
+                &line[..offset],
+                userinfo,
+                host,
+                first,
+                &line[end..]
+            );
+            hopping = Some(ports.to_owned());
+        }
+    }
+    let link = Link::parse(&normalized, &mut parser.budget)?;
+    if matches!(scheme, "vless" | "vmess") {
+        let node = v_share(&link, scheme, &mut parser.budget)?;
+        return parser.push(node);
+    }
+    if scheme == "mierus" {
+        let ports = link.query.get("port").ok_or_else(invalid)?;
+        let protocols = link
+            .query
+            .get("protocol")
+            .filter(|v| v.len() == ports.len())
+            .ok_or_else(invalid)?;
+        let host = link.host()?;
+        let name = link.name()?;
+        let name = if !name.is_empty() {
+            name.as_str()
+        } else if !link.get("profile").is_empty() {
+            link.get("profile")
+        } else {
+            &host
+        };
+        for (port, protocol) in ports.iter().zip(protocols) {
+            let mut node = json!({"name":format!("{name}:{port}/{protocol}"),"type":"mieru","server":host,"username":link.user()?,"password":link.password()?.unwrap_or_default(),"transport":protocol,"udp":true}).as_object().unwrap().clone();
+            if port.contains('-') {
+                node.insert("port-range".into(), json!(port));
+            } else {
+                node.insert(
+                    "port".into(),
+                    json!(port.parse::<u16>().map_err(|_| invalid())?),
+                );
+            }
+            copy_query(
+                &mut node,
+                &link,
+                &[
+                    ("multiplexing", "multiplexing"),
+                    ("handshake-mode", "handshake-mode"),
+                    ("traffic-pattern", "traffic-pattern"),
+                ],
+            );
+            parser.push(node)?;
+        }
+        return Ok(());
+    }
+    let kind = match scheme {
+        "hy2" | "hysteria2" => "hysteria2",
+        "socks" | "socks5" | "socks5h" => "socks5",
+        "http" | "https" => "http",
+        value => value,
+    };
+    let mut node = link.base(kind, (kind == "hysteria2").then_some(443))?;
+    match kind {
+        "hysteria2" => {
+            node.insert(
+                "password".into(),
+                json!(link.user()? + &link.password()?.map_or(String::new(), |v| format!(":{v}"))),
+            );
+            node.insert(
+                "skip-cert-verify".into(),
+                json!(boolean(link.get("insecure"))),
+            );
+            node.insert("udp".into(), json!(true));
+            copy_query(
+                &mut node,
+                &link,
+                &[
+                    ("obfs", "obfs"),
+                    ("obfs-password", "obfs-password"),
+                    ("sni", "sni"),
+                    ("pinSHA256", "fingerprint"),
+                    ("up", "up"),
+                    ("down", "down"),
+                ],
+            );
+            alpn(&mut node, link.get("alpn"));
+            if let Some(ports) = hopping {
+                node.insert("ports".into(), json!(ports));
+            }
+        }
+        "tuic" => {
+            node.insert("uuid".into(), json!(link.user()?));
+            node.insert(
+                "password".into(),
+                json!(link.password()?.ok_or_else(invalid)?),
+            );
+            node.insert("udp".into(), json!(true));
+            copy_query(
+                &mut node,
+                &link,
+                &[
+                    ("congestion_control", "congestion-controller"),
+                    ("sni", "sni"),
+                    ("udp_relay_mode", "udp-relay-mode"),
+                ],
+            );
+            alpn(&mut node, link.get("alpn"));
+            if link.get("disable_sni") == "1" {
+                node.insert("disable-sni".into(), json!(true));
+            }
+        }
+        "trojan" => {
+            node.insert("password".into(), json!(link.user()?));
+            node.insert("udp".into(), json!(true));
+            node.insert(
+                "skip-cert-verify".into(),
+                json!(boolean(link.get("allowInsecure"))),
+            );
+            copy_query(&mut node, &link, &[("sni", "sni"), ("pcs", "fingerprint")]);
+            alpn(&mut node, link.get("alpn"));
+            node.insert(
+                "client-fingerprint".into(),
+                json!(if link.get("fp").is_empty() {
+                    "chrome"
+                } else {
+                    link.get("fp")
+                }),
+            );
+            transport(&mut node, &link, kind, &mut parser.budget)?;
+        }
+        "anytls" => {
+            node.insert(
+                "password".into(),
+                json!(link.password()?.unwrap_or(link.user()?)),
+            );
+            node.insert("udp".into(), json!(true));
+            node.insert(
+                "skip-cert-verify".into(),
+                json!(link.get("insecure") == "1"),
+            );
+            copy_query(&mut node, &link, &[("sni", "sni"), ("hpkp", "fingerprint")]);
+        }
+        "socks5" | "http" => {
+            if !link.url.username().is_empty() || link.url.password().is_some() {
+                let user = link.user()?;
+                let raw = link
+                    .password()?
+                    .map_or_else(|| user.clone(), |password| format!("{user}:{password}"));
+                let decoded = decode64(raw.as_bytes(), false);
+                let credentials = decoded
+                    .as_deref()
+                    .map(std::str::from_utf8)
+                    .transpose()
+                    .map_err(|_| invalid())?
+                    .unwrap_or(&raw);
+                let (user, password) = credentials.split_once(':').unwrap_or((credentials, ""));
+                node.insert("username".into(), json!(user));
+                node.insert("password".into(), json!(password));
+            }
+            if scheme == "https" {
+                node.insert("tls".into(), json!(true));
+            }
+        }
+        _ => return Err(invalid()),
+    }
+    parser.push(node)
+}
+
+fn charge(value: &Value, budget: &mut usize, depth: usize) -> Result<()> {
+    if depth > 64 {
+        return Err(invalid());
+    }
+    *budget = budget.checked_sub(256).ok_or_else(invalid)?;
+    match value {
+        Value::String(value) => {
+            *budget = budget.checked_sub(value.len() * 4).ok_or_else(invalid)?;
+        }
+        Value::Array(items) => {
+            for item in items {
+                charge(item, budget, depth + 1)?;
+            }
+        }
+        Value::Object(items) => {
+            for (key, item) in items {
+                *budget = budget
+                    .checked_sub(256 + key.len() * 4)
+                    .ok_or_else(invalid)?;
+                charge(item, budget, depth + 1)?;
+            }
+        }
+        _ => {}
+    }
+    Ok(())
+}
+
+fn parse_json(bytes: &[u8], budget: &mut usize) -> Result<Value> {
+    use serde::Deserialize;
+    let mut syntax = serde_json::Deserializer::from_slice(bytes);
+    serde::de::IgnoredAny::deserialize(&mut syntax).map_err(|_| invalid())?;
+    syntax.end().map_err(|_| invalid())?;
+    let bounded = crate::config::yaml::parse_with_budget(bytes, budget).map_err(|_| invalid())?;
+    serde_yaml_ng::from_value(bounded).map_err(|_| invalid())
+}
+
+struct Parser<'a> {
+    control: &'a DecodeControl<'a>,
+    nodes: Vec<serde_yaml_ng::Value>,
+    names: HashSet<String>,
+    next_name: BTreeMap<String, usize>,
+    budget: usize,
+}
+impl Parser<'_> {
+    fn line(&mut self, line: &str, scheme: &str) -> Result<()> {
+        // A live reservation covers every temporary allocation in convert(),
+        // including one Mieru expanded node at a time. push() charges retained
+        // nodes before the next expansion or YAML conversion can begin.
+        let scratch = scratch_allowance(line.len())?;
+        self.budget = self.budget.checked_sub(scratch).ok_or_else(invalid)?;
+        let result = convert(line, scheme, self);
+        self.budget += scratch;
+        result
+    }
+
+    fn push(&mut self, mut node: Map<String, Value>) -> Result<()> {
+        self.control.check()?;
+        let base = node
+            .get("name")
+            .and_then(Value::as_str)
+            .filter(|v| !v.is_empty())
+            .ok_or_else(invalid)?
+            .to_owned();
+        let mut name = base.clone();
+        let mut index = self.next_name.get(&base).copied().unwrap_or(0);
+        if index > 0 {
+            name = format!("{base}-{index:02}");
+        }
+        while self.names.contains(&name) {
+            self.control.check()?;
+            index += 1;
+            name = format!("{base}-{index:02}");
+        }
+        self.next_name.insert(base, index + 1);
+        node.insert("name".into(), json!(name));
+        let value = Value::Object(node);
+        charge(&value, &mut self.budget, 0)?;
+        self.names.insert(name);
+        self.nodes
+            .push(serde_yaml_ng::to_value(value).map_err(|_| invalid())?);
+        Ok(())
+    }
+}
+
+pub(crate) fn parse(
+    bytes: &[u8],
+    control: &DecodeControl<'_>,
+) -> Result<Vec<serde_yaml_ng::Value>> {
+    control.check()?;
+    if bytes.len() > MAX_CONFIG_BYTES {
+        return Err(invalid());
+    }
+    // Outer Base64 cleaning and decoding coexist temporarily. The caller's
+    // original source buffer is outside this conversion allowance.
+    if bytes
+        .len()
+        .checked_mul(2)
+        .is_none_or(|n| n > CONVERSION_BUDGET)
+    {
+        return Err(invalid());
+    }
+    let decoded = decode64(bytes, false);
+    let input = std::str::from_utf8(decoded.as_deref().unwrap_or(bytes)).map_err(|_| invalid())?;
+    let mut parser = Parser {
+        control,
+        nodes: Vec::new(),
+        names: HashSet::new(),
+        next_name: BTreeMap::new(),
+        budget: CONVERSION_BUDGET - decoded.as_ref().map_or(0, Vec::len),
+    };
+    for line in input.lines() {
+        control.check()?;
+        let line = line.trim_end_matches([' ', '\r']);
+        if line.len() > MAX_URI_LINE_BYTES {
+            return Err(invalid());
+        }
+        let Some((scheme, _)) = line.split_once("://") else {
+            continue;
+        };
+        if scheme.len() > 16 {
+            continue;
+        }
+        let scheme = scheme.to_ascii_lowercase();
+        if !matches!(
+            scheme.as_str(),
+            "hysteria2"
+                | "hy2"
+                | "tuic"
+                | "trojan"
+                | "vless"
+                | "vmess"
+                | "ss"
+                | "socks"
+                | "socks5"
+                | "socks5h"
+                | "http"
+                | "https"
+                | "anytls"
+                | "mierus"
+        ) {
+            continue;
+        }
+        parser.line(line, &scheme)?;
+    }
+    control.check()?;
+    if parser.nodes.is_empty() {
+        return Err(invalid());
+    }
+    Ok(parser.nodes)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::time::{Duration, Instant};
+
+    fn control() -> DecodeControl<'static> {
+        DecodeControl::new(None, Instant::now() + Duration::from_secs(10))
+    }
+
+    fn one(input: &str) -> serde_yaml_ng::Value {
+        let mut nodes = parse(input.as_bytes(), &control()).unwrap();
+        assert_eq!(nodes.len(), 1);
+        nodes.remove(0)
+    }
+
+    #[test]
+    fn subscription_plain_base64_names_and_same_schema() {
+        let input =
+            "socks5://alice:pass@proxy.invalid:1080#edge\r\nsocks5://proxy.invalid:1081#edge\n";
+        for bytes in [
+            input.as_bytes().to_vec(),
+            STANDARD.encode(input).into_bytes(),
+            STANDARD_NO_PAD.encode(input).into_bytes(),
+        ] {
+            let nodes = parse(&bytes, &control()).unwrap();
+            assert_eq!(nodes[0]["name"].as_str(), Some("edge"));
+            assert_eq!(nodes[1]["name"].as_str(), Some("edge-01"));
+            assert_eq!(nodes[0]["username"].as_str(), Some("alice"));
+            assert_eq!(nodes[0]["password"].as_str(), Some("pass"));
+            let yaml = serde_yaml_ng::to_string(&serde_json::json!({"proxies":nodes})).unwrap();
+            if cfg!(feature = "outbound-socks5") {
+                crate::config::Config::parse_yaml(yaml.as_bytes()).unwrap();
+            }
+        }
+    }
+
+    #[test]
+    fn supported_uri_values_are_consumed_by_existing_node_schema() {
+        let uuid = "00000000-0000-4000-8000-000000000001";
+        let cases = [
+            (cfg!(feature="outbound-vless"), format!("vless://{uuid}@proxy.invalid:443?security=tls&type=ws&sni=proxy.invalid&host=cover.invalid&path=%2Fedge&ed=64#edge")),
+            (cfg!(feature="outbound-vmess"), format!("vmess://{uuid}@proxy.invalid:443?security=tls&type=grpc&serviceName=edge#edge")),
+            (cfg!(feature="outbound-trojan"), "trojan://password@proxy.invalid:443?type=grpc&serviceName=edge#edge".into()),
+            (cfg!(feature="outbound-anytls"), "anytls://pa%3Ass@proxy.invalid:443?sni=proxy.invalid#edge".into()),
+            (cfg!(feature="outbound-tuic"), format!("tuic://{uuid}:password@proxy.invalid:443?congestion_control=bbr#edge")),
+            (cfg!(feature="outbound-hysteria2"), "hy2://password@proxy.invalid:443,444-445?sni=proxy.invalid#edge".into()),
+            (cfg!(feature="outbound-http"), "https://alice:password@proxy.invalid:443#edge".into()),
+            (cfg!(feature="outbound-http"), "http://proxy.invalid:80#edge".into()),
+            (cfg!(feature="outbound-mieru"), "mierus://alice:password@proxy.invalid?port=1234&protocol=TCP&multiplexing=MULTIPLEXING_MIDDLE#edge".into()),
+            (cfg!(feature="outbound-shadowsocks"), format!("ss://{}@proxy.invalid:443#edge", URL_SAFE_NO_PAD.encode(format!("2022-blake3-aes-128-gcm:{}", STANDARD.encode([7u8;16]))))),
+        ];
+        for (enabled, input) in cases {
+            let nodes = parse(input.as_bytes(), &control()).unwrap();
+            if input.starts_with("mierus:") {
+                assert_eq!(
+                    nodes[0]["multiplexing"].as_str(),
+                    Some("MULTIPLEXING_MIDDLE")
+                );
+            }
+            let yaml = serde_yaml_ng::to_string(&serde_json::json!({"proxies":nodes})).unwrap();
+            if enabled {
+                crate::config::Config::parse_yaml(yaml.as_bytes()).unwrap();
+            }
+        }
+    }
+
+    #[test]
+    fn vmess_json_and_vless_xhttp_translate_transports_without_second_schema() {
+        let uuid = "00000000-0000-4000-8000-000000000001";
+        let vmess = json!({"v":"2","ps":"edge","add":"proxy.invalid","port":"443","id":uuid,"aid":"0","net":"ws","host":"cover.invalid","path":"/edge?ed=32&token=fixture","tls":"tls"});
+        let node = one(&format!(
+            "vmess://{}",
+            STANDARD.encode(serde_json::to_vec(&vmess).unwrap())
+        ));
+        assert_eq!(
+            node["ws-opts"]["path"].as_str(),
+            Some("/edge?token=fixture")
+        );
+        assert_eq!(node["ws-opts"]["max-early-data"].as_u64(), Some(32));
+        if cfg!(feature = "outbound-vmess") {
+            crate::config::Config::parse_yaml(
+                serde_yaml_ng::to_string(&json!({"proxies":[node]}))
+                    .unwrap()
+                    .as_bytes(),
+            )
+            .unwrap();
+        }
+        let mut url = Url::parse(&format!("vless://{uuid}@proxy.invalid:443")).unwrap();
+        url.query_pairs_mut().append_pair("security","tls").append_pair("type","xhttp").append_pair("path","/edge").append_pair("mode","packet-up").append_pair("extra",&json!({"xmux":{"maxConnections":2,"hKeepAlivePeriod":-1},"scMaxEachPostBytes":8192,"scMinPostsIntervalMs":1}).to_string());
+        let node = one(url.as_str());
+        assert_eq!(
+            node["xhttp-opts"]["reuse-settings"]["max-connections"].as_str(),
+            Some("2")
+        );
+        if cfg!(feature = "outbound-vless") {
+            crate::config::Config::parse_yaml(
+                serde_yaml_ng::to_string(&json!({"proxies":[node]}))
+                    .unwrap()
+                    .as_bytes(),
+            )
+            .unwrap();
+        }
+    }
+
+    #[test]
+    fn ss_plugin_uris_reach_the_existing_strict_consumers() {
+        for (plugin, expected, tls) in [
+            (
+                "obfs-local;obfs=http;obfs-host=cover.invalid",
+                "obfs",
+                false,
+            ),
+            ("simple-obfs;obfs=tls;obfs-host=cover.invalid", "obfs", true),
+            (
+                "v2ray-plugin;mode=websocket;host=cover.invalid;path=/edge;tls",
+                "v2ray-plugin",
+                true,
+            ),
+            (
+                "v2ray-plugin;obfs=websocket;obfs-host=cover.invalid;path=/edge",
+                "v2ray-plugin",
+                false,
+            ),
+        ] {
+            let user = URL_SAFE_NO_PAD.encode(format!(
+                "2022-blake3-aes-128-gcm:{}",
+                STANDARD.encode([7u8; 16])
+            ));
+            let mut link = Url::parse(&format!("ss://{user}@proxy.invalid:443#edge")).unwrap();
+            link.query_pairs_mut().append_pair("plugin", plugin);
+            let node = one(link.as_str());
+            assert_eq!(node["plugin"].as_str(), Some(expected));
+            assert_eq!(node["plugin-opts"]["host"].as_str(), Some("cover.invalid"));
+            if cfg!(feature = "outbound-shadowsocks") {
+                let config = crate::config::Config::parse_yaml(
+                    serde_json::to_vec(&json!({"proxies":[node],"rules":["MATCH,edge"]}))
+                        .unwrap()
+                        .as_slice(),
+                )
+                .unwrap();
+                let crate::config::ProxyProtocol::Shadowsocks(ss) = &config.proxies[0].protocol
+                else {
+                    panic!("SS2022");
+                };
+                match ss.plugin.as_ref().unwrap() {
+                    crate::config::ShadowsocksPlugin::Obfs { tls: actual, .. } => {
+                        assert_eq!(*actual, tls)
+                    }
+                    crate::config::ShadowsocksPlugin::WebSocket {
+                        tls: actual,
+                        mux,
+                        gost,
+                        ..
+                    } => {
+                        assert_eq!(actual.is_some(), tls);
+                        assert!(*mux);
+                        assert!(!gost);
+                    }
+                    _ => panic!("URI did not choose its actual plugin consumer"),
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn subscription_limits_cancellation_and_errors_are_bounded_and_private() {
+        let token = tokio_util::sync::CancellationToken::new();
+        token.cancel();
+        assert!(
+            parse(
+                b"socks5://proxy.invalid:1080",
+                &DecodeControl::new(Some(&token), Instant::now() + Duration::from_secs(5))
+            )
+            .is_err()
+        );
+        assert!(parse(&vec![b'A'; MAX_CONFIG_BYTES + 1], &control()).is_err());
+        assert!(
+            parse(
+                b"socks5://secret-user:secret-pass@proxy.invalid",
+                &control()
+            )
+            .unwrap_err()
+            .to_string()
+            .contains("invalid or unsupported")
+        );
+        let error = parse(b"ss://legacy:secret@proxy.invalid:443", &control())
+            .unwrap_err()
+            .to_string();
+        assert!(!error.contains("secret"));
+        let mut budget = 64;
+        assert!(charge(&json!({"field":"value"}), &mut budget, 0).is_err());
+        assert!(parse(b"plain unrelated content", &control()).is_err());
+    }
+
+    #[test]
+    fn scratch_is_reserved_before_conversion_and_multiport_expansion_stays_bounded() {
+        let control = control();
+        let line = "socks5://proxy.invalid:1080";
+        let remaining = scratch_allowance(line.len()).unwrap() - 1;
+        let mut parser = Parser {
+            control: &control,
+            nodes: Vec::new(),
+            names: HashSet::new(),
+            next_name: BTreeMap::new(),
+            budget: remaining,
+        };
+        assert!(parser.line(line, "socks5").is_err());
+        assert_eq!(parser.budget, remaining);
+        assert!(parser.nodes.is_empty());
+        assert!(parser.names.is_empty());
+        assert!(parser.next_name.is_empty());
+
+        let long = format!(
+            "socks5://proxy.invalid:1080#{}",
+            "x".repeat(MAX_URI_LINE_BYTES)
+        );
+        assert!(parse(long.as_bytes(), &control).is_err());
+        let mut multiport = format!("mierus://{}:password@proxy.invalid?", "x".repeat(8192));
+        for port in 1..=1000 {
+            multiport.push_str(&format!("port={port}&protocol=TCP&"));
+        }
+        assert!(multiport.len() < MAX_URI_LINE_BYTES);
+        assert!(parse(multiport.as_bytes(), &control).is_err());
+    }
+}
diff --git a/src/resource/subscription.rs b/src/resource/subscription.rs
new file mode 100644
index 0000000..72818a9
--- /dev/null
+++ b/src/resource/subscription.rs
@@ -0,0 +1,78 @@
+//! Bounded numeric subscription metadata; raw headers are never retained.
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub(crate) struct SubscriptionInfo {
+    pub upload: i64,
+    pub download: i64,
+    pub total: i64,
+    pub expire: i64,
+}
+
+impl SubscriptionInfo {
+    pub fn parse(header: &str) -> Option<Self> {
+        if header.is_empty() {
+            return None;
+        }
+        let normalized = header.to_ascii_lowercase().replace(' ', "");
+        let mut info = Self::default();
+        for field in normalized.split(';') {
+            let Some((name, value)) = field.split_once('=') else {
+                continue;
+            };
+            let slot = match name {
+                "upload" => &mut info.upload,
+                "download" => &mut info.download,
+                "total" => &mut info.total,
+                "expire" => &mut info.expire,
+                _ => continue,
+            };
+            if let Some(value) = parse_value(value) {
+                *slot = value;
+            }
+        }
+        Some(info)
+    }
+}
+
+fn parse_value(value: &str) -> Option<i64> {
+    if let Ok(value) = value.parse::<i64>() {
+        return Some(value);
+    }
+    let value = value.parse::<f64>().ok()?;
+    // The upper bound is exclusive: i64::MAX rounds to 2^63 in f64.
+    (value.is_finite()
+        && (-9_223_372_036_854_775_808.0..9_223_372_036_854_775_808.0).contains(&value))
+    .then_some(value as i64)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn numeric_header_matches_subscription_fields_without_retaining_raw_values() {
+        let info = SubscriptionInfo::parse(
+            " Upload = 12 ; DOWNLOAD=3.9; total=1e4; expire=-4.8; upload=19; upload=invalid; other=55",
+        )
+        .unwrap();
+        assert_eq!(
+            serde_json::to_value(info).unwrap(),
+            serde_json::json!({"Upload":19,"Download":3,"Total":10000,"Expire":-4})
+        );
+        assert_eq!(SubscriptionInfo::parse(""), None);
+        assert_eq!(
+            SubscriptionInfo::parse("upload=NaN;download=Inf;total=9223372036854775808;expire=bad"),
+            Some(SubscriptionInfo::default())
+        );
+        assert_eq!(
+            SubscriptionInfo::parse("upload=9223372036854775807;download=-9223372036854775808"),
+            Some(SubscriptionInfo {
+                upload: i64::MAX,
+                download: i64::MIN,
+                ..Default::default()
+            })
+        );
+    }
+}
diff --git a/src/resources.rs b/src/resources.rs
index 07d8924..f42685f 100644
--- a/src/resources.rs
+++ b/src/resources.rs
@@ -1,5 +1,3 @@
-#[cfg(any(test, feature = "interop-test"))]
-pub mod case_events;
 pub mod observation;
 
 use std::sync::{
@@ -228,6 +226,7 @@ impl RuntimeResourceStats {
                     event = "runtime_dns_response_drop",
                     scope = self.inner.scope,
                     limit,
+                    dns_queue_drops = counter.load(Ordering::Relaxed),
                     "runtime queue dropped an item for the first time"
                 ),
             }
diff --git a/src/resources/case_events.rs b/src/resources/case_events.rs
deleted file mode 100644
index 87407f0..0000000
--- a/src/resources/case_events.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-//! Structured opt-in evidence from assertion-bearing Rust tests. Human test
-//! output is not a coverage source. Missing/partial events cannot become PASS.
-use super::observation::ResourceSnapshot;
-use std::{fs::OpenOptions, io::Write, path::PathBuf, sync::Mutex, time::Instant};
-
-static WRITE_LOCK: Mutex<()> = Mutex::new(());
-
-pub struct Case {
-    suite: &'static str,
-    assertion: &'static str,
-    started: Instant,
-    path: Option<PathBuf>,
-    resources: Option<ResourceSnapshot>,
-    checkpoints: Vec<(&'static str, ResourceSnapshot)>,
-}
-impl Case {
-    pub fn new(suite: &'static str, assertion: &'static str) -> Self {
-        let case = Self {
-            suite,
-            assertion,
-            started: Instant::now(),
-            path: std::env::var_os("VOLE_CASE_EVENTS").map(PathBuf::from),
-            resources: None,
-            checkpoints: Vec::new(),
-        };
-        case.emit("BEGIN");
-        case
-    }
-    pub fn resources(&mut self, snapshot: ResourceSnapshot) {
-        self.resources = Some(snapshot);
-    }
-    pub fn checkpoint(&mut self, phase: &'static str, snapshot: ResourceSnapshot) {
-        self.checkpoints.push((phase, snapshot));
-    }
-    fn emit(&self, status: &str) {
-        let Some(path) = &self.path else {
-            return;
-        };
-        let checkpoints: Vec<_> = self
-            .checkpoints
-            .iter()
-            .map(|(phase, snapshot)| serde_json::json!({"phase":phase,"resources":snapshot}))
-            .collect();
-        let event = serde_json::json!({"schema_version":1,"suite":self.suite,"assertion":self.assertion,"status":status,"seconds":self.started.elapsed().as_secs_f64(),"resources":self.resources,"checkpoints":checkpoints});
-        let _lock = WRITE_LOCK
-            .lock()
-            .unwrap_or_else(std::sync::PoisonError::into_inner);
-        let result = (|| -> std::io::Result<()> {
-            let mut file = OpenOptions::new().create(true).append(true).open(path)?;
-            writeln!(file, "{event}")?;
-            file.flush()
-        })();
-        if result.is_err() && !std::thread::panicking() {
-            panic!("cannot persist structured case evidence");
-        }
-    }
-}
-impl Drop for Case {
-    fn drop(&mut self) {
-        self.emit(
-            if std::thread::panicking()
-                || self
-                    .resources
-                    .as_ref()
-                    .is_some_and(|snapshot| !snapshot.is_idle())
-            {
-                "FAIL"
-            } else {
-                "PASS"
-            },
-        );
-    }
-}
diff --git a/src/resources/observation.rs b/src/resources/observation.rs
index 9e49450..ad60b49 100644
--- a/src/resources/observation.rs
+++ b/src/resources/observation.rs
@@ -243,11 +243,13 @@ where
 }
 
 pub(crate) fn task<F: Future>(future: F) -> impl Future<Output = F::Output> {
+    use tracing::instrument::WithSubscriber;
     let guard = track(ResourceKind::Task);
     bind(async move {
         let _guard = guard;
         future.await
     })
+    .with_current_subscriber()
 }
 
 /// IO plus a test-only lifetime guard. In release builds the guard is a ZST;
diff --git a/src/routing/balance.rs b/src/routing/balance.rs
new file mode 100644
index 0000000..b430e77
--- /dev/null
+++ b/src/routing/balance.rs
@@ -0,0 +1,321 @@
+//! Per-group selection; transports retain the selected leaf, not this cursor.
+use crate::{
+    config::{BalanceHashKey, BalanceStrategy},
+    session::Destination,
+};
+use std::{
+    collections::{HashMap, hash_map::RandomState},
+    hash::BuildHasher,
+    net::SocketAddr,
+    sync::OnceLock,
+    time::Duration,
+};
+use tokio::time::Instant;
+
+#[derive(Debug)]
+pub(super) struct Balance {
+    strategy: BalanceStrategy,
+    hash_key: BalanceHashKey,
+    healthy: Vec<bool>,
+    cursor: usize,
+    sticky: HashMap<u64, Entry>,
+    clock: u64,
+}
+#[derive(Debug)]
+struct Entry {
+    index: usize,
+    expires: Instant,
+    used: u64,
+}
+
+impl Balance {
+    pub fn new(strategy: BalanceStrategy, members: usize) -> Self {
+        Self {
+            strategy,
+            hash_key: BalanceHashKey::Default,
+            healthy: vec![true; members],
+            cursor: 0,
+            sticky: HashMap::new(),
+            clock: 0,
+        }
+    }
+    pub fn with_hash_key(mut self, hash_key: BalanceHashKey) -> Self {
+        self.hash_key = hash_key;
+        self
+    }
+    pub fn health(&mut self, samples: &[Option<u64>]) {
+        if samples.len() == self.healthy.len() {
+            for (alive, sample) in self.healthy.iter_mut().zip(samples) {
+                *alive = sample.is_some();
+            }
+        }
+    }
+    pub fn choose(
+        &mut self,
+        source: Option<SocketAddr>,
+        destination: Option<&Destination>,
+        user: Option<&str>,
+    ) -> usize {
+        self.inspect(source, destination, user, true)
+    }
+    pub fn inspect(
+        &mut self,
+        source: Option<SocketAddr>,
+        destination: Option<&Destination>,
+        user: Option<&str>,
+        commit: bool,
+    ) -> usize {
+        let count = self.healthy.len();
+        if count == 0 {
+            return 0;
+        }
+        if self.strategy == BalanceStrategy::RoundRobin {
+            let selected = (0..count)
+                .map(|offset| (self.cursor + offset) % count)
+                .find(|&i| self.healthy[i]);
+            if let Some(index) = selected {
+                if commit {
+                    self.cursor = (index + 1) % count;
+                }
+                return index;
+            }
+            return 0;
+        }
+        let user = (self.hash_key == BalanceHashKey::InUser)
+            .then_some(user)
+            .flatten()
+            .filter(|user| !user.is_empty());
+        let fallback = user.is_none().then(|| {
+            let mut key = destination_key(destination);
+            if self.strategy == BalanceStrategy::StickySessions {
+                key.insert_str(
+                    0,
+                    &source.map_or_else(|| "invalid IP".into(), |s| s.ip().to_string()),
+                );
+            }
+            key
+        });
+        static HASH: OnceLock<RandomState> = OnceLock::new();
+        let key = HASH
+            .get_or_init(RandomState::new)
+            .hash_one(user.unwrap_or_else(|| fallback.as_deref().unwrap()));
+        if self.strategy == BalanceStrategy::ConsistentHashing {
+            return (0..5)
+                .map(|offset| jump(key.wrapping_add(offset), count))
+                .find(|&i| self.healthy[i])
+                .or_else(|| self.healthy.iter().position(|&v| v))
+                .unwrap_or(0);
+        }
+        self.clock = self.clock.wrapping_add(1);
+        let now = Instant::now();
+        if let Some(entry) = self.sticky.get_mut(&key)
+            && entry.expires > now
+            && entry.index < count
+            && self.healthy[entry.index]
+        {
+            entry.used = self.clock;
+            return entry.index;
+        }
+        let index = healthy_candidate(
+            &self.healthy,
+            (0..4).map(|_| jump(key.wrapping_add(rand::random::<u64>()), count)),
+        );
+        if self.sticky.len() >= 1000
+            && !self.sticky.contains_key(&key)
+            && let Some(oldest) = self
+                .sticky
+                .iter()
+                .min_by_key(|(_, e)| e.used)
+                .map(|(&k, _)| k)
+        {
+            self.sticky.remove(&oldest);
+        }
+        self.sticky.insert(
+            key,
+            Entry {
+                index,
+                expires: now + Duration::from_secs(600),
+                used: self.clock,
+            },
+        );
+        index
+    }
+    pub fn commit(&mut self, index: usize) {
+        if self.strategy == BalanceStrategy::RoundRobin && !self.healthy.is_empty() {
+            self.cursor = (index + 1) % self.healthy.len();
+        }
+    }
+}
+fn healthy_candidate(healthy: &[bool], mut candidates: impl Iterator<Item = usize>) -> usize {
+    candidates
+        .find(|&i| healthy[i])
+        .or_else(|| healthy.iter().position(|&alive| alive))
+        .unwrap_or(0)
+}
+fn destination_key(destination: Option<&Destination>) -> String {
+    match destination {
+        Some(Destination::Ip(address)) => address.ip().to_string(),
+        Some(Destination::Domain { host, .. }) => host
+            .parse::<std::net::IpAddr>()
+            .map(|ip| ip.to_string())
+            .unwrap_or_else(|_| psl::domain_str(host).unwrap_or_default().to_owned()),
+        None => String::new(),
+    }
+}
+// Jump consistent hash (Lamping and Veach); only the bucket count affects remapping.
+fn jump(mut key: u64, count: usize) -> usize {
+    let mut bucket = 0;
+    let mut next = 0;
+    while next < count {
+        bucket = next;
+        key = key.wrapping_mul(2862933555777941757).wrapping_add(1);
+        next = ((bucket + 1) as f64 * ((1_u64 << 31) as f64 / ((key >> 33) + 1) as f64)) as usize;
+    }
+    bucket
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn sticky_sampling_keeps_healthy_hits_and_falls_back_after_four_misses() {
+        let mut attempts = 0;
+        assert_eq!(
+            healthy_candidate(
+                &[false, false, true],
+                [0, 1, 0, 1].into_iter().inspect(|_| attempts += 1),
+            ),
+            2
+        );
+        assert_eq!(attempts, 4);
+        assert_eq!(
+            healthy_candidate(&[false, true, true], [2, 1, 0, 0].into_iter()),
+            2
+        );
+        assert_eq!(
+            healthy_candidate(&[false, true, true], [0, 0, 0, 0].into_iter()),
+            1
+        );
+        assert_eq!(
+            healthy_candidate(&[false, false, false], [2, 1, 0, 2].into_iter()),
+            0
+        );
+    }
+
+    #[test]
+    fn sticky_cache_replaces_unhealthy_and_out_of_range_members() {
+        let source = Some("192.0.2.1:1234".parse().unwrap());
+        let destination = Destination::domain("example.com", 443).unwrap();
+        let mut sticky = Balance::new(BalanceStrategy::StickySessions, 3);
+        sticky.health(&[Some(10), None, None]);
+        assert_eq!(sticky.choose(source, Some(&destination), None), 0);
+
+        sticky.health(&[None, None, Some(20)]);
+        assert_eq!(sticky.choose(source, Some(&destination), None), 2);
+        assert_eq!(sticky.sticky.len(), 1);
+        assert_eq!(sticky.sticky.values().next().unwrap().index, 2);
+
+        sticky.health(&[Some(10), Some(15), Some(20)]);
+        assert_eq!(sticky.choose(source, Some(&destination), None), 2);
+
+        // A stale cache index must never index the current member list.
+        sticky.sticky.values_mut().next().unwrap().index = 3;
+        sticky.health(&[None, Some(15), None]);
+        assert_eq!(sticky.choose(source, Some(&destination), None), 1);
+        assert_eq!(sticky.sticky.len(), 1);
+        assert_eq!(sticky.sticky.values().next().unwrap().index, 1);
+    }
+
+    #[test]
+    fn sticky_member_boundaries_keep_empty_and_all_unhealthy_fallbacks() {
+        let mut empty = Balance::new(BalanceStrategy::StickySessions, 0);
+        assert_eq!(empty.choose(None, None, None), 0);
+        assert!(empty.sticky.is_empty());
+
+        let mut single = Balance::new(BalanceStrategy::StickySessions, 1);
+        assert_eq!(single.choose(None, None, None), 0);
+        single.health(&[None]);
+        assert_eq!(single.choose(None, None, None), 0);
+        assert_eq!(single.sticky.len(), 1);
+
+        let mut unhealthy = Balance::new(BalanceStrategy::StickySessions, 3);
+        unhealthy.health(&[None, None, None]);
+        assert_eq!(unhealthy.choose(None, None, None), 0);
+        assert_eq!(unhealthy.sticky.values().next().unwrap().index, 0);
+    }
+
+    #[test]
+    fn ingress_hash_uses_only_authenticated_user_and_keeps_address_fallback() {
+        let a = Destination::domain("first.example.com", 443).unwrap();
+        let b = Destination::domain("other.example.org", 80).unwrap();
+        let first = Some("192.0.2.1:1234".parse().unwrap());
+        let second = Some("203.0.113.2:4321".parse().unwrap());
+        for strategy in [
+            BalanceStrategy::ConsistentHashing,
+            BalanceStrategy::StickySessions,
+        ] {
+            let mut balance = Balance::new(strategy, 7).with_hash_key(BalanceHashKey::InUser);
+            let selected = balance.choose(first, Some(&a), Some("Alice"));
+            assert_eq!(balance.choose(second, Some(&b), Some("Alice")), selected);
+            assert_eq!(balance.choose(None, None, Some("Alice")), selected);
+            if strategy == BalanceStrategy::StickySessions {
+                assert_eq!(balance.sticky.len(), 1);
+                balance.choose(first, Some(&a), None);
+                assert_eq!(balance.sticky.len(), 2);
+                // An empty identity falls back to exactly the same address key.
+                balance.choose(first, Some(&a), Some(""));
+                assert_eq!(balance.sticky.len(), 2);
+            } else {
+                let mut fallback = Balance::new(strategy, 7);
+                assert_eq!(
+                    balance.choose(first, Some(&a), None),
+                    fallback.choose(first, Some(&a), None)
+                );
+                assert_eq!(
+                    balance.choose(second, Some(&b), Some("")),
+                    fallback.choose(second, Some(&b), None)
+                );
+            }
+        }
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn balance_strategies_health_stickiness_and_membership() {
+        let source = Some("192.0.2.1:1234".parse().unwrap());
+        let a = Destination::domain("a.example.co.uk", 443).unwrap();
+        let b = Destination::domain("b.example.co.uk", 80).unwrap();
+        let mut round = Balance::new(BalanceStrategy::RoundRobin, 3);
+        assert_eq!(
+            (0..4)
+                .map(|_| round.choose(source, Some(&a), None))
+                .collect::<Vec<_>>(),
+            [0, 1, 2, 0]
+        );
+        round.health(&[None, Some(20), None]);
+        assert_eq!(round.choose(source, Some(&a), None), 1);
+        let mut hash = Balance::new(BalanceStrategy::ConsistentHashing, 3);
+        assert_eq!(
+            hash.choose(source, Some(&a), None),
+            hash.choose(source, Some(&b), None)
+        );
+        let mut sticky = Balance::new(BalanceStrategy::StickySessions, 3);
+        let index = sticky.choose(source, Some(&a), None);
+        for _ in 0..20 {
+            assert_eq!(sticky.choose(source, Some(&b), None), index);
+        }
+        tokio::time::advance(Duration::from_secs(601)).await;
+        sticky.choose(source, Some(&a), None);
+        assert!(sticky.sticky.values().all(|e| e.expires > Instant::now()));
+        // A new provider generation owns its own state; an old transport keeps its leaf.
+        let mut updated = Balance::new(BalanceStrategy::RoundRobin, 2);
+        assert_eq!(
+            (
+                updated.choose(source, Some(&a), None),
+                updated.choose(source, Some(&b), None)
+            ),
+            (0, 1)
+        );
+        assert_eq!(round.choose(source, Some(&a), None), 1);
+    }
+}
diff --git a/src/routing/datagram_ready.rs b/src/routing/datagram_ready.rs
new file mode 100644
index 0000000..17d24d9
--- /dev/null
+++ b/src/routing/datagram_ready.rs
@@ -0,0 +1,238 @@
+//! Deduplicated readiness for independently polled datagram receivers.
+use crate::session::Destination;
+use futures_util::task::{ArcWake, AtomicWaker};
+use std::{
+    collections::VecDeque,
+    sync::{Arc, Mutex, Weak},
+    task::Waker,
+};
+
+#[derive(Default)]
+pub(super) struct ReadyQueue {
+    entries: Mutex<VecDeque<Arc<ReadyFlow>>>,
+    parent: AtomicWaker,
+}
+
+pub(super) struct ReadyFlow {
+    key: Destination,
+    queue: Weak<ReadyQueue>,
+    state: Mutex<FlowState>,
+}
+
+struct FlowState {
+    active: bool,
+    queued: bool,
+}
+
+impl ReadyQueue {
+    pub fn registration(self: &Arc<Self>, key: Destination) -> Arc<ReadyFlow> {
+        Arc::new(ReadyFlow {
+            key,
+            queue: Arc::downgrade(self),
+            state: Mutex::new(FlowState {
+                active: true,
+                queued: false,
+            }),
+        })
+    }
+
+    /// Register before inspecting readiness on each poll. An enqueue before
+    /// registration remains visible in the queue; one after it wakes the task.
+    pub fn register(&self, waker: &Waker) {
+        self.parent.register(waker);
+    }
+
+    pub fn pop(&self) -> Option<Arc<ReadyFlow>> {
+        let mut entries = self.entries.lock().unwrap();
+        while let Some(flow) = entries.pop_front() {
+            let active = {
+                let mut state = flow.state.lock().unwrap();
+                state.queued = false;
+                state.active
+            };
+            if active {
+                return Some(flow);
+            }
+        }
+        None
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.entries.lock().unwrap().is_empty()
+    }
+
+    pub fn shrink(&self) {
+        let mut entries = self.entries.lock().unwrap();
+        if entries.capacity() > entries.len().saturating_mul(4).max(8) {
+            let retained = entries.len().saturating_mul(2);
+            entries.shrink_to(retained);
+        }
+    }
+}
+
+impl ReadyFlow {
+    pub fn key(&self) -> &Destination {
+        &self.key
+    }
+
+    pub fn enqueue(self: &Arc<Self>) {
+        self.enqueue_inner(true);
+    }
+
+    /// Requeue a ready flow at the FIFO tail while its receiver is polling.
+    /// The caller must explicitly wake if it exhausts its work budget.
+    pub fn requeue(self: &Arc<Self>) {
+        self.enqueue_inner(false);
+    }
+
+    fn enqueue_inner(self: &Arc<Self>, notify_parent: bool) {
+        let Some(queue) = self.queue.upgrade() else {
+            return;
+        };
+        {
+            // Every operation needing both locks takes queue before state.
+            let mut entries = queue.entries.lock().unwrap();
+            let mut state = self.state.lock().unwrap();
+            if !state.active || state.queued {
+                return;
+            }
+            state.queued = true;
+            entries.push_back(self.clone());
+        }
+        // A parent wake is allowed to poll immediately and reacquire the locks.
+        if notify_parent {
+            queue.parent.wake();
+        }
+    }
+
+    /// Permanently retire this registration, including its outstanding item.
+    /// Replacements for the same endpoint have a distinct registration owner.
+    pub fn deactivate(&self) {
+        let Some(queue) = self.queue.upgrade() else {
+            let mut state = self.state.lock().unwrap();
+            state.active = false;
+            state.queued = false;
+            return;
+        };
+        let mut entries = queue.entries.lock().unwrap();
+        let mut state = self.state.lock().unwrap();
+        if !state.active {
+            return;
+        }
+        state.active = false;
+        if state.queued {
+            entries.retain(|flow| !std::ptr::eq(flow.as_ref(), self));
+            state.queued = false;
+        }
+    }
+}
+
+impl ArcWake for ReadyFlow {
+    fn wake_by_ref(arc_self: &Arc<Self>) {
+        arc_self.enqueue();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use futures_util::task::{waker, waker_ref};
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    #[derive(Default)]
+    struct WakeCount(AtomicUsize);
+    impl ArcWake for WakeCount {
+        fn wake_by_ref(arc_self: &Arc<Self>) {
+            arc_self.0.fetch_add(1, Ordering::Relaxed);
+        }
+    }
+    fn key() -> Destination {
+        Destination::Ip("198.51.100.1:443".parse().unwrap())
+    }
+
+    #[test]
+    fn readiness_before_registration_and_cross_thread_wake_are_not_lost() {
+        let queue = Arc::new(ReadyQueue::default());
+        let flow = queue.registration(key());
+        let wakes = Arc::new(WakeCount::default());
+        let parent = waker(wakes.clone());
+
+        flow.enqueue();
+        queue.register(&parent);
+        assert!(Arc::ptr_eq(&queue.pop().unwrap(), &flow));
+        assert!(queue.is_empty());
+
+        queue.register(&parent);
+        std::thread::scope(|scope| {
+            scope.spawn(|| waker_ref(&flow).wake_by_ref());
+        });
+        assert_eq!(wakes.0.load(Ordering::Relaxed), 1);
+        assert_eq!(queue.pop().unwrap().key(), &key());
+        assert!(queue.is_empty());
+    }
+
+    #[test]
+    fn duplicate_notifications_have_one_item_and_reenqueue_is_fifo() {
+        let queue = Arc::new(ReadyQueue::default());
+        let first = queue.registration(key());
+        let second = queue.registration(Destination::Ip("198.51.100.2:443".parse().unwrap()));
+        std::thread::scope(|scope| {
+            for _ in 0..4 {
+                scope.spawn(|| {
+                    for _ in 0..100 {
+                        waker_ref(&first).wake_by_ref();
+                    }
+                });
+            }
+        });
+        second.enqueue();
+        assert!(Arc::ptr_eq(&queue.pop().unwrap(), &first));
+        first.enqueue();
+        assert!(Arc::ptr_eq(&queue.pop().unwrap(), &second));
+        assert!(Arc::ptr_eq(&queue.pop().unwrap(), &first));
+        assert!(queue.is_empty());
+    }
+
+    #[test]
+    fn retirement_removes_queued_items_and_old_waker_cannot_notify_replacement() {
+        let queue = Arc::new(ReadyQueue::default());
+        let old = queue.registration(key());
+        let stale_waker = waker(old.clone());
+        old.enqueue();
+        old.deactivate();
+        assert!(queue.is_empty());
+        let replacement = queue.registration(key());
+        stale_waker.wake_by_ref();
+        assert!(queue.is_empty());
+        replacement.enqueue();
+        assert!(Arc::ptr_eq(&queue.pop().unwrap(), &replacement));
+        old.deactivate();
+        replacement.enqueue();
+        assert!(Arc::ptr_eq(&queue.pop().unwrap(), &replacement));
+        assert!(queue.is_empty());
+        let weak_queue = Arc::downgrade(&queue);
+        drop(queue);
+        assert!(weak_queue.upgrade().is_none());
+        stale_waker.wake_by_ref();
+        replacement.deactivate();
+    }
+
+    #[test]
+    fn synchronous_parent_notification_does_not_hold_queue_locks() {
+        struct PopWake(Arc<ReadyQueue>, AtomicUsize);
+        impl ArcWake for PopWake {
+            fn wake_by_ref(arc_self: &Arc<Self>) {
+                if arc_self.0.pop().is_some() {
+                    arc_self.1.fetch_add(1, Ordering::Relaxed);
+                }
+            }
+        }
+        let queue = Arc::new(ReadyQueue::default());
+        let flow = queue.registration(key());
+        let parent = Arc::new(PopWake(queue.clone(), AtomicUsize::new(0)));
+        queue.register(&waker(parent.clone()));
+        flow.enqueue();
+        assert_eq!(parent.1.load(Ordering::Relaxed), 1);
+        assert!(queue.is_empty());
+    }
+}
diff --git a/src/routing/diagnostics.rs b/src/routing/diagnostics.rs
new file mode 100644
index 0000000..1639d75
--- /dev/null
+++ b/src/routing/diagnostics.rs
@@ -0,0 +1,413 @@
+//! Current effective settings and rule counters; never serialize raw node config.
+use crate::{
+    config::{Config, RouteTargetId, RuleAction, RuleKind},
+    routing::RuleSet,
+};
+use serde_json::{Value, json};
+use std::{
+    collections::{BTreeMap, BTreeSet},
+    sync::{
+        Arc, Mutex,
+        atomic::{AtomicU64, Ordering},
+    },
+};
+
+pub(crate) struct Diagnostics {
+    pub connections: Arc<crate::connections::Registry>,
+    pub proxy_names: Vec<Arc<str>>,
+    providers: BTreeMap<Arc<str>, Vec<Arc<str>>>,
+    names: BTreeSet<Arc<str>>,
+    config: Value,
+    rules: Vec<Rule>,
+    disabled: Arc<super::rule_disable::RuleDisable>,
+}
+struct Rule {
+    kind: &'static str,
+    payload: Arc<str>,
+    target: Arc<str>,
+    hits: AtomicU64,
+    // A numeric UTC value; formatting belongs to the Controller query path.
+    hit_at: Mutex<Option<time::OffsetDateTime>>,
+}
+impl Diagnostics {
+    pub fn new(
+        config: &Config,
+        rules: &RuleSet,
+        connections: Arc<crate::connections::Registry>,
+    ) -> Self {
+        // Intern only display text. Connections can retain these small strings without
+        // pinning a Config or an entire retired resource generation.
+        let mut texts = BTreeSet::new();
+        let mut names = BTreeSet::new();
+        for name in ["", "DIRECT", "REJECT", "PASS", "PASS-RULE"]
+            .into_iter()
+            .chain(config.proxies.iter().map(|p| p.tag.as_str()))
+            .chain(config.proxy_groups.iter().map(|g| g.name.as_str()))
+            .chain(config.provider_members.keys().map(String::as_str))
+        {
+            names.insert(intern(&mut texts, name));
+        }
+        let proxy_names = config
+            .proxies
+            .iter()
+            .map(|p| intern(&mut texts, &p.tag))
+            .collect();
+        let providers = config
+            .provider_members
+            .iter()
+            .map(|(name, members)| {
+                let mut members = members
+                    .iter()
+                    .map(|member| intern(&mut texts, member))
+                    .collect::<Vec<_>>();
+                members.sort_unstable();
+                members.dedup();
+                (intern(&mut texts, name), members)
+            })
+            .collect();
+        let disabled = rules.disable_state().clone();
+        let rules = (0..rules.len())
+            .filter_map(|i| rules.rule(i))
+            .map(|spec| {
+                let (kind, payload) = rule_description(&spec.kind);
+                let target = match &spec.kind {
+                    RuleKind::Flow { control, .. } => control.name(),
+                    RuleKind::SubRule { target, .. } => rules.subrule_name(*target),
+                    _ => match spec.action {
+                        RuleAction::Direct => "DIRECT",
+                        RuleAction::Reject => "REJECT",
+                        RuleAction::RejectDrop => "REJECT-DROP",
+                        RuleAction::Route(RouteTargetId::Proxy(id)) => {
+                            &config.proxies[id.index()].tag
+                        }
+                        RuleAction::Route(RouteTargetId::Group(id)) => {
+                            &config.proxy_groups[id.index()].name
+                        }
+                    },
+                };
+                Rule {
+                    kind,
+                    payload: intern(&mut texts, &payload),
+                    target: intern(&mut texts, target),
+                    hits: AtomicU64::new(0),
+                    hit_at: Mutex::new(None),
+                }
+            })
+            .collect();
+        Self {
+            connections,
+            proxy_names,
+            providers,
+            names,
+            config: effective_config(config),
+            rules,
+            disabled,
+        }
+    }
+    /// Reuse known route/provider names, without retaining dynamic destinations.
+    pub fn text(&self, text: &str) -> Arc<str> {
+        self.names
+            .get(text)
+            .cloned()
+            .unwrap_or_else(|| Arc::from(text))
+    }
+    pub fn providers(&self, chain: &[Arc<str>]) -> Vec<Arc<str>> {
+        self.providers
+            .iter()
+            .filter(|(_, members)| chain.iter().any(|node| members.binary_search(node).is_ok()))
+            .map(|(name, _)| name.clone())
+            .collect()
+    }
+    pub fn config(&self) -> Value {
+        self.config.clone()
+    }
+    pub fn hit(&self, index: usize) {
+        if let Some(rule) = self.rules.get(index) {
+            let mut old = rule.hits.load(Ordering::Relaxed);
+            while let Err(current) = rule.hits.compare_exchange_weak(
+                old,
+                old.saturating_add(1),
+                Ordering::Relaxed,
+                Ordering::Relaxed,
+            ) {
+                old = current;
+            }
+            *rule.hit_at.lock().unwrap() = Some(time::OffsetDateTime::now_utc());
+        }
+    }
+    pub fn matched(&self, index: usize) -> (&'static str, Arc<str>) {
+        self.rules
+            .get(index)
+            .map_or_else(|| ("", self.text("")), |r| (r.kind, r.payload.clone()))
+    }
+    pub fn disable_rules(&self, changes: &[(usize, bool)]) -> Result<(), ()> {
+        self.disabled.apply(changes)
+    }
+    pub fn rules(&self) -> Value {
+        let disabled = self.disabled.snapshot();
+        json!({"rules": self.rules.iter().enumerate().map(|(index, r)| {
+            let hit_at = *r.hit_at.lock().unwrap();
+            let hit_at = hit_at.map(|time| {
+                time.format(&time::format_description::well_known::Rfc3339)
+                    .expect("recorded UTC date")
+            });
+            json!({"index":index,"type":r.kind,"payload":r.payload.as_ref(),"proxy":r.target.as_ref(),"size":-1,"extra":{"disabled":disabled.contains(index),"hitCount":r.hits.load(Ordering::Relaxed),"hitAt":hit_at}})
+        }).collect::<Vec<_>>()})
+    }
+}
+fn intern(texts: &mut BTreeSet<Arc<str>>, text: &str) -> Arc<str> {
+    if let Some(shared) = texts.get(text) {
+        return shared.clone();
+    }
+    let shared: Arc<str> = text.into();
+    texts.insert(shared.clone());
+    shared
+}
+fn effective_config(config: &Config) -> Value {
+    use crate::config::{InboundConfig, LogLevel, Mode};
+    let mixed = config.inbounds.iter().find_map(|inbound| match inbound {
+        InboundConfig::Mixed(mixed) => Some(mixed),
+        _ => None,
+    });
+    json!({
+        "mixed-port":config.mixed_port.unwrap_or(0), "allow-lan":mixed.is_some_and(|m| m.access.allow_lan),
+        "bind-address":mixed.and_then(|m| m.access.bind_address).map_or_else(|| "*".into(), |ip| ip.to_string()),
+        "mode": match config.mode { Mode::Rule => "rule", Mode::Direct => "direct", Mode::Global => "global" },
+        "log-level":match config.log_level { LogLevel::Silent => "silent", LogLevel::Error => "error", LogLevel::Warning => "warning", LogLevel::Info => "info", LogLevel::Debug => "debug" },
+        "ipv6": config.ipv6, "sniffing": config.sniffer.enable, "tcp-concurrent": config.connections.tcp_concurrent, "find-process-mode":config.find_process_mode.name(),
+        "keep-alive-idle": config.connections.keep_alive_idle, "keep-alive-interval":config.connections.keep_alive_interval, "disable-keep-alive":config.connections.disable_keep_alive,
+        "unified-delay":config.unified_delay, "profile":{"store-selected":config.profile.store_selected,"store-fake-ip":config.profile.store_fake_ip},
+        "tun":{"enable":config.tun.enable,"device":config.tun.device,"file-descriptor":config.tun.file_descriptor,"mtu":config.tun.mtu,"udp-timeout":config.tun.udp_timeout.as_secs(),"auto-route":config.tun.auto_route,"auto-detect-interface":config.tun.auto_detect_interface,"dns-hijack":config.tun.dns_hijack.iter().map(ToString::to_string).collect::<Vec<_>>()}
+    })
+}
+fn rule_description(rule: &RuleKind) -> (&'static str, String) {
+    match rule {
+        RuleKind::Domain(s) => ("Domain", s.clone()),
+        RuleKind::DomainSuffix(s) => ("DomainSuffix", s.clone()),
+        RuleKind::DomainKeyword(s) => ("DomainKeyword", s.clone()),
+        RuleKind::DomainWildcard(s) => ("DomainWildcard", s.clone()),
+        RuleKind::DomainRegex(r) => ("DomainRegex", r.as_str().into()),
+        RuleKind::GeoSite(s) => ("GeoSite", s.clone()),
+        RuleKind::GeoIp(s) => ("GeoIP", s.clone()),
+        RuleKind::SrcGeoIp(s) => ("SrcGeoIP", s.clone()),
+        RuleKind::IpAsn(s) => ("IPASN", s.clone()),
+        RuleKind::SrcIpAsn(s) => ("SrcIPASN", s.clone()),
+        RuleKind::InTypes(types) => (
+            "InType",
+            types
+                .iter()
+                .map(|kind| kind.name())
+                .collect::<Vec<_>>()
+                .join("/"),
+        ),
+        RuleKind::InNames(names) => ("InName", names.join("/")),
+        RuleKind::InUsers(users) => ("InUser", users.join("/")),
+        RuleKind::RematchNames(names) => ("RematchName", names.join("/")),
+        RuleKind::Process(rule) => (rule.description(), rule.pattern.clone()),
+        RuleKind::Uid(ranges) => (
+            "UID",
+            ranges
+                .iter()
+                .map(|range| {
+                    if range.start == range.end {
+                        range.start.to_string()
+                    } else {
+                        format!("{}-{}", range.start, range.end)
+                    }
+                })
+                .collect::<Vec<_>>()
+                .join("/"),
+        ),
+        RuleKind::RuleSet { name, .. } => ("RuleSet", name.clone()),
+        RuleKind::IpSuffix(value) => ("IPSuffix", value.as_str().into()),
+        RuleKind::SrcIpSuffix(value) => ("SrcIPSuffix", value.as_str().into()),
+        RuleKind::IpCidr(cidr) => ("IPCIDR", format!("{}/{}", cidr.network, cidr.prefix_len)),
+        RuleKind::SrcIpCidr(cidr) => ("SrcIPCIDR", format!("{}/{}", cidr.network, cidr.prefix_len)),
+        RuleKind::SrcPorts(ports) | RuleKind::DstPorts(ports) | RuleKind::InPorts(ports) => (
+            if matches!(rule, RuleKind::SrcPorts(_)) {
+                "SrcPort"
+            } else if matches!(rule, RuleKind::InPorts(_)) {
+                "InPort"
+            } else {
+                "DstPort"
+            },
+            ports
+                .iter()
+                .map(|p| {
+                    if p.start == p.end {
+                        p.start.to_string()
+                    } else {
+                        format!("{}-{}", p.start, p.end)
+                    }
+                })
+                .collect::<Vec<_>>()
+                .join("/"),
+        ),
+        RuleKind::Network(network) => (
+            "Network",
+            match network {
+                crate::config::Network::Tcp => "tcp",
+                crate::config::Network::Udp => "udp",
+            }
+            .into(),
+        ),
+        RuleKind::Match => ("Match", String::new()),
+        RuleKind::And(rules) | RuleKind::Or(rules) => (
+            if matches!(rule, RuleKind::And(_)) {
+                "AND"
+            } else {
+                "OR"
+            },
+            logical(rules.iter().map(|r| &r.kind)),
+        ),
+        RuleKind::Not(rule) => ("NOT", logical(std::iter::once(&rule.kind))),
+        RuleKind::Flow { predicate, .. } => rule_description(&predicate.kind),
+        RuleKind::SubRule { predicate, .. } => {
+            ("SubRule", logical(std::iter::once(&predicate.kind)))
+        }
+    }
+}
+fn logical<'a>(rules: impl Iterator<Item = &'a RuleKind>) -> String {
+    format!(
+        "({})",
+        rules
+            .map(|r| {
+                let (kind, payload) = rule_description(r);
+                format!("({kind},{payload})")
+            })
+            .collect::<Vec<_>>()
+            .join(",")
+    )
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn shared_diagnostic_text_outlives_only_its_small_value() {
+        let mut config = Config::parse_yaml(
+            br#"
+mixed-port: 1080
+proxies: [{name: edge, type: socks5, server: 192.0.2.1, port: 1080}]
+proxy-groups: [{name: pool, type: select, proxies: [edge]}]
+rules: ["DOMAIN-SUFFIX,example.com,pool", "DOMAIN-SUFFIX,example.com,pool", "MATCH,edge"]
+"#,
+        )
+        .unwrap();
+        config
+            .provider_members
+            .insert("z-provider".into(), vec!["edge".into()]);
+        config
+            .provider_members
+            .insert("a-provider".into(), vec!["edge".into(), "edge".into()]);
+        let rules = RuleSet::compile(config.rules.clone()).unwrap();
+        let diagnostics = Arc::new(Diagnostics::new(&config, &rules, Default::default()));
+        let (_, payload) = diagnostics.matched(0);
+        assert!(Arc::ptr_eq(&payload, &diagnostics.matched(1).1));
+        assert!(Arc::ptr_eq(
+            &diagnostics.proxy_names[0],
+            &diagnostics.text("edge")
+        ));
+        assert!(Arc::ptr_eq(
+            &diagnostics.rules[0].target,
+            &diagnostics.text("pool")
+        ));
+        assert!(Arc::ptr_eq(
+            &diagnostics.rules[2].target,
+            &diagnostics.proxy_names[0]
+        ));
+        let providers =
+            diagnostics.providers(&[diagnostics.text("edge"), diagnostics.text("pool")]);
+        assert_eq!(
+            providers.iter().map(AsRef::as_ref).collect::<Vec<&str>>(),
+            ["a-provider", "z-provider"]
+        );
+        assert!(Arc::ptr_eq(&providers[0], &diagnostics.text("a-provider")));
+        assert!(diagnostics.rules()["rules"][0]["extra"]["hitAt"].is_null());
+        diagnostics.hit(0);
+        let view = diagnostics.rules();
+        let recorded = diagnostics.rules[0].hit_at.lock().unwrap().unwrap();
+        assert_eq!(
+            view["rules"][0]["extra"]["hitAt"],
+            recorded
+                .format(&time::format_description::well_known::Rfc3339)
+                .unwrap()
+        );
+        assert_eq!(view["rules"][0]["extra"]["hitCount"], 1);
+        diagnostics.rules[0].hits.store(u64::MAX, Ordering::Relaxed);
+        diagnostics.hit(0);
+        assert_eq!(
+            diagnostics.rules()["rules"][0]["extra"]["hitCount"],
+            u64::MAX
+        );
+        let owner = Arc::downgrade(&diagnostics);
+        drop(diagnostics);
+        assert!(owner.upgrade().is_none());
+        assert_eq!(payload.as_ref(), "example.com");
+        assert_eq!(providers[0].as_ref(), "a-provider");
+    }
+
+    #[test]
+    fn rule_switch_view_shares_only_small_state_with_the_program() {
+        let config =
+            Config::parse_yaml(b"mixed-port: 1080\nrules: ['MATCH,DIRECT', 'MATCH,REJECT']\n")
+                .unwrap();
+        let rules = RuleSet::compile(config.rules.clone()).unwrap();
+        let program = Arc::downgrade(&rules.graph);
+        let diagnostics = Diagnostics::new(&config, &rules, Default::default());
+        diagnostics.disable_rules(&[(0, true)]).unwrap();
+        let view = diagnostics.rules();
+        assert_eq!(view["rules"][0]["extra"]["disabled"], true);
+        assert_eq!(view["rules"][1]["extra"]["disabled"], false);
+        assert!(matches!(
+            rules.evaluate(
+                &crate::routing::RoutingContext::new(
+                    crate::config::Network::Tcp,
+                    &crate::session::Destination::Ip("192.0.2.1:443".parse().unwrap())
+                )
+                .unwrap()
+            ),
+            crate::routing::RuleEvaluation::Matched(crate::routing::RuleMatch {
+                action: RuleAction::Reject,
+                rule_index: 1
+            })
+        ));
+        drop(rules);
+        assert!(
+            program.upgrade().is_none(),
+            "diagnostics must not pin the whole program"
+        );
+        assert_eq!(diagnostics.rules()["rules"][0]["extra"]["disabled"], true);
+    }
+
+    #[test]
+    fn effective_configuration_excludes_credentials_and_resource_locations() {
+        let config = Config::parse_yaml(br#"
+mixed-port: 1080
+authentication: [user:secret-sentinel]
+external-controller: 127.0.0.1:9090
+secret: controller-sentinel
+proxy-providers:
+  nodes:
+    type: inline
+    payload:
+      - {name: edge, type: socks5, server: 192.0.2.1, port: 1080, password: node-sentinel, username: private-user}
+proxy-groups: [{name: pool, type: select, use: [nodes]}]
+rules: ["MATCH,pool"]
+"#).unwrap();
+        let rules = RuleSet::compile(config.rules.clone()).unwrap();
+        let diagnostics = Diagnostics::new(&config, &rules, Default::default());
+        let view = diagnostics.config().to_string();
+        for secret in [
+            "secret-sentinel",
+            "controller-sentinel",
+            "node-sentinel",
+            "private-user",
+            "192.0.2.1",
+        ] {
+            assert!(!view.contains(secret));
+        }
+        assert_eq!(diagnostics.config()["mixed-port"], 1080);
+        diagnostics.hit(0);
+        assert_eq!(diagnostics.rules()["rules"][0]["extra"]["hitCount"], 1);
+    }
+}
diff --git a/src/routing/dispatcher.rs b/src/routing/dispatcher.rs
index 1c781f0..f3dd326 100644
--- a/src/routing/dispatcher.rs
+++ b/src/routing/dispatcher.rs
@@ -1,6 +1,6 @@
 use std::{
     collections::{HashMap, HashSet},
-    io,
+    future::Future,
     net::{IpAddr, SocketAddr},
     pin::Pin,
     sync::Arc,
@@ -10,33 +10,35 @@ use std::{
 
 use async_trait::async_trait;
 use futures_util::future::select_all;
-use tokio::{
-    io::{AsyncRead, AsyncReadExt as _, AsyncWrite, AsyncWriteExt as _, DuplexStream, ReadBuf},
-    sync::Notify,
-    task::JoinHandle,
-    time::Instant,
-};
+use tokio::{sync::Notify, time::Instant};
 
 use crate::{
     config::{Network, ProxyId, RouteTargetId, RuleAction, TunConfig},
     dispatch::{BoxStream, DatagramTransport, DispatchError, Dispatcher},
-    dns::{
-        MAX_MESSAGE_SIZE,
-        runtime::{DnsWireResponse, RuntimeDns},
-    },
+    dns::runtime::{DnsWireResponse, RuntimeDns},
     session::{Datagram, DatagramSession, Destination, InboundKind, StreamSession},
 };
 
 use super::{
-    GeoMatcher, ProxyGroups, ResolvedProxyGroupLeaf, RoutingContext, RuleEvaluation, RuleSet,
+    GeoMatcher, ProgramEvaluation, ProxyGroups, ResolvedProxyGroupLeaf, RoutingContext, RuleSet,
+    RuleTargetEffect,
+    datagram_ready::{ReadyFlow, ReadyQueue},
+    proxy_group::InspectedRuleTarget,
 };
 
-const TCP_DNS_DUPLEX_CAPACITY: usize = 8 * 1024;
-
 const UDP_FLOW_CLEANUP_INTERVAL: Duration = Duration::from_secs(10);
 
 #[async_trait]
 trait RoutingDns: Send + Sync {
+    fn is_enabled(&self) -> bool {
+        true
+    }
+    fn recover_fake_ip(&self, _address: IpAddr) -> Result<Option<String>, DispatchError> {
+        Ok(None)
+    }
+    async fn resolve_direct(&self, host: &str) -> Result<Vec<IpAddr>, DispatchError> {
+        self.resolve(host).await
+    }
     async fn resolve(&self, host: &str) -> Result<Vec<IpAddr>, DispatchError>;
     async fn exchange(&self, query: &[u8]) -> Result<DnsWireResponse, DispatchError>;
     async fn domain_hint(&self, address: IpAddr) -> Option<String>;
@@ -44,6 +46,18 @@ trait RoutingDns: Send + Sync {
 
 #[async_trait]
 impl RoutingDns for RuntimeDns {
+    fn recover_fake_ip(&self, address: IpAddr) -> Result<Option<String>, DispatchError> {
+        RuntimeDns::recover_fake_ip(self, address).map_err(|_| DispatchError::HostUnreachable)
+    }
+
+    fn is_enabled(&self) -> bool {
+        RuntimeDns::is_enabled(self)
+    }
+    async fn resolve_direct(&self, host: &str) -> Result<Vec<IpAddr>, DispatchError> {
+        RuntimeDns::resolve_direct(self, host)
+            .await
+            .map_err(runtime_dns_error)
+    }
     async fn resolve(&self, host: &str) -> Result<Vec<IpAddr>, DispatchError> {
         RuntimeDns::resolve(self, host)
             .await
@@ -61,8 +75,13 @@ impl RoutingDns for RuntimeDns {
     }
 }
 
-fn runtime_dns_error(error: impl std::fmt::Display) -> DispatchError {
-    DispatchError::Other(format!("runtime DNS: {error}"))
+fn runtime_dns_error(error: crate::dns::runtime::RuntimeDnsError) -> DispatchError {
+    match error {
+        crate::dns::runtime::RuntimeDnsError::RuleEvaluation(failure) => {
+            DispatchError::RuleEvaluation(failure)
+        }
+        error => DispatchError::Other(format!("runtime DNS: {error}")),
+    }
 }
 
 /// Runtime registry for concrete proxy nodes.
@@ -71,6 +90,10 @@ fn runtime_dns_error(error: impl std::fmt::Display) -> DispatchError {
 /// name and methods while this type preserves the public node-only API.
 #[derive(Clone)]
 pub struct ProxyDispatchers {
+    entries: Arc<DispatcherRegistry>,
+}
+
+struct DispatcherRegistry {
     proxies: Vec<Arc<dyn Dispatcher>>,
     groups: Vec<Arc<dyn Dispatcher>>,
     proxy_groups: Option<Arc<ProxyGroups>>,
@@ -80,22 +103,20 @@ impl std::fmt::Debug for ProxyDispatchers {
     fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         formatter
             .debug_struct("ProxyDispatchers")
-            .field("len", &self.proxies.len())
+            .field("len", &self.entries.proxies.len())
+            .field("groups", &self.entries.groups.len())
             .finish_non_exhaustive()
     }
 }
 
 impl ProxyDispatchers {
     pub fn new(proxies: Vec<Arc<dyn Dispatcher>>) -> Result<Self, DispatchError> {
-        if proxies.is_empty() {
-            return Err(DispatchError::Other(
-                "proxy registry must contain at least one entry".to_owned(),
-            ));
-        }
         Ok(Self {
-            proxies,
-            groups: Vec::new(),
-            proxy_groups: None,
+            entries: Arc::new(DispatcherRegistry {
+                proxies,
+                groups: Vec::new(),
+                proxy_groups: None,
+            }),
         })
     }
 
@@ -103,8 +124,7 @@ impl ProxyDispatchers {
         proxies: Vec<Arc<dyn Dispatcher>>,
         proxy_groups: &Arc<ProxyGroups>,
     ) -> Result<Self, DispatchError> {
-        let mut registry = Self::new(proxies)?;
-        registry.groups = (0..proxy_groups.len())
+        let groups = (0..proxy_groups.len())
             .map(|index| {
                 proxy_groups.dispatcher(
                     crate::config::ProxyGroupId::new(index)
@@ -112,59 +132,116 @@ impl ProxyDispatchers {
                 )
             })
             .collect();
-        registry.proxy_groups = Some(proxy_groups.clone());
-        Ok(registry)
+        Ok(Self {
+            entries: Arc::new(DispatcherRegistry {
+                proxies,
+                groups,
+                proxy_groups: Some(proxy_groups.clone()),
+            }),
+        })
     }
 
     #[must_use]
     pub fn len(&self) -> usize {
-        self.proxies.len()
+        self.entries.proxies.len()
     }
 
     #[must_use]
     pub fn is_empty(&self) -> bool {
-        self.proxies.is_empty()
+        self.entries.proxies.is_empty()
     }
 
     pub fn get(&self, id: ProxyId) -> Result<&Arc<dyn Dispatcher>, DispatchError> {
-        self.proxies
+        self.entries
+            .proxies
             .get(id.index())
             .ok_or_else(|| DispatchError::Other(format!("unknown proxy id {}", id.index())))
     }
 
+    #[cfg(test)]
     pub(crate) fn get_route(
         &self,
         id: RouteTargetId,
     ) -> Result<&Arc<dyn Dispatcher>, DispatchError> {
         match id {
             RouteTargetId::Proxy(id) => self.get(id),
-            RouteTargetId::Group(id) => self.groups.get(id.index()).ok_or_else(|| {
+            RouteTargetId::Group(id) => self.entries.groups.get(id.index()).ok_or_else(|| {
                 DispatchError::Other(format!("unknown proxy group id {}", id.index()))
             }),
         }
     }
 
-    pub(crate) fn resolve(
+    pub(crate) fn inspect_rule_target(
+        &self,
+        id: RouteTargetId,
+        udp: bool,
+        commit: bool,
+        source: Option<SocketAddr>,
+        destination: Option<&Destination>,
+        user: Option<&str>,
+    ) -> Result<InspectedRuleTarget, DispatchError> {
+        match id {
+            RouteTargetId::Proxy(id) => {
+                if let Some(target) = self
+                    .entries
+                    .proxy_groups
+                    .as_ref()
+                    .and_then(|groups| groups.rematch(id))
+                {
+                    return Ok(InspectedRuleTarget::Rematch(target.clone()));
+                }
+                let dispatcher = self.get(id)?.clone();
+                if udp && !dispatcher.supports_udp() {
+                    return Ok(InspectedRuleTarget::Unavailable);
+                }
+                Ok(InspectedRuleTarget::Egress(ResolvedProxyGroupLeaf {
+                    chain: Vec::new(),
+                    selections: Vec::new(),
+                    dispatcher,
+                    direct: false,
+                }))
+            }
+            RouteTargetId::Group(id) => self
+                .entries
+                .proxy_groups
+                .as_ref()
+                .ok_or(DispatchError::NotAllowed)?
+                .inspect_rule_target(id, udp, commit, source, destination, user),
+        }
+    }
+
+    fn per_flow(&self, id: RouteTargetId) -> bool {
+        matches!(id, RouteTargetId::Group(id) if self.entries.proxy_groups.as_ref().is_some_and(|groups| groups.contains_balance(id)))
+    }
+    fn resolve_for(
         &self,
         id: RouteTargetId,
+        udp: bool,
+        source: Option<SocketAddr>,
+        destination: Option<&Destination>,
+        user: Option<&str>,
     ) -> Result<ResolvedProxyGroupLeaf, DispatchError> {
         match id {
             RouteTargetId::Proxy(id) => self
+                .entries
                 .proxies
                 .get(id.index())
                 .cloned()
                 .map(|dispatcher| ResolvedProxyGroupLeaf {
+                    chain: Vec::new(),
+                    selections: Vec::new(),
                     dispatcher,
                     direct: false,
                 })
                 .ok_or_else(|| DispatchError::Other(format!("unknown proxy id {}", id.index()))),
             RouteTargetId::Group(id) => self
+                .entries
                 .proxy_groups
                 .as_ref()
                 .ok_or_else(|| {
                     DispatchError::Other(format!("unknown proxy group id {}", id.index()))
                 })?
-                .resolve_leaf(id),
+                .resolve_leaf_for(id, udp, source, destination, user),
         }
     }
 }
@@ -181,14 +258,50 @@ pub(crate) type RouteTargetDispatchers = ProxyDispatchers;
 pub struct RoutingDispatcher {
     route_targets: ProxyDispatchers,
     direct: Arc<dyn Dispatcher>,
+    reject_drop: Arc<dyn Dispatcher>,
     dns: Option<Arc<dyn RoutingDns>>,
     ipv6: bool,
     rules: Arc<RuleSet>,
     geo_matcher: Arc<dyn GeoMatcher>,
     tun_config: TunConfig,
+    sniffer: Option<Arc<crate::sniffing::Policy>>,
+    tcp_concurrent: bool,
+    diagnostics: Option<Arc<crate::routing::diagnostics::Diagnostics>>,
+    process_mode: crate::config::FindProcessMode,
+    process_dialer: Option<crate::dialer::Dialer>,
 }
 
 impl RoutingDispatcher {
+    pub(crate) fn with_process_lookup(
+        mut self,
+        mode: crate::config::FindProcessMode,
+        dialer: crate::dialer::Dialer,
+    ) -> Self {
+        self.process_mode = mode;
+        self.process_dialer = Some(dialer);
+        self
+    }
+    pub(crate) fn with_reject_drop(mut self, dispatcher: Arc<dyn Dispatcher>) -> Self {
+        self.reject_drop = dispatcher;
+        self
+    }
+    pub(crate) fn with_diagnostics(
+        mut self,
+        diagnostics: Arc<crate::routing::diagnostics::Diagnostics>,
+    ) -> Self {
+        self.diagnostics = Some(diagnostics);
+        self
+    }
+    pub(crate) fn with_tcp_concurrent(mut self, enabled: bool) -> Self {
+        self.tcp_concurrent = enabled;
+        self
+    }
+    pub(crate) fn with_sniffer(mut self, config: &crate::config::SnifferConfig) -> Self {
+        self.sniffer = config.enable.then(|| {
+            crate::sniffing::Policy::new(Arc::new(config.clone()), self.geo_matcher.clone())
+        });
+        self
+    }
     #[must_use]
     pub fn new(
         route_targets: ProxyDispatchers,
@@ -212,11 +325,17 @@ impl RoutingDispatcher {
         Self {
             route_targets,
             direct,
+            reject_drop: default_reject_drop(),
             dns: dns.map(|dns| dns as Arc<dyn RoutingDns>),
             ipv6,
             rules: Arc::new(rules),
             geo_matcher,
             tun_config: TunConfig::default(),
+            sniffer: None,
+            tcp_concurrent: false,
+            diagnostics: None,
+            process_mode: crate::config::FindProcessMode::Strict,
+            process_dialer: None,
         }
     }
 
@@ -233,10 +352,16 @@ impl RoutingDispatcher {
             route_targets: ProxyDispatchers::new(vec![proxy])
                 .expect("test proxy registry contains one entry"),
             direct,
+            reject_drop: default_reject_drop(),
             dns,
             ipv6,
             rules: Arc::new(rules),
             geo_matcher,
+            sniffer: None,
+            tcp_concurrent: false,
+            diagnostics: None,
+            process_mode: crate::config::FindProcessMode::Strict,
+            process_dialer: None,
             tun_config: TunConfig {
                 udp_timeout: Duration::from_secs(30),
                 ..TunConfig::default()
@@ -257,23 +382,80 @@ impl RoutingDispatcher {
         Ok(())
     }
 
-    async fn resolve_addresses(&self, dns: &Arc<dyn RoutingDns>, host: &str) -> Vec<IpAddr> {
-        let mut addresses = dns.resolve(host).await.unwrap_or_default();
+    async fn resolve_addresses(
+        &self,
+        dns: &Arc<dyn RoutingDns>,
+        host: &str,
+    ) -> Result<Vec<IpAddr>, DispatchError> {
+        let mut addresses = match dns.resolve(host).await {
+            Ok(addresses) => addresses,
+            Err(error @ DispatchError::RuleEvaluation(_)) => return Err(error),
+            Err(_) => Vec::new(),
+        };
         if !self.ipv6 {
             addresses.retain(IpAddr::is_ipv4);
         }
-        addresses
+        Ok(addresses)
     }
 
     async fn route(
         &self,
         network: Network,
-        inbound: InboundKind,
+        inbound: (InboundKind, &crate::session::InboundMetadata),
+        source: SocketAddr,
         destination: &Destination,
         sniffed_domain: Option<&str>,
+        mut cached: Option<
+            &mut HashMap<(RouteTargetId, Option<Destination>), CachedRouteTransport>,
+        >,
     ) -> Result<RouteDecision, DispatchError> {
+        let (inbound, inbound_metadata) = inbound;
+        let unsaved = (business(inbound) && inbound_metadata.original.is_none())
+            .then(|| inbound_metadata.facts(source, inbound, destination));
+        let original = inbound_metadata.original.as_deref().or(unsaved.as_ref());
         self.ensure_destination_allowed(destination)?;
-        let accepts_domain_hint = inbound == InboundKind::Tun && self.rules.uses_domain_routing();
+        let recovered = if matches!(
+            inbound,
+            InboundKind::Tun | InboundKind::Http | InboundKind::Https | InboundKind::Socks5
+        ) {
+            match (destination, &self.dns) {
+                (Destination::Ip(address), Some(dns)) => {
+                    dns.recover_fake_ip(address.ip())?
+                        .map(|host| Destination::Domain {
+                            host,
+                            port: address.port(),
+                        })
+                }
+                _ => None,
+            }
+        } else {
+            None
+        };
+        let overridden = (network == Network::Udp
+            && self
+                .sniffer
+                .as_ref()
+                .is_some_and(|policy| policy.config.quic_override))
+        .then(|| {
+            sniffed_domain.map(|host| Destination::Domain {
+                host: host.to_owned(),
+                port: destination.port(),
+            })
+        })
+        .flatten();
+        let destination = overridden
+            .as_ref()
+            .or(recovered.as_ref())
+            .unwrap_or(destination);
+        let accepts_domain_hint = business(inbound)
+            && (self.rules.uses_domain_routing()
+                || self.diagnostics.is_some()
+                || self
+                    .route_targets
+                    .entries
+                    .proxy_groups
+                    .as_ref()
+                    .is_some_and(|groups| groups.has_balance()));
         let sniffed_domain = accepts_domain_hint.then_some(sniffed_domain).flatten();
         let dns_domain_hint = match (accepts_domain_hint, destination, &self.dns, sniffed_domain) {
             (true, Destination::Ip(address), Some(dns), None) => {
@@ -284,60 +466,202 @@ impl RoutingDispatcher {
         let domain_hint = sniffed_domain.or(dns_domain_hint.as_deref());
         let mut context = RoutingContext::with_domain_hint(network, destination, domain_hint)
             .map_err(|_| DispatchError::HostUnreachable)?;
+        if let Some(host) = sniffed_domain {
+            context.set_sniffed_domain(host);
+        }
+
+        context.set_source(source);
+        context.set_inbound(inbound, inbound_metadata);
+        context.enable_process_lookup(
+            business(inbound)
+                && self.process_mode != crate::config::FindProcessMode::Off
+                && self.process_dialer.is_some(),
+        );
+        if business(inbound) && self.process_mode == crate::config::FindProcessMode::Always {
+            self.lookup_process(&mut context, network, original).await?;
+        }
 
         // All GeoData rules in this decision see the same immutable view.
         let snapshot = self.geo_matcher.routing_snapshot();
         let geo_matcher = snapshot.as_deref().unwrap_or(self.geo_matcher.as_ref());
 
         let mut resolved = None;
-        let evaluation = match self.rules.evaluate_with_geo(&context, geo_matcher) {
-            RuleEvaluation::NeedsIpResolution { rule_index } => {
-                let addresses = match (destination, &self.dns) {
-                    (Destination::Domain { host, .. }, Some(dns)) => {
-                        self.resolve_addresses(dns, context.domain().unwrap_or(host))
-                            .await
-                    }
-                    _ => Vec::new(),
-                };
-                resolved = Some(addresses);
-                self.rules.evaluate_with_resolved_ips(
-                    &mut context,
-                    geo_matcher,
-                    rule_index,
-                    resolved.as_deref().unwrap_or_default(),
-                )
+        let mut selected = None;
+        let mut selection_error = None;
+        let mut select = |action, candidate: &RoutingContext| {
+            let RuleAction::Route(id) = action else {
+                return RuleTargetEffect::Accept;
+            };
+            let metadata = candidate.domain().map_or_else(
+                || destination.clone(),
+                |host| Destination::Domain {
+                    host: host.to_owned(),
+                    port: destination.port(),
+                },
+            );
+            let key = (
+                id,
+                self.route_targets.per_flow(id).then(|| destination.clone()),
+            );
+            let cached = cached
+                .as_deref_mut()
+                .and_then(|cached| cached.get(&key))
+                .map(|cached| cached.leaf.clone());
+            if let Some(leaf) = cached {
+                // Existing UDP transports retain their selected leaf even if
+                // the group's next member cannot carry UDP.
+                selected = Some(Ok(leaf));
+                return RuleTargetEffect::Accept;
+            }
+            match self.route_targets.inspect_rule_target(
+                id,
+                network == Network::Udp,
+                true,
+                Some(source),
+                Some(&metadata),
+                candidate.authenticated_user(),
+            ) {
+                Ok(InspectedRuleTarget::Rematch(_)) if !self.rules.filters_udp() => {
+                    selected = Some(Err(DispatchError::NotAllowed));
+                    RuleTargetEffect::Accept
+                }
+                Ok(InspectedRuleTarget::Rematch(target)) => RuleTargetEffect::Rematch(target),
+                Ok(InspectedRuleTarget::Control(_)) if !self.rules.filters_udp() => {
+                    selected = Some(Err(DispatchError::NotAllowed));
+                    RuleTargetEffect::Accept
+                }
+                Ok(InspectedRuleTarget::Control(control)) => RuleTargetEffect::Control(control),
+                Ok(InspectedRuleTarget::Egress(leaf)) => {
+                    selected = Some(Ok(leaf));
+                    RuleTargetEffect::Accept
+                }
+                Ok(InspectedRuleTarget::Unavailable) if self.rules.filters_udp() => {
+                    RuleTargetEffect::Skip
+                }
+                Ok(InspectedRuleTarget::Unavailable) => {
+                    selected = Some(Err(DispatchError::NotAllowed));
+                    RuleTargetEffect::Accept
+                }
+                Err(error) => {
+                    selection_error = Some(error);
+                    RuleTargetEffect::Accept
+                }
             }
-            evaluation => evaluation,
         };
-
-        let RuleEvaluation::Matched(rule_match) = evaluation else {
+        let mut cursor = None;
+        let evaluation = loop {
+            match self.rules.evaluate_program(
+                &mut context,
+                geo_matcher,
+                cursor.take(),
+                resolved.as_deref(),
+                &mut select,
+            ) {
+                ProgramEvaluation::NeedsProcessLookup(next) => {
+                    self.lookup_process(&mut context, network, original).await?;
+                    cursor = Some(next);
+                }
+                ProgramEvaluation::NeedsIpResolution(next) => {
+                    let addresses = match (destination, &self.dns) {
+                        (Destination::Domain { host, .. }, Some(dns)) => {
+                            context
+                                .decision()
+                                .scope(self.resolve_addresses(dns, host))
+                                .await?
+                        }
+                        _ => Vec::new(),
+                    };
+                    resolved = Some(addresses);
+                    // Resume the exact predicate, including nested sub-rules.
+                    // A process pause may follow DNS (or precede it) once.
+                    cursor = Some(next);
+                }
+                evaluation => break evaluation,
+            }
+        };
+        if let Some(error) = selection_error {
+            return Err(error);
+        }
+        if let ProgramEvaluation::Failed(failure) = evaluation {
+            return Err(DispatchError::RuleEvaluation(failure));
+        }
+        let ProgramEvaluation::Matched(rule_match) = evaluation else {
             return Err(DispatchError::Other(
                 "routing rules produced no final action".to_owned(),
             ));
         };
 
+        if business(inbound)
+            && let Some(diagnostics) = &self.diagnostics
+        {
+            diagnostics.hit(rule_match.rule_index);
+        }
+        if recovered.is_some() {
+            crate::dns::trace::record("fake-ip-recovery");
+        }
         let routed_destination = match destination {
-            Destination::Domain { port, .. } => Destination::Domain {
-                host: context
-                    .domain()
-                    .expect("domain destination has a normalized routing domain")
-                    .to_owned(),
+            Destination::Domain { host, port } => Destination::Domain {
+                host: super::normalize_domain_name(host)
+                    .map_err(|_| DispatchError::HostUnreachable)?,
                 port: *port,
             },
             Destination::Ip(_) => destination.clone(),
         };
         let mut decision = RouteDecision {
+            original: inbound_metadata.original.clone().or_else(|| {
+                self.diagnostics
+                    .as_ref()
+                    .and_then(|_| original.cloned().map(Arc::new))
+            }),
+            process: context.process().cloned().unwrap_or_default(),
+            rule_index: rule_match.rule_index,
+            dns_mode: if recovered.is_some() {
+                "fake-ip"
+            } else if dns_domain_hint.is_some() {
+                "mapping"
+            } else {
+                "normal"
+            },
+            metadata: context.domain().map_or_else(
+                || destination.clone(),
+                |host| Destination::Domain {
+                    host: host.to_owned(),
+                    port: destination.port(),
+                },
+            ),
             action: rule_match.action,
             destination: context.pinned_ip().map_or(routed_destination, |address| {
                 Destination::Ip(std::net::SocketAddr::new(address, destination.port()))
             }),
             resolved_addresses: resolved,
+            selected,
         };
         if decision.action == RuleAction::Direct {
             self.resolve_direct_destination(&mut decision).await?;
         }
         Ok(decision)
     }
+    async fn lookup_process(
+        &self,
+        context: &mut RoutingContext,
+        network: Network,
+        original: Option<&crate::session::InboundSnapshot>,
+    ) -> Result<(), DispatchError> {
+        let query =
+            original.and_then(|origin| crate::process::Query::from_snapshot(network, origin));
+        let identity = match (query, &self.process_dialer) {
+            (Some(query), Some(dialer)) => dialer
+                .process_identity(query)
+                .await
+                .map_err(|_| DispatchError::NotAllowed)?,
+            _ => Default::default(),
+        };
+        context.set_process(identity);
+        context
+            .decision()
+            .check()
+            .map_err(DispatchError::RuleEvaluation)
+    }
 
     async fn resolve_direct_destination(
         &self,
@@ -351,7 +675,13 @@ impl RoutingDispatcher {
             preferred_address(addresses)
         } else {
             let addresses = match &self.dns {
-                Some(dns) => self.resolve_addresses(dns, &host).await,
+                Some(dns) => dns
+                    .resolve_direct(&host)
+                    .await
+                    .unwrap_or_default()
+                    .into_iter()
+                    .filter(|ip| self.ipv6 || ip.is_ipv4())
+                    .collect(),
                 None => Vec::new(),
             };
             let address = preferred_address(&addresses);
@@ -364,91 +694,43 @@ impl RoutingDispatcher {
     }
 
     fn dns_tcp_stream(&self, dns: Arc<dyn RoutingDns>) -> BoxStream {
-        let (client, mut server) = tokio::io::duplex(TCP_DNS_DUPLEX_CAPACITY);
-        let relay = crate::resources::observation::spawn(async move {
-            let mut query = vec![0_u8; MAX_MESSAGE_SIZE];
-            let mut length = [0_u8; 2];
-            loop {
-                if server.read_exact(&mut length).await.is_err() {
-                    break;
-                }
-                let length = usize::from(u16::from_be_bytes(length));
-                if length == 0 || length > MAX_MESSAGE_SIZE {
-                    break;
-                }
-                if server.read_exact(&mut query[..length]).await.is_err() {
-                    break;
-                }
-                let Ok(response) = dns.exchange(&query[..length]).await else {
-                    break;
-                };
-                if response.wire().is_empty() || response.wire().len() > MAX_MESSAGE_SIZE {
-                    break;
-                }
-                let Ok(response_len) = u16::try_from(response.wire().len()) else {
-                    break;
-                };
-                if server.write_all(&response_len.to_be_bytes()).await.is_err()
-                    || server.write_all(response.wire()).await.is_err()
-                {
-                    break;
-                }
-            }
-            let _ = server.shutdown().await;
-        });
-        Box::new(DnsTcpStream {
-            inner: client,
-            relay,
-        })
+        crate::outbound::dns_tcp_stream(
+            Arc::new(RoutingDnsExchange(Arc::downgrade(&dns))),
+            tokio_util::sync::CancellationToken::new(),
+            None,
+        )
     }
 }
 
-/// Couples the local TCP DNS relay task to the stream returned to the inbound.
-/// Dropping a cancelled TUN session aborts an in-flight upstream query instead
-/// of leaving it detached in the runtime until its nameserver timeout expires.
-struct DnsTcpStream {
-    inner: DuplexStream,
-    relay: JoinHandle<()>,
-}
-
-impl AsyncRead for DnsTcpStream {
-    fn poll_read(
-        mut self: Pin<&mut Self>,
-        context: &mut Context<'_>,
-        buffer: &mut ReadBuf<'_>,
-    ) -> Poll<io::Result<()>> {
-        Pin::new(&mut self.inner).poll_read(context, buffer)
-    }
+fn default_reject_drop() -> Arc<dyn Dispatcher> {
+    Arc::new(crate::outbound::ConnectorDispatcher::new(Arc::new(
+        crate::outbound::RejectOutbound::drop_connections(),
+    )))
 }
 
-impl AsyncWrite for DnsTcpStream {
-    fn poll_write(
-        mut self: Pin<&mut Self>,
-        context: &mut Context<'_>,
-        buffer: &[u8],
-    ) -> Poll<io::Result<usize>> {
-        Pin::new(&mut self.inner).poll_write(context, buffer)
-    }
-
-    fn poll_flush(mut self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<io::Result<()>> {
-        Pin::new(&mut self.inner).poll_flush(context)
-    }
+struct RoutingDnsExchange(std::sync::Weak<dyn RoutingDns>);
 
-    fn poll_shutdown(mut self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<io::Result<()>> {
-        Pin::new(&mut self.inner).poll_shutdown(context)
-    }
-}
-
-impl Drop for DnsTcpStream {
-    fn drop(&mut self) {
-        self.relay.abort();
+#[async_trait]
+impl crate::outbound::DnsExchange for RoutingDnsExchange {
+    async fn exchange(&self, query: &[u8]) -> Result<DnsWireResponse, DispatchError> {
+        self.0
+            .upgrade()
+            .ok_or(DispatchError::HostUnreachable)?
+            .exchange(query)
+            .await
     }
 }
 
 struct RouteDecision {
+    original: Option<Arc<crate::session::InboundSnapshot>>,
+    process: crate::process::Identity,
+    rule_index: usize,
+    dns_mode: &'static str,
+    metadata: Destination,
     action: RuleAction,
     destination: Destination,
     resolved_addresses: Option<Vec<IpAddr>>,
+    selected: Option<Result<ResolvedProxyGroupLeaf, DispatchError>>,
 }
 
 fn log_route_decision(network: Network, decision: &RouteDecision) {
@@ -480,6 +762,12 @@ fn log_route_decision(network: Network, decision: &RouteDecision) {
             destination_port,
             "routing decision"
         ),
+        RuleAction::RejectDrop => tracing::debug!(
+            ?network,
+            action = "reject_drop",
+            destination_port,
+            "routing decision"
+        ),
     }
 }
 
@@ -493,11 +781,93 @@ fn preferred_address(addresses: &[IpAddr]) -> Option<IpAddr> {
 
 #[async_trait]
 impl Dispatcher for RoutingDispatcher {
-    async fn connect_tcp(&self, mut session: StreamSession) -> Result<BoxStream, DispatchError> {
+    async fn sniff_plan(
+        &self,
+        source: SocketAddr,
+        destination: &Destination,
+    ) -> Result<Option<crate::sniffing::Plan>, DispatchError> {
+        let Some(policy) = self.sniffer.as_ref() else {
+            return Ok(None);
+        };
+        let (host, mapped) = match destination {
+            Destination::Domain { host, .. } => (Some(host.clone()), false),
+            Destination::Ip(address) => {
+                let fake = self
+                    .dns
+                    .as_ref()
+                    .and_then(|dns| dns.recover_fake_ip(address.ip()).ok().flatten());
+                if fake.is_some() {
+                    (fake, false)
+                } else {
+                    let hint = if let Some(dns) = &self.dns {
+                        dns.domain_hint(address.ip()).await
+                    } else {
+                        None
+                    };
+                    let mapped = hint.is_some();
+                    (hint, mapped)
+                }
+            }
+        };
+        Ok(Some(policy.plan(
+            source,
+            destination,
+            host.as_deref(),
+            mapped,
+        )?))
+    }
+
+    async fn connect_tcp(&self, session: StreamSession) -> Result<BoxStream, DispatchError> {
+        if self.diagnostics.is_some() && business(session.inbound) {
+            crate::dns::trace::capture(self.connect_tcp_inner(session))
+                .await
+                .0
+        } else {
+            self.connect_tcp_inner(session).await
+        }
+    }
+
+    async fn open_datagram(
+        &self,
+        session: DatagramSession,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        Ok(Box::new(self.routed_datagrams(session)))
+    }
+}
+
+impl RoutingDispatcher {
+    fn routed_datagrams(&self, session: DatagramSession) -> RoutedDatagramTransport {
+        let managed_ready = (self.diagnostics.is_some() && business(session.inbound))
+            .then(|| Arc::new(ReadyQueue::default()));
+        RoutedDatagramTransport {
+            router: self.clone_parts(),
+            session,
+            route_transports: HashMap::new(),
+            fake_flows: HashMap::new(),
+            managed_flows: ManagedDatagramFlows::default(),
+            managed_shared: HashMap::new(),
+            managed_shared_sequence: 0,
+            managed_ready,
+            managed_receive_buffer: Vec::new(),
+            managed_next_cleanup: Instant::now() + UDP_FLOW_CLEANUP_INTERVAL,
+            direct_transport: None,
+            flows: DatagramRoutes::new(self.tun_config.udp_timeout),
+            logged_route_actions: HashSet::new(),
+            receive_wakeup: Arc::new(Notify::new()),
+        }
+    }
+
+    async fn connect_tcp_inner(
+        &self,
+        mut session: StreamSession,
+    ) -> Result<BoxStream, DispatchError> {
+        if business(session.inbound) {
+            session.capture_original();
+        }
         self.ensure_destination_allowed(&session.destination)?;
         if session.inbound == InboundKind::Tun
             && matches!(&session.destination, Destination::Ip(address) if self.tun_config.hijacks_dns(*address))
-            && let Some(dns) = &self.dns
+            && let Some(dns) = self.dns.as_ref().filter(|dns| dns.is_enabled())
         {
             return Ok(self.dns_tcp_stream(dns.clone()));
         }
@@ -505,60 +875,178 @@ impl Dispatcher for RoutingDispatcher {
         let mut decision = self
             .route(
                 Network::Tcp,
-                session.inbound,
+                (session.inbound, &session.metadata),
+                session.source,
                 &session.destination,
                 session.sniffed_domain.as_deref(),
+                None,
             )
             .await?;
-        let resolved_target = match decision.action {
-            RuleAction::Route(id) => Some(self.route_targets.resolve(id)?),
-            RuleAction::Direct | RuleAction::Reject => None,
-        };
+        let resolved_target = decision.selected.take().transpose()?;
         if resolved_target.as_ref().is_some_and(|target| target.direct) {
             self.resolve_direct_destination(&mut decision).await?;
         }
         log_route_decision(Network::Tcp, &decision);
-        session.destination = decision.destination;
-        session.sniffed_domain = None;
-        match decision.action {
-            RuleAction::Route(_) => {
-                resolved_target
-                    .expect("route target was resolved before dispatch")
-                    .dispatcher
-                    .connect_tcp(session)
-                    .await
+        let chain = resolved_target
+            .as_ref()
+            .map_or_else(Vec::new, |target| target.chain.clone());
+        let connection = self.connection(
+            Network::Tcp,
+            session.inbound,
+            session.source,
+            &session.destination,
+            session.sniffed_domain.as_deref(),
+            &decision,
+            chain,
+        );
+        let setup = async {
+            let direct = decision.action == RuleAction::Direct
+                || resolved_target.as_ref().is_some_and(|target| target.direct);
+            if direct
+                && self.tcp_concurrent
+                && let Some(addresses) = &decision.resolved_addresses
+                && addresses.len() > 1
+            {
+                let dispatcher = resolved_target
+                    .as_ref()
+                    .map_or(&self.direct, |target| &target.dispatcher);
+                let addresses = addresses
+                    .iter()
+                    .map(|&ip| SocketAddr::new(ip, decision.destination.port()))
+                    .collect::<Vec<_>>();
+                return crate::dialer::race_connections(&addresses, None, |address| {
+                    let mut attempt = session.clone();
+                    attempt.destination = Destination::Ip(address);
+                    attempt.sniffed_domain = None;
+                    dispatcher.connect_tcp(attempt)
+                })
+                .await;
             }
-            RuleAction::Direct => self.direct.connect_tcp(session).await,
-            RuleAction::Reject => Err(DispatchError::NotAllowed),
+            session.destination = decision.destination;
+            session.sniffed_domain = None;
+            match decision.action {
+                RuleAction::Route(_) => {
+                    let target = resolved_target
+                        .as_ref()
+                        .expect("route target was resolved before dispatch");
+                    let result = target.dispatcher.connect_tcp(session).await;
+                    target.report(&result);
+                    result
+                }
+                RuleAction::Direct => self.direct.connect_tcp(session).await,
+                RuleAction::Reject => Err(DispatchError::NotAllowed),
+                RuleAction::RejectDrop => self.reject_drop.connect_tcp(session).await,
+            }
+        };
+        if let Some(connection) = connection {
+            let token = connection.token();
+            let result = tokio::select! { biased; () = token.cancelled() => Err(DispatchError::NotAllowed), result = setup => result };
+            connection.dns_path(crate::dns::trace::snapshot());
+            match result {
+                Ok(stream) => Ok(connection.stream(stream)),
+                Err(error) => {
+                    if !connection.cancelled() {
+                        connection.failed(&error);
+                    }
+                    Err(error)
+                }
+            }
+        } else {
+            setup.await
         }
     }
 
-    async fn open_datagram(
+    #[allow(clippy::too_many_arguments)]
+    fn connection(
         &self,
-        session: DatagramSession,
-    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
-        Ok(Box::new(RoutedDatagramTransport {
-            router: self.clone_parts(),
-            session,
-            route_transports: HashMap::new(),
-            direct_transport: None,
-            flows: DatagramRoutes::new(self.tun_config.udp_timeout),
-            logged_route_actions: HashSet::new(),
-            receive_wakeup: Arc::new(Notify::new()),
-        }))
+        network: Network,
+        inbound: InboundKind,
+        source: SocketAddr,
+        original: &Destination,
+        sniffed: Option<&str>,
+        decision: &RouteDecision,
+        chain: Vec<String>,
+    ) -> Option<crate::connections::Connection> {
+        if !business(inbound) {
+            return None;
+        }
+        let diagnostics = self.diagnostics.as_ref()?;
+        let mut chain = chain
+            .iter()
+            .map(|name| diagnostics.text(name))
+            .collect::<Vec<_>>();
+        if chain.is_empty() {
+            chain.push(match decision.action {
+                RuleAction::Direct => diagnostics.text("DIRECT"),
+                RuleAction::Reject => diagnostics.text("REJECT"),
+                RuleAction::RejectDrop => diagnostics.text("REJECT-DROP"),
+                RuleAction::Route(RouteTargetId::Proxy(id)) => {
+                    diagnostics.proxy_names[id.index()].clone()
+                }
+                RuleAction::Route(RouteTargetId::Group(_)) => {
+                    unreachable!("group leaf supplies chain")
+                }
+            });
+        }
+        let (rule, rule_payload) = diagnostics.matched(decision.rule_index);
+        let host = match &decision.metadata {
+            Destination::Domain { host, .. } => diagnostics.text(host),
+            _ => diagnostics.text(""),
+        };
+        let destination_ip = match &decision.destination {
+            Destination::Ip(addr) => Some(addr.ip()),
+            _ => None,
+        };
+        let provider_chains = diagnostics.providers(&chain);
+        Some(
+            diagnostics
+                .connections
+                .open(crate::connections::ConnectionInfo {
+                    metadata: crate::connections::ConnectionMetadata {
+                        network: if network == Network::Tcp {
+                            "tcp"
+                        } else {
+                            "udp"
+                        },
+                        inbound_type: match inbound {
+                            InboundKind::Tun => "Tun",
+                            InboundKind::Http => "HTTP",
+                            InboundKind::Https => "HTTPS",
+                            _ => "Socks5",
+                        },
+                        source,
+                        destination_ip,
+                        destination_port: original.port(),
+                        host,
+                        dns_mode: decision.dns_mode,
+                        sniff_host: diagnostics.text(sniffed.unwrap_or_default()),
+                        process: decision.process.clone(),
+                        original: decision.original.clone(),
+                    },
+                    chains: chain,
+                    provider_chains,
+                    rule,
+                    rule_payload,
+                    dns_path: crate::dns::trace::snapshot(),
+                }),
+        )
     }
-}
 
-impl RoutingDispatcher {
     fn clone_parts(&self) -> Self {
         Self {
             route_targets: self.route_targets.clone(),
             direct: self.direct.clone(),
+            reject_drop: self.reject_drop.clone(),
             dns: self.dns.clone(),
             ipv6: self.ipv6,
             rules: self.rules.clone(),
             geo_matcher: self.geo_matcher.clone(),
             tun_config: self.tun_config.clone(),
+            sniffer: self.sniffer.clone(),
+            tcp_concurrent: self.tcp_concurrent,
+            diagnostics: self.diagnostics.clone(),
+            process_mode: self.process_mode,
+            process_dialer: self.process_dialer.clone(),
         }
     }
 }
@@ -566,14 +1054,118 @@ impl RoutingDispatcher {
 struct RoutedDatagramTransport {
     router: RoutingDispatcher,
     session: DatagramSession,
-    route_transports: HashMap<RouteTargetId, CachedRouteTransport>,
+    route_transports: HashMap<(RouteTargetId, Option<Destination>), CachedRouteTransport>,
+    fake_flows: HashMap<SocketAddr, FakeDatagramFlow>,
+    managed_flows: ManagedDatagramFlows,
+    managed_shared: HashMap<usize, ManagedSharedTransport>,
+    managed_shared_sequence: usize,
+    managed_ready: Option<Arc<ReadyQueue>>,
+    managed_receive_buffer: Vec<u8>,
+    managed_next_cleanup: Instant,
     direct_transport: Option<Box<dyn DatagramTransport>>,
     flows: DatagramRoutes,
     logged_route_actions: HashSet<LoggedRouteAction>,
     receive_wakeup: Arc<Notify>,
 }
 
+// Each synthetic target owns an association: two names may resolve to the same
+// real endpoint, and replies must still retain their original synthetic address.
+struct FakeDatagramFlow {
+    transport: Box<dyn DatagramTransport>,
+    remote: SocketAddr,
+    last_used: Instant,
+    flow_id: Option<Box<[u8]>>,
+}
+
+struct ManagedReceive {
+    wake: Arc<ReadyFlow>,
+    cancelled: Pin<Box<tokio_util::sync::WaitForCancellationFutureOwned>>,
+}
+
+#[derive(Default)]
+struct ManagedDatagramFlows {
+    polled: HashMap<Destination, ManagedDatagramFlow>,
+    asynchronous: HashMap<Destination, ManagedDatagramFlow>,
+}
+impl ManagedDatagramFlows {
+    fn get(&self, key: &Destination) -> Option<&ManagedDatagramFlow> {
+        self.polled.get(key).or_else(|| self.asynchronous.get(key))
+    }
+    fn get_mut(&mut self, key: &Destination) -> Option<&mut ManagedDatagramFlow> {
+        self.polled
+            .get_mut(key)
+            .or_else(|| self.asynchronous.get_mut(key))
+    }
+    fn contains_key(&self, key: &Destination) -> bool {
+        self.polled.contains_key(key) || self.asynchronous.contains_key(key)
+    }
+    fn insert(&mut self, key: Destination, flow: ManagedDatagramFlow) {
+        if flow.receiver.is_some() {
+            self.polled.insert(key, flow);
+        } else {
+            self.asynchronous.insert(key, flow);
+        }
+    }
+    fn remove(&mut self, key: &Destination) -> Option<ManagedDatagramFlow> {
+        self.polled
+            .remove(key)
+            .or_else(|| self.asynchronous.remove(key))
+    }
+    fn iter(&self) -> impl Iterator<Item = (&Destination, &ManagedDatagramFlow)> {
+        self.polled.iter().chain(self.asynchronous.iter())
+    }
+    fn drain(&mut self) -> impl Iterator<Item = (Destination, ManagedDatagramFlow)> {
+        self.polled.drain().chain(self.asynchronous.drain())
+    }
+    fn shrink(&mut self) {
+        for map in [&mut self.polled, &mut self.asynchronous] {
+            if map.capacity() > map.len().saturating_mul(4).max(8) {
+                map.shrink_to(map.len().saturating_mul(2));
+            }
+        }
+    }
+}
+
+struct ManagedDatagramFlow {
+    receiver: Option<ManagedReceive>,
+    transport: ManagedTransport,
+    connection: crate::connections::Connection,
+    destination: Destination,
+    restore: bool,
+    last_used: Instant,
+    flow_id: Option<Box<[u8]>>,
+}
+
+enum ManagedTransport {
+    Dedicated(Box<dyn DatagramTransport>),
+    Shared(usize),
+}
+
+struct ManagedSharedTransport {
+    // Keep the concrete node and its resource generation alive. Pointer
+    // equality alone would permit address reuse after a provider replacement.
+    dispatcher: Arc<dyn Dispatcher>,
+    transport: Box<dyn DatagramTransport>,
+    members: usize,
+    accepting: bool,
+}
+
+enum ManagedDatagramEvent {
+    Flow(Destination, Option<Result<Datagram, DispatchError>>),
+    Shared(usize, Result<Datagram, DispatchError>),
+}
+
+impl Drop for ManagedDatagramFlow {
+    fn drop(&mut self) {
+        if let Some(receiver) = &self.receiver {
+            receiver.wake.deactivate();
+        }
+    }
+}
+
 struct CachedRouteTransport {
+    leaf: ResolvedProxyGroupLeaf,
+    last_used: Instant,
     transport: Box<dyn DatagramTransport>,
     direct: bool,
 }
@@ -644,6 +1236,7 @@ enum LoggedRouteAction {
     Route(RouteTargetId),
     Direct,
     Reject,
+    RejectDrop,
 }
 
 impl From<RuleAction> for LoggedRouteAction {
@@ -652,11 +1245,546 @@ impl From<RuleAction> for LoggedRouteAction {
             RuleAction::Route(id) => Self::Route(id),
             RuleAction::Direct => Self::Direct,
             RuleAction::Reject => Self::Reject,
+            RuleAction::RejectDrop => Self::RejectDrop,
         }
     }
 }
 
 impl RoutedDatagramTransport {
+    fn tracked(&self) -> bool {
+        self.router.diagnostics.is_some() && business(self.session.inbound)
+    }
+
+    async fn remove_managed(&mut self, key: &Destination) -> Result<(), DispatchError> {
+        let Some(mut flow) = self.managed_flows.remove(key) else {
+            return Ok(());
+        };
+        if let Some(receiver) = &flow.receiver {
+            receiver.wake.deactivate();
+        }
+        match &mut flow.transport {
+            ManagedTransport::Dedicated(transport) => transport.close().await,
+            ManagedTransport::Shared(id) => {
+                let shared = self.managed_shared.get_mut(id).expect("shared flow owner");
+                // A later connection with this same destination must not receive
+                // a delayed reply from the old generation. Existing siblings
+                // keep this wire, but new destinations use a new association.
+                shared.accepting = false;
+                shared.members -= 1;
+                if shared.members == 0 {
+                    let mut shared = self.managed_shared.remove(id).expect("last shared owner");
+                    shared.transport.close().await?;
+                }
+                Ok(())
+            }
+        }
+    }
+
+    async fn fail_managed_shared(&mut self, id: usize, error: &DispatchError) {
+        let keys = self
+            .managed_flows
+            .iter()
+            .filter(|(_, flow)| matches!(flow.transport, ManagedTransport::Shared(owner) if owner == id))
+            .map(|(key, flow)| {
+                if !flow.connection.cancelled() {
+                    flow.connection.failed(error);
+                }
+                key.clone()
+            })
+            .collect::<Vec<_>>();
+        for key in keys {
+            let _ = self.remove_managed(&key).await;
+        }
+    }
+
+    async fn open_managed_transport(
+        &mut self,
+        dispatcher: Arc<dyn Dispatcher>,
+        connection: &crate::connections::Connection,
+        share: bool,
+    ) -> Result<ManagedTransport, DispatchError> {
+        if share
+            && let Some((&id, shared)) = self.managed_shared.iter_mut().find(|(_, shared)| {
+                shared.accepting && Arc::ptr_eq(&dispatcher, &shared.dispatcher)
+            })
+        {
+            shared.members += 1;
+            return Ok(ManagedTransport::Shared(id));
+        }
+        let token = connection.token();
+        let transport = tokio::select! {
+            biased;
+            () = token.cancelled() => return Err(DispatchError::NotAllowed),
+            result = dispatcher.open_datagram(self.session.clone()) => result?,
+        };
+        if share && transport.supports_shared_destinations() {
+            self.managed_shared_sequence = self
+                .managed_shared_sequence
+                .checked_add(1)
+                .ok_or(DispatchError::NotAllowed)?;
+            let id = self.managed_shared_sequence;
+            self.managed_shared.insert(
+                id,
+                ManagedSharedTransport {
+                    dispatcher,
+                    transport,
+                    members: 1,
+                    accepting: true,
+                },
+            );
+            Ok(ManagedTransport::Shared(id))
+        } else {
+            Ok(ManagedTransport::Dedicated(transport))
+        }
+    }
+
+    async fn clean_managed(&mut self) {
+        let now = Instant::now();
+        if now < self.managed_next_cleanup {
+            return;
+        }
+        self.managed_next_cleanup = now + UDP_FLOW_CLEANUP_INTERVAL;
+        let expired = self
+            .managed_flows
+            .iter()
+            .filter(|(_, flow)| {
+                flow.connection.cancelled()
+                    || flow.last_used.elapsed() >= self.router.tun_config.udp_timeout
+            })
+            .map(|(key, _)| key.clone())
+            .collect::<Vec<_>>();
+        for key in expired {
+            let _ = self.remove_managed(&key).await;
+        }
+        self.managed_flows.shrink();
+        if self.managed_shared.capacity() > self.managed_shared.len().saturating_mul(4).max(8) {
+            self.managed_shared
+                .shrink_to(self.managed_shared.len().saturating_mul(2));
+        }
+        self.managed_ready
+            .as_ref()
+            .expect("tracked receive queue")
+            .shrink();
+    }
+    async fn send_managed(&mut self, mut datagram: Datagram) -> Result<(), DispatchError> {
+        self.clean_managed().await;
+        let key = datagram.remote.clone();
+        if self.managed_flows.get(&key).is_some_and(|flow| {
+            flow.connection.cancelled()
+                || flow.last_used.elapsed() >= self.router.tun_config.udp_timeout
+        }) {
+            let _ = self.remove_managed(&key).await;
+        }
+        if !self.managed_flows.contains_key(&key) {
+            // Keep route setup state out of the future allocated for each cached send.
+            let mut decision = Box::pin(self.router.route(
+                Network::Udp,
+                (self.session.inbound, &self.session.metadata),
+                self.session.source,
+                &key,
+                datagram.sniffed_domain.as_deref(),
+                None,
+            ))
+            .await?;
+            if matches!(decision.action, RuleAction::Reject | RuleAction::RejectDrop) {
+                return Ok(());
+            }
+            let (dispatcher, direct, chain) = match decision.action {
+                RuleAction::Direct => (self.router.direct.clone(), true, Vec::new()),
+                RuleAction::Route(_) => {
+                    let leaf = decision
+                        .selected
+                        .take()
+                        .expect("accepted route owns its selected leaf")?;
+                    (leaf.dispatcher, leaf.direct, leaf.chain)
+                }
+                RuleAction::Reject | RuleAction::RejectDrop => unreachable!(),
+            };
+            if direct {
+                self.router
+                    .resolve_direct_destination(&mut decision)
+                    .await?;
+            }
+            let restore = matches!(key, Destination::Ip(_))
+                && (decision.dns_mode == "fake-ip"
+                    || (datagram.sniffed_domain.is_some()
+                        && self
+                            .router
+                            .sniffer
+                            .as_ref()
+                            .is_some_and(|p| p.config.quic_override)));
+            if restore && let Destination::Domain { host, port } = &decision.destination {
+                let dns = self
+                    .router
+                    .dns
+                    .as_ref()
+                    .ok_or(DispatchError::HostUnreachable)?;
+                let addresses = self.router.resolve_addresses(dns, host).await?;
+                decision.destination = Destination::Ip(SocketAddr::new(
+                    preferred_address(&addresses).ok_or(DispatchError::HostUnreachable)?,
+                    *port,
+                ));
+            }
+            let connection = self
+                .router
+                .connection(
+                    Network::Udp,
+                    self.session.inbound,
+                    self.session.source,
+                    &key,
+                    datagram.sniffed_domain.as_deref(),
+                    &decision,
+                    chain,
+                )
+                .expect("tracked business flow");
+            // Only identical IP addresses can be demultiplexed without a DNS
+            // alias table. Fake-IP, QUIC override and domain requests retain
+            // dedicated wires, including two names resolving to one endpoint.
+            let share =
+                !restore && matches!(key, Destination::Ip(_)) && key == decision.destination;
+            let result = self
+                .open_managed_transport(dispatcher, &connection, share)
+                .await;
+            connection.dns_path(crate::dns::trace::snapshot());
+            let transport = match result {
+                Ok(transport) => transport,
+                Err(error) => {
+                    if !connection.cancelled() {
+                        connection.failed(&error);
+                    }
+                    return Err(error);
+                }
+            };
+            let polled = match &transport {
+                ManagedTransport::Dedicated(transport) => transport.supports_poll_receive(),
+                ManagedTransport::Shared(_) => true, // readiness owns only logical cancellation
+            };
+            let receiver = polled.then(|| {
+                let wake = self
+                    .managed_ready
+                    .as_ref()
+                    .expect("tracked receive queue")
+                    .registration(key.clone());
+                wake.enqueue();
+                ManagedReceive {
+                    wake,
+                    cancelled: Box::pin(connection.token().cancelled_owned()),
+                }
+            });
+            self.managed_flows.insert(
+                key.clone(),
+                ManagedDatagramFlow {
+                    receiver,
+                    transport,
+                    connection,
+                    destination: decision.destination,
+                    restore,
+                    last_used: Instant::now(),
+                    flow_id: None,
+                },
+            );
+        }
+        let flow = self.managed_flows.get_mut(&key).expect("flow created");
+        flow.last_used = Instant::now();
+        let size = datagram.payload.len();
+        datagram.remote = flow.destination.clone();
+        datagram.sniffed_domain = None;
+        let token = flow.connection.token();
+        let (transport, shared_id) = match &mut flow.transport {
+            ManagedTransport::Dedicated(transport) => (transport, None),
+            ManagedTransport::Shared(id) => (
+                &mut self
+                    .managed_shared
+                    .get_mut(id)
+                    .expect("shared flow owner")
+                    .transport,
+                Some(*id),
+            ),
+        };
+        let result = tokio::select! { biased; () = token.cancelled() => Err(DispatchError::NotAllowed), result = transport.send(datagram) => result };
+        match &result {
+            Ok(()) => flow.connection.upload(size),
+            Err(error) => {
+                if shared_id.is_none() && !flow.connection.cancelled() {
+                    flow.connection.failed(error);
+                }
+                if let Some(id) = shared_id
+                    && !token.is_cancelled()
+                {
+                    self.fail_managed_shared(id, error).await;
+                } else {
+                    let _ = self.remove_managed(&key).await;
+                }
+            }
+        }
+        result
+    }
+    fn poll_managed(
+        flows: &mut HashMap<Destination, ManagedDatagramFlow>,
+        ready: &ReadyQueue,
+        scratch: &mut Vec<u8>,
+        idle_timeout: Duration,
+        context: &mut Context<'_>,
+    ) -> Poll<(Destination, Option<Result<Datagram, DispatchError>>)> {
+        ready.register(context.waker());
+        for _ in 0..crate::limits::IO_POLL_BUDGET {
+            let Some(wake) = ready.pop() else {
+                return Poll::Pending;
+            };
+            let Some(flow) = flows.get_mut(wake.key()) else {
+                continue;
+            };
+            let receiver = flow.receiver.as_mut().expect("polled receiver");
+            if !Arc::ptr_eq(&receiver.wake, &wake) {
+                continue;
+            }
+            let waker = futures_util::task::waker_ref(&wake);
+            let mut flow_context = Context::from_waker(&waker);
+            if receiver
+                .cancelled
+                .as_mut()
+                .poll(&mut flow_context)
+                .is_ready()
+                || flow.last_used.elapsed() >= idle_timeout
+            {
+                return Poll::Ready((wake.key().clone(), None));
+            }
+            let ManagedTransport::Dedicated(transport) = &mut flow.transport else {
+                continue;
+            };
+            match transport.poll_receive(&mut flow_context, scratch) {
+                Poll::Pending => {}
+                Poll::Ready(Ok(mut datagram)) => {
+                    wake.requeue();
+                    if flow.restore {
+                        if datagram.remote != flow.destination {
+                            continue;
+                        }
+                        datagram.remote = wake.key().clone();
+                    }
+                    flow.connection.download(datagram.payload.len());
+                    flow.last_used = Instant::now();
+                    return Poll::Ready((wake.key().clone(), Some(Ok(datagram))));
+                }
+                Poll::Ready(Err(error)) => {
+                    return Poll::Ready((wake.key().clone(), Some(Err(error))));
+                }
+            }
+        }
+        if !ready.is_empty() {
+            context.waker().wake_by_ref();
+        }
+        Poll::Pending
+    }
+
+    async fn receive_managed_shared(
+        transports: &mut HashMap<usize, ManagedSharedTransport>,
+    ) -> (usize, Result<Datagram, DispatchError>) {
+        if transports.is_empty() {
+            return std::future::pending().await;
+        }
+        if transports.len() == 1 {
+            let (&id, shared) = transports.iter_mut().next().expect("one shared transport");
+            return (id, shared.transport.receive().await);
+        }
+        let receives = transports
+            .iter_mut()
+            .map(|(&id, shared)| {
+                Box::pin(async move { (id, shared.transport.receive().await) })
+                    as futures_util::future::BoxFuture<'_, _>
+            })
+            .collect::<Vec<_>>();
+        select_all(receives).await.0
+    }
+
+    async fn receive_managed(&mut self) -> Result<Datagram, DispatchError> {
+        loop {
+            self.clean_managed().await;
+            let idle_timeout = self.router.tun_config.udp_timeout;
+            let result = {
+                let polled = std::future::poll_fn(|context| {
+                    Self::poll_managed(
+                        &mut self.managed_flows.polled,
+                        self.managed_ready.as_ref().expect("tracked receive queue"),
+                        &mut self.managed_receive_buffer,
+                        idle_timeout,
+                        context,
+                    )
+                });
+                let asynchronous = async {
+                    if self.managed_flows.asynchronous.is_empty() {
+                        std::future::pending::<()>().await;
+                    }
+                    let receives = self.managed_flows.asynchronous.iter_mut().map(|(key, flow)| Box::pin(async move {
+                        let token = flow.connection.token();
+                        loop {
+                            if flow.last_used.elapsed() >= idle_timeout {
+                                return (key.clone(), None);
+                            }
+                            let ManagedTransport::Dedicated(transport) = &mut flow.transport else {
+                                unreachable!("shared logical flows use cancellation readiness");
+                            };
+                            let result = tokio::select! { biased; () = token.cancelled() => None, result = transport.receive() => Some(result) };
+                            if let Some(Ok(mut datagram)) = result {
+                                if flow.last_used.elapsed() >= idle_timeout {
+                                    return (key.clone(), None);
+                                }
+                                if flow.restore {
+                                    if datagram.remote != flow.destination { continue; }
+                                    datagram.remote = key.clone();
+                                }
+                                flow.connection.download(datagram.payload.len());
+                                flow.last_used = Instant::now();
+                                return (key.clone(), Some(Ok(datagram)));
+                            }
+                            return (key.clone(), result);
+                        }
+                    }) as futures_util::future::BoxFuture<'_, _>).collect::<Vec<_>>();
+                    select_all(receives).await.0
+                };
+                let shared = Self::receive_managed_shared(&mut self.managed_shared);
+                tokio::select! {
+                    (key, result) = polled => Some(ManagedDatagramEvent::Flow(key, result)),
+                    (key, result) = asynchronous => Some(ManagedDatagramEvent::Flow(key, result)),
+                    (id, result) = shared => Some(ManagedDatagramEvent::Shared(id, result)),
+                    () = tokio::time::sleep_until(self.managed_next_cleanup) => None,
+                }
+            };
+            match result {
+                Some(ManagedDatagramEvent::Flow(_, Some(Ok(datagram)))) => {
+                    return Ok(datagram);
+                }
+                Some(ManagedDatagramEvent::Flow(key, result)) => {
+                    if let Some(Err(error)) = result
+                        && let Some(flow) = self.managed_flows.get(&key)
+                    {
+                        flow.connection.failed(&error);
+                    }
+                    let _ = self.remove_managed(&key).await;
+                }
+                Some(ManagedDatagramEvent::Shared(id, Ok(datagram))) => {
+                    let key = &datagram.remote;
+                    if let Some(flow) = self.managed_flows.get_mut(key)
+                        && matches!(flow.transport, ManagedTransport::Shared(owner) if owner == id)
+                    {
+                        if flow.connection.cancelled() || flow.last_used.elapsed() >= idle_timeout {
+                            let _ = self.remove_managed(key).await;
+                        } else {
+                            flow.connection.download(datagram.payload.len());
+                            flow.last_used = Instant::now();
+                            return Ok(datagram);
+                        }
+                    }
+                }
+                Some(ManagedDatagramEvent::Shared(id, Err(error))) => {
+                    self.fail_managed_shared(id, &error).await
+                }
+                None => {}
+            }
+            tokio::task::consume_budget().await;
+        }
+    }
+
+    async fn expire_fake_flows(&mut self) {
+        let expired = self
+            .route_transports
+            .iter()
+            .filter(|((_, destination), cached)| {
+                destination.is_some()
+                    && cached.last_used.elapsed() >= self.router.tun_config.udp_timeout
+            })
+            .map(|(key, _)| key.clone())
+            .collect::<Vec<_>>();
+        for key in expired {
+            if let Some(mut cached) = self.route_transports.remove(&key) {
+                let _ = cached.transport.close().await;
+            }
+        }
+
+        let now = Instant::now();
+        let expired: Vec<_> = self
+            .fake_flows
+            .iter()
+            .filter_map(|(key, flow)| {
+                (now.duration_since(flow.last_used) >= self.router.tun_config.udp_timeout)
+                    .then_some(*key)
+            })
+            .collect();
+        for key in expired {
+            if let Some(mut flow) = self.fake_flows.remove(&key) {
+                let _ = flow.transport.close().await;
+            }
+        }
+    }
+
+    async fn send_fake(
+        &mut self,
+        original: SocketAddr,
+        mut datagram: Datagram,
+    ) -> Result<(), DispatchError> {
+        if !self.fake_flows.contains_key(&original) {
+            let mut decision = Box::pin(self.router.route(
+                Network::Udp,
+                (self.session.inbound, &self.session.metadata),
+                self.session.source,
+                &datagram.remote,
+                datagram.sniffed_domain.as_deref(),
+                None,
+            ))
+            .await?;
+            let (dispatcher, direct) = match decision.action {
+                RuleAction::Reject | RuleAction::RejectDrop => return Ok(()),
+                RuleAction::Direct => (self.router.direct.clone(), true),
+                RuleAction::Route(_) => {
+                    let target = decision
+                        .selected
+                        .take()
+                        .expect("accepted route owns its selected leaf")?;
+                    (target.dispatcher, target.direct)
+                }
+            };
+            if direct {
+                self.router
+                    .resolve_direct_destination(&mut decision)
+                    .await?;
+            }
+            let remote = match decision.destination {
+                Destination::Ip(address) => address,
+                Destination::Domain { host, port } => {
+                    let dns = self
+                        .router
+                        .dns
+                        .as_ref()
+                        .ok_or(DispatchError::HostUnreachable)?;
+                    let addresses = self.router.resolve_addresses(dns, &host).await?;
+                    SocketAddr::new(
+                        preferred_address(&addresses).ok_or(DispatchError::HostUnreachable)?,
+                        port,
+                    )
+                }
+            };
+            let transport = dispatcher.open_datagram(self.session.clone()).await?;
+            self.fake_flows.insert(
+                original,
+                FakeDatagramFlow {
+                    transport,
+                    remote,
+                    last_used: Instant::now(),
+                    flow_id: None,
+                },
+            );
+            self.receive_wakeup.notify_one();
+        }
+        let flow = self
+            .fake_flows
+            .get_mut(&original)
+            .expect("fake-IP flow inserted");
+        datagram.remote = Destination::Ip(flow.remote);
+        datagram.sniffed_domain = None;
+        flow.last_used = Instant::now();
+        flow.transport.send(datagram).await
+    }
+
     fn should_log_route_action(&mut self, action: RuleAction) -> bool {
         self.logged_route_actions.insert(action.into())
     }
@@ -667,11 +1795,27 @@ impl RoutedDatagramTransport {
         mut decision: RouteDecision,
         mut datagram: Datagram,
     ) -> Result<(), DispatchError> {
-        let direct = self.route_transports.get(&id).map(|cached| cached.direct);
+        let key = (
+            id,
+            self.router
+                .route_targets
+                .per_flow(id)
+                .then(|| datagram.remote.clone()),
+        );
+        let direct = self.route_transports.get(&key).map(|cached| cached.direct);
         let direct = match direct {
             Some(direct) => direct,
             None => {
-                let target = self.router.route_targets.resolve(id)?;
+                let target = match decision.selected.take() {
+                    Some(target) => target?,
+                    None => self.router.route_targets.resolve_for(
+                        id,
+                        true,
+                        Some(self.session.source),
+                        Some(&decision.metadata),
+                        self.session.metadata.user.as_deref(),
+                    )?,
+                };
                 let direct = target.direct;
                 if direct {
                     self.router
@@ -682,8 +1826,15 @@ impl RoutedDatagramTransport {
                     .dispatcher
                     .open_datagram(self.session.clone())
                     .await?;
-                self.route_transports
-                    .insert(id, CachedRouteTransport { transport, direct });
+                self.route_transports.insert(
+                    key.clone(),
+                    CachedRouteTransport {
+                        transport,
+                        direct,
+                        leaf: target,
+                        last_used: Instant::now(),
+                    },
+                );
                 self.receive_wakeup.notify_one();
                 direct
             }
@@ -695,12 +1846,12 @@ impl RoutedDatagramTransport {
         }
         datagram.remote = decision.destination;
         datagram.sniffed_domain = None;
-        self.route_transports
-            .get_mut(&id)
-            .expect("route transport was inserted")
-            .transport
-            .send(datagram)
-            .await
+        let cached = self
+            .route_transports
+            .get_mut(&key)
+            .expect("route transport was inserted");
+        cached.last_used = Instant::now();
+        cached.transport.send(datagram).await
     }
 
     async fn send_direct(&mut self, datagram: Datagram) -> Result<(), DispatchError> {
@@ -725,28 +1876,56 @@ impl RoutedDatagramTransport {
             // Only send/close can change these caches, and they also require
             // &mut self. The sole backend cannot change during this receive;
             // cancellation releases the borrow before another route is opened.
-            if self.route_transports.is_empty() {
+            if self.fake_flows.is_empty() && self.route_transports.is_empty() {
                 if let Some(direct) = self.direct_transport.as_mut() {
                     return direct.receive().await;
                 }
-            } else if self.route_transports.len() == 1 && self.direct_transport.is_none() {
-                return self
+            } else if self.fake_flows.is_empty()
+                && self.route_transports.len() == 1
+                && self.direct_transport.is_none()
+            {
+                let cached = self
                     .route_transports
                     .values_mut()
                     .next()
-                    .expect("the only route transport exists")
-                    .transport
-                    .receive()
-                    .await;
+                    .expect("the only route transport exists");
+                let result = cached.transport.receive().await;
+                if result.is_ok() {
+                    cached.last_used = Instant::now();
+                }
+                return result;
             }
-            let mut receives = self
+            let mut receives: Vec<
+                futures_util::future::BoxFuture<'_, Result<Datagram, DispatchError>>,
+            > = self
                 .route_transports
                 .values_mut()
-                .map(|cached| cached.transport.receive())
+                .map(|cached| {
+                    Box::pin(async move {
+                        let result = cached.transport.receive().await;
+                        if result.is_ok() {
+                            cached.last_used = Instant::now();
+                        }
+                        result
+                    }) as futures_util::future::BoxFuture<'_, _>
+                })
                 .collect::<Vec<_>>();
             if let Some(direct) = self.direct_transport.as_mut() {
                 receives.push(direct.receive());
             }
+            for (original, flow) in &mut self.fake_flows {
+                receives.push(Box::pin(async move {
+                    loop {
+                        let mut response = flow.transport.receive().await?;
+                        if response.remote != Destination::Ip(flow.remote) {
+                            continue;
+                        }
+                        response.remote = Destination::Ip(*original);
+                        flow.last_used = Instant::now();
+                        return Ok(response);
+                    }
+                }));
+            }
             if receives.is_empty() {
                 self.receive_wakeup.notified().await;
                 continue;
@@ -761,7 +1940,38 @@ impl RoutedDatagramTransport {
 
 #[async_trait]
 impl DatagramTransport for RoutedDatagramTransport {
+    fn supports_shared_destinations(&self) -> bool {
+        // Owns routing and address restoration; it is not a transparent codec.
+        false
+    }
+
     async fn send(&mut self, mut datagram: Datagram) -> Result<(), DispatchError> {
+        if self.tracked() {
+            return crate::dns::trace::capture(self.send_managed(datagram))
+                .await
+                .0;
+        }
+        self.expire_fake_flows().await;
+        if matches!(self.session.inbound, InboundKind::Tun | InboundKind::Socks5)
+            && let Destination::Ip(original) = datagram.remote
+            && (self.fake_flows.contains_key(&original)
+                || self
+                    .router
+                    .dns
+                    .as_ref()
+                    .map(|dns| dns.recover_fake_ip(original.ip()))
+                    .transpose()?
+                    .flatten()
+                    .is_some()
+                || (datagram.sniffed_domain.is_some()
+                    && self
+                        .router
+                        .sniffer
+                        .as_ref()
+                        .is_some_and(|policy| policy.config.quic_override)))
+        {
+            return self.send_fake(original, datagram).await;
+        }
         let now = Instant::now();
         if self.session.inbound == InboundKind::Tun {
             self.flows.expire(now);
@@ -773,20 +1983,26 @@ impl DatagramTransport for RoutedDatagramTransport {
         let action = flow.and_then(|destination| self.flows.action(destination, now));
         let decision = if let Some(action) = action {
             RouteDecision {
+                original: None,
+                process: Default::default(),
+                rule_index: self.router.rules.len(),
+                dns_mode: "normal",
+                metadata: datagram.remote.clone(),
                 action,
                 destination: datagram.remote.clone(),
                 resolved_addresses: None,
+                selected: None,
             }
         } else {
-            let decision = self
-                .router
-                .route(
-                    Network::Udp,
-                    self.session.inbound,
-                    &datagram.remote,
-                    datagram.sniffed_domain.as_deref(),
-                )
-                .await?;
+            let decision = Box::pin(self.router.route(
+                Network::Udp,
+                (self.session.inbound, &self.session.metadata),
+                self.session.source,
+                &datagram.remote,
+                datagram.sniffed_domain.as_deref(),
+                Some(&mut self.route_transports),
+            ))
+            .await?;
             if let Some(destination) = flow {
                 self.flows.entries.insert(
                     destination,
@@ -811,7 +2027,7 @@ impl DatagramTransport for RoutedDatagramTransport {
             }
             // UDP REJECT applies only to this datagram. The association stays
             // alive so a later destination can select another action.
-            RuleAction::Reject => Ok(()),
+            RuleAction::Reject | RuleAction::RejectDrop => Ok(()),
         }
     }
 
@@ -823,6 +2039,21 @@ impl DatagramTransport for RoutedDatagramTransport {
         if flow_id.is_empty() || flow_id.len() > 25 {
             return Err(DispatchError::NotAllowed);
         }
+        if self.tracked() {
+            let key = datagram.remote.clone();
+            if self
+                .managed_flows
+                .get(&key)
+                .is_some_and(|flow| flow.flow_id.as_deref() != Some(flow_id))
+            {
+                self.remove_managed(&key).await?;
+            }
+            self.send(datagram).await?;
+            if let Some(flow) = self.managed_flows.get_mut(&key) {
+                flow.flow_id = Some(flow_id.into());
+            }
+            return Ok(());
+        }
         let flow = match (self.session.inbound, &datagram.remote) {
             (InboundKind::Tun, Destination::Ip(address)) => Some(*address),
             _ => None,
@@ -836,9 +2067,34 @@ impl DatagramTransport for RoutedDatagramTransport {
                 .is_some_and(|route| route.flow_id.as_deref() != Some(flow_id))
             {
                 self.flows.entries.remove(&destination);
+                let keys = self
+                    .route_transports
+                    .keys()
+                    .filter(|(_, target)| target.as_ref() == Some(&Destination::Ip(destination)))
+                    .cloned()
+                    .collect::<Vec<_>>();
+                for key in keys {
+                    if let Some(mut cached) = self.route_transports.remove(&key) {
+                        cached.transport.close().await?;
+                    }
+                }
             }
         }
+        if let Some(destination) = flow
+            && self
+                .fake_flows
+                .get(&destination)
+                .is_some_and(|flow| flow.flow_id.as_deref() != Some(flow_id))
+            && let Some(mut old) = self.fake_flows.remove(&destination)
+        {
+            old.transport.close().await?;
+        }
         self.send(datagram).await?;
+        if let Some(destination) = flow
+            && let Some(flow) = self.fake_flows.get_mut(&destination)
+        {
+            flow.flow_id = Some(flow_id.into());
+        }
         if let Some(destination) = flow
             && let Some(route) = self.flows.entries.get_mut(&destination)
             && route.flow_id.as_deref() != Some(flow_id)
@@ -849,7 +2105,16 @@ impl DatagramTransport for RoutedDatagramTransport {
     }
 
     async fn receive(&mut self) -> Result<Datagram, DispatchError> {
-        let datagram = self.receive_inner().await?;
+        if self.tracked() {
+            return self.receive_managed().await;
+        }
+        let datagram = loop {
+            self.expire_fake_flows().await;
+            tokio::select! {
+                result = self.receive_inner() => break result?,
+                () = tokio::time::sleep(UDP_FLOW_CLEANUP_INTERVAL) => {},
+            }
+        };
         if self.session.inbound == InboundKind::Tun {
             let now = Instant::now();
             self.flows.expire(now);
@@ -862,6 +2127,29 @@ impl DatagramTransport for RoutedDatagramTransport {
 
     async fn close(&mut self) -> Result<(), DispatchError> {
         let mut first_error = None;
+        for (_, mut flow) in self.managed_flows.drain() {
+            if let ManagedTransport::Dedicated(transport) = &mut flow.transport
+                && let Err(error) = transport.close().await
+                && first_error.is_none()
+            {
+                first_error = Some(error);
+            }
+        }
+        for (_, mut shared) in self.managed_shared.drain() {
+            if let Err(error) = shared.transport.close().await
+                && first_error.is_none()
+            {
+                first_error = Some(error);
+            }
+        }
+        for flow in self.fake_flows.values_mut() {
+            if let Err(error) = flow.transport.close().await
+                && first_error.is_none()
+            {
+                first_error = Some(error);
+            }
+        }
+        self.fake_flows.clear();
         for route in self.route_transports.values_mut() {
             if let Err(error) = route.transport.close().await
                 && first_error.is_none()
@@ -896,6 +2184,7 @@ mod tests {
             atomic::{AtomicBool, AtomicUsize, Ordering},
         },
     };
+    use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};
 
     use super::*;
     use crate::{
@@ -910,6 +2199,11 @@ mod tests {
 
     #[derive(Default)]
     struct RecordingDispatcher {
+        tcp_only: bool,
+        pollable: bool,
+        shareable: bool,
+        receive_polls: Arc<AtomicUsize>,
+        udp_closes: Arc<AtomicUsize>,
         tcp_sessions: Mutex<Vec<StreamSession>>,
         datagrams: Arc<Mutex<Vec<Datagram>>>,
         udp_opens: AtomicUsize,
@@ -917,6 +2211,10 @@ mod tests {
 
     #[async_trait]
     impl Dispatcher for RecordingDispatcher {
+        fn supports_udp(&self) -> bool {
+            !self.tcp_only
+        }
+
         async fn connect_tcp(&self, session: StreamSession) -> Result<BoxStream, DispatchError> {
             self.tcp_sessions.lock().unwrap().push(session);
             let (client, _server) = tokio::io::duplex(64);
@@ -931,6 +2229,11 @@ mod tests {
             Ok(Box::new(RecordingDatagrams {
                 sent: self.datagrams.clone(),
                 responses: VecDeque::new(),
+                pollable: self.pollable,
+                shareable: self.shareable,
+                receive_polls: self.receive_polls.clone(),
+                closes: self.udp_closes.clone(),
+                receive_waker: None,
             }))
         }
     }
@@ -938,13 +2241,45 @@ mod tests {
     struct RecordingDatagrams {
         sent: Arc<Mutex<Vec<Datagram>>>,
         responses: VecDeque<Datagram>,
+        pollable: bool,
+        shareable: bool,
+        receive_polls: Arc<AtomicUsize>,
+        closes: Arc<AtomicUsize>,
+        receive_waker: Option<std::task::Waker>,
     }
 
     #[async_trait]
     impl DatagramTransport for RecordingDatagrams {
+        fn supports_shared_destinations(&self) -> bool {
+            self.shareable
+        }
+
+        fn supports_poll_receive(&self) -> bool {
+            self.pollable
+        }
+        fn poll_receive(
+            &mut self,
+            context: &mut Context<'_>,
+            _scratch: &mut Vec<u8>,
+        ) -> Poll<Result<Datagram, DispatchError>> {
+            self.receive_polls.fetch_add(1, Ordering::Relaxed);
+            self.receive_waker = Some(context.waker().clone());
+            match self.responses.pop_front() {
+                Some(response) => Poll::Ready(Ok(response)),
+                None => Poll::Pending,
+            }
+        }
+        async fn close(&mut self) -> Result<(), DispatchError> {
+            self.closes.fetch_add(1, Ordering::Relaxed);
+            self.receive_waker = None;
+            Ok(())
+        }
         async fn send(&mut self, datagram: Datagram) -> Result<(), DispatchError> {
             self.sent.lock().unwrap().push(datagram.clone());
             self.responses.push_back(datagram);
+            if let Some(waker) = &self.receive_waker {
+                waker.wake_by_ref();
+            }
             Ok(())
         }
 
@@ -1100,6 +2435,15 @@ mod tests {
         members: Vec<(&str, ProxyGroupMemberTarget)>,
     ) -> SelectProxyGroupConfig {
         SelectProxyGroupConfig {
+            kind: crate::config::GroupKind::Select,
+            strategy: crate::config::BalanceStrategy::default(),
+            hash_key: crate::config::BalanceHashKey::default(),
+            health: crate::config::HealthCheckConfig::default(),
+            tolerance: 0,
+            max_failed_times: 5,
+            disable_udp: false,
+            hidden: false,
+            icon: String::new(),
             name: name.to_owned(),
             members: members
                 .into_iter()
@@ -1138,25 +2482,1055 @@ mod tests {
         )
     }
 
-    fn dispatcher_with_proxies(
-        proxies: Vec<Arc<RecordingDispatcher>>,
-        direct: Arc<RecordingDispatcher>,
-        rules: Vec<RuleSpec>,
-    ) -> RoutingDispatcher {
-        let proxies = ProxyDispatchers::new(
-            proxies
-                .into_iter()
-                .map(|proxy| proxy as Arc<dyn Dispatcher>)
-                .collect(),
+    fn dispatcher_with_proxies(
+        proxies: Vec<Arc<RecordingDispatcher>>,
+        direct: Arc<RecordingDispatcher>,
+        rules: Vec<RuleSpec>,
+    ) -> RoutingDispatcher {
+        let proxies = ProxyDispatchers::new(
+            proxies
+                .into_iter()
+                .map(|proxy| proxy as Arc<dyn Dispatcher>)
+                .collect(),
+        )
+        .unwrap();
+        RoutingDispatcher::new(
+            proxies,
+            direct,
+            None,
+            RuleSet::compile(rules).unwrap(),
+            Arc::new(EmptyGeoMatcher),
+        )
+    }
+
+    #[derive(Default)]
+    struct ManagedWakeCount(AtomicUsize);
+    impl futures_util::task::ArcWake for ManagedWakeCount {
+        fn wake_by_ref(owner: &Arc<Self>) {
+            owner.0.fetch_add(1, Ordering::Relaxed);
+        }
+    }
+
+    fn managed_wake_fixture() -> (
+        RoutedDatagramTransport,
+        Arc<RecordingDispatcher>,
+        Arc<crate::connections::Registry>,
+    ) {
+        let config =
+            crate::config::Config::parse_yaml(b"mixed-port: 1080\nrules: [\"MATCH,DIRECT\"]\n")
+                .unwrap();
+        let direct = Arc::new(RecordingDispatcher {
+            pollable: true,
+            ..Default::default()
+        });
+        let rules = RuleSet::compile(config.rules.clone()).unwrap();
+        let registry = Arc::new(crate::connections::Registry::default());
+        let diagnostics = Arc::new(crate::routing::diagnostics::Diagnostics::new(
+            &config,
+            &rules,
+            registry.clone(),
+        ));
+        let router = RoutingDispatcher::new(
+            ProxyDispatchers::new(Vec::new()).unwrap(),
+            direct.clone(),
+            None,
+            rules,
+            Arc::new(EmptyGeoMatcher),
+        )
+        .with_diagnostics(diagnostics);
+        (
+            router.routed_datagrams(association(InboundKind::Socks5)),
+            direct,
+            registry,
+        )
+    }
+
+    fn poll_managed_test(
+        transport: &mut RoutedDatagramTransport,
+        cx: &mut Context<'_>,
+    ) -> Poll<(Destination, Option<Result<Datagram, DispatchError>>)> {
+        RoutedDatagramTransport::poll_managed(
+            &mut transport.managed_flows.polled,
+            transport.managed_ready.as_ref().unwrap(),
+            &mut transport.managed_receive_buffer,
+            transport.router.tun_config.udp_timeout,
+            cx,
+        )
+    }
+
+    #[tokio::test]
+    async fn managed_udp_ready_delivery_requeues_without_notifying_its_running_parent() {
+        let (mut transport, direct, registry) = managed_wake_fixture();
+        let endpoint = "198.51.100.1:443".parse().unwrap();
+        transport.send(datagram(endpoint, b"first")).await.unwrap();
+        transport.send(datagram(endpoint, b"second")).await.unwrap();
+        let counter = Arc::new(ManagedWakeCount::default());
+        let parent = futures_util::task::waker(counter.clone());
+        let mut cx = Context::from_waker(&parent);
+        let first = poll_managed_test(&mut transport, &mut cx);
+        let second = poll_managed_test(&mut transport, &mut cx);
+        let notified = counter.0.load(Ordering::Relaxed);
+        let still_queued = !transport.managed_ready.as_ref().unwrap().is_empty();
+        transport.close().await.unwrap();
+        assert!(
+            matches!(first, Poll::Ready((Destination::Ip(remote), Some(Ok(ref value)))) if remote == endpoint && value.payload == Bytes::from_static(b"first"))
+        );
+        assert!(
+            matches!(second, Poll::Ready((Destination::Ip(remote), Some(Ok(ref value)))) if remote == endpoint && value.payload == Bytes::from_static(b"second"))
+        );
+        assert_eq!(
+            notified, 0,
+            "local FIFO requeue scheduled its running parent"
+        );
+        assert!(still_queued, "ready flow lost its next receive opportunity");
+        assert!(transport.managed_ready.as_ref().unwrap().is_empty());
+        assert_eq!(transport.managed_flows.iter().count(), 0);
+        assert_eq!(direct.udp_closes.load(Ordering::Relaxed), 1);
+        assert!(
+            serde_json::to_value(registry.snapshot()).unwrap()["connections"]
+                .as_array()
+                .unwrap()
+                .is_empty()
+        );
+    }
+
+    #[tokio::test]
+    async fn managed_udp_pending_receive_and_controller_cancel_keep_external_wakes() {
+        let (mut transport, direct, registry) = managed_wake_fixture();
+        let endpoint = "198.51.100.1:443".parse().unwrap();
+        transport.send(datagram(endpoint, b"first")).await.unwrap();
+        let counter = Arc::new(ManagedWakeCount::default());
+        let parent = futures_util::task::waker(counter.clone());
+        let mut cx = Context::from_waker(&parent);
+        let first = poll_managed_test(&mut transport, &mut cx);
+        let idle = poll_managed_test(&mut transport, &mut cx);
+        counter.0.store(0, Ordering::Relaxed);
+        transport
+            .send(datagram(endpoint, b"external"))
+            .await
+            .unwrap();
+        let ready_wakes = counter.0.load(Ordering::Relaxed);
+        let delivered = poll_managed_test(&mut transport, &mut cx);
+        let cancel_pending = poll_managed_test(&mut transport, &mut cx);
+        let snapshot = serde_json::to_value(registry.snapshot()).unwrap();
+        let id = snapshot["connections"][0]["id"].as_str().unwrap();
+        counter.0.store(0, Ordering::Relaxed);
+        registry.close(id);
+        let cancel_wakes = counter.0.load(Ordering::Relaxed);
+        let cancelled = poll_managed_test(&mut transport, &mut cx);
+        transport.close().await.unwrap();
+        assert!(matches!(first, Poll::Ready((_, Some(Ok(_))))));
+        assert!(idle.is_pending());
+        assert!(
+            ready_wakes > 0,
+            "actual Pending lost the external receive wake"
+        );
+        assert!(
+            matches!(delivered, Poll::Ready((Destination::Ip(remote), Some(Ok(ref value)))) if remote == endpoint && value.payload == Bytes::from_static(b"external"))
+        );
+        assert!(cancel_pending.is_pending());
+        assert!(
+            cancel_wakes > 0,
+            "Controller close did not wake Pending receive"
+        );
+        assert!(
+            matches!(cancelled, Poll::Ready((Destination::Ip(remote), None)) if remote == endpoint)
+        );
+        assert!(transport.managed_ready.as_ref().unwrap().is_empty());
+        assert_eq!(transport.managed_flows.iter().count(), 0);
+        assert_eq!(direct.udp_closes.load(Ordering::Relaxed), 1);
+        assert!(
+            serde_json::to_value(registry.snapshot()).unwrap()["connections"]
+                .as_array()
+                .unwrap()
+                .is_empty()
+        );
+    }
+
+    #[tokio::test]
+    async fn managed_udp_connections_close_one_flow_and_preserve_others() {
+        let config = crate::config::Config::parse_yaml(
+            br#"
+mixed-port: 1080
+proxies:
+  - {name: edge, type: socks5, server: 192.0.2.1, port: 1080, udp: true}
+  - {name: other, type: socks5, server: 192.0.2.2, port: 1080, udp: true}
+proxy-groups: [{name: pool, type: select, proxies: [edge, other]}]
+rules: ["MATCH,pool"]
+"#,
+        )
+        .unwrap();
+        let proxy = Arc::new(RecordingDispatcher {
+            shareable: true,
+            ..Default::default()
+        });
+        let other = Arc::new(RecordingDispatcher {
+            shareable: true,
+            ..Default::default()
+        });
+        let direct = Arc::new(RecordingDispatcher::default());
+        let nodes = vec![proxy.clone() as Arc<dyn Dispatcher>, other.clone()];
+        let groups = ProxyGroups::new(&config.proxy_groups, nodes.clone(), direct.clone()).unwrap();
+        let rules = RuleSet::compile(config.rules.clone()).unwrap();
+        let registry = Arc::new(crate::connections::Registry::default());
+        let diagnostics = Arc::new(crate::routing::diagnostics::Diagnostics::new(
+            &config,
+            &rules,
+            registry.clone(),
+        ));
+        let router = RoutingDispatcher::new(
+            ProxyDispatchers::with_proxy_groups(nodes, &groups).unwrap(),
+            direct,
+            None,
+            rules,
+            Arc::new(EmptyGeoMatcher),
+        )
+        .with_diagnostics(diagnostics);
+        let mut transport = router
+            .open_datagram(association(InboundKind::Socks5))
+            .await
+            .unwrap();
+        let first = "198.51.100.1:443".parse().unwrap();
+        let second = "198.51.100.2:443".parse().unwrap();
+        transport
+            .send(datagram(first, b"stale-original"))
+            .await
+            .unwrap();
+        transport.send(datagram(second, b"two")).await.unwrap();
+        assert_eq!(proxy.udp_opens.load(Ordering::Relaxed), 1);
+        let snapshot = serde_json::to_value(registry.snapshot()).unwrap();
+        let entries = snapshot["connections"].as_array().unwrap();
+        assert_eq!(entries.len(), 2);
+        let entry = entries
+            .iter()
+            .find(|e| e["metadata"]["destinationIP"] == "198.51.100.1")
+            .unwrap();
+        assert_eq!(entry["chains"], serde_json::json!(["edge", "pool"]));
+        assert_eq!(entry["rule"], "Match");
+        registry.close(entry["id"].as_str().unwrap());
+        groups.select("pool", "other").unwrap();
+        // Recreate before reading: the old wire still has a reply for the same
+        // tuple, which must not be delivered or counted on the new connection.
+        transport.send(datagram(first, b"new")).await.unwrap();
+        let mut replies = HashMap::new();
+        for _ in 0..2 {
+            let reply = transport.receive().await.unwrap();
+            replies.insert(reply.remote, reply.payload);
+        }
+        assert_eq!(
+            replies.get(&Destination::Ip(first)).unwrap().as_ref(),
+            b"new"
+        );
+        assert_eq!(
+            replies.get(&Destination::Ip(second)).unwrap().as_ref(),
+            b"two"
+        );
+        assert_eq!(
+            serde_json::to_value(registry.snapshot()).unwrap()["connections"]
+                .as_array()
+                .unwrap()
+                .len(),
+            2
+        );
+        let third = "198.51.100.3:443".parse().unwrap();
+        transport.send(datagram(third, b"third")).await.unwrap();
+        transport.send(datagram(second, b"pinned")).await.unwrap();
+        assert_eq!(proxy.udp_opens.load(Ordering::Relaxed), 1);
+        assert_eq!(other.udp_opens.load(Ordering::Relaxed), 1);
+        groups.select("pool", "edge").unwrap();
+        transport
+            .send(datagram("198.51.100.4:443".parse().unwrap(), b"fourth"))
+            .await
+            .unwrap();
+        assert_eq!(
+            proxy.udp_opens.load(Ordering::Relaxed),
+            2,
+            "retired wires must reject new destinations"
+        );
+        let snapshot = serde_json::to_value(registry.snapshot()).unwrap();
+        let first_entry = snapshot["connections"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .find(|entry| entry["metadata"]["destinationIP"] == "198.51.100.1")
+            .unwrap();
+        assert_eq!(first_entry["download"], 3);
+        assert_eq!(first_entry["chains"], serde_json::json!(["other", "pool"]));
+        groups.select("pool", "other").unwrap();
+        for host in ["first.example", "second.example"] {
+            transport
+                .send(Datagram {
+                    remote: Destination::domain(host, 53).unwrap(),
+                    payload: Bytes::from_static(b"domain"),
+                    sniffed_domain: None,
+                })
+                .await
+                .unwrap();
+        }
+        assert_eq!(
+            other.udp_opens.load(Ordering::Relaxed),
+            3,
+            "domain aliases must not share a wire"
+        );
+        transport.close().await.unwrap();
+        assert_eq!(proxy.udp_closes.load(Ordering::Relaxed), 2);
+        assert_eq!(other.udp_closes.load(Ordering::Relaxed), 3);
+        assert!(
+            serde_json::to_value(registry.snapshot()).unwrap()["connections"]
+                .as_array()
+                .unwrap()
+                .is_empty()
+        );
+    }
+
+    #[cfg(feature = "outbound-trojan")]
+    #[tokio::test]
+    async fn managed_trojan_udp_shares_ip_destinations_and_retires_closed_members() {
+        use crate::{dispatch::DatagramBudget, outbound::trojan::TrojanDatagram};
+
+        #[derive(Default)]
+        struct MemoryTrojan {
+            wires: Mutex<Vec<(SocketAddr, tokio::io::DuplexStream)>>,
+        }
+        #[async_trait]
+        impl Dispatcher for MemoryTrojan {
+            async fn connect_tcp(&self, _: StreamSession) -> Result<BoxStream, DispatchError> {
+                Err(DispatchError::NotAllowed)
+            }
+            async fn open_datagram(
+                &self,
+                session: DatagramSession,
+            ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+                let (client, peer) = tokio::io::duplex(4096);
+                self.wires.lock().unwrap().push((session.source, peer));
+                Ok(Box::new(TrojanDatagram::new(
+                    Box::new(client),
+                    DatagramBudget::new(8192, 8192),
+                )))
+            }
+        }
+        fn frame(target: SocketAddr, payload: &[u8]) -> Vec<u8> {
+            let IpAddr::V4(ip) = target.ip() else {
+                panic!("fixture uses IPv4 targets");
+            };
+            let mut wire = vec![1];
+            wire.extend_from_slice(&ip.octets());
+            wire.extend_from_slice(&target.port().to_be_bytes());
+            wire.extend_from_slice(&(payload.len() as u16).to_be_bytes());
+            wire.extend_from_slice(b"\r\n");
+            wire.extend_from_slice(payload);
+            wire
+        }
+        async fn expect_wire(peer: &mut tokio::io::DuplexStream, expected: &[u8]) {
+            let mut sent = vec![0; expected.len()];
+            peer.read_exact(&mut sent).await.unwrap();
+            assert_eq!(sent, expected);
+        }
+
+        tokio::time::timeout(Duration::from_secs(1), async {
+            let config = crate::config::Config::parse_yaml(
+                br#"
+proxies:
+  - {name: edge, type: trojan, server: 192.0.2.1, port: 443, password: fixture, udp: true}
+rules: ["MATCH,edge"]
+"#,
+            )
+            .unwrap();
+            let proxy = Arc::new(MemoryTrojan::default());
+            let rules = RuleSet::compile(config.rules.clone()).unwrap();
+            let registry = Arc::new(crate::connections::Registry::default());
+            let diagnostics = Arc::new(crate::routing::diagnostics::Diagnostics::new(
+                &config,
+                &rules,
+                registry.clone(),
+            ));
+            let router = RoutingDispatcher::new(
+                ProxyDispatchers::new(vec![proxy.clone()]).unwrap(),
+                Arc::new(RecordingDispatcher::default()),
+                None,
+                rules,
+                Arc::new(EmptyGeoMatcher),
+            )
+            .with_diagnostics(diagnostics);
+            let session = association(InboundKind::Tun);
+            let mut first = router.open_datagram(session.clone()).await.unwrap();
+            let mut second = router
+                .open_datagram(DatagramSession::new(
+                    InboundKind::Tun,
+                    "127.0.0.1:10001".parse().unwrap(),
+                ))
+                .await
+                .unwrap();
+            let a = "198.51.100.1:443".parse().unwrap();
+            let b = "198.51.100.2:443".parse().unwrap();
+            let c = "198.51.100.1:8443".parse().unwrap();
+            for (target, payload) in [(a, &b"one"[..]), (b, b"two"), (c, b"three")] {
+                first.send(datagram(target, payload)).await.unwrap();
+            }
+            assert_eq!(
+                proxy.wires.lock().unwrap().len(),
+                1,
+                "same-source IP targets must share the real Trojan association"
+            );
+            second.send(datagram(a, b"other")).await.unwrap();
+            let mut peers = std::mem::take(&mut *proxy.wires.lock().unwrap());
+            assert_eq!(peers.len(), 2, "different sources need independent wires");
+            let (second_source, mut second_peer) = peers.pop().unwrap();
+            let (first_source, mut old_peer) = peers.pop().unwrap();
+            assert_eq!(first_source, session.source);
+            assert_eq!(second_source.port(), 10001);
+            expect_wire(
+                &mut old_peer,
+                &[frame(a, b"one"), frame(b, b"two"), frame(c, b"three")].concat(),
+            )
+            .await;
+            expect_wire(&mut second_peer, &frame(a, b"other")).await;
+
+            let snapshot = serde_json::to_value(registry.snapshot()).unwrap();
+            assert_eq!(snapshot["connections"].as_array().unwrap().len(), 4);
+            let closed = snapshot["connections"]
+                .as_array()
+                .unwrap()
+                .iter()
+                .find(|entry| {
+                    entry["metadata"]["sourcePort"] == "10000"
+                        && entry["metadata"]["destinationIP"] == "198.51.100.1"
+                        && entry["metadata"]["destinationPort"] == "443"
+                })
+                .unwrap();
+            registry.close(closed["id"].as_str().unwrap());
+            first.send(datagram(a, b"new")).await.unwrap();
+            let mut peers = std::mem::take(&mut *proxy.wires.lock().unwrap());
+            assert_eq!(
+                peers.len(),
+                1,
+                "closed members must retire their shared wire"
+            );
+            let (_, mut new_peer) = peers.pop().unwrap();
+            expect_wire(&mut new_peer, &frame(a, b"new")).await;
+            old_peer
+                .write_all(&[frame(a, b"stale"), frame(b, b"sibling"), frame(c, b"port")].concat())
+                .await
+                .unwrap();
+            new_peer.write_all(&frame(a, b"fresh")).await.unwrap();
+            second_peer.write_all(&frame(a, b"separate")).await.unwrap();
+            let mut replies = HashMap::new();
+            for _ in 0..3 {
+                let reply = first.receive().await.unwrap();
+                assert!(replies.insert(reply.remote, reply.payload).is_none());
+            }
+            for (target, expected) in [(a, &b"fresh"[..]), (b, b"sibling"), (c, b"port")] {
+                assert_eq!(replies[&Destination::Ip(target)].as_ref(), expected);
+            }
+            let reply = second.receive().await.unwrap();
+            assert_eq!(reply.remote, Destination::Ip(a));
+            assert_eq!(reply.payload.as_ref(), b"separate");
+            first.close().await.unwrap();
+            second.close().await.unwrap();
+            assert!(
+                serde_json::to_value(registry.snapshot()).unwrap()["connections"]
+                    .as_array()
+                    .unwrap()
+                    .is_empty()
+            );
+            for peer in [&mut old_peer, &mut new_peer, &mut second_peer] {
+                let mut remainder = Vec::new();
+                peer.read_to_end(&mut remainder).await.unwrap();
+                assert!(
+                    remainder.is_empty(),
+                    "close must release both wire directions"
+                );
+            }
+        })
+        .await
+        .expect("memory-only routing must complete without peer or shutdown waits");
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn managed_udp_connections_poll_only_ready_targets_and_close_pending_flow() {
+        let config =
+            crate::config::Config::parse_yaml(b"mixed-port: 1080\nrules: [\"MATCH,DIRECT\"]\n")
+                .unwrap();
+        let direct = Arc::new(RecordingDispatcher {
+            pollable: true,
+            ..Default::default()
+        });
+        let rules = RuleSet::compile(config.rules.clone()).unwrap();
+        let registry = Arc::new(crate::connections::Registry::default());
+        let diagnostics = Arc::new(crate::routing::diagnostics::Diagnostics::new(
+            &config,
+            &rules,
+            registry.clone(),
+        ));
+        let router = RoutingDispatcher::new(
+            ProxyDispatchers::new(Vec::new()).unwrap(),
+            direct.clone(),
+            None,
+            rules,
+            Arc::new(EmptyGeoMatcher),
+        )
+        .with_diagnostics(diagnostics);
+        let mut transport = router.routed_datagrams(association(InboundKind::Socks5));
+        let addresses = (0..256)
+            .map(|port| SocketAddr::new("198.51.100.1".parse().unwrap(), 10000 + port))
+            .collect::<Vec<_>>();
+        for address in &addresses {
+            transport.send(datagram(*address, b"first")).await.unwrap();
+        }
+        for _ in &addresses {
+            transport.receive().await.unwrap();
+        }
+        // Register all idle readers without retaining futures across calls.
+        while !transport.managed_ready.as_ref().unwrap().is_empty() {
+            assert!(futures_util::poll!(transport.receive()).is_pending());
+        }
+        direct.receive_polls.store(0, Ordering::Relaxed);
+        let deadline = transport.managed_next_cleanup;
+        transport
+            .send(datagram(addresses[0], b"ready"))
+            .await
+            .unwrap();
+        assert_eq!(
+            transport.receive().await.unwrap().remote,
+            Destination::Ip(addresses[0])
+        );
+        assert_eq!(direct.receive_polls.load(Ordering::Relaxed), 1);
+        assert_eq!(transport.managed_next_cleanup, deadline);
+        let snapshot = serde_json::to_value(registry.snapshot()).unwrap();
+        let entry = snapshot["connections"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .find(|entry| entry["metadata"]["destinationPort"] == addresses[1].port().to_string())
+            .unwrap();
+        registry.close(entry["id"].as_str().unwrap());
+        // Cancellation wakes an idle reader immediately; no timer advance is needed.
+        assert!(futures_util::poll!(transport.receive()).is_pending());
+        assert!(
+            transport
+                .managed_flows
+                .get(&Destination::Ip(addresses[1]))
+                .is_none()
+        );
+        assert_eq!(direct.udp_closes.load(Ordering::Relaxed), 1);
+        assert_eq!(Instant::now() + UDP_FLOW_CLEANUP_INTERVAL, deadline);
+        transport.close().await.unwrap();
+        assert_eq!(direct.udp_closes.load(Ordering::Relaxed), 256);
+        assert!(transport.managed_ready.as_ref().unwrap().is_empty());
+        assert!(
+            serde_json::to_value(registry.snapshot()).unwrap()["connections"]
+                .as_array()
+                .unwrap()
+                .is_empty()
+        );
+    }
+
+    #[tokio::test]
+    async fn rematch_group_selection_routes_tcp_udp_without_control_io_or_old_flow_migration() {
+        let mut config = crate::config::Config::parse_yaml(
+            br#"
+mixed-port: 1080
+proxies: [{name: mark, type: rematch, target-rematch-name: phase}]
+proxy-groups:
+  - {name: gate, type: select, proxies: [mark,DIRECT]}
+  - {name: outer, type: select, proxies: [gate], disable-udp: true}
+rules: ['REMATCH-NAME,phase,REJECT', 'MATCH,outer', 'MATCH,DIRECT']
+"#,
+        )
+        .unwrap();
+        // If a rematch is mistaken for an egress, this mock would succeed and
+        // expose the wrong physical path through its counters.
+        let control = Arc::new(RecordingDispatcher {
+            tcp_only: true,
+            ..Default::default()
+        });
+        let direct = Arc::new(RecordingDispatcher::default());
+        let nodes: Vec<Arc<dyn Dispatcher>> = vec![control.clone()];
+        let selections = config
+            .proxy_groups
+            .iter()
+            .map(|group| Arc::new(super::super::GroupSelection::new(group.initial_member)))
+            .collect::<Vec<_>>();
+        let groups = ProxyGroups::with_selections_and_drop(
+            &config.proxy_groups,
+            nodes.clone(),
+            direct.clone(),
+            &selections,
+            direct.clone(),
+            super::super::RematchTargets::new(&config.proxies),
+        )
+        .unwrap();
+        let router = RoutingDispatcher::new(
+            ProxyDispatchers::with_proxy_groups(nodes, &groups).unwrap(),
+            direct.clone(),
+            None,
+            RuleSet::compile_config(&mut config).unwrap(),
+            Arc::new(EmptyGeoMatcher),
+        );
+        let first = "198.51.100.1:443".parse().unwrap();
+        for network in [Network::Tcp, Network::Udp] {
+            let decision = router
+                .route(
+                    network,
+                    (InboundKind::Tun, &Default::default()),
+                    "192.0.2.2:10000".parse().unwrap(),
+                    &Destination::Ip(first),
+                    None,
+                    None,
+                )
+                .await
+                .unwrap();
+            assert_eq!(decision.action, RuleAction::Reject);
+        }
+        assert!(matches!(
+            router.connect_tcp(stream(first, InboundKind::Tun)).await,
+            Err(DispatchError::NotAllowed)
+        ));
+        let mut udp = router
+            .open_datagram(association(InboundKind::Tun))
+            .await
+            .unwrap();
+        udp.send(datagram(first, b"rejected")).await.unwrap();
+        assert!(direct.datagrams.lock().unwrap().is_empty());
+
+        groups.select("gate", "DIRECT").unwrap();
+        router
+            .connect_tcp(stream(first, InboundKind::Tun))
+            .await
+            .unwrap();
+        let second = "198.51.100.2:443".parse().unwrap();
+        udp.send(datagram(second, b"direct")).await.unwrap();
+        groups.select("gate", "mark").unwrap();
+        udp.send(datagram(second, b"established")).await.unwrap();
+        udp.send(datagram(
+            "198.51.100.3:443".parse().unwrap(),
+            b"new-rejected",
+        ))
+        .await
+        .unwrap();
+        udp.close().await.unwrap();
+        assert_eq!(direct.tcp_sessions.lock().unwrap().len(), 1);
+        assert_eq!(direct.datagrams.lock().unwrap().len(), 2);
+        assert!(control.tcp_sessions.lock().unwrap().is_empty());
+        assert_eq!(control.udp_opens.load(Ordering::Relaxed), 0);
+        assert!(matches!(
+            groups.resolve_leaf_for(
+                crate::config::ProxyGroupId::new(0).unwrap(),
+                false,
+                None,
+                None,
+                None
+            ),
+            Err(DispatchError::NotAllowed)
+        ));
+    }
+
+    #[tokio::test]
+    async fn udp_rules_skip_incapable_targets_without_changing_explicit_modes() {
+        for target in ["edge", "outer", "disabled"] {
+            for mode in ["rule", "global"] {
+                let mut config = crate::config::Config::parse_yaml(
+                    format!(
+                        r#"
+mixed-port: 1080
+mode: {mode}
+proxies: [{{name: edge, type: socks5, server: 192.0.2.1, port: 1080}}]
+proxy-groups:
+  - {{name: inner, type: select, proxies: [edge]}}
+  - {{name: outer, type: select, proxies: [inner]}}
+  - {{name: disabled, type: select, proxies: [DIRECT], disable-udp: true}}
+  - {{name: GLOBAL, type: select, proxies: [{target}]}}
+rules: ["DST-PORT,443,{target}", "MATCH,DIRECT"]
+"#
+                    )
+                    .as_bytes(),
+                )
+                .unwrap();
+                let nodes: Vec<Arc<dyn Dispatcher>> =
+                    vec![crate::dispatch::observe_handshakes_with_stats(
+                        Arc::new(RecordingDispatcher {
+                            tcp_only: true,
+                            ..Default::default()
+                        }),
+                        crate::resources::RuntimeResourceStats::new("udp-capability"),
+                    )];
+                let direct = Arc::new(RecordingDispatcher::default());
+                let groups =
+                    ProxyGroups::new(&config.proxy_groups, nodes.clone(), direct.clone()).unwrap();
+                let router = RoutingDispatcher::new(
+                    ProxyDispatchers::with_proxy_groups(nodes, &groups).unwrap(),
+                    direct,
+                    None,
+                    RuleSet::compile_config(&mut config).unwrap(),
+                    Arc::new(EmptyGeoMatcher),
+                );
+                for network in [Network::Tcp, Network::Udp] {
+                    let decision = router
+                        .route(
+                            network,
+                            (InboundKind::Socks5, &Default::default()),
+                            "192.0.2.2:1234".parse().unwrap(),
+                            &Destination::Ip("203.0.113.1:443".parse().unwrap()),
+                            None,
+                            None,
+                        )
+                        .await
+                        .unwrap();
+                    assert_eq!(
+                        decision.action == RuleAction::Direct,
+                        mode == "rule" && network == Network::Udp
+                    );
+                }
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn routed_group_failures_notify_each_selected_group() {
+        struct Failed;
+        #[async_trait]
+        impl Dispatcher for Failed {
+            async fn connect_tcp(&self, _: StreamSession) -> Result<BoxStream, DispatchError> {
+                Err(DispatchError::HostUnreachable)
+            }
+            async fn open_datagram(
+                &self,
+                _: DatagramSession,
+            ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+                Err(DispatchError::NetworkUnreachable)
+            }
+        }
+        let config = crate::config::Config::parse_yaml(
+            br#"
+mixed-port: 1080
+proxies: [{name: edge, type: socks5, server: 192.0.2.1, port: 1080}]
+proxy-groups:
+  - {name: inner, type: fallback, proxies: [edge], max-failed-times: 2}
+  - {name: outer, type: fallback, proxies: [inner], max-failed-times: 2}
+rules: ["MATCH,outer"]
+"#,
+        )
+        .unwrap();
+        let nodes: Vec<Arc<dyn Dispatcher>> = vec![Arc::new(Failed)];
+        let direct = Arc::new(RecordingDispatcher::default());
+        let groups = ProxyGroups::new(&config.proxy_groups, nodes.clone(), direct.clone()).unwrap();
+        let router = RoutingDispatcher::new(
+            ProxyDispatchers::with_proxy_groups(nodes, &groups).unwrap(),
+            direct,
+            None,
+            RuleSet::compile(config.rules).unwrap(),
+            Arc::new(EmptyGeoMatcher),
+        );
+        for attempt in 0..2 {
+            let result = router
+                .connect_tcp(StreamSession {
+                    metadata: Default::default(),
+                    inbound: InboundKind::Socks5,
+                    source: "192.0.2.2:5555".parse().unwrap(),
+                    destination: Destination::Ip("198.51.100.1:443".parse().unwrap()),
+                    sniffed_domain: None,
+                })
+                .await;
+            assert!(matches!(result, Err(DispatchError::HostUnreachable)));
+            for index in 0..2 {
+                assert_eq!(groups.selection(index).take_urgent(), attempt == 1);
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn load_balance_routes_tcp_and_pins_udp_flows() {
+        let config = crate::config::Config::parse_yaml(
+            br#"
+mixed-port: 1080
+proxies:
+  - {name: a, type: socks5, server: 192.0.2.10, port: 1080}
+  - {name: b, type: socks5, server: 192.0.2.11, port: 1080}
+proxy-groups:
+  - {name: balance, type: load-balance, proxies: [a,b], strategy: round-robin}
+rules: ["MATCH,balance"]
+"#,
+        )
+        .unwrap();
+        let a = Arc::new(RecordingDispatcher::default());
+        let b = Arc::new(RecordingDispatcher::default());
+        let direct = Arc::new(RecordingDispatcher::default());
+        let nodes: Vec<Arc<dyn Dispatcher>> = vec![a.clone(), b.clone()];
+        let groups = ProxyGroups::new(&config.proxy_groups, nodes.clone(), direct.clone()).unwrap();
+        let router = RoutingDispatcher::new(
+            ProxyDispatchers::with_proxy_groups(nodes, &groups).unwrap(),
+            direct,
+            None,
+            RuleSet::compile(vec![rule(RuleKind::Match, group_action(0))]).unwrap(),
+            Arc::new(EmptyGeoMatcher),
+        );
+        let source = "192.0.2.1:5555".parse().unwrap();
+        let dest = Destination::Ip("198.51.100.1:443".parse().unwrap());
+        for _ in 0..2 {
+            router
+                .connect_tcp(StreamSession {
+                    metadata: Default::default(),
+                    inbound: InboundKind::Socks5,
+                    source,
+                    destination: dest.clone(),
+                    sniffed_domain: None,
+                })
+                .await
+                .unwrap();
+        }
+        assert_eq!(a.tcp_sessions.lock().unwrap().len(), 1);
+        assert_eq!(b.tcp_sessions.lock().unwrap().len(), 1);
+        let mut transport = router
+            .open_datagram(DatagramSession::new(InboundKind::Socks5, source))
+            .await
+            .unwrap();
+        let first = Datagram {
+            remote: dest,
+            payload: Bytes::from_static(b"x"),
+            sniffed_domain: None,
+        };
+        transport.send(first.clone()).await.unwrap();
+        groups.apply_health(0, &[None, Some(50)]);
+        transport.send(first).await.unwrap();
+        transport
+            .send(Datagram {
+                remote: Destination::Ip("198.51.100.2:443".parse().unwrap()),
+                payload: Bytes::from_static(b"y"),
+                sniffed_domain: None,
+            })
+            .await
+            .unwrap();
+        assert_eq!(a.datagrams.lock().unwrap().len(), 2);
+        assert_eq!(b.datagrams.lock().unwrap().len(), 1);
+        assert_eq!(a.udp_opens.load(Ordering::Relaxed), 1);
+        assert!(groups.select("balance", "a").is_err());
+        transport.close().await.unwrap();
+    }
+
+    #[tokio::test]
+    async fn ingress_rules_and_user_hash_reach_tcp_udp_with_one_leaf() {
+        let mut config = crate::config::Config::parse_yaml(
+            br#"
+mixed-port: 1080
+proxies:
+  - {name: a, type: socks5, server: 192.0.2.10, port: 1080, udp: true}
+  - {name: b, type: socks5, server: 192.0.2.11, port: 1080, udp: true}
+proxy-groups:
+  - {name: balance, type: load-balance, proxies: [a,b], hash-key: in-user}
+rules:
+  - 'AND,((IN-TYPE,HTTPS/SOCKS5),(IN-USER,Alice),(IN-PORT,1080),(SRC-IP-CIDR,192.0.2.0/24)),balance'
+  - 'MATCH,REJECT'
+"#,
         )
         .unwrap();
-        RoutingDispatcher::new(
-            proxies,
+        let a = Arc::new(RecordingDispatcher::default());
+        let b = Arc::new(RecordingDispatcher::default());
+        let direct = Arc::new(RecordingDispatcher::default());
+        let nodes: Vec<Arc<dyn Dispatcher>> = vec![a.clone(), b.clone()];
+        let groups = ProxyGroups::new(&config.proxy_groups, nodes.clone(), direct.clone()).unwrap();
+        let router = RoutingDispatcher::new(
+            ProxyDispatchers::with_proxy_groups(nodes, &groups).unwrap(),
             direct,
             None,
-            RuleSet::compile(rules).unwrap(),
+            RuleSet::compile(config.take_runtime_rules()).unwrap(),
+            Arc::new(EmptyGeoMatcher),
+        );
+        let metadata = crate::session::InboundMetadata {
+            local_port: 1080,
+            user: Some(Arc::from("Alice")),
+            ..Default::default()
+        };
+        for (source, remote) in [
+            ("192.0.2.1:5555", "198.51.100.1:443"),
+            ("192.0.2.2:6666", "203.0.113.2:80"),
+        ] {
+            router
+                .connect_tcp(StreamSession {
+                    metadata: metadata.clone(),
+                    inbound: InboundKind::Https,
+                    source: source.parse().unwrap(),
+                    destination: Destination::Ip(remote.parse().unwrap()),
+                    sniffed_domain: None,
+                })
+                .await
+                .unwrap();
+        }
+        let counts = [
+            a.tcp_sessions.lock().unwrap().len(),
+            b.tcp_sessions.lock().unwrap().len(),
+        ];
+        assert!(counts == [2, 0] || counts == [0, 2]);
+        let selected = usize::from(counts[0] == 0);
+        let nodes = [a, b];
+        let mut udp = router
+            .open_datagram(
+                DatagramSession::new(InboundKind::Socks5, "192.0.2.3:7777".parse().unwrap())
+                    .with_metadata(metadata),
+            )
+            .await
+            .unwrap();
+        let datagram = Datagram {
+            remote: Destination::Ip("198.51.100.3:53".parse().unwrap()),
+            payload: Bytes::from_static(b"x"),
+            sniffed_domain: None,
+        };
+        udp.send(datagram.clone()).await.unwrap();
+        groups.apply_health(
+            0,
+            if selected == 0 {
+                &[None, Some(10)]
+            } else {
+                &[Some(10), None]
+            },
+        );
+        udp.send(datagram).await.unwrap();
+        assert_eq!(nodes[selected].datagrams.lock().unwrap().len(), 2);
+        assert_eq!(nodes[1 - selected].datagrams.lock().unwrap().len(), 0);
+        udp.close().await.unwrap();
+    }
+
+    #[tokio::test]
+    async fn subrule_routes_resume_dns_and_commit_one_tcp_udp_leaf() {
+        let mut config = crate::config::Config::parse_yaml(br#"
+mixed-port: 1080
+proxies:
+  - {name: a, type: socks5, server: 192.0.2.10, port: 1080}
+  - {name: b, type: socks5, server: 192.0.2.11, port: 1080}
+proxy-groups:
+  - {name: gate, type: load-balance, proxies: [PASS-RULE,a], strategy: round-robin, disable-udp: true}
+  - {name: pool, type: load-balance, proxies: [a,b], strategy: round-robin}
+  - {name: GLOBAL, type: select, proxies: [PASS,pool]}
+rules: ['SUB-RULE,(DST-PORT,443),child', 'MATCH,REJECT']
+sub-rules:
+  child: ['DST-PORT,443,gate', 'IP-CIDR,192.0.2.0/24,pool', 'MATCH,pool']
+"#).unwrap();
+        let mut global_config = config.clone();
+        global_config.mode = crate::config::Mode::Global;
+        let a = Arc::new(RecordingDispatcher::default());
+        let b = Arc::new(RecordingDispatcher::default());
+        let nodes: Vec<Arc<dyn Dispatcher>> = vec![a.clone(), b.clone()];
+        let direct = Arc::new(RecordingDispatcher::default());
+        let groups = ProxyGroups::new(&config.proxy_groups, nodes.clone(), direct.clone()).unwrap();
+        let dns = Arc::new(MockDns::new(vec!["192.0.2.7".parse().unwrap()]));
+        let mut router = RoutingDispatcher::new(
+            ProxyDispatchers::with_proxy_groups(nodes, &groups).unwrap(),
+            direct,
+            None,
+            RuleSet::compile_config(&mut config).unwrap(),
+            Arc::new(EmptyGeoMatcher),
+        );
+        router.dns = Some(dns.clone());
+        let source = "192.0.2.1:5555".parse().unwrap();
+        for _ in 0..2 {
+            router
+                .connect_tcp(StreamSession {
+                    metadata: Default::default(),
+                    inbound: InboundKind::Socks5,
+                    source,
+                    destination: Destination::domain("example.com", 443).unwrap(),
+                    sniffed_domain: None,
+                })
+                .await
+                .unwrap();
+        }
+        assert_eq!(dns.resolve_calls.load(Ordering::Relaxed), 2);
+        assert_eq!(a.tcp_sessions.lock().unwrap().len(), 1);
+        assert_eq!(b.tcp_sessions.lock().unwrap().len(), 1);
+        let mut transport = router
+            .open_datagram(DatagramSession::new(InboundKind::Socks5, source))
+            .await
+            .unwrap();
+        let first = datagram("198.51.100.1:443".parse().unwrap(), b"first");
+        transport.send(first.clone()).await.unwrap();
+        transport.send(first).await.unwrap();
+        transport
+            .send(datagram("198.51.100.2:443".parse().unwrap(), b"next"))
+            .await
+            .unwrap();
+        assert_eq!(a.datagrams.lock().unwrap().len(), 2);
+        assert_eq!(b.datagrams.lock().unwrap().len(), 1);
+        assert_eq!(groups.selection(0).choose(None, None), 0);
+        transport.close().await.unwrap();
+        let global = RoutingDispatcher::new(
+            router.route_targets.clone(),
+            router.direct.clone(),
+            None,
+            RuleSet::compile_config(&mut global_config).unwrap(),
             Arc::new(EmptyGeoMatcher),
+        );
+        assert!(matches!(
+            global
+                .connect_tcp(StreamSession {
+                    metadata: Default::default(),
+                    inbound: InboundKind::Socks5,
+                    source,
+                    destination: Destination::Ip("198.51.100.1:443".parse().unwrap()),
+                    sniffed_domain: None
+                })
+                .await,
+            Err(DispatchError::NotAllowed)
+        ));
+    }
+
+    #[test]
+    fn proxy_registry_clones_share_ownership_and_release_dependencies() {
+        let proxy: Arc<dyn Dispatcher> = Arc::new(RecordingDispatcher::default());
+        let direct = Arc::new(RecordingDispatcher::default());
+        let proxy_id = ProxyId::new(0).unwrap();
+        let group_id = RouteTargetId::Group(ProxyGroupId::new(0).unwrap());
+        let groups = ProxyGroups::new(
+            &[select_group(
+                "route",
+                vec![(
+                    "node",
+                    ProxyGroupMemberTarget::Route(RouteTargetId::Proxy(proxy_id)),
+                )],
+            )],
+            vec![proxy.clone()],
+            direct,
         )
+        .unwrap();
+        let registry = ProxyDispatchers::with_proxy_groups(vec![proxy.clone()], &groups).unwrap();
+        let weak_proxy = Arc::downgrade(&proxy);
+        let weak_groups = Arc::downgrade(&groups);
+        let weak_group_dispatcher = Arc::downgrade(registry.get_route(group_id).unwrap());
+        let reference_counts = (
+            Arc::strong_count(&proxy),
+            weak_group_dispatcher.strong_count(),
+            Arc::strong_count(&groups),
+        );
+
+        let cloned = registry.clone();
+        assert_eq!(
+            (
+                Arc::strong_count(&proxy),
+                weak_group_dispatcher.strong_count(),
+                Arc::strong_count(&groups),
+            ),
+            reference_counts,
+            "cloning the registry must not clone its node or group ownership arrays"
+        );
+        assert!(Arc::ptr_eq(
+            registry.get(proxy_id).unwrap(),
+            cloned.get(proxy_id).unwrap()
+        ));
+        assert!(Arc::ptr_eq(
+            registry.get_route(group_id).unwrap(),
+            cloned.get_route(group_id).unwrap()
+        ));
+
+        drop(registry);
+        drop(groups);
+        drop(proxy);
+        assert!(weak_proxy.upgrade().is_some());
+        assert!(weak_groups.upgrade().is_some());
+        assert!(cloned.get(proxy_id).unwrap().supports_udp());
+        assert!(cloned.get_route(group_id).unwrap().supports_udp());
+
+        drop(cloned);
+        assert!(weak_group_dispatcher.upgrade().is_none());
+        assert!(weak_groups.upgrade().is_none());
+        assert!(weak_proxy.upgrade().is_none());
     }
 
     #[test]
@@ -1173,24 +3547,24 @@ mod tests {
 
     #[tokio::test]
     async fn group_route_snapshots_direct_dns_for_tcp() {
-        let proxy = Arc::new(RecordingDispatcher::default());
         let direct = Arc::new(RecordingDispatcher::default());
         let groups = ProxyGroups::new(
             &[select_group(
                 "route",
                 vec![("DIRECT", ProxyGroupMemberTarget::Direct)],
             )],
-            vec![proxy.clone()],
+            Vec::new(),
             direct.clone(),
         )
         .unwrap();
-        let targets = RouteTargetDispatchers::with_proxy_groups(vec![proxy], &groups).unwrap();
+        let targets = RouteTargetDispatchers::with_proxy_groups(Vec::new(), &groups).unwrap();
         let dns = Arc::new(MockDns::new(vec![IpAddr::V4(Ipv4Addr::new(
             203, 0, 113, 9,
         ))]));
         let router = RoutingDispatcher {
             route_targets: targets,
             direct: direct.clone(),
+            reject_drop: default_reject_drop(),
             dns: Some(dns.clone()),
             ipv6: true,
             rules: Arc::new(
@@ -1198,10 +3572,16 @@ mod tests {
             ),
             geo_matcher: Arc::new(EmptyGeoMatcher),
             tun_config: TunConfig::default(),
+            sniffer: None,
+            tcp_concurrent: false,
+            diagnostics: None,
+            process_dialer: None,
+            process_mode: crate::config::FindProcessMode::Strict,
         };
 
         router
             .connect_tcp(StreamSession {
+                metadata: Default::default(),
                 inbound: InboundKind::Http,
                 source: "127.0.0.1:10000".parse().unwrap(),
                 destination: Destination::domain("example.com", 443).unwrap(),
@@ -1286,8 +3666,95 @@ mod tests {
         assert_eq!(second.datagrams.lock().unwrap().len(), 1);
     }
 
+    #[tokio::test]
+    async fn cached_udp_leaf_survives_selection_of_a_tcp_only_member() {
+        for kind in ["select", "fallback", "url-test", "load-balance"] {
+            for fallback in ["DIRECT", "REJECT"] {
+                let mut config = crate::config::Config::parse_yaml(
+                    format!(
+                        r#"
+mixed-port: 1080
+proxies:
+  - {{name: first, type: socks5, server: 192.0.2.1, port: 1080, udp: true}}
+  - {{name: next, type: socks5, server: 192.0.2.2, port: 1080, udp: false}}
+proxy-groups:
+  - {{name: route, type: {kind}, proxies: [first, next]}}
+rules: ["DST-PORT,443,route", "MATCH,{fallback}"]
+"#
+                    )
+                    .as_bytes(),
+                )
+                .unwrap();
+                let first = Arc::new(RecordingDispatcher::default());
+                let next = Arc::new(RecordingDispatcher {
+                    tcp_only: true,
+                    ..Default::default()
+                });
+                let direct = Arc::new(RecordingDispatcher::default());
+                let nodes: Vec<Arc<dyn Dispatcher>> = vec![first.clone(), next.clone()];
+                let groups =
+                    ProxyGroups::new(&config.proxy_groups, nodes.clone(), direct.clone()).unwrap();
+                groups.apply_health(0, &[Some(10), None]);
+                let router = RoutingDispatcher::new(
+                    RouteTargetDispatchers::with_proxy_groups(nodes, &groups).unwrap(),
+                    direct.clone(),
+                    None,
+                    RuleSet::compile_config(&mut config).unwrap(),
+                    Arc::new(EmptyGeoMatcher),
+                );
+                assert!(router.diagnostics.is_none());
+                let remote = "198.51.100.1:443".parse().unwrap();
+                let mut established = router
+                    .open_datagram(association(InboundKind::Socks5))
+                    .await
+                    .unwrap();
+                established.send(datagram(remote, b"first")).await.unwrap();
+                if kind == "select" {
+                    groups.select("route", "next").unwrap();
+                } else {
+                    groups.apply_health(0, &[None, Some(10)]);
+                }
+                established
+                    .send(datagram(remote, b"still-first"))
+                    .await
+                    .unwrap();
+                assert_eq!(first.datagrams.lock().unwrap().len(), 2, "{kind}");
+                assert_eq!(direct.udp_opens.load(Ordering::Relaxed), 0, "{kind}");
+                for payload in [b"first".as_slice(), b"still-first"] {
+                    let reply = established.receive().await.unwrap();
+                    assert_eq!(reply.remote, Destination::Ip(remote));
+                    assert_eq!(reply.payload.as_ref(), payload);
+                }
+
+                // Another source owns a separate association and must evaluate the
+                // current group, rather than borrowing this source's cached leaf.
+                let mut fresh = router
+                    .open_datagram(DatagramSession::new(
+                        InboundKind::Socks5,
+                        "192.0.2.20:10001".parse().unwrap(),
+                    ))
+                    .await
+                    .unwrap();
+                fresh.send(datagram(remote, b"fresh-direct")).await.unwrap();
+                let forwarded = usize::from(fallback == "DIRECT");
+                assert_eq!(direct.datagrams.lock().unwrap().len(), forwarded, "{kind}");
+                assert_eq!(first.udp_opens.load(Ordering::Relaxed), 1, "{kind}");
+                assert_eq!(next.udp_opens.load(Ordering::Relaxed), 0, "{kind}");
+                fresh.close().await.unwrap();
+                established.close().await.unwrap();
+                assert_eq!(first.udp_closes.load(Ordering::Relaxed), 1, "{kind}");
+                assert_eq!(
+                    direct.udp_closes.load(Ordering::Relaxed),
+                    forwarded,
+                    "{kind}"
+                );
+            }
+        }
+    }
+
     fn stream(destination: SocketAddr, inbound: InboundKind) -> StreamSession {
         StreamSession {
+            metadata: Default::default(),
             inbound,
             source: "127.0.0.1:10000".parse().unwrap(),
             destination: Destination::Ip(destination),
@@ -1315,6 +3782,40 @@ mod tests {
         query
     }
 
+    #[tokio::test]
+    async fn builtin_final_actions_route_tcp_and_udp_without_proxies() {
+        let destination = "192.0.2.1:443".parse().unwrap();
+        for action in [RuleAction::Direct, RuleAction::Reject] {
+            let direct = Arc::new(RecordingDispatcher::default());
+            let router = dispatcher_with_proxies(
+                Vec::new(),
+                direct.clone(),
+                vec![rule(RuleKind::Match, action)],
+            );
+            let result = router
+                .connect_tcp(stream(destination, InboundKind::Http))
+                .await;
+            if action == RuleAction::Direct {
+                assert!(result.is_ok());
+            } else {
+                assert!(matches!(result, Err(DispatchError::NotAllowed)));
+            }
+            let mut transport = router
+                .open_datagram(association(InboundKind::Socks5))
+                .await
+                .unwrap();
+            transport
+                .send(datagram(destination, b"payload"))
+                .await
+                .unwrap();
+            let expected = usize::from(action == RuleAction::Direct);
+            assert_eq!(direct.tcp_sessions.lock().unwrap().len(), expected);
+            assert_eq!(direct.datagrams.lock().unwrap().len(), expected);
+            assert_eq!(direct.udp_opens.load(Ordering::Relaxed), expected);
+            transport.close().await.unwrap();
+        }
+    }
+
     #[tokio::test]
     async fn tcp_selects_proxy_direct_and_reject() {
         let proxy = Arc::new(RecordingDispatcher::default());
@@ -1427,6 +3928,7 @@ mod tests {
         assert!(matches!(
             router
                 .connect_tcp(StreamSession {
+                    metadata: Default::default(),
                     inbound: InboundKind::Http,
                     source: "127.0.0.1:10000".parse().unwrap(),
                     destination: Destination::domain("example.com", 443).unwrap(),
@@ -1466,6 +3968,7 @@ mod tests {
 
         router
             .connect_tcp(StreamSession {
+                metadata: Default::default(),
                 inbound: InboundKind::Http,
                 source: "127.0.0.1:10000".parse().unwrap(),
                 destination: Destination::domain("example.com", 443).unwrap(),
@@ -1505,6 +4008,7 @@ mod tests {
 
         router
             .connect_tcp(StreamSession {
+                metadata: Default::default(),
                 inbound: InboundKind::Tun,
                 source: "192.0.2.10:10000".parse().unwrap(),
                 destination: Destination::Ip(destination),
@@ -1570,61 +4074,31 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn dns_and_sniffed_domain_hints_are_consumed_only_by_tun() {
+    async fn business_inbounds_use_sniffed_domains_without_exposing_them_to_outbounds() {
         let destination: SocketAddr = "198.51.100.8:443".parse().unwrap();
         let proxy = Arc::new(RecordingDispatcher::default());
         let direct = Arc::new(RecordingDispatcher::default());
-        let mut dns = MockDns::new(Vec::new());
-        dns.hint = Some((destination.ip(), "hint.example".to_owned()));
-        let dns = Arc::new(dns);
         let router = dispatcher(
             proxy.clone(),
             direct.clone(),
-            Some(dns.clone()),
+            None,
             vec![
-                rule(
-                    RuleKind::Domain("hint.example".to_owned()),
-                    RuleAction::Direct,
-                ),
+                rule(RuleKind::Domain("hint.example".into()), RuleAction::Direct),
                 rule(RuleKind::Match, proxy_action(0)),
             ],
         );
-
-        router
-            .connect_tcp(StreamSession {
-                inbound: InboundKind::Http,
-                source: "127.0.0.1:10000".parse().unwrap(),
-                destination: Destination::Ip(destination),
-                sniffed_domain: Some("hint.example".to_owned()),
-            })
-            .await
-            .unwrap();
-        assert_eq!(dns.hint_calls.load(Ordering::Relaxed), 0);
-        assert_eq!(proxy.tcp_sessions.lock().unwrap().len(), 1);
-        assert!(direct.tcp_sessions.lock().unwrap().is_empty());
-
-        router
-            .connect_tcp(stream(destination, InboundKind::Tun))
-            .await
-            .unwrap();
-        assert_eq!(dns.hint_calls.load(Ordering::Relaxed), 1);
-        assert_eq!(direct.tcp_sessions.lock().unwrap().len(), 1);
-
-        let mut http_udp = router
-            .open_datagram(association(InboundKind::Http))
-            .await
-            .unwrap();
-        http_udp.send(datagram(destination, b"http")).await.unwrap();
-        assert_eq!(dns.hint_calls.load(Ordering::Relaxed), 1);
-
-        let mut tun_udp = router
-            .open_datagram(association(InboundKind::Tun))
-            .await
-            .unwrap();
-        tun_udp.send(datagram(destination, b"tun")).await.unwrap();
-        assert_eq!(dns.hint_calls.load(Ordering::Relaxed), 2);
-        assert_eq!(proxy.datagrams.lock().unwrap().len(), 1);
-        assert_eq!(direct.datagrams.lock().unwrap().len(), 1);
+        for inbound in [InboundKind::Http, InboundKind::Socks5, InboundKind::Tun] {
+            let mut session = stream(destination, inbound);
+            session.sniffed_domain = Some("hint.example".into());
+            router.connect_tcp(session).await.unwrap();
+        }
+        assert!(proxy.tcp_sessions.lock().unwrap().is_empty());
+        let sessions = direct.tcp_sessions.lock().unwrap();
+        assert_eq!(sessions.len(), 3);
+        assert!(sessions.iter().all(
+            |session| session.destination == Destination::Ip(destination)
+                && session.sniffed_domain.is_none()
+        ));
     }
 
     #[tokio::test]
@@ -1805,6 +4279,7 @@ mod tests {
         );
         router
             .connect_tcp(StreamSession {
+                metadata: Default::default(),
                 inbound: InboundKind::Http,
                 source: "127.0.0.1:10000".parse().unwrap(),
                 destination: Destination::domain("例子.中国", 443).unwrap(),
@@ -1831,6 +4306,7 @@ mod tests {
         );
         router
             .connect_tcp(StreamSession {
+                metadata: Default::default(),
                 inbound: InboundKind::Http,
                 source: "127.0.0.1:10001".parse().unwrap(),
                 destination: Destination::domain("例子.中国", 443).unwrap(),
@@ -1984,6 +4460,10 @@ mod tests {
 
         #[async_trait]
         impl DatagramTransport for FailingReceiveDatagrams {
+            fn supports_shared_destinations(&self) -> bool {
+                false
+            }
+
             async fn send(&mut self, datagram: Datagram) -> Result<(), DispatchError> {
                 self.responses.push_back(datagram);
                 Ok(())
@@ -2766,6 +5246,7 @@ mod tests {
 
         router
             .connect_tcp(StreamSession {
+                metadata: Default::default(),
                 inbound: InboundKind::Http,
                 source: "127.0.0.1:10000".parse().unwrap(),
                 destination: Destination::domain("example.com", 443).unwrap(),
@@ -2827,6 +5308,7 @@ mod tests {
 
         router
             .connect_tcp(StreamSession {
+                metadata: Default::default(),
                 inbound: InboundKind::Http,
                 source: "127.0.0.1:10001".parse().unwrap(),
                 destination: Destination::domain("example.com", 443).unwrap(),
@@ -2842,4 +5324,187 @@ mod tests {
             Destination::Ip(SocketAddr::new(selected, 443))
         );
     }
+    #[tokio::test]
+    async fn fake_ip_routing_preserves_tcp_names_and_distinct_udp_reply_addresses() {
+        struct FakeDns;
+        #[async_trait]
+        impl RoutingDns for FakeDns {
+            fn recover_fake_ip(&self, address: IpAddr) -> Result<Option<String>, DispatchError> {
+                Ok(match address.to_string().as_str() {
+                    "198.18.0.4" => Some("one.example".into()),
+                    "198.18.0.5" => Some("two.example".into()),
+                    _ => None,
+                })
+            }
+            async fn resolve(&self, _: &str) -> Result<Vec<IpAddr>, DispatchError> {
+                Ok(vec!["203.0.113.10".parse().unwrap()])
+            }
+            async fn exchange(&self, _: &[u8]) -> Result<DnsWireResponse, DispatchError> {
+                Err(DispatchError::HostUnreachable)
+            }
+            async fn domain_hint(&self, _: IpAddr) -> Option<String> {
+                None
+            }
+        }
+        let proxy = Arc::new(RecordingDispatcher {
+            shareable: true,
+            ..Default::default()
+        });
+        let direct = Arc::new(RecordingDispatcher::default());
+        let router = dispatcher(
+            proxy.clone(),
+            direct,
+            Some(Arc::new(FakeDns)),
+            vec![rule(RuleKind::Match, proxy_action(0))],
+        );
+        let config = crate::config::Config::parse_yaml(
+            br#"proxies: [{name: edge, type: socks5, server: 192.0.2.1, port: 1080, udp: true}]
+rules: ["MATCH,edge"]"#,
+        )
+        .unwrap();
+        let registry = Arc::new(crate::connections::Registry::default());
+        let diagnostics = Arc::new(crate::routing::diagnostics::Diagnostics::new(
+            &config,
+            &router.rules,
+            registry.clone(),
+        ));
+        let router = router.with_diagnostics(diagnostics);
+        let first: SocketAddr = "198.18.0.4:443".parse().unwrap();
+        let second: SocketAddr = "198.18.0.5:443".parse().unwrap();
+        let _stream = router
+            .connect_tcp(stream(first, InboundKind::Tun))
+            .await
+            .unwrap();
+        assert_eq!(
+            proxy.tcp_sessions.lock().unwrap()[0].destination,
+            Destination::Domain {
+                host: "one.example".into(),
+                port: 443
+            }
+        );
+        drop(_stream);
+        let mut udp = router
+            .open_datagram(DatagramSession::new(
+                InboundKind::Tun,
+                "192.0.2.2:9000".parse().unwrap(),
+            ))
+            .await
+            .unwrap();
+        for (address, payload) in [(first, "one"), (second, "two")] {
+            udp.send(Datagram {
+                remote: Destination::Ip(address),
+                payload: Bytes::from(payload),
+                sniffed_domain: None,
+            })
+            .await
+            .unwrap();
+        }
+        let mut received = Vec::new();
+        for _ in 0..2 {
+            let packet = udp.receive().await.unwrap();
+            received.push((packet.remote, packet.payload));
+        }
+        assert!(received.contains(&(Destination::Ip(first), Bytes::from("one"))));
+        assert!(received.contains(&(Destination::Ip(second), Bytes::from("two"))));
+        assert_eq!(proxy.udp_opens.load(Ordering::Relaxed), 2);
+        assert!(proxy.datagrams.lock().unwrap().iter().all(|packet| packet.remote == Destination::Ip("203.0.113.10:443".parse().unwrap())));
+        assert_eq!(
+            serde_json::to_value(registry.snapshot()).unwrap()["connections"]
+                .as_array()
+                .unwrap()
+                .len(),
+            2
+        );
+        udp.close().await.unwrap();
+        assert!(
+            serde_json::to_value(registry.snapshot()).unwrap()["connections"]
+                .as_array()
+                .unwrap()
+                .is_empty()
+        );
+    }
+    #[tokio::test]
+    async fn quic_override_resolves_new_domain_and_restores_udp_response_target() {
+        let mut config = crate::config::SnifferConfig::disabled();
+        config.enable = true;
+        let proxy = Arc::new(RecordingDispatcher {
+            shareable: true,
+            ..Default::default()
+        });
+        let direct = Arc::new(RecordingDispatcher::default());
+        let dns = Arc::new(MockDns::new(vec!["203.0.113.8".parse().unwrap()]));
+        let router = dispatcher(
+            proxy.clone(),
+            direct,
+            Some(dns.clone()),
+            vec![rule(RuleKind::Match, proxy_action(0))],
+        )
+        .with_sniffer(&config);
+        let config = crate::config::Config::parse_yaml(
+            br#"proxies: [{name: edge, type: socks5, server: 192.0.2.1, port: 1080, udp: true}]
+rules: ["MATCH,edge"]"#,
+        )
+        .unwrap();
+        let registry = Arc::new(crate::connections::Registry::default());
+        let diagnostics = Arc::new(crate::routing::diagnostics::Diagnostics::new(
+            &config,
+            &router.rules,
+            registry.clone(),
+        ));
+        let router = router.with_diagnostics(diagnostics);
+        let original = "198.51.100.4:443".parse().unwrap();
+        let mut transport = router
+            .open_datagram(association(InboundKind::Tun))
+            .await
+            .unwrap();
+        let mut packet = datagram(original, b"quic");
+        packet.sniffed_domain = Some("sniffed.example".into());
+        transport.send(packet).await.unwrap();
+        assert_eq!(
+            proxy.datagrams.lock().unwrap()[0].remote,
+            Destination::Ip("203.0.113.8:443".parse().unwrap())
+        );
+        assert_eq!(
+            transport.receive().await.unwrap().remote,
+            Destination::Ip(original)
+        );
+        let other = "198.51.100.5:443".parse().unwrap();
+        let mut packet = datagram(other, b"other");
+        packet.sniffed_domain = Some("alias.example".into());
+        transport.send(packet).await.unwrap();
+        assert_eq!(
+            transport.receive().await.unwrap().remote,
+            Destination::Ip(other)
+        );
+        assert_eq!(
+            proxy.udp_opens.load(Ordering::Relaxed),
+            2,
+            "two original destinations mapping to one real endpoint need separate wires"
+        );
+        assert_eq!(
+            *dns.resolved_hosts.lock().unwrap(),
+            ["sniffed.example", "alias.example"]
+        );
+        assert_eq!(
+            serde_json::to_value(registry.snapshot()).unwrap()["connections"]
+                .as_array()
+                .unwrap()
+                .len(),
+            2
+        );
+        transport.close().await.unwrap();
+        assert!(
+            serde_json::to_value(registry.snapshot()).unwrap()["connections"]
+                .as_array()
+                .unwrap()
+                .is_empty()
+        );
+    }
+}
+
+fn business(inbound: InboundKind) -> bool {
+    matches!(
+        inbound,
+        InboundKind::Tun | InboundKind::Http | InboundKind::Https | InboundKind::Socks5
+    )
 }
diff --git a/src/routing/mod.rs b/src/routing/mod.rs
index 26654b0..8fe74c5 100644
--- a/src/routing/mod.rs
+++ b/src/routing/mod.rs
@@ -1,19 +1,35 @@
-//! Allocation-free runtime matching for Vole routing rules.
+//! Bounded runtime matching for Vole routing rules.
 //!
 //! Rule parsing and structural validation belong to [`crate::config`]. This
 //! module performs a second, deliberately small compilation step: textual
 //! match values are normalized once and the resulting ordered rule set can be
 //! evaluated without allocating for each rule.
 
-use std::{fmt, net::IpAddr, sync::Arc};
+use std::{
+    fmt,
+    net::{IpAddr, SocketAddr},
+    sync::Arc,
+};
 
 use crate::{
-    config::{IpCidr, Network, RuleAction, RuleKind, RuleSpec},
-    session::Destination,
+    config::{IpCidr, Network, RuleAction, RuleKind, RuleSpec, RuntimeRuleProgram},
+    session::{Destination, InboundKind, InboundMetadata},
 };
 
+mod program;
+mod rematch;
+mod rule_disable;
+use program::CompiledProgram;
+pub(crate) use program::{ProgramEvaluation, RuleTargetEffect};
+pub(crate) use rematch::RematchTargets;
+mod balance;
+pub(super) mod datagram_ready;
+mod selection;
+pub(crate) use selection::GroupSelection;
+
+pub(crate) mod diagnostics;
 mod dispatcher;
-mod proxy_group;
+pub(crate) mod proxy_group;
 
 pub(crate) use dispatcher::RouteTargetDispatchers;
 pub use dispatcher::{ProxyDispatchers, RoutingDispatcher};
@@ -27,18 +43,40 @@ pub const MAX_ROUTING_RULES: usize = crate::config::MAX_RULES;
 pub const MAX_RULE_TEXT_BYTES: usize = crate::config::MAX_RULES_TOTAL_BYTES;
 
 /// A prepared routing context. Domain normalization happens only while this
-/// value is built; matching the context does not allocate.
+/// value is built; clones and lazy-DNS continuations share its execution budget.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct RoutingContext {
     network: Network,
     destination_port: u16,
-    normalized_domain: Option<Box<str>>,
+    source_ip: Option<IpAddr>,
+    source_port: u16,
+    inbound: InboundKind,
+    selector_metadata: bool,
+    metadata: InboundMetadata,
+    process: Option<crate::process::Identity>,
+    process_lookup_enabled: bool,
+    normalized_domain: Option<Arc<str>>,
+    rematch_name: Option<Arc<str>>,
     destination_ip: Option<IpAddr>,
     pinned_ip: Option<IpAddr>,
     ip_resolution_unavailable: bool,
+    decision: crate::config::RuleDecision,
 }
 
 impl RoutingContext {
+    pub(crate) fn with_decision(mut self, decision: &crate::config::RuleDecision) -> Self {
+        self.decision = decision.clone();
+        self
+    }
+    pub(crate) fn decision(&self) -> &crate::config::RuleDecision {
+        &self.decision
+    }
+    pub(crate) fn set_sniffed_domain(&mut self, host: &str) {
+        if let Ok(host) = normalize_domain_name(host) {
+            self.normalized_domain = Some(Arc::from(host));
+        }
+    }
+
     /// Builds a context from the original destination without a redir-host
     /// domain hint.
     pub fn new(network: Network, destination: &Destination) -> Result<Self, DomainNameError> {
@@ -55,7 +93,7 @@ impl RoutingContext {
     ) -> Result<Self, DomainNameError> {
         let (normalized_domain, destination_ip) = match destination {
             Destination::Domain { host, .. } => {
-                (Some(normalize_domain_name(host)?.into_boxed_str()), None)
+                (Some(Arc::from(normalize_domain_name(host)?)), None)
             }
             Destination::Ip(address) => (
                 domain_hint
@@ -65,7 +103,7 @@ impl RoutingContext {
                     // contain `_`), so an unusable hint must not turn the
                     // literal IP itself into an unreachable destination.
                     .and_then(|hint| normalize_domain_name(hint).ok())
-                    .map(String::into_boxed_str),
+                    .map(Arc::from),
                 Some(address.ip()),
             ),
         };
@@ -73,13 +111,93 @@ impl RoutingContext {
         Ok(Self {
             network,
             destination_port: destination.port(),
+            source_ip: None,
+            source_port: 0,
+            inbound: InboundKind::InternalDns,
+            selector_metadata: false,
+            metadata: InboundMetadata::new(0),
+            process: None,
+            process_lookup_enabled: false,
             normalized_domain,
+            rematch_name: None,
             destination_ip,
             pinned_ip: None,
             ip_resolution_unavailable: false,
+            decision: Default::default(),
         })
     }
 
+    pub(crate) fn disable_ip_resolution(&mut self) {
+        self.ip_resolution_unavailable = true;
+    }
+
+    pub fn set_source(&mut self, source: SocketAddr) {
+        self.source_ip = Some(source.ip());
+        self.source_port = source.port();
+    }
+
+    pub(crate) fn set_inbound(&mut self, kind: InboundKind, metadata: &InboundMetadata) {
+        self.inbound = kind;
+        self.selector_metadata = false;
+        self.metadata = metadata.clone();
+    }
+
+    fn inbound_name(&self) -> &'static str {
+        if self.selector_metadata {
+            return "";
+        }
+        match self.inbound {
+            InboundKind::Tun => "DEFAULT-TUN",
+            InboundKind::Http | InboundKind::Https | InboundKind::Socks5 => "DEFAULT-MIXED",
+            InboundKind::InternalDns
+            | InboundKind::InternalGeoData
+            | InboundKind::InternalMeasure => "",
+        }
+    }
+
+    /// A reference selector receives only Host or DstIP. Other fields keep the
+    /// zero values of Mihomo Metadata (TCP/HTTP, port 0 and no ingress name).
+    /// It is not a business HTTP connection and must never acquire an identity.
+    pub(crate) fn selector(destination: &Destination) -> Result<Self, DomainNameError> {
+        let mut context = Self::new(Network::Tcp, destination)?;
+        context.destination_port = 0;
+        context.inbound = InboundKind::Http;
+        context.selector_metadata = true;
+        context.disable_ip_resolution();
+        Ok(context)
+    }
+    pub(crate) fn source_ip(&self) -> Option<IpAddr> {
+        self.source_ip
+    }
+    pub(crate) fn authenticated_user(&self) -> Option<&str> {
+        self.metadata.user.as_deref()
+    }
+    pub(crate) fn enable_process_lookup(&mut self, enabled: bool) {
+        self.process_lookup_enabled = enabled;
+    }
+    pub(crate) fn set_process(&mut self, identity: crate::process::Identity) {
+        self.process = Some(identity);
+    }
+    pub(crate) fn process(&self) -> Option<&crate::process::Identity> {
+        self.process.as_ref()
+    }
+    fn process_identity(&self) -> Result<Option<&crate::process::Identity>, PredicateFailure> {
+        match &self.process {
+            Some(identity) => Ok(Some(identity)),
+            None if self.process_lookup_enabled => Err(PredicateFailure::NeedsProcessLookup),
+            None => Ok(None),
+        }
+    }
+    /// A local rule-provider view only. Host and ingress identity are unchanged.
+    pub(crate) fn swap_source_destination(&mut self) {
+        let source = self.source_ip;
+        self.source_ip = self.effective_ip();
+        self.destination_ip = source;
+        self.pinned_ip = None;
+        std::mem::swap(&mut self.source_port, &mut self.destination_port);
+        self.disable_ip_resolution();
+    }
+
     #[must_use]
     pub const fn network(&self) -> Network {
         self.network
@@ -120,7 +238,7 @@ impl RoutingContext {
     }
 
     #[must_use]
-    fn should_request_ip_resolution(&self) -> bool {
+    pub(crate) fn should_request_ip_resolution(&self) -> bool {
         self.destination_ip.is_none() && self.pinned_ip.is_none() && !self.ip_resolution_unavailable
     }
 }
@@ -211,7 +329,23 @@ pub trait GeoMatcher: Send + Sync {
         true
     }
 
+    fn asn_available(&self) -> bool {
+        false
+    }
+    fn matches_asn(&self, _payload: &str, _address: IpAddr) -> bool {
+        false
+    }
+
     fn matches_geosite(&self, code: &str, domain: &str) -> bool;
+    fn matches_geosite_bounded(
+        &self,
+        code: &str,
+        domain: &str,
+        decision: &crate::config::RuleDecision,
+    ) -> Result<bool, crate::config::MatchFailure> {
+        decision.visit()?;
+        Ok(self.matches_geosite(code, domain))
+    }
     fn matches_geoip(&self, code: &str, address: IpAddr) -> bool;
 }
 
@@ -248,12 +382,17 @@ pub struct RuleMatch {
 pub enum RuleEvaluation {
     Matched(RuleMatch),
     NeedsIpResolution { rule_index: usize },
+    NeedsProcessLookup { rule_index: usize },
     NoMatch,
+    Failed(crate::config::MatchFailure),
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum RuleSetError {
-    Empty,
+    InvalidProgram,
+    InvalidInboundRule {
+        rule_index: usize,
+    },
     TooManyRules {
         count: usize,
         maximum: usize,
@@ -278,16 +417,16 @@ pub enum RuleSetError {
     InvalidPortRange {
         rule_index: usize,
     },
-    MatchNotFinal {
-        rule_index: usize,
-    },
-    MissingFinalMatch,
 }
 
 impl fmt::Display for RuleSetError {
     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Self::Empty => formatter.write_str("routing rules are empty"),
+            Self::InvalidProgram => formatter.write_str("invalid sub-rule program graph"),
+            Self::InvalidInboundRule { rule_index } => write!(
+                formatter,
+                "routing rule {rule_index} has an invalid inbound predicate"
+            ),
             Self::TooManyRules { count, maximum } => {
                 write!(formatter, "routing rule count {count} exceeds {maximum}")
             }
@@ -324,10 +463,6 @@ impl fmt::Display for RuleSetError {
                     "routing rule {rule_index} has an invalid destination port"
                 )
             }
-            Self::MatchNotFinal { rule_index } => {
-                write!(formatter, "MATCH rule {rule_index} is not the final rule")
-            }
-            Self::MissingFinalMatch => formatter.write_str("routing rules do not end in MATCH"),
         }
     }
 }
@@ -337,116 +472,84 @@ impl std::error::Error for RuleSetError {}
 /// An immutable ordered rule set.
 #[derive(Debug, Clone)]
 pub struct RuleSet {
-    rules: Box<[RuleSpec]>,
-    uses_domain_routing: bool,
+    graph: Arc<CompiledProgram>,
+    filter_udp: bool,
 }
 
 impl RuleSet {
     /// Validates and normalizes the ordered rules. This is the only rule-set
-    /// construction path that allocates.
-    pub fn compile(mut rules: Vec<RuleSpec>) -> Result<Self, RuleSetError> {
-        if rules.is_empty() {
-            return Err(RuleSetError::Empty);
-        }
-        if rules.len() > MAX_ROUTING_RULES {
+    /// construction path that allocates during normal routing. Controller
+    /// switches may publish their own bounded snapshot separately.
+    pub fn compile(program: impl Into<RuntimeRuleProgram>) -> Result<Self, RuleSetError> {
+        let mut program = program.into();
+        let count = program
+            .sub_rules
+            .iter()
+            .fold(program.main.len(), |count, sub| {
+                count.saturating_add(sub.rules.len())
+            });
+        if count > MAX_ROUTING_RULES {
             return Err(RuleSetError::TooManyRules {
-                count: rules.len(),
+                count,
                 maximum: MAX_ROUTING_RULES,
             });
         }
-
-        let final_index = rules.len() - 1;
-        let mut text_bytes = 0_usize;
+        let mut text_bytes = 0;
         let mut uses_domain_routing = false;
-        for (index, rule) in rules.iter_mut().enumerate() {
-            uses_domain_routing |= matches!(
-                &rule.kind,
-                RuleKind::Domain(_)
-                    | RuleKind::DomainSuffix(_)
-                    | RuleKind::DomainKeyword(_)
-                    | RuleKind::GeoSite(_)
-            );
-            match &mut rule.kind {
-                RuleKind::Domain(value) | RuleKind::DomainSuffix(value) => {
-                    *value = normalize_domain_name(value).map_err(|source| {
-                        RuleSetError::InvalidDomain {
-                            rule_index: index,
-                            source,
-                        }
-                    })?;
-                    text_bytes = checked_text_bytes(text_bytes, value.len())?;
-                }
-                RuleKind::DomainKeyword(value) => {
-                    if value.is_empty() || !value.is_ascii() {
-                        return Err(RuleSetError::InvalidKeyword { rule_index: index });
-                    }
-                    value.make_ascii_lowercase();
-                    text_bytes = checked_text_bytes(text_bytes, value.len())?;
-                }
-                RuleKind::GeoSite(selector) => {
-                    *selector = crate::geodata::normalize_selector(
-                        crate::geodata::GeoDataKind::GeoSite,
-                        selector,
-                    )
-                    .map_err(|_| RuleSetError::InvalidGeoCode { rule_index: index })?;
-                    text_bytes = checked_text_bytes(text_bytes, selector.len())?;
-                }
-                RuleKind::GeoIp(selector) => {
-                    *selector = crate::geodata::normalize_selector(
-                        crate::geodata::GeoDataKind::GeoIp,
-                        selector,
-                    )
-                    .map_err(|_| RuleSetError::InvalidGeoCode { rule_index: index })?;
-                    text_bytes = checked_text_bytes(text_bytes, selector.len())?;
-                }
-                RuleKind::IpCidr(cidr) => {
-                    if !valid_cidr(cidr) {
-                        return Err(RuleSetError::InvalidCidr { rule_index: index });
-                    }
-                }
-                RuleKind::DstPorts(ranges) => {
-                    if ranges.is_empty()
-                        || ranges
-                            .iter()
-                            .any(|range| range.start == 0 || range.start > range.end)
-                    {
-                        return Err(RuleSetError::InvalidPortRange { rule_index: index });
-                    }
-                }
-                RuleKind::Network(_) => {}
-                RuleKind::Match => {
-                    if index != final_index {
-                        return Err(RuleSetError::MatchNotFinal { rule_index: index });
-                    }
-                }
-            }
+        for sub in &program.sub_rules {
+            text_bytes = checked_text_bytes(text_bytes, sub.name.len())?;
         }
-
-        if !matches!(rules.last().map(|rule| &rule.kind), Some(RuleKind::Match)) {
-            return Err(RuleSetError::MissingFinalMatch);
+        for (index, rule) in program
+            .main
+            .iter_mut()
+            .chain(program.sub_rules.iter_mut().flat_map(|sub| &mut sub.rules))
+            .enumerate()
+        {
+            normalize_rule(rule, index, 0, &mut text_bytes, &mut uses_domain_routing)?;
         }
-
+        crate::config::rules::validate_subrule_calls(&program.main, &program.sub_rules)
+            .map_err(|_| RuleSetError::InvalidProgram)?;
         Ok(Self {
-            rules: rules.into_boxed_slice(),
-            uses_domain_routing,
+            graph: Arc::new(CompiledProgram {
+                disabled: Arc::new(rule_disable::RuleDisable::new(program.main.len())),
+                main: program.main.into_boxed_slice(),
+                sub_rules: program.sub_rules.into_boxed_slice(),
+                uses_domain_routing,
+            }),
+            filter_udp: true,
         })
     }
 
+    #[cfg(any(feature = "invoke", test))]
+    pub(crate) fn compile_config(config: &mut crate::config::Config) -> Result<Self, RuleSetError> {
+        let mut rules = Self::compile(config.take_runtime_rules())?;
+        rules.filter_udp = config.mode == crate::config::Mode::Rule;
+        Ok(rules)
+    }
+
+    pub(crate) fn disable_state(&self) -> &Arc<rule_disable::RuleDisable> {
+        &self.graph.disabled
+    }
+
     #[must_use]
     pub fn len(&self) -> usize {
-        self.rules.len()
+        self.graph.main.len()
     }
 
     #[must_use]
     pub fn is_empty(&self) -> bool {
-        self.rules.is_empty()
+        self.graph.main.is_empty()
+    }
+
+    pub(crate) const fn filters_udp(&self) -> bool {
+        self.filter_udp
     }
 
     /// Whether an IP-based TUN flow can benefit from a sniffed or DNS-derived
     /// domain routing hint.
     #[must_use]
-    pub const fn uses_domain_routing(&self) -> bool {
-        self.uses_domain_routing
+    pub fn uses_domain_routing(&self) -> bool {
+        self.graph.uses_domain_routing
     }
 
     /// Exposes one immutable compiled rule so the asynchronous router can
@@ -454,7 +557,7 @@ impl RuleSet {
     /// [`RuleEvaluation::NeedsIpResolution`].
     #[must_use]
     pub fn rule(&self, index: usize) -> Option<&RuleSpec> {
-        self.rules.get(index)
+        self.graph.main.get(index)
     }
 
     /// Evaluates with no loaded GeoData. GEOSITE and GEOIP never match.
@@ -463,69 +566,53 @@ impl RuleSet {
         self.evaluate_with_geo(context, &EmptyGeoMatcher)
     }
 
-    /// Evaluates from top to bottom and stops at the first match. Rule traversal
-    /// does not allocate; GeoSite regexes may allocate internal search caches.
+    /// Evaluates from top to bottom and stops at the first match. Regular-expression
+    /// engines may allocate internal search state; execution failure is explicit.
     #[must_use]
     pub fn evaluate_with_geo(
         &self,
         context: &RoutingContext,
         geo_matcher: &dyn GeoMatcher,
     ) -> RuleEvaluation {
-        for (index, rule) in self.rules.iter().enumerate() {
-            let matched = match &rule.kind {
-                RuleKind::Domain(expected) => context.domain() == Some(expected.as_str()),
-                RuleKind::DomainSuffix(suffix) => context
-                    .domain()
-                    .is_some_and(|domain| domain_suffix_matches(domain, suffix)),
-                RuleKind::DomainKeyword(keyword) => context
-                    .domain()
-                    .is_some_and(|domain| domain.contains(keyword)),
-                RuleKind::GeoSite(code) => {
-                    geo_matcher.geosite_available(code)
-                        && context
-                            .domain()
-                            .is_some_and(|domain| geo_matcher.matches_geosite(code, domain))
-                }
-                RuleKind::GeoIp(code) => {
-                    if !geo_matcher.geoip_available(code) {
-                        false
-                    } else if let Some(address) = context.effective_ip() {
-                        geo_matcher.matches_geoip(code, address)
-                    } else if !rule.no_resolve && context.should_request_ip_resolution() {
-                        return RuleEvaluation::NeedsIpResolution { rule_index: index };
-                    } else {
-                        false
-                    }
-                }
-                RuleKind::IpCidr(cidr) => {
-                    if let Some(address) = context.effective_ip() {
-                        cidr_contains(cidr, address)
-                    } else if !rule.no_resolve && context.should_request_ip_resolution() {
-                        return RuleEvaluation::NeedsIpResolution { rule_index: index };
-                    } else {
-                        false
-                    }
+        self.evaluate_with_egress(context, geo_matcher, |_| true)
+    }
+
+    pub(crate) fn evaluate_with_egress(
+        &self,
+        context: &RoutingContext,
+        geo: &dyn GeoMatcher,
+        supports_udp: impl Fn(RuleAction) -> bool,
+    ) -> RuleEvaluation {
+        self.evaluate_program(
+            &mut context.clone(),
+            geo,
+            None,
+            None,
+            |action, candidate| {
+                if self.accepts_egress(candidate, action, &supports_udp) {
+                    RuleTargetEffect::Accept
+                } else {
+                    RuleTargetEffect::Skip
                 }
-                RuleKind::DstPorts(ranges) => ranges.iter().any(|range| {
-                    range.start <= context.destination_port && context.destination_port <= range.end
-                }),
-                RuleKind::Network(network) => *network == context.network,
-                RuleKind::Match => true,
-            };
+            },
+        )
+        .into_public()
+    }
 
-            if matched {
-                return RuleEvaluation::Matched(RuleMatch {
-                    action: rule.action,
-                    rule_index: index,
-                });
-            }
-        }
-        RuleEvaluation::NoMatch
+    pub(crate) fn all_rules(&self) -> impl Iterator<Item = &RuleSpec> {
+        self.graph
+            .main
+            .iter()
+            .chain(self.graph.sub_rules.iter().flat_map(|sub| &sub.rules))
+    }
+    pub(crate) fn subrule_name(&self, id: crate::config::SubRuleId) -> &str {
+        &self.graph.sub_rules[id.index()].name
     }
 
     /// Continues evaluation at the IP rule which requested a bounded
     /// runtime-DNS result. Rules before `resolution_rule_index` have already
-    /// failed and are not revisited. This matches Mihomo's `no-resolve`
+    /// failed and are not revisited. Retain the original context to share the
+    /// remaining execution budget across this continuation. This matches Mihomo's `no-resolve`
     /// semantics: the flag prevents a rule from initiating DNS, while later
     /// `no-resolve` rules may still consume an address resolved by an earlier
     /// rule.
@@ -546,61 +633,375 @@ impl RuleSet {
         resolution_rule_index: usize,
         addresses: &[IpAddr],
     ) -> RuleEvaluation {
-        for (index, rule) in self.rules.iter().enumerate().skip(resolution_rule_index) {
-            let mut selected_address = None;
-            let matched = match &rule.kind {
-                RuleKind::Domain(expected) => context.domain() == Some(expected.as_str()),
-                RuleKind::DomainSuffix(suffix) => context
-                    .domain()
-                    .is_some_and(|domain| domain_suffix_matches(domain, suffix)),
-                RuleKind::DomainKeyword(keyword) => context
-                    .domain()
-                    .is_some_and(|domain| domain.contains(keyword)),
-                RuleKind::GeoSite(code) => {
-                    geo_matcher.geosite_available(code)
-                        && context
-                            .domain()
-                            .is_some_and(|domain| geo_matcher.matches_geosite(code, domain))
-                }
-                RuleKind::GeoIp(code) => {
-                    if !geo_matcher.geoip_available(code) {
-                        false
-                    } else if let Some(address) = context.effective_ip() {
-                        geo_matcher.matches_geoip(code, address)
-                    } else {
-                        selected_address = preferred_addresses(addresses)
-                            .find(|address| geo_matcher.matches_geoip(code, *address));
-                        selected_address.is_some()
-                    }
+        self.evaluate_with_resolved_egress(
+            context,
+            geo_matcher,
+            resolution_rule_index,
+            addresses,
+            |_| true,
+        )
+    }
+
+    pub(crate) fn evaluate_with_resolved_egress(
+        &self,
+        context: &mut RoutingContext,
+        geo: &dyn GeoMatcher,
+        index: usize,
+        addresses: &[IpAddr],
+        supports_udp: impl Fn(RuleAction) -> bool,
+    ) -> RuleEvaluation {
+        self.flat_resolved(context, geo, index, addresses, |action, candidate| {
+            if self.accepts_egress(candidate, action, &supports_udp) {
+                RuleTargetEffect::Accept
+            } else {
+                RuleTargetEffect::Skip
+            }
+        })
+    }
+
+    fn accepts_egress(
+        &self,
+        context: &RoutingContext,
+        action: RuleAction,
+        supports_udp: &impl Fn(RuleAction) -> bool,
+    ) -> bool {
+        !self.filter_udp || context.network != Network::Udp || supports_udp(action)
+    }
+}
+
+fn normalize_rule(
+    rule: &mut RuleSpec,
+    index: usize,
+    depth: usize,
+    bytes: &mut usize,
+    domain: &mut bool,
+) -> Result<(), RuleSetError> {
+    if depth > 32 {
+        return Err(RuleSetError::TooManyRules {
+            count: depth,
+            maximum: 32,
+        });
+    }
+    match &mut rule.kind {
+        RuleKind::RuleSet { content, .. } => {
+            *domain |= content.as_ref().is_some_and(|set| set.uses_domain());
+        }
+        RuleKind::Domain(value) | RuleKind::DomainSuffix(value) => {
+            *value =
+                normalize_domain_name(value).map_err(|source| RuleSetError::InvalidDomain {
+                    rule_index: index,
+                    source,
+                })?;
+            *bytes = checked_text_bytes(*bytes, value.len())?;
+            *domain = true;
+        }
+        RuleKind::DomainKeyword(value) | RuleKind::DomainWildcard(value) => {
+            if value.is_empty() {
+                return Err(RuleSetError::InvalidKeyword { rule_index: index });
+            }
+            value.make_ascii_lowercase();
+            *bytes = checked_text_bytes(*bytes, value.len())?;
+            *domain = true;
+        }
+        RuleKind::DomainRegex(value) => {
+            *bytes = checked_text_bytes(*bytes, value.as_str().len())?;
+            *domain = true;
+        }
+        RuleKind::GeoSite(value) => {
+            *value =
+                crate::geodata::normalize_selector(crate::geodata::GeoDataKind::GeoSite, value)
+                    .map_err(|_| RuleSetError::InvalidGeoCode { rule_index: index })?;
+            *bytes = checked_text_bytes(*bytes, value.len())?;
+            *domain = true;
+        }
+        RuleKind::GeoIp(value) | RuleKind::SrcGeoIp(value) => {
+            *value = crate::geodata::normalize_selector(crate::geodata::GeoDataKind::GeoIp, value)
+                .map_err(|_| RuleSetError::InvalidGeoCode { rule_index: index })?;
+            *bytes = checked_text_bytes(*bytes, value.len())?;
+        }
+        RuleKind::IpAsn(value) | RuleKind::SrcIpAsn(value) => {
+            *bytes = checked_text_bytes(*bytes, value.len())?;
+        }
+        RuleKind::IpSuffix(value) | RuleKind::SrcIpSuffix(value) => {
+            *bytes = checked_text_bytes(*bytes, value.as_str().len())?;
+        }
+        RuleKind::IpCidr(cidr) | RuleKind::SrcIpCidr(cidr) => {
+            if !valid_cidr(cidr) {
+                return Err(RuleSetError::InvalidCidr { rule_index: index });
+            }
+        }
+        RuleKind::DstPorts(ranges) | RuleKind::SrcPorts(ranges) | RuleKind::InPorts(ranges) => {
+            if ranges.is_empty()
+                || ranges.len() > 28
+                || ranges.iter().any(|range| range.start > range.end)
+            {
+                return Err(RuleSetError::InvalidPortRange { rule_index: index });
+            }
+        }
+        RuleKind::InNames(users) | RuleKind::InUsers(users) | RuleKind::RematchNames(users) => {
+            if users.is_empty() || users.iter().any(|user| user.is_empty()) {
+                return Err(RuleSetError::InvalidInboundRule { rule_index: index });
+            }
+            for user in users {
+                *bytes = checked_text_bytes(*bytes, user.len())?;
+            }
+        }
+        RuleKind::Process(value) => {
+            *bytes = checked_text_bytes(*bytes, value.pattern.len())?;
+        }
+        RuleKind::Uid(ranges) => {
+            if ranges.is_empty()
+                || ranges.len() > 28
+                || ranges.iter().any(|range| range.start > range.end)
+            {
+                return Err(RuleSetError::InvalidInboundRule { rule_index: index });
+            }
+        }
+        RuleKind::InTypes(types) => {
+            if types.is_empty() {
+                return Err(RuleSetError::InvalidInboundRule { rule_index: index });
+            }
+            for kind in types {
+                *bytes = checked_text_bytes(*bytes, kind.name().len())?;
+            }
+        }
+        RuleKind::And(children) | RuleKind::Or(children) => {
+            for child in children {
+                normalize_rule(child, index, depth + 1, bytes, domain)?;
+            }
+        }
+        RuleKind::Not(child) => normalize_rule(child, index, depth + 1, bytes, domain)?,
+        RuleKind::Flow { predicate, .. } | RuleKind::SubRule { predicate, .. } => {
+            normalize_rule(predicate, index, depth, bytes, domain)?
+        }
+        RuleKind::Network(_) | RuleKind::Match => {}
+    }
+    Ok(())
+}
+
+pub(crate) fn uses_destination_ip(rule: &RuleSpec) -> bool {
+    match &rule.kind {
+        RuleKind::RuleSet {
+            content, source, ..
+        } => !source && content.as_ref().is_some_and(|set| set.uses_ip()),
+        RuleKind::IpCidr(_) | RuleKind::IpSuffix(_) | RuleKind::GeoIp(_) | RuleKind::IpAsn(_) => {
+            true
+        }
+        RuleKind::And(children) | RuleKind::Or(children) => {
+            children.iter().any(uses_destination_ip)
+        }
+        RuleKind::Not(child)
+        | RuleKind::Flow {
+            predicate: child, ..
+        }
+        | RuleKind::SubRule {
+            predicate: child, ..
+        } => uses_destination_ip(child),
+        _ => false,
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum PredicateFailure {
+    NeedsIpResolution,
+    NeedsProcessLookup,
+    Evaluation(crate::config::MatchFailure),
+}
+impl From<crate::config::MatchFailure> for PredicateFailure {
+    fn from(error: crate::config::MatchFailure) -> Self {
+        Self::Evaluation(error)
+    }
+}
+
+// NeedsIpResolution means this exact traversal requires one lazy DNS resolution. Short
+// circuiting keeps later IP predicates from triggering unnecessary queries.
+pub(crate) fn matches_rule(
+    rule: &RuleSpec,
+    context: &RoutingContext,
+    geo: &dyn GeoMatcher,
+) -> Result<bool, PredicateFailure> {
+    context.decision.visit()?;
+    let port_matches = |ranges: &[crate::config::PortRange], port| {
+        ranges
+            .iter()
+            .any(|range| range.start <= port && port <= range.end)
+    };
+    Ok(match &rule.kind {
+        RuleKind::RuleSet {
+            content, source, ..
+        } => match content {
+            Some(set) => set.matches(context, geo, rule.no_resolve, *source)?,
+            None => false,
+        },
+        RuleKind::Domain(value) => context.domain() == Some(value.as_str()),
+        RuleKind::DomainSuffix(value) => context
+            .domain()
+            .is_some_and(|domain| domain_suffix_matches(domain, value)),
+        RuleKind::DomainKeyword(value) => context
+            .domain()
+            .is_some_and(|domain| domain.contains(value)),
+        RuleKind::DomainWildcard(value) => context
+            .domain()
+            .is_some_and(|domain| wildcard_matches(value, domain)),
+        RuleKind::DomainRegex(value) => match context.domain() {
+            Some(domain) => value.is_match(domain, &context.decision)?,
+            None => false,
+        },
+        RuleKind::GeoSite(code) => {
+            if geo.geosite_available(code)
+                && let Some(domain) = context.domain()
+            {
+                geo.matches_geosite_bounded(code, domain, &context.decision)?
+            } else {
+                false
+            }
+        }
+        RuleKind::GeoIp(code) => {
+            if !geoip_available(geo, code) {
+                false
+            } else if let Some(address) = context.effective_ip() {
+                matches_geoip(geo, code, address)
+            } else if !rule.no_resolve && context.should_request_ip_resolution() {
+                return Err(PredicateFailure::NeedsIpResolution);
+            } else {
+                false
+            }
+        }
+        RuleKind::IpAsn(payload) => {
+            if !geo.asn_available() {
+                false
+            } else if let Some(address) = context.effective_ip() {
+                geo.matches_asn(payload, address)
+            } else if !rule.no_resolve && context.should_request_ip_resolution() {
+                return Err(PredicateFailure::NeedsIpResolution);
+            } else {
+                false
+            }
+        }
+        RuleKind::SrcIpAsn(payload) => {
+            geo.asn_available()
+                && context
+                    .source_ip
+                    .is_some_and(|address| geo.matches_asn(payload, address))
+        }
+        RuleKind::IpCidr(cidr) => {
+            if let Some(address) = context.effective_ip() {
+                cidr_contains(cidr, address)
+            } else if !rule.no_resolve && context.should_request_ip_resolution() {
+                return Err(PredicateFailure::NeedsIpResolution);
+            } else {
+                false
+            }
+        }
+        RuleKind::IpSuffix(value) => {
+            if let Some(address) = context.effective_ip() {
+                value.matches(address)
+            } else if !rule.no_resolve && context.should_request_ip_resolution() {
+                return Err(PredicateFailure::NeedsIpResolution);
+            } else {
+                false
+            }
+        }
+        RuleKind::SrcIpSuffix(value) => context
+            .source_ip
+            .is_some_and(|address| value.matches(address)),
+        RuleKind::SrcGeoIp(code) => {
+            geoip_available(geo, code)
+                && context
+                    .source_ip
+                    .is_some_and(|address| matches_geoip(geo, code, address))
+        }
+        RuleKind::SrcIpCidr(cidr) => context.source_ip.is_some_and(|ip| cidr_contains(cidr, ip)),
+        RuleKind::SrcPorts(ranges) => port_matches(ranges, context.source_port),
+        RuleKind::InTypes(types) => types.contains(&crate::config::RuleInboundType::for_inbound(
+            context.inbound,
+        )),
+        RuleKind::InNames(names) => names.iter().any(|name| name == context.inbound_name()),
+        RuleKind::InUsers(users) => context
+            .authenticated_user()
+            .is_some_and(|user| users.iter().any(|expected| expected == user)),
+        RuleKind::Process(rule) => match context.process_identity()? {
+            Some(identity) => match match rule.field {
+                crate::config::ProcessField::Name => identity.name.as_deref(),
+                crate::config::ProcessField::Path => identity.path.as_deref(),
+            } {
+                Some(value) => rule.matches(value, context.decision())?,
+                None => false,
+            },
+            None => false,
+        },
+        RuleKind::Uid(ranges) => context
+            .process_identity()?
+            .and_then(|identity| identity.uid)
+            .filter(|uid| *uid != 0)
+            .is_some_and(|uid| {
+                ranges
+                    .iter()
+                    .any(|range| range.start <= uid && uid <= range.end)
+            }),
+        RuleKind::InPorts(ranges) => port_matches(ranges, context.metadata.local_port),
+        RuleKind::DstPorts(ranges) => port_matches(ranges, context.destination_port),
+        RuleKind::Network(network) => *network == context.network,
+        RuleKind::And(children) => {
+            for child in children {
+                if !matches_rule(child, context, geo)? {
+                    return Ok(false);
                 }
-                RuleKind::IpCidr(cidr) => {
-                    if let Some(address) = context.effective_ip() {
-                        cidr_contains(cidr, address)
-                    } else {
-                        selected_address = preferred_addresses(addresses)
-                            .find(|address| cidr_contains(cidr, *address));
-                        selected_address.is_some()
-                    }
+            }
+            true
+        }
+        RuleKind::Or(children) => {
+            for child in children {
+                if matches_rule(child, context, geo)? {
+                    return Ok(true);
                 }
-                RuleKind::DstPorts(ranges) => ranges.iter().any(|range| {
-                    range.start <= context.destination_port && context.destination_port <= range.end
-                }),
-                RuleKind::Network(network) => *network == context.network,
-                RuleKind::Match => true,
-            };
+            }
+            false
+        }
+        RuleKind::Not(child) => !matches_rule(child, context, geo)?,
+        RuleKind::RematchNames(names) => context
+            .rematch_name
+            .as_deref()
+            .is_some_and(|mark| names.iter().any(|name| name == mark)),
+        RuleKind::Match => true,
+        RuleKind::Flow { predicate, .. } | RuleKind::SubRule { predicate, .. } => {
+            matches_rule(predicate, context, geo)?
+        }
+    })
+}
 
-            if matched {
-                if let Some(address) = selected_address {
-                    context.pin_ip(address);
-                }
-                return RuleEvaluation::Matched(RuleMatch {
-                    action: rule.action,
-                    rule_index: index,
-                });
+fn geoip_available(geo: &dyn GeoMatcher, code: &str) -> bool {
+    crate::geodata::lan_selector(code) || geo.geoip_available(code)
+}
+fn matches_geoip(geo: &dyn GeoMatcher, code: &str, ip: IpAddr) -> bool {
+    crate::geodata::matches_lan(code, ip).unwrap_or_else(|| geo.matches_geoip(code, ip))
+}
+
+fn wildcard_matches(pattern: &str, value: &str) -> bool {
+    let (pattern, value) = (pattern.as_bytes(), value.as_bytes());
+    let (mut p, mut v) = (0, 0);
+    let mut retry = None;
+    while v < value.len() {
+        match pattern.get(p) {
+            Some(b'*') => {
+                retry = Some((p + 1, v));
+                p += 1;
             }
+            Some(byte) if *byte == b'?' || *byte == value[v] => {
+                p += 1;
+                v += 1;
+            }
+            _ => match retry {
+                Some((after_star, consumed)) => {
+                    v = consumed + 1;
+                    p = after_star;
+                    retry = Some((p, v));
+                }
+                None => return false,
+            },
         }
-        RuleEvaluation::NoMatch
     }
+    pattern[p..].iter().all(|byte| *byte == b'*')
 }
 
 fn preferred_addresses(addresses: &[IpAddr]) -> impl Iterator<Item = IpAddr> + '_ {
@@ -687,6 +1088,83 @@ mod tests {
         ))
     }
 
+    #[test]
+    fn in_name_uses_actual_tun_or_mixed_ingress_without_naming_internal_requests() {
+        let mut config = crate::config::Config::parse_yaml(
+            b"rules: ['IN-NAME, ignored / DEFAULT-TUN ,DIRECT', 'IN-NAME,DEFAULT-MIXED,REJECT-DROP', 'MATCH,REJECT']\n",
+        )
+        .unwrap();
+        let rules = RuleSet::compile_config(&mut config).unwrap();
+        let destination = Destination::domain("example.test", 443).unwrap();
+        for (kind, expected) in [
+            (InboundKind::Tun, RuleAction::Direct),
+            (InboundKind::Http, RuleAction::RejectDrop),
+            (InboundKind::Https, RuleAction::RejectDrop),
+            (InboundKind::Socks5, RuleAction::RejectDrop),
+            (InboundKind::InternalDns, RuleAction::Reject),
+            (InboundKind::InternalGeoData, RuleAction::Reject),
+            (InboundKind::InternalMeasure, RuleAction::Reject),
+        ] {
+            for network in [Network::Tcp, Network::Udp] {
+                let mut context = RoutingContext::new(network, &destination).unwrap();
+                context.set_inbound(kind, &InboundMetadata::new(0));
+                assert!(
+                    matches!(rules.evaluate(&context), RuleEvaluation::Matched(found) if found.action == expected)
+                );
+            }
+        }
+        let lower_case = crate::config::Config::parse_yaml(
+            b"rules: ['IN-NAME,default-tun,DIRECT', 'MATCH,REJECT']\n",
+        )
+        .unwrap();
+        let rules = RuleSet::compile(lower_case.rules).unwrap();
+        let mut context = RoutingContext::new(Network::Tcp, &destination).unwrap();
+        context.set_inbound(InboundKind::Tun, &InboundMetadata::new(0));
+        assert!(
+            matches!(rules.evaluate(&context), RuleEvaluation::Matched(found) if found.action == RuleAction::Reject)
+        );
+        assert!(
+            crate::config::Config::parse_yaml(b"rules: ['IN-NAME,DEFAULT-TUN / ,DIRECT']\n")
+                .is_err()
+        );
+    }
+
+    #[test]
+    fn rematch_name_predicate_is_trimmed_nonempty_and_case_sensitive() {
+        let mut config = crate::config::Config::parse_yaml(
+            b"rules: ['REMATCH-NAME, blue / Green ,DIRECT', 'MATCH,REJECT']\n",
+        )
+        .unwrap();
+        let rules = RuleSet::compile_config(&mut config).unwrap();
+        let mut context = domain_context(Network::Tcp, "example.com", 443);
+        assert!(matches!(
+            rules.evaluate(&context),
+            RuleEvaluation::Matched(RuleMatch {
+                action: RuleAction::Reject,
+                ..
+            })
+        ));
+        for (name, action) in [
+            ("blue", RuleAction::Direct),
+            ("Green", RuleAction::Direct),
+            ("Blue", RuleAction::Reject),
+            ("", RuleAction::Reject),
+        ] {
+            context.rematch_name = Some(Arc::from(name));
+            assert!(
+                matches!(rules.evaluate(&context), RuleEvaluation::Matched(found) if found.action == action)
+            );
+        }
+        for names in ["blue/", "/blue", "blue/ /Green"] {
+            assert!(
+                crate::config::Config::parse_yaml(
+                    format!("rules: ['REMATCH-NAME,{names},DIRECT']").as_bytes()
+                )
+                .is_err()
+            );
+        }
+    }
+
     fn domain_context(network: Network, host: &str, port: u16) -> RoutingContext {
         let destination = Destination::domain(host, port).unwrap();
         RoutingContext::new(network, &destination).unwrap()
@@ -711,10 +1189,10 @@ mod tests {
         ])
         .unwrap();
         assert_eq!(
-            rules.rules[0].kind,
+            rules.graph.main[0].kind,
             RuleKind::GeoSite("!google@ads@cn".to_owned())
         );
-        assert_eq!(rules.rules[1].kind, RuleKind::GeoIp("!cn".to_owned()));
+        assert_eq!(rules.graph.main[1].kind, RuleKind::GeoIp("!cn".to_owned()));
         assert!(
             RuleSet::compile(vec![
                 spec(RuleKind::GeoIp("cn@ads".to_owned()), RuleAction::Direct),
@@ -724,6 +1202,37 @@ mod tests {
         );
     }
 
+    #[test]
+    fn udp_capability_filter_continues_after_ip_resolution() {
+        let rules = RuleSet::compile(vec![
+            spec(
+                RuleKind::IpCidr(IpCidr {
+                    network: "192.0.2.0".parse().unwrap(),
+                    prefix_len: 24,
+                }),
+                proxy_action(0),
+            ),
+            spec(RuleKind::Match, RuleAction::Reject),
+        ])
+        .unwrap();
+        let mut context = domain_context(Network::Udp, "example.com", 53);
+        let available = |action| action != proxy_action(0);
+        assert!(matches!(
+            rules.evaluate_with_egress(&context, &EmptyGeoMatcher, available),
+            RuleEvaluation::NeedsIpResolution { rule_index: 0 }
+        ));
+        assert_eq!(
+            action(rules.evaluate_with_resolved_egress(
+                &mut context,
+                &EmptyGeoMatcher,
+                0,
+                &["192.0.2.1".parse().unwrap()],
+                available
+            )),
+            RuleAction::Reject
+        );
+    }
+
     #[test]
     fn first_matching_rule_wins() {
         let rules = RuleSet::compile(vec![
@@ -862,13 +1371,23 @@ mod tests {
             action(rules.evaluate(&domain_context(Network::Tcp, "example.com", 443))),
             RuleAction::Direct
         );
-        assert!(matches!(
-            RuleSet::compile(vec![spec(
-                RuleKind::Domain("example.com".to_owned()),
-                RuleAction::Direct,
-            )]),
-            Err(RuleSetError::MissingFinalMatch)
-        ));
+        let rules = RuleSet::compile(vec![spec(
+            RuleKind::Domain("example.com".to_owned()),
+            RuleAction::Reject,
+        )])
+        .unwrap();
+        assert_eq!(
+            action(rules.evaluate(&domain_context(Network::Tcp, "other.example", 443))),
+            RuleAction::Direct
+        );
+        assert_eq!(
+            action(RuleSet::compile(vec![]).unwrap().evaluate(&domain_context(
+                Network::Tcp,
+                "other.example",
+                443
+            ))),
+            RuleAction::Direct
+        );
     }
 
     #[test]
diff --git a/src/routing/program.rs b/src/routing/program.rs
new file mode 100644
index 0000000..18a7c19
--- /dev/null
+++ b/src/routing/program.rs
@@ -0,0 +1,880 @@
+//! Immutable programs and bounded resumable rule traversal.
+use std::{net::IpAddr, sync::Arc};
+
+use super::{
+    GeoMatcher, RoutingContext, RuleEvaluation, RuleMatch, RuleSet, matches_rule,
+    preferred_addresses, uses_destination_ip,
+};
+use crate::config::{NamedRuleProgram, RuleAction, RuleControl, RuleKind, RuleSpec};
+
+#[derive(Debug)]
+pub(super) struct CompiledProgram {
+    pub main: Box<[RuleSpec]>,
+    pub sub_rules: Box<[NamedRuleProgram]>,
+    pub uses_domain_routing: bool,
+    pub disabled: Arc<super::rule_disable::RuleDisable>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+struct Frame {
+    program: usize,
+    index: usize,
+    address: Option<IpAddr>,
+}
+
+/// Pauses only the current predicate; completed controls and groups are not replayed.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct RuleCursor {
+    frames: [Frame; 33],
+    depth: usize,
+    disabled: super::rule_disable::Snapshot,
+    rematch: Option<Box<super::rematch::RematchCursor>>,
+}
+
+impl RuleCursor {
+    fn new(index: usize, disabled: super::rule_disable::Snapshot) -> Self {
+        let frame = Frame {
+            program: 0,
+            index: 0,
+            address: None,
+        };
+        let mut frames = [frame; 33];
+        frames[0].index = index;
+        Self {
+            frames,
+            depth: 0,
+            disabled,
+            rematch: None,
+        }
+    }
+    pub(crate) fn root_index(&self) -> usize {
+        if self.frames[0].program == 0 {
+            self.frames[0].index
+        } else {
+            self.rematch
+                .as_ref()
+                .map_or(usize::MAX, |state| state.unlisted_index)
+        }
+    }
+}
+
+// The fixed cursor is inline; ordinary decisions do not allocate a call stack.
+#[allow(clippy::large_enum_variant)]
+pub(crate) enum ProgramEvaluation {
+    Matched(RuleMatch),
+    NeedsIpResolution(RuleCursor),
+    NeedsProcessLookup(RuleCursor),
+    Failed(crate::config::MatchFailure),
+}
+
+impl ProgramEvaluation {
+    pub(crate) fn into_public(self) -> RuleEvaluation {
+        match self {
+            Self::Failed(failure) => RuleEvaluation::Failed(failure),
+            Self::Matched(matched) => RuleEvaluation::Matched(matched),
+            Self::NeedsIpResolution(cursor) => RuleEvaluation::NeedsIpResolution {
+                rule_index: cursor.root_index(),
+            },
+            Self::NeedsProcessLookup(cursor) => RuleEvaluation::NeedsProcessLookup {
+                rule_index: cursor.root_index(),
+            },
+        }
+    }
+}
+
+pub(crate) enum RuleTargetEffect {
+    Accept,
+    Skip,
+    Control(RuleControl),
+    Rematch(Arc<super::rematch::RematchTarget>),
+}
+
+impl RuleSet {
+    pub(crate) fn evaluate_program(
+        &self,
+        context: &mut RoutingContext,
+        geo: &dyn GeoMatcher,
+        cursor: Option<RuleCursor>,
+        addresses: Option<&[IpAddr]>,
+        mut effect: impl FnMut(RuleAction, &RoutingContext) -> RuleTargetEffect,
+    ) -> ProgramEvaluation {
+        let mut cursor =
+            cursor.unwrap_or_else(|| RuleCursor::new(0, self.graph.disabled.snapshot()));
+        loop {
+            if let Err(failure) = context.decision().check() {
+                return ProgramEvaluation::Failed(failure);
+            }
+            let frame = cursor.frames[cursor.depth];
+            if frame.program == 0 && cursor.disabled.contains(frame.index) {
+                cursor.frames[0].index += 1;
+                continue;
+            }
+            let rules = if frame.program == 0 {
+                &self.graph.main[..]
+            } else {
+                &self.graph.sub_rules[frame.program - 1].rules[..]
+            };
+            let Some(rule) = rules.get(frame.index) else {
+                if cursor.depth == 0 {
+                    return ProgramEvaluation::Matched(RuleMatch {
+                        action: RuleAction::Direct,
+                        rule_index: self.len(),
+                    });
+                }
+                cursor.depth -= 1;
+                cursor.frames[cursor.depth].index += 1;
+                continue;
+            };
+            let predicate = match &rule.kind {
+                RuleKind::Flow { predicate, .. } | RuleKind::SubRule { predicate, .. } => predicate,
+                _ => rule,
+            };
+            let mut candidate = context.clone();
+            if let Some(address) = frame.address {
+                candidate.pin_ip(address);
+            }
+            let matched = if candidate.effective_ip().is_none()
+                && uses_destination_ip(predicate)
+                && let Some(addresses) = addresses
+                && !addresses.is_empty()
+            {
+                let mut found = None;
+                for address in preferred_addresses(addresses) {
+                    candidate.pin_ip(address);
+                    match matches_rule(predicate, &candidate, geo) {
+                        Ok(true) => {
+                            found = Some(address);
+                            break;
+                        }
+                        Ok(false) | Err(super::PredicateFailure::NeedsIpResolution) => {}
+                        Err(super::PredicateFailure::NeedsProcessLookup) => {
+                            return ProgramEvaluation::NeedsProcessLookup(cursor);
+                        }
+                        Err(super::PredicateFailure::Evaluation(failure)) => {
+                            return ProgramEvaluation::Failed(failure);
+                        }
+                    }
+                }
+                if let Some(address) = found {
+                    candidate.pin_ip(address);
+                    true
+                } else {
+                    false
+                }
+            } else {
+                if addresses.is_some() {
+                    candidate.mark_ip_resolution_unavailable();
+                }
+                match matches_rule(predicate, &candidate, geo) {
+                    Ok(matched) => matched,
+                    Err(super::PredicateFailure::NeedsIpResolution) => {
+                        return ProgramEvaluation::NeedsIpResolution(cursor);
+                    }
+                    Err(super::PredicateFailure::NeedsProcessLookup) => {
+                        return ProgramEvaluation::NeedsProcessLookup(cursor);
+                    }
+                    Err(super::PredicateFailure::Evaluation(failure)) => {
+                        return ProgramEvaluation::Failed(failure);
+                    }
+                }
+            };
+            if !matched {
+                cursor.frames[cursor.depth].index += 1;
+                continue;
+            }
+            let effect = match &rule.kind {
+                RuleKind::Flow { control, .. } => RuleTargetEffect::Control(*control),
+                RuleKind::SubRule { target, .. } => {
+                    cursor.depth += 1;
+                    cursor.frames[cursor.depth] = Frame {
+                        program: target.index() + 1,
+                        index: 0,
+                        address: candidate.pinned_ip(),
+                    };
+                    continue;
+                }
+                _ => effect(rule.action, &candidate),
+            };
+            match effect {
+                RuleTargetEffect::Rematch(target) => {
+                    let state = cursor.rematch.get_or_insert_with(|| {
+                        Box::new(super::rematch::RematchCursor::new(self.len()))
+                    });
+                    if let Err(failure) = state.enter(&target.name, context.decision()) {
+                        return ProgramEvaluation::Failed(failure);
+                    }
+                    // Retain addresses, source, identity, budget and deadline from
+                    // the predicate that actually selected this control.
+                    *context = candidate;
+                    if let Some(name) = &target.config.target_rematch_name {
+                        context.rematch_name = (!name.is_empty()).then(|| name.clone());
+                    }
+                    let program = if let Some(name) = &target.config.target_sub_rule {
+                        match self.rematch_program(name, context.decision()) {
+                            Ok(program) => program,
+                            Err(failure) => return ProgramEvaluation::Failed(failure),
+                        }
+                    } else {
+                        cursor.frames[0].program
+                    };
+                    cursor.depth = 0;
+                    cursor.frames[0] = Frame {
+                        program,
+                        index: 0,
+                        address: None,
+                    };
+                    // Keep the original D07 switch snapshot across every restart.
+                }
+                RuleTargetEffect::Control(RuleControl::Pass) => {
+                    cursor.depth = 0;
+                    cursor.frames[0].index += 1;
+                }
+                RuleTargetEffect::Control(RuleControl::PassRule) if cursor.depth == 0 => {
+                    return ProgramEvaluation::Matched(RuleMatch {
+                        action: RuleAction::Reject,
+                        rule_index: cursor.root_index(),
+                    });
+                }
+                RuleTargetEffect::Skip | RuleTargetEffect::Control(RuleControl::PassRule) => {
+                    cursor.frames[cursor.depth].index += 1
+                }
+                RuleTargetEffect::Accept => {
+                    if let Some(address) = candidate.pinned_ip() {
+                        context.pin_ip(address);
+                    }
+                    return ProgramEvaluation::Matched(RuleMatch {
+                        action: rule.action,
+                        rule_index: cursor.root_index(),
+                    });
+                }
+            }
+        }
+    }
+
+    fn rematch_program(
+        &self,
+        name: &str,
+        decision: &crate::config::RuleDecision,
+    ) -> Result<usize, crate::config::MatchFailure> {
+        if !name.is_empty() {
+            for (index, program) in self.graph.sub_rules.iter().enumerate() {
+                decision.visit()?;
+                if program.name == name {
+                    return Ok(index + 1);
+                }
+            }
+        }
+        Ok(0)
+    }
+
+    pub(super) fn flat_resolved(
+        &self,
+        context: &mut RoutingContext,
+        geo: &dyn GeoMatcher,
+        index: usize,
+        addresses: &[IpAddr],
+        effect: impl FnMut(RuleAction, &RoutingContext) -> RuleTargetEffect,
+    ) -> RuleEvaluation {
+        self.evaluate_program(
+            context,
+            geo,
+            Some(RuleCursor::new(index, self.graph.disabled.snapshot())),
+            Some(addresses),
+            effect,
+        )
+        .into_public()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        config::{Config, Network, RuntimeRuleProgram},
+        routing::EmptyGeoMatcher,
+        session::Destination,
+    };
+
+    fn compile(yaml: &str) -> RuleSet {
+        let mut config =
+            Config::parse_yaml(format!("mixed-port: 1080\n{yaml}").as_bytes()).unwrap();
+        RuleSet::compile_config(&mut config).unwrap()
+    }
+    fn context() -> RoutingContext {
+        RoutingContext::new(
+            Network::Tcp,
+            &Destination::domain("example.com", 443).unwrap(),
+        )
+        .unwrap()
+    }
+
+    fn rematch_fixture(yaml: &str) -> (RuleSet, super::super::RematchTargets) {
+        let mut config = Config::parse_yaml(yaml.as_bytes()).unwrap();
+        let targets = super::super::RematchTargets::new(&config.proxies);
+        (RuleSet::compile_config(&mut config).unwrap(), targets)
+    }
+
+    fn rematch_effect(
+        targets: &super::super::RematchTargets,
+        action: RuleAction,
+    ) -> RuleTargetEffect {
+        if let RuleAction::Route(crate::config::RouteTargetId::Proxy(id)) = action
+            && let Some(target) = targets.get(id)
+        {
+            return RuleTargetEffect::Rematch(target.clone());
+        }
+        RuleTargetEffect::Accept
+    }
+
+    #[test]
+    fn rematch_sets_clears_and_preserves_metadata_and_selects_root_programs() {
+        let cases = [
+            // A selected child root has no row in GET /rules. Its hit must use
+            // the existing sentinel, even when child index equals a main index.
+            (
+                r#"
+proxies:
+  - {name: mark, type: rematch, target-rematch-name: phase}
+  - {name: clear, type: rematch, target-rematch-name: '', target-sub-rule: clean}
+rules: ['REMATCH-NAME,phase,clear', 'MATCH,mark']
+sub-rules:
+  clean: ['NOT,((REMATCH-NAME,phase)),DIRECT', 'MATCH,REJECT']
+"#,
+                2,
+                None,
+            ),
+            // Omitting the sub-rule preserves the selected root; omitting the
+            // name on a subsequent control preserves the mark.
+            (
+                r#"
+proxies:
+  - {name: mark, type: rematch, target-rematch-name: phase, target-sub-rule: first}
+  - {name: retag, type: rematch, target-rematch-name: done}
+  - {name: jump, type: rematch, target-sub-rule: last}
+rules: ['MATCH,mark']
+sub-rules:
+  first: ['REMATCH-NAME,phase,retag', 'REMATCH-NAME,done,jump', 'MATCH,REJECT']
+  last: ['REMATCH-NAME,done,DIRECT', 'MATCH,REJECT']
+"#,
+                1,
+                Some("done"),
+            ),
+            (
+                r#"
+proxies: [{name: jump, type: rematch, target-rematch-name: phase, target-sub-rule: missing}]
+rules: ['REMATCH-NAME,phase,DIRECT', 'MATCH,jump']
+"#,
+                0,
+                Some("phase"),
+            ),
+            (
+                r#"
+proxies: [{name: jump, type: rematch, target-rematch-name: phase, target-sub-rule: ''}]
+rules: ['REMATCH-NAME,phase,DIRECT', 'MATCH,jump']
+"#,
+                0,
+                Some("phase"),
+            ),
+            // Existing empty programs exhaust to DIRECT; they are not unknown.
+            (
+                r#"
+proxies: [{name: jump, type: rematch, target-sub-rule: empty}]
+rules: ['MATCH,jump', 'MATCH,REJECT']
+sub-rules: {empty: []}
+"#,
+                2,
+                None,
+            ),
+        ];
+        for (yaml, expected_index, expected_name) in cases {
+            let (rules, targets) = rematch_fixture(yaml);
+            let mut context = context();
+            assert!(matches!(
+                rules.evaluate_program(&mut context, &EmptyGeoMatcher, None, None,
+                    |action, _| rematch_effect(&targets, action)),
+                ProgramEvaluation::Matched(RuleMatch { action: RuleAction::Direct, rule_index })
+                    if rule_index == expected_index
+            ));
+            assert_eq!(context.rematch_name.as_deref(), expected_name);
+        }
+    }
+
+    #[test]
+    fn rematch_keeps_lazy_progress_and_the_original_rule_switch_snapshot() {
+        let (rules, targets) = rematch_fixture(
+            r#"
+proxies: [{name: mark, type: rematch, target-rematch-name: done}]
+rules:
+  - REMATCH-NAME,done,DIRECT
+  - AND,((PROCESS-NAME,app),(IP-CIDR,192.0.2.0/24)),mark
+  - MATCH,REJECT
+"#,
+        );
+        let mut context = context();
+        context.enable_process_lookup(true);
+        let cursor =
+            match rules.evaluate_program(&mut context, &EmptyGeoMatcher, None, None, |action, _| {
+                rematch_effect(&targets, action)
+            }) {
+                ProgramEvaluation::NeedsProcessLookup(cursor) => cursor,
+                _ => panic!("process identity must be requested only at its predicate"),
+            };
+        assert!(cursor.rematch.is_none());
+        context.set_process(crate::process::Identity {
+            name: Some("app".into()),
+            ..Default::default()
+        });
+        let cursor = match rules.evaluate_program(
+            &mut context,
+            &EmptyGeoMatcher,
+            Some(cursor),
+            None,
+            |action, _| rematch_effect(&targets, action),
+        ) {
+            ProgramEvaluation::NeedsIpResolution(cursor) => cursor,
+            _ => panic!("DNS continuation must retain completed process lookup"),
+        };
+        rules.disable_state().apply(&[(0, true)]).unwrap();
+        let addresses = ["192.0.2.7".parse().unwrap()];
+        assert!(matches!(
+            rules.evaluate_program(
+                &mut context,
+                &EmptyGeoMatcher,
+                Some(cursor),
+                Some(&addresses),
+                |action, _| rematch_effect(&targets, action)
+            ),
+            ProgramEvaluation::Matched(RuleMatch {
+                action: RuleAction::Direct,
+                rule_index: 0
+            })
+        ));
+        assert_eq!(context.pinned_ip(), Some(addresses[0]));
+        assert_eq!(
+            context
+                .process()
+                .and_then(|identity| identity.name.as_deref()),
+            Some("app")
+        );
+    }
+
+    #[test]
+    fn rematch_keeps_the_original_cancellation_and_deadline() {
+        let (rules, targets) = rematch_fixture(
+            r#"
+proxies: [{name: mark, type: rematch, target-rematch-name: done}]
+rules: ['REMATCH-NAME,done,DIRECT', 'MATCH,mark']
+"#,
+        );
+        for cancel in [false, true] {
+            let mut context = context();
+            let token = tokio_util::sync::CancellationToken::new();
+            context.decision().set_cancellation(token.clone());
+            let result = rules.evaluate_program(
+                &mut context,
+                &EmptyGeoMatcher,
+                None,
+                None,
+                |action, candidate| {
+                    if cancel {
+                        token.cancel();
+                    } else {
+                        candidate.decision().set_deadline(
+                            std::time::Instant::now() - std::time::Duration::from_secs(1),
+                        );
+                    }
+                    rematch_effect(&targets, action)
+                },
+            );
+            let expected = if cancel {
+                crate::config::MatchFailure::Cancelled
+            } else {
+                crate::config::MatchFailure::Budget
+            };
+            assert!(matches!(result, ProgramEvaluation::Failed(failure) if failure == expected));
+        }
+    }
+
+    #[test]
+    fn rematch_repeated_node_fails_before_replaying_its_effect() {
+        let (rules, targets) = rematch_fixture(
+            r#"
+proxies:
+  - {name: first, type: rematch, target-rematch-name: a}
+  - {name: second, type: rematch, target-rematch-name: b}
+rules: ['REMATCH-NAME,b,first', 'REMATCH-NAME,a,second', 'MATCH,first']
+"#,
+        );
+        let mut calls = 0;
+        assert!(matches!(
+            rules.evaluate_program(&mut context(), &EmptyGeoMatcher, None, None, |action, _| {
+                calls += 1;
+                rematch_effect(&targets, action)
+            }),
+            ProgramEvaluation::Failed(crate::config::MatchFailure::Budget)
+        ));
+        assert_eq!(calls, 3);
+    }
+
+    #[test]
+    fn disabled_main_rules_skip_subprograms_and_keep_the_decision_snapshot() {
+        let rules = compile(
+            "rules: ['SUB-RULE,(NETWORK,TCP),child', 'MATCH,REJECT']\nsub-rules: {child: ['IP-CIDR,192.0.2.0/24,DIRECT']}\n",
+        );
+        let mut context = self::context();
+        let cursor =
+            match rules.evaluate_program(&mut context, &EmptyGeoMatcher, None, None, |_, _| {
+                RuleTargetEffect::Accept
+            }) {
+                ProgramEvaluation::NeedsIpResolution(cursor) => cursor,
+                _ => panic!("child IP predicate must pause"),
+            };
+        rules.disable_state().apply(&[(0, true)]).unwrap();
+        assert!(matches!(
+            rules.evaluate_program(
+                &mut context,
+                &EmptyGeoMatcher,
+                Some(cursor),
+                Some(&["192.0.2.7".parse().unwrap()]),
+                |_, _| RuleTargetEffect::Accept
+            ),
+            ProgramEvaluation::Matched(RuleMatch {
+                action: RuleAction::Direct,
+                rule_index: 0
+            })
+        ));
+        assert!(matches!(
+            rules.evaluate(&self::context()),
+            RuleEvaluation::Matched(RuleMatch {
+                action: RuleAction::Reject,
+                rule_index: 1
+            })
+        ));
+        let fresh = compile(
+            "rules: ['SUB-RULE,(NETWORK,TCP),child', 'MATCH,REJECT']\nsub-rules: {child: ['IP-CIDR,192.0.2.0/24,DIRECT']}\n",
+        );
+        assert!(matches!(
+            fresh.evaluate(&self::context()),
+            RuleEvaluation::NeedsIpResolution { rule_index: 0 }
+        ));
+    }
+
+    #[test]
+    fn process_cursor_is_lazy_once_and_keeps_dns_and_subrule_progress() {
+        let rules = compile(
+            "rules: ['SUB-RULE,(NETWORK,TCP),child', 'MATCH,REJECT']\nsub-rules: {child: ['DOMAIN,never.invalid,DIRECT', 'AND,((PROCESS-NAME,APP),(IP-CIDR,192.0.2.0/24)),DIRECT']}\n",
+        );
+        let mut context = context();
+        context.enable_process_lookup(true);
+        let cursor =
+            match rules.evaluate_program(&mut context, &EmptyGeoMatcher, None, None, |_, _| {
+                RuleTargetEffect::Accept
+            }) {
+                ProgramEvaluation::NeedsProcessLookup(cursor) => cursor,
+                _ => panic!("strict must pause at the actual identity predicate"),
+            };
+        context.set_process(crate::process::Identity {
+            name: Some("app".into()),
+            ..Default::default()
+        });
+        let cursor = match rules.evaluate_program(
+            &mut context,
+            &EmptyGeoMatcher,
+            Some(cursor),
+            None,
+            |_, _| RuleTargetEffect::Accept,
+        ) {
+            ProgramEvaluation::NeedsIpResolution(cursor) => cursor,
+            _ => panic!("identity continuation must preserve the child DNS position"),
+        };
+        let addresses = ["192.0.2.7".parse().unwrap()];
+        assert!(matches!(
+            rules.evaluate_program(
+                &mut context,
+                &EmptyGeoMatcher,
+                Some(cursor),
+                Some(&addresses),
+                |_, _| RuleTargetEffect::Accept
+            ),
+            ProgramEvaluation::Matched(RuleMatch {
+                action: RuleAction::Direct,
+                rule_index: 0
+            })
+        ));
+        assert_eq!(context.pinned_ip(), Some(addresses[0]));
+
+        for yaml in [
+            "rules: ['MATCH,DIRECT', 'PROCESS-NAME,app,REJECT']\n",
+            "rules: ['AND,((DOMAIN,never.invalid),(PROCESS-NAME,app)),REJECT', 'MATCH,DIRECT']\n",
+            "rules: ['MATCH,DIRECT']\n",
+        ] {
+            let mut context = self::context();
+            context.enable_process_lookup(true);
+            assert!(matches!(
+                compile(yaml).evaluate_program(
+                    &mut context,
+                    &EmptyGeoMatcher,
+                    None,
+                    None,
+                    |_, _| RuleTargetEffect::Accept
+                ),
+                ProgramEvaluation::Matched(RuleMatch {
+                    action: RuleAction::Direct,
+                    ..
+                })
+            ));
+            assert!(context.process().is_none());
+        }
+        let mut context = self::context();
+        let rules = compile("rules: ['PROCESS-NAME-REGEX,.*,REJECT', 'MATCH,DIRECT']\n");
+        // off and inaccessible identity never match an empty-string regex.
+        assert!(matches!(
+            rules.evaluate(&context),
+            RuleEvaluation::Matched(RuleMatch {
+                action: RuleAction::Direct,
+                ..
+            })
+        ));
+        context.enable_process_lookup(true);
+        context.set_process(Default::default());
+        assert!(matches!(
+            rules.evaluate(&context),
+            RuleEvaluation::Matched(RuleMatch {
+                action: RuleAction::Direct,
+                ..
+            })
+        ));
+    }
+
+    #[test]
+    fn classical_process_provider_resumes_without_selector_side_effects() {
+        let rules = compile(
+            "rule-providers: {identity: {type: inline, behavior: classical, payload: ['PROCESS-PATH-REGEX,^/路径/.*$']}}\nrules: ['RULE-SET,identity,DIRECT','MATCH,REJECT']\n",
+        );
+        let mut context = context();
+        context.enable_process_lookup(true);
+        let cursor =
+            match rules.evaluate_program(&mut context, &EmptyGeoMatcher, None, None, |_, _| {
+                RuleTargetEffect::Accept
+            }) {
+                ProgramEvaluation::NeedsProcessLookup(cursor) => cursor,
+                _ => panic!("provider must pause"),
+            };
+        context.set_process(crate::process::Identity {
+            path: Some("/路径/程序".into()),
+            ..Default::default()
+        });
+        assert!(matches!(
+            rules.evaluate_program(
+                &mut context,
+                &EmptyGeoMatcher,
+                Some(cursor),
+                None,
+                |_, _| RuleTargetEffect::Accept
+            ),
+            ProgramEvaluation::Matched(RuleMatch {
+                action: RuleAction::Direct,
+                ..
+            })
+        ));
+        let crate::config::RuleKind::RuleSet {
+            content: Some(set), ..
+        } = &rules.graph.main[0].kind
+        else {
+            panic!("bound provider")
+        };
+        assert!(
+            !set.matches_domain("example.com", &EmptyGeoMatcher, &Default::default())
+                .unwrap()
+        );
+    }
+
+    #[test]
+    fn subrule_nested_calls_and_flow_controls_preserve_root_position() {
+        for (inner, outer_tail, expected, index) in [
+            ("['DOMAIN,example.com,REJECT']", "", RuleAction::Reject, 0),
+            ("[]", ", 'MATCH,REJECT'", RuleAction::Reject, 0),
+            ("['MATCH,PASS']", ", 'MATCH,REJECT'", RuleAction::Direct, 1),
+            (
+                "['MATCH,PASS-RULE','MATCH,REJECT']",
+                "",
+                RuleAction::Reject,
+                0,
+            ),
+        ] {
+            let rules = compile(&format!(
+                "rules: ['SUB-RULE,(NETWORK,TCP),outer', 'MATCH,DIRECT']\nsub-rules:\n  outer: ['SUB-RULE,(DOMAIN,example.com),inner'{outer_tail}]\n  inner: {inner}\n"
+            ));
+            assert_eq!(
+                rules.evaluate(&context()),
+                RuleEvaluation::Matched(RuleMatch {
+                    action: expected,
+                    rule_index: index
+                })
+            );
+            assert!(std::sync::Arc::ptr_eq(&rules.graph, &rules.clone().graph));
+        }
+        assert_eq!(
+            compile("rules: ['MATCH,PASS-RULE']\n").evaluate(&context()),
+            RuleEvaluation::Matched(RuleMatch {
+                action: RuleAction::Reject,
+                rule_index: 0
+            })
+        );
+    }
+
+    #[test]
+    fn subrule_graph_validation_covers_references_and_combined_budget() {
+        for yaml in [
+            "rules: ['SUB-RULE,(NETWORK,TCP),missing']\n",
+            "sub-rules: {a: ['SUB-RULE,(NETWORK,TCP),b'], b: ['SUB-RULE,(NETWORK,TCP),a']}\n",
+        ] {
+            assert!(Config::parse_yaml(format!("mixed-port: 1080\n{yaml}").as_bytes()).is_err());
+        }
+        for depth in [32, 33] {
+            let definitions = (0..depth)
+                .map(|index| {
+                    let rule = if index + 1 == depth {
+                        "MATCH,DIRECT".to_owned()
+                    } else {
+                        format!("SUB-RULE,(NETWORK,TCP),p{}", index + 1)
+                    };
+                    format!("  p{index}: ['{rule}']\n")
+                })
+                .collect::<String>();
+            let parsed = Config::parse_yaml(format!("mixed-port: 1080\nrules: ['SUB-RULE,(NETWORK,TCP),p0']\nsub-rules:\n{definitions}").as_bytes());
+            assert_eq!(parsed.is_ok(), depth == 32);
+            if let Ok(mut config) = parsed {
+                assert_eq!(
+                    RuleSet::compile_config(&mut config)
+                        .unwrap()
+                        .evaluate(&context()),
+                    RuleEvaluation::Matched(RuleMatch {
+                        action: RuleAction::Direct,
+                        rule_index: 0
+                    })
+                );
+            }
+        }
+        let rules = compile("rules: ['MATCH,DIRECT']\nsub-rules: {one: ['MATCH,DIRECT']}\n");
+        let program = RuntimeRuleProgram {
+            main: vec![rules.graph.main[0].clone(); crate::config::MAX_RULES],
+            sub_rules: rules.graph.sub_rules.to_vec(),
+        };
+        assert!(matches!(
+            RuleSet::compile(program),
+            Err(super::super::RuleSetError::TooManyRules { .. })
+        ));
+    }
+
+    #[test]
+    fn subrule_dns_cursor_does_not_replay_controls_or_mix_candidate_ips() {
+        let rules = compile(
+            "rules: ['SUB-RULE,(NETWORK,TCP),child', 'MATCH,REJECT']\nsub-rules: {child: ['NETWORK,TCP,DIRECT', 'IP-CIDR,192.0.2.0/24,DIRECT']}\n",
+        );
+        let mut context = context();
+        let mut controls = 0;
+        let cursor =
+            match rules.evaluate_program(&mut context, &EmptyGeoMatcher, None, None, |_, _| {
+                controls += 1;
+                RuleTargetEffect::Control(RuleControl::PassRule)
+            }) {
+                ProgramEvaluation::NeedsIpResolution(cursor) => cursor,
+                _ => panic!("expected a child DNS pause"),
+            };
+        let addresses = ["192.0.2.7".parse().unwrap()];
+        let result = rules.evaluate_program(
+            &mut context,
+            &EmptyGeoMatcher,
+            Some(cursor),
+            Some(&addresses),
+            |_, _| RuleTargetEffect::Accept,
+        );
+        assert_eq!(controls, 1);
+        assert_eq!(
+            result.into_public(),
+            RuleEvaluation::Matched(RuleMatch {
+                action: RuleAction::Direct,
+                rule_index: 0
+            })
+        );
+        assert_eq!(context.pinned_ip(), Some(addresses[0]));
+        let rules = compile(
+            "rules: ['SUB-RULE,(IP-CIDR,192.0.2.0/24),child', 'MATCH,REJECT']\nsub-rules: {child: ['IP-CIDR,198.51.100.0/24,DIRECT']}\n",
+        );
+        let mut context = self::context();
+        let result = rules.evaluate_program(
+            &mut context,
+            &EmptyGeoMatcher,
+            None,
+            Some(&[addresses[0], "198.51.100.7".parse().unwrap()]),
+            |_, _| RuleTargetEffect::Accept,
+        );
+        assert_eq!(
+            result.into_public(),
+            RuleEvaluation::Matched(RuleMatch {
+                action: RuleAction::Reject,
+                rule_index: 1
+            })
+        );
+        assert_eq!(context.pinned_ip(), None);
+    }
+    #[test]
+    fn suffix_rules_use_source_low_bits_and_resume_with_shared_provider_budget() {
+        let rules = compile(
+            "rules: ['SUB-RULE,(NETWORK,TCP),child', 'MATCH,REJECT']\nsub-rules: {child: ['AND,((SRC-IP-SUFFIX,192.0.2.19/5),(IP-SUFFIX,198.51.100.7/9)),DIRECT']}\n",
+        );
+        let mut context = self::context();
+        context.set_source("203.0.113.51:9000".parse().unwrap());
+        let cursor =
+            match rules.evaluate_program(&mut context, &EmptyGeoMatcher, None, None, |_, _| {
+                RuleTargetEffect::Accept
+            }) {
+                ProgramEvaluation::NeedsIpResolution(cursor) => cursor,
+                _ => panic!("destination suffix must request lazy DNS"),
+            };
+        let addresses = [
+            "203.0.113.8".parse().unwrap(),
+            "203.0.112.7".parse().unwrap(),
+        ];
+        assert!(matches!(
+            rules.evaluate_program(
+                &mut context,
+                &EmptyGeoMatcher,
+                Some(cursor),
+                Some(&addresses),
+                |_, _| RuleTargetEffect::Accept
+            ),
+            ProgramEvaluation::Matched(RuleMatch {
+                action: RuleAction::Direct,
+                ..
+            })
+        ));
+        assert_eq!(context.pinned_ip(), Some(addresses[1]));
+
+        // A classical provider spends most of the decision's complex quota before DNS.
+        let payload = vec!["DOMAIN-REGEX,(?=never)never"; 31];
+        let payload = serde_json::to_string(&payload).unwrap();
+        let rules = compile(&format!(
+            "rule-providers: {{patterns: {{type: inline, behavior: classical, payload: {payload}}}}}\nrules: ['RULE-SET,patterns,REJECT', 'IP-SUFFIX,192.0.2.19/5,REJECT', 'DOMAIN-REGEX,(?=never)never,REJECT', 'MATCH,DIRECT']\n"
+        ));
+        let mut context = self::context();
+        assert!(matches!(
+            rules.evaluate(&context),
+            RuleEvaluation::NeedsIpResolution { rule_index: 1 }
+        ));
+        assert_eq!(
+            rules.evaluate_with_resolved_ips(
+                &mut context,
+                &EmptyGeoMatcher,
+                1,
+                &["203.0.113.20".parse().unwrap()]
+            ),
+            RuleEvaluation::Failed(crate::config::MatchFailure::Budget)
+        );
+        assert_eq!(
+            rules.evaluate(&context),
+            RuleEvaluation::Failed(crate::config::MatchFailure::Budget)
+        );
+    }
+}
diff --git a/src/routing/proxy_group.rs b/src/routing/proxy_group.rs
index 19ba8fe..5c67dc9 100644
--- a/src/routing/proxy_group.rs
+++ b/src/routing/proxy_group.rs
@@ -1,10 +1,10 @@
+use super::GroupSelection;
+#[cfg(test)]
+use std::sync::atomic::AtomicUsize;
 use std::{
     collections::HashMap,
     fmt,
-    sync::{
-        Arc,
-        atomic::{AtomicUsize, Ordering},
-    },
+    sync::{Arc, atomic::Ordering},
 };
 
 use async_trait::async_trait;
@@ -17,15 +17,20 @@ use crate::{
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) struct ProxyGroupState {
+    pub kind: crate::config::GroupKind,
     pub(crate) name: String,
     pub(crate) all: Vec<String>,
     pub(crate) now: String,
+    pub(crate) hidden: bool,
+    pub(crate) icon: String,
+    pub(crate) fixed: Option<String>,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum ProxyGroupError {
     UnknownGroup,
     UnknownMember,
+    NotSelectable,
 }
 
 impl fmt::Display for ProxyGroupError {
@@ -33,6 +38,7 @@ impl fmt::Display for ProxyGroupError {
         formatter.write_str(match self {
             Self::UnknownGroup => "unknown proxy group",
             Self::UnknownMember => "unknown proxy group member",
+            Self::NotSelectable => "load-balance does not support manual selection",
         })
     }
 }
@@ -40,9 +46,13 @@ impl fmt::Display for ProxyGroupError {
 impl std::error::Error for ProxyGroupError {}
 
 struct SelectProxyGroup {
+    config: SelectProxyGroupConfig,
     name: String,
     members: Box<[ProxyGroupMember]>,
-    selected: Arc<AtomicUsize>,
+    selected: Arc<GroupSelection>,
+    disable_udp: bool,
+    hidden: bool,
+    icon: String,
 }
 
 struct ProxyGroupMember {
@@ -50,11 +60,31 @@ struct ProxyGroupMember {
     target: ProxyGroupMemberTarget,
 }
 
+#[derive(Clone)]
 pub(crate) struct ResolvedProxyGroupLeaf {
+    pub(crate) chain: Vec<String>,
+    pub(crate) selections: Vec<Arc<GroupSelection>>,
     pub(crate) dispatcher: Arc<dyn Dispatcher>,
     pub(crate) direct: bool,
 }
 
+pub(crate) enum InspectedRuleTarget {
+    Control(crate::config::RuleControl),
+    Rematch(Arc<super::rematch::RematchTarget>),
+    Egress(ResolvedProxyGroupLeaf),
+    Unavailable,
+}
+
+impl ResolvedProxyGroupLeaf {
+    pub(crate) fn report(&self, result: &Result<BoxStream, DispatchError>) {
+        if !self.direct && !matches!(result, Err(DispatchError::NotAllowed)) {
+            for selection in &self.selections {
+                selection.outcome(result.is_ok());
+            }
+        }
+    }
+}
+
 /// Immutable select-group graph with one atomically replaceable member index
 /// per group. Concrete node dispatchers and DIRECT are shared with the rest of
 /// the runtime; groups own no protocol resources or background tasks.
@@ -62,8 +92,10 @@ pub(crate) struct ProxyGroups {
     proxies: Box<[Arc<dyn Dispatcher>]>,
     direct: Arc<dyn Dispatcher>,
     reject: Arc<dyn Dispatcher>,
+    reject_drop: Arc<dyn Dispatcher>,
     groups: Box<[SelectProxyGroup]>,
     ids_by_name: HashMap<String, ProxyGroupId>,
+    rematches: super::RematchTargets,
 }
 
 impl fmt::Debug for ProxyGroups {
@@ -85,16 +117,37 @@ impl ProxyGroups {
     ) -> Result<Arc<Self>, DispatchError> {
         let selections = configs
             .iter()
-            .map(|config| Arc::new(AtomicUsize::new(config.initial_member)))
+            .map(|config| Arc::new(GroupSelection::new(config.initial_member)))
             .collect::<Vec<_>>();
         Self::with_selections(configs, proxies, direct, &selections)
     }
 
+    #[cfg(test)]
     pub(crate) fn with_selections(
         configs: &[SelectProxyGroupConfig],
         proxies: Vec<Arc<dyn Dispatcher>>,
         direct: Arc<dyn Dispatcher>,
-        selections: &[Arc<AtomicUsize>],
+        selections: &[Arc<GroupSelection>],
+    ) -> Result<Arc<Self>, DispatchError> {
+        Self::with_selections_and_drop(
+            configs,
+            proxies,
+            direct,
+            selections,
+            Arc::new(crate::outbound::ConnectorDispatcher::new(Arc::new(
+                crate::outbound::RejectOutbound::drop_connections(),
+            ))),
+            super::RematchTargets::default(),
+        )
+    }
+
+    pub(crate) fn with_selections_and_drop(
+        configs: &[SelectProxyGroupConfig],
+        proxies: Vec<Arc<dyn Dispatcher>>,
+        direct: Arc<dyn Dispatcher>,
+        selections: &[Arc<GroupSelection>],
+        reject_drop: Arc<dyn Dispatcher>,
+        rematches: super::RematchTargets,
     ) -> Result<Arc<Self>, DispatchError> {
         if selections.len() != configs.len() {
             return Err(DispatchError::Other(
@@ -146,26 +199,43 @@ impl ProxyGroups {
             proxies: proxies.into_boxed_slice(),
             direct,
             reject: Arc::new(RejectDispatcher),
+            reject_drop,
             groups: configs
                 .iter()
                 .zip(selections)
-                .map(|(config, selection)| SelectProxyGroup {
-                    name: config.name.clone(),
-                    members: config
-                        .members
-                        .iter()
-                        .map(|member| ProxyGroupMember {
-                            name: member.name.clone(),
-                            target: member.target,
-                        })
-                        .collect(),
-                    selected: selection.clone(),
+                .map(|(config, selection)| {
+                    selection.configure(config.max_failed_times, config.health.timeout);
+                    selection.configure_balance(config);
+                    SelectProxyGroup {
+                        config: config.clone(),
+                        name: config.name.clone(),
+                        members: config
+                            .members
+                            .iter()
+                            .map(|member| ProxyGroupMember {
+                                name: member.name.clone(),
+                                target: member.target,
+                            })
+                            .collect(),
+                        selected: selection.clone(),
+                        disable_udp: config.disable_udp,
+                        hidden: config.hidden,
+                        icon: config.icon.clone(),
+                    }
                 })
                 .collect(),
             ids_by_name,
+            rematches,
         }))
     }
 
+    pub(super) fn rematch(
+        &self,
+        id: crate::config::ProxyId,
+    ) -> Option<&Arc<super::rematch::RematchTarget>> {
+        self.rematches.get(id)
+    }
+
     #[must_use]
     pub(crate) fn len(&self) -> usize {
         self.groups.len()
@@ -185,30 +255,80 @@ impl ProxyGroups {
     }
 
     pub(crate) fn select(&self, group: &str, member: &str) -> Result<(), ProxyGroupError> {
+        self.inherit_selection(group, member, true)
+    }
+    pub(crate) fn clear_fixed(&self, name: &str) -> Result<(), ProxyGroupError> {
+        let id = self
+            .ids_by_name
+            .get(name)
+            .copied()
+            .ok_or(ProxyGroupError::UnknownGroup)?;
+        let group = &self.groups[id.index()];
+        if !matches!(
+            group.config.kind,
+            crate::config::GroupKind::UrlTest | crate::config::GroupKind::Fallback
+        ) {
+            return Err(ProxyGroupError::NotSelectable);
+        }
+        group.selected.clear_forced();
+        Ok(())
+    }
+    pub(crate) fn inherit_selection(
+        &self,
+        group: &str,
+        member: &str,
+        forced: bool,
+    ) -> Result<(), ProxyGroupError> {
         let id = self
             .ids_by_name
             .get(group)
             .copied()
             .ok_or(ProxyGroupError::UnknownGroup)?;
         let group = &self.groups[id.index()];
+        if group.config.kind == crate::config::GroupKind::LoadBalance {
+            return Err(ProxyGroupError::NotSelectable);
+        }
         let selected = group
             .members
             .iter()
             .position(|candidate| candidate.name == member)
             .ok_or(ProxyGroupError::UnknownMember)?;
-        group.selected.store(selected, Ordering::Release);
+        if forced {
+            group.selected.force(selected);
+        } else {
+            group.selected.store(selected, Ordering::Release);
+        }
         Ok(())
     }
 
+    #[cfg(test)]
     pub(crate) fn resolve_leaf(
+        &self,
+        group_id: ProxyGroupId,
+    ) -> Result<ResolvedProxyGroupLeaf, DispatchError> {
+        self.resolve_leaf_for(group_id, false, None, None, None)
+    }
+
+    pub(crate) fn resolve_leaf_for(
         &self,
         mut group_id: ProxyGroupId,
+        udp: bool,
+        source: Option<std::net::SocketAddr>,
+        destination: Option<&crate::session::Destination>,
+        user: Option<&str>,
     ) -> Result<ResolvedProxyGroupLeaf, DispatchError> {
+        let mut chain = Vec::new();
+        let mut selections = Vec::new();
         for _ in 0..=self.groups.len() {
             let group = self.groups.get(group_id.index()).ok_or_else(|| {
                 DispatchError::Other(format!("unknown proxy group id {}", group_id.index()))
             })?;
-            let selected = group.selected.load(Ordering::Acquire);
+            chain.push(group.name.clone());
+            selections.push(group.selected.clone());
+            if udp && group.disable_udp {
+                return Err(DispatchError::NotAllowed);
+            }
+            let selected = group.selected.choose_for(source, destination, user);
             let member = group.members.get(selected).ok_or_else(|| {
                 DispatchError::Other(format!(
                     "proxy group {} has invalid selected index {selected}",
@@ -217,11 +337,18 @@ impl ProxyGroups {
             })?;
             match member.target {
                 ProxyGroupMemberTarget::Route(RouteTargetId::Proxy(id)) => {
+                    if self.rematches.get(id).is_some() {
+                        return Err(DispatchError::NotAllowed);
+                    }
+                    chain.push(member.name.clone());
+                    chain.reverse();
                     return self
                         .proxies
                         .get(id.index())
                         .cloned()
                         .map(|dispatcher| ResolvedProxyGroupLeaf {
+                            chain,
+                            selections,
                             dispatcher,
                             direct: false,
                         })
@@ -231,17 +358,36 @@ impl ProxyGroups {
                 }
                 ProxyGroupMemberTarget::Route(RouteTargetId::Group(id)) => group_id = id,
                 ProxyGroupMemberTarget::Direct => {
+                    chain.push(member.name.clone());
+                    chain.reverse();
                     return Ok(ResolvedProxyGroupLeaf {
+                        chain,
+                        selections,
                         dispatcher: self.direct.clone(),
                         direct: true,
                     });
                 }
+                ProxyGroupMemberTarget::Control(_) => return Err(DispatchError::NotAllowed),
                 ProxyGroupMemberTarget::Reject => {
+                    chain.push("REJECT".into());
+                    chain.reverse();
                     return Ok(ResolvedProxyGroupLeaf {
+                        chain,
+                        selections,
                         dispatcher: self.reject.clone(),
                         direct: false,
                     });
                 }
+                ProxyGroupMemberTarget::RejectDrop => {
+                    chain.push(member.name.clone());
+                    chain.reverse();
+                    return Ok(ResolvedProxyGroupLeaf {
+                        chain,
+                        selections,
+                        dispatcher: self.reject_drop.clone(),
+                        direct: false,
+                    });
+                }
             }
         }
         Err(DispatchError::Other(
@@ -249,6 +395,154 @@ impl ProxyGroups {
         ))
     }
 
+    /// The validated DAG gives group locks one traversal order. No lock is held
+    /// across IO; controls and ineligible UDP leaves never advance round robin.
+    pub(crate) fn inspect_rule_target(
+        &self,
+        mut group_id: ProxyGroupId,
+        udp: bool,
+        commit: bool,
+        source: Option<std::net::SocketAddr>,
+        destination: Option<&crate::session::Destination>,
+        user: Option<&str>,
+    ) -> Result<InspectedRuleTarget, DispatchError> {
+        let mut inspected = Vec::new();
+        let mut chain = Vec::new();
+        let mut selections = Vec::new();
+        let mut disabled = false;
+        for _ in 0..=self.groups.len() {
+            let group = self
+                .groups
+                .get(group_id.index())
+                .ok_or(DispatchError::NotAllowed)?;
+            // Defend the public constructor as well as the validated config path.
+            if selections
+                .iter()
+                .any(|selection| Arc::ptr_eq(selection, &group.selected))
+            {
+                return Err(DispatchError::NotAllowed);
+            }
+            let selected = group.selected.inspect(source, destination, user);
+            let member = group
+                .members
+                .get(selected.index)
+                .ok_or(DispatchError::NotAllowed)?;
+            inspected.push(selected);
+            selections.push(group.selected.clone());
+            chain.push(group.name.clone());
+            disabled |= group.disable_udp;
+            let (dispatcher, direct) = match member.target {
+                ProxyGroupMemberTarget::Control(control) => {
+                    return Ok(InspectedRuleTarget::Control(control));
+                }
+                ProxyGroupMemberTarget::Route(RouteTargetId::Group(id)) => {
+                    group_id = id;
+                    continue;
+                }
+                ProxyGroupMemberTarget::Route(RouteTargetId::Proxy(id)) => {
+                    if let Some(target) = self.rematches.get(id) {
+                        return Ok(InspectedRuleTarget::Rematch(target.clone()));
+                    }
+                    (
+                        self.proxies
+                            .get(id.index())
+                            .ok_or(DispatchError::NotAllowed)?
+                            .clone(),
+                        false,
+                    )
+                }
+                ProxyGroupMemberTarget::Direct => (self.direct.clone(), true),
+                ProxyGroupMemberTarget::Reject => (self.reject.clone(), false),
+                ProxyGroupMemberTarget::RejectDrop => (self.reject_drop.clone(), false),
+            };
+            if udp && (disabled || !dispatcher.supports_udp()) {
+                return Ok(InspectedRuleTarget::Unavailable);
+            }
+            if commit {
+                for selected in inspected {
+                    selected.commit();
+                }
+            }
+            chain.push(member.name.clone());
+            chain.reverse();
+            return Ok(InspectedRuleTarget::Egress(ResolvedProxyGroupLeaf {
+                chain,
+                selections,
+                dispatcher,
+                direct,
+            }));
+        }
+        Err(DispatchError::NotAllowed)
+    }
+
+    pub(crate) fn has_balance(&self) -> bool {
+        self.groups
+            .iter()
+            .any(|g| g.config.kind == crate::config::GroupKind::LoadBalance)
+    }
+    pub(crate) fn contains_balance(&self, id: ProxyGroupId) -> bool {
+        let mut pending = vec![id];
+        let mut seen = std::collections::HashSet::new();
+        while let Some(id) = pending.pop() {
+            if !seen.insert(id) {
+                continue;
+            }
+            let group = &self.groups[id.index()];
+            if group.config.kind == crate::config::GroupKind::LoadBalance {
+                return true;
+            }
+            pending.extend(group.members.iter().filter_map(|m| match m.target {
+                ProxyGroupMemberTarget::Route(RouteTargetId::Group(id)) => Some(id),
+                _ => None,
+            }));
+        }
+        false
+    }
+
+    pub(crate) fn selection(&self, index: usize) -> Arc<GroupSelection> {
+        self.groups[index].selected.clone()
+    }
+    pub(crate) fn apply_health(&self, index: usize, samples: &[Option<u64>]) {
+        let group = &self.groups[index];
+        if group.config.kind == crate::config::GroupKind::Select
+            || samples.len() != group.members.len()
+        {
+            return;
+        }
+        if group.config.kind == crate::config::GroupKind::LoadBalance {
+            group.selected.balance_health(samples);
+            return;
+        }
+        if let Some(forced) = group.selected.forced() {
+            if samples[forced].is_some() {
+                group.selected.store(forced, Ordering::Release);
+                return;
+            }
+            group.selected.clear_forced();
+        }
+        let old = group.selected.load(Ordering::Acquire);
+        let next = if group.config.kind == crate::config::GroupKind::Fallback {
+            samples.iter().position(Option::is_some).unwrap_or(0)
+        } else {
+            let fastest = samples
+                .iter()
+                .enumerate()
+                .filter_map(|(i, d)| d.map(|d| (i, d)))
+                .min_by_key(|(_, d)| *d)
+                .map(|(i, _)| i)
+                .unwrap_or(0);
+            if samples[old]
+                .zip(samples[fastest])
+                .is_some_and(|(a, b)| a <= b.saturating_add(u64::from(group.config.tolerance)))
+            {
+                old
+            } else {
+                fastest
+            }
+        };
+        group.selected.store(next, Ordering::Release);
+    }
+
     pub(super) fn dispatcher(self: &Arc<Self>, id: ProxyGroupId) -> Arc<dyn Dispatcher> {
         Arc::new(SelectProxyGroupDispatcher {
             groups: self.clone(),
@@ -261,13 +555,29 @@ impl SelectProxyGroup {
     fn state(&self) -> ProxyGroupState {
         let selected = self.selected.load(Ordering::Acquire);
         ProxyGroupState {
+            kind: self.config.kind,
             name: self.name.clone(),
             all: self
                 .members
                 .iter()
                 .map(|member| member.name.clone())
                 .collect(),
-            now: self.members[selected].name.clone(),
+            now: if self.config.kind == crate::config::GroupKind::LoadBalance {
+                String::new()
+            } else {
+                self.members[selected].name.clone()
+            },
+            hidden: self.hidden,
+            icon: self.icon.clone(),
+            fixed: matches!(
+                self.config.kind,
+                crate::config::GroupKind::UrlTest | crate::config::GroupKind::Fallback
+            )
+            .then(|| {
+                self.selected
+                    .forced()
+                    .map_or_else(String::new, |index| self.members[index].name.clone())
+            }),
         }
     }
 }
@@ -279,26 +589,126 @@ struct SelectProxyGroupDispatcher {
 
 #[async_trait]
 impl Dispatcher for SelectProxyGroupDispatcher {
+    fn supports_udp(&self) -> bool {
+        let mut id = self.id;
+        for _ in 0..=self.groups.groups.len() {
+            let Some(group) = self.groups.groups.get(id.index()) else {
+                return false;
+            };
+            if group.disable_udp {
+                return false;
+            }
+            // Mihomo advertises balance-group UDP independently of the next
+            // selected leaf. Capability queries must not advance round-robin.
+            if group.config.kind == crate::config::GroupKind::LoadBalance {
+                return true;
+            }
+            let Some(member) = group.members.get(group.selected.load(Ordering::Acquire)) else {
+                return false;
+            };
+            match member.target {
+                ProxyGroupMemberTarget::Route(RouteTargetId::Proxy(id)) => {
+                    return self
+                        .groups
+                        .proxies
+                        .get(id.index())
+                        .is_some_and(|d| d.supports_udp());
+                }
+                ProxyGroupMemberTarget::Route(RouteTargetId::Group(nested)) => id = nested,
+                ProxyGroupMemberTarget::Direct
+                | ProxyGroupMemberTarget::Reject
+                | ProxyGroupMemberTarget::RejectDrop => return true,
+                ProxyGroupMemberTarget::Control(_) => return false,
+            }
+        }
+        false
+    }
+
     async fn connect_tcp(&self, session: StreamSession) -> Result<BoxStream, DispatchError> {
-        self.groups
-            .resolve_leaf(self.id)?
-            .dispatcher
-            .connect_tcp(session)
-            .await
+        let leaf = self.groups.resolve_leaf_for(
+            self.id,
+            false,
+            Some(session.source),
+            Some(&session.destination),
+            session.metadata.user.as_deref(),
+        )?;
+        let result = leaf.dispatcher.connect_tcp(session).await;
+        leaf.report(&result);
+        result
     }
 
     async fn open_datagram(
         &self,
         session: DatagramSession,
     ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        if self.groups.contains_balance(self.id) {
+            return Ok(Box::new(BalancedDatagrams {
+                groups: self.groups.clone(),
+                id: self.id,
+                session,
+                transport: None,
+            }));
+        }
         self.groups
-            .resolve_leaf(self.id)?
+            .resolve_leaf_for(
+                self.id,
+                true,
+                Some(session.source),
+                None,
+                session.metadata.user.as_deref(),
+            )?
             .dispatcher
             .open_datagram(session)
             .await
     }
 }
 
+// Core-originated DNS/probes also enter groups without a first destination.
+// Resolve their leaf on first send and retain it through the association.
+struct BalancedDatagrams {
+    groups: Arc<ProxyGroups>,
+    id: ProxyGroupId,
+    session: DatagramSession,
+    transport: Option<Box<dyn DatagramTransport>>,
+}
+#[async_trait]
+impl DatagramTransport for BalancedDatagrams {
+    fn supports_shared_destinations(&self) -> bool {
+        // The first destination selects a leaf whose framing is not known yet.
+        false
+    }
+
+    async fn send(&mut self, datagram: Datagram) -> Result<(), DispatchError> {
+        if self.transport.is_none() {
+            let leaf = self.groups.resolve_leaf_for(
+                self.id,
+                true,
+                Some(self.session.source),
+                Some(&datagram.remote),
+                self.session.metadata.user.as_deref(),
+            )?;
+            self.transport = Some(leaf.dispatcher.open_datagram(self.session.clone()).await?);
+        }
+        self.transport
+            .as_mut()
+            .expect("group association opened")
+            .send(datagram)
+            .await
+    }
+    async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+        match &mut self.transport {
+            Some(transport) => transport.receive().await,
+            None => std::future::pending().await,
+        }
+    }
+    async fn close(&mut self) -> Result<(), DispatchError> {
+        match self.transport.take() {
+            Some(mut transport) => transport.close().await,
+            None => Ok(()),
+        }
+    }
+}
+
 struct RejectDispatcher;
 
 #[async_trait]
@@ -319,6 +729,10 @@ struct RejectDatagramTransport;
 
 #[async_trait]
 impl DatagramTransport for RejectDatagramTransport {
+    fn supports_shared_destinations(&self) -> bool {
+        true
+    }
+
     async fn send(&mut self, _datagram: Datagram) -> Result<(), DispatchError> {
         Ok(())
     }
@@ -330,11 +744,7 @@ impl DatagramTransport for RejectDatagramTransport {
 
 #[cfg(test)]
 mod tests {
-    use std::{
-        net::SocketAddr,
-        sync::atomic::{AtomicUsize, Ordering},
-        time::Duration,
-    };
+    use std::{net::SocketAddr, sync::atomic::Ordering, time::Duration};
 
     use bytes::Bytes;
     use tokio::sync::Semaphore;
@@ -377,6 +787,10 @@ mod tests {
 
     #[async_trait]
     impl DatagramTransport for RecordingDatagramTransport {
+        fn supports_shared_destinations(&self) -> bool {
+            false
+        }
+
         async fn send(&mut self, _datagram: Datagram) -> Result<(), DispatchError> {
             self.sends.fetch_add(1, Ordering::Relaxed);
             Ok(())
@@ -450,6 +864,15 @@ mod tests {
         initial_member: usize,
     ) -> SelectProxyGroupConfig {
         SelectProxyGroupConfig {
+            kind: crate::config::GroupKind::Select,
+            strategy: crate::config::BalanceStrategy::default(),
+            hash_key: crate::config::BalanceHashKey::default(),
+            health: crate::config::HealthCheckConfig::default(),
+            tolerance: 0,
+            max_failed_times: 5,
+            disable_udp: false,
+            hidden: false,
+            icon: String::new(),
             name: name.to_owned(),
             members,
             initial_member,
@@ -458,6 +881,7 @@ mod tests {
 
     fn stream_session() -> StreamSession {
         StreamSession {
+            metadata: Default::default(),
             inbound: InboundKind::Http,
             source: "127.0.0.1:10000".parse().unwrap(),
             destination: Destination::Ip("192.0.2.1:443".parse().unwrap()),
@@ -477,6 +901,55 @@ mod tests {
         }
     }
 
+    #[tokio::test(start_paused = true)]
+    async fn automatic_groups_apply_tolerance_recover_and_restore_selection() {
+        let config = crate::config::Config::parse_yaml(
+            br#"
+mixed-port: 1080
+proxies:
+  - {name: a, type: socks5, server: 192.0.2.1, port: 1080}
+  - {name: b, type: socks5, server: 192.0.2.2, port: 1080}
+proxy-groups:
+  - {name: fastest, type: url-test, proxies: [a,b], tolerance: 20, max-failed-times: 2}
+  - {name: backup, type: fallback, proxies: [a,b]}
+  - {name: manual, type: select, proxies: [a,b], default-selected: a}
+"#,
+        )
+        .unwrap();
+        let node = Arc::new(FailingDispatcher);
+        let groups = ProxyGroups::new(
+            &config.proxy_groups,
+            vec![node.clone(), node.clone()],
+            node.clone(),
+        )
+        .unwrap();
+        groups.apply_health(0, &[Some(100), Some(90)]);
+        assert_eq!(groups.state("fastest").unwrap().now, "a");
+        groups.apply_health(0, &[Some(100), Some(60)]);
+        assert_eq!(groups.state("fastest").unwrap().now, "b");
+        groups.apply_health(1, &[None, Some(60)]);
+        assert_eq!(groups.state("backup").unwrap().now, "b");
+        groups.apply_health(1, &[Some(100), Some(60)]);
+        assert_eq!(groups.state("backup").unwrap().now, "a");
+        groups.select("fastest", "a").unwrap();
+        groups.apply_health(0, &[None, Some(60)]);
+        assert_eq!(groups.state("fastest").unwrap().now, "b");
+        let selection = groups.selection(0);
+        selection.outcome(false);
+        selection.outcome(false);
+        assert!(selection.take_urgent());
+        tokio::time::advance(std::time::Duration::from_secs(301)).await;
+        assert!(!selection.active(std::time::Duration::from_secs(300)));
+        let root = tempfile::tempdir().unwrap();
+        let store = crate::resource::profile::SelectionStore::open(root.path(), true);
+        groups.select("manual", "b").unwrap();
+        store.save("manual", "b").unwrap();
+        let restarted =
+            ProxyGroups::new(&config.proxy_groups, vec![node.clone(), node.clone()], node).unwrap();
+        crate::resource::profile::SelectionStore::open(root.path(), true).restore(&restarted);
+        assert_eq!(restarted.state("manual").unwrap().now, "b");
+    }
+
     #[tokio::test]
     async fn nested_selection_preserves_duplicates_and_snapshots_new_transports() {
         let first = Arc::new(RecordingDispatcher::default());
@@ -534,14 +1007,22 @@ mod tests {
             groups.list_states(),
             vec![
                 ProxyGroupState {
+                    kind: crate::config::GroupKind::Select,
                     name: "child".to_owned(),
                     all: vec!["first".to_owned(), "first".to_owned(), "second".to_owned()],
                     now: "second".to_owned(),
+                    hidden: false,
+                    icon: String::new(),
+                    fixed: None,
                 },
                 ProxyGroupState {
+                    kind: crate::config::GroupKind::Select,
                     name: "parent".to_owned(),
                     all: vec!["child".to_owned(), "DIRECT".to_owned(), "REJECT".to_owned()],
                     now: "child".to_owned(),
+                    hidden: false,
+                    icon: String::new(),
+                    fixed: None,
                 },
             ]
         );
@@ -712,4 +1193,51 @@ mod tests {
         };
         assert!(error.to_string().contains("hop ceiling"));
     }
+
+    #[tokio::test(start_paused = true)]
+    async fn automatic_fixed_clear_uses_existing_health_without_probe() {
+        let mut automatic = group(
+            "automatic",
+            vec![
+                member("first", ProxyGroupMemberTarget::Direct),
+                member("second", ProxyGroupMemberTarget::Reject),
+            ],
+            0,
+        );
+        automatic.kind = crate::config::GroupKind::UrlTest;
+        let manual = group(
+            "manual",
+            vec![member("first", ProxyGroupMemberTarget::Direct)],
+            0,
+        );
+        let node = Arc::new(FailingDispatcher);
+        let groups = ProxyGroups::new(&[automatic, manual], Vec::new(), node).unwrap();
+        assert_eq!(
+            groups.state("automatic").unwrap().fixed.as_deref(),
+            Some("")
+        );
+        assert_eq!(groups.state("manual").unwrap().fixed, None);
+        groups.select("automatic", "first").unwrap();
+        groups.apply_health(0, &[Some(100), Some(10)]);
+        assert_eq!(groups.state("automatic").unwrap().now, "first");
+        assert_eq!(
+            groups.state("automatic").unwrap().fixed.as_deref(),
+            Some("first")
+        );
+        groups.clear_fixed("automatic").unwrap();
+        groups.apply_health(0, &[Some(100), Some(10)]);
+        assert_eq!(groups.state("automatic").unwrap().now, "second");
+        assert_eq!(
+            groups.state("automatic").unwrap().fixed.as_deref(),
+            Some("")
+        );
+        assert_eq!(
+            groups.clear_fixed("manual"),
+            Err(ProxyGroupError::NotSelectable)
+        );
+        assert_eq!(
+            groups.clear_fixed("missing"),
+            Err(ProxyGroupError::UnknownGroup)
+        );
+    }
 }
diff --git a/src/routing/rematch.rs b/src/routing/rematch.rs
new file mode 100644
index 0000000..641fbe2
--- /dev/null
+++ b/src/routing/rematch.rs
@@ -0,0 +1,101 @@
+//! Sparse generation-owned controls and decision-local bounded cycle tracking.
+use std::sync::Arc;
+
+use crate::config::{
+    MatchFailure, ProxyConfig, ProxyId, ProxyProtocol, RematchConfig, RuleDecision,
+};
+
+pub(crate) struct RematchTarget {
+    pub(super) name: Arc<str>,
+    pub(super) config: RematchConfig,
+}
+
+/// The ordinary graph keeps None; only actual rematch nodes allocate entries.
+#[derive(Clone, Default)]
+pub(crate) struct RematchTargets(Option<RematchEntries>);
+type RematchEntries = Arc<[(ProxyId, Arc<RematchTarget>)]>;
+impl RematchTargets {
+    pub(crate) fn new(proxies: &[ProxyConfig]) -> Self {
+        let mut entries = Vec::new();
+        for (index, proxy) in proxies.iter().enumerate() {
+            if let ProxyProtocol::Rematch(config) = &proxy.protocol {
+                entries.push((
+                    ProxyId::new(index).expect("proxy index"),
+                    Arc::new(RematchTarget {
+                        name: Arc::from(proxy.tag.as_str()),
+                        config: config.clone(),
+                    }),
+                ));
+            }
+        }
+        Self((!entries.is_empty()).then(|| Arc::from(entries)))
+    }
+    pub(super) fn get(&self, id: ProxyId) -> Option<&Arc<RematchTarget>> {
+        let entries = self.0.as_ref()?;
+        entries
+            .binary_search_by_key(&id.index(), |(index, _)| index.index())
+            .ok()
+            .map(|index| &entries[index].1)
+    }
+}
+
+/// Allocated once, only when a decision first encounters a rematch target.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(super) struct RematchCursor {
+    visited: [Option<Arc<str>>; 32],
+    count: usize,
+    pub(super) unlisted_index: usize,
+}
+impl RematchCursor {
+    pub(super) fn new(unlisted_index: usize) -> Self {
+        Self {
+            visited: std::array::from_fn(|_| None),
+            count: 0,
+            unlisted_index,
+        }
+    }
+    pub(super) fn enter(
+        &mut self,
+        name: &Arc<str>,
+        decision: &RuleDecision,
+    ) -> Result<(), MatchFailure> {
+        decision.check()?;
+        if self.count == self.visited.len()
+            || self.visited[..self.count]
+                .iter()
+                .any(|old| old.as_deref() == Some(name.as_ref()))
+        {
+            return Err(MatchFailure::Budget);
+        }
+        self.visited[self.count] = Some(name.clone());
+        self.count += 1;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn reentry_is_bounded_by_node_identity_and_keeps_shared_names() {
+        let mut cursor = RematchCursor::new(9);
+        let decision = RuleDecision::default();
+        let first: Arc<str> = Arc::from("first");
+        cursor.enter(&first, &decision).unwrap();
+        assert!(Arc::ptr_eq(cursor.visited[0].as_ref().unwrap(), &first));
+        assert_eq!(
+            cursor.enter(&Arc::from("first"), &decision),
+            Err(MatchFailure::Budget)
+        );
+        for index in 1..32 {
+            cursor
+                .enter(&Arc::from(format!("node-{index}")), &decision)
+                .unwrap();
+        }
+        assert_eq!(
+            cursor.enter(&Arc::from("next"), &decision),
+            Err(MatchFailure::Budget)
+        );
+    }
+}
diff --git a/src/routing/rule_disable.rs b/src/routing/rule_disable.rs
new file mode 100644
index 0000000..6e88fe4
--- /dev/null
+++ b/src/routing/rule_disable.rs
@@ -0,0 +1,128 @@
+//! Generation-local rule switches, published as one immutable bounded snapshot.
+use arc_swap::ArcSwapOption;
+use std::sync::{Arc, Mutex};
+
+#[derive(Debug)]
+pub(crate) struct RuleDisable {
+    count: usize,
+    current: ArcSwapOption<Bits>,
+    updates: Mutex<()>,
+}
+
+#[derive(Debug, PartialEq, Eq)]
+struct Bits(Box<[u64]>);
+impl Bits {
+    fn contains(&self, index: usize) -> bool {
+        self.0
+            .get(index / 64)
+            .is_some_and(|word| word & (1 << (index % 64)) != 0)
+    }
+}
+
+/// A routing decision keeps the same switches across DNS/process continuations.
+#[derive(Debug, Default, Clone, PartialEq, Eq)]
+pub(super) struct Snapshot(Option<Arc<Bits>>);
+impl Snapshot {
+    pub(super) fn contains(&self, index: usize) -> bool {
+        self.0.as_ref().is_some_and(|bits| bits.contains(index))
+    }
+}
+
+impl RuleDisable {
+    pub(super) fn new(count: usize) -> Self {
+        Self {
+            count,
+            current: ArcSwapOption::empty(),
+            updates: Mutex::new(()),
+        }
+    }
+    pub(super) fn snapshot(&self) -> Snapshot {
+        Snapshot(self.current.load_full())
+    }
+    pub(crate) fn apply(&self, changes: &[(usize, bool)]) -> Result<(), ()> {
+        if changes.iter().any(|(index, _)| *index >= self.count) {
+            return Err(());
+        }
+        if changes.is_empty() {
+            return Ok(());
+        }
+        // Publication takes its generation lock before entering here. This
+        // additional lock also prevents lost concurrent updates for direct users.
+        let _update = self.updates.lock().unwrap();
+        let previous = self.current.load_full();
+        if changes.iter().all(|(index, disabled)| {
+            previous.as_ref().is_some_and(|bits| bits.contains(*index)) == *disabled
+        }) {
+            return Ok(());
+        }
+        let mut words = previous.as_ref().map_or_else(
+            || vec![0_u64; self.count.div_ceil(64)],
+            |bits| bits.0.to_vec(),
+        );
+        for (index, disabled) in changes {
+            let mask = 1 << (index % 64);
+            if *disabled {
+                words[index / 64] |= mask;
+            } else {
+                words[index / 64] &= !mask;
+            }
+        }
+        self.current.store(
+            words
+                .iter()
+                .any(|word| *word != 0)
+                .then(|| Arc::new(Bits(words.into_boxed_slice()))),
+        );
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn updates_validate_the_whole_patch_and_preserve_old_snapshots() {
+        let state = RuleDisable::new(crate::config::MAX_RULES);
+        assert!(state.current.load().is_none());
+        state.apply(&[(0, false)]).unwrap();
+        assert!(state.current.load().is_none());
+        state
+            .apply(&[(0, true), (crate::config::MAX_RULES - 1, true)])
+            .unwrap();
+        let old = state.snapshot();
+        assert_eq!(old.0.as_ref().unwrap().0.len() * size_of::<u64>(), 8192);
+        assert!(
+            state
+                .apply(&[(0, false), (crate::config::MAX_RULES, true)])
+                .is_err()
+        );
+        assert!(state.snapshot().contains(0));
+        state
+            .apply(&[(0, false), (crate::config::MAX_RULES - 1, false)])
+            .unwrap();
+        assert!(state.current.load().is_none());
+        assert!(old.contains(0));
+        assert!(old.contains(crate::config::MAX_RULES - 1));
+    }
+
+    #[test]
+    fn concurrent_patch_writers_do_not_lose_each_others_changes() {
+        let state = Arc::new(RuleDisable::new(64));
+        let start = std::sync::Barrier::new(8);
+        std::thread::scope(|scope| {
+            for worker in 0..8 {
+                let state = &state;
+                let start = &start;
+                scope.spawn(move || {
+                    start.wait();
+                    for index in (worker..64).step_by(8) {
+                        state.apply(&[(index, true)]).unwrap();
+                    }
+                });
+            }
+        });
+        let snapshot = state.snapshot();
+        assert!((0..64).all(|index| snapshot.contains(index)));
+    }
+}
diff --git a/src/routing/selection.rs b/src/routing/selection.rs
new file mode 100644
index 0000000..84ff933
--- /dev/null
+++ b/src/routing/selection.rs
@@ -0,0 +1,145 @@
+//! Selection and probe activity shared by route and upstream groups.
+use std::sync::{
+    Mutex, MutexGuard,
+    atomic::{AtomicBool, AtomicU32, AtomicU64, AtomicUsize, Ordering},
+};
+use std::time::Duration;
+use tokio::time::Instant;
+#[derive(Debug)]
+pub(crate) struct GroupSelection {
+    index: AtomicUsize,
+    balance: Mutex<Option<super::balance::Balance>>,
+    forced: Mutex<Option<usize>>,
+    touched: Mutex<Instant>,
+    failures: Mutex<(Instant, u32)>,
+    urgent: AtomicBool,
+    maximum: AtomicU32,
+    window_ms: AtomicU64,
+}
+pub(super) struct InspectedSelection<'a> {
+    owner: &'a GroupSelection,
+    balance: MutexGuard<'a, Option<super::balance::Balance>>,
+    pub index: usize,
+}
+impl InspectedSelection<'_> {
+    pub fn commit(mut self) {
+        if let Some(balance) = self.balance.as_mut() {
+            balance.commit(self.index);
+        }
+        self.owner.touch();
+    }
+}
+impl GroupSelection {
+    pub fn new(index: usize) -> Self {
+        let now = Instant::now();
+        Self {
+            index: AtomicUsize::new(index),
+            balance: Mutex::new(None),
+            forced: Mutex::new(None),
+            touched: Mutex::new(now),
+            failures: Mutex::new((now, 0)),
+            urgent: AtomicBool::new(false),
+            maximum: AtomicU32::new(5),
+            window_ms: AtomicU64::new(5000),
+        }
+    }
+    pub fn configure_balance(&self, config: &crate::config::SelectProxyGroupConfig) {
+        if config.kind == crate::config::GroupKind::LoadBalance {
+            let mut state = self.balance.lock().unwrap();
+            if state.is_none() {
+                *state = Some(
+                    super::balance::Balance::new(config.strategy, config.members.len())
+                        .with_hash_key(config.hash_key),
+                );
+            }
+        }
+    }
+    #[cfg(test)]
+    pub fn choose(
+        &self,
+        source: Option<std::net::SocketAddr>,
+        destination: Option<&crate::session::Destination>,
+    ) -> usize {
+        self.choose_for(source, destination, None)
+    }
+    pub fn choose_for(
+        &self,
+        source: Option<std::net::SocketAddr>,
+        destination: Option<&crate::session::Destination>,
+        user: Option<&str>,
+    ) -> usize {
+        self.touch();
+        self.balance.lock().unwrap().as_mut().map_or_else(
+            || self.load(Ordering::Acquire),
+            |s| s.choose(source, destination, user),
+        )
+    }
+    pub(super) fn inspect(
+        &self,
+        source: Option<std::net::SocketAddr>,
+        destination: Option<&crate::session::Destination>,
+        user: Option<&str>,
+    ) -> InspectedSelection<'_> {
+        let mut balance = self.balance.lock().unwrap();
+        let index = balance.as_mut().map_or_else(
+            || self.load(Ordering::Acquire),
+            |state| state.inspect(source, destination, user, false),
+        );
+        InspectedSelection {
+            owner: self,
+            balance,
+            index,
+        }
+    }
+    pub fn balance_health(&self, samples: &[Option<u64>]) {
+        if let Some(balance) = self.balance.lock().unwrap().as_mut() {
+            balance.health(samples);
+        }
+    }
+    pub fn load(&self, order: Ordering) -> usize {
+        self.index.load(order)
+    }
+    pub fn store(&self, index: usize, order: Ordering) {
+        self.index.store(index, order);
+    }
+    pub fn touch(&self) {
+        *self.touched.lock().unwrap() = Instant::now();
+    }
+    pub fn active(&self, interval: Duration) -> bool {
+        self.touched.lock().unwrap().elapsed() < interval
+    }
+    pub fn configure(&self, maximum: u32, window: u64) {
+        self.maximum.store(maximum, Ordering::Relaxed);
+        self.window_ms.store(window, Ordering::Relaxed);
+    }
+    pub fn force(&self, index: usize) {
+        *self.forced.lock().unwrap() = Some(index);
+        self.store(index, Ordering::Release);
+    }
+    pub fn forced(&self) -> Option<usize> {
+        *self.forced.lock().unwrap()
+    }
+    pub fn clear_forced(&self) {
+        *self.forced.lock().unwrap() = None;
+    }
+    pub fn take_urgent(&self) -> bool {
+        self.urgent.swap(false, Ordering::Relaxed)
+    }
+    pub fn outcome(&self, success: bool) {
+        let mut failures = self.failures.lock().unwrap();
+        if success {
+            failures.1 = 0;
+            return;
+        }
+        if failures.0.elapsed() > Duration::from_millis(self.window_ms.load(Ordering::Relaxed))
+            || failures.1 == 0
+        {
+            *failures = (Instant::now(), 0);
+        }
+        failures.1 = failures.1.saturating_add(1);
+        if failures.1 >= self.maximum.load(Ordering::Relaxed) {
+            self.urgent.store(true, Ordering::Relaxed);
+            failures.1 = 0;
+        }
+    }
+}
diff --git a/src/runtime.rs b/src/runtime.rs
index ac4fc5f..c4efbfe 100644
--- a/src/runtime.rs
+++ b/src/runtime.rs
@@ -1,5 +1,9 @@
 #![cfg_attr(not(any(feature = "invoke", feature = "cli")), allow(dead_code))]
 
+use crate::routing::diagnostics;
+
+use tracing::instrument::WithSubscriber;
+
 #[cfg(all(
     test,
     unix,
@@ -10,13 +14,9 @@
 #[path = "runtime_lifecycle_tests.rs"]
 mod lifecycle_tests;
 
-use std::{
-    future::Future,
-    io,
-    net::SocketAddr,
-    sync::{Arc, atomic::AtomicUsize},
-    time::Duration,
-};
+#[cfg(test)]
+use std::sync::atomic::AtomicUsize;
+use std::{future::Future, io, net::SocketAddr, sync::Arc, time::Duration};
 
 use futures_util::future::{join_all, select_all};
 use tokio::task::JoinHandle;
@@ -77,27 +77,40 @@ use crate::outbound::ShadowsocksOutbound;
 use crate::outbound::Socks5Outbound;
 #[cfg(feature = "outbound-trojan")]
 use crate::outbound::trojan::TrojanOutbound;
+#[cfg(feature = "outbound-trusttunnel")]
+use crate::outbound::trusttunnel::TrustTunnelOutbound;
 #[cfg(feature = "outbound-anytls")]
 use crate::outbound::{AnyTlsOutbound, server_destination};
 #[cfg(feature = "outbound-vless")]
 use crate::outbound::{VlessOutbound, VlessResourceLimits};
 #[cfg(feature = "outbound-anytls")]
-use crate::security::StandardTlsClient;
+use crate::security::SecurityClient;
+use crate::security::SecurityContext;
 #[cfg(any(
+    feature = "outbound-http",
+    feature = "outbound-socks5",
     feature = "outbound-anytls",
     feature = "outbound-vless",
     feature = "outbound-trojan",
+    feature = "outbound-trusttunnel",
     feature = "outbound-vmess",
     feature = "outbound-hysteria2",
     feature = "outbound-tuic",
-    feature = "shadow-tls-v3"
+    feature = "shadow-tls-v3",
+    feature = "outbound-shadowsocks"
 ))]
-use crate::security::{SecurityContext, TLS_RESUMPTION_SESSION_BUDGET};
+use crate::security::TLS_RESUMPTION_SESSION_BUDGET;
+
+mod health;
+mod providers;
+use providers::ProviderRuntime;
 
-/// Parsed configuration plus the bootstrap-resolved physical proxy roots.
+/// Validated configuration; physical server names resolve on first use.
 #[derive(Debug)]
 pub(crate) struct PreparedCore {
     config: Config,
+    security: SecurityContext,
+    provider_cache: std::sync::Mutex<Option<crate::resource::cache::ProviderCache>>,
     endpoints: Vec<PreparedProxyEndpoints>,
     limits: ResourceLimits,
     rules: RuleSet,
@@ -112,6 +125,14 @@ pub(crate) struct PreparedCore {
     traffic_stats: Option<Arc<TunTrafficStats>>,
 }
 
+/// A short-lived reconnect lease of actual configuration and provider content.
+/// It owns no live transports and never serializes private HTTP material.
+#[cfg(any(feature = "invoke", test))]
+pub(crate) struct RecoverySnapshot {
+    pub(crate) config: Config,
+    pub(crate) provider_cache: Option<crate::resource::cache::ProviderCache>,
+}
+
 /// A node-only outbound graph prepared for one built-in latency probe.
 ///
 /// Unlike `PreparedCore`, this type never registers GeoData, compiles rules,
@@ -120,16 +141,14 @@ pub(crate) struct PreparedCore {
 #[cfg(feature = "invoke")]
 pub(crate) struct PreparedMeasurement {
     config: MeasureConfig,
+    security: SecurityContext,
     endpoints: Vec<PreparedProxyEndpoints>,
     limits: ResourceLimits,
 }
 
-/// Bootstrap-resolved physical destinations for one proxy graph node.
-///
-/// Proxy-only upstreams keep both entries empty. Nodes with a possible DIRECT
-/// group path are also physical roots, regardless of initial selection. They retain a
-/// primary endpoint and, when XHTTP download settings are present, a second
-/// endpoint for the independent download leg.
+/// Pre-resolved physical destinations used by standalone measurements.
+/// Running sessions leave these empty and resolve node endpoints on demand.
+/// XHTTP measurements can retain a separate endpoint for the download leg.
 #[derive(Debug, Clone, Default)]
 struct PreparedProxyEndpoints {
     upload: Option<ResolvedEndpoint>,
@@ -138,31 +157,41 @@ struct PreparedProxyEndpoints {
 
 #[cfg(feature = "invoke")]
 pub(crate) struct MeasurementRuntime {
+    security: SecurityContext,
     dispatcher: Arc<dyn Dispatcher>,
-    proxy_graph: BuiltProxyGraph,
+    proxy_graph: Arc<BuiltProxyGraph>,
+    _ech_dns: Arc<RuntimeDns>,
 }
 
 #[cfg(feature = "invoke")]
 impl MeasurementRuntime {
+    pub(crate) fn security(&self) -> &SecurityContext {
+        &self.security
+    }
     #[must_use]
     pub(crate) fn dispatcher(&self) -> Arc<dyn Dispatcher> {
         self.dispatcher.clone()
     }
 
     pub(crate) async fn shutdown(self) {
+        self._ech_dns.begin_shutdown();
         self.proxy_graph.begin_shutdown();
         self.proxy_graph.shutdown().await;
+        self._ech_dns.shutdown().await;
     }
 }
 
 #[cfg(feature = "invoke")]
 impl Drop for MeasurementRuntime {
     fn drop(&mut self) {
+        self._ech_dns.begin_shutdown();
         self.proxy_graph.begin_shutdown();
     }
 }
 
 struct BuiltRuntimeParts {
+    connections: Arc<crate::connections::Registry>,
+    diagnostics: Option<Arc<diagnostics::Diagnostics>>,
     dispatcher: Arc<dyn Dispatcher>,
     // Local dispatch owns its DNS reference; this copy feeds shared TUN startup.
     #[cfg_attr(
@@ -172,7 +201,11 @@ struct BuiltRuntimeParts {
     dns: Option<Arc<RuntimeDns>>,
     geodata_updater: Option<GeoDataUpdateService>,
     proxy_groups: Arc<ProxyGroups>,
-    proxy_graph: BuiltProxyGraph,
+    proxy_graph: Arc<BuiltProxyGraph>,
+    resources: Option<Arc<ProviderRuntime>>,
+    health: Arc<health::HealthRuntime>,
+    resource_targets: RouteTargetDispatchers,
+    direct: Arc<dyn Dispatcher>,
 }
 
 struct BuiltProxyGraph {
@@ -180,7 +213,8 @@ struct BuiltProxyGraph {
     resolution: ResolutionContext,
     nodes: Vec<Arc<dyn OutboundConnector>>,
     lifecycle_order: Vec<BuiltRouteTarget>,
-    selections: Vec<Arc<AtomicUsize>>,
+    selections: Vec<Arc<crate::routing::GroupSelection>>,
+    reject_drop: Arc<crate::outbound::RejectOutbound>,
 }
 
 enum BuiltRouteTarget {
@@ -206,6 +240,7 @@ impl BuiltProxyGraph {
     fn begin_shutdown(&self) {
         self.dialer.begin_shutdown();
         self.resolution.close();
+        self.reject_drop.begin_shutdown();
         for target in self.lifecycle_order.iter().rev() {
             if let BuiltRouteTarget::Proxy(connector) = target {
                 connector.begin_shutdown();
@@ -214,6 +249,7 @@ impl BuiltProxyGraph {
     }
 
     async fn shutdown(&self) {
+        self.resolution.shutdown().await;
         for target in self.lifecycle_order.iter().rev() {
             if let BuiltRouteTarget::Proxy(connector) = target {
                 connector.shutdown().await;
@@ -237,6 +273,10 @@ impl Drop for BuiltProxyGraph {
 }
 
 impl PreparedCore {
+    pub(crate) fn log_level(&self) -> crate::config::LogLevel {
+        self.config.log_level
+    }
+
     #[cfg(test)]
     async fn prepare(
         yaml: &[u8],
@@ -246,8 +286,11 @@ impl PreparedCore {
         let config = Config::parse_yaml(yaml)
             .map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error))?;
         let directory = tempfile::tempdir()?;
-        let manager = GeoDataManager::open(directory.path(), Duration::from_secs(24 * 60 * 60))
-            .map_err(io::Error::other)?;
+        let manager = GeoDataManager::open(
+            &directory.path().join("geodata"),
+            Duration::from_secs(24 * 60 * 60),
+        )
+        .map_err(io::Error::other)?;
         Self::prepare_config(config, manager, resolver, limits).await
     }
 
@@ -256,7 +299,55 @@ impl PreparedCore {
     /// claim runtime-local resources, notably the unique TUN lease, before a
     /// potentially blocking DNS lookup.
     pub(crate) async fn prepare_config(
+        config: Config,
+        geodata_manager: Arc<GeoDataManager>,
+        resolver: &dyn Resolver,
+        limits: ResourceLimits,
+    ) -> io::Result<Self> {
+        let (config, provider_cache) = Self::resolve_config(config, &geodata_manager).await?;
+        Self::prepare_resolved(config, provider_cache, geodata_manager, resolver, limits).await
+    }
+
+    /// Resolve providers before stopping an existing session. Recovery uses
+    /// the returned actual content instead of reopening mutable source files.
+    pub(crate) async fn resolve_config(
         mut config: Config,
+        geodata_manager: &GeoDataManager,
+    ) -> io::Result<(Config, Option<crate::resource::cache::ProviderCache>)> {
+        if config
+            .http_policy()
+            .is_some_and(|policy| !policy.is_prepared())
+        {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "HTTP resources or private context are not prepared",
+            ));
+        }
+        let provider_cache = if let Some(template) = config.providers.clone() {
+            let root = geodata_manager
+                .store_dir()
+                .parent()
+                .ok_or_else(|| io::Error::other("dataDir is missing"))?
+                .to_path_buf();
+            let cache = tokio::task::spawn_blocking(move || {
+                crate::resource::cache::ProviderCache::open(&root, template)
+            })
+            .await
+            .map_err(io::Error::other)??;
+            config = cache
+                .template
+                .materialize(&cache.contents)
+                .map_err(io::Error::other)?;
+            Some(cache)
+        } else {
+            None
+        };
+        Ok((config, provider_cache))
+    }
+
+    pub(crate) async fn prepare_resolved(
+        mut config: Config,
+        provider_cache: Option<crate::resource::cache::ProviderCache>,
         geodata_manager: Arc<GeoDataManager>,
         resolver: &dyn Resolver,
         limits: ResourceLimits,
@@ -264,16 +355,22 @@ impl PreparedCore {
         limits
             .validate()
             .map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error))?;
+        crate::dns::hosts::materialize_lan(&mut config.dns.hosts)?;
         let (rules, geodata_registration) = prepare_routing(&mut config, &geodata_manager)?;
-        let endpoints =
-            prepare_proxy_endpoints(&config.proxies, &config.proxy_groups, resolver, config.ipv6)
-                .await?;
+        let _ = resolver;
+        let endpoints = vec![PreparedProxyEndpoints::default(); config.proxies.len()];
         let traffic_stats = config
             .tun
             .enable
             .then(|| Arc::new(TunTrafficStats::default()));
+        let trust = config.tls.clone();
+        let security = tokio::task::spawn_blocking(move || SecurityContext::load(&trust))
+            .await
+            .map_err(io::Error::other)?;
         Ok(Self {
             config,
+            security,
+            provider_cache: std::sync::Mutex::new(provider_cache),
             endpoints,
             limits,
             rules,
@@ -286,9 +383,9 @@ impl PreparedCore {
     /// Performs every configuration-owned validation step without resolving
     /// the proxy, opening GeoData files, or retaining a matcher.
     pub(crate) fn validate_config(mut config: Config) -> io::Result<()> {
-        GeoRequirements::collect(&config.rules, &config.dns.nameserver_policies)
+        GeoRequirements::for_config(&config)
             .map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error))?;
-        RuleSet::compile(std::mem::take(&mut config.rules))
+        RuleSet::compile_config(&mut config)
             .map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error))?;
         Ok(())
     }
@@ -333,112 +430,17 @@ impl PreparedCore {
         self.traffic_stats.clone()
     }
 
-    fn dns_redir_host_entries(&self) -> usize {
-        if self.has_tun() && self.rules.uses_domain_routing() {
-            self.limits.dns_redir_host_entries
-        } else {
-            0
-        }
-    }
-
     // Sniffing remains a shared TUN capability, including Windows CLI.
     #[cfg_attr(
         all(feature = "cli", not(feature = "invoke"), unix, not(test)),
         allow(dead_code)
     )]
     fn domain_sniffer_config(&self) -> Option<Arc<crate::config::SnifferConfig>> {
-        (self.has_tun() && self.config.sniffer.enable && self.rules.uses_domain_routing())
+        (self.has_tun() && self.config.sniffer.enable)
             .then(|| Arc::new(self.config.sniffer.clone()))
     }
 
-    fn build_dispatcher(&self, dialer: Dialer) -> io::Result<BuiltRuntimeParts> {
-        let dialer = dialer
-            .with_ipv6(self.config.ipv6)
-            .with_fresh_initialization();
-        let handshake_stats = RuntimeResourceStats::new("runtime_handshake_observation");
-        let proxy_graph = self.build_proxy_graph(dialer.clone())?;
-        let proxy_dispatchers = self.wrap_proxy_dispatchers(
-            proxy_graph.connectors(),
-            &handshake_stats,
-            &proxy_graph.resolution,
-        )?;
-        let direct_raw: Arc<dyn Dispatcher> = Arc::new(DirectOutbound::new(dialer));
-        let direct = observe_handshakes_with_stats(direct_raw, handshake_stats.clone());
-        let proxy_groups = ProxyGroups::with_selections(
-            &self.config.proxy_groups,
-            proxy_dispatchers.clone(),
-            direct.clone(),
-            &proxy_graph.selections,
-        )
-        .map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error))?;
-        let route_targets =
-            RouteTargetDispatchers::with_proxy_groups(proxy_dispatchers, &proxy_groups)
-                .map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error))?;
-        let rules = self.rules.clone();
-        let redir_host_entries = self.dns_redir_host_entries();
-        let geo_matcher: Arc<dyn GeoMatcher> = self.geodata_registration.matcher();
-        let dns = self.config.dns.enable.then(|| {
-            Arc::new(RuntimeDns::new_routed_proxies_with_cache_limits(
-                &self.config.dns,
-                route_targets.clone(),
-                direct.clone(),
-                rules.clone(),
-                geo_matcher.clone(),
-                self.limits.dns_address_cache_entries,
-                redir_host_entries,
-            ))
-        });
-        proxy_graph.resolution.bind_runtime(dns.as_ref())?;
-        let geodata_rules = RuleSet::compile(vec![crate::config::RuleSpec {
-            kind: crate::config::RuleKind::Match,
-            action: crate::config::RuleAction::Route(self.config.default_route_target),
-            no_resolve: false,
-        }])
-        .map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error))?;
-        let geodata_dispatcher: Arc<dyn Dispatcher> = Arc::new(RoutingDispatcher::new_with_ipv6(
-            route_targets.clone(),
-            direct.clone(),
-            dns.clone(),
-            self.config.ipv6,
-            geodata_rules,
-            geo_matcher.clone(),
-        ));
-        let router: Arc<dyn Dispatcher> = Arc::new(
-            RoutingDispatcher::new_with_ipv6(
-                route_targets,
-                direct,
-                dns.clone(),
-                self.config.ipv6,
-                rules,
-                geo_matcher,
-            )
-            .with_tun_config(&self.config.tun),
-        );
-        let session_stats = RuntimeResourceStats::new("runtime_session_observation");
-        Ok(BuiltRuntimeParts {
-            dispatcher: observe_sessions_with_stats(router, session_stats),
-            dns,
-            geodata_updater: {
-                let report = self.geodata_registration.initial_report();
-                let required = report.geosite.required || report.geoip.required;
-                self.config
-                    .geodata_update
-                    .as_ref()
-                    .filter(|update| update.auto_update && required)
-                    .map(|update| {
-                        GeoDataUpdateService::new(
-                            self.geodata_manager.clone(),
-                            geodata_dispatcher,
-                            self.geodata_registration.updater_lease(),
-                            update.urls.clone(),
-                        )
-                    })
-            },
-            proxy_groups,
-            proxy_graph,
-        })
-    }
-
+    #[cfg(test)]
     fn build_proxy_graph(&self, dialer: Dialer) -> io::Result<BuiltProxyGraph> {
         build_proxy_graph(
             &self.config.proxies,
@@ -447,25 +449,57 @@ impl PreparedCore {
             self.limits,
             dialer,
             ResolutionContext::runtime(self.config.ipv6),
+            &self.security,
+            None,
         )
     }
 
-    fn wrap_proxy_dispatchers(
-        &self,
-        connectors: &[Arc<dyn OutboundConnector>],
-        handshake_stats: &RuntimeResourceStats,
-        resolution: &ResolutionContext,
-    ) -> io::Result<Vec<Arc<dyn Dispatcher>>> {
-        let mut dispatchers = Vec::with_capacity(connectors.len());
-        for (proxy, connector) in self.config.proxies.iter().zip(connectors) {
-            let mut dispatcher: Arc<dyn Dispatcher> = Arc::new(
-                ConnectorDispatcher::with_udp_capability(connector.clone(), proxy.udp)
-                    .with_resolution(resolution.clone()),
-            );
-            dispatcher = observe_handshakes_with_stats(dispatcher, handshake_stats.clone());
-            dispatchers.push(dispatcher);
+    fn build_dispatcher(&self, dialer: Dialer) -> io::Result<BuiltRuntimeParts> {
+        let mut parts = GraphBuilder {
+            security: self.security.clone(),
+            connections: Arc::default(),
+            config: self.config.clone(),
+            endpoints: self.endpoints.clone(),
+            limits: self.limits,
+            rules: self.rules.clone(),
+            geo_matcher: self.geodata_registration.matcher(),
+            previous_dns: None,
+            data_dir: self
+                .geodata_manager
+                .store_dir()
+                .parent()
+                .map(std::path::Path::to_path_buf),
         }
-        Ok(dispatchers)
+        .build(dialer.clone())?;
+        if let Some(cache) = self.provider_cache.lock().unwrap().take() {
+            let resources = ProviderRuntime::new(cache, self, &parts, dialer);
+            parts.dispatcher = resources.clone();
+            parts.resources = Some(resources);
+        }
+        let report = self.geodata_registration.initial_report();
+        if let Some(update) = self.config.geodata_update.as_ref().filter(|_| {
+            report.geosite.required
+                || report.geoip.required
+                || report.asn.required
+                || self
+                    .config
+                    .providers
+                    .as_ref()
+                    .is_some_and(|providers| !providers.rules.is_empty())
+        }) {
+            parts.geodata_updater = Some(GeoDataUpdateService::new(
+                self.geodata_manager.clone(),
+                parts.dispatcher.clone(),
+                self.geodata_registration.updater_lease(),
+                update.urls.clone(),
+                update.geodata_mode,
+                self.config.global_ua.clone(),
+                self.config.etag_support,
+                update.auto_update && update.interval_hours > 0,
+                self.security.clone(),
+            ));
+        }
+        Ok(parts)
     }
 
     async fn bind_controller(
@@ -478,9 +512,17 @@ impl PreparedCore {
         };
         #[cfg(any(feature = "inbound-http", feature = "inbound-socks5"))]
         {
-            RuntimeController::bind(config, traffic, proxy_groups)
-                .await
-                .map(Some)
+            RuntimeController::bind_at(
+                config,
+                traffic,
+                proxy_groups,
+                self.geodata_manager
+                    .store_dir()
+                    .parent()
+                    .unwrap_or(self.geodata_manager.store_dir()),
+            )
+            .await
+            .map(Some)
         }
         #[cfg(not(any(feature = "inbound-http", feature = "inbound-socks5")))]
         {
@@ -495,14 +537,29 @@ impl PreparedCore {
     /// Starts configured local proxy listeners. TUN is started separately once
     /// a platform descriptor and netstack are available.
     pub(crate) async fn start_local(self, dialer: Dialer) -> io::Result<RunningCore> {
+        let dispatch = crate::logging::dispatch(self.config.log_level);
+        self.start_local_inner(dialer)
+            .with_subscriber(dispatch)
+            .await
+    }
+
+    async fn start_local_inner(self, dialer: Dialer) -> io::Result<RunningCore> {
         let BuiltRuntimeParts {
             dispatcher,
             geodata_updater,
             proxy_groups,
             proxy_graph,
+            resources,
             ..
         } = self.build_dispatcher(dialer)?;
         let controller = self.bind_controller(None, proxy_groups).await?;
+        #[cfg(any(feature = "inbound-http", feature = "inbound-socks5"))]
+        let controller = {
+            let control = resources.as_ref().map(|resources| {
+                resources.clone() as Arc<dyn crate::resource::control::RuntimeResources>
+            });
+            controller.map(|controller| controller.with_resources(control))
+        };
         RunningCore::start_components(
             &self.config.inbounds,
             dispatcher,
@@ -512,6 +569,7 @@ impl PreparedCore {
             geodata_updater,
             self.geodata_registration,
             proxy_graph,
+            resources,
         )
         .await
     }
@@ -548,7 +606,45 @@ impl PreparedCore {
         all(feature = "cli", not(feature = "invoke"), unix, not(test)),
         allow(dead_code)
     )]
-    pub(crate) async fn start_tun(mut self, tun: TunIo, dialer: Dialer) -> io::Result<RunningCore> {
+    pub(crate) async fn start_tun(self, tun: TunIo, dialer: Dialer) -> io::Result<RunningCore> {
+        let dispatch = crate::logging::dispatch(self.config.log_level);
+        self.start_tun_inner(tun, dialer)
+            .with_subscriber(dispatch)
+            .await
+    }
+
+    #[cfg(all(feature = "tun", target_os = "linux"))]
+    pub(crate) async fn start_native_tun(self, dialer: Dialer) -> io::Result<RunningCore> {
+        let (tun, dialer, mut network) = crate::platform::linux_network::open(
+            &self.config.tun,
+            &self.config.dns,
+            self.config.ipv6,
+            dialer,
+        )?;
+        match self.start_tun(tun, dialer).await {
+            Ok(mut running) => {
+                running.system_network = network;
+                Ok(running)
+            }
+            Err(error) => {
+                if let Some(network) = &mut network {
+                    network.restore()?;
+                }
+                Err(error)
+            }
+        }
+    }
+
+    #[cfg(all(
+        feature = "tun",
+        any(
+            unix,
+            all(windows, any(feature = "windows-wintun", feature = "windows-uwp"))
+        )
+    ))]
+    async fn start_tun_inner(mut self, tun: TunIo, dialer: Dialer) -> io::Result<RunningCore> {
+        #[cfg(any(target_os = "linux", target_os = "macos"))]
+        let dialer = dialer.with_dns_tun_interface(tun.interface_name().ok().map(Into::into));
         self.limits.tun_max_datagram_size = usize::from(self.config.tun.mtu);
         let tun_count = self
             .config
@@ -568,14 +664,20 @@ impl PreparedCore {
             geodata_updater,
             proxy_groups,
             proxy_graph,
+            resources,
+            ..
         } = self.build_dispatcher(dialer)?;
         let sniffer = self.domain_sniffer_config();
         let traffic_stats = self
             .traffic_stats()
             .unwrap_or_else(|| Arc::new(TunTrafficStats::default()));
+        let control = resources.as_ref().map(|resources| {
+            resources.clone() as Arc<dyn crate::resource::control::RuntimeResources>
+        });
         let controller = self
             .bind_controller(Some(traffic_stats.clone()), proxy_groups)
-            .await?;
+            .await?
+            .map(|controller| controller.with_resources(control.clone()));
         let tun_runtime = TunRuntime::new_with_stats(
             tun,
             self.limits,
@@ -586,7 +688,25 @@ impl PreparedCore {
             true,
             sniffer,
             traffic_stats.clone(),
-        )?;
+        )?
+        .with_resources(control);
+        #[cfg(target_os = "linux")]
+        let tun_runtime = tun_runtime
+            .with_real_echo(
+                proxy_graph.dialer.clone(),
+                [
+                    self.config.dns.fake_ip.range,
+                    self.config.dns.fake_ip.range6,
+                ]
+                .map(|range| {
+                    range
+                        .filter(|_| self.config.dns.fake_ip.enabled)
+                        .map(|range| range.cidr)
+                }),
+                self.config.tun.icmp_timeout,
+                self.config.tun.disable_icmp_forwarding,
+            )
+            .await?;
         RunningCore::start_components(
             &self.config.inbounds,
             dispatcher,
@@ -596,11 +716,231 @@ impl PreparedCore {
             geodata_updater,
             self.geodata_registration,
             proxy_graph,
+            resources,
         )
         .await
     }
 }
 
+struct GraphBuilder {
+    security: SecurityContext,
+    connections: Arc<crate::connections::Registry>,
+    config: Config,
+    endpoints: Vec<PreparedProxyEndpoints>,
+    limits: ResourceLimits,
+    rules: RuleSet,
+    geo_matcher: Arc<dyn GeoMatcher>,
+    previous_dns: Option<Arc<RuntimeDns>>,
+    data_dir: Option<std::path::PathBuf>,
+}
+impl GraphBuilder {
+    fn build(&self, dialer: Dialer) -> io::Result<BuiltRuntimeParts> {
+        let dialer = dialer
+            .with_ipv6(self.config.ipv6)
+            .with_connections(self.config.connections)
+            .with_egress(&self.config.egress)
+            .with_fresh_initialization();
+        dialer.validate_egress()?;
+        let handshake_stats = RuntimeResourceStats::new("runtime_handshake_observation");
+        let diagnostics = (self.config.external_controller.is_some()
+            || self
+                .config
+                .proxies
+                .iter()
+                .any(|p| p.smux.as_ref().is_some_and(|s| s.statistic)))
+        .then(|| {
+            Arc::new(diagnostics::Diagnostics::new(
+                &self.config,
+                &self.rules,
+                self.connections.clone(),
+            ))
+        });
+        let proxy_graph = self.build_proxy_graph(dialer.clone(), diagnostics.as_ref())?;
+        let proxy_dispatchers = self.wrap_proxy_dispatchers(
+            proxy_graph.connectors(),
+            &handshake_stats,
+            &proxy_graph.resolution,
+        )?;
+        let activities = proxy_dispatchers
+            .iter()
+            .map(|_| health::Activity::new())
+            .collect::<Vec<_>>();
+        let proxy_dispatchers = proxy_dispatchers
+            .into_iter()
+            .zip(&activities)
+            .map(|(dispatcher, activity)| {
+                Arc::new(health::ActiveDispatcher {
+                    dispatcher,
+                    activity: activity.clone(),
+                }) as Arc<dyn Dispatcher>
+            })
+            .collect::<Vec<_>>();
+        let direct_raw: Arc<dyn Dispatcher> = Arc::new(DirectOutbound::new(dialer.clone()));
+        let direct = observe_handshakes_with_stats(direct_raw, handshake_stats.clone());
+        let reject_drop: Arc<dyn Dispatcher> = Arc::new(
+            ConnectorDispatcher::new(proxy_graph.reject_drop.clone())
+                .with_resolution(proxy_graph.resolution.clone()),
+        );
+        let proxy_groups = ProxyGroups::with_selections_and_drop(
+            &self.config.proxy_groups,
+            proxy_dispatchers.clone(),
+            direct.clone(),
+            &proxy_graph.selections,
+            reject_drop.clone(),
+            crate::routing::RematchTargets::new(&self.config.proxies),
+        )
+        .map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error))?;
+        let route_targets =
+            RouteTargetDispatchers::with_proxy_groups(proxy_dispatchers, &proxy_groups)
+                .map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error))?;
+        let rules = self.rules.clone();
+        let redir_host_entries = if self.config.dns.enable
+            && (self.rules.uses_domain_routing() || self.config.sniffer.enable)
+        {
+            self.limits.dns_redir_host_entries
+        } else {
+            0
+        };
+        let geo_matcher = self.geo_matcher.clone();
+        let mut dns_config = self.config.dns.clone();
+        if !dns_config.enable {
+            dns_config.ipv6 = self.config.ipv6;
+        }
+        let dns = Some(Arc::new(
+            RuntimeDns::new_routed_proxies_with_cache_limits_and_security(
+                &dns_config,
+                route_targets.clone(),
+                direct.clone(),
+                rules.clone(),
+                geo_matcher.clone(),
+                dns_config.cache_max_size,
+                redir_host_entries,
+                self.security.clone(),
+            )
+            .with_network_sources(
+                dialer.clone(),
+                crate::dns::source::SourceExclusions {
+                    interface: dialer.dns_tun_interface().or_else(|| {
+                        (self.config.tun.enable && !self.config.tun.device.is_empty())
+                            .then(|| self.config.tun.device.as_str().into())
+                    }),
+                    addresses: if self.config.tun.enable {
+                        vec![
+                            self.config
+                                .dns
+                                .fake_ip
+                                .range
+                                .map(|range| range.interface_address)
+                                .unwrap_or_else(|| "198.18.0.1".parse().unwrap()),
+                            self.config
+                                .dns
+                                .fake_ip
+                                .range
+                                .map(|range| match range.interface_address {
+                                    std::net::IpAddr::V4(ip) => std::net::IpAddr::V4(
+                                        std::net::Ipv4Addr::from(u32::from(ip).saturating_add(1)),
+                                    ),
+                                    ip => ip,
+                                })
+                                .unwrap_or_else(|| "198.18.0.2".parse().unwrap()),
+                            "fdfe:dcba:9876::1".parse().unwrap(),
+                            "fdfe:dcba:9876::2".parse().unwrap(),
+                        ]
+                    } else {
+                        Vec::new()
+                    },
+                },
+            )
+            .with_mapping_from(self.previous_dns.as_deref())
+            .with_fake_ip_store(if self.config.profile.store_fake_ip {
+                self.data_dir.as_deref()
+            } else {
+                None
+            })?,
+        ));
+        if let Some(dns) = &dns {
+            dns.enable_refresh(self.previous_dns.as_deref());
+            dns.network_sources().register(dns);
+        }
+        proxy_graph.resolution.bind_runtime(dns.as_ref())?;
+        let health = health::HealthRuntime::new(
+            &self.config,
+            proxy_groups.clone(),
+            route_targets.clone(),
+            direct.clone(),
+            activities,
+            dns.clone(),
+            self.security.clone(),
+        );
+        let mut router = RoutingDispatcher::new_with_ipv6(
+            route_targets.clone(),
+            direct.clone(),
+            dns.clone(),
+            self.config.ipv6,
+            rules,
+            geo_matcher,
+        )
+        .with_tun_config(&self.config.tun)
+        .with_sniffer(&self.config.sniffer)
+        .with_process_lookup(self.config.find_process_mode, proxy_graph.dialer.clone())
+        .with_tcp_concurrent(self.config.connections.tcp_concurrent);
+        router = router.with_reject_drop(reject_drop);
+        if let Some(diagnostics) = &diagnostics {
+            router = router.with_diagnostics(diagnostics.clone());
+        }
+        let router: Arc<dyn Dispatcher> = Arc::new(router);
+        let session_stats = RuntimeResourceStats::new("runtime_session_observation");
+        Ok(BuiltRuntimeParts {
+            connections: self.connections.clone(),
+            diagnostics,
+            dispatcher: observe_sessions_with_stats(router, session_stats),
+            dns,
+            geodata_updater: None,
+            proxy_groups,
+            proxy_graph: Arc::new(proxy_graph),
+            resources: None,
+            health,
+            resource_targets: route_targets,
+            direct,
+        })
+    }
+
+    fn build_proxy_graph(
+        &self,
+        dialer: Dialer,
+        diagnostics: Option<&Arc<diagnostics::Diagnostics>>,
+    ) -> io::Result<BuiltProxyGraph> {
+        build_proxy_graph(
+            &self.config.proxies,
+            &self.config.proxy_groups,
+            &self.endpoints,
+            self.limits,
+            dialer,
+            ResolutionContext::runtime(self.config.ipv6),
+            &self.security,
+            diagnostics,
+        )
+    }
+
+    fn wrap_proxy_dispatchers(
+        &self,
+        connectors: &[Arc<dyn OutboundConnector>],
+        handshake_stats: &RuntimeResourceStats,
+        resolution: &ResolutionContext,
+    ) -> io::Result<Vec<Arc<dyn Dispatcher>>> {
+        let mut dispatchers = Vec::with_capacity(connectors.len());
+        for (proxy, connector) in self.config.proxies.iter().zip(connectors) {
+            let mut dispatcher: Arc<dyn Dispatcher> = Arc::new(
+                ConnectorDispatcher::with_udp_capability(connector.clone(), proxy.udp)
+                    .with_resolution(resolution.clone()),
+            );
+            dispatcher = observe_handshakes_with_stats(dispatcher, handshake_stats.clone());
+            dispatchers.push(dispatcher);
+        }
+        Ok(dispatchers)
+    }
+}
+
 #[cfg(feature = "invoke")]
 impl PreparedMeasurement {
     pub(crate) async fn prepare_config(
@@ -612,8 +952,13 @@ impl PreparedMeasurement {
             .validate()
             .map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error))?;
         let endpoints = prepare_proxy_endpoints(&config.proxies, &[], resolver, true).await?;
+        let trust = config.tls.clone();
+        let security = tokio::task::spawn_blocking(move || SecurityContext::load(&trust))
+            .await
+            .map_err(io::Error::other)?;
         Ok(Self {
             config,
+            security,
             endpoints,
             limits,
         })
@@ -629,13 +974,21 @@ impl PreparedMeasurement {
         resolver: Arc<dyn Resolver>,
     ) -> io::Result<MeasurementRuntime> {
         let dialer = dialer.with_fresh_initialization();
+        let ech_dns = Arc::new(RuntimeDns::measurement_ech(
+            dialer.clone(),
+            self.security.clone(),
+        ));
+        let resolution = ResolutionContext::measurement(resolver, true);
+        resolution.bind_measurement_ech(&ech_dns)?;
         let proxy_graph = build_proxy_graph(
             &self.config.proxies,
             &[],
             &self.endpoints,
             self.limits,
             dialer,
-            ResolutionContext::measurement(resolver, true),
+            resolution,
+            &self.security,
+            None,
         )?;
         let connector = proxy_graph
             .get(self.config.default_proxy.index())
@@ -653,12 +1006,15 @@ impl PreparedMeasurement {
         let dispatcher = observe_handshakes_with_stats(dispatcher, handshake_stats);
         let session_stats = RuntimeResourceStats::new("measurement_session_observation");
         Ok(MeasurementRuntime {
+            security: self.security,
             dispatcher: observe_sessions_with_stats(dispatcher, session_stats),
-            proxy_graph,
+            proxy_graph: Arc::new(proxy_graph),
+            _ech_dns: ech_dns,
         })
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 fn build_proxy_graph(
     proxies: &[ProxyConfig],
     groups: &[SelectProxyGroupConfig],
@@ -666,6 +1022,8 @@ fn build_proxy_graph(
     limits: ResourceLimits,
     dialer: Dialer,
     resolution: ResolutionContext,
+    security: &SecurityContext,
+    diagnostics: Option<&Arc<diagnostics::Diagnostics>>,
 ) -> io::Result<BuiltProxyGraph> {
     if endpoints.len() != proxies.len() {
         return Err(io::Error::new(
@@ -676,33 +1034,45 @@ fn build_proxy_graph(
     let order = proxy_graph_order(proxies, groups)
         .map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error))?;
     #[cfg(any(
+        feature = "outbound-http",
+        feature = "outbound-socks5",
         feature = "outbound-anytls",
         feature = "outbound-vless",
         feature = "outbound-trojan",
+        feature = "outbound-trusttunnel",
         feature = "outbound-vmess",
         feature = "outbound-hysteria2",
         feature = "outbound-tuic",
-        feature = "shadow-tls-v3"
+        feature = "shadow-tls-v3",
+        feature = "outbound-shadowsocks"
     ))]
-    let (security_client_count, standard_tls_count) = security_counts(proxies);
+    let (_, standard_tls_count) = security_counts(proxies);
     #[cfg(any(
+        feature = "outbound-http",
+        feature = "outbound-socks5",
         feature = "outbound-anytls",
         feature = "outbound-vless",
         feature = "outbound-trojan",
+        feature = "outbound-trusttunnel",
         feature = "outbound-vmess",
         feature = "outbound-hysteria2",
         feature = "outbound-tuic",
-        feature = "shadow-tls-v3"
+        feature = "shadow-tls-v3",
+        feature = "outbound-shadowsocks"
     ))]
-    let security_context = (security_client_count != 0).then(SecurityContext::new);
+    let security_context = Some(security.clone());
     #[cfg(any(
+        feature = "outbound-http",
+        feature = "outbound-socks5",
         feature = "outbound-anytls",
         feature = "outbound-vless",
         feature = "outbound-trojan",
+        feature = "outbound-trusttunnel",
         feature = "outbound-vmess",
         feature = "outbound-hysteria2",
         feature = "outbound-tuic",
-        feature = "shadow-tls-v3"
+        feature = "shadow-tls-v3",
+        feature = "outbound-shadowsocks"
     ))]
     let resumption_sessions = standard_tls_resumption_sessions(standard_tls_count);
 
@@ -716,8 +1086,13 @@ fn build_proxy_graph(
         lifecycle_order: Vec::with_capacity(order.len()),
         selections: groups
             .iter()
-            .map(|group| Arc::new(AtomicUsize::new(group.initial_member)))
+            .map(|group| {
+                let selection = Arc::new(crate::routing::GroupSelection::new(group.initial_member));
+                selection.configure_balance(group);
+                selection
+            })
             .collect(),
+        reject_drop: Arc::new(crate::outbound::RejectOutbound::drop_connections()),
     };
     let mut nodes: Vec<Option<Arc<dyn OutboundConnector>>> = vec![None; proxies.len()];
     let mut group_nodes: Vec<Option<Arc<SelectUpstream>>> = vec![None; groups.len()];
@@ -747,12 +1122,16 @@ fn build_proxy_graph(
                         }
                         ProxyGroupMemberTarget::Direct => SelectUpstreamMember::Direct,
                         ProxyGroupMemberTarget::Reject => SelectUpstreamMember::Reject,
+                        ProxyGroupMemberTarget::RejectDrop => {
+                            SelectUpstreamMember::Proxy(graph.reject_drop.clone())
+                        }
+                        ProxyGroupMemberTarget::Control(_) => SelectUpstreamMember::Control,
                     })
                     .collect();
-                let group = Arc::new(SelectUpstream::new(
-                    graph.selections[id.index()].clone(),
-                    members,
-                ));
+                let group = Arc::new(
+                    SelectUpstream::new(graph.selections[id.index()].clone(), members)
+                        .with_udp_disabled(config.disable_udp),
+                );
                 group_nodes[id.index()] = Some(group.clone());
                 graph.lifecycle_order.push(BuiltRouteTarget::Group(group));
                 continue;
@@ -760,37 +1139,158 @@ fn build_proxy_graph(
             RouteTargetId::Proxy(id) => id.index(),
         };
         let proxy = &proxies[index];
-        let upstream = build_upstream_path(
-            proxy.dialer_proxy,
-            endpoints[index].upload.clone(),
-            &nodes,
-            &group_nodes,
-            &dialer,
-        )?;
+        let node_dialer = dialer
+            .clone()
+            .with_ip_version(proxy.ip_version)
+            .with_tfo(proxy.tfo)
+            .with_mptcp(proxy.mptcp)
+            .with_egress(&proxy.egress);
+        node_dialer.validate_egress()?;
         let connector: Arc<dyn OutboundConnector> = match &proxy.protocol {
-            ProxyProtocol::Tuic(config) => {
-                #[cfg(feature = "outbound-tuic")]
-                {
-                    Arc::new(crate::outbound::tuic::TuicOutbound::with_shared_security(
-                        config,
-                        upstream,
-                        security_context.as_ref().expect("TLS context"),
-                        limits.tls_buffer_limit,
-                    )?)
-                }
-                #[cfg(not(feature = "outbound-tuic"))]
-                {
-                    let _ = config;
-                    return Err(io::Error::new(
-                        io::ErrorKind::Unsupported,
-                        "TUIC support is disabled in this build",
-                    ));
-                }
+            ProxyProtocol::Direct => {
+                Arc::new(crate::outbound::NamedDirectOutbound::new(node_dialer))
             }
-            ProxyProtocol::Hysteria2(config) => {
-                #[cfg(feature = "outbound-hysteria2")]
-                {
-                    Arc::new(
+            ProxyProtocol::Dns => Arc::new(crate::outbound::DnsOutbound::default()),
+            ProxyProtocol::Reject => Arc::new(crate::outbound::RejectOutbound::default()),
+            ProxyProtocol::Rematch(_) => Arc::new(crate::outbound::RuleControlConnector),
+            _ => {
+                let (address, port) = proxy
+                    .server_endpoint()
+                    .expect("remote protocol has an endpoint");
+                let upstream = build_upstream_path(
+                    crate::outbound::server_destination(address, port)?,
+                    proxy.dialer_proxy,
+                    endpoints[index].upload.clone(),
+                    &nodes,
+                    &group_nodes,
+                    &node_dialer,
+                )?;
+                match &proxy.protocol {
+                    ProxyProtocol::Direct
+                    | ProxyProtocol::Dns
+                    | ProxyProtocol::Reject
+                    | ProxyProtocol::Rematch(_) => {
+                        unreachable!("functional route was constructed without a server endpoint")
+                    }
+                    ProxyProtocol::Masque(config) => {
+                        #[cfg(feature = "outbound-masque")]
+                        {
+                            Arc::new(
+                                crate::outbound::masque::MasqueOutbound::with_shared_security(
+                                    config, upstream, security,
+                                )?,
+                            )
+                        }
+                        #[cfg(not(feature = "outbound-masque"))]
+                        {
+                            let _ = (config, upstream);
+                            return Err(io::Error::new(
+                                io::ErrorKind::Unsupported,
+                                "MASQUE outbound support is disabled at build time",
+                            ));
+                        }
+                    }
+                    ProxyProtocol::WireGuard(config) => {
+                        #[cfg(feature = "outbound-wireguard")]
+                        {
+                            Arc::new(
+                        crate::outbound::wireguard::WireGuardOutbound::with_shared_security(
+                            config, upstream, security,
+                        )?,
+                    )
+                        }
+                        #[cfg(not(feature = "outbound-wireguard"))]
+                        {
+                            let _ = (config, upstream);
+                            return Err(io::Error::new(
+                                io::ErrorKind::Unsupported,
+                                "WireGuard support is disabled",
+                            ));
+                        }
+                    }
+                    ProxyProtocol::Http(config) => {
+                        #[cfg(feature = "outbound-http")]
+                        {
+                            Arc::new(crate::outbound::http::HttpOutbound::with_shared_security(
+                                config,
+                                upstream,
+                                security_context.as_ref().expect("HTTP security context"),
+                                resumption_sessions,
+                                limits.tls_buffer_limit,
+                            )?)
+                        }
+                        #[cfg(not(feature = "outbound-http"))]
+                        {
+                            let _ = (config, upstream);
+                            return Err(io::Error::new(
+                                io::ErrorKind::Unsupported,
+                                "HTTP outbound support is disabled",
+                            ));
+                        }
+                    }
+                    ProxyProtocol::TrustTunnel(config) => {
+                        #[cfg(feature = "outbound-trusttunnel")]
+                        {
+                            Arc::new(TrustTunnelOutbound::with_shared_security(
+                                config,
+                                upstream,
+                                security_context
+                                    .as_ref()
+                                    .expect("TrustTunnel security context"),
+                                resumption_sessions,
+                                limits.tls_buffer_limit,
+                            )?)
+                        }
+                        #[cfg(not(feature = "outbound-trusttunnel"))]
+                        {
+                            let _ = (config, upstream);
+                            return Err(io::Error::new(
+                                io::ErrorKind::Unsupported,
+                                "TrustTunnel outbound support is disabled at build time",
+                            ));
+                        }
+                    }
+                    ProxyProtocol::Mieru(config) => {
+                        #[cfg(feature = "outbound-mieru")]
+                        {
+                            Arc::new(crate::outbound::mieru::MieruOutbound::new(
+                                config,
+                                upstream,
+                                limits.tcp_buffer_per_direction,
+                            )?)
+                        }
+                        #[cfg(not(feature = "outbound-mieru"))]
+                        {
+                            let _ = (config, upstream);
+                            return Err(io::Error::new(
+                                io::ErrorKind::Unsupported,
+                                "Mieru outbound support is disabled at build time",
+                            ));
+                        }
+                    }
+                    ProxyProtocol::Tuic(config) => {
+                        #[cfg(feature = "outbound-tuic")]
+                        {
+                            Arc::new(crate::outbound::tuic::TuicOutbound::with_shared_security(
+                                config,
+                                upstream,
+                                security_context.as_ref().expect("TLS context"),
+                                limits.tls_buffer_limit,
+                            )?)
+                        }
+                        #[cfg(not(feature = "outbound-tuic"))]
+                        {
+                            let _ = config;
+                            return Err(io::Error::new(
+                                io::ErrorKind::Unsupported,
+                                "TUIC support is disabled in this build",
+                            ));
+                        }
+                    }
+                    ProxyProtocol::Hysteria2(config) => {
+                        #[cfg(feature = "outbound-hysteria2")]
+                        {
+                            Arc::new(
                         crate::outbound::hysteria2::Hysteria2Outbound::with_shared_security(
                             config,
                             upstream,
@@ -799,163 +1299,197 @@ fn build_proxy_graph(
                             limits.tls_buffer_limit,
                         )?,
                     )
-                }
-                #[cfg(not(feature = "outbound-hysteria2"))]
-                {
-                    let _ = config;
-                    return Err(io::Error::new(
-                        io::ErrorKind::Unsupported,
-                        "Hysteria2 support is disabled in this build",
-                    ));
-                }
-            }
-            ProxyProtocol::Vmess(config) => {
-                #[cfg(feature = "outbound-vmess")]
-                {
-                    Arc::new(crate::outbound::vmess::VmessOutbound::with_shared_security(
-                        config,
-                        upstream,
-                        security_context.as_ref().expect("VMess security context"),
-                        resumption_sessions,
-                        limits.tls_buffer_limit,
-                    )?)
-                }
-                #[cfg(not(feature = "outbound-vmess"))]
-                {
-                    let _ = (config, upstream);
-                    return Err(io::Error::new(
-                        io::ErrorKind::Unsupported,
-                        "VMess outbound support is disabled at build time",
-                    ));
-                }
-            }
-            ProxyProtocol::Trojan(config) => {
-                #[cfg(feature = "outbound-trojan")]
-                {
-                    Arc::new(TrojanOutbound::with_shared_security(
-                        config,
-                        upstream,
-                        security_context
-                            .as_ref()
-                            .expect("Trojan graph has security material"),
-                        resumption_sessions,
-                        limits.tls_buffer_limit,
-                    )?)
-                }
-                #[cfg(not(feature = "outbound-trojan"))]
-                {
-                    let _ = (config, upstream);
-                    return Err(io::Error::new(
-                        io::ErrorKind::Unsupported,
-                        "Trojan outbound support is disabled at build time",
-                    ));
-                }
-            }
-            ProxyProtocol::Shadowsocks(config) => {
-                #[cfg(feature = "outbound-shadowsocks")]
-                {
-                    #[cfg(feature = "shadow-tls-v3")]
-                    let security = security_context.as_ref();
-                    Arc::new(ShadowsocksOutbound::with_security(
-                        config,
-                        upstream,
-                        #[cfg(feature = "shadow-tls-v3")]
-                        security,
-                    )?)
-                }
-                #[cfg(not(feature = "outbound-shadowsocks"))]
-                {
-                    let _ = (config, upstream);
-                    return Err(io::Error::new(
-                        io::ErrorKind::Unsupported,
-                        "Shadowsocks outbound support is disabled at build time",
-                    ));
-                }
-            }
-            ProxyProtocol::Vless(config) => {
-                #[cfg(feature = "outbound-vless")]
-                {
-                    let download_upstream = config
-                        .download()
-                        .map(|_| {
-                            build_upstream_path(
-                                proxy.dialer_proxy,
-                                endpoints[index].download.clone(),
-                                &nodes,
-                                &group_nodes,
-                                &dialer,
-                            )
-                        })
-                        .transpose()?;
-                    Arc::new(VlessOutbound::new_with_shared_security(
-                        config,
-                        upstream,
-                        download_upstream,
-                        security_context
-                            .as_ref()
-                            .expect("VLESS graph has shared security material"),
-                        resumption_sessions,
-                        VlessResourceLimits::new(
-                            limits.tls_buffer_limit,
-                            limits.xhttp_send_buffer_size,
-                            limits.xhttp_upload_chunk_size,
-                        ),
-                    )?)
-                }
-                #[cfg(not(feature = "outbound-vless"))]
-                {
-                    let _ = (config, upstream);
-                    return Err(io::Error::new(
-                        io::ErrorKind::Unsupported,
-                        "VLESS outbound support is disabled at build time",
-                    ));
+                        }
+                        #[cfg(not(feature = "outbound-hysteria2"))]
+                        {
+                            let _ = config;
+                            return Err(io::Error::new(
+                                io::ErrorKind::Unsupported,
+                                "Hysteria2 support is disabled in this build",
+                            ));
+                        }
+                    }
+                    ProxyProtocol::Vmess(config) => {
+                        #[cfg(feature = "outbound-vmess")]
+                        {
+                            Arc::new(crate::outbound::vmess::VmessOutbound::with_shared_security(
+                                config,
+                                upstream,
+                                security_context.as_ref().expect("VMess security context"),
+                                resumption_sessions,
+                                limits.tls_buffer_limit,
+                            )?)
+                        }
+                        #[cfg(not(feature = "outbound-vmess"))]
+                        {
+                            let _ = (config, upstream);
+                            return Err(io::Error::new(
+                                io::ErrorKind::Unsupported,
+                                "VMess outbound support is disabled at build time",
+                            ));
+                        }
+                    }
+                    ProxyProtocol::Trojan(config) => {
+                        #[cfg(feature = "outbound-trojan")]
+                        {
+                            Arc::new(TrojanOutbound::with_shared_security(
+                                config,
+                                upstream,
+                                security_context
+                                    .as_ref()
+                                    .expect("Trojan graph has security material"),
+                                resumption_sessions,
+                                limits.tls_buffer_limit,
+                            )?)
+                        }
+                        #[cfg(not(feature = "outbound-trojan"))]
+                        {
+                            let _ = (config, upstream);
+                            return Err(io::Error::new(
+                                io::ErrorKind::Unsupported,
+                                "Trojan outbound support is disabled at build time",
+                            ));
+                        }
+                    }
+                    ProxyProtocol::Shadowsocks(config) => {
+                        #[cfg(feature = "outbound-shadowsocks")]
+                        {
+                            Arc::new(ShadowsocksOutbound::with_security(
+                                config,
+                                upstream,
+                                security_context.as_ref(),
+                                resumption_sessions,
+                                limits.tls_buffer_limit,
+                            )?)
+                        }
+                        #[cfg(not(feature = "outbound-shadowsocks"))]
+                        {
+                            let _ = (config, upstream);
+                            return Err(io::Error::new(
+                                io::ErrorKind::Unsupported,
+                                "Shadowsocks outbound support is disabled at build time",
+                            ));
+                        }
+                    }
+                    ProxyProtocol::Vless(config) => {
+                        #[cfg(feature = "outbound-vless")]
+                        {
+                            let download_upstream = config
+                                .download()
+                                .map(|download| {
+                                    build_upstream_path(
+                                        crate::outbound::server_destination(
+                                            &download.address,
+                                            download.port,
+                                        )?,
+                                        proxy.dialer_proxy,
+                                        endpoints[index].download.clone(),
+                                        &nodes,
+                                        &group_nodes,
+                                        &node_dialer,
+                                    )
+                                })
+                                .transpose()?;
+                            let mut outbound = VlessOutbound::new_with_shared_security(
+                                config,
+                                upstream,
+                                download_upstream,
+                                security_context
+                                    .as_ref()
+                                    .expect("VLESS graph has shared security material"),
+                                resumption_sessions,
+                                VlessResourceLimits::new(
+                                    limits.tls_buffer_limit,
+                                    limits.xhttp_send_buffer_size,
+                                    limits.xhttp_upload_chunk_size,
+                                ),
+                            )?;
+                            outbound.configure_shared_xhttp_transport(proxy.smux.as_ref());
+                            Arc::new(outbound)
+                        }
+                        #[cfg(not(feature = "outbound-vless"))]
+                        {
+                            let _ = (config, upstream);
+                            return Err(io::Error::new(
+                                io::ErrorKind::Unsupported,
+                                "VLESS outbound support is disabled at build time",
+                            ));
+                        }
+                    }
+                    ProxyProtocol::Socks5(config) => {
+                        #[cfg(feature = "outbound-socks5")]
+                        {
+                            Arc::new(Socks5Outbound::with_shared_security(
+                                config,
+                                upstream,
+                                security_context.as_ref(),
+                                resumption_sessions,
+                                limits.tls_buffer_limit,
+                            )?)
+                        }
+                        #[cfg(not(feature = "outbound-socks5"))]
+                        {
+                            let _ = (config, upstream);
+                            return Err(io::Error::new(
+                                io::ErrorKind::Unsupported,
+                                "SOCKS5 outbound support is disabled at build time",
+                            ));
+                        }
+                    }
+                    ProxyProtocol::AnyTls(config) => {
+                        #[cfg(feature = "outbound-anytls")]
+                        {
+                            let tls = SecurityClient::from_security_with_context(
+                                &config.security,
+                                security_context
+                                    .as_ref()
+                                    .expect("AnyTLS graph has shared security material"),
+                                resumption_sessions,
+                                limits.tls_buffer_limit,
+                            )?;
+                            Arc::new(AnyTlsOutbound::with_session_options(
+                                server_destination(&config.address, config.port)?,
+                                upstream,
+                                &config.password,
+                                Arc::new(tls),
+                                limits.tcp_buffer_per_direction,
+                                config.session.clone(),
+                            )?)
+                        }
+                        #[cfg(not(feature = "outbound-anytls"))]
+                        {
+                            let _ = (config, upstream);
+                            return Err(io::Error::new(
+                                io::ErrorKind::Unsupported,
+                                "AnyTLS outbound support is disabled at build time",
+                            ));
+                        }
+                    }
                 }
             }
-            ProxyProtocol::Socks5(config) => {
-                #[cfg(feature = "outbound-socks5")]
-                {
-                    Arc::new(Socks5Outbound::new_with_path(config, upstream)?)
-                }
-                #[cfg(not(feature = "outbound-socks5"))]
-                {
-                    let _ = (config, upstream);
-                    return Err(io::Error::new(
-                        io::ErrorKind::Unsupported,
-                        "SOCKS5 outbound support is disabled at build time",
-                    ));
-                }
+        };
+
+        #[cfg(feature = "sing-mux")]
+        let connector: Arc<dyn OutboundConnector> = if let Some(options) = &proxy.smux {
+            let mut mux = crate::outbound::SingMuxConnector::new(connector, options.clone())
+                .with_autonomous_xhttp(proxy);
+            #[cfg(target_os = "linux")]
+            {
+                mux = mux.with_physical_tcp_control(proxy);
             }
-            ProxyProtocol::AnyTls(config) => {
-                #[cfg(feature = "outbound-anytls")]
-                {
-                    let tls = StandardTlsClient::for_anytls(
-                        security_context
-                            .as_ref()
-                            .expect("AnyTLS graph has shared security material"),
-                        &config.server_name,
-                        &config.tls,
-                        resumption_sessions,
-                        limits.tls_buffer_limit,
-                    )?;
-                    Arc::new(AnyTlsOutbound::new(
-                        server_destination(&config.address, config.port)?,
-                        upstream,
-                        &config.password,
-                        Arc::new(tls),
-                        limits.tcp_buffer_per_direction,
-                    )?)
-                }
-                #[cfg(not(feature = "outbound-anytls"))]
-                {
-                    let _ = (config, upstream);
-                    return Err(io::Error::new(
-                        io::ErrorKind::Unsupported,
-                        "AnyTLS outbound support is disabled at build time",
-                    ));
-                }
+            if options.statistic
+                && let Some(diagnostics) = diagnostics
+            {
+                mux = mux.with_tracking(diagnostics, &proxy.tag);
             }
+            Arc::new(mux)
+        } else {
+            connector
         };
-
+        let connector: Arc<dyn OutboundConnector> = Arc::new(crate::outbound::IpVersionConnector {
+            inner: connector,
+            version: proxy.ip_version,
+        });
         graph
             .lifecycle_order
             .push(BuiltRouteTarget::Proxy(connector.clone()));
@@ -969,6 +1503,7 @@ fn build_proxy_graph(
 }
 
 fn build_upstream_path(
+    server: crate::session::Destination,
     parent: Option<RouteTargetId>,
     endpoint: Option<ResolvedEndpoint>,
     nodes: &[Option<Arc<dyn OutboundConnector>>],
@@ -983,6 +1518,7 @@ fn build_upstream_path(
                 .clone(),
         )),
         Some(RouteTargetId::Group(id)) => Ok(UpstreamPath::Group {
+            server,
             group: groups[id.index()]
                 .as_ref()
                 .expect("dependency built")
@@ -990,14 +1526,12 @@ fn build_upstream_path(
             endpoint,
             dialer: dialer.clone(),
         }),
-        None => endpoint
-            .map(|endpoint| UpstreamPath::direct(endpoint, dialer.clone()))
-            .ok_or_else(|| {
-                io::Error::new(
-                    io::ErrorKind::InvalidInput,
-                    "physical proxy root has no prepared endpoint",
-                )
-            }),
+        None => Ok(endpoint.map_or_else(
+            || UpstreamPath::LazyDirect {
+                dialer: dialer.clone(),
+            },
+            |endpoint| UpstreamPath::direct(endpoint, dialer.clone()),
+        )),
     }
 }
 
@@ -1028,18 +1562,30 @@ async fn prepare_proxy_endpoints(
     let lookups = proxies
         .iter()
         .enumerate()
-        .filter(|(_, proxy)| match proxy.dialer_proxy {
-            None => true,
-            Some(RouteTargetId::Group(id)) => direct_groups[id.index()],
-            Some(RouteTargetId::Proxy(_)) => false,
+        .filter(|(_, proxy)| {
+            proxy.server_endpoint().is_some()
+                && match proxy.dialer_proxy {
+                    None => true,
+                    Some(RouteTargetId::Group(id)) => direct_groups[id.index()],
+                    Some(RouteTargetId::Proxy(_)) => false,
+                }
         })
         .map(|(index, proxy)| async move {
-            let upload_address = proxy.address();
-            let upload_port = proxy.port();
+            let (upload_address, upload_port) =
+                proxy.server_endpoint().expect("filtered remote endpoint");
             let download = match &proxy.protocol {
                 ProxyProtocol::Vless(config) => config.download(),
-                ProxyProtocol::Socks5(_)
+                ProxyProtocol::Direct
+                | ProxyProtocol::Dns
+                | ProxyProtocol::Reject
+                | ProxyProtocol::Rematch(_)
+                | ProxyProtocol::WireGuard(_)
+                | ProxyProtocol::Masque(_)
+                | ProxyProtocol::Http(_)
+                | ProxyProtocol::Socks5(_)
                 | ProxyProtocol::Trojan(_)
+                | ProxyProtocol::TrustTunnel(_)
+                | ProxyProtocol::Mieru(_)
                 | ProxyProtocol::Vmess(_)
                 | ProxyProtocol::AnyTls(_)
                 | ProxyProtocol::Shadowsocks(_)
@@ -1104,13 +1650,17 @@ fn restrict_endpoint_addresses(
 }
 
 #[cfg(any(
+    feature = "outbound-http",
+    feature = "outbound-socks5",
     feature = "outbound-anytls",
     feature = "outbound-vless",
     feature = "outbound-trojan",
+    feature = "outbound-trusttunnel",
     feature = "outbound-vmess",
     feature = "outbound-hysteria2",
     feature = "outbound-tuic",
-    feature = "shadow-tls-v3"
+    feature = "shadow-tls-v3",
+    feature = "outbound-shadowsocks"
 ))]
 fn security_counts(proxies: &[ProxyConfig]) -> (usize, usize) {
     proxies.iter().fold(
@@ -1133,31 +1683,72 @@ fn security_counts(proxies: &[ProxyConfig]) -> (usize, usize) {
                         }),
                 )
             }
-            ProxyProtocol::AnyTls(_) | ProxyProtocol::Trojan(_) | ProxyProtocol::Hysteria2(_) => {
+            ProxyProtocol::AnyTls(config) => (
+                client_count + 1,
+                standard_count
+                    + usize::from(matches!(
+                        config.security,
+                        crate::config::SecurityConfig::Tls(_)
+                    )),
+            ),
+            ProxyProtocol::Trojan(config) => (
+                client_count + 1,
+                standard_count
+                    + usize::from(matches!(
+                        config.security,
+                        crate::config::SecurityConfig::Tls(_)
+                    )),
+            ),
+            ProxyProtocol::TrustTunnel(_) | ProxyProtocol::Hysteria2(_) => {
                 (client_count + 1, standard_count + 1)
             }
             ProxyProtocol::Vmess(config) => (
                 client_count + 1,
-                standard_count + usize::from(config.tls.is_some()),
+                standard_count
+                    + usize::from(matches!(
+                        config.security,
+                        crate::config::SecurityConfig::Tls(_)
+                    )),
             ),
             ProxyProtocol::Shadowsocks(config) => (
-                client_count + usize::from(config.shadow_tls.is_some()),
-                standard_count,
+                client_count + usize::from(config.plugin.is_some()),
+                standard_count
+                    + config
+                        .plugin
+                        .as_ref()
+                        .map_or(0, crate::config::ShadowsocksPlugin::tls_sessions),
+            ),
+            ProxyProtocol::Http(config) => (
+                client_count + 1,
+                standard_count + usize::from(config.tls.is_some()),
             ),
-            ProxyProtocol::Socks5(_) => (client_count, standard_count),
-            ProxyProtocol::Tuic(_) => (client_count + 1, standard_count),
+            ProxyProtocol::Socks5(config) => (
+                client_count + usize::from(config.tls.is_some()),
+                standard_count + usize::from(config.tls.is_some()),
+            ),
+            ProxyProtocol::Tuic(_) | ProxyProtocol::Masque(_) => (client_count + 1, standard_count),
+            ProxyProtocol::Direct
+            | ProxyProtocol::Dns
+            | ProxyProtocol::Reject
+            | ProxyProtocol::Rematch(_)
+            | ProxyProtocol::WireGuard(_)
+            | ProxyProtocol::Mieru(_) => (client_count, standard_count),
         },
     )
 }
 
 #[cfg(any(
+    feature = "outbound-http",
+    feature = "outbound-socks5",
     feature = "outbound-anytls",
     feature = "outbound-vless",
     feature = "outbound-trojan",
+    feature = "outbound-trusttunnel",
     feature = "outbound-vmess",
     feature = "outbound-hysteria2",
     feature = "outbound-tuic",
-    feature = "shadow-tls-v3"
+    feature = "shadow-tls-v3",
+    feature = "outbound-shadowsocks"
 ))]
 fn standard_tls_resumption_sessions(standard_tls_count: usize) -> usize {
     if standard_tls_count == 0 || standard_tls_count > TLS_RESUMPTION_SESSION_BUDGET {
@@ -1171,24 +1762,38 @@ fn prepare_routing(
     config: &mut Config,
     geodata_manager: &Arc<GeoDataManager>,
 ) -> io::Result<(RuleSet, GeoDataRegistration)> {
-    let requirements = GeoRequirements::collect(&config.rules, &config.dns.nameserver_policies)
+    let requirements = GeoRequirements::for_config(config)
         .map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error))?;
     let geodata_registration = geodata_manager
-        .register(requirements)
+        .register_with_interval(
+            requirements,
+            Duration::from_secs(
+                config
+                    .geodata_update
+                    .as_ref()
+                    .map_or(crate::config::GEO_UPDATE_INTERVAL_HOURS, |update| {
+                        update.interval_hours
+                    })
+                    * 3600,
+            ),
+        )
         .map_err(io::Error::other)?;
     // GeoData must inspect the normalized rule specifications first. Once that
     // borrowing load is complete, move the rules directly into the compiled
     // set so PreparedCore does not retain a second owned rule graph.
-    let rules = RuleSet::compile(std::mem::take(&mut config.rules))
+    let rules = RuleSet::compile_config(config)
         .map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error))?;
     Ok((rules, geodata_registration))
 }
 
 pub(crate) struct RunningCore {
+    #[cfg(all(feature = "tun", target_os = "linux"))]
+    system_network: Option<crate::platform::linux_network::NetworkLease>,
     cancellation: CancellationToken,
     tasks: Vec<JoinHandle<io::Result<()>>>,
     traffic_stats: Option<Arc<TunTrafficStats>>,
-    proxy_graph: BuiltProxyGraph,
+    proxy_graph: Arc<BuiltProxyGraph>,
+    resources: Option<Arc<ProviderRuntime>>,
     _geodata_registration: GeoDataRegistration,
 }
 
@@ -1203,6 +1808,32 @@ impl std::fmt::Debug for RunningCore {
 }
 
 impl RunningCore {
+    #[cfg(feature = "invoke")]
+    pub(crate) fn maintain_http(
+        &mut self,
+        store: Arc<tokio::sync::Mutex<crate::http_processing::providers::Store>>,
+    ) {
+        let Some(resources) = &self.resources else {
+            return;
+        };
+        let resources = resources.clone();
+        self.tasks
+            .push(tokio::spawn(crate::resources::observation::task(
+                crate::invoke::http::maintenance(
+                    store,
+                    move || resources.http_download_context(),
+                    self.cancellation.clone(),
+                ),
+            )));
+    }
+    pub(crate) fn config_apply_handle(
+        &self,
+    ) -> Option<crate::resource::config_apply::ConfigApplyHandle> {
+        self.resources
+            .as_ref()
+            .map(|resources| resources.config_apply_handle())
+    }
+
     // Runtime construction keeps ownership transfers explicit; grouping these
     // independent components into another one-use container would only hide
     // the shutdown responsibilities enforced below.
@@ -1215,7 +1846,8 @@ impl RunningCore {
         controller: Option<RuntimeController>,
         geodata_updater: Option<GeoDataUpdateService>,
         geodata_registration: GeoDataRegistration,
-        proxy_graph: BuiltProxyGraph,
+        proxy_graph: Arc<BuiltProxyGraph>,
+        resources: Option<Arc<ProviderRuntime>>,
     ) -> io::Result<Self> {
         let cancellation = CancellationToken::new();
         let mut tasks = Vec::with_capacity(
@@ -1244,7 +1876,10 @@ impl RunningCore {
                         ));
                     }
                     #[cfg(all(feature = "inbound-http", feature = "inbound-socks5"))]
-                    mixed_servers.push(MixedServer::bind(config.clone(), dispatcher.clone())?);
+                    mixed_servers.push(
+                        MixedServer::bind(config.clone(), dispatcher.clone())?
+                            .with_connections(proxy_graph.dialer.connections()),
+                    );
                 }
                 InboundConfig::Tun(_) => {
                     if tun_runtime.is_none() {
@@ -1295,7 +1930,15 @@ impl RunningCore {
             ));
         }
 
+        if let Some(resources) = &resources {
+            tasks.push(crate::resources::observation::spawn(
+                resources.clone().run(cancellation.clone()),
+            ));
+        }
         Ok(Self {
+            #[cfg(all(feature = "tun", target_os = "linux"))]
+            system_network: None,
+            resources,
             cancellation,
             tasks,
             traffic_stats,
@@ -1321,7 +1964,13 @@ impl RunningCore {
             result = &mut shutdown => (None, result.err()),
             completed = wait_first_task(&mut self.tasks), if !self.tasks.is_empty() => (completed, None),
         };
+        // Keep weakly bound DNS alive through listener teardown and its driver
+        // join barrier. Resource generations retain their own resolver owners.
+        let dns = self.proxy_graph.resolution.runtime_dns();
         self.proxy_graph.begin_shutdown();
+        if let Some(resources) = &self.resources {
+            resources.begin_shutdown();
+        }
         let result = stop_components(
             &self.cancellation,
             &mut self.tasks,
@@ -1329,6 +1978,18 @@ impl RunningCore {
         )
         .await;
         self.proxy_graph.shutdown().await;
+        if let Some(resources) = &self.resources {
+            resources.shutdown().await;
+        }
+        if let Some(dns) = dns {
+            dns.shutdown().await;
+        }
+        #[cfg(all(feature = "tun", target_os = "linux"))]
+        let result = if let Some(mut network) = self.system_network.take() {
+            result.and(network.restore())
+        } else {
+            result
+        };
         result
     }
 }
@@ -1376,6 +2037,9 @@ fn component_completion_error(result: Result<io::Result<()>, tokio::task::JoinEr
 impl Drop for RunningCore {
     fn drop(&mut self) {
         self.proxy_graph.begin_shutdown();
+        if let Some(resources) = &self.resources {
+            resources.begin_shutdown();
+        }
         self.cancellation.cancel();
         for task in &self.tasks {
             task.abort();
@@ -1484,6 +2148,7 @@ mod socks_tests;
 
 #[cfg(test)]
 mod tests {
+    use crate::config::ProxyGroupId;
     use std::net::{IpAddr, SocketAddr};
     use std::sync::{
         Mutex,
@@ -1514,12 +2179,283 @@ mod tests {
     #[cfg(all(windows, feature = "tun"))]
     use crate::platform::TunIo;
 
+    fn live_fake_ip_configuration(enabled: bool, persistent: bool) -> Config {
+        Config::parse_yaml(
+            format!(
+                "ipv6: true\nprofile: {{store-fake-ip: {persistent}}}\ndns:\n  enable: {enabled}\n  ipv6: false\n  enhanced-mode: fake-ip\n  fake-ip-range: 198.18.0.1/24\n  use-hosts: false\n  use-system-hosts: false\n  nameserver: [rcode://success]\n"
+            )
+            .as_bytes(),
+        )
+        .unwrap()
+    }
+
+    fn build_live_fake_ip_parts(
+        config: &Config,
+        previous_dns: Option<Arc<RuntimeDns>>,
+        directory: Option<&std::path::Path>,
+    ) -> BuiltRuntimeParts {
+        let mut config = config.clone();
+        let rules = RuleSet::compile_config(&mut config).unwrap();
+        assert!(config.proxies.is_empty());
+        assert!(config.inbounds.is_empty());
+        assert!(config.external_controller.is_none());
+        GraphBuilder {
+            security: SecurityContext::new(),
+            connections: Arc::default(),
+            config,
+            endpoints: Vec::new(),
+            limits: ResourceLimits::default(),
+            rules,
+            geo_matcher: Arc::new(crate::routing::EmptyGeoMatcher),
+            previous_dns,
+            data_dir: directory.map(std::path::Path::to_path_buf),
+        }
+        .build(Dialer::default())
+        .unwrap()
+    }
+
+    async fn live_fake_ip_answers(
+        parts: &BuiltRuntimeParts,
+        host: &str,
+        query_type: crate::dns::QueryType,
+    ) -> Vec<IpAddr> {
+        let query = crate::dns::build_query(947, host, query_type).unwrap();
+        let response = parts.dns.as_ref().unwrap().exchange(&query).await.unwrap();
+        let response = crate::dns::parse_response(&response).unwrap();
+        assert_eq!(response.id, 947);
+        assert_eq!(response.rcode, 0);
+        assert_eq!(response.question.name, host);
+        assert_eq!(response.question.query_type, query_type);
+        response
+            .answers
+            .into_iter()
+            .filter_map(|record| match record.data {
+                crate::dns::RecordData::A(ip) => Some(IpAddr::V4(ip)),
+                crate::dns::RecordData::Aaaa(ip) => Some(IpAddr::V6(ip)),
+                _ => None,
+            })
+            .collect()
+    }
+
+    async fn stop_live_fake_ip_parts(parts: BuiltRuntimeParts) {
+        parts.dns.as_ref().unwrap().shutdown().await;
+        parts.proxy_graph.begin_shutdown();
+        parts.proxy_graph.shutdown().await;
+    }
+
+    #[tokio::test]
+    async fn live_dns_toggle_preserves_fake_ip_pool_with_distinct_system_ipv6() {
+        let enabled = live_fake_ip_configuration(true, false);
+        let disabled = live_fake_ip_configuration(false, false);
+        assert!(crate::config::live_update::startup_compatible(
+            &enabled, &disabled
+        ));
+        assert!(crate::config::live_update::startup_compatible(
+            &disabled, &enabled
+        ));
+        let first: IpAddr = "198.18.0.4".parse().unwrap();
+        let second: IpAddr = "198.18.0.5".parse().unwrap();
+        let before = build_live_fake_ip_parts(&enabled, None, None);
+        assert_eq!(
+            live_fake_ip_answers(&before, "first.example", crate::dns::QueryType::A).await,
+            [first]
+        );
+        assert_eq!(
+            live_fake_ip_answers(&before, "second.example", crate::dns::QueryType::A).await,
+            [second]
+        );
+        let paused = build_live_fake_ip_parts(&disabled, before.dns.clone(), None);
+        assert!(!paused.dns.as_ref().unwrap().is_enabled());
+        let resumed = build_live_fake_ip_parts(&enabled, paused.dns.clone(), None);
+        // Ask in reverse allocation order: a fresh pool would incorrectly
+        // assign the first address to the second name after the toggle.
+        assert_eq!(
+            live_fake_ip_answers(&resumed, "second.example", crate::dns::QueryType::A).await,
+            [second]
+        );
+        assert_eq!(
+            live_fake_ip_answers(&resumed, "first.example", crate::dns::QueryType::A).await,
+            [first]
+        );
+        assert!(
+            live_fake_ip_answers(&resumed, "second.example", crate::dns::QueryType::Aaaa)
+                .await
+                .is_empty()
+        );
+        for parts in [&before, &paused, &resumed] {
+            assert_eq!(
+                parts
+                    .dns
+                    .as_ref()
+                    .unwrap()
+                    .recover_fake_ip(second)
+                    .unwrap()
+                    .as_deref(),
+                Some("second.example")
+            );
+        }
+        stop_live_fake_ip_parts(resumed).await;
+        stop_live_fake_ip_parts(paused).await;
+        stop_live_fake_ip_parts(before).await;
+    }
+
+    #[tokio::test]
+    async fn live_dns_enable_loads_and_persists_fake_ip_store() {
+        let directory = tempdir().unwrap();
+        let enabled = live_fake_ip_configuration(true, true);
+        let disabled = live_fake_ip_configuration(false, true);
+        assert!(crate::config::live_update::startup_compatible(
+            &disabled, &enabled
+        ));
+        let first: IpAddr = "198.18.0.4".parse().unwrap();
+        let second: IpAddr = "198.18.0.5".parse().unwrap();
+        let third: IpAddr = "198.18.0.6".parse().unwrap();
+        let seed = build_live_fake_ip_parts(&enabled, None, Some(directory.path()));
+        for (name, address) in [("first.example", first), ("second.example", second)] {
+            assert_eq!(
+                live_fake_ip_answers(&seed, name, crate::dns::QueryType::A).await,
+                [address]
+            );
+        }
+        stop_live_fake_ip_parts(seed).await;
+        assert!(directory.path().join("fake-ip.redb").is_file());
+
+        let paused = build_live_fake_ip_parts(&disabled, None, Some(directory.path()));
+        assert!(!paused.dns.as_ref().unwrap().is_enabled());
+        let active = build_live_fake_ip_parts(&enabled, paused.dns.clone(), Some(directory.path()));
+        // The pre-existing durable second binding must load before allocating
+        // anything; a newly empty in-memory pool would return the first IP.
+        assert_eq!(
+            live_fake_ip_answers(&active, "second.example", crate::dns::QueryType::A).await,
+            [second]
+        );
+        assert_eq!(
+            live_fake_ip_answers(&active, "third.example", crate::dns::QueryType::A).await,
+            [third]
+        );
+
+        // A later compatible replacement must retain the open store instead
+        // of trying to open its locked path for a second database owner.
+        let replaced =
+            build_live_fake_ip_parts(&enabled, active.dns.clone(), Some(directory.path()));
+        assert_eq!(
+            live_fake_ip_answers(&replaced, "first.example", crate::dns::QueryType::A).await,
+            [first]
+        );
+        assert_eq!(
+            live_fake_ip_answers(&replaced, "fourth.example", crate::dns::QueryType::A).await,
+            ["198.18.0.7".parse::<IpAddr>().unwrap()]
+        );
+        stop_live_fake_ip_parts(replaced).await;
+        stop_live_fake_ip_parts(active).await;
+        stop_live_fake_ip_parts(paused).await;
+
+        let restarted = build_live_fake_ip_parts(&enabled, None, Some(directory.path()));
+        assert_eq!(
+            live_fake_ip_answers(&restarted, "third.example", crate::dns::QueryType::A).await,
+            [third]
+        );
+        assert_eq!(
+            live_fake_ip_answers(&restarted, "fifth.example", crate::dns::QueryType::A).await,
+            ["198.18.0.8".parse::<IpAddr>().unwrap()]
+        );
+        assert_eq!(
+            restarted
+                .dns
+                .as_ref()
+                .unwrap()
+                .recover_fake_ip(second)
+                .unwrap()
+                .as_deref(),
+            Some("second.example")
+        );
+        assert!(
+            live_fake_ip_answers(&restarted, "third.example", crate::dns::QueryType::Aaaa)
+                .await
+                .is_empty()
+        );
+        stop_live_fake_ip_parts(restarted).await;
+    }
+
     struct FixedResolver;
 
+    #[cfg(feature = "outbound-masque")]
+    #[tokio::test]
+    async fn masque_runtime_graph_owns_the_node_without_creating_physical_io() {
+        use base64::{Engine as _, engine::general_purpose::STANDARD};
+        use boring::{
+            ec::{EcGroup, EcKey},
+            nid::Nid,
+            pkey::PKey,
+        };
+        use serde_json::json;
+
+        let key =
+            EcKey::generate(&EcGroup::from_curve_name(Nid::X9_62_PRIME256V1).unwrap()).unwrap();
+        let private = STANDARD.encode(key.private_key_to_der().unwrap());
+        let public = STANDARD.encode(PKey::from_ec_key(key).unwrap().public_key_to_der().unwrap());
+        let config = Config::parse_yaml(
+            &serde_json::to_vec(&json!({
+                "proxies": [{
+                    "name": "edge", "type": "masque", "server": "unresolved.invalid", "port": 443,
+                    "private-key": private, "public-key": public, "network": "h3-l4proxy",
+                    "udp": true, "dialer-proxy": "upstream"
+                }],
+                "proxy-groups": [{"name": "upstream", "type": "select", "proxies": ["DIRECT"]}]
+            }))
+            .unwrap(),
+        )
+        .unwrap();
+        assert!(!config.proxies[0].udp);
+        let graph = build_proxy_graph(
+            &config.proxies,
+            &config.proxy_groups,
+            &[PreparedProxyEndpoints::default()],
+            ResourceLimits::default(),
+            Dialer::default(),
+            ResolutionContext::default(),
+            &SecurityContext::new(),
+            None,
+        )
+        .unwrap();
+        assert_eq!(graph.len(), 1);
+        graph.begin_shutdown();
+        graph.shutdown().await;
+    }
+
     #[tokio::test]
     async fn integration_feature_admission_is_explicit_without_opening_sockets() {
+        #[cfg(feature = "outbound-masque")]
+        let masque_fields = {
+            use base64::{Engine as _, engine::general_purpose::STANDARD};
+            use boring::{
+                ec::{EcGroup, EcKey},
+                nid::Nid,
+                pkey::PKey,
+            };
+
+            let key =
+                EcKey::generate(&EcGroup::from_curve_name(Nid::X9_62_PRIME256V1).unwrap()).unwrap();
+            let private = STANDARD.encode(key.private_key_to_der().unwrap());
+            let public =
+                STANDARD.encode(PKey::from_ec_key(key).unwrap().public_key_to_der().unwrap());
+            format!(", network: h3-l4proxy, private-key: '{private}', public-key: '{public}'")
+        };
+        #[cfg(not(feature = "outbound-masque"))]
+        let masque_fields = ", network: h3-l4proxy, private-key: '', public-key: ''".to_owned();
         let variants = [
             ("socks5", "", cfg!(feature = "outbound-socks5")),
+            ("trusttunnel", "", cfg!(feature = "outbound-trusttunnel")),
+            (
+                "mieru",
+                ", transport: TCP, username: fixture, password: fixture",
+                cfg!(feature = "outbound-mieru"),
+            ),
+            (
+                "masque",
+                masque_fields.as_str(),
+                cfg!(feature = "outbound-masque"),
+            ),
             (
                 "anytls",
                 ", password: fixture",
@@ -1555,9 +2491,13 @@ mod tests {
                 ", uuid: 08080808-0808-0808-0808-080808080808, password: fixture",
                 cfg!(feature = "outbound-tuic"),
             ),
+            (
+                "wireguard",
+                ", ip: 10.84.0.2, private-key: AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE=, public-key: AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI=",
+                cfg!(feature = "outbound-wireguard"),
+            ),
         ];
         for (protocol, fields, enabled) in variants {
-            let _case = crate::resources::case_events::Case::new("INTEGRATION-FEATURE", protocol);
             let yaml = format!(
                 "mixed-port: 1080\nproxies:\n  - {{name: peer, type: {protocol}, server: 127.0.0.1, port: 443{fields}}}\nrules: ['MATCH,peer']\n"
             );
@@ -1695,7 +2635,188 @@ rules:
     }
 
     #[tokio::test]
-    async fn prepare_resolves_the_sole_outbound() {
+    async fn controller_diagnostics_are_opt_in_for_business_routes() {
+        for controller in [false, true] {
+            let mut yaml = String::from(
+                "mixed-port: 1080\nproxy-groups: [{name: local, type: select, proxies: [REJECT]}]\nrules: ['MATCH,REJECT']\n",
+            );
+            if controller {
+                yaml.push_str("external-controller: 127.0.0.1:9090\nsecret: test-token\n");
+            }
+            let prepared =
+                PreparedCore::prepare(yaml.as_bytes(), &FixedResolver, ResourceLimits::default())
+                    .await
+                    .unwrap();
+            let parts = prepared.build_dispatcher(Dialer::default()).unwrap();
+            let result = parts
+                .dispatcher
+                .connect_tcp(crate::session::StreamSession {
+                    metadata: Default::default(),
+                    inbound: crate::session::InboundKind::Socks5,
+                    source: "127.0.0.1:12345".parse().unwrap(),
+                    destination: crate::session::Destination::Ip("192.0.2.1:443".parse().unwrap()),
+                    sniffed_domain: None,
+                })
+                .await;
+            assert!(matches!(
+                result,
+                Err(crate::dispatch::DispatchError::NotAllowed)
+            ));
+            // REJECT exercises the assembled business path without opening a socket.
+            assert_eq!(parts.diagnostics.is_some(), controller);
+            let snapshot = serde_json::to_value(parts.connections.snapshot()).unwrap();
+            assert_eq!(
+                snapshot["errors"].as_array().unwrap().len(),
+                usize::from(controller)
+            );
+            if let Some(diagnostics) = &parts.diagnostics {
+                assert_eq!(diagnostics.rules()["rules"][0]["extra"]["hitCount"], 1);
+            }
+            parts.proxy_graph.shutdown().await;
+        }
+    }
+
+    #[tokio::test]
+    async fn prepares_udp_capabilities_through_runtime_wrappers() {
+        let prepared = PreparedCore::prepare(
+            br#"
+mixed-port: 1080
+proxies: [{name: tcp-only, type: socks5, server: 192.0.2.1, port: 1080}]
+proxy-groups:
+  - {name: selected, type: select, proxies: [tcp-only, DIRECT]}
+  - {name: disabled, type: select, proxies: [DIRECT], disable-udp: true}
+  - {name: balanced, type: load-balance, proxies: [tcp-only]}
+"#,
+            &FixedResolver,
+            ResourceLimits::default(),
+        )
+        .await
+        .unwrap();
+        let parts = prepared.build_dispatcher(Dialer::default()).unwrap();
+        assert!(
+            !parts
+                .resource_targets
+                .get(ProxyId::new(0).unwrap())
+                .unwrap()
+                .supports_udp()
+        );
+        for (index, expected) in [false, false, true].into_iter().enumerate() {
+            let route = RouteTargetId::Group(ProxyGroupId::new(index).unwrap());
+            assert_eq!(
+                parts
+                    .resource_targets
+                    .get_route(route)
+                    .unwrap()
+                    .supports_udp(),
+                expected
+            );
+        }
+        parts.proxy_groups.select("selected", "DIRECT").unwrap();
+        assert!(
+            parts
+                .resource_targets
+                .get_route(RouteTargetId::Group(ProxyGroupId::new(0).unwrap()))
+                .unwrap()
+                .supports_udp()
+        );
+        parts.proxy_graph.shutdown().await;
+    }
+
+    #[cfg(all(
+        feature = "sing-mux",
+        feature = "outbound-http",
+        feature = "outbound-socks5"
+    ))]
+    #[tokio::test]
+    async fn prepares_shared_mux_capabilities_and_registers_only_final_graph_nodes() {
+        let prepared = PreparedCore::prepare(
+            br#"
+mixed-port: 1080
+proxies:
+  - {name: mux-http, type: http, server: 192.0.2.1, port: 1080, smux: {enabled: true}}
+  - {name: native-udp, type: socks5, server: 192.0.2.2, port: 1080, udp: false, smux: {enabled: true, only-tcp: true}}
+proxy-groups:
+  - {name: selected, type: select, proxies: [mux-http, native-udp]}
+  - {name: disabled, type: select, proxies: [mux-http], disable-udp: true}
+"#,
+            &FixedResolver,
+            ResourceLimits::default(),
+        ).await.unwrap();
+        let parts = prepared.build_dispatcher(Dialer::default()).unwrap();
+        for (index, expected) in [true, false].into_iter().enumerate() {
+            assert_eq!(
+                parts
+                    .resource_targets
+                    .get(ProxyId::new(index).unwrap())
+                    .unwrap()
+                    .supports_udp(),
+                expected
+            );
+            let node = &parts.proxy_graph.nodes[index];
+            assert_eq!(parts.proxy_graph.lifecycle_order.iter().filter(|target| {
+                matches!(target, BuiltRouteTarget::Proxy(registered) if Arc::ptr_eq(node, registered))
+            }).count(), 1);
+        }
+        assert_eq!(
+            parts
+                .proxy_graph
+                .lifecycle_order
+                .iter()
+                .filter(|target| matches!(target, BuiltRouteTarget::Proxy(_)))
+                .count(),
+            2
+        );
+        for (index, expected) in [true, false].into_iter().enumerate() {
+            assert_eq!(
+                parts
+                    .resource_targets
+                    .get_route(RouteTargetId::Group(ProxyGroupId::new(index).unwrap()))
+                    .unwrap()
+                    .supports_udp(),
+                expected
+            );
+        }
+        parts.proxy_groups.select("selected", "native-udp").unwrap();
+        assert!(
+            !parts
+                .resource_targets
+                .get_route(RouteTargetId::Group(ProxyGroupId::new(0).unwrap()))
+                .unwrap()
+                .supports_udp()
+        );
+        parts.proxy_graph.begin_shutdown();
+        parts.proxy_graph.shutdown().await;
+    }
+
+    #[tokio::test]
+    async fn prepares_builtin_routes_without_static_nodes_or_bootstrap() {
+        let resolver = RecordingResolver::default();
+        for (groups, target) in [
+            ("", "DIRECT"),
+            ("", "REJECT"),
+            (
+                "proxy-groups:\n  - name: local\n    type: select\n    proxies: [DIRECT, REJECT]\n",
+                "local",
+            ),
+        ] {
+            let yaml = format!(
+                "mixed-port: 1080\n{groups}dns:\n  enable: true\n  nameserver: [1.1.1.1]\n  nameserver-policy:\n    '+.example.com': 223.5.5.5\nrules: ['MATCH,{target}']\n"
+            );
+            let prepared =
+                PreparedCore::prepare(yaml.as_bytes(), &resolver, ResourceLimits::default())
+                    .await
+                    .unwrap();
+            assert!(prepared.endpoints.is_empty());
+            let parts = prepared.build_dispatcher(Dialer::default()).unwrap();
+            assert_eq!(parts.proxy_graph.len(), 0);
+            assert!(parts.dns.is_some());
+            parts.proxy_graph.shutdown().await;
+        }
+        assert!(resolver.hosts.lock().unwrap().is_empty());
+    }
+
+    #[tokio::test]
+    async fn prepare_defers_proxy_endpoint_resolution() {
         let prepared =
             PreparedCore::prepare(CONFIG.as_bytes(), &FixedResolver, ResourceLimits::default())
                 .await
@@ -1706,7 +2827,7 @@ rules:
             prepared.proxy(id).protocol,
             ProxyProtocol::Vless(_)
         ));
-        assert_eq!(prepared.endpoint(id).unwrap().logical_host, "server.test");
+        assert!(prepared.endpoint(id).is_none());
         assert!(!prepared.has_tun());
         assert!(
             prepared.config.rules.is_empty(),
@@ -1723,7 +2844,7 @@ rules:
     }
 
     #[tokio::test]
-    async fn prepare_reuses_one_resolution_for_an_identical_download_server() {
+    async fn prepare_defers_identical_download_endpoints() {
         let resolver = RecordingResolver::default();
         let yaml = CONFIG.replace(
             "      mode: packet-up\n",
@@ -1732,12 +2853,11 @@ rules:
         let prepared = PreparedCore::prepare(yaml.as_bytes(), &resolver, ResourceLimits::default())
             .await
             .unwrap();
-        assert_eq!(*resolver.hosts.lock().unwrap(), ["server.test".to_owned()]);
+        assert!(resolver.hosts.lock().unwrap().is_empty());
 
         let id = ProxyId::new(0).unwrap();
-        let upload = prepared.endpoint(id).unwrap();
-        let download = prepared.download_endpoint(id).unwrap();
-        assert_eq!(upload, download);
+        assert!(prepared.endpoint(id).is_none());
+        assert!(prepared.download_endpoint(id).is_none());
         assert_eq!(
             prepared.build_proxy_graph(Dialer::default()).unwrap().len(),
             1
@@ -1745,19 +2865,17 @@ rules:
     }
 
     #[tokio::test]
-    async fn prepare_resolves_distinct_download_server_concurrently() {
+    async fn prepare_defers_distinct_download_endpoints() {
         let resolver = ConcurrentResolver::default();
         let yaml = config_with_download("        server: download.test\n        port: 8443");
         let prepared = PreparedCore::prepare(yaml.as_bytes(), &resolver, ResourceLimits::default())
             .await
             .unwrap();
-        assert_eq!(resolver.peak.load(Ordering::Acquire), 2);
+        assert_eq!(resolver.peak.load(Ordering::Acquire), 0);
 
         let id = ProxyId::new(0).unwrap();
-        assert_eq!(prepared.endpoint(id).unwrap().logical_host, "server.test");
-        let download = prepared.download_endpoint(id).unwrap();
-        assert_eq!(download.logical_host, "download.test");
-        assert_eq!(download.port, 8443);
+        assert!(prepared.endpoint(id).is_none());
+        assert!(prepared.download_endpoint(id).is_none());
         assert_eq!(
             prepared.build_proxy_graph(Dialer::default()).unwrap().len(),
             1
@@ -1765,7 +2883,12 @@ rules:
     }
 
     #[test]
-    #[cfg(any(feature = "outbound-anytls", feature = "outbound-vless"))]
+    #[cfg(any(
+        feature = "outbound-http",
+        feature = "outbound-socks5",
+        feature = "outbound-anytls",
+        feature = "outbound-vless"
+    ))]
     fn security_budget_counts_every_vless_transport_leg() {
         let yaml = config_with_download("        server: download.test\n        port: 8443");
         let config = Config::parse_yaml(yaml.as_bytes()).unwrap();
@@ -1774,55 +2897,7 @@ rules:
     }
 
     #[tokio::test]
-    async fn production_redir_host_store_requires_tun_and_domain_rules() {
-        let domain_rules = r#"
-rules:
-  - DOMAIN-SUFFIX,example.com,DIRECT
-  - MATCH,proxy
-"#;
-        let tun = r#"
-tun:
-  enable: true
-  mtu: 1500
-"#;
-
-        let no_tun = PreparedCore::prepare(
-            config_with_rules(domain_rules).as_bytes(),
-            &FixedResolver,
-            ResourceLimits::default(),
-        )
-        .await
-        .unwrap();
-        assert_eq!(no_tun.dns_redir_host_entries(), 0);
-
-        let no_domain_rules = PreparedCore::prepare(
-            format!("{CONFIG}{tun}").as_bytes(),
-            &FixedResolver,
-            ResourceLimits::default(),
-        )
-        .await
-        .unwrap();
-        assert_eq!(no_domain_rules.dns_redir_host_entries(), 0);
-
-        let enabled = PreparedCore::prepare(
-            format!("{}{tun}", config_with_rules(domain_rules)).as_bytes(),
-            &FixedResolver,
-            ResourceLimits::default(),
-        )
-        .await
-        .unwrap();
-        assert_eq!(
-            enabled.dns_redir_host_entries(),
-            ResourceLimits::default().dns_redir_host_entries
-        );
-        assert!(
-            enabled.domain_sniffer_config().is_none(),
-            "redir-host remains available when the optional sniffer is omitted"
-        );
-    }
-
-    #[tokio::test]
-    async fn production_domain_sniffer_requires_tun_enable_and_domain_rules() {
+    async fn production_tun_sniffer_is_independent_of_domain_rules() {
         let domain_rules = r#"
 rules:
   - DOMAIN-SUFFIX,example.com,DIRECT
@@ -1859,7 +2934,7 @@ sniffer:
         )
         .await
         .unwrap();
-        assert!(no_domain_rules.domain_sniffer_config().is_none());
+        assert!(no_domain_rules.domain_sniffer_config().is_some());
 
         let disabled = PreparedCore::prepare(
             format!(
@@ -1873,11 +2948,6 @@ sniffer:
         .await
         .unwrap();
         assert!(disabled.domain_sniffer_config().is_none());
-        assert_eq!(
-            disabled.dns_redir_host_entries(),
-            ResourceLimits::default().dns_redir_host_entries,
-            "sniffer disablement must not remove DNS routing hints"
-        );
 
         let enabled = PreparedCore::prepare(
             format!("{}{tun}{sniffer}", config_with_rules(domain_rules)).as_bytes(),
@@ -1888,7 +2958,7 @@ sniffer:
         .unwrap();
         let normalized = enabled
             .domain_sniffer_config()
-            .expect("all three production sniffer gates are enabled");
+            .expect("the TUN sniffer is enabled");
         assert!(normalized.matches_http_port(8080));
         assert!(!normalized.matches_http_port(80));
         assert!(normalized.matches_tls_port(8444));
@@ -1913,10 +2983,11 @@ dns:
 
     #[cfg(feature = "outbound-vless")]
     #[tokio::test]
-    async fn geodata_updater_requires_enabled_config_and_actual_demand() {
+    async fn geodata_updater_fetches_missing_assets_and_requires_actual_demand() {
         fn configured(auto_update: bool, geodata_rule: bool) -> String {
             let fields = format!(
-                r#"geox-url:
+                r#"geodata-mode: true
+geox-url:
   geoip: https://downloads.example.test/custom-geoip.dat
   geosite: https://downloads.example.test/custom-geosite.dat
 geo-auto-update: {auto_update}
@@ -1949,8 +3020,10 @@ geo-update-interval: 24
 
         let missing_config_with_demand =
             config_with_rules("rules:\n  - GEOIP,cn,proxy\n  - MATCH,proxy\n");
-        assert!(updater_for(&missing_config_with_demand).await.is_none());
-        assert!(updater_for(&configured(false, true)).await.is_none());
+        assert!(updater_for(&missing_config_with_demand).await.is_some());
+        let asn_only = config_with_rules("rules:\n  - IP-ASN,0,proxy\n  - MATCH,proxy\n");
+        assert!(updater_for(&asn_only).await.is_some());
+        assert!(updater_for(&configured(false, true)).await.is_some());
         assert!(updater_for(&configured(true, false)).await.is_none());
 
         let updater = updater_for(&configured(true, true))
@@ -1971,7 +3044,8 @@ geo-update-interval: 24
     async fn a_manager_rejects_a_second_prepared_configuration() {
         fn configured(auto_update: bool, rule: &str, source: &str) -> String {
             let fields = format!(
-                r#"geox-url:
+                r#"geodata-mode: true
+geox-url:
   geoip: https://{source}/geoip.dat
   geosite: https://{source}/geosite.dat
 geo-auto-update: {auto_update}
@@ -2040,7 +3114,7 @@ rules:
     }
 
     #[tokio::test]
-    async fn prepare_resolves_both_independent_proxy_roots() {
+    async fn prepare_defers_independent_proxy_roots() {
         let resolver = RecordingResolver::default();
         let prepared = PreparedCore::prepare(
             two_socks_config(false).as_bytes(),
@@ -2051,14 +3125,14 @@ rules:
         .unwrap();
         let mut hosts = resolver.hosts.lock().unwrap().clone();
         hosts.sort();
-        assert_eq!(hosts, ["a.test".to_owned(), "b.test".to_owned()]);
-        assert!(prepared.endpoint(ProxyId::new(0).unwrap()).is_some());
-        assert!(prepared.endpoint(ProxyId::new(1).unwrap()).is_some());
+        assert!(hosts.is_empty());
+        assert!(prepared.endpoint(ProxyId::new(0).unwrap()).is_none());
+        assert!(prepared.endpoint(ProxyId::new(1).unwrap()).is_none());
     }
 
     #[cfg(feature = "outbound-socks5")]
     #[tokio::test]
-    async fn prepare_resolves_only_the_physical_chain_root() {
+    async fn prepare_defers_the_physical_chain_root() {
         let resolver = RecordingResolver::default();
         let prepared = PreparedCore::prepare(
             two_socks_config(true).as_bytes(),
@@ -2067,15 +3141,47 @@ rules:
         )
         .await
         .unwrap();
-        assert_eq!(*resolver.hosts.lock().unwrap(), ["b.test".to_owned()]);
+        assert!(resolver.hosts.lock().unwrap().is_empty());
         assert!(prepared.endpoint(ProxyId::new(0).unwrap()).is_none());
-        assert!(prepared.endpoint(ProxyId::new(1).unwrap()).is_some());
+        assert!(prepared.endpoint(ProxyId::new(1).unwrap()).is_none());
         assert_eq!(
             prepared.build_proxy_graph(Dialer::default()).unwrap().len(),
             2
         );
     }
 
+    #[cfg(feature = "outbound-trusttunnel")]
+    #[tokio::test]
+    async fn trusttunnel_graph_defers_resolution_and_shares_tls_budget() {
+        let yaml = br#"proxies:
+  - name: tunnel-child
+    type: trusttunnel
+    server: child.test
+    port: 443
+    dialer-proxy: upstream
+  - name: tunnel-root
+    type: trusttunnel
+    server: root.test
+    port: 443
+proxy-groups:
+  - name: upstream
+    type: select
+    proxies: [DIRECT, tunnel-root]
+rules: ["MATCH,tunnel-child"]
+"#;
+        let resolver = RecordingResolver::default();
+        let prepared = PreparedCore::prepare(yaml, &resolver, ResourceLimits::default())
+            .await
+            .unwrap();
+        assert!(resolver.hosts.lock().unwrap().is_empty());
+        assert_eq!(security_counts(&prepared.config.proxies), (2, 2));
+        assert_eq!(standard_tls_resumption_sessions(2), 2);
+        let graph = prepared.build_proxy_graph(Dialer::default()).unwrap();
+        assert_eq!(graph.len(), 2);
+        graph.begin_shutdown();
+        graph.shutdown().await;
+    }
+
     #[cfg(all(feature = "outbound-socks5", feature = "outbound-vless"))]
     #[tokio::test]
     async fn split_vless_behind_dialer_proxy_does_not_resolve_either_child_leg() {
@@ -2113,10 +3219,7 @@ rules:
         let prepared = PreparedCore::prepare(yaml.as_bytes(), &resolver, ResourceLimits::default())
             .await
             .unwrap();
-        assert_eq!(
-            *resolver.hosts.lock().unwrap(),
-            ["socks-root.test".to_owned()]
-        );
+        assert!(resolver.hosts.lock().unwrap().is_empty());
         let child = ProxyId::new(0).unwrap();
         assert!(prepared.endpoint(child).is_none());
         assert!(prepared.download_endpoint(child).is_none());
@@ -2127,6 +3230,7 @@ rules:
     }
 
     #[cfg(all(
+        feature = "outbound-http",
         feature = "outbound-anytls",
         feature = "outbound-socks5",
         feature = "outbound-vless"
@@ -2153,10 +3257,16 @@ rules:
 
         fn socks5(tag: &str) -> ProxyConfig {
             ProxyConfig {
+                tfo: false,
+                mptcp: false,
+                egress: Default::default(),
+                smux: None,
+                ip_version: crate::config::IpVersion::Dual,
                 tag: tag.to_owned(),
                 dialer_proxy: None,
                 udp: false,
                 protocol: ProxyProtocol::Socks5(crate::config::Socks5OutboundConfig {
+                    tls: None,
                     address: "127.0.0.1".to_owned(),
                     port: 1080,
                     username: None,
@@ -2167,6 +3277,11 @@ rules:
 
         fn anytls(tag: &str) -> ProxyConfig {
             ProxyConfig {
+                tfo: false,
+                mptcp: false,
+                egress: Default::default(),
+                smux: None,
+                ip_version: crate::config::IpVersion::Dual,
                 tag: tag.to_owned(),
                 dialer_proxy: None,
                 udp: true,
@@ -2175,7 +3290,17 @@ rules:
                     port: 443,
                     password: "secret".to_owned(),
                     server_name: "example.com".to_owned(),
-                    tls: Default::default(),
+                    security: crate::config::SecurityConfig::Tls(crate::config::TlsConfig {
+                        server_name: "example.com".into(),
+                        ech: None,
+                        client_fingerprint: None,
+                        alpn: Vec::new(),
+                        tls13_only: false,
+                        required_alpn: None,
+                        certificate: Default::default(),
+                        identity: None,
+                    }),
+                    session: Default::default(),
                 }),
             }
         }
@@ -2565,6 +3690,6 @@ rules:
         let (host, peer) = UnixDatagram::pair().unwrap();
         host.set_nonblocking(true).unwrap();
         let fd = crate::platform::TunFd::duplicate_mock(host.as_raw_fd()).unwrap();
-        (TunIo::new(fd, crate::TunFraming::RawIp).unwrap(), peer)
+        (TunIo::new_mock(fd, crate::TunFraming::RawIp).unwrap(), peer)
     }
 }
diff --git a/src/runtime/health.rs b/src/runtime/health.rs
new file mode 100644
index 0000000..2f8a19e
--- /dev/null
+++ b/src/runtime/health.rs
@@ -0,0 +1,780 @@
+//! Shared probe scheduling and automatic group selection for one resource generation.
+use super::*;
+use crate::{
+    config::{HealthCheckConfig, status_ranges},
+    dispatch::{BoxStream, DatagramTransport, DispatchError},
+    resource::{
+        control::{DelayRequest, ProbeError},
+        probe::{self, Target},
+    },
+    session::{DatagramSession, StreamSession},
+};
+use futures_util::{StreamExt, stream};
+use std::{collections::BTreeMap, sync::Mutex};
+use tokio::time::Instant;
+
+#[derive(Debug)]
+pub(super) struct Activity(Mutex<Instant>);
+impl Activity {
+    pub fn new() -> Arc<Self> {
+        Arc::new(Self(Mutex::new(Instant::now())))
+    }
+    fn touch(&self) {
+        *self.0.lock().unwrap() = Instant::now();
+    }
+    fn active(&self, interval: Duration) -> bool {
+        self.0.lock().unwrap().elapsed() < interval
+    }
+}
+pub(super) struct ActiveDispatcher {
+    pub dispatcher: Arc<dyn Dispatcher>,
+    pub activity: Arc<Activity>,
+}
+#[async_trait::async_trait]
+impl Dispatcher for ActiveDispatcher {
+    fn supports_udp(&self) -> bool {
+        self.dispatcher.supports_udp()
+    }
+
+    async fn connect_tcp(&self, session: StreamSession) -> Result<BoxStream, DispatchError> {
+        if session.inbound != crate::session::InboundKind::InternalMeasure {
+            self.activity.touch();
+        }
+        self.dispatcher.connect_tcp(session).await
+    }
+    async fn open_datagram(
+        &self,
+        session: DatagramSession,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        self.activity.touch();
+        self.dispatcher.open_datagram(session).await
+    }
+}
+#[derive(Debug, Clone, serde::Serialize)]
+pub(super) struct Sample {
+    pub alive: bool,
+    pub delay: u64,
+    pub time: u64,
+    #[serde(skip)]
+    order: u64,
+    #[serde(skip)]
+    status: Option<u16>,
+}
+struct Job {
+    spec: HealthCheckConfig,
+    members: Vec<String>,
+    group: Option<usize>,
+    last: Option<Instant>,
+    provider: Option<String>,
+}
+pub(super) struct HealthRuntime {
+    security: SecurityContext,
+    jobs: Mutex<Vec<Job>>,
+    samples: Mutex<BTreeMap<(String, String), Sample>>,
+    manual_samples: Mutex<BTreeMap<String, Sample>>,
+    sequence: std::sync::atomic::AtomicU64,
+    probe_slots: tokio::sync::Semaphore,
+    groups: Arc<ProxyGroups>,
+    targets: RouteTargetDispatchers,
+    direct: Arc<dyn Dispatcher>,
+    names: BTreeMap<String, RouteTargetId>,
+    activity: BTreeMap<String, Arc<Activity>>,
+    unified: bool,
+    dns: Option<Arc<RuntimeDns>>,
+    ipv6: bool,
+}
+impl HealthRuntime {
+    pub fn new(
+        config: &Config,
+        groups: Arc<ProxyGroups>,
+        targets: RouteTargetDispatchers,
+        direct: Arc<dyn Dispatcher>,
+        activity: Vec<Arc<Activity>>,
+        dns: Option<Arc<RuntimeDns>>,
+        security: SecurityContext,
+    ) -> Arc<Self> {
+        let mut jobs = Vec::new();
+        for (i, group) in config.proxy_groups.iter().enumerate() {
+            jobs.push(Job {
+                spec: group.health.clone(),
+                members: group
+                    .members
+                    .iter()
+                    .map(|member| member.name.clone())
+                    .collect(),
+                group: Some(i),
+                last: None,
+                provider: None,
+            });
+        }
+        if let Some(template) = &config.providers {
+            for (name, spec) in &template.proxies {
+                let mut health = spec.health_check.clone();
+                if health.enable && health.interval == 0 {
+                    health.interval = 300;
+                }
+                jobs.push(Job {
+                    spec: health,
+                    members: config
+                        .provider_members
+                        .get(name)
+                        .cloned()
+                        .unwrap_or_default(),
+                    group: None,
+                    last: None,
+                    provider: Some(name.clone()),
+                });
+            }
+        }
+        let mut names = BTreeMap::new();
+        for (i, node) in config.proxies.iter().enumerate() {
+            names.insert(
+                node.tag.clone(),
+                RouteTargetId::Proxy(crate::config::ProxyId::new(i).unwrap()),
+            );
+        }
+        for (i, group) in config.proxy_groups.iter().enumerate() {
+            names.insert(
+                group.name.clone(),
+                RouteTargetId::Group(crate::config::ProxyGroupId::new(i).unwrap()),
+            );
+        }
+        let activity = config
+            .proxies
+            .iter()
+            .map(|proxy| proxy.tag.clone())
+            .zip(activity)
+            .collect();
+        Arc::new(Self {
+            security,
+            jobs: Mutex::new(jobs),
+            samples: Mutex::new(BTreeMap::new()),
+            manual_samples: Mutex::new(BTreeMap::new()),
+            sequence: std::sync::atomic::AtomicU64::new(0),
+            probe_slots: tokio::sync::Semaphore::new(10),
+            groups,
+            targets,
+            direct,
+            names,
+            activity,
+            unified: config.unified_delay,
+            dns,
+            ipv6: config.ipv6,
+        })
+    }
+    pub fn states(&self) -> serde_json::Value {
+        let samples = self.samples.lock().unwrap();
+        let mut nodes = self
+            .names
+            .iter()
+            .filter(|(_, target)| matches!(target, RouteTargetId::Proxy(_)))
+            .map(|(name, _)| {
+                (
+                    name.clone(),
+                    serde_json::json!({"name":name,"alive":true,"history":[]}),
+                )
+            })
+            .collect::<BTreeMap<_, _>>();
+        for (name, kind) in [
+            ("DIRECT", "Direct"),
+            ("COMPATIBLE", "Compatible"),
+            ("REJECT", "Reject"),
+            ("REJECT-DROP", "RejectDrop"),
+            ("PASS", "Pass"),
+            ("PASS-RULE", "PassRule"),
+        ] {
+            nodes.insert(
+                name.to_owned(),
+                serde_json::json!({"name":name,"type":kind,"alive":true,"history":[]}),
+            );
+        }
+        let manual = self.manual_samples.lock().unwrap();
+        let mut latest = BTreeMap::<&str, &Sample>::new();
+        for (name, sample) in samples
+            .iter()
+            .map(|((name, _), s)| (name.as_str(), s))
+            .chain(manual.iter().map(|(name, s)| (name.as_str(), s)))
+        {
+            if latest.get(name).is_none_or(|old| old.order < sample.order) {
+                latest.insert(name, sample);
+            }
+        }
+        for (name, sample) in latest {
+            let node = nodes
+                .entry(name.to_owned())
+                .or_insert_with(|| serde_json::json!({"name":name}));
+            node["alive"] = serde_json::json!(sample.alive);
+            node["history"] = serde_json::json!([{"time":sample.time,"delay":sample.delay}]);
+        }
+        serde_json::json!(nodes)
+    }
+    fn sample(&self, result: &Result<probe::Observation, ProbeError>) -> Sample {
+        Sample {
+            alive: result.is_ok(),
+            delay: result.as_ref().map_or(0, |sample| sample.delay),
+            status: result.as_ref().ok().map(|sample| sample.status),
+            time: std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap_or_default()
+                .as_secs(),
+            order: self
+                .sequence
+                .fetch_add(1, std::sync::atomic::Ordering::Relaxed),
+        }
+    }
+
+    async fn run_probe(
+        &self,
+        name: &str,
+        request: &DelayRequest,
+        cancel: &CancellationToken,
+    ) -> Result<probe::Observation, ProbeError> {
+        let action = match name {
+            "DIRECT" | "COMPATIBLE" => crate::config::RuleAction::Direct,
+            "REJECT" | "PASS" | "PASS-RULE" => crate::config::RuleAction::Reject,
+            "REJECT-DROP" => crate::config::RuleAction::RejectDrop,
+            _ => {
+                crate::config::RuleAction::Route(*self.names.get(name).ok_or(ProbeError::NotFound)?)
+            }
+        };
+        if request.timeout.is_zero() {
+            return Err(ProbeError::Timeout);
+        }
+        let operation = async {
+            let _slot = self
+                .probe_slots
+                .acquire()
+                .await
+                .map_err(|_| ProbeError::Stopped)?;
+            let target = Target::parse(&request.url).map_err(|_| ProbeError::Failed)?;
+            let rules = RuleSet::compile(vec![crate::config::RuleSpec {
+                kind: crate::config::RuleKind::Match,
+                action,
+                no_resolve: false,
+            }])
+            .expect("health route");
+            let dispatcher = Arc::new(RoutingDispatcher::new_with_ipv6(
+                self.targets.clone(),
+                self.direct.clone(),
+                self.dns.clone(),
+                self.ipv6,
+                rules,
+                Arc::new(crate::routing::EmptyGeoMatcher),
+            ));
+            probe::observe(
+                &target,
+                dispatcher,
+                request.timeout,
+                self.unified,
+                &request.expected,
+                cancel,
+                &self.security,
+            )
+            .await
+            .map_err(|error| match error.kind() {
+                io::ErrorKind::TimedOut => ProbeError::Timeout,
+                io::ErrorKind::Interrupted => ProbeError::Stopped,
+                _ => ProbeError::Failed,
+            })
+        };
+        tokio::select! { biased;
+            () = cancel.cancelled() => Err(ProbeError::Stopped),
+            result = tokio::time::timeout(request.timeout, operation) => result.map_err(|_| ProbeError::Timeout)?,
+        }
+    }
+
+    fn record_manual(
+        &self,
+        name: &str,
+        url: &str,
+        result: &Result<probe::Observation, ProbeError>,
+    ) {
+        let sample = self.sample(result);
+        self.manual_samples
+            .lock()
+            .unwrap()
+            .insert(name.to_owned(), sample.clone());
+        let configured = self
+            .jobs
+            .lock()
+            .unwrap()
+            .iter()
+            .any(|job| job.spec.url == url && job.members.iter().any(|member| member == name));
+        if configured {
+            self.samples
+                .lock()
+                .unwrap()
+                .insert((name.to_owned(), url.to_owned()), sample);
+        }
+    }
+
+    pub async fn node_delay(
+        &self,
+        name: &str,
+        request: &DelayRequest,
+        cancel: &CancellationToken,
+    ) -> Result<u64, ProbeError> {
+        let result = self.run_probe(name, request, cancel).await;
+        if !cancel.is_cancelled() && result != Err(ProbeError::NotFound) {
+            self.record_manual(name, &request.url, &result);
+            self.apply_group_health();
+        }
+        result.map(|sample| sample.delay)
+    }
+
+    pub async fn group_delay(
+        &self,
+        name: &str,
+        request: &DelayRequest,
+        cancel: &CancellationToken,
+    ) -> Result<BTreeMap<String, u64>, ProbeError> {
+        let state = self.groups.state(name).map_err(|_| ProbeError::NotFound)?;
+        let configured_url = if state.kind == crate::config::GroupKind::UrlTest {
+            self.names.get(name).and_then(|target| {
+                let RouteTargetId::Group(id) = target else {
+                    return None;
+                };
+                self.jobs
+                    .lock()
+                    .unwrap()
+                    .iter()
+                    .find(|job| job.group == Some(id.index()))
+                    .map(|job| job.spec.url.clone())
+            })
+        } else {
+            None
+        };
+        let request = DelayRequest {
+            url: configured_url.unwrap_or_else(|| request.url.clone()),
+            timeout: request.timeout,
+            expected: request.expected.clone(),
+        };
+        let request = &request;
+        let work = state.all.into_iter().map(|name| async move {
+            let result = self.run_probe(&name, request, cancel).await;
+            if !cancel.is_cancelled() {
+                self.record_manual(&name, &request.url, &result);
+            }
+            (name, result)
+        });
+        let operation = async {
+            let mut results = stream::iter(work).buffer_unordered(10);
+            let mut delays = BTreeMap::new();
+            while let Some((name, result)) = results.next().await {
+                if let Ok(delay) = result {
+                    delays.insert(name, delay.delay);
+                }
+            }
+            self.apply_group_health();
+            if delays.is_empty() {
+                Err(ProbeError::Timeout)
+            } else {
+                Ok(delays)
+            }
+        };
+        tokio::select! { biased;
+            () = cancel.cancelled() => Err(ProbeError::Stopped),
+            result = tokio::time::timeout(request.timeout, operation) => result.map_err(|_| ProbeError::Timeout)?,
+        }
+    }
+
+    pub async fn provider_healthcheck(
+        &self,
+        name: &str,
+        cancel: &CancellationToken,
+    ) -> Result<(), ProbeError> {
+        let (spec, members) = self
+            .jobs
+            .lock()
+            .unwrap()
+            .iter()
+            .find(|job| job.provider.as_deref() == Some(name))
+            .map(|job| (job.spec.clone(), job.members.clone()))
+            .ok_or(ProbeError::NotFound)?;
+        if spec.url.is_empty() {
+            return Ok(());
+        }
+        let request = DelayRequest {
+            url: spec.url,
+            timeout: Duration::from_millis(if spec.timeout == 0 {
+                5000
+            } else {
+                spec.timeout
+            }),
+            expected: status_ranges(&spec.expected_status).expect("validated provider health"),
+        };
+        let work = members.into_iter().map(|name| async {
+            let result = self.run_probe(&name, &request, cancel).await;
+            if !cancel.is_cancelled() {
+                self.samples
+                    .lock()
+                    .unwrap()
+                    .insert((name, request.url.clone()), self.sample(&result));
+            }
+        });
+        let mut results = stream::iter(work).buffer_unordered(10);
+        while results.next().await.is_some() {
+            if cancel.is_cancelled() {
+                return Err(ProbeError::Stopped);
+            }
+        }
+        self.apply_group_health();
+        Ok(())
+    }
+
+    pub(super) fn apply_group_health(&self) {
+        let samples = self.samples.lock().unwrap();
+        for job in self.jobs.lock().unwrap().iter() {
+            if let Some(index) = job.group {
+                // A shared member/URL probe must retain each group's status policy.
+                let expected =
+                    status_ranges(&job.spec.expected_status).expect("validated health status");
+                let values = job
+                    .members
+                    .iter()
+                    .map(|name| {
+                        samples.get(&(name.clone(), job.spec.url.clone())).map_or(
+                            Some(u16::MAX.into()),
+                            |s| {
+                                (s.alive
+                                    && s.status.is_some_and(|status| {
+                                        expected.is_empty()
+                                            || expected.iter().any(|(start, end)| {
+                                                (*start..=*end).contains(&status)
+                                            })
+                                    }))
+                                .then_some(s.delay)
+                            },
+                        )
+                    })
+                    .collect::<Vec<_>>();
+                self.groups.apply_health(index, &values);
+            }
+        }
+    }
+
+    pub async fn tick(&self, cancel: &CancellationToken) {
+        let mut work = BTreeMap::new();
+        {
+            let mut jobs = self.jobs.lock().unwrap();
+            for job in jobs.iter_mut() {
+                let urgent = job
+                    .group
+                    .is_some_and(|i| self.groups.selection(i).take_urgent());
+                if !job.spec.enable
+                    || job.spec.url.is_empty()
+                    || (job.spec.interval == 0 && !urgent)
+                {
+                    continue;
+                }
+                let interval = Duration::from_secs(job.spec.interval);
+                if !urgent && job.last.is_some_and(|last| last.elapsed() < interval) {
+                    continue;
+                }
+                let active = job
+                    .group
+                    .map(|i| self.groups.selection(i).active(interval))
+                    .unwrap_or_else(|| {
+                        job.members.iter().any(|name| {
+                            self.activity
+                                .get(name)
+                                .is_some_and(|activity| activity.active(interval))
+                        }) || self
+                            .groups
+                            .list_states()
+                            .iter()
+                            .enumerate()
+                            .any(|(i, group)| {
+                                self.groups.selection(i).active(interval)
+                                    && group.all.iter().any(|name| job.members.contains(name))
+                            })
+                    });
+                if !urgent && job.last.is_some() && job.spec.lazy && !active {
+                    job.last = Some(Instant::now());
+                    continue;
+                }
+                job.last = Some(Instant::now());
+                for member in &job.members {
+                    work.entry((member.clone(), job.spec.url.clone()))
+                        .or_insert_with(|| job.spec.clone());
+                }
+            }
+        }
+        let jobs = work.into_iter().map(|((name, url), spec)| async move {
+            let request = DelayRequest {
+                url: url.clone(),
+                timeout: Duration::from_millis(if spec.timeout == 0 {
+                    5000
+                } else {
+                    spec.timeout
+                }),
+                expected: status_ranges(&spec.expected_status).expect("validated health status"),
+            };
+            let result = self.run_probe(&name, &request, cancel).await;
+            (name, url, result)
+        });
+        let mut results = stream::iter(jobs).buffer_unordered(10);
+        while let Some((name, url, result)) = results.next().await {
+            if cancel.is_cancelled() {
+                return;
+            }
+            self.samples
+                .lock()
+                .unwrap()
+                .insert((name, url), self.sample(&result));
+        }
+        self.apply_group_health();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+    struct MemoryProbe {
+        status: u16,
+        peers: Mutex<Vec<tokio::task::JoinHandle<()>>>,
+    }
+    #[async_trait::async_trait]
+    impl Dispatcher for MemoryProbe {
+        async fn connect_tcp(&self, session: StreamSession) -> Result<BoxStream, DispatchError> {
+            assert_eq!(
+                session.inbound,
+                crate::session::InboundKind::InternalMeasure
+            );
+            let (client, mut peer) = tokio::io::duplex(1024);
+            let status = self.status;
+            let task = tokio::spawn(async move {
+                let mut bytes = Vec::new();
+                while !bytes.ends_with(b"\r\n\r\n") {
+                    bytes.push(peer.read_u8().await.unwrap());
+                }
+                tokio::time::sleep(Duration::from_millis(2)).await;
+                peer.write_all(
+                    format!("HTTP/1.1 {status} Response\r\nContent-Length: 0\r\n\r\n").as_bytes(),
+                )
+                .await
+                .unwrap();
+            });
+            self.peers.lock().unwrap().push(task);
+            Ok(Box::new(client))
+        }
+        async fn open_datagram(
+            &self,
+            _: DatagramSession,
+        ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+            Err(DispatchError::NotAllowed)
+        }
+    }
+
+    fn shared_status_runtime() -> (Arc<HealthRuntime>, [Arc<MemoryProbe>; 2]) {
+        let config = Config::parse_yaml(
+            br#"
+mixed-port: 1080
+proxies:
+  - {name: a, type: socks5, server: 192.0.2.1, port: 1080}
+  - {name: b, type: socks5, server: 192.0.2.2, port: 1080}
+proxy-groups:
+  - {name: any, type: fallback, proxies: [a,b], url: 'http://example.test/health', interval: 60, lazy: false, expected-status: '*'}
+  - {name: strict, type: fallback, proxies: [a,b], url: 'http://example.test/health', interval: 60, lazy: false, expected-status: 204}
+  - {name: strict-copy, type: fallback, proxies: [a,b], url: 'http://example.test/health', interval: 60, lazy: false, expected-status: 204}
+"#,
+        )
+        .unwrap();
+        let nodes = [500, 204].map(|status| {
+            Arc::new(MemoryProbe {
+                status,
+                peers: Mutex::new(Vec::new()),
+            })
+        });
+        let proxies: Vec<Arc<dyn Dispatcher>> = vec![nodes[0].clone(), nodes[1].clone()];
+        let groups =
+            ProxyGroups::new(&config.proxy_groups, proxies.clone(), nodes[1].clone()).unwrap();
+        let targets = RouteTargetDispatchers::with_proxy_groups(proxies, &groups).unwrap();
+        let runtime = HealthRuntime::new(
+            &config,
+            groups,
+            targets,
+            nodes[1].clone(),
+            vec![],
+            None,
+            SecurityContext::new(),
+        );
+        (runtime, nodes)
+    }
+
+    fn assert_status_selections(runtime: &HealthRuntime, any: &str) {
+        assert_eq!(runtime.groups.state("any").unwrap().now, any);
+        assert_eq!(runtime.groups.state("strict").unwrap().now, "b");
+        assert_eq!(runtime.groups.state("strict-copy").unwrap().now, "b");
+    }
+
+    async fn finish_peers(nodes: &[Arc<MemoryProbe>]) {
+        for node in nodes {
+            let tasks = std::mem::take(&mut *node.peers.lock().unwrap());
+            for task in tasks {
+                task.await.unwrap();
+            }
+        }
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn shared_probes_apply_each_group_status_policy_and_refresh_failed_samples() {
+        let (runtime, nodes) = shared_status_runtime();
+        let cancel = CancellationToken::new();
+        runtime.tick(&cancel).await;
+        assert_status_selections(&runtime, "a");
+        assert_eq!(runtime.samples.lock().unwrap().len(), 2);
+        for node in &nodes {
+            assert_eq!(node.peers.lock().unwrap().len(), 1);
+        }
+
+        runtime.tick(&cancel).await;
+        for node in &nodes {
+            assert_eq!(node.peers.lock().unwrap().len(), 1);
+        }
+        let failed = runtime.sample(&Err(ProbeError::Timeout));
+        assert_eq!(failed.status, None);
+        runtime.samples.lock().unwrap().insert(
+            ("a".to_owned(), "http://example.test/health".to_owned()),
+            failed,
+        );
+        runtime.apply_group_health();
+        assert_status_selections(&runtime, "b");
+
+        runtime.jobs.lock().unwrap().reverse();
+        tokio::time::advance(Duration::from_secs(60)).await;
+        runtime.tick(&cancel).await;
+        assert_status_selections(&runtime, "a");
+        assert_eq!(runtime.samples.lock().unwrap().len(), 2);
+        for node in &nodes {
+            assert_eq!(node.peers.lock().unwrap().len(), 2);
+        }
+        finish_peers(&nodes).await;
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn manual_and_provider_probes_do_not_replace_group_status_policies() {
+        let (runtime, nodes) = shared_status_runtime();
+        let cancel = CancellationToken::new();
+        runtime.tick(&cancel).await;
+        let mut request = DelayRequest {
+            url: "http://example.test/health".to_owned(),
+            timeout: Duration::from_secs(1),
+            expected: vec![(204, 204)],
+        };
+        runtime.node_delay("a", &request, &cancel).await.unwrap();
+        assert_status_selections(&runtime, "a");
+        assert!(runtime.states()["a"]["alive"].as_bool().unwrap());
+
+        request.expected = vec![(500, 500)];
+        assert_eq!(
+            runtime
+                .group_delay("any", &request, &cancel)
+                .await
+                .unwrap()
+                .len(),
+            2
+        );
+        assert_status_selections(&runtime, "a");
+
+        let mut spec = runtime.jobs.lock().unwrap()[0].spec.clone();
+        spec.expected_status = "500".to_owned();
+        runtime.jobs.lock().unwrap().push(Job {
+            spec,
+            members: vec!["a".to_owned(), "b".to_owned()],
+            group: None,
+            last: None,
+            provider: Some("fixture".to_owned()),
+        });
+        runtime
+            .provider_healthcheck("fixture", &cancel)
+            .await
+            .unwrap();
+        assert_status_selections(&runtime, "a");
+        assert_eq!(runtime.samples.lock().unwrap().len(), 2);
+        assert_eq!(runtime.manual_samples.lock().unwrap().len(), 2);
+        finish_peers(&nodes).await;
+    }
+
+    #[tokio::test]
+    async fn manual_probes_keep_one_history_per_node_and_cancel_queued_work() {
+        let config = Config::parse_yaml(b"mixed-port: 1080\nrules:\n  - MATCH,DIRECT\n").unwrap();
+        let direct = Arc::new(MemoryProbe {
+            status: 204,
+            peers: Mutex::new(Vec::new()),
+        });
+        let groups = ProxyGroups::new(&config.proxy_groups, vec![], direct.clone()).unwrap();
+        let targets = RouteTargetDispatchers::with_proxy_groups(vec![], &groups).unwrap();
+        let runtime = HealthRuntime::new(
+            &config,
+            groups,
+            targets,
+            direct.clone(),
+            vec![],
+            None,
+            SecurityContext::new(),
+        );
+        let cancel = CancellationToken::new();
+        for index in 0..8 {
+            let request = DelayRequest {
+                url: format!("http://192.0.2.1/{index}"),
+                timeout: Duration::from_secs(1),
+                expected: vec![(204, 204)],
+            };
+            assert!(
+                runtime
+                    .node_delay("DIRECT", &request, &cancel)
+                    .await
+                    .unwrap()
+                    > 0
+            );
+        }
+        assert_eq!(runtime.manual_samples.lock().unwrap().len(), 1);
+        assert!(runtime.samples.lock().unwrap().is_empty());
+        let mismatch = DelayRequest {
+            url: "http://192.0.2.1/unexpected".into(),
+            timeout: Duration::from_secs(1),
+            expected: vec![(200, 200)],
+        };
+        assert!(
+            runtime
+                .node_delay("DIRECT", &mismatch, &cancel)
+                .await
+                .unwrap()
+                > 0
+        );
+        {
+            let samples = runtime.manual_samples.lock().unwrap();
+            assert!(samples["DIRECT"].alive);
+            assert_eq!(samples["DIRECT"].status, Some(204));
+        }
+        assert_eq!(
+            runtime.states()["DIRECT"]["history"]
+                .as_array()
+                .unwrap()
+                .len(),
+            1
+        );
+        let mut slots = Vec::new();
+        for _ in 0..10 {
+            slots.push(runtime.probe_slots.acquire().await.unwrap());
+        }
+        cancel.cancel();
+        let request = DelayRequest {
+            url: "http://192.0.2.1/".into(),
+            timeout: Duration::from_secs(60),
+            expected: vec![],
+        };
+        assert_eq!(
+            runtime.node_delay("DIRECT", &request, &cancel).await,
+            Err(ProbeError::Stopped)
+        );
+        drop(slots);
+        let tasks = std::mem::take(&mut *direct.peers.lock().unwrap());
+        for task in tasks {
+            task.await.unwrap();
+        }
+    }
+}
diff --git a/src/runtime/providers.rs b/src/runtime/providers.rs
new file mode 100644
index 0000000..faa5784
--- /dev/null
+++ b/src/runtime/providers.rs
@@ -0,0 +1,978 @@
+//! Transactional provider generations. Existing sessions pin their original graph.
+mod apply;
+use super::*;
+use crate::config::ProxyId;
+use crate::resource::config_apply::{ApplyRequest, ConfigApplyHandle};
+use crate::{
+    config::{RuleAction, RuleKind, RuleSpec},
+    dispatch::{BoxStream, DatagramBudget, DatagramTransport, DispatchError},
+    resource::{
+        cache::{ProviderCache, ProviderState},
+        control::{DelayRequest, DnsSnapshot, ProbeError, RuleUpdateError, RuntimeResources},
+    },
+    routing::ProxyGroupError,
+    session::{Datagram, DatagramSession, Destination, StreamSession},
+};
+use arc_swap::ArcSwap;
+use async_trait::async_trait;
+use std::{
+    collections::BTreeMap,
+    pin::Pin,
+    sync::{Mutex, RwLock},
+    task::{Context, Poll},
+};
+use tokio::{
+    io::{AsyncRead, AsyncWrite, ReadBuf},
+    sync::{mpsc, oneshot},
+};
+
+struct Generation {
+    connections: Arc<crate::connections::Registry>,
+    diagnostics: Option<Arc<diagnostics::Diagnostics>>,
+    health: Arc<health::HealthRuntime>,
+    requirements: GeoRequirements,
+    config: Config,
+    dispatcher: Arc<dyn Dispatcher>,
+    dns: Option<Arc<RuntimeDns>>,
+    groups: Arc<ProxyGroups>,
+    graph: Arc<BuiltProxyGraph>,
+    targets: RouteTargetDispatchers,
+    direct: Arc<dyn Dispatcher>,
+}
+impl Generation {
+    fn from_parts(
+        config: Config,
+        parts: &BuiltRuntimeParts,
+        requirements: GeoRequirements,
+    ) -> Self {
+        Self {
+            connections: parts.connections.clone(),
+            diagnostics: parts.diagnostics.clone(),
+            health: parts.health.clone(),
+            requirements,
+            config,
+            dispatcher: parts.dispatcher.clone(),
+            dns: parts.dns.clone(),
+            groups: parts.proxy_groups.clone(),
+            graph: parts.proxy_graph.clone(),
+            targets: parts.resource_targets.clone(),
+            direct: parts.direct.clone(),
+        }
+    }
+}
+struct Refresh {
+    rules: bool,
+    name: String,
+    reply: oneshot::Sender<Result<(), &'static str>>,
+}
+pub(super) struct ProviderRuntime {
+    security: SecurityContext,
+    store: crate::resource::profile::SelectionStore,
+    persistence_error: RwLock<Option<&'static str>>,
+    current: ArcSwap<Generation>,
+    retired: Mutex<Vec<Arc<Generation>>>,
+    publication: Mutex<()>,
+    cache: tokio::sync::Mutex<ProviderCache>,
+    states: RwLock<Vec<ProviderState>>,
+    requests: mpsc::Sender<Refresh>,
+    receiver: tokio::sync::Mutex<Option<mpsc::Receiver<Refresh>>>,
+    cancellation: CancellationToken,
+    config_apply: ConfigApplyHandle,
+    config_receiver: tokio::sync::Mutex<Option<mpsc::Receiver<ApplyRequest>>>,
+    logs: Option<Arc<crate::logging::RuntimeLog>>,
+    dialer: Dialer,
+    limits: ResourceLimits,
+    manager: Arc<GeoDataManager>,
+    lease: crate::geodata::GeoDataRegistrationLease,
+    geo: Arc<dyn GeoMatcher>,
+}
+impl ProviderRuntime {
+    pub(super) fn http_download_context(
+        &self,
+    ) -> crate::http_processing::providers::DownloadContext {
+        let generation = self.current.load_full();
+        let dispatcher = Arc::new(
+            ConnectorDispatcher::new(Arc::new(crate::outbound::NamedDirectOutbound::new(
+                generation.graph.dialer.clone(),
+            )))
+            .with_resolution(generation.graph.resolution.clone()),
+        );
+        crate::http_processing::providers::DownloadContext {
+            dispatcher: Arc::new(PinnedDispatcher {
+                generation,
+                dispatcher,
+            }),
+            security: self.security.clone(),
+        }
+    }
+    pub(super) fn new(
+        cache: ProviderCache,
+        prepared: &PreparedCore,
+        parts: &BuiltRuntimeParts,
+        dialer: Dialer,
+    ) -> Arc<Self> {
+        let (requests, receiver) = mpsc::channel(16);
+        let cancellation = CancellationToken::new();
+        let (config_apply, config_receiver) = ConfigApplyHandle::channel(cancellation.clone());
+        let requirements = GeoRequirements::for_rules(&prepared.config, prepared.rules.all_rules())
+            .expect("prepared requirements");
+        let root = prepared
+            .geodata_manager
+            .store_dir()
+            .parent()
+            .expect("dataDir");
+        let store = crate::resource::profile::SelectionStore::open(
+            root,
+            prepared.config.profile.store_selected,
+        );
+        store.restore(&parts.proxy_groups);
+        Arc::new(Self {
+            security: prepared.security.clone(),
+            store,
+            persistence_error: RwLock::new(None),
+            current: ArcSwap::from_pointee(Generation::from_parts(
+                prepared.config.clone(),
+                parts,
+                requirements,
+            )),
+            retired: Mutex::new(Vec::new()),
+            publication: Mutex::new(()),
+            states: RwLock::new(
+                cache
+                    .entries
+                    .iter()
+                    .map(|entry| entry.state.clone())
+                    .collect(),
+            ),
+            cache: tokio::sync::Mutex::new(cache),
+            requests,
+            receiver: tokio::sync::Mutex::new(Some(receiver)),
+            cancellation,
+            config_apply,
+            config_receiver: tokio::sync::Mutex::new(Some(config_receiver)),
+            logs: crate::logging::current(),
+            dialer,
+            limits: prepared.limits,
+            manager: prepared.geodata_manager.clone(),
+            lease: prepared.geodata_registration.updater_lease(),
+            geo: prepared.geodata_registration.matcher(),
+        })
+    }
+    pub(super) fn config_apply_handle(&self) -> ConfigApplyHandle {
+        self.config_apply.clone()
+    }
+    pub(super) fn begin_shutdown(&self) {
+        let _publication = self.publication.lock().unwrap();
+        self.security.identities.begin_shutdown();
+        self.cancellation.cancel();
+        self.current.load().connections.shutdown();
+        self.current.load().graph.begin_shutdown();
+        for generation in self.retired.lock().unwrap().iter() {
+            generation.graph.begin_shutdown();
+        }
+    }
+    pub(super) async fn shutdown(&self) {
+        self.begin_shutdown();
+        let current = self.current.load_full();
+        current.graph.shutdown().await;
+        let retired = std::mem::take(&mut *self.retired.lock().unwrap());
+        for generation in retired {
+            generation.graph.shutdown().await;
+        }
+    }
+    async fn reap(&self) {
+        let expired = {
+            let mut retired = self.retired.lock().unwrap();
+            let mut expired = Vec::new();
+            let mut i = 0;
+            while i < retired.len() {
+                if Arc::strong_count(&retired[i]) == 1 {
+                    expired.push(retired.swap_remove(i));
+                } else {
+                    i += 1;
+                }
+            }
+            expired
+        };
+        let changed = !expired.is_empty();
+        for generation in expired {
+            generation.graph.begin_shutdown();
+            generation.graph.shutdown().await;
+        }
+        if changed && !self.cancellation.is_cancelled() {
+            let current = self.current.load_full();
+            if let Ok(requirements) = self.combined_requirements(&current.requirements) {
+                let manager = self.manager.clone();
+                let lease = self.lease.clone();
+                let cancellation = self.cancellation.clone();
+                let _ = tokio::task::spawn_blocking(move || {
+                    manager.replace_requirements(&lease, requirements, &cancellation)
+                })
+                .await;
+            }
+        }
+    }
+
+    async fn maintain(&self) {
+        self.reap().await;
+        if !self.security.identities.has_sources() || self.cancellation.is_cancelled() {
+            return;
+        }
+        let identities = self.security.identities.clone();
+        let cancellation = self.cancellation.clone();
+        // Await even during Stop: no file read or candidate publication may
+        // outlive the existing resource worker's synchronous join barrier.
+        let _ = tokio::task::spawn_blocking(move || identities.refresh(&cancellation)).await;
+    }
+    fn combined_requirements(
+        &self,
+        next: &GeoRequirements,
+    ) -> Result<GeoRequirements, &'static str> {
+        let mut requirements = next.clone();
+        requirements
+            .extend(&self.current.load().requirements)
+            .map_err(|_| "invalid resource requirements")?;
+        for old in self.retired.lock().unwrap().iter() {
+            requirements
+                .extend(&old.requirements)
+                .map_err(|_| "invalid resource requirements")?;
+        }
+        Ok(requirements)
+    }
+    pub(super) async fn run(self: Arc<Self>, parent: CancellationToken) -> io::Result<()> {
+        let health = async {
+            let mut tick = tokio::time::interval(Duration::from_secs(1));
+            loop {
+                tokio::select! {biased;
+                    ()=parent.cancelled()=>{self.begin_shutdown();break;},
+                    ()=self.cancellation.cancelled()=>break,
+                    _=tick.tick()=>{let current=self.current.load_full(); current.health.tick(&self.cancellation).await;}
+                }
+            }
+        };
+        let worker = self.provider_loop(parent.clone());
+        let (result, ()) = tokio::join!(worker, health);
+        result
+    }
+    async fn provider_loop(self: &Arc<Self>, parent: CancellationToken) -> io::Result<()> {
+        let mut receiver = self
+            .receiver
+            .lock()
+            .await
+            .take()
+            .ok_or_else(|| io::Error::other("provider worker already running"))?;
+        let mut config_receiver = self
+            .config_receiver
+            .lock()
+            .await
+            .take()
+            .ok_or_else(|| io::Error::other("configuration worker already running"))?;
+        let mut maintenance = tokio::time::interval(Duration::from_secs(1));
+        loop {
+            let deadline = self.cache.lock().await.next_refresh().map(|(_, at)| at);
+            let refresh = async {
+                if let Some(deadline) = deadline {
+                    tokio::time::sleep_until(deadline).await;
+                } else {
+                    std::future::pending::<()>().await;
+                }
+            };
+            tokio::select! {
+                biased;
+                ()=parent.cancelled()=>{self.begin_shutdown();return Ok(());}
+                ()=self.cancellation.cancelled()=>return Ok(()),
+                request=config_receiver.recv()=>if let Some(request)=request {self.apply_request(request).await;},
+                request=receiver.recv()=>if let Some(request)=request {
+                    let index=self.cache.lock().await.entries.iter().position(|entry|entry.state.rule==request.rules && entry.state.name==request.name);
+                    let result=match index {Some(index)=>self.update(index).await,None=>Err("unknown provider")};
+                    let _=request.reply.send(result);
+                },
+                ()=refresh=>{
+                    let due=self.cache.lock().await.next_due();
+                    if let Some(index)=due { let _=self.update(index).await; }
+                },
+                _=maintenance.tick()=>self.maintain().await,
+            }
+        }
+    }
+    async fn update(self: &Arc<Self>, index: usize) -> Result<(), &'static str> {
+        let result = self.update_inner(index).await;
+        if result.is_err() && !self.cancellation.is_cancelled() {
+            let mut cache = self.cache.lock().await;
+            // Fetch/parse and ordinary candidate failures already schedule
+            // backoff. Cover later preparation/publication errors that left an
+            // expired deadline so the exact timer cannot spin immediately.
+            if cache.entries[index].next <= tokio::time::Instant::now() {
+                cache.reject(index);
+                self.record_states(&cache);
+            }
+        }
+        result
+    }
+    async fn update_inner(self: &Arc<Self>, index: usize) -> Result<(), &'static str> {
+        let mut cache = self.cache.lock().await;
+        let proxy = cache.entries[index].spec.proxy.clone();
+        let generation = self.current.load_full();
+        let dispatcher = match self.download_dispatcher(generation.clone(), &proxy) {
+            Ok(dispatcher) => dispatcher,
+            Err(error) => {
+                cache.reject(index);
+                self.record_states(&cache);
+                return Err(error);
+            }
+        };
+        cache.entries[index].state.updating = true;
+        self.record_states(&cache);
+        let user_agent = generation.config.global_ua.clone();
+        let etag = generation.config.etag_support;
+        let candidate = cache
+            .fetch(
+                index,
+                dispatcher,
+                user_agent,
+                etag,
+                self.security.clone(),
+                self.cancellation.clone(),
+            )
+            .await;
+        self.record_states(&cache);
+        let Some(candidate) = candidate.map_err(|_| "resource fetch failed")? else {
+            return Ok(());
+        };
+        let mut contents = cache.contents.clone();
+        contents.insert(cache.entries[index].key.clone(), candidate.content.clone());
+        let template = cache.template.clone();
+        let limits = self.limits;
+        let dialer = self.dialer.clone();
+        let geo = self.geo.clone();
+        let previous_dns = generation.dns.clone();
+        let hosts = generation.config.dns.hosts.clone();
+        let connections = generation.connections.clone();
+        let data_dir = self
+            .manager
+            .store_dir()
+            .parent()
+            .map(std::path::Path::to_path_buf);
+        let security = self.security.clone();
+        let expression_cancellation = self.cancellation.clone();
+        let prepared = tokio::task::spawn_blocking(
+            move || -> io::Result<(Config, BuiltRuntimeParts, GeoRequirements)> {
+                let mut config = template
+                    .materialize_with_cancel(&contents, Some(&expression_cancellation))
+                    .map_err(io::Error::other)?;
+                // Provider refreshes do not refresh the session's startup LAN snapshot.
+                config.dns.hosts = hosts;
+                let requirements =
+                    GeoRequirements::for_config(&config).map_err(io::Error::other)?;
+                let rules = RuleSet::compile_config(&mut config).map_err(io::Error::other)?;
+                let endpoints = vec![PreparedProxyEndpoints::default(); config.proxies.len()];
+                let parts = GraphBuilder {
+                    security,
+                    connections,
+                    config: config.clone(),
+                    endpoints,
+                    limits,
+                    rules,
+                    geo_matcher: geo,
+                    previous_dns,
+                    data_dir,
+                }
+                .build(dialer)?;
+                Ok((config, parts, requirements))
+            },
+        )
+        .await
+        .map_err(|_| "provider preparation failed")?;
+        let (config, parts, requirements) = match prepared {
+            Ok(value) => value,
+            Err(_) => {
+                cache.reject(index);
+                self.record_states(&cache);
+                return Err("provider candidate rejected");
+            }
+        };
+        let next = Arc::new(Generation::from_parts(config, &parts, requirements.clone()));
+        let requirements = self.combined_requirements(&requirements)?;
+        let manager = self.manager.clone();
+        let lease = self.lease.clone();
+        let cancellation = self.cancellation.clone();
+        let updated = tokio::task::spawn_blocking(move || {
+            manager.replace_requirements(&lease, requirements, &cancellation)
+        })
+        .await;
+        if !matches!(updated, Ok(Ok(()))) || self.cancellation.is_cancelled() {
+            next.graph.begin_shutdown();
+            next.graph.shutdown().await;
+            return Err("provider update cancelled");
+        }
+        let result: io::Result<()> = {
+            let _publication = self.publication.lock().unwrap();
+            if self.cancellation.is_cancelled() {
+                Err(io::ErrorKind::Interrupted.into())
+            } else {
+                cache
+                    .commit(index, candidate, &self.cancellation)
+                    .map(|()| {
+                        for (index, state) in self
+                            .current
+                            .load()
+                            .groups
+                            .list_states()
+                            .into_iter()
+                            .enumerate()
+                        {
+                            let forced = self
+                                .current
+                                .load()
+                                .groups
+                                .selection(index)
+                                .forced()
+                                .is_some();
+                            let _ = next
+                                .groups
+                                .inherit_selection(&state.name, &state.now, forced);
+                        }
+                        let old = self.current.swap(next.clone());
+                        self.retired.lock().unwrap().push(old);
+                    })
+            }
+        };
+        if result.is_err() {
+            next.graph.begin_shutdown();
+            next.graph.shutdown().await;
+            cache.reject(index);
+        }
+        self.record_states(&cache);
+        result.map_err(|_| "provider cache commit failed")
+    }
+    fn record_states(&self, cache: &ProviderCache) {
+        *self.states.write().unwrap() = cache
+            .entries
+            .iter()
+            .map(|entry| entry.state.clone())
+            .collect();
+    }
+    fn download_dispatcher(
+        &self,
+        generation: Arc<Generation>,
+        name: &str,
+    ) -> Result<Arc<dyn Dispatcher>, &'static str> {
+        let dispatcher = if name.is_empty() {
+            generation.dispatcher.clone()
+        } else {
+            let action = match name {
+                "DIRECT" | "COMPATIBLE" => RuleAction::Direct,
+                "REJECT" => RuleAction::Reject,
+                "REJECT-DROP" => RuleAction::RejectDrop,
+                _ => {
+                    if let Some(index) = generation
+                        .config
+                        .proxies
+                        .iter()
+                        .position(|proxy| proxy.tag == name)
+                    {
+                        RuleAction::Route(RouteTargetId::Proxy(ProxyId::new(index).unwrap()))
+                    } else if let Some(index) = generation
+                        .config
+                        .proxy_groups
+                        .iter()
+                        .position(|group| group.name == name)
+                    {
+                        RuleAction::Route(RouteTargetId::Group(
+                            crate::config::ProxyGroupId::new(index).unwrap(),
+                        ))
+                    } else {
+                        return Err("unknown provider download proxy");
+                    }
+                }
+            };
+            let rules = RuleSet::compile(vec![RuleSpec {
+                kind: RuleKind::Match,
+                action,
+                no_resolve: false,
+            }])
+            .map_err(|_| "invalid resource route")?;
+            Arc::new(RoutingDispatcher::new_with_ipv6(
+                generation.targets.clone(),
+                generation.direct.clone(),
+                generation.dns.clone(),
+                generation.config.ipv6,
+                rules,
+                self.geo.clone(),
+            )) as Arc<dyn Dispatcher>
+        };
+        Ok(Arc::new(PinnedDispatcher {
+            generation,
+            dispatcher,
+        }))
+    }
+}
+#[async_trait]
+impl RuntimeResources for ProviderRuntime {
+    fn connections(&self) -> Arc<crate::connections::Registry> {
+        self.current.load().connections.clone()
+    }
+    fn config_apply(&self) -> Option<ConfigApplyHandle> {
+        Some(self.config_apply.clone())
+    }
+    fn configs(&self) -> serde_json::Value {
+        self.current
+            .load()
+            .diagnostics
+            .as_ref()
+            .map_or(serde_json::Value::Null, |diagnostics| diagnostics.config())
+    }
+    fn rules(&self) -> serde_json::Value {
+        self.current.load().diagnostics.as_ref().map_or_else(
+            || serde_json::json!({"rules": []}),
+            |diagnostics| diagnostics.rules(),
+        )
+    }
+
+    fn disable_rules(&self, changes: &[(usize, bool)]) -> Result<(), RuleUpdateError> {
+        // A replacement uses this same outer lock, so validation and mutation
+        // cannot accidentally target the previous generation after publication.
+        let _publication = self.publication.lock().unwrap();
+        let current = self.current.load();
+        current
+            .diagnostics
+            .as_ref()
+            .ok_or(RuleUpdateError::NotFound)?
+            .disable_rules(changes)
+            .map_err(|()| RuleUpdateError::InvalidIndex)
+    }
+    fn groups(&self) -> Arc<ProxyGroups> {
+        self.current.load().groups.clone()
+    }
+    fn select(&self, group: &str, member: &str) -> Result<(), ProxyGroupError> {
+        let _publication = self.publication.lock().unwrap();
+        self.current.load().groups.select(group, member)?;
+        *self.persistence_error.write().unwrap() = self
+            .store
+            .save(group, member)
+            .err()
+            .map(|_| "selection cache write failed");
+        Ok(())
+    }
+    fn clear_fixed(&self, group: &str) -> Result<(), ProxyGroupError> {
+        let _publication = self.publication.lock().unwrap();
+        let current = self.current.load();
+        current.groups.clear_fixed(group)?;
+        current.health.apply_group_health();
+        *self.persistence_error.write().unwrap() = self
+            .store
+            .save(group, "")
+            .err()
+            .map(|_| "selection cache write failed");
+        Ok(())
+    }
+    fn health(&self) -> serde_json::Value {
+        serde_json::json!({"proxies":self.current.load().health.states(),"selectionError":*self.persistence_error.read().unwrap()})
+    }
+    fn providers(&self, rules: bool) -> serde_json::Value {
+        let providers = self
+            .states
+            .read()
+            .unwrap()
+            .iter()
+            .filter(|state| state.rule == rules)
+            .map(|state| {
+                let mut value = serde_json::to_value(state).expect("provider status");
+                value["type"] = serde_json::json!(if rules { "Rule" } else { "Proxy" });
+                if !rules {
+                    let current = self.current.load_full();
+                    let health = current.health.states();
+                    value["proxies"] = serde_json::json!(
+                        current
+                            .config
+                            .provider_members
+                            .get(&state.name)
+                            .into_iter()
+                            .flatten()
+                            .filter_map(|name| health.get(name))
+                            .collect::<Vec<_>>()
+                    );
+                }
+                (state.name.clone(), value)
+            })
+            .collect::<BTreeMap<_, _>>();
+        serde_json::json!({"providers":providers})
+    }
+    fn dns(&self) -> Option<DnsSnapshot> {
+        let generation = self.current.load_full();
+        generation.dns.clone().map(|dns| DnsSnapshot {
+            dns,
+            _generation: Some(generation),
+        })
+    }
+    async fn node_delay(
+        &self,
+        name: &str,
+        request: &DelayRequest,
+        cancel: &CancellationToken,
+    ) -> Result<u64, ProbeError> {
+        let generation = self.current.load_full();
+        tokio::select! { biased;
+            () = self.cancellation.cancelled() => Err(ProbeError::Stopped),
+            result = generation.health.node_delay(name, request, cancel) => result,
+        }
+    }
+    async fn group_delay(
+        &self,
+        name: &str,
+        request: &DelayRequest,
+        cancel: &CancellationToken,
+    ) -> Result<BTreeMap<String, u64>, ProbeError> {
+        let generation = {
+            // Reset and persist under the same publication lock as manual selection.
+            // Release it before any probe waits or network I/O.
+            let _publication = self.publication.lock().unwrap();
+            let generation = self.current.load_full();
+            if let Ok(state) = generation.groups.state(name)
+                && matches!(
+                    state.kind,
+                    crate::config::GroupKind::UrlTest | crate::config::GroupKind::Fallback
+                )
+            {
+                if let Some(index) = generation
+                    .config
+                    .proxy_groups
+                    .iter()
+                    .position(|group| group.name == name)
+                {
+                    generation.groups.selection(index).clear_forced();
+                }
+                *self.persistence_error.write().unwrap() = self
+                    .store
+                    .save(name, "")
+                    .err()
+                    .map(|_| "selection cache write failed");
+            }
+            generation
+        };
+        tokio::select! { biased;
+            () = self.cancellation.cancelled() => Err(ProbeError::Stopped),
+            result = generation.health.group_delay(name, request, cancel) => result,
+        }
+    }
+    async fn provider_healthcheck(
+        &self,
+        name: &str,
+        cancel: &CancellationToken,
+    ) -> Result<(), ProbeError> {
+        let generation = self.current.load_full();
+        tokio::select! { biased;
+            () = self.cancellation.cancelled() => Err(ProbeError::Stopped),
+            result = generation.health.provider_healthcheck(name, cancel) => result,
+        }
+    }
+    async fn refresh(&self, rules: bool, name: &str) -> Result<(), &'static str> {
+        if self.cancellation.is_cancelled() {
+            return Err("runtime stopped");
+        }
+        let (reply, response) = oneshot::channel();
+        tokio::select! {biased; ()=self.cancellation.cancelled()=>Err("runtime stopped"),result=async {self.requests.send(Refresh{rules,name:name.to_owned(),reply}).await.map_err(|_|"runtime stopped")?;response.await.map_err(|_|"runtime stopped")?}=>result}
+    }
+}
+#[async_trait]
+impl Dispatcher for ProviderRuntime {
+    #[cfg(feature = "inbound-http")]
+    fn http_context(&self) -> Option<crate::http_processing::HttpContext> {
+        if self.cancellation.is_cancelled() {
+            return None;
+        }
+        let generation = self.current.load();
+        let policy = generation.config.http_policy()?;
+        let generation = Arc::clone(&generation);
+        let dispatcher = Arc::new(PinnedDispatcher {
+            dispatcher: generation.dispatcher.clone(),
+            generation,
+        });
+        Some(crate::http_processing::HttpContext::new(
+            policy,
+            dispatcher,
+            self.security.clone(),
+        ))
+    }
+
+    fn supports_udp(&self) -> bool {
+        self.current.load().dispatcher.supports_udp()
+    }
+
+    async fn sniff_plan(
+        &self,
+        source: SocketAddr,
+        destination: &Destination,
+    ) -> Result<Option<crate::sniffing::Plan>, DispatchError> {
+        if self.cancellation.is_cancelled() {
+            return Err(DispatchError::NotAllowed);
+        }
+        self.current
+            .load_full()
+            .dispatcher
+            .sniff_plan(source, destination)
+            .await
+    }
+
+    async fn connect_tcp(&self, session: StreamSession) -> Result<BoxStream, DispatchError> {
+        if self.cancellation.is_cancelled() {
+            return Err(DispatchError::NotAllowed);
+        }
+        let generation = self.current.load_full();
+        let io = generation.dispatcher.connect_tcp(session).await?;
+        Ok(Box::new(GenerationStream {
+            io,
+            _generation: generation,
+        }))
+    }
+    async fn open_datagram(
+        &self,
+        session: DatagramSession,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        if self.cancellation.is_cancelled() {
+            return Err(DispatchError::NotAllowed);
+        }
+        let generation = self.current.load_full();
+        let io = generation.dispatcher.open_datagram(session).await?;
+        Ok(Box::new(GenerationDatagram {
+            io,
+            _generation: generation,
+        }))
+    }
+}
+struct PinnedDispatcher {
+    generation: Arc<Generation>,
+    dispatcher: Arc<dyn Dispatcher>,
+}
+#[async_trait]
+impl Dispatcher for PinnedDispatcher {
+    fn supports_udp(&self) -> bool {
+        self.dispatcher.supports_udp()
+    }
+
+    async fn sniff_plan(
+        &self,
+        source: SocketAddr,
+        destination: &Destination,
+    ) -> Result<Option<crate::sniffing::Plan>, DispatchError> {
+        self.dispatcher.sniff_plan(source, destination).await
+    }
+
+    async fn connect_tcp(&self, session: StreamSession) -> Result<BoxStream, DispatchError> {
+        let io = self.dispatcher.connect_tcp(session).await?;
+        Ok(Box::new(GenerationStream {
+            io,
+            _generation: self.generation.clone(),
+        }))
+    }
+    async fn open_datagram(
+        &self,
+        session: DatagramSession,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        let io = self.dispatcher.open_datagram(session).await?;
+        Ok(Box::new(GenerationDatagram {
+            io,
+            _generation: self.generation.clone(),
+        }))
+    }
+}
+struct GenerationStream {
+    io: BoxStream,
+    _generation: Arc<Generation>,
+}
+impl AsyncRead for GenerationStream {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.io).poll_read(cx, buf)
+    }
+}
+impl AsyncWrite for GenerationStream {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        Pin::new(&mut self.io).poll_write(cx, buf)
+    }
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.io).poll_flush(cx)
+    }
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.io).poll_shutdown(cx)
+    }
+}
+struct GenerationDatagram {
+    io: Box<dyn DatagramTransport>,
+    _generation: Arc<Generation>,
+}
+#[async_trait]
+impl DatagramTransport for GenerationDatagram {
+    fn supports_shared_destinations(&self) -> bool {
+        self.io.supports_shared_destinations()
+    }
+
+    fn payload_budget(&self, peer: &Destination) -> DatagramBudget {
+        self.io.payload_budget(peer)
+    }
+    async fn send(&mut self, datagram: Datagram) -> Result<(), DispatchError> {
+        self.io.send(datagram).await
+    }
+    async fn send_with_flow_id(
+        &mut self,
+        datagram: Datagram,
+        id: &[u8],
+    ) -> Result<(), DispatchError> {
+        self.io.send_with_flow_id(datagram, id).await
+    }
+    async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+        self.io.receive().await
+    }
+    async fn close(&mut self) -> Result<(), DispatchError> {
+        self.io.close().await
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::dialer::SystemResolver;
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+    #[tokio::test]
+    async fn file_refresh_publishes_valid_members_and_preserves_old_sessions() {
+        let root = tempfile::tempdir().unwrap();
+        let file = root.path().join("nodes.yaml");
+        let payload = |name: &str| {
+            format!("proxies: [{{name: {name}, type: socks5, server: 192.0.2.1, port: 1080}}]\n")
+        };
+        std::fs::write(&file, payload("old")).unwrap();
+        let mut config = Config::parse_yaml(
+            br#"
+mixed-port: 1080
+external-controller: 127.0.0.1:0
+proxy-providers:
+  remote:
+    type: file
+    path: nodes.yaml
+    filter: '(?=.)'
+    override:
+      override-expr:
+        - '.name |= sub("^old$", "old-renamed")'
+        - '(select(.name == "bad-expr") | .port) = ("private-expression-value" | tonumber)'
+proxy-groups:
+  - {name: choice, type: select, use: [remote]}
+dns:
+  enable: true
+  enhanced-mode: fake-ip
+  nameserver: [192.0.2.53]
+profile: {store-fake-ip: true}
+rules: ['MATCH,choice']
+"#,
+        )
+        .unwrap();
+        Arc::make_mut(config.providers.as_mut().unwrap()).proxies[0]
+            .1
+            .age_identities =
+            crate::resource::age_provider::Identities::from_value(serde_yaml_ng::Value::String(
+                include_str!("../../tests/fixtures/provider-age/x25519.key").into(),
+            ))
+            .unwrap();
+        let manager =
+            GeoDataManager::open(&root.path().join("geodata"), Duration::from_secs(86400)).unwrap();
+        let prepared = PreparedCore::prepare_config(
+            config,
+            manager,
+            &SystemResolver,
+            ResourceLimits::default(),
+        )
+        .await
+        .unwrap();
+        let parts = prepared.build_dispatcher(Dialer::default()).unwrap();
+        let live = parts.resources.clone().unwrap();
+        let generation = live.current.load_full();
+        live.disable_rules(&[(0, true)]).unwrap();
+        assert!(matches!(
+            live.disable_rules(&[(0, false), (1, true)]),
+            Err(RuleUpdateError::InvalidIndex)
+        ));
+        assert_eq!(live.rules()["rules"][0]["extra"]["disabled"], true);
+        let old_rule_view = generation.diagnostics.clone().unwrap();
+        let query = crate::dns::build_query(1, "example.com", crate::dns::QueryType::A).unwrap();
+        let wire = generation
+            .dns
+            .as_ref()
+            .unwrap()
+            .exchange(&query)
+            .await
+            .unwrap();
+        assert!(
+            !crate::dns::parse_response(&wire)
+                .unwrap()
+                .answers
+                .is_empty()
+        );
+        let registry = live.connections();
+        let weak = Arc::downgrade(&generation);
+        let (io, mut peer) = tokio::io::duplex(32);
+        let mut old_session = GenerationStream {
+            io: Box::new(io),
+            _generation: generation,
+        };
+        assert_eq!(live.groups().state("choice").unwrap().now, "old-renamed");
+        std::fs::write(&file, payload("new-node")).unwrap();
+        live.update(0).await.unwrap();
+        assert_eq!(live.rules()["rules"][0]["extra"]["disabled"], false);
+        assert_eq!(old_rule_view.rules()["rules"][0]["extra"]["disabled"], true);
+        drop(old_rule_view);
+        assert_eq!(live.groups().state("choice").unwrap().now, "new-node");
+        assert!(Arc::ptr_eq(&registry, &live.connections()));
+        std::fs::write(&file, payload("bad-expr")).unwrap();
+        assert!(live.update(0).await.is_err());
+        assert_eq!(live.groups().state("choice").unwrap().now, "new-node");
+        assert!(
+            !live
+                .providers(false)
+                .to_string()
+                .contains("private-expression-value")
+        );
+        peer.write_all(b"active").await.unwrap();
+        let mut buffer = [0; 6];
+        old_session.read_exact(&mut buffer).await.unwrap();
+        assert_eq!(&buffer, b"active");
+        live.reap().await;
+        assert!(weak.upgrade().is_some());
+        let encrypted = include_bytes!("../../tests/fixtures/provider-age/x25519.age");
+        std::fs::write(&file, encrypted).unwrap();
+        live.update(0).await.unwrap();
+        assert_eq!(live.groups().state("choice").unwrap().now, "age-node");
+        for bad_encrypted in [
+            include_bytes!("../../tests/fixtures/provider-age/hybrid.age").as_slice(),
+            &encrypted[..encrypted.len() - 40],
+        ] {
+            std::fs::write(&file, bad_encrypted).unwrap();
+            assert!(live.update(0).await.is_err());
+            assert_eq!(live.groups().state("choice").unwrap().now, "age-node");
+        }
+        std::fs::write(
+            &file,
+            b"proxies: [{name: bad, type: socks5, server: missing}]\n",
+        )
+        .unwrap();
+        assert!(live.update(0).await.is_err());
+        assert_eq!(live.groups().state("choice").unwrap().now, "age-node");
+        assert!(live.providers(false)["providers"]["remote"]["error"].is_string());
+        std::fs::write(&file, payload(&"x".repeat(4097))).unwrap();
+        assert!(live.update(0).await.is_err());
+        assert_eq!(live.groups().state("choice").unwrap().now, "age-node");
+        drop(old_session);
+        live.reap().await;
+        assert!(weak.upgrade().is_none());
+        let worker = tokio::spawn(live.clone().run(CancellationToken::new()));
+        live.begin_shutdown();
+        worker.await.unwrap().unwrap();
+        live.shutdown().await;
+        assert!(live.refresh(false, "remote").await.is_err());
+    }
+}
diff --git a/src/runtime/providers/apply.rs b/src/runtime/providers/apply.rs
new file mode 100644
index 0000000..bd75201
--- /dev/null
+++ b/src/runtime/providers/apply.rs
@@ -0,0 +1,710 @@
+//! Live configuration uses the same immutable graphs and publication as providers.
+use super::*;
+use crate::resource::config_apply::{ApplyError, ApplyRequest, ConfigUpdate};
+
+impl ProviderRuntime {
+    async fn refresh_geodata(&self, cancel: &CancellationToken) -> Result<(), ApplyError> {
+        let current = self.current.load_full();
+        let Some(config) = &current.config.geodata_update else {
+            return Ok(());
+        };
+        let service = GeoDataUpdateService::new(
+            self.manager.clone(),
+            current.dispatcher.clone(),
+            self.lease.clone(),
+            config.urls.clone(),
+            config.geodata_mode,
+            current.config.global_ua.clone(),
+            current.config.etag_support,
+            false,
+            self.security.clone(),
+        );
+        service.refresh_active(cancel.clone()).await.map_err(|_| {
+            if cancel.is_cancelled() {
+                ApplyError::Stopped
+            } else {
+                ApplyError::PreparationFailed
+            }
+        })
+    }
+
+    async fn flush_fake_ip(&self, cancel: &CancellationToken) -> Result<(), ApplyError> {
+        if cancel.is_cancelled() {
+            return Err(ApplyError::Stopped);
+        }
+        let current = self.current.load_full();
+        if let Some(dns) = &current.dns {
+            // The worker joins this future even if its caller/Stop cancels it;
+            // never detach the already-started durable database transaction.
+            dns.flush_fake_ip()
+                .await
+                .map_err(|_| ApplyError::PreparationFailed)?;
+        }
+        if cancel.is_cancelled() {
+            Err(ApplyError::Stopped)
+        } else {
+            Ok(())
+        }
+    }
+
+    pub(super) async fn apply_request(&self, mut request: ApplyRequest) {
+        let cancellation = request.cancellation();
+        let update = request.take_update();
+        let result = self.apply_update(update, cancellation).await;
+        request.complete(result);
+    }
+    async fn apply_update(
+        &self,
+        update: ConfigUpdate,
+        cancel: CancellationToken,
+    ) -> Result<(), ApplyError> {
+        if cancel.is_cancelled() {
+            return Err(ApplyError::Stopped);
+        }
+        match &update {
+            ConfigUpdate::RecoverySnapshot(reply) => {
+                let cache = self.cache.lock().await.clone();
+                let _publication = self.publication.lock().unwrap();
+                if cancel.is_cancelled() || self.cancellation.is_cancelled() {
+                    return Err(ApplyError::Stopped);
+                }
+                let current = self.current.load_full();
+                let mut config = current.config.clone();
+                for state in current.groups.list_states() {
+                    if state.kind == crate::config::GroupKind::LoadBalance {
+                        continue;
+                    }
+                    let Some(group) = config
+                        .proxy_groups
+                        .iter_mut()
+                        .find(|group| group.name == state.name)
+                    else {
+                        return Err(ApplyError::PreparationFailed);
+                    };
+                    group.initial_member = group
+                        .members
+                        .iter()
+                        .position(|member| member.name == state.now)
+                        .ok_or(ApplyError::PreparationFailed)?;
+                }
+                let snapshot = Box::new(crate::runtime::RecoverySnapshot {
+                    config,
+                    provider_cache: Some(cache),
+                });
+                return reply.send(snapshot).map_err(|_| ApplyError::Stopped);
+            }
+            // Implementations are supplied by the shared maintenance adapter;
+            // these commands occupy the same admission and worker as reloads.
+            ConfigUpdate::RefreshGeoData => return self.refresh_geodata(&cancel).await,
+            ConfigUpdate::RefreshHttp {
+                document,
+                context,
+                store,
+                force,
+                security,
+                reply,
+            } => {
+                let mut network = self.http_download_context();
+                if let Some(security) = security {
+                    network.security = security.clone();
+                }
+                let candidate = crate::resource::http_control::refresh(
+                    document.clone(),
+                    context,
+                    store,
+                    &network,
+                    &cancel,
+                    *force,
+                )
+                .await?;
+                if let Some(reply) = reply {
+                    reply.try_send(candidate).map_err(|_| ApplyError::Stopped)?;
+                }
+                return Ok(());
+            }
+            ConfigUpdate::FlushFakeIp => return self.flush_fake_ip(&cancel).await,
+            _ => {}
+        }
+        if matches!(&update,ConfigUpdate::Patch(patch) if patch.is_empty()) {
+            return Ok(());
+        }
+        let current = self.current.load_full();
+        let previous = current.clone();
+        let directory = self
+            .manager
+            .store_dir()
+            .parent()
+            .ok_or(ApplyError::PreparationFailed)?
+            .to_path_buf();
+        let dialer = self.dialer.clone();
+        let limits = self.limits;
+        let geo = self.geo.clone();
+        let security = self.security.clone();
+        let blocking_cancel = cancel.clone();
+        // The provider worker owns and awaits every started blocking task. No
+        // response/adapter cancellation can detach parsing or graph preparation.
+        let prepared = tokio::task::spawn_blocking(move || {
+            if blocking_cancel.is_cancelled() {
+                return Err(ApplyError::Stopped);
+            }
+            let patch = matches!(&update, ConfigUpdate::Patch(_));
+            let mut template = match update {
+                ConfigUpdate::Replace(yaml) => {
+                    crate::config::providers::ProviderTemplate::update_yaml(
+                        yaml.as_bytes(),
+                        &directory,
+                    )
+                    .map(|mut next| {
+                        Arc::make_mut(&mut next).http_policy = previous.config.http_policy();
+                        next
+                    })
+                }
+                ConfigUpdate::ReplaceTemplate(mut next) => {
+                    Arc::make_mut(&mut next).http_policy = previous.config.http_policy();
+                    Ok(next)
+                }
+                ConfigUpdate::ReplaceWithHttp {
+                    yaml,
+                    http,
+                    base_dir,
+                } => {
+                    let candidate = crate::http_processing::Policy::compile_optional(Some(&http))
+                        .map_err(|_| ApplyError::InvalidConfig)?;
+                    let same = match (&previous.config.http_policy(), &candidate) {
+                        (None, None) => true,
+                        (Some(active), Some(candidate)) => {
+                            active.document().identity() == candidate.document().identity()
+                        }
+                        _ => false,
+                    };
+                    if !same {
+                        return Err(ApplyError::RestartRequired);
+                    }
+                    if let Some(base_dir) = base_dir {
+                        let source = crate::http_processing::providers::SourceContext {
+                            base_dir,
+                            data_dir: Some(directory.clone()),
+                            config_path: None,
+                            ..Default::default()
+                        };
+                        if previous
+                            .config
+                            .http_policy()
+                            .as_ref()
+                            .and_then(|policy| policy.candidate())
+                            .and_then(|candidate| candidate.source_identity())
+                            != Some(source.identity())
+                        {
+                            return Err(ApplyError::RestartRequired);
+                        }
+                    }
+                    crate::config::providers::ProviderTemplate::update_yaml(
+                        yaml.as_bytes(),
+                        &directory,
+                    )
+                    .map(|mut next| {
+                        Arc::make_mut(&mut next).http_policy = previous.config.http_policy();
+                        next
+                    })
+                }
+                ConfigUpdate::Patch(patch) => previous
+                    .config
+                    .providers
+                    .as_ref()
+                    .ok_or(ApplyError::PreparationFailed)?
+                    .patched(&patch),
+                ConfigUpdate::RefreshGeoData
+                | ConfigUpdate::RefreshHttp { .. }
+                | ConfigUpdate::FlushFakeIp
+                | ConfigUpdate::RecoverySnapshot(_) => {
+                    unreachable!("maintenance handled before candidate construction")
+                }
+            }
+            .map_err(|_| ApplyError::InvalidConfig)?;
+            if let Some(previous_template) = &previous.config.providers {
+                Arc::make_mut(&mut template).resource_paths =
+                    previous_template.resource_paths.clone();
+            }
+            let cache = ProviderCache::open_candidate(&directory, template, &blocking_cancel)
+                .map_err(|_| {
+                    if blocking_cancel.is_cancelled() {
+                        ApplyError::Stopped
+                    } else {
+                        ApplyError::PreparationFailed
+                    }
+                })?;
+            let mut config = cache
+                .template
+                .materialize_with_cancel(&cache.contents, Some(&blocking_cancel))
+                .map_err(|_| {
+                    if blocking_cancel.is_cancelled() {
+                        ApplyError::Stopped
+                    } else {
+                        ApplyError::InvalidConfig
+                    }
+                })?;
+            if !crate::config::live_update::startup_compatible(&previous.config, &config) {
+                return Err(ApplyError::RestartRequired);
+            }
+            if patch {
+                config.dns.hosts = previous.config.dns.hosts.clone();
+            } else {
+                crate::dns::hosts::materialize_lan(&mut config.dns.hosts)
+                    .map_err(|_| ApplyError::PreparationFailed)?;
+            }
+            let requirements =
+                GeoRequirements::for_config(&config).map_err(|_| ApplyError::InvalidConfig)?;
+            let rules =
+                RuleSet::compile_config(&mut config).map_err(|_| ApplyError::InvalidConfig)?;
+            if blocking_cancel.is_cancelled() {
+                return Err(ApplyError::Stopped);
+            }
+            let parts = GraphBuilder {
+                security,
+                connections: previous.connections.clone(),
+                config: config.clone(),
+                endpoints: vec![PreparedProxyEndpoints::default(); config.proxies.len()],
+                limits,
+                rules,
+                geo_matcher: geo,
+                previous_dns: previous.dns.clone(),
+                data_dir: Some(directory),
+            }
+            .build(dialer)
+            .map_err(|_| ApplyError::PreparationFailed)?;
+            Ok((cache, config, parts, requirements))
+        })
+        .await
+        .map_err(|_| ApplyError::PreparationFailed)??;
+        let (cache, config, parts, requirements) = prepared;
+        let next = Arc::new(Generation::from_parts(config, &parts, requirements.clone()));
+        drop(parts);
+        // The validated graph is ready before confined cache directories are
+        // created. This joined task never writes a resource body or metadata.
+        let directory = self
+            .manager
+            .store_dir()
+            .parent()
+            .ok_or(ApplyError::PreparationFailed)?
+            .to_owned();
+        let paths_cancel = cancel.clone();
+        let prepared_cache = tokio::task::spawn_blocking(move || {
+            cache
+                .prepare_paths(&directory, &paths_cancel)
+                .map(|()| cache)
+        })
+        .await;
+        let cache = match prepared_cache {
+            Ok(Ok(cache)) => cache,
+            _ => {
+                next.graph.begin_shutdown();
+                next.graph.shutdown().await;
+                return Err(if cancel.is_cancelled() {
+                    ApplyError::Stopped
+                } else {
+                    ApplyError::PreparationFailed
+                });
+            }
+        };
+        if cancel.is_cancelled() {
+            next.graph.begin_shutdown();
+            next.graph.shutdown().await;
+            return Err(ApplyError::Stopped);
+        }
+        let combined = match self.combined_requirements(&requirements) {
+            Ok(value) => value,
+            Err(_) => {
+                next.graph.begin_shutdown();
+                next.graph.shutdown().await;
+                return Err(ApplyError::PreparationFailed);
+            }
+        };
+        let manager = self.manager.clone();
+        let lease = self.lease.clone();
+        let blocking_cancel = cancel.clone();
+        let registered = tokio::task::spawn_blocking(move || {
+            manager.replace_requirements(&lease, combined, &blocking_cancel)
+        })
+        .await;
+        if !matches!(registered, Ok(Ok(()))) {
+            next.graph.begin_shutdown();
+            next.graph.shutdown().await;
+            self.restore_requirements().await;
+            return Err(if cancel.is_cancelled() {
+                ApplyError::Stopped
+            } else {
+                ApplyError::PreparationFailed
+            });
+        }
+        // Acquire asynchronous locks before the short publication mutex. New
+        // cache admissions and old results cannot cross this shared DNS epoch.
+        let mut active_cache = self.cache.lock().await;
+        let dns_boundary = match next.dns.as_ref().or(current.dns.as_ref()) {
+            Some(dns) => Some(dns.configuration_publication().await),
+            None => None,
+        };
+        // Config updates and provider refreshes use the same serial worker.
+        let result = {
+            let _publication = self.publication.lock().unwrap();
+            if cancel.is_cancelled() || self.cancellation.is_cancelled() {
+                Err(ApplyError::Stopped)
+            } else {
+                for (index, state) in current.groups.list_states().into_iter().enumerate() {
+                    let forced = current.groups.selection(index).forced().is_some();
+                    let _ = next
+                        .groups
+                        .inherit_selection(&state.name, &state.now, forced);
+                }
+                if let Some(dns) = &current.dns {
+                    dns.retire_configuration_hints();
+                }
+                for generation in self.retired.lock().unwrap().iter() {
+                    if let Some(dns) = &generation.dns {
+                        dns.retire_configuration_hints();
+                    }
+                }
+                let old = self.current.swap(next.clone());
+                *active_cache = cache;
+                self.record_states(&active_cache);
+                self.retired.lock().unwrap().push(old);
+                if let Some(logs) = &self.logs {
+                    logs.set_level(next.config.log_level);
+                }
+                Ok(())
+            }
+        };
+        drop(dns_boundary);
+        drop(active_cache);
+        if result.is_err() {
+            next.graph.begin_shutdown();
+            next.graph.shutdown().await;
+            self.restore_requirements().await;
+        }
+        result
+    }
+    async fn restore_requirements(&self) {
+        let current = self.current.load_full();
+        let Ok(requirements) = self.combined_requirements(&current.requirements) else {
+            return;
+        };
+        let manager = self.manager.clone();
+        let lease = self.lease.clone();
+        // Restoration is a local registration operation. It must complete even
+        // after Stop/caller cancellation to keep the still-live lease valid.
+        let cancel = CancellationToken::new();
+        let _ = tokio::task::spawn_blocking(move || {
+            manager.replace_requirements(&lease, requirements, &cancel)
+        })
+        .await;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{dialer::SystemResolver, resource::config_apply::ConfigPatch};
+
+    #[tokio::test]
+    async fn recovery_snapshot_keeps_current_group_member_without_selection_persistence() {
+        let root = tempfile::tempdir().unwrap();
+        let config = Config::parse_yaml(b"profile: {store-selected: false}\nproxy-groups: [{name: chosen, type: select, proxies: [DIRECT, REJECT]}, {name: balanced, type: load-balance, proxies: [DIRECT, REJECT]}]\nrules: ['MATCH,chosen']\n").unwrap();
+        let manager =
+            GeoDataManager::open(&root.path().join("geodata"), Duration::from_secs(86400)).unwrap();
+        let prepared = PreparedCore::prepare_config(
+            config,
+            manager,
+            &SystemResolver,
+            ResourceLimits::default(),
+        )
+        .await
+        .unwrap();
+        let parts = prepared.build_dispatcher(Dialer::default()).unwrap();
+        let live = parts.resources.clone().unwrap();
+        live.select("chosen", "REJECT").unwrap();
+        let (send, receive) = std::sync::mpsc::sync_channel(1);
+        live.apply_update(
+            ConfigUpdate::RecoverySnapshot(send),
+            CancellationToken::new(),
+        )
+        .await
+        .unwrap();
+        let snapshot = receive.recv().unwrap();
+        assert!(!snapshot.config.profile.store_selected);
+        let group = &snapshot.config.proxy_groups[0];
+        assert_eq!(group.members[group.initial_member].name, "REJECT");
+        assert_eq!(live.current.load().config.proxy_groups[0].initial_member, 0);
+        live.shutdown().await;
+    }
+
+    #[tokio::test]
+    async fn config_candidates_preserve_old_generation_and_latest_provider_template() {
+        let root = tempfile::tempdir().unwrap();
+        let file = root.path().join("nodes.yaml");
+        std::fs::write(&file, b"proxies: [{name: old, type: direct}]\n").unwrap();
+        let yaml = |extra: &str| {
+            format!(
+                "{extra}\nproxy-providers: {{remote: {{type: file, path: nodes.yaml}}}}\nproxy-groups: [{{name: chosen, type: select, use: [remote]}}]\nrules: ['MATCH,chosen']\n"
+            )
+        };
+        let manager =
+            GeoDataManager::open(&root.path().join("geodata"), Duration::from_secs(86400)).unwrap();
+        let prepared = PreparedCore::prepare_config(
+            Config::parse_yaml(yaml("").as_bytes()).unwrap(),
+            manager,
+            &SystemResolver,
+            ResourceLimits::default(),
+        )
+        .await
+        .unwrap();
+        let parts = prepared.build_dispatcher(Dialer::default()).unwrap();
+        let live = parts.resources.clone().unwrap();
+        let old = live.current.load_full();
+        assert!(matches!(
+            live.apply_update(
+                ConfigUpdate::Replace("rules: ['MATCH,missing']\n".into()),
+                CancellationToken::new()
+            )
+            .await,
+            Err(ApplyError::InvalidConfig)
+        ));
+        assert!(Arc::ptr_eq(&old, &live.current.load_full()));
+        let resource_change = yaml("mixed-port: 1080");
+        assert_eq!(
+            live.apply_update(
+                ConfigUpdate::Replace(resource_change),
+                CancellationToken::new()
+            )
+            .await,
+            Err(ApplyError::RestartRequired)
+        );
+        assert!(Arc::ptr_eq(&old, &live.current.load_full()));
+        live.apply_update(
+            ConfigUpdate::Patch(ConfigPatch {
+                tcp_concurrent: Some(true),
+                ..Default::default()
+            }),
+            CancellationToken::new(),
+        )
+        .await
+        .unwrap();
+        assert!(live.current.load().config.connections.tcp_concurrent);
+        assert!(!old.config.connections.tcp_concurrent);
+        assert!(Arc::ptr_eq(
+            &old.connections,
+            &live.current.load().connections
+        ));
+        let next = yaml("mode: direct\nlog-level: warning\ntcp-concurrent: true");
+        live.apply_update(ConfigUpdate::Replace(next), CancellationToken::new())
+            .await
+            .unwrap();
+        std::fs::write(&file, b"proxies: [{name: fresh, type: direct}]\n").unwrap();
+        live.update(0).await.unwrap();
+        assert_eq!(live.current.load().config.mode, crate::config::Mode::Direct);
+        assert!(live.current.load().config.connections.tcp_concurrent);
+        assert_eq!(live.groups().state("chosen").unwrap().now, "fresh");
+        let cancelled = CancellationToken::new();
+        cancelled.cancel();
+        assert_eq!(
+            live.apply_update(
+                ConfigUpdate::Patch(ConfigPatch {
+                    mode: Some("rule".into()),
+                    ..Default::default()
+                }),
+                cancelled
+            )
+            .await,
+            Err(ApplyError::Stopped)
+        );
+        assert_eq!(live.current.load().config.mode, crate::config::Mode::Direct);
+        live.shutdown().await;
+    }
+}
+
+#[cfg(all(test, feature = "inbound-http"))]
+mod http_tests {
+    use super::*;
+    use crate::dialer::SystemResolver;
+    #[tokio::test]
+    async fn http_download_resolves_domain_with_direct_dns_and_pins_its_generation() {
+        let root = tempfile::tempdir().unwrap();
+        let yaml = "ipv6: false\ndns: {enable: true, use-system-hosts: false, nameserver: [rcode://success], direct-nameserver: [rcode://refused]}\nrules: ['MATCH,DIRECT']\n";
+        let config = Config::parse_yaml(yaml.as_bytes()).unwrap();
+        let manager =
+            GeoDataManager::open(&root.path().join("geodata"), Duration::from_secs(86400)).unwrap();
+        let prepared = PreparedCore::prepare_config(
+            config,
+            manager,
+            &SystemResolver,
+            ResourceLimits::default(),
+        )
+        .await
+        .unwrap();
+        let parts = prepared.build_dispatcher(Dialer::default()).unwrap();
+        let live = parts.resources.clone().unwrap();
+        let old = Arc::downgrade(&live.current.load_full());
+        let network = live.http_download_context();
+        // The synthetic REFUSED resolver never opens a socket. A bare IP-only
+        // DIRECT dispatcher rejects this domain without reaching the DNS role.
+        let (result, trace) = crate::dns::trace::capture(network.dispatcher.connect_tcp(
+            crate::session::StreamSession {
+                metadata: Default::default(),
+                inbound: crate::session::InboundKind::InternalGeoData,
+                source: SocketAddr::from(([0, 0, 0, 0], 0)),
+                destination: Destination::domain("rules.example.test", 443).unwrap(),
+                sniffed_domain: None,
+            },
+        ))
+        .await;
+        assert!(result.is_err());
+        assert!(trace.contains(&"direct-role"));
+        live.apply_update(ConfigUpdate::Replace(yaml.into()), CancellationToken::new())
+            .await
+            .unwrap();
+        live.reap().await;
+        assert!(old.upgrade().is_some());
+        drop(network);
+        live.reap().await;
+        assert!(old.upgrade().is_none());
+        live.shutdown().await;
+    }
+
+    #[tokio::test]
+    async fn routing_updates_keep_active_http_and_changed_http_requires_reconnect() {
+        let root = tempfile::tempdir().unwrap();
+        let path = root.path().join("nodes.yaml");
+        std::fs::write(&path, "proxies: [{name: first, type: direct}]").unwrap();
+        let yaml = "proxy-providers: {fixture: {type: file, path: nodes.yaml}}\nproxy-groups: [{name: chosen, type: select, use: [fixture]}]\nrules: ['MATCH,chosen']\n";
+        let mut config = Config::parse_yaml(yaml.as_bytes()).unwrap();
+        config
+            .set_http_config(Some(
+                "rewrite: {enabled: true, rules: [{url: '.', action: reject}]}",
+            ))
+            .unwrap();
+        let policy = config.http_policy().unwrap();
+        let manager =
+            GeoDataManager::open(&root.path().join("geodata"), Duration::from_secs(86400)).unwrap();
+        let prepared = PreparedCore::prepare_config(
+            config,
+            manager,
+            &SystemResolver,
+            ResourceLimits::default(),
+        )
+        .await
+        .unwrap();
+        let parts = prepared.build_dispatcher(Dialer::default()).unwrap();
+        let live = parts.resources.clone().unwrap();
+        let pinned = live.http_context().unwrap();
+        live.apply_update(ConfigUpdate::Replace(yaml.into()), CancellationToken::new())
+            .await
+            .unwrap();
+        assert!(Arc::ptr_eq(
+            &policy,
+            &live.current.load().config.http_policy().unwrap()
+        ));
+        let provider_paths = live
+            .current
+            .load()
+            .config
+            .providers
+            .as_ref()
+            .unwrap()
+            .resource_paths
+            .clone();
+        // The foreground input form takes the same worker and active HTTP snapshot.
+        let template =
+            crate::config::providers::ProviderTemplate::update_yaml(yaml.as_bytes(), root.path())
+                .unwrap();
+        live.apply_update(
+            ConfigUpdate::ReplaceTemplate(template),
+            CancellationToken::new(),
+        )
+        .await
+        .unwrap();
+        assert!(Arc::ptr_eq(
+            &policy,
+            &live.current.load().config.http_policy().unwrap()
+        ));
+        assert!(Arc::ptr_eq(
+            &provider_paths,
+            &live
+                .current
+                .load()
+                .config
+                .providers
+                .as_ref()
+                .unwrap()
+                .resource_paths
+        ));
+        let invalid = crate::config::providers::ProviderTemplate::update_yaml(
+            b"rules: ['MATCH,missing']",
+            root.path(),
+        )
+        .unwrap();
+        assert!(matches!(
+            live.apply_update(
+                ConfigUpdate::ReplaceTemplate(invalid),
+                CancellationToken::new()
+            )
+            .await,
+            Err(ApplyError::InvalidConfig)
+        ));
+        let reconnect = format!("external-controller: 127.0.0.1:9999\n{yaml}");
+        let reconnect = crate::config::providers::ProviderTemplate::update_yaml(
+            reconnect.as_bytes(),
+            root.path(),
+        )
+        .unwrap();
+        assert!(matches!(
+            live.apply_update(
+                ConfigUpdate::ReplaceTemplate(reconnect),
+                CancellationToken::new()
+            )
+            .await,
+            Err(ApplyError::RestartRequired)
+        ));
+        assert!(Arc::ptr_eq(
+            &policy,
+            &live.current.load().config.http_policy().unwrap()
+        ));
+        std::fs::write(&path, "proxies: [{name: fresh, type: direct}]").unwrap();
+        live.update(0).await.unwrap();
+        assert!(Arc::ptr_eq(
+            &policy,
+            &live.current.load().config.http_policy().unwrap()
+        ));
+        assert!(
+            live.apply_update(
+                ConfigUpdate::ReplaceWithHttp {
+                    yaml: yaml.into(),
+                    http: "private-bad: private-value".into(),
+                    base_dir: None
+                },
+                CancellationToken::new()
+            )
+            .await
+            .is_err()
+        );
+        assert!(Arc::ptr_eq(
+            &policy,
+            &live.current.load().config.http_policy().unwrap()
+        ));
+        let result = live
+            .apply_update(
+                ConfigUpdate::ReplaceWithHttp {
+                    yaml: yaml.into(),
+                    http: String::new(),
+                    base_dir: None,
+                },
+                CancellationToken::new(),
+            )
+            .await;
+        assert!(matches!(result, Err(ApplyError::RestartRequired)));
+        assert!(Arc::ptr_eq(
+            &policy,
+            &live.current.load().config.http_policy().unwrap()
+        ));
+        assert!(pinned.candidate_port(80));
+        drop(pinned);
+        live.shutdown().await;
+    }
+}
diff --git a/src/runtime_group_tests.rs b/src/runtime_group_tests.rs
index ac66b13..14e864d 100644
--- a/src/runtime_group_tests.rs
+++ b/src/runtime_group_tests.rs
@@ -48,116 +48,37 @@ rules: ['MATCH,child']
 }
 
 #[tokio::test]
-async fn prepare_includes_unselected_direct_candidates_and_excludes_proxy_only_hosts() {
-    for (members, expected) in [
-        ("root, DIRECT", vec!["child.invalid", "root.invalid"]),
-        ("root, REJECT", vec!["root.invalid"]),
-    ] {
-        let resolver = RecordingResolver::default();
-        let prepared = PreparedCore::prepare(
-            grouped_config(members).as_bytes(),
-            &resolver,
-            ResourceLimits::default(),
-        )
-        .await
-        .unwrap();
-        let mut actual = resolver
-            .hosts
-            .lock()
-            .unwrap()
-            .iter()
-            .map(|(host, _)| host.clone())
-            .collect::<Vec<_>>();
-        actual.sort();
-        assert_eq!(actual, expected);
-        for endpoints in &prepared.endpoints {
-            if let Some(endpoint) = &endpoints.upload {
-                assert!(endpoint.addresses.iter().all(SocketAddr::is_ipv4));
-            }
-        }
-        assert_eq!(
-            prepared.endpoints[0].upload.is_some(),
-            members.contains("DIRECT")
-        );
-    }
-}
-
-#[tokio::test]
-async fn candidate_dns_failure_rolls_back_geodata_registration_and_loopback_domains_fail_closed() {
+async fn group_preparation_is_lazy_and_releases_registration_on_drop() {
     let directory = tempfile::tempdir().unwrap();
     let manager = GeoDataManager::open(directory.path(), Duration::from_secs(86400)).unwrap();
     let resolver = RecordingResolver {
         fail_host: Some("child.invalid"),
         ..Default::default()
     };
-    let config = Config::parse_yaml(grouped_config("root, DIRECT").as_bytes()).unwrap();
-    let error = PreparedCore::prepare_config(
-        config,
-        manager.clone(),
-        &resolver,
-        ResourceLimits::default(),
-    )
-    .await
-    .unwrap_err();
-    assert_eq!(error.kind(), io::ErrorKind::NotFound);
-    // The failed prepare must release its exclusive GeoData registration.
-    let config = Config::parse_yaml(grouped_config("root, REJECT").as_bytes()).unwrap();
-    drop(
-        PreparedCore::prepare_config(config, manager, &resolver, ResourceLimits::default())
-            .await
-            .unwrap(),
-    );
-
-    let yaml = grouped_config("root, DIRECT")
-        .replace("child.invalid", "localhost")
-        .replace("root.invalid", "127.0.0.1");
-    let error = PreparedCore::prepare(yaml.as_bytes(), &SystemResolver, ResourceLimits::default())
-        .await
-        .unwrap_err();
-    assert_eq!(error.kind(), io::ErrorKind::PermissionDenied);
-}
-
-#[tokio::test]
-async fn cancelling_group_prepare_releases_its_geodata_registration() {
-    struct PendingResolver(AtomicUsize);
-    #[async_trait]
-    impl Resolver for PendingResolver {
-        async fn resolve(&self, _host: &str, _port: u16) -> io::Result<ResolvedEndpoint> {
-            self.0.fetch_add(1, Ordering::Relaxed);
-            std::future::pending().await
-        }
-    }
-    let directory = tempfile::tempdir().unwrap();
-    let manager = GeoDataManager::open(directory.path(), Duration::from_secs(86400)).unwrap();
-    let resolver = PendingResolver(AtomicUsize::new(0));
-    let yaml = grouped_config("root, DIRECT");
-    let config = Config::parse_yaml(yaml.as_bytes()).unwrap();
-    let mut preparing = Box::pin(PreparedCore::prepare_config(
-        config,
-        manager.clone(),
-        &resolver,
-        ResourceLimits::default(),
-    ));
-    assert!(futures_util::poll!(&mut preparing).is_pending());
-    assert!(resolver.0.load(Ordering::Relaxed) > 0);
-    drop(preparing);
-    // Cancellation during candidate DNS must not retain the exclusive registration.
-    let config = Config::parse_yaml(yaml.as_bytes()).unwrap();
-    drop(
-        PreparedCore::prepare_config(
+    for members in ["root, DIRECT", "root, REJECT"] {
+        let config = Config::parse_yaml(grouped_config(members).as_bytes()).unwrap();
+        let prepared = PreparedCore::prepare_config(
             config,
-            manager,
-            &RecordingResolver::default(),
+            manager.clone(),
+            &resolver,
             ResourceLimits::default(),
         )
         .await
-        .unwrap(),
-    );
+        .unwrap();
+        assert!(resolver.hosts.lock().unwrap().is_empty());
+        assert!(
+            prepared
+                .endpoints
+                .iter()
+                .all(|entry| entry.upload.is_none())
+        );
+        drop(prepared);
+    }
 }
 
 #[cfg(all(feature = "outbound-vless", feature = "outbound-socks5"))]
 #[tokio::test]
-async fn possible_direct_vless_prepares_both_independent_legs() {
+async fn possible_direct_vless_defers_both_independent_legs() {
     let yaml = grouped_config("root, DIRECT").replace(
         "{name: child, type: socks5, server: child.invalid, port: 1080, udp: true, dialer-proxy: outer}",
         r#"name: child
@@ -184,16 +105,9 @@ async fn possible_direct_vless_prepares_both_independent_legs() {
             .await
             .unwrap();
         let child = ProxyId::new(0).unwrap();
-        assert_eq!(prepared.endpoint(child).is_some(), direct);
-        assert_eq!(prepared.download_endpoint(child).is_some(), direct);
-        if direct {
-            let download = prepared.download_endpoint(child).unwrap();
-            assert_eq!(download.logical_host, "download.invalid");
-            assert_eq!(download.port, 8443);
-            assert_eq!(resolver.hosts.lock().unwrap().len(), 3);
-        } else {
-            assert_eq!(resolver.hosts.lock().unwrap().len(), 1);
-        }
+        assert!(prepared.endpoint(child).is_none());
+        assert!(prepared.download_endpoint(child).is_none());
+        assert!(resolver.hosts.lock().unwrap().is_empty());
         let graph = prepared.build_proxy_graph(Dialer::default()).unwrap();
         assert_eq!(graph.len(), 2);
     }
@@ -500,6 +414,7 @@ mod wire {
 
     fn session(host: &str) -> StreamSession {
         StreamSession {
+            metadata: Default::default(),
             inbound: InboundKind::Http,
             source: "127.0.0.1:18081".parse().unwrap(),
             destination: Destination::domain(host, 443).unwrap(),
diff --git a/src/runtime_lifecycle_tests.rs b/src/runtime_lifecycle_tests.rs
index eb41d63..406f881 100644
--- a/src/runtime_lifecycle_tests.rs
+++ b/src/runtime_lifecycle_tests.rs
@@ -106,6 +106,7 @@ rules: ['MATCH,path']
                 geodata_updater,
                 prepared.geodata_registration,
                 proxy_graph,
+                None,
             )
             .await
             .unwrap();
diff --git a/src/security/boring.rs b/src/security/boring.rs
index 7af3028..6e492be 100644
--- a/src/security/boring.rs
+++ b/src/security/boring.rs
@@ -1,15 +1,11 @@
 //! Named TLS profiles over caller-supplied IO. Certificate policy is shared with
 //! rustls, not a second OpenSSL trust policy. This module never resolves or dials.
 use super::boring_stream::{BoringStream, KeepOpen};
-use super::{SecurityContext, TlsClientOptions, TlsVersions};
+use super::{SecurityContext, TlsClientIdentity, TlsClientOptions, TlsVersions};
 use crate::dispatch::BoxStream;
-use boring::{
-    pkey::PKey,
-    ssl::{
-        ClientFingerprint, ConnectConfiguration, FingerprintConnector, SslAlert, SslConnector,
-        SslMethod, SslVerifyError, SslVerifyMode, SslVersion,
-    },
-    x509::X509,
+use boring::ssl::{
+    ClientFingerprint, ConnectConfiguration, FingerprintConnector, SslAlert, SslConnector,
+    SslMethod, SslVerifyError, SslVerifyMode, SslVersion,
 };
 use rustls::{
     client::danger::ServerCertVerifier,
@@ -25,14 +21,15 @@ pub(super) struct BoringTlsClient {
     alpn: Vec<u8>,
     required_alpn: Option<Vec<u8>>,
     sessions: super::boring_resumption::Sessions,
+    identity: Option<TlsClientIdentity>,
     ech: Option<crate::config::StaticEchConfig>,
-    #[cfg(feature = "outbound-vless")]
+    #[cfg(feature = "stream-security")]
     reality: Option<boring::ssl::RealityClientConfig>,
-    #[cfg(feature = "outbound-vless")]
+    #[cfg(feature = "stream-security")]
     jls: Option<Arc<JlsCredentials>>,
 }
 
-#[cfg(feature = "outbound-vless")]
+#[cfg(feature = "stream-security")]
 struct JlsCredentials {
     username: zeroize::Zeroizing<Vec<u8>>,
     password: zeroize::Zeroizing<Vec<u8>>,
@@ -51,7 +48,7 @@ impl Connector {
                 config.set_alpn_protos(alpn)?;
                 Ok(config)
             }
-            Self::Named(connector) => connector.configure(alpn),
+            Self::Named(connector) => connector.configure_with_application_settings(alpn, false),
         }
     }
 }
@@ -63,6 +60,21 @@ impl BoringTlsClient {
         options: &TlsClientOptions,
         capacity: usize,
     ) -> io::Result<Self> {
+        let identity = options
+            .identity
+            .as_ref()
+            .map(TlsClientIdentity::for_native)
+            .transpose()?;
+        if let Some(identity) = &identity {
+            identity.native_snapshot()?.material.validate()?;
+        }
+        if (options.ech.is_some() || options.versions == TlsVersions::Tls13)
+            && options
+                .client_fingerprint
+                .is_some_and(|profile| !profile.supports_tls13())
+        {
+            return Err(invalid());
+        }
         let name = ServerName::try_from(server_name.to_owned()).map_err(|_| invalid())?;
         let verifier = Arc::new(super::verifier::CertificateVerifier::new(
             context,
@@ -120,29 +132,6 @@ impl BoringTlsClient {
                 .map(|_| ())
                 .map_err(|_| reject())
         });
-        if let Some(identity) = &options.identity {
-            let size = identity
-                .certificates
-                .iter()
-                .try_fold(identity.key.secret_der().len(), |size, cert| {
-                    size.checked_add(cert.len())
-                });
-            if size.is_none_or(|n| n > crate::config::MAX_CONFIG_BYTES) {
-                return Err(invalid());
-            }
-            let (leaf, rest) = identity.certificates.split_first().ok_or_else(invalid)?;
-            let leaf = X509::from_der(leaf).map_err(|_| invalid())?;
-            builder.set_certificate(&leaf).map_err(|_| invalid())?;
-            for cert in rest {
-                builder
-                    .add_extra_chain_cert(X509::from_der(cert).map_err(|_| invalid())?)
-                    .map_err(|_| invalid())?;
-            }
-            let key =
-                PKey::private_key_from_der(identity.key.secret_der()).map_err(|_| invalid())?;
-            builder.set_private_key(&key).map_err(|_| invalid())?;
-            builder.check_private_key().map_err(|_| invalid())?;
-        }
         let connector = match options.client_fingerprint {
             Some(value) => Connector::Named(
                 FingerprintConnector::new(builder, profile(value)).map_err(|_| invalid())?,
@@ -156,15 +145,16 @@ impl BoringTlsClient {
             alpn,
             required_alpn: options.required_alpn.clone(),
             sessions,
+            identity,
             ech: options.ech.clone(),
-            #[cfg(feature = "outbound-vless")]
+            #[cfg(feature = "stream-security")]
             reality: None,
-            #[cfg(feature = "outbound-vless")]
+            #[cfg(feature = "stream-security")]
             jls: None,
         })
     }
 
-    #[cfg(feature = "outbound-vless")]
+    #[cfg(feature = "stream-security")]
     pub(super) fn reality(config: &crate::config::RealityConfig) -> io::Result<Self> {
         config.validate_fingerprint().map_err(|_| invalid())?;
         ServerName::try_from(config.server_name.to_owned()).map_err(|_| invalid())?;
@@ -184,7 +174,7 @@ impl BoringTlsClient {
             .map_err(|_| invalid())?;
         builder
             .set_curves_list(if config.support_x25519mlkem768 {
-                "X25519MLKEM768"
+                "X25519MLKEM768:X25519"
             } else {
                 "X25519"
             })
@@ -203,7 +193,7 @@ impl BoringTlsClient {
         )
         .map_err(|_| invalid())?;
         let reality = if config.support_x25519mlkem768 {
-            reality.require_x25519mlkem768()
+            reality.allow_x25519mlkem768()
         } else {
             reality
         };
@@ -215,13 +205,14 @@ impl BoringTlsClient {
             // configured HTTP version; no ordinary PKI fallback is permitted.
             required_alpn: None,
             sessions,
+            identity: None,
             ech: None,
             reality: Some(reality),
             jls: None,
         })
     }
 
-    #[cfg(feature = "outbound-vless")]
+    #[cfg(feature = "stream-security")]
     pub(super) fn jls(config: &crate::config::JlsConfig) -> io::Result<Self> {
         config.validate().map_err(|_| invalid())?;
         ServerName::try_from(config.tls.server_name.to_owned()).map_err(|_| invalid())?;
@@ -247,6 +238,7 @@ impl BoringTlsClient {
             alpn: wire_alpn(&config.tls.alpn)?,
             required_alpn: config.tls.required_alpn.clone(),
             sessions,
+            identity: None,
             ech: None,
             reality: None,
             jls: Some(Arc::new(JlsCredentials {
@@ -261,10 +253,31 @@ impl BoringTlsClient {
         stream: BoxStream,
         buffer_limit: usize,
     ) -> io::Result<BoxStream> {
-        Ok(Box::new(BoringStream::new(
-            self.handshake(stream).await?,
-            buffer_limit,
-        )))
+        self.connect_negotiated(stream, buffer_limit)
+            .await
+            .map(|(stream, _)| stream)
+    }
+
+    pub(super) async fn connect_negotiated(
+        &self,
+        stream: BoxStream,
+        buffer_limit: usize,
+    ) -> io::Result<(BoxStream, Option<Vec<u8>>)> {
+        self.connect_negotiated_with_policy(stream, buffer_limit, false)
+            .await
+    }
+
+    pub(super) async fn connect_negotiated_with_policy(
+        &self,
+        stream: BoxStream,
+        buffer_limit: usize,
+        allow_missing_alpn: bool,
+    ) -> io::Result<(BoxStream, Option<Vec<u8>>)> {
+        let tls = self
+            .handshake_configured_with_policy(stream, |_| Ok(()), allow_missing_alpn)
+            .await?;
+        let alpn = tls.ssl().selected_alpn_protocol().map(<[u8]>::to_vec);
+        Ok((Box::new(BoringStream::new(tls, buffer_limit)), alpn))
     }
 
     #[cfg(feature = "outbound-vless")]
@@ -289,6 +302,16 @@ impl BoringTlsClient {
         &self,
         stream: S,
         configure: impl FnOnce(&mut ConnectConfiguration) -> io::Result<()>,
+    ) -> io::Result<tokio_boring::SslStream<KeepOpen<S>>> {
+        self.handshake_configured_with_policy(stream, configure, false)
+            .await
+    }
+
+    async fn handshake_configured_with_policy<S: AsyncRead + AsyncWrite + Unpin>(
+        &self,
+        stream: S,
+        configure: impl FnOnce(&mut ConnectConfiguration) -> io::Result<()>,
+        allow_missing_alpn: bool,
     ) -> io::Result<tokio_boring::SslStream<KeepOpen<S>>> {
         let mut config = self
             .connector
@@ -297,17 +320,45 @@ impl BoringTlsClient {
         // The shared WebPKI verifier owns name checking, including independent
         // verification names and pin precedence; wire SNI still uses server_name.
         config.set_verify_hostname(false);
-        let sink = self.sessions.configure(&mut config)?;
+        // Read one identity generation for this physical handshake. The SSL
+        // object owns its certificate/key references after installation; a
+        // later rotation cannot rewrite a handshake already in progress.
+        let identity = self
+            .identity
+            .as_ref()
+            .map(TlsClientIdentity::native_snapshot)
+            .transpose()?;
+        if let Some(identity) = &identity {
+            let material = &identity.material;
+            let size = material
+                .certificates
+                .iter()
+                .try_fold(material.key.secret_der().len(), |size, cert| {
+                    size.checked_add(cert.len())
+                });
+            if size.is_none_or(|n| n > crate::config::MAX_CONFIG_BYTES) {
+                return Err(invalid());
+            }
+            let native = identity.native.as_ref().ok_or_else(invalid)?;
+            let (leaf, rest) = native.certificates.split_first().ok_or_else(invalid)?;
+            config.set_certificate(leaf).map_err(|_| invalid())?;
+            for cert in rest {
+                config.add_chain_cert(cert).map_err(|_| invalid())?;
+            }
+            config.set_private_key(&native.key).map_err(|_| invalid())?;
+        }
+        let epoch = identity.map(|snapshot| snapshot.epoch).unwrap_or_default();
+        let sink = self.sessions.configure(&mut config, epoch)?;
         if let Some(ech) = &self.ech {
             config
                 .set_ech_config_list(ech.as_bytes())
                 .map_err(|_| invalid())?;
         }
-        #[cfg(feature = "outbound-vless")]
+        #[cfg(feature = "stream-security")]
         if let Some(reality) = &self.reality {
             config.set_reality_client(reality).map_err(|_| invalid())?;
         }
-        #[cfg(feature = "outbound-vless")]
+        #[cfg(feature = "stream-security")]
         if let Some(jls) = &self.jls {
             config
                 .set_jls_client(&jls.username, &jls.password)
@@ -320,16 +371,11 @@ impl BoringTlsClient {
         if self.ech.is_some() && !tls.ssl().ech_accepted() {
             return Err(io::Error::other("TLS ECH was not accepted"));
         }
-        if self
-            .required_alpn
-            .as_deref()
-            .is_some_and(|required| tls.ssl().selected_alpn_protocol() != Some(required))
-        {
-            return Err(io::Error::new(
-                io::ErrorKind::InvalidData,
-                "TLS server did not negotiate the required ALPN",
-            ));
-        }
+        super::tls::validate_alpn(
+            self.required_alpn.as_deref(),
+            tls.ssl().selected_alpn_protocol(),
+            allow_missing_alpn,
+        )?;
         // The HTTP drivers use on-wire SETTINGS and do not import ALPS into
         // their initial state. Never silently accept nonempty peer settings.
         if tls
@@ -349,10 +395,14 @@ impl BoringTlsClient {
 
 fn profile(value: crate::config::ClientFingerprint) -> ClientFingerprint {
     match value {
-        crate::config::ClientFingerprint::Chrome120 => ClientFingerprint::Chrome120,
         crate::config::ClientFingerprint::Chrome133 => ClientFingerprint::Chrome133,
         crate::config::ClientFingerprint::Firefox120 => ClientFingerprint::Firefox120,
         crate::config::ClientFingerprint::Safari16 => ClientFingerprint::Safari16,
+        crate::config::ClientFingerprint::Ios14 => ClientFingerprint::Ios14,
+        crate::config::ClientFingerprint::Android11 => ClientFingerprint::Android11,
+        crate::config::ClientFingerprint::Edge85 => ClientFingerprint::Edge85,
+        crate::config::ClientFingerprint::ThreeSixty75 => ClientFingerprint::ThreeSixty75,
+        crate::config::ClientFingerprint::Qq111 => ClientFingerprint::Qq111,
     }
 }
 
diff --git a/src/security/boring_resumption.rs b/src/security/boring_resumption.rs
index 096ba2c..1bff873 100644
--- a/src/security/boring_resumption.rs
+++ b/src/security/boring_resumption.rs
@@ -12,6 +12,8 @@ use std::{
     sync::{Arc, LazyLock, Mutex},
 };
 
+use super::identity::IdentityEpoch;
+
 type SessionIndex = Index<Ssl, Arc<SessionSink>>;
 // Only the slot number is global, never the tickets or a verification policy.
 static SESSION_INDEX: LazyLock<Result<SessionIndex, boring::error::ErrorStack>> =
@@ -19,11 +21,30 @@ static SESSION_INDEX: LazyLock<Result<SessionIndex, boring::error::ErrorStack>>
 
 #[derive(Clone)]
 pub(super) struct Sessions {
-    queue: Arc<Mutex<VecDeque<SslSession>>>,
+    queue: Arc<Mutex<Cache>>,
     capacity: usize,
     index: SessionIndex,
 }
 
+#[derive(Default)]
+struct Cache {
+    generation: u64,
+    tickets: VecDeque<SslSession>,
+}
+
+impl Cache {
+    fn select_epoch(&mut self, epoch: &IdentityEpoch) -> bool {
+        if !epoch.is_current() || epoch.generation() < self.generation {
+            return false;
+        }
+        if epoch.generation() != self.generation {
+            self.tickets.clear();
+            self.generation = epoch.generation();
+        }
+        true
+    }
+}
+
 impl Sessions {
     pub(super) fn new(builder: &mut SslConnectorBuilder, capacity: usize) -> io::Result<Self> {
         if capacity > super::TLS_RESUMPTION_SESSION_BUDGET {
@@ -55,9 +76,11 @@ impl Sessions {
     pub(super) fn configure(
         &self,
         config: &mut ConnectConfiguration,
+        epoch: IdentityEpoch,
     ) -> io::Result<Arc<SessionSink>> {
         let sink = Arc::new(SessionSink {
             cache: self.clone(),
+            epoch: epoch.clone(),
             state: Mutex::new(State {
                 accepted: false,
                 pending: VecDeque::new(),
@@ -66,8 +89,11 @@ impl Sessions {
         config.set_ex_data(self.index, sink.clone());
         let session = {
             let now = UnixTime::now().as_secs();
-            let mut queue = self.queue.lock().map_err(|_| cache_error())?;
-            queue.retain(|session| {
+            let mut cache = self.queue.lock().map_err(|_| cache_error())?;
+            if !cache.select_epoch(&epoch) {
+                return Ok(sink);
+            }
+            cache.tickets.retain(|session| {
                 let hint = session.ticket_lifetime_hint();
                 let lifetime = if hint == 0 {
                     session.timeout()
@@ -76,20 +102,21 @@ impl Sessions {
                 };
                 now < session.time().saturating_add(u64::from(lifetime))
             });
-            if queue
+            if cache
+                .tickets
                 .back()
                 .is_some_and(|s| s.protocol_version() == SslVersion::TLS1_2)
             {
                 // TLS 1.2 abbreviated handshakes need not issue another ticket.
-                queue.back().cloned()
+                cache.tickets.back().cloned()
             } else {
                 // A TLS 1.3 ticket is consumed once.
-                queue.pop_back()
+                cache.tickets.pop_back()
             }
         };
         if let Some(session) = session {
-            // SAFETY: Only this immutable client's SSL_CTX can populate its
-            // cache. A cloned client shares that exact context and policy.
+            // SAFETY: Only this client's SSL_CTX and the same current identity
+            // generation populate its node-owned cache. Clone shares policy.
             unsafe { config.set_session(&session) }.map_err(|_| cache_error())?;
         }
         Ok(sink)
@@ -103,6 +130,7 @@ struct State {
 
 pub(super) struct SessionSink {
     cache: Sessions,
+    epoch: IdentityEpoch,
     state: Mutex<State>,
 }
 
@@ -112,9 +140,15 @@ impl SessionSink {
         let Ok(mut state) = self.state.lock() else {
             return;
         };
+        if !self.epoch.is_current() {
+            state.pending.clear();
+            return;
+        }
         if state.accepted {
-            if let Ok(mut queue) = self.cache.queue.lock() {
-                bounded_push(&mut queue, session, self.cache.capacity);
+            if let Ok(mut cache) = self.cache.queue.lock()
+                && cache.select_epoch(&self.epoch)
+            {
+                bounded_push(&mut cache.tickets, session, self.cache.capacity);
             }
         } else {
             bounded_push(&mut state.pending, session, self.cache.capacity);
@@ -123,10 +157,14 @@ impl SessionSink {
 
     pub(super) fn accept(&self) -> io::Result<()> {
         let mut state = self.state.lock().map_err(|_| cache_error())?;
-        let mut queue = self.cache.queue.lock().map_err(|_| cache_error())?;
+        let mut cache = self.cache.queue.lock().map_err(|_| cache_error())?;
         state.accepted = true;
+        if !cache.select_epoch(&self.epoch) {
+            state.pending.clear();
+            return Ok(());
+        }
         for session in state.pending.drain(..) {
-            bounded_push(&mut queue, session, self.cache.capacity);
+            bounded_push(&mut cache.tickets, session, self.cache.capacity);
         }
         Ok(())
     }
diff --git a/src/security/client.rs b/src/security/client.rs
index 982dc5e..2e28d3c 100644
--- a/src/security/client.rs
+++ b/src/security/client.rs
@@ -1,13 +1,14 @@
-use std::{io, sync::Arc};
+use std::io;
+#[cfg(any(feature = "outbound-vless", feature = "quinn-h3-transport"))]
+use std::sync::Arc;
 
-use rustls::ClientConfig;
 #[cfg(feature = "interop-test")]
 use rustls::RootCertStore;
 
-use crate::{
-    config::{SecurityConfig, VlessOutboundConfig},
-    dispatch::BoxStream,
-};
+use crate::{config::SecurityConfig, dispatch::BoxStream};
+
+#[cfg(feature = "outbound-vless")]
+use crate::config::VlessOutboundConfig;
 
 use super::{
     SecurityContext,
@@ -26,6 +27,8 @@ pub const REALITY_CLIENT_VERSION: [u8; 3] = [26, 7, 11];
 #[derive(Clone)]
 enum SecurityBackend {
     Plain,
+    #[cfg(feature = "shadow-tls-v3")]
+    ShadowTls(super::ShadowTlsClient),
     Standard(StandardTlsClient),
     Reality {
         client: super::boring::BoringTlsClient,
@@ -46,6 +49,11 @@ impl std::fmt::Debug for SecurityClient {
     fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self.backend {
             SecurityBackend::Plain => formatter.write_str("SecurityClient::Plain"),
+            #[cfg(feature = "shadow-tls-v3")]
+            SecurityBackend::ShadowTls(client) => formatter
+                .debug_tuple("SecurityClient::ShadowTls")
+                .field(client)
+                .finish(),
             SecurityBackend::Standard(client) => formatter
                 .debug_tuple("SecurityClient::Standard")
                 .field(client)
@@ -63,13 +71,25 @@ impl std::fmt::Debug for SecurityClient {
 }
 
 impl SecurityClient {
-    pub(crate) fn quic_config(&self) -> io::Result<(Arc<ClientConfig>, String)> {
+    #[cfg(feature = "quinn-h3-transport")]
+    pub(crate) async fn quic_config_with_context(
+        &self,
+        context: &crate::outbound::EstablishContext,
+    ) -> io::Result<(Arc<rustls::ClientConfig>, String)> {
         match &self.backend {
-            SecurityBackend::Standard(client) => client.quic_config(),
-            _ => Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "HTTP/3 requires standard TLS",
-            )),
+            SecurityBackend::Standard(client) => client.quic_config_with_context(context).await,
+            _ => Err(io::Error::other("HTTP/3 requires standard TLS")),
+        }
+    }
+
+    pub(crate) async fn connect_with_context(
+        &self,
+        stream: BoxStream,
+        context: &crate::outbound::EstablishContext,
+    ) -> io::Result<BoxStream> {
+        match &self.backend {
+            SecurityBackend::Standard(client) => client.connect_with_context(stream, context).await,
+            _ => self.connect(stream).await,
         }
     }
 
@@ -86,6 +106,7 @@ impl SecurityClient {
     }
 
     /// Backwards-compatible primary-leg constructor.
+    #[cfg(feature = "outbound-vless")]
     pub fn from_proxy(config: &VlessOutboundConfig) -> io::Result<Self> {
         Self::from_security(&config.security)
     }
@@ -95,6 +116,7 @@ impl SecurityClient {
     /// nodes; zero disables resumption when the fixed four-session runtime
     /// budget cannot provide a slot for every node. REALITY and JLS ignore the
     /// budget because their resumption policies are disabled.
+    #[cfg(feature = "outbound-vless")]
     pub(crate) fn from_proxy_with_context(
         config: &VlessOutboundConfig,
         context: &SecurityContext,
@@ -127,7 +149,7 @@ impl SecurityClient {
     ///
     /// This entry point does not exist unless the `interop-test` feature is
     /// enabled. Production builds always use the bundled WebPKI roots.
-    #[cfg(feature = "interop-test")]
+    #[cfg(all(feature = "interop-test", feature = "outbound-vless"))]
     pub(crate) fn from_proxy_with_test_tls_roots(
         config: &VlessOutboundConfig,
         roots_der: impl IntoIterator<Item = Vec<u8>>,
@@ -180,6 +202,20 @@ impl SecurityClient {
         }
         let backend = match config {
             SecurityConfig::None => SecurityBackend::Plain,
+            SecurityConfig::ShadowTls(config) => {
+                #[cfg(feature = "shadow-tls-v3")]
+                {
+                    SecurityBackend::ShadowTls(super::ShadowTlsClient::new(context, config)?)
+                }
+                #[cfg(not(feature = "shadow-tls-v3"))]
+                {
+                    let _ = config;
+                    return Err(io::Error::new(
+                        io::ErrorKind::Unsupported,
+                        "ShadowTLS v3 is not compiled in",
+                    ));
+                }
+            }
             SecurityConfig::Tls(tls) => SecurityBackend::Standard(StandardTlsClient::with_options(
                 context,
                 &tls.server_name,
@@ -197,12 +233,7 @@ impl SecurityClient {
                     identity: tls
                         .identity
                         .as_ref()
-                        .map(|identity| {
-                            super::TlsClientIdentity::from_pem(
-                                &identity.certificate,
-                                &identity.private_key,
-                            )
-                        })
+                        .map(|identity| super::TlsClientIdentity::from_config(identity, context))
                         .transpose()?,
                 },
                 resumption_sessions,
@@ -224,6 +255,8 @@ impl SecurityClient {
     pub async fn connect(&self, stream: BoxStream) -> io::Result<BoxStream> {
         match &self.backend {
             SecurityBackend::Plain => Ok(stream),
+            #[cfg(feature = "shadow-tls-v3")]
+            SecurityBackend::ShadowTls(client) => client.connect(stream).await,
             SecurityBackend::Standard(client) => client.connect(stream).await,
             SecurityBackend::Reality {
                 client,
@@ -236,6 +269,7 @@ impl SecurityClient {
         }
     }
 
+    #[cfg(feature = "outbound-vless")]
     pub(crate) async fn connect_vision(
         &self,
         stream: BoxStream,
@@ -246,6 +280,11 @@ impl SecurityClient {
                 io::ErrorKind::InvalidInput,
                 "Vision requires TLS",
             )),
+            #[cfg(feature = "shadow-tls-v3")]
+            SecurityBackend::ShadowTls(_) => Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Vision cannot use ShadowTLS",
+            )),
             SecurityBackend::Jls { .. } => Err(io::Error::new(
                 io::ErrorKind::InvalidInput,
                 "Vision cannot use JLS",
@@ -258,10 +297,12 @@ impl SecurityClient {
         }
     }
 
-    #[cfg(test)]
+    #[cfg(all(test, feature = "outbound-vless"))]
     const fn buffer_limit(&self) -> usize {
         match &self.backend {
             SecurityBackend::Plain => 0,
+            #[cfg(feature = "shadow-tls-v3")]
+            SecurityBackend::ShadowTls(_) => 0,
             SecurityBackend::Standard(client) => client.buffer_limit(),
             SecurityBackend::Reality { buffer_limit, .. }
             | SecurityBackend::Jls { buffer_limit, .. } => *buffer_limit,
@@ -269,7 +310,7 @@ impl SecurityClient {
     }
 }
 
-#[cfg(test)]
+#[cfg(all(test, feature = "outbound-vless"))]
 mod tests {
     use super::*;
     use crate::config::{SecurityConfig, TlsConfig, VlessEncryption, XHttpConfig, XHttpMode};
diff --git a/src/security/client_identity_tests.rs b/src/security/client_identity_tests.rs
new file mode 100644
index 0000000..5beaa0d
--- /dev/null
+++ b/src/security/client_identity_tests.rs
@@ -0,0 +1,75 @@
+//! Shared identity dispatch and cancellation on memory IO, without any peer socket.
+use super::{SecurityClient, SecurityContext};
+#[cfg(feature = "shadow-tls-v3")]
+use crate::config::ShadowTlsConfig;
+use crate::config::{JlsConfig, RealityConfig, SecurityConfig, TlsConfig};
+use tokio::io::AsyncReadExt;
+
+#[tokio::test]
+async fn shared_identity_handshakes_cancel_without_retaining_io_or_reusing_hellos() {
+    let mut tls = TlsConfig::xhttp("cover.invalid".into());
+    tls.alpn.clear();
+    tls.required_alpn = None;
+    let identities = vec![
+        SecurityConfig::Jls(JlsConfig {
+            tls,
+            username: "synthetic-shared-user".into(),
+            password: "synthetic-shared-password".into(),
+        }),
+        SecurityConfig::Reality(RealityConfig {
+            client_fingerprint: None,
+            support_x25519mlkem768: false,
+            server_name: "cover.invalid".into(),
+            public_key: [7; 32],
+            short_id: vec![1, 2],
+            alpn: Vec::new(),
+        }),
+    ];
+    let identities = identities.into_iter();
+    #[cfg(feature = "shadow-tls-v3")]
+    let identities = identities.chain(std::iter::once(SecurityConfig::ShadowTls(
+        ShadowTlsConfig {
+            server_name: "cover.invalid".into(),
+            password: "synthetic-shared-cover-password".into(),
+            alpn: Vec::new(),
+            required_alpn: None,
+            certificate: Default::default(),
+            identity: None,
+            client_fingerprint: None,
+        },
+    )));
+    let context = SecurityContext::new();
+    tokio::time::timeout(std::time::Duration::from_secs(10), async {
+        for identity in identities {
+            let client =
+                SecurityClient::from_security_with_context(&identity, &context, 0, 8192).unwrap();
+            let mut previous = None;
+            for _ in 0..2 {
+                let (raw, mut peer) = tokio::io::duplex(73);
+                let client = client.clone();
+                let task = tokio::spawn(async move { client.connect(Box::new(raw)).await });
+                let mut header = [0; 5];
+                peer.read_exact(&mut header).await.unwrap();
+                assert_eq!(header[0], 22);
+                let length = usize::from(u16::from_be_bytes([header[3], header[4]]));
+                assert!((71..=16_384).contains(&length));
+                let mut hello = vec![0; length];
+                peer.read_exact(&mut hello).await.unwrap();
+                assert_eq!(hello[0], 1);
+                assert_eq!(hello[38], 32);
+                let session_id: [u8; 32] = hello[39..71].try_into().unwrap();
+                assert_ne!(previous.replace(session_id), Some(session_id));
+                if let SecurityConfig::ShadowTls(config) = &identity {
+                    hello[67..71].fill(0);
+                    let tag = boring::hash::hmac_sha1(config.password.as_bytes(), &hello).unwrap();
+                    assert_eq!(&session_id[28..], &tag[..4]);
+                }
+                task.abort();
+                assert!(task.await.is_err_and(|error| error.is_cancelled()));
+                assert_eq!(peer.read(&mut header).await.unwrap(), 0);
+            }
+        }
+    })
+    .await
+    .unwrap();
+}
diff --git a/src/security/context.rs b/src/security/context.rs
index 256d143..4426ae7 100644
--- a/src/security/context.rs
+++ b/src/security/context.rs
@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use rustls::RootCertStore;
 
-/// Immutable cryptographic material shared by every TLS client in one runtime.
+/// Shared immutable roots/provider and the runtime's client-identity publisher.
 ///
 /// Protocol-specific clients still own their small `ClientConfig`, while the
 /// crypto provider and WebPKI roots are constructed only once.
@@ -10,6 +10,7 @@ use rustls::RootCertStore;
 pub struct SecurityContext {
     pub(super) provider: Arc<rustls::crypto::CryptoProvider>,
     pub(super) tls_roots: Arc<RootCertStore>,
+    pub(crate) identities: Arc<super::identity::IdentityRegistry>,
 }
 
 impl std::fmt::Debug for SecurityContext {
@@ -22,19 +23,56 @@ impl std::fmt::Debug for SecurityContext {
 }
 
 impl SecurityContext {
+    #[cfg(test)]
+    pub(crate) fn shares_roots_with(&self, other: &Self) -> bool {
+        Arc::ptr_eq(&self.tls_roots, &other.tls_roots)
+    }
+    /// Read available platform roots once during preparation, retaining the
+    /// approved built-in roots when a platform store is unavailable.
+    #[cfg(any(test, feature = "invoke"))]
+    pub(crate) fn load(trust: &crate::config::TlsTrustConfig) -> Self {
+        let native = rustls_native_certs::load_native_certs();
+        if !native.errors.is_empty() {
+            tracing::debug!("some platform TLS trust roots were unavailable");
+        }
+        Self::with_certificates(trust, native.certs)
+    }
+
+    #[cfg(any(test, feature = "invoke"))]
+    pub(crate) fn with_certificates(
+        trust: &crate::config::TlsTrustConfig,
+        mut native: Vec<rustls::pki_types::CertificateDer<'static>>,
+    ) -> Self {
+        native.extend(trust.certificates.iter().cloned());
+        native.sort_unstable_by(|a, b| a.as_ref().cmp(b.as_ref()));
+        native.dedup_by(|a, b| a.as_ref() == b.as_ref());
+        let mut roots: RootCertStore = webpki_roots::TLS_SERVER_ROOTS.iter().cloned().collect();
+        roots.add_parsable_certificates(native);
+        // Native and embedded sources may contain the same trust anchor.
+        let mut unique = std::collections::HashSet::new();
+        roots.roots.retain(|root| unique.insert(root.clone()));
+        Self {
+            provider: Arc::new(rustls::crypto::ring::default_provider()),
+            tls_roots: Arc::new(roots),
+            identities: Arc::default(),
+        }
+    }
+
     #[must_use]
     pub fn new() -> Self {
         Self {
             provider: Arc::new(rustls::crypto::ring::default_provider()),
             tls_roots: Arc::new(webpki_roots::TLS_SERVER_ROOTS.iter().cloned().collect()),
+            identities: Arc::default(),
         }
     }
 
-    #[cfg(feature = "interop-test")]
-    pub(super) fn with_tls_roots(tls_roots: RootCertStore) -> Self {
+    #[cfg(any(test, feature = "interop-test"))]
+    pub(crate) fn with_tls_roots(tls_roots: RootCertStore) -> Self {
         Self {
             provider: Arc::new(rustls::crypto::ring::default_provider()),
             tls_roots: Arc::new(tls_roots),
+            identities: Arc::default(),
         }
     }
 }
@@ -57,4 +95,27 @@ mod tests {
         assert!(Arc::ptr_eq(&context.tls_roots, &clone.tls_roots));
         assert!(!context.tls_roots.is_empty());
     }
+
+    #[test]
+    fn configured_and_native_roots_merge_once_without_removing_embedded_roots() {
+        use base64::{Engine as _, engine::general_purpose::STANDARD};
+        let certificate = rcgen::generate_simple_self_signed(vec!["trust.example".into()])
+            .unwrap()
+            .cert;
+        let pem = format!(
+            "-----BEGIN CERTIFICATE-----\n{}\n-----END CERTIFICATE-----\n",
+            STANDARD.encode(certificate.der())
+        );
+        let trust = serde_yaml_ng::from_value::<crate::config::TlsTrustConfig>(
+            serde_yaml_ng::to_value(serde_json::json!({"custom-certifactes": [pem]})).unwrap(),
+        )
+        .unwrap();
+        let context = SecurityContext::with_certificates(&trust, vec![certificate.der().clone()]);
+        assert_eq!(
+            context.tls_roots.len(),
+            SecurityContext::new().tls_roots.len() + 1
+        );
+        assert!(context.shares_roots_with(&context.clone()));
+        assert!(!context.shares_roots_with(&SecurityContext::new()));
+    }
 }
diff --git a/src/security/ech.rs b/src/security/ech.rs
index bb926d9..286494b 100644
--- a/src/security/ech.rs
+++ b/src/security/ech.rs
@@ -1,6 +1,6 @@
 //! Adapter for official Rust HPKE through rustls's public provider seam. The
 //! wire enum paths are publicly exported but internal to rustls: keep them here.
-use hpke::{Deserializable, Kem as _, Serializable, aead::Aead};
+use hpke::{Deserializable, Serializable, aead::Aead};
 use rand::SeedableRng;
 use rustls::internal::msgs::{
     enums::{HpkeAead, HpkeKdf, HpkeKem},
@@ -14,28 +14,56 @@ use rustls::{
 };
 use std::marker::PhantomData;
 
-type Kem = hpke::kem::X25519HkdfSha256;
-type Kdf = hpke::kdf::HkdfSha256;
+macro_rules! suites {
+    ($($kem:ty),+ $(,)?) => {
+        &[
+        $(
+            &Adapter::<hpke::aead::AesGcm128, hpke::kdf::HkdfSha256, $kem>(PhantomData),
+            &Adapter::<hpke::aead::AesGcm256, hpke::kdf::HkdfSha256, $kem>(PhantomData),
+            &Adapter::<hpke::aead::ChaCha20Poly1305, hpke::kdf::HkdfSha256, $kem>(PhantomData),
+            &Adapter::<hpke::aead::AesGcm128, hpke::kdf::HkdfSha384, $kem>(PhantomData),
+            &Adapter::<hpke::aead::AesGcm256, hpke::kdf::HkdfSha384, $kem>(PhantomData),
+            &Adapter::<hpke::aead::ChaCha20Poly1305, hpke::kdf::HkdfSha384, $kem>(PhantomData),
+            &Adapter::<hpke::aead::AesGcm128, hpke::kdf::HkdfSha512, $kem>(PhantomData),
+            &Adapter::<hpke::aead::AesGcm256, hpke::kdf::HkdfSha512, $kem>(PhantomData),
+            &Adapter::<hpke::aead::ChaCha20Poly1305, hpke::kdf::HkdfSha512, $kem>(PhantomData),
+            &Adapter::<hpke::aead::AesGcm128, hpke::kdf::KdfShake128, $kem>(PhantomData),
+            &Adapter::<hpke::aead::AesGcm256, hpke::kdf::KdfShake128, $kem>(PhantomData),
+            &Adapter::<hpke::aead::ChaCha20Poly1305, hpke::kdf::KdfShake128, $kem>(PhantomData),
+            &Adapter::<hpke::aead::AesGcm128, hpke::kdf::KdfShake256, $kem>(PhantomData),
+            &Adapter::<hpke::aead::AesGcm256, hpke::kdf::KdfShake256, $kem>(PhantomData),
+            &Adapter::<hpke::aead::ChaCha20Poly1305, hpke::kdf::KdfShake256, $kem>(PhantomData),
+        )+
+        ]
+    };
+}
 
-static AES128: Adapter<hpke::aead::AesGcm128> = Adapter(PhantomData);
-static AES256: Adapter<hpke::aead::AesGcm256> = Adapter(PhantomData);
-static CHACHA: Adapter<hpke::aead::ChaCha20Poly1305> = Adapter(PhantomData);
-pub(super) static SUITES: &[&dyn Hpke] = &[&AES128, &AES256, &CHACHA];
+pub(super) static SUITES: &[&dyn Hpke] = suites![
+    hpke::kem::X25519HkdfSha256,
+    hpke::kem::DhP256HkdfSha256,
+    hpke::kem::DhP384HkdfSha384,
+    hpke::kem::DhP521HkdfSha512,
+    hpke::kem::MlKem768,
+    hpke::kem::MlKem1024,
+    hpke::kem::XWing,
+    hpke::kem::MlKem768P256,
+    hpke::kem::MlKem1024P384,
+];
 
-struct Adapter<A>(PhantomData<A>);
-struct Sender<A: Aead>(hpke::aead::AeadCtxS<A, Kdf, Kem>);
-struct Receiver<A: Aead>(hpke::aead::AeadCtxR<A, Kdf, Kem>);
-impl<A> std::fmt::Debug for Adapter<A> {
+struct Adapter<A, D, K>(PhantomData<(A, D, K)>);
+struct Sender<A: Aead, D: hpke::kdf::Kdf, K: hpke::Kem>(hpke::aead::AeadCtxS<A, D, K>);
+struct Receiver<A: Aead, D: hpke::kdf::Kdf, K: hpke::Kem>(hpke::aead::AeadCtxR<A, D, K>);
+impl<A, D, K> std::fmt::Debug for Adapter<A, D, K> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.write_str("HPKE adapter")
     }
 }
-impl<A: Aead> std::fmt::Debug for Sender<A> {
+impl<A: Aead, D: hpke::kdf::Kdf, K: hpke::Kem> std::fmt::Debug for Sender<A, D, K> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.write_str("HPKE sender")
     }
 }
-impl<A: Aead> std::fmt::Debug for Receiver<A> {
+impl<A: Aead, D: hpke::kdf::Kdf, K: hpke::Kem> std::fmt::Debug for Receiver<A, D, K> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.write_str("HPKE receiver")
     }
@@ -47,28 +75,43 @@ fn rng() -> Result<rand::rngs::StdRng, Error> {
     rand::rngs::StdRng::try_from_rng(&mut rand::rngs::SysRng)
         .map_err(|_| Error::General("HPKE randomness unavailable".into()))
 }
-impl<A: Aead + Send + Sync + 'static> HpkeSealer for Sender<A> {
+impl<
+    A: Aead + Send + Sync + 'static,
+    D: hpke::kdf::Kdf + Send + Sync + 'static,
+    K: hpke::Kem + Send + Sync + 'static,
+> HpkeSealer for Sender<A, D, K>
+{
     fn seal(&mut self, aad: &[u8], plaintext: &[u8]) -> Result<Vec<u8>, Error> {
         self.0.seal(plaintext, aad).map_err(error)
     }
 }
-impl<A: Aead + Send + Sync + 'static> HpkeOpener for Receiver<A> {
+impl<
+    A: Aead + Send + Sync + 'static,
+    D: hpke::kdf::Kdf + Send + Sync + 'static,
+    K: hpke::Kem + Send + Sync + 'static,
+> HpkeOpener for Receiver<A, D, K>
+{
     fn open(&mut self, aad: &[u8], ciphertext: &[u8]) -> Result<Vec<u8>, Error> {
         self.0.open(ciphertext, aad).map_err(error)
     }
 }
-impl<A: Aead + Send + Sync + 'static> Hpke for Adapter<A> {
+impl<
+    A: Aead + Send + Sync + 'static,
+    D: hpke::kdf::Kdf + Send + Sync + 'static,
+    K: hpke::Kem + Send + Sync + 'static,
+> Hpke for Adapter<A, D, K>
+{
     fn suite(&self) -> HpkeSuite {
         HpkeSuite {
-            kem: HpkeKem::DHKEM_X25519_HKDF_SHA256,
+            kem: HpkeKem::from(K::KEM_ID),
             sym: HpkeSymmetricCipherSuite {
-                kdf_id: HpkeKdf::HKDF_SHA256,
+                kdf_id: HpkeKdf::from(D::KDF_ID),
                 aead_id: HpkeAead::from(A::AEAD_ID),
             },
         }
     }
     fn generate_key_pair(&self) -> Result<(HpkePublicKey, HpkePrivateKey), Error> {
-        let (sk, pk) = Kem::gen_keypair_with_rng(&mut rng()?);
+        let (sk, pk) = K::gen_keypair_with_rng(&mut rng()?);
         Ok((
             HpkePublicKey(pk.to_bytes().to_vec()),
             sk.to_bytes().to_vec().into(),
@@ -79,14 +122,10 @@ impl<A: Aead + Send + Sync + 'static> Hpke for Adapter<A> {
         info: &[u8],
         key: &HpkePublicKey,
     ) -> Result<(EncapsulatedSecret, Box<dyn HpkeSealer>), Error> {
-        let pk = <Kem as hpke::Kem>::PublicKey::from_bytes(&key.0).map_err(error)?;
-        let (enc, ctx) = hpke::setup_sender_with_rng::<A, Kdf, Kem>(
-            &hpke::OpModeS::Base,
-            &pk,
-            info,
-            &mut rng()?,
-        )
-        .map_err(error)?;
+        let pk = <K as hpke::Kem>::PublicKey::from_bytes(&key.0).map_err(error)?;
+        let (enc, ctx) =
+            hpke::setup_sender_with_rng::<A, D, K>(&hpke::OpModeS::Base, &pk, info, &mut rng()?)
+                .map_err(error)?;
         Ok((
             EncapsulatedSecret(enc.to_bytes().to_vec()),
             Box::new(Sender(ctx)),
@@ -98,9 +137,9 @@ impl<A: Aead + Send + Sync + 'static> Hpke for Adapter<A> {
         info: &[u8],
         key: &HpkePrivateKey,
     ) -> Result<Box<dyn HpkeOpener>, Error> {
-        let sk = <Kem as hpke::Kem>::PrivateKey::from_bytes(key.secret_bytes()).map_err(error)?;
-        let enc = <Kem as hpke::Kem>::EncappedKey::from_bytes(&enc.0).map_err(error)?;
-        let ctx = hpke::setup_receiver::<A, Kdf, Kem>(&hpke::OpModeR::Base, &sk, &enc, info)
+        let sk = <K as hpke::Kem>::PrivateKey::from_bytes(key.secret_bytes()).map_err(error)?;
+        let enc = <K as hpke::Kem>::EncappedKey::from_bytes(&enc.0).map_err(error)?;
+        let ctx = hpke::setup_receiver::<A, D, K>(&hpke::OpModeR::Base, &sk, &enc, info)
             .map_err(error)?;
         Ok(Box::new(Receiver(ctx)))
     }
@@ -125,3 +164,25 @@ impl<A: Aead + Send + Sync + 'static> Hpke for Adapter<A> {
         self.setup_opener(enc, info, key)?.open(aad, ciphertext)
     }
 }
+
+pub(crate) fn valid_public_key(kem: u16, key: &[u8]) -> bool {
+    fn valid<K: hpke::Kem>(key: &[u8]) -> bool {
+        K::PublicKey::from_bytes(key).is_ok()
+    }
+    match kem {
+        0x0020 => valid::<hpke::kem::X25519HkdfSha256>(key),
+        0x0010 => valid::<hpke::kem::DhP256HkdfSha256>(key),
+        0x0011 => valid::<hpke::kem::DhP384HkdfSha384>(key),
+        0x0012 => valid::<hpke::kem::DhP521HkdfSha512>(key),
+        0x0041 => valid::<hpke::kem::MlKem768>(key),
+        0x0042 => valid::<hpke::kem::MlKem1024>(key),
+        0x647a => valid::<hpke::kem::XWing>(key),
+        0x0050 => valid::<hpke::kem::MlKem768P256>(key),
+        0x0051 => valid::<hpke::kem::MlKem1024P384>(key),
+        _ => false,
+    }
+}
+
+#[cfg(test)]
+#[path = "ech_tests.rs"]
+mod tests;
diff --git a/src/security/ech_dynamic_tests.rs b/src/security/ech_dynamic_tests.rs
new file mode 100644
index 0000000..7e3d244
--- /dev/null
+++ b/src/security/ech_dynamic_tests.rs
@@ -0,0 +1,177 @@
+use super::SecurityClient;
+use crate::{
+    config::{Config, ProxyProtocol},
+    dispatch::{BoxStream, DatagramTransport, DispatchError, Dispatcher},
+    dns::{classify_query, resolution::ResolutionContext, runtime::RuntimeDns},
+    outbound::EstablishContext,
+    session::{Datagram, DatagramSession, StreamSession},
+};
+use async_trait::async_trait;
+use boring::{
+    hpke::HpkeKey,
+    pkey::PKey,
+    ssl::{NameType, SslAcceptor, SslEchKeys, SslMethod, SslVersion},
+    x509::X509,
+};
+use bytes::Bytes;
+use hpke::{Kem, Serializable};
+use rand::SeedableRng;
+use serde_json::json;
+use sha2::{Digest, Sha256};
+use std::{
+    sync::{
+        Arc, Mutex,
+        atomic::{AtomicUsize, Ordering},
+    },
+    time::Duration,
+};
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+struct DnsPeer {
+    list: Vec<u8>,
+    calls: AtomicUsize,
+    names: Arc<Mutex<Vec<String>>>,
+}
+struct DnsTransport {
+    list: Vec<u8>,
+    query: Option<Datagram>,
+    names: Arc<Mutex<Vec<String>>>,
+}
+#[async_trait]
+impl Dispatcher for DnsPeer {
+    async fn connect_tcp(&self, _: StreamSession) -> Result<BoxStream, DispatchError> {
+        Err(DispatchError::NotAllowed)
+    }
+    async fn open_datagram(
+        &self,
+        _: DatagramSession,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        self.calls.fetch_add(1, Ordering::Relaxed);
+        Ok(Box::new(DnsTransport {
+            list: self.list.clone(),
+            query: None,
+            names: self.names.clone(),
+        }))
+    }
+}
+#[async_trait]
+impl DatagramTransport for DnsTransport {
+    fn supports_shared_destinations(&self) -> bool {
+        false
+    }
+
+    async fn send(&mut self, query: Datagram) -> Result<(), DispatchError> {
+        let question = classify_query(&query.payload).unwrap().question;
+        assert_eq!(question.query_type, 65);
+        self.names.lock().unwrap().push(question.name);
+        self.query = Some(query);
+        Ok(())
+    }
+    async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+        let query = self.query.take().unwrap();
+        let mut wire = query.payload.to_vec();
+        wire[2..4].copy_from_slice(&0x8180u16.to_be_bytes());
+        wire[6..8].copy_from_slice(&1u16.to_be_bytes());
+        wire.extend_from_slice(&[0xc0, 0x0c, 0, 65, 0, 1]);
+        wire.extend_from_slice(&60u32.to_be_bytes());
+        let mut data = vec![0, 1, 0, 0, 5];
+        data.extend_from_slice(&(self.list.len() as u16).to_be_bytes());
+        data.extend_from_slice(&self.list);
+        wire.extend_from_slice(&(data.len() as u16).to_be_bytes());
+        wire.extend_from_slice(&data);
+        Ok(Datagram {
+            remote: query.remote,
+            payload: Bytes::from(wire),
+            sniffed_domain: None,
+        })
+    }
+}
+
+#[tokio::test]
+async fn dynamic_ech_dns_configuration_is_consumed_by_real_tls_before_business_data() {
+    let mut rng = rand::rngs::StdRng::try_from_rng(&mut rand::rngs::SysRng).unwrap();
+    let (sk, pk) = hpke::kem::X25519HkdfSha256::gen_keypair_with_rng(&mut rng);
+    let mut content = vec![7, 0, 32, 0, 32];
+    content.extend_from_slice(&pk.to_bytes());
+    content.extend_from_slice(&[0, 4, 0, 1, 0, 1, 0, 14]);
+    content.extend_from_slice(b"public.invalid");
+    content.extend_from_slice(&[0, 0]);
+    let mut config = vec![0xfe, 0x0d];
+    config.extend_from_slice(&(content.len() as u16).to_be_bytes());
+    config.extend_from_slice(&content);
+    let mut list = (config.len() as u16).to_be_bytes().to_vec();
+    list.extend_from_slice(&config);
+    let cert =
+        rcgen::generate_simple_self_signed(vec!["inner.invalid".into(), "public.invalid".into()])
+            .unwrap();
+    let pin: String = Sha256::digest(cert.cert.der())
+        .iter()
+        .map(|b| format!("{b:02x}"))
+        .collect();
+    // This existing safe API's implementation imports X25519 despite its name.
+    let key = HpkeKey::dhkem_p256_sha256(&sk.to_bytes()).unwrap();
+    let mut keys = SslEchKeys::builder().unwrap();
+    keys.add_key(true, &config, key).unwrap();
+    let mut server = SslAcceptor::mozilla_intermediate_v5(SslMethod::tls()).unwrap();
+    server
+        .set_certificate(&X509::from_der(cert.cert.der()).unwrap())
+        .unwrap();
+    server
+        .set_private_key(&PKey::private_key_from_der(&cert.signing_key.serialize_der()).unwrap())
+        .unwrap();
+    server
+        .set_min_proto_version(Some(SslVersion::TLS1_3))
+        .unwrap();
+    server.set_ech_keys(&keys.build()).unwrap();
+    let server = server.build();
+    let peer = Arc::new(DnsPeer {
+        list,
+        calls: AtomicUsize::new(0),
+        names: Arc::new(Mutex::new(Vec::new())),
+    });
+    let dns_config = Config::parse_yaml(b"mixed-port: 1080\ndns:\n  enable: true\n  use-system-hosts: false\n  nameserver: [203.0.113.53]\n").unwrap();
+    let dns = Arc::new(RuntimeDns::new(&dns_config.dns, peer.clone()));
+    let resolution = ResolutionContext::runtime(false);
+    resolution.bind_runtime(Some(&dns)).unwrap();
+    for profile in ["none", "ios"] {
+        let config = Config::parse_yaml(&serde_json::to_vec(&json!({"mixed-port":1080,"proxies":[{"name":"edge","type":"vless","server":"inner.invalid","port":443,"uuid":"07070707-0707-0707-0707-070707070707","tls":true,"client-fingerprint":profile,"fingerprint":pin,"ech-opts":{"enable":true,"query-server-name":"query.invalid"}}]})).unwrap()).unwrap();
+        let ProxyProtocol::Vless(node) = &config.proxies[0].protocol else {
+            panic!()
+        };
+        let client = SecurityClient::from_proxy(node).unwrap();
+        let context = EstablishContext::with_resolution(Duration::from_secs(2), resolution.clone());
+        let (io, server_io) = tokio::io::duplex(65536);
+        tokio::time::timeout(Duration::from_secs(2), async {
+            let consumer = async {
+                let mut stream = client
+                    .connect_with_context(Box::new(io), &context)
+                    .await
+                    .unwrap();
+                stream.write_all(b"payload").await.unwrap();
+                stream.flush().await.unwrap();
+                let mut reply = [0; 5];
+                stream.read_exact(&mut reply).await.unwrap();
+                assert_eq!(&reply, b"reply");
+            };
+            let receiver = async {
+                let mut stream = tokio_boring::accept(&server, server_io).await.unwrap();
+                assert!(stream.ssl().ech_accepted());
+                assert!(!stream.ssl().session_reused());
+                assert_eq!(
+                    stream.ssl().servername(NameType::HOST_NAME),
+                    Some("inner.invalid")
+                );
+                let mut payload = [0; 7];
+                stream.read_exact(&mut payload).await.unwrap();
+                assert_eq!(&payload, b"payload");
+                stream.write_all(b"reply").await.unwrap();
+                stream.flush().await.unwrap();
+            };
+            tokio::join!(consumer, receiver);
+        })
+        .await
+        .unwrap();
+    }
+    assert_eq!(peer.calls.load(Ordering::Relaxed), 1);
+    assert_eq!(*peer.names.lock().unwrap(), ["query.invalid"]);
+}
diff --git a/src/security/ech_tests.rs b/src/security/ech_tests.rs
new file mode 100644
index 0000000..ed557cb
--- /dev/null
+++ b/src/security/ech_tests.rs
@@ -0,0 +1,140 @@
+use super::*;
+use std::sync::Arc;
+
+fn config_list(suite: HpkeSuite, key: &[u8]) -> Vec<u8> {
+    config_list_with_name(suite, key, b"public.invalid")
+}
+
+fn config_list_with_name(suite: HpkeSuite, key: &[u8], name: &[u8]) -> Vec<u8> {
+    let mut content = vec![7];
+    content.extend_from_slice(&u16::from(suite.kem).to_be_bytes());
+    content.extend_from_slice(&(key.len() as u16).to_be_bytes());
+    content.extend_from_slice(key);
+    content.extend_from_slice(&4u16.to_be_bytes());
+    content.extend_from_slice(&u16::from(suite.sym.kdf_id).to_be_bytes());
+    content.extend_from_slice(&u16::from(suite.sym.aead_id).to_be_bytes());
+    content.extend_from_slice(&[0, name.len() as u8]);
+    content.extend_from_slice(name);
+    content.extend_from_slice(&[0, 0]);
+    let mut list = ((content.len() + 4) as u16).to_be_bytes().to_vec();
+    list.extend_from_slice(&[0xfe, 0x0d]);
+    list.extend_from_slice(&(content.len() as u16).to_be_bytes());
+    list.extend_from_slice(&content);
+    list
+}
+
+fn vector_end(data: &[u8], at: usize, width: usize) -> usize {
+    let length = match width {
+        1 => usize::from(data[at]),
+        2 => usize::from(u16::from_be_bytes([data[at], data[at + 1]])),
+        _ => unreachable!(),
+    };
+    at + width + length
+}
+
+// Decode only the bounded ClientHello fixture. ECH AAD is ClientHelloOuter
+// without the handshake header, with its encrypted payload replaced by zeroes.
+fn encrypted_inner(wire: &[u8], hpke: &dyn Hpke, sk: &HpkePrivateKey, list: &[u8]) -> Vec<u8> {
+    assert_eq!(&wire[..3], &[22, 3, 1]);
+    assert_eq!(wire[5], 1);
+    let mut hello = wire[9..].to_vec();
+    let mut cursor = vector_end(&hello, 34, 1);
+    cursor = vector_end(&hello, cursor, 2);
+    cursor = vector_end(&hello, cursor, 1);
+    let end = vector_end(&hello, cursor, 2);
+    cursor += 2;
+    while cursor < end {
+        let kind = u16::from_be_bytes([hello[cursor], hello[cursor + 1]]);
+        let next = vector_end(&hello, cursor + 2, 2);
+        if kind == 0xfe0d {
+            let start = cursor + 4;
+            assert_eq!(hello[start], 0); // outer
+            assert_eq!(hello[start + 5], 7);
+            let enc_start = start + 8;
+            let payload_at = vector_end(&hello, start + 6, 2);
+            let payload_start = payload_at + 2;
+            let payload_end = vector_end(&hello, payload_at, 2);
+            let enc = EncapsulatedSecret(hello[enc_start..payload_at].to_vec());
+            let payload = hello[payload_start..payload_end].to_vec();
+            hello[payload_start..payload_end].fill(0);
+            let mut info = b"tls ech\0".to_vec();
+            info.extend_from_slice(&list[2..]);
+            return hpke.open(&enc, &info, &hello, &payload, sk).unwrap();
+        }
+        cursor = next;
+    }
+    panic!("missing real ECH extension");
+}
+
+#[test]
+fn ech_receiver_algorithms_encrypt_real_rustls_client_hello() {
+    // One real consumer for every KEM, then the remaining KDF/AEAD families.
+    // This is a bounded crypto fixture, not a protocol/platform matrix.
+    let indices = [0, 15, 30, 45, 60, 75, 90, 105, 120, 3, 6, 9, 12, 1, 2];
+    for index in indices {
+        let hpke = SUITES[index];
+        let (pk, sk) = hpke.generate_key_pair().unwrap();
+        assert!(valid_public_key(u16::from(hpke.suite().kem), &pk.0));
+        let list = if index == 0 {
+            let ordinary = config_list_with_name(hpke.suite(), &pk.0, b"public.0x123");
+            assert!(
+                crate::config::StaticEchConfig::from_config_list_for_backend(&ordinary, true)
+                    .is_err()
+            );
+            let single_label = config_list_with_name(hpke.suite(), &pk.0, b"public");
+            assert!(
+                crate::config::StaticEchConfig::from_config_list_for_backend(&single_label, false)
+                    .is_err()
+            );
+            ordinary
+        } else {
+            config_list(hpke.suite(), &pk.0)
+        };
+        let admitted =
+            crate::config::StaticEchConfig::from_config_list_for_backend(&list, false).unwrap();
+        let ech = rustls::client::EchConfig::new(admitted.as_bytes().into(), SUITES).unwrap();
+        let config = rustls::ClientConfig::builder_with_provider(Arc::new(
+            rustls::crypto::ring::default_provider(),
+        ))
+        .with_ech(ech.into())
+        .unwrap()
+        .with_root_certificates(rustls::RootCertStore::empty())
+        .with_no_client_auth();
+        let mut connection =
+            rustls::ClientConnection::new(Arc::new(config), "inner.invalid".try_into().unwrap())
+                .unwrap();
+        let mut wire = Vec::new();
+        connection.write_tls(&mut wire).unwrap();
+        assert!(!wire.windows(13).any(|v| v == b"inner.invalid"));
+        let plaintext = encrypted_inner(&wire, hpke, &sk, &list);
+        assert!(plaintext.windows(13).any(|v| v == b"inner.invalid"));
+        // Ciphertext is authenticated: the same receiver rejects different AAD.
+        let (enc, ciphertext) = hpke.seal(b"fixture", b"aad", b"payload", &pk).unwrap();
+        assert!(
+            hpke.open(&enc, b"fixture", b"other", &ciphertext, &sk)
+                .is_err()
+        );
+    }
+}
+
+#[test]
+fn inherited_ech_reselects_the_final_backend_before_any_handshake() {
+    let ordinary = SUITES[15];
+    let (pk, _) = ordinary.generate_key_pair().unwrap();
+    let first = config_list(ordinary.suite(), &pk.0);
+    let named = SUITES[0];
+    let (pk, _) = named.generate_key_pair().unwrap();
+    let second = config_list(named.suite(), &pk.0);
+    let mut list = ((first.len() + second.len() - 4) as u16)
+        .to_be_bytes()
+        .to_vec();
+    list.extend_from_slice(&first[2..]);
+    list.extend_from_slice(&second[2..]);
+    let ordinary =
+        crate::config::StaticEchConfig::from_config_list_for_backend(&list, false).unwrap();
+    assert_eq!(ordinary.as_bytes(), first);
+    assert_eq!(ordinary.for_backend(true).unwrap().as_bytes(), second);
+    let unsupported =
+        crate::config::StaticEchConfig::from_config_list_for_backend(&first, false).unwrap();
+    assert!(unsupported.for_backend(true).is_err());
+}
diff --git a/src/security/identity.rs b/src/security/identity.rs
new file mode 100644
index 0000000..ff95671
--- /dev/null
+++ b/src/security/identity.rs
@@ -0,0 +1,431 @@
+//! File-backed client identities, published independently of the proxy graph.
+//! The existing joined runtime worker owns all subsequent file reads.
+use std::{
+    io,
+    sync::{
+        Arc, Mutex, OnceLock, Weak,
+        atomic::{AtomicBool, Ordering},
+    },
+};
+
+use arc_swap::ArcSwap;
+use rustls::pki_types::{CertificateDer, PrivateKeyDer};
+use tokio_util::sync::CancellationToken;
+
+use crate::config::identity_files::{IdentityFileOrigin, PairStamp};
+
+pub(super) struct IdentityMaterial {
+    pub(super) certificates: Vec<CertificateDer<'static>>,
+    pub(super) key: PrivateKeyDer<'static>,
+    validated: OnceLock<bool>,
+    #[cfg(any(feature = "tls-fingerprint", feature = "quiche-h3-transport"))]
+    native: Mutex<Weak<NativeIdentity>>,
+}
+
+#[cfg(any(feature = "tls-fingerprint", feature = "quiche-h3-transport"))]
+pub(super) struct NativeIdentity {
+    pub(super) certificates: Vec<boring::x509::X509>,
+    pub(super) key: boring::pkey::PKey<boring::pkey::Private>,
+}
+
+impl IdentityMaterial {
+    pub(super) fn new(
+        certificates: Vec<CertificateDer<'static>>,
+        key: PrivateKeyDer<'static>,
+    ) -> Self {
+        Self {
+            certificates,
+            key,
+            validated: OnceLock::new(),
+            #[cfg(any(feature = "tls-fingerprint", feature = "quiche-h3-transport"))]
+            native: Mutex::new(Weak::new()),
+        }
+    }
+
+    #[cfg(any(feature = "tls-fingerprint", feature = "quiche-h3-transport"))]
+    pub(super) fn native(&self) -> io::Result<Arc<NativeIdentity>> {
+        let mut cached = self.native.lock().map_err(|_| invalid())?;
+        if let Some(native) = cached.upgrade() {
+            return Ok(native);
+        }
+        let certificates = self
+            .certificates
+            .iter()
+            .map(|cert| boring::x509::X509::from_der(cert))
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|_| invalid())?;
+        let key = boring::pkey::PKey::private_key_from_der(self.key.secret_der())
+            .map_err(|_| invalid())?;
+        let leaf = certificates.first().ok_or_else(invalid)?;
+        if !leaf.public_key().map_err(|_| invalid())?.public_eq(&key) {
+            return Err(invalid());
+        }
+        let native = Arc::new(NativeIdentity { certificates, key });
+        *cached = Arc::downgrade(&native);
+        Ok(native)
+    }
+
+    pub(super) fn certified_key(&self) -> io::Result<Arc<rustls::sign::CertifiedKey>> {
+        let size = self
+            .certificates
+            .iter()
+            .try_fold(self.key.secret_der().len(), |size, cert| {
+                size.checked_add(cert.len())
+            });
+        if size.is_none_or(|size| size > crate::config::MAX_CONFIG_BYTES) {
+            return Err(invalid());
+        }
+        rustls::sign::CertifiedKey::from_der(
+            self.certificates.clone(),
+            self.key.clone_key(),
+            &rustls::crypto::ring::default_provider(),
+        )
+        .map(Arc::new)
+        .map_err(|_| invalid())
+    }
+
+    pub(super) fn validate(&self) -> io::Result<()> {
+        if *self.validated.get_or_init(|| self.certified_key().is_ok()) {
+            Ok(())
+        } else {
+            Err(invalid())
+        }
+    }
+}
+
+pub(super) struct IdentityGeneration {
+    generation: u64,
+    material: Arc<IdentityMaterial>,
+    file_bytes: usize,
+}
+
+pub(super) struct ClientIdentitySource {
+    origin: Arc<IdentityFileOrigin>,
+    current: ArcSwap<IdentityGeneration>,
+    attempted: Mutex<PairStamp>,
+    stopped: Arc<AtomicBool>,
+    #[cfg(any(feature = "tls-fingerprint", feature = "quiche-h3-transport"))]
+    native_users: Mutex<Weak<()>>,
+    #[cfg(any(feature = "tls-fingerprint", feature = "quiche-h3-transport"))]
+    publication: Arc<Mutex<()>>,
+}
+
+#[derive(Clone, Default)]
+pub(super) struct IdentityEpoch {
+    generation: u64,
+    source: Option<Weak<ClientIdentitySource>>,
+}
+
+impl IdentityEpoch {
+    pub(super) fn generation(&self) -> u64 {
+        self.generation
+    }
+
+    pub(super) fn is_current(&self) -> bool {
+        self.source.as_ref().is_none_or(|source| {
+            source.upgrade().is_some_and(|source| {
+                !source.stopped.load(Ordering::Acquire)
+                    && source.current.load().generation == self.generation
+            })
+        })
+    }
+}
+
+pub(super) struct IdentitySnapshot {
+    pub(super) material: Arc<IdentityMaterial>,
+    pub(super) epoch: IdentityEpoch,
+    #[cfg(any(feature = "tls-fingerprint", feature = "quiche-h3-transport"))]
+    pub(super) native: Option<Arc<NativeIdentity>>,
+}
+
+impl ClientIdentitySource {
+    #[cfg(any(feature = "tls-fingerprint", feature = "quiche-h3-transport"))]
+    pub(super) fn native_lease(&self) -> io::Result<Arc<()>> {
+        // The final publication check and first native registration use the
+        // same short lock. Neither path parses certificates while holding it.
+        let _publication = self.publication.lock().map_err(|_| invalid())?;
+        if self.stopped.load(Ordering::Acquire) {
+            return Err(invalid());
+        }
+        let mut users = self.native_users.lock().map_err(|_| invalid())?;
+        if let Some(lease) = users.upgrade() {
+            return Ok(lease);
+        }
+        let lease = Arc::new(());
+        *users = Arc::downgrade(&lease);
+        Ok(lease)
+    }
+
+    #[cfg(any(feature = "tls-fingerprint", feature = "quiche-h3-transport"))]
+    pub(super) fn native_required(&self) -> bool {
+        self.native_users
+            .lock()
+            .map_or(true, |users| users.strong_count() != 0)
+    }
+
+    pub(super) fn snapshot(self: &Arc<Self>) -> IdentitySnapshot {
+        let current = self.current.load_full();
+        IdentitySnapshot {
+            material: current.material.clone(),
+            epoch: IdentityEpoch {
+                generation: current.generation,
+                source: Some(Arc::downgrade(self)),
+            },
+            #[cfg(any(feature = "tls-fingerprint", feature = "quiche-h3-transport"))]
+            native: None,
+        }
+    }
+}
+
+/// Weak membership prevents retired nodes or a stopped runtime from retaining
+/// complete graphs. Identical explicit file pairs may share material, while
+/// every TLS node/leg retains its own immutable policy and ticket budget.
+#[derive(Default)]
+pub(crate) struct IdentityRegistry {
+    sources: Mutex<Vec<Weak<ClientIdentitySource>>>,
+    publication: Arc<Mutex<()>>,
+    stopped: Arc<AtomicBool>,
+}
+
+impl IdentityRegistry {
+    pub(crate) fn has_sources(&self) -> bool {
+        !self.stopped.load(Ordering::Acquire)
+            && self
+                .sources
+                .lock()
+                .is_ok_and(|sources| sources.iter().any(|source| source.strong_count() != 0))
+    }
+
+    pub(crate) fn begin_shutdown(&self) {
+        let _publication = self.publication.lock();
+        self.stopped.store(true, Ordering::Release);
+    }
+
+    pub(super) fn register(
+        &self,
+        origin: &Arc<IdentityFileOrigin>,
+        initial: Arc<IdentityMaterial>,
+        file_bytes: usize,
+    ) -> io::Result<Arc<ClientIdentitySource>> {
+        let mut sources = self.sources.lock().map_err(|_| invalid())?;
+        let _publication = self.publication.lock().map_err(|_| invalid())?;
+        if self.stopped.load(Ordering::Acquire) {
+            return Err(invalid());
+        }
+        sources.retain(|source| source.strong_count() != 0);
+        let mut used = 0_usize;
+        let mut existing = None;
+        for source in sources.iter().filter_map(Weak::upgrade) {
+            used = used.saturating_add(source.current.load().file_bytes);
+            if source.origin.same_files(origin) {
+                existing = Some(source);
+            }
+        }
+        if let Some(source) = existing {
+            let other_bytes = used.saturating_sub(source.current.load().file_bytes);
+            if other_bytes.saturating_add(file_bytes) > crate::config::MAX_CONFIG_BYTES {
+                return Err(invalid());
+            }
+            return Ok(source);
+        }
+        if used.saturating_add(file_bytes) > crate::config::MAX_CONFIG_BYTES {
+            return Err(invalid());
+        }
+        let source = Arc::new(ClientIdentitySource {
+            origin: origin.clone(),
+            current: ArcSwap::from_pointee(IdentityGeneration {
+                generation: 1,
+                material: initial,
+                file_bytes,
+            }),
+            attempted: Mutex::new(origin.initial.clone()),
+            stopped: self.stopped.clone(),
+            #[cfg(any(feature = "tls-fingerprint", feature = "quiche-h3-transport"))]
+            native_users: Mutex::new(Weak::new()),
+            #[cfg(any(feature = "tls-fingerprint", feature = "quiche-h3-transport"))]
+            publication: self.publication.clone(),
+        });
+        sources.push(Arc::downgrade(&source));
+        Ok(source)
+    }
+
+    /// Called only by the existing joined maintenance worker. Metadata probes
+    /// and PEM input are bounded; a failed pair preserves the published identity.
+    pub(crate) fn refresh(&self, cancellation: &CancellationToken) {
+        #[cfg(test)]
+        self.refresh_inner(cancellation, None);
+        #[cfg(not(test))]
+        self.refresh_inner(cancellation);
+    }
+
+    #[cfg(test)]
+    pub(super) fn refresh_before_publication(
+        &self,
+        cancellation: &CancellationToken,
+        before: &mut dyn FnMut(),
+    ) {
+        self.refresh_inner(cancellation, Some(before));
+    }
+
+    fn refresh_inner(
+        &self,
+        cancellation: &CancellationToken,
+        #[cfg(test)] mut before: Option<&mut dyn FnMut()>,
+    ) {
+        if cancellation.is_cancelled() || self.stopped.load(Ordering::Acquire) {
+            return;
+        }
+        let Ok(mut entries) = self.sources.lock() else {
+            return;
+        };
+        entries.retain(|source| source.strong_count() != 0);
+        let sources: Vec<_> = entries.iter().filter_map(Weak::upgrade).collect();
+        // Serialize registration/publication so the aggregate active material
+        // budget cannot be bypassed by concurrent candidate graph preparation.
+        let mut used: usize = sources
+            .iter()
+            .map(|source| source.current.load().file_bytes)
+            .sum();
+        for source in &sources {
+            if cancellation.is_cancelled() || self.stopped.load(Ordering::Acquire) {
+                return;
+            }
+            let Ok(stamp) = source.origin.stamp() else {
+                continue;
+            };
+            let Ok(mut attempted) = source.attempted.lock() else {
+                continue;
+            };
+            if *attempted == stamp {
+                continue;
+            }
+            let old = source.current.load_full();
+            let other_bytes = used.saturating_sub(old.file_bytes);
+            let Some(mut remaining) = crate::config::MAX_CONFIG_BYTES.checked_sub(other_bytes)
+            else {
+                continue;
+            };
+            // Oversized pairs may become admissible after another identity is
+            // removed or shrinks; do not remember an unsuccessful budget check.
+            if stamp.bytes() > remaining {
+                continue;
+            }
+            let Ok((certificate, private_key, read_stamp)) = source.origin.read(&mut remaining)
+            else {
+                continue;
+            };
+            if read_stamp != stamp
+                || source.origin.stamp().ok().as_ref() != Some(&read_stamp)
+                || cancellation.is_cancelled()
+            {
+                continue;
+            }
+            // Only stable content failures are remembered. Permission and IO
+            // recovery must work even when size/mtime/inode stay unchanged.
+            *attempted = read_stamp.clone();
+            let file_bytes = certificate.len().saturating_add(private_key.len());
+            let Ok(identity) = super::tls::TlsClientIdentity::from_pem(&certificate, &private_key)
+            else {
+                continue;
+            };
+            let material = identity.snapshot().material;
+            if material.validate().is_err()
+                || source.origin.stamp().ok().as_ref() != Some(&read_stamp)
+                || cancellation.is_cancelled()
+            {
+                continue;
+            }
+            #[cfg(any(feature = "tls-fingerprint", feature = "quiche-h3-transport"))]
+            let mut native_validation = if source.native_required() {
+                let Ok(native) = material.native() else {
+                    continue;
+                };
+                Some(native)
+            } else {
+                None
+            };
+            let Some(generation) = old.generation.checked_add(1) else {
+                continue;
+            };
+            #[cfg(test)]
+            if let Some(before) = &mut before {
+                before();
+            }
+            let Ok(publication) = self.publication.lock() else {
+                return;
+            };
+            #[cfg(any(feature = "tls-fingerprint", feature = "quiche-h3-transport"))]
+            let mut publication = publication;
+            #[cfg(any(feature = "tls-fingerprint", feature = "quiche-h3-transport"))]
+            if source.native_required() && native_validation.is_none() {
+                // A native client registered after the first check. Complete
+                // validation outside the Stop/publication lock, then reenter.
+                drop(publication);
+                let Ok(native) = material.native() else {
+                    continue;
+                };
+                native_validation = Some(native);
+                let Ok(guard) = self.publication.lock() else {
+                    return;
+                };
+                publication = guard;
+            }
+            if cancellation.is_cancelled() || self.stopped.load(Ordering::Acquire) {
+                return;
+            }
+            source.current.store(Arc::new(IdentityGeneration {
+                generation,
+                material,
+                file_bytes,
+            }));
+            drop(publication);
+            #[cfg(any(feature = "tls-fingerprint", feature = "quiche-h3-transport"))]
+            drop(native_validation);
+            used = other_bytes.saturating_add(file_bytes);
+        }
+    }
+}
+
+pub(super) fn invalid() -> io::Error {
+    io::Error::new(io::ErrorKind::InvalidInput, "invalid TLS client identity")
+}
+
+#[cfg(all(
+    test,
+    any(feature = "tls-fingerprint", feature = "quiche-h3-transport")
+))]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn ordinary_rustls_identity_does_not_retain_an_unused_native_representation() {
+        let generated = rcgen::generate_simple_self_signed(vec!["client.invalid".into()]).unwrap();
+        let identity = super::super::TlsClientIdentity::from_der(
+            vec![generated.cert.der().clone()],
+            rustls::pki_types::PrivatePkcs8KeyDer::from(generated.signing_key.serialize_der())
+                .into(),
+        );
+        let snapshot = identity.snapshot();
+        let _client = super::super::StandardTlsClient::with_options(
+            &super::super::SecurityContext::new(),
+            "peer.invalid",
+            super::super::TlsClientOptions {
+                identity: Some(identity.clone()),
+                ..Default::default()
+            },
+            0,
+            65536,
+        )
+        .unwrap();
+        assert_eq!(snapshot.material.native.lock().unwrap().strong_count(), 0);
+        let native_client = identity.for_native().unwrap();
+        let first = native_client.native_snapshot().unwrap().native.unwrap();
+        let second = native_client.native_snapshot().unwrap().native.unwrap();
+        assert!(Arc::ptr_eq(&first, &second));
+        let cached = Arc::downgrade(&first);
+        drop((first, second));
+        assert!(cached.upgrade().is_some());
+        drop(native_client);
+        assert!(cached.upgrade().is_none());
+    }
+}
diff --git a/src/security/identity_rotation_tests.rs b/src/security/identity_rotation_tests.rs
new file mode 100644
index 0000000..b34827d
--- /dev/null
+++ b/src/security/identity_rotation_tests.rs
@@ -0,0 +1,522 @@
+//! Published file identities over memory TLS; no sockets or external material.
+#![cfg(feature = "outbound-http")]
+
+use super::*;
+use tokio_util::sync::CancellationToken;
+
+type Accepted = tokio_rustls::server::TlsStream<tokio::io::DuplexStream>;
+
+struct Files {
+    directory: tempfile::TempDir,
+}
+
+impl Files {
+    fn new(identity: &Chain) -> Self {
+        let files = Self {
+            directory: tempfile::tempdir().unwrap(),
+        };
+        files.replace(identity);
+        files
+    }
+
+    fn replace_member(&self, name: &str, contents: &str) {
+        use std::io::Write;
+        let mut candidate = tempfile::NamedTempFile::new_in(self.directory.path()).unwrap();
+        candidate.write_all(contents.as_bytes()).unwrap();
+        // Replacing the inode makes every candidate observable even when equal
+        // length writes happen within one filesystem timestamp quantum.
+        candidate.persist(self.directory.path().join(name)).unwrap();
+    }
+
+    fn replace(&self, identity: &Chain) {
+        let pem = identity.identity_pem();
+        self.replace_member("client.pem", &pem.certificate);
+        self.replace_member("client.key", &pem.private_key);
+    }
+
+    fn identity(&self, context: &SecurityContext) -> TlsClientIdentity {
+        TlsClientIdentity::from_config(&self.configuration(), context).unwrap()
+    }
+
+    fn configuration(&self) -> crate::config::TlsIdentityPem {
+        let config = crate::config::Config::parse_yaml_with_directory(
+            br#"proxies:
+  - name: edge
+    type: http
+    server: fixture.invalid
+    port: 443
+    tls: true
+    certificate: client.pem
+    private-key: client.key
+rules: ['MATCH,edge']
+"#,
+            Some(self.directory.path()),
+        )
+        .unwrap();
+        let crate::config::ProxyProtocol::Http(http) = &config.proxies[0].protocol else {
+            panic!("file-backed HTTP identity expected");
+        };
+        http.tls
+            .as_ref()
+            .unwrap()
+            .identity
+            .as_ref()
+            .unwrap()
+            .clone()
+    }
+}
+
+fn endpoint(peer: &Chain, identities: &[&Chain]) -> Arc<ServerConfig> {
+    let mut roots = RootCertStore::empty();
+    for identity in identities {
+        roots.add(identity.certificates[2].clone()).unwrap();
+    }
+    let provider = Arc::new(rustls::crypto::ring::default_provider());
+    let verifier = rustls::server::WebPkiClientVerifier::builder_with_provider(
+        Arc::new(roots),
+        provider.clone(),
+    )
+    .build()
+    .unwrap();
+    let mut config = ServerConfig::builder_with_provider(provider)
+        .with_protocol_versions(&[&TLS13])
+        .unwrap()
+        .with_client_cert_verifier(verifier)
+        .with_single_cert(peer.certificates.clone(), peer.key.clone_key())
+        .unwrap();
+    // More than the node's budget makes a late old connection capable of
+    // displacing every new ticket if generation checks are accidentally lost.
+    config.send_tls13_tickets = 8;
+    Arc::new(config)
+}
+
+fn rotating_client(
+    context: &SecurityContext,
+    identity: TlsClientIdentity,
+    profile: Option<crate::config::ClientFingerprint>,
+) -> StandardTlsClient {
+    StandardTlsClient::with_options(
+        context,
+        "fixture.invalid",
+        TlsClientOptions {
+            identity: Some(identity),
+            client_fingerprint: profile,
+            ..Default::default()
+        },
+        TLS_RESUMPTION_SESSION_BUDGET,
+        DEFAULT_TLS_BUFFER_LIMIT,
+    )
+    .unwrap()
+}
+
+async fn open(
+    client: &StandardTlsClient,
+    endpoint: Arc<ServerConfig>,
+    expected: &Chain,
+) -> (crate::dispatch::BoxStream, Accepted, bool) {
+    let (client_io, peer_io) = tokio::io::duplex(16_384);
+    let acceptor = tokio_rustls::TlsAcceptor::from(endpoint);
+    let (client, peer) = tokio::time::timeout(Duration::from_secs(3), async {
+        tokio::join!(
+            client.connect(Box::new(client_io)),
+            acceptor.accept(peer_io)
+        )
+    })
+    .await
+    .unwrap();
+    let peer = peer.unwrap();
+    let client = client.unwrap();
+    assert_eq!(
+        peer.get_ref().1.peer_certificates().unwrap().first(),
+        expected.certificates.first(),
+        "the new physical TLS connection used another client identity"
+    );
+    let resumed = peer.get_ref().1.handshake_kind() == Some(rustls::HandshakeKind::Resumed);
+    (client, peer, resumed)
+}
+
+async fn exchange(client: &mut crate::dispatch::BoxStream, peer: &mut Accepted, value: &[u8]) {
+    assert!(value.len() <= 1024);
+    tokio::time::timeout(Duration::from_secs(3), async {
+        let caller = async {
+            client.write_all(value).await.unwrap();
+            client.flush().await.unwrap();
+            let mut reply = vec![0; value.len()];
+            client.read_exact(&mut reply).await.unwrap();
+            assert_eq!(reply, value);
+        };
+        let responder = async {
+            let mut request = vec![0; value.len()];
+            peer.read_exact(&mut request).await.unwrap();
+            assert_eq!(request, value);
+            peer.write_all(&request).await.unwrap();
+            peer.flush().await.unwrap();
+        };
+        tokio::join!(caller, responder);
+    })
+    .await
+    .unwrap();
+}
+
+fn assert_identity(identity: &TlsClientIdentity, expected: &Chain, generation: u64) {
+    let snapshot = identity.snapshot();
+    assert_eq!(snapshot.material.certificates, expected.certificates);
+    assert_eq!(snapshot.epoch.generation(), generation);
+    assert!(snapshot.epoch.is_current());
+}
+
+#[tokio::test]
+async fn consecutive_rotations_preserve_old_transports_and_reject_late_old_tickets() {
+    let peer = chain(false);
+    let a = chain_with_usage(false, ExtendedKeyUsagePurpose::ClientAuth);
+    let b = chain_with_usage(false, ExtendedKeyUsagePurpose::ClientAuth);
+    let c = chain_with_usage(false, ExtendedKeyUsagePurpose::ClientAuth);
+    #[cfg(not(feature = "tls-fingerprint"))]
+    let profiles = [None];
+    #[cfg(feature = "tls-fingerprint")]
+    let profiles = [None, Some(crate::config::ClientFingerprint::Chrome133)];
+    for profile in profiles {
+        let files = Files::new(&a);
+        let context = trusted(&peer);
+        let identity = files.identity(&context);
+        let client = rotating_client(&context, identity.clone(), profile);
+        let endpoint = endpoint(&peer, &[&a, &b, &c]);
+        let frozen_rustls = match client.current_connector().unwrap() {
+            StandardConnector::Rustls(connector) => Some(connector.config().clone()),
+            #[cfg(feature = "tls-fingerprint")]
+            StandardConnector::Boring(_) => None,
+        };
+        let (mut old_client, mut old_peer, resumed) = open(&client, endpoint.clone(), &a).await;
+        assert!(!resumed);
+        // Leave A's post-handshake tickets unread until after B has filled the
+        // node cache, so its late TLS callbacks cannot repopulate the new era.
+        let old_epoch = identity.snapshot().epoch;
+        files.replace(&b);
+        context.identities.refresh(&CancellationToken::new());
+        assert!(!old_epoch.is_current());
+        assert_identity(&identity, &b, 2);
+        let (mut b_client, mut b_peer, resumed) = open(&client, endpoint.clone(), &b).await;
+        assert!(!resumed, "the old identity's ticket crossed the rotation");
+        exchange(&mut b_client, &mut b_peer, b"new-B").await;
+        exchange(&mut old_client, &mut old_peer, b"old-A-still-live").await;
+        let (mut resumed_b, mut resumed_peer, resumed) = open(&client, endpoint.clone(), &b).await;
+        assert!(resumed, "late A tickets displaced B's usable session cache");
+        exchange(&mut resumed_b, &mut resumed_peer, b"resumed-B").await;
+        drop((resumed_b, resumed_peer));
+
+        files.replace(&c);
+        context.identities.refresh(&CancellationToken::new());
+        assert_identity(&identity, &c, 3);
+        let (mut c_client, mut c_peer, resumed) = open(&client.clone(), endpoint.clone(), &c).await;
+        assert!(!resumed, "B's ticket crossed the second rotation");
+        exchange(&mut c_client, &mut c_peer, b"new-C").await;
+        exchange(&mut b_client, &mut b_peer, b"old-B-still-live").await;
+        exchange(&mut old_client, &mut old_peer, b"old-A-after-C").await;
+
+        if let Some(config) = frozen_rustls {
+            // A retired QUIC/TLS consumer may still own its immutable config.
+            // The old config remains a working A identity, without borrowing
+            // the live node's newer resolver or publishing tickets into it.
+            let (client_io, peer_io) = tokio::io::duplex(16_384);
+            let connector = TlsConnector::from(config);
+            let acceptor = tokio_rustls::TlsAcceptor::from(endpoint);
+            let (frozen, accepted) = tokio::time::timeout(Duration::from_secs(3), async {
+                tokio::join!(
+                    connector.connect(ServerName::try_from("fixture.invalid").unwrap(), client_io),
+                    acceptor.accept(peer_io),
+                )
+            })
+            .await
+            .unwrap();
+            let mut accepted = accepted.unwrap();
+            assert_eq!(
+                accepted.get_ref().1.peer_certificates().unwrap().first(),
+                a.certificates.first()
+            );
+            assert_ne!(
+                accepted.get_ref().1.handshake_kind(),
+                Some(rustls::HandshakeKind::Resumed)
+            );
+            let mut frozen = Box::new(frozen.unwrap()) as crate::dispatch::BoxStream;
+            exchange(&mut frozen, &mut accepted, b"frozen-A-config").await;
+        }
+        // Read C after an older configuration has completed too: neither old
+        // transport lifetime nor its ticket callbacks may stall new identity use.
+        exchange(&mut c_client, &mut c_peer, b"current-C").await;
+    }
+}
+
+#[tokio::test]
+async fn mismatched_candidates_recover_and_cancel_or_stop_cannot_publish() {
+    let peer = chain(false);
+    let a = chain_with_usage(false, ExtendedKeyUsagePurpose::ClientAuth);
+    let b = chain_with_usage(false, ExtendedKeyUsagePurpose::ClientAuth);
+    let c = chain_with_usage(false, ExtendedKeyUsagePurpose::ClientAuth);
+    let files = Files::new(&a);
+    let context = trusted(&peer);
+    let identity = files.identity(&context);
+    let client = rotating_client(&context, identity.clone(), None);
+    let endpoint = endpoint(&peer, &[&a, &b, &c]);
+    let b_pem = b.identity_pem();
+    files.replace_member("client.pem", &b_pem.certificate);
+    context.identities.refresh(&CancellationToken::new());
+    assert_identity(&identity, &a, 1);
+    let (mut caller, mut accepted, _) = open(&client, endpoint.clone(), &a).await;
+    exchange(&mut caller, &mut accepted, b"bad-pair-keeps-A").await;
+    drop((caller, accepted));
+
+    files.replace_member("client.key", &b_pem.private_key);
+    context.identities.refresh(&CancellationToken::new());
+    assert_identity(&identity, &b, 2);
+    let (mut caller, mut accepted, _) = open(&client, endpoint.clone(), &b).await;
+    exchange(&mut caller, &mut accepted, b"recovered-B").await;
+    drop((caller, accepted));
+
+    files.replace(&c);
+    let cancelled = CancellationToken::new();
+    cancelled.cancel();
+    context.identities.refresh(&cancelled);
+    assert_identity(&identity, &b, 2);
+    context.identities.refresh(&CancellationToken::new());
+    assert_identity(&identity, &c, 3);
+    let epoch = identity.snapshot().epoch;
+    context.identities.begin_shutdown();
+    assert!(!epoch.is_current());
+    files.replace(&a);
+    context.identities.refresh(&CancellationToken::new());
+    assert_eq!(identity.snapshot().epoch.generation(), 3);
+    assert_eq!(identity.snapshot().material.certificates, c.certificates);
+    assert!(!context.identities.has_sources());
+}
+
+#[test]
+fn different_pairs_rotate_independently_and_identical_sources_share_one_publication() {
+    let a = chain_with_usage(false, ExtendedKeyUsagePurpose::ClientAuth);
+    let b = chain_with_usage(false, ExtendedKeyUsagePurpose::ClientAuth);
+    let first_files = Files::new(&a);
+    let second_files = Files::new(&a);
+    let context = SecurityContext::new();
+    let first = first_files.identity(&context);
+    let same_files = first_files.identity(&context);
+    let different_files = second_files.identity(&context);
+    assert!(Arc::ptr_eq(
+        &first.snapshot().material,
+        &same_files.snapshot().material
+    ));
+    assert!(!Arc::ptr_eq(
+        &first.snapshot().material,
+        &different_files.snapshot().material
+    ));
+    first_files.replace(&b);
+    context.identities.refresh(&CancellationToken::new());
+    assert_identity(&first, &b, 2);
+    assert_identity(&same_files, &b, 2);
+    assert_identity(&different_files, &a, 1);
+    second_files.replace(&b);
+    context.identities.refresh(&CancellationToken::new());
+    assert_identity(&different_files, &b, 2);
+}
+
+#[test]
+fn larger_same_pair_candidate_cannot_bypass_other_active_material() {
+    let a = chain_with_usage(false, ExtendedKeyUsagePurpose::ClientAuth);
+    let first_files = Files::new(&a);
+    let other_files = Files::new(&a);
+    let context = SecurityContext::new();
+    let first = first_files.identity(&context);
+    let other = other_files.identity(&context);
+    let mut large = a.identity_pem();
+    let padding =
+        crate::config::MAX_CONFIG_BYTES - large.certificate.len() - large.private_key.len();
+    // Whitespace is valid PEM input and still consumes the shared file budget.
+    large.certificate.extend(std::iter::repeat_n(' ', padding));
+    first_files.replace_member("client.pem", &large.certificate);
+    let candidate = first_files.configuration();
+    assert!(TlsClientIdentity::from_config(&candidate, &context).is_err());
+    assert_identity(&first, &a, 1);
+    context.identities.refresh(&CancellationToken::new());
+    assert_identity(&first, &a, 1);
+    drop(other);
+    let accepted = TlsClientIdentity::from_config(&candidate, &context).unwrap();
+    assert!(Arc::ptr_eq(
+        &first.snapshot().material,
+        &accepted.snapshot().material
+    ));
+    context.identities.refresh(&CancellationToken::new());
+    assert_identity(&first, &a, 2);
+    assert_identity(&accepted, &a, 2);
+}
+
+#[cfg(all(feature = "tls-fingerprint", feature = "outbound-vless"))]
+#[test]
+fn dynamic_ech_rebuilds_share_the_native_owner_without_resolving_dns() {
+    let a = chain_with_usage(false, ExtendedKeyUsagePurpose::ClientAuth);
+    let files = Files::new(&a);
+    let context = SecurityContext::new();
+    let identity = files.identity(&context);
+    let config = crate::config::Config::parse_yaml(
+        br#"proxies:
+  - name: edge
+    type: vless
+    server: fixture.invalid
+    port: 443
+    uuid: 07070707-0707-0707-0707-070707070707
+    tls: true
+    client-fingerprint: chrome
+    ech-opts: {enable: true, query-server-name: query.invalid}
+"#,
+    )
+    .unwrap();
+    let crate::config::ProxyProtocol::Vless(vless) = &config.proxies[0].protocol else {
+        unreachable!()
+    };
+    let client = StandardTlsClient::with_options(
+        &context,
+        "fixture.invalid",
+        TlsClientOptions {
+            ech: vless.security.as_tls().unwrap().ech.clone(),
+            client_fingerprint: Some(crate::config::ClientFingerprint::Chrome133),
+            identity: Some(identity),
+            ..Default::default()
+        },
+        0,
+        DEFAULT_TLS_BUFFER_LIMIT,
+    )
+    .unwrap();
+    let dynamic = client.dynamic_ech.as_ref().unwrap();
+    let owner = dynamic
+        .options
+        .identity
+        .as_ref()
+        .unwrap()
+        .native
+        .as_ref()
+        .unwrap()
+        .clone();
+    let retained = Arc::strong_count(&owner);
+    // Exercise the same backend reconstruction after DNS without making a DNS
+    // request: only the resolved ECH option is omitted from this ownership test.
+    let mut resolved = dynamic.options.clone();
+    resolved.ech = None;
+    resolved.versions = TlsVersions::Tls13;
+    let rebuilt = StandardTlsClient::with_options(
+        &context,
+        "fixture.invalid",
+        resolved,
+        0,
+        DEFAULT_TLS_BUFFER_LIMIT,
+    )
+    .unwrap();
+    assert_eq!(Arc::strong_count(&owner), retained + 1);
+    drop(rebuilt);
+    assert_eq!(Arc::strong_count(&owner), retained);
+}
+
+#[cfg(feature = "tls-fingerprint")]
+#[test]
+fn discarded_native_candidate_releases_its_requirement_and_cached_representation() {
+    let a = chain_with_usage(false, ExtendedKeyUsagePurpose::ClientAuth);
+    let files = Files::new(&a);
+    let context = SecurityContext::new();
+    let identity = files.identity(&context);
+    let IdentityStorage::Files(source) = &identity.storage else {
+        unreachable!()
+    };
+    let _plain = rotating_client(&context, identity.clone(), None);
+    assert!(!source.native_required());
+    let rejected = StandardTlsClient::with_options(
+        &context,
+        "fixture.invalid",
+        TlsClientOptions {
+            versions: TlsVersions::Tls13,
+            client_fingerprint: Some(crate::config::ClientFingerprint::ThreeSixty75),
+            identity: Some(identity.clone()),
+            ..Default::default()
+        },
+        0,
+        DEFAULT_TLS_BUFFER_LIMIT,
+    );
+    assert!(rejected.is_err());
+    assert!(!source.native_required());
+    let candidate = rotating_client(
+        &context,
+        identity.clone(),
+        Some(crate::config::ClientFingerprint::Chrome133),
+    );
+    assert!(source.native_required());
+    let cached = Arc::downgrade(&identity.snapshot().material.native().unwrap());
+    assert!(cached.upgrade().is_some());
+    drop(candidate);
+    assert!(!source.native_required());
+    assert!(cached.upgrade().is_none());
+}
+
+#[cfg(feature = "tls-fingerprint")]
+#[test]
+fn native_registration_between_validation_and_publication_rechecks_the_candidate() {
+    let a = chain_with_usage(false, ExtendedKeyUsagePurpose::ClientAuth);
+    let b = chain_with_usage(false, ExtendedKeyUsagePurpose::ClientAuth);
+    let files = Files::new(&a);
+    let context = SecurityContext::new();
+    let identity = files.identity(&context);
+    let mut candidate = b.identity_pem();
+    candidate
+        .certificate
+        .push_str("-----BEGIN CERTIFICATE-----\nAQID\n-----END CERTIFICATE-----\n");
+    // rustls checks the matching leaf/key at construction; native TLS parses
+    // every chain member. The late subscriber must not inherit this candidate.
+    let parsed =
+        TlsClientIdentity::from_pem(&candidate.certificate, &candidate.private_key).unwrap();
+    assert!(parsed.snapshot().material.native().is_err());
+    files.replace_member("client.pem", &candidate.certificate);
+    files.replace_member("client.key", &candidate.private_key);
+    let mut native_owner = None;
+    context
+        .identities
+        .refresh_before_publication(&CancellationToken::new(), &mut || {
+            native_owner = Some(identity.for_native().unwrap());
+        });
+    assert_identity(&identity, &a, 1);
+    files.replace(&b);
+    context.identities.refresh(&CancellationToken::new());
+    assert_identity(&identity, &b, 2);
+    assert_eq!(
+        native_owner
+            .unwrap()
+            .native_snapshot()
+            .unwrap()
+            .material
+            .certificates,
+        b.certificates
+    );
+}
+
+#[cfg(unix)]
+#[test]
+fn transient_read_failure_retries_after_permissions_recover_without_content_change() {
+    use std::os::unix::fs::PermissionsExt;
+    // SAFETY: geteuid has no arguments, memory access or ownership effects.
+    if unsafe { libc::geteuid() } == 0 {
+        return; // Root bypasses the file permission failure this case requires.
+    }
+    let a = chain_with_usage(false, ExtendedKeyUsagePurpose::ClientAuth);
+    let b = chain_with_usage(false, ExtendedKeyUsagePurpose::ClientAuth);
+    let files = Files::new(&a);
+    let context = SecurityContext::new();
+    let identity = files.identity(&context);
+    files.replace(&b);
+    let path = files.directory.path().join("client.key");
+    let metadata = std::fs::metadata(&path).unwrap();
+    let permissions = metadata.permissions();
+    let modified = metadata.modified().unwrap();
+    std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0)).unwrap();
+    context.identities.refresh(&CancellationToken::new());
+    assert_identity(&identity, &a, 1);
+    std::fs::set_permissions(&path, permissions).unwrap();
+    assert_eq!(
+        std::fs::metadata(path).unwrap().modified().unwrap(),
+        modified
+    );
+    context.identities.refresh(&CancellationToken::new());
+    assert_identity(&identity, &b, 2);
+}
diff --git a/src/security/masque.rs b/src/security/masque.rs
new file mode 100644
index 0000000..1b6021e
--- /dev/null
+++ b/src/security/masque.rs
@@ -0,0 +1,1190 @@
+//! MASQUE uses an ECDSA identity and a peer public-key pin, without WebPKI.
+//! HTTP/2 uses rustls/ring; HTTP/3 uses the shared Boring QUIC backend. Boring
+//! also supplies P-224/P-521 and TLS 1.2's curve-independent hash selection.
+use std::{
+    fmt, io,
+    sync::{
+        Arc, OnceLock,
+        atomic::{AtomicU8, Ordering},
+    },
+    time::{SystemTime, UNIX_EPOCH},
+};
+
+use base64::{Engine as _, alphabet, engine::general_purpose};
+use boring::{
+    asn1::Asn1Time,
+    bn::{BigNum, BigNumContext},
+    ec::{EcGroup, EcKey, EcPoint},
+    hash::MessageDigest,
+    nid::Nid,
+    pkey::{HasPublic, Id, PKey, PKeyRef, Private, Public},
+    rsa::Padding,
+    sign::{RsaPssSaltlen, Signer as NativeSigner, Verifier},
+    x509::{X509, X509Name},
+};
+use rustls::{
+    CertificateError, ClientConfig, DigitallySignedStruct, Error, SignatureAlgorithm,
+    SignatureScheme,
+    client::{
+        Resumption,
+        danger::{HandshakeSignatureValid, ServerCertVerified, ServerCertVerifier},
+    },
+    crypto::CryptoProvider,
+    pki_types::{CertificateDer, ServerName, SubjectPublicKeyInfoDer, UnixTime},
+    sign::{CertifiedKey, Signer, SigningKey, SingleCertAndKey},
+    version::{TLS12, TLS13},
+};
+use zeroize::Zeroizing;
+
+use super::SecurityContext;
+
+const UNKNOWN_VERSION: u8 = 0;
+const VERSION_12: u8 = 12;
+const VERSION_13: u8 = 13;
+const VERIFY_SCHEMES: [SignatureScheme; 10] = [
+    SignatureScheme::RSA_PSS_SHA256,
+    SignatureScheme::ECDSA_NISTP256_SHA256,
+    SignatureScheme::ED25519,
+    SignatureScheme::RSA_PSS_SHA384,
+    SignatureScheme::RSA_PSS_SHA512,
+    SignatureScheme::RSA_PKCS1_SHA256,
+    SignatureScheme::RSA_PKCS1_SHA384,
+    SignatureScheme::RSA_PKCS1_SHA512,
+    SignatureScheme::ECDSA_NISTP384_SHA384,
+    SignatureScheme::ECDSA_NISTP521_SHA512,
+];
+
+/// Immutable keys/certificate; call `config` once for each physical connection.
+#[derive(Clone)]
+pub(crate) struct MasqueTls {
+    identity: Arc<Identity>,
+    peer: PKey<Public>,
+    skip_pin: bool,
+    provider: Arc<CryptoProvider>,
+}
+
+impl fmt::Debug for MasqueTls {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("MasqueTls")
+            .field("skip_pin", &self.skip_pin)
+            .finish_non_exhaustive()
+    }
+}
+
+impl MasqueTls {
+    #[cfg(feature = "quiche-h3-transport")]
+    pub(crate) fn quiche_config(
+        &self,
+        server_name: impl Into<String>,
+    ) -> io::Result<super::QuicheTls> {
+        use boring::ssl::{SslAlert, SslVerifyError, SslVerifyMode};
+
+        let mut builder = super::QuicheTls::builder()?;
+        let certificate = parsed_certificate(&self.identity.certificate)
+            .map_err(|_| io::Error::other("cannot create MASQUE QUIC TLS configuration"))?;
+        builder
+            .set_certificate(&certificate)
+            .map_err(|_| io::Error::other("cannot set MASQUE QUIC certificate"))?;
+        builder
+            .set_private_key(&self.identity.key)
+            .map_err(|_| io::Error::other("cannot set MASQUE QUIC identity"))?;
+        builder
+            .check_private_key()
+            .map_err(|_| io::Error::other("invalid MASQUE QUIC identity"))?;
+        let verifier = MasqueVerifier {
+            peer: self.peer.clone(),
+            skip_pin: self.skip_pin,
+            version: Arc::new(AtomicU8::new(VERSION_13)),
+        };
+        builder.set_custom_verify_callback(SslVerifyMode::PEER, move |ssl| {
+            let reject = || SslVerifyError::Invalid(SslAlert::BAD_CERTIFICATE);
+            let certificates = super::quiche_tls::peer_certificates(ssl).map_err(|_| reject())?;
+            let (leaf, rest) = certificates.split_first().ok_or_else(reject)?;
+            verifier.verify_chain(leaf, rest).map_err(|_| reject())
+        });
+        super::QuicheTls::from_builder(
+            builder,
+            server_name.into(),
+            vec![b"h3".to_vec()],
+            Some(b"h3".to_vec()),
+            None,
+        )
+    }
+
+    pub(crate) fn new(
+        private_b64: &str,
+        public_b64: &str,
+        skip: bool,
+        context: &SecurityContext,
+    ) -> io::Result<Self> {
+        let (key, identity_curve, peer) = keys(private_b64, public_b64)?;
+        let spki = key
+            .public_key_to_der()
+            .map_err(|_| invalid("invalid MASQUE ECDSA private key"))?;
+        let certificate = certificate(&key, identity_curve)?;
+
+        Ok(Self {
+            identity: Arc::new(Identity {
+                key,
+                curve: identity_curve,
+                spki,
+                certificate,
+            }),
+            peer,
+            skip_pin: skip,
+            provider: context.provider.clone(),
+        })
+    }
+
+    /// QUIC is TLS 1.3 only. HTTP/2 can negotiate either version, so its
+    /// signer and verifier share state unique to this returned configuration.
+    pub(crate) fn config(&self, quic: bool) -> io::Result<Arc<ClientConfig>> {
+        let version = Arc::new(AtomicU8::new(if quic {
+            VERSION_13
+        } else {
+            UNKNOWN_VERSION
+        }));
+        let verifier = Arc::new(MasqueVerifier {
+            peer: self.peer.clone(),
+            skip_pin: self.skip_pin,
+            version: version.clone(),
+        });
+        let key = CertifiedKey::new(
+            vec![self.identity.certificate.clone()],
+            Arc::new(IdentityKey {
+                identity: self.identity.clone(),
+                version,
+            }),
+        );
+        let versions: &[&'static rustls::SupportedProtocolVersion] =
+            if quic { &[&TLS13] } else { &[&TLS13, &TLS12] };
+        let mut config = ClientConfig::builder_with_provider(self.provider.clone())
+            .with_protocol_versions(versions)
+            .map_err(|_| io::Error::other("cannot create MASQUE TLS configuration"))?
+            .dangerous()
+            .with_custom_certificate_verifier(verifier)
+            .with_client_cert_resolver(Arc::new(SingleCertAndKey::from(key)));
+        config.alpn_protocols = vec![if quic { b"h3".to_vec() } else { b"h2".to_vec() }];
+        config.resumption = Resumption::disabled();
+        config.enable_early_data = false;
+        Ok(Arc::new(config))
+    }
+}
+
+/// Configuration validation parses the immutable material without reading
+/// time, generating a certificate, or acquiring runtime resources.
+pub(crate) fn validate_keys(private_b64: &str, public_b64: &str) -> io::Result<()> {
+    keys(private_b64, public_b64).map(|_| ())
+}
+
+fn keys(private_b64: &str, public_b64: &str) -> io::Result<(PKey<Private>, Curve, PKey<Public>)> {
+    let private_der = decode_key(private_b64)?;
+    let ec = sec1_private_key(&private_der)?;
+    let key = PKey::from_ec_key(ec).map_err(|_| invalid("invalid MASQUE ECDSA private key"))?;
+    let identity_curve = curve(&key)?;
+    let public_der = decode_key(public_b64)?;
+    complete_der_sequence(&public_der).map_err(|_| invalid("invalid MASQUE SPKI public key"))?;
+    let peer = PKey::public_key_from_der(&public_der)
+        .map_err(|_| invalid("invalid MASQUE SPKI public key"))?;
+    curve(&peer)?;
+    Ok((key, identity_curve, peer))
+}
+
+struct Identity {
+    key: PKey<Private>,
+    curve: Curve,
+    spki: Vec<u8>,
+    certificate: CertificateDer<'static>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum Curve {
+    P224,
+    P256,
+    P384,
+    P521,
+}
+
+impl Curve {
+    fn tls13_scheme(self) -> Option<SignatureScheme> {
+        match self {
+            Self::P224 => None,
+            Self::P256 => Some(SignatureScheme::ECDSA_NISTP256_SHA256),
+            Self::P384 => Some(SignatureScheme::ECDSA_NISTP384_SHA384),
+            Self::P521 => Some(SignatureScheme::ECDSA_NISTP521_SHA512),
+        }
+    }
+    fn certificate_digest(self) -> MessageDigest {
+        match self {
+            Self::P224 | Self::P256 => MessageDigest::sha256(),
+            Self::P384 => MessageDigest::sha384(),
+            Self::P521 => MessageDigest::sha512(),
+        }
+    }
+}
+
+fn curve<T: HasPublic>(key: &PKeyRef<T>) -> io::Result<Curve> {
+    let ec = key
+        .ec_key()
+        .map_err(|_| invalid("MASQUE key must be ECDSA"))?;
+    match ec.group().curve_name() {
+        Some(Nid::SECP224R1) => Ok(Curve::P224),
+        Some(Nid::X9_62_PRIME256V1) => Ok(Curve::P256),
+        Some(Nid::SECP384R1) => Ok(Curve::P384),
+        Some(Nid::SECP521R1) => Ok(Curve::P521),
+        _ => Err(invalid("unsupported MASQUE ECDSA curve")),
+    }
+}
+
+fn decode_key(encoded: &str) -> io::Result<Zeroizing<Vec<u8>>> {
+    if encoded.len() > crate::config::MAX_CONFIG_BYTES {
+        return Err(invalid("MASQUE key exceeds configuration bound"));
+    }
+    let cleaned = Zeroizing::new(
+        encoded
+            .bytes()
+            .filter(|b| !matches!(b, b'\r' | b'\n'))
+            .collect::<Vec<_>>(),
+    );
+    let engine = general_purpose::GeneralPurpose::new(
+        &alphabet::STANDARD,
+        general_purpose::GeneralPurposeConfig::new().with_decode_allow_trailing_bits(true),
+    );
+    engine
+        .decode(cleaned.as_slice())
+        .map(Zeroizing::new)
+        .map_err(|_| invalid("invalid MASQUE key base64"))
+}
+
+fn named_curve(oid: &[u8]) -> Option<Nid> {
+    match oid {
+        [0x2b, 0x81, 0x04, 0, 0x21] => Some(Nid::SECP224R1),
+        [0x2a, 0x86, 0x48, 0xce, 0x3d, 3, 1, 7] => Some(Nid::X9_62_PRIME256V1),
+        [0x2b, 0x81, 0x04, 0, 0x22] => Some(Nid::SECP384R1),
+        [0x2b, 0x81, 0x04, 0, 0x23] => Some(Nid::SECP521R1),
+        _ => None,
+    }
+}
+
+/// Go's SEC1 consumer derives the public point from the scalar, ignoring the
+/// optional encoded point. It also tolerates scalar zero padding and a suffix.
+fn sec1_private_key(der: &[u8]) -> io::Result<EcKey<Private>> {
+    let parse = || -> Result<EcKey<Private>, Error> {
+        let mut der = der;
+        let mut fields = der_value(&mut der, 0x30)?;
+        if der_value(&mut fields, 2)? != [1] {
+            return Err(bad_encoding());
+        }
+        let mut scalar = der_value(&mut fields, 4)?;
+        let mut parameters = der_value(&mut fields, 0xa0)?;
+        let nid = named_curve(der_value(&mut parameters, 6)?).ok_or_else(bad_encoding)?;
+        if fields.first() == Some(&0xa1) {
+            let mut public = der_value(&mut fields, 0xa1)?;
+            let bits = der_value(&mut public, 3)?;
+            let unused = *bits.first().ok_or_else(bad_encoding)?;
+            if unused > 7
+                || (bits.len() == 1 && unused != 0)
+                || (unused != 0 && bits.last().copied().unwrap_or(0) & ((1 << unused) - 1) != 0)
+            {
+                return Err(bad_encoding());
+            }
+        }
+        let group = EcGroup::from_curve_name(nid).map_err(|_| bad_encoding())?;
+        let size = (group.order_bits() as usize).div_ceil(8);
+        while scalar.len() > size && scalar.first() == Some(&0) {
+            scalar = &scalar[1..];
+        }
+        if scalar.len() > size {
+            return Err(bad_encoding());
+        }
+        let scalar = BigNum::from_slice(scalar).map_err(|_| bad_encoding())?;
+        let mut context = BigNumContext::new().map_err(|_| bad_encoding())?;
+        let mut order = BigNum::new().map_err(|_| bad_encoding())?;
+        group
+            .order(&mut order, &mut context)
+            .map_err(|_| bad_encoding())?;
+        if scalar.num_bits() == 0 || scalar.ucmp(&order) != std::cmp::Ordering::Less {
+            return Err(bad_encoding());
+        }
+        let mut point = EcPoint::new(&group).map_err(|_| bad_encoding())?;
+        point
+            .mul_generator(&group, &scalar, &mut context)
+            .map_err(|_| bad_encoding())?;
+        let key =
+            EcKey::from_private_components(&group, &scalar, &point).map_err(|_| bad_encoding())?;
+        key.check_key().map_err(|_| bad_encoding())?;
+        Ok(key)
+    };
+    parse().map_err(|_| invalid("invalid MASQUE SEC1 private key"))
+}
+
+fn certificate(key: &PKeyRef<Private>, curve: Curve) -> io::Result<CertificateDer<'static>> {
+    let now = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map_err(|_| io::Error::other("cannot read MASQUE certificate time"))?
+        .as_secs();
+    let not_before =
+        i64::try_from(now).map_err(|_| io::Error::other("invalid MASQUE certificate time"))?;
+    let not_after = not_before
+        .checked_add(24 * 60 * 60)
+        .ok_or_else(|| io::Error::other("invalid MASQUE certificate time"))?;
+    let build = || -> Result<Vec<u8>, boring::error::ErrorStack> {
+        let mut cert = X509::builder()?;
+        cert.set_version(2)?;
+        let serial = BigNum::from_u32(0)?.to_asn1_integer()?;
+        cert.set_serial_number(&serial)?;
+        let name = X509Name::builder()?.build();
+        cert.set_subject_name(&name)?;
+        cert.set_issuer_name(&name)?;
+        let not_before = Asn1Time::from_unix(not_before)?;
+        let not_after = Asn1Time::from_unix(not_after)?;
+        cert.set_not_before(&not_before)?;
+        cert.set_not_after(&not_after)?;
+        cert.set_pubkey(key)?;
+        cert.sign(key, curve.certificate_digest())?;
+        cert.build().to_der()
+    };
+    build()
+        .map(CertificateDer::from)
+        .map_err(|_| io::Error::other("cannot create MASQUE client certificate"))
+}
+
+/// The safe Boring decoders permit a suffix. Go's SPKI/certificate parsers
+/// consume one complete DER value; SEC1 deliberately retains its own parser.
+fn der_value<'a>(der: &mut &'a [u8], tag: u8) -> Result<&'a [u8], Error> {
+    let input = *der;
+    if der.first() != Some(&tag) {
+        return Err(bad_encoding());
+    }
+    let first = *der.get(1).ok_or_else(bad_encoding)?;
+    let (header, length) = if first < 128 {
+        (2, first as usize)
+    } else {
+        let count = (first & 127) as usize;
+        if count == 0 || count > size_of::<usize>() {
+            return Err(bad_encoding());
+        }
+        let bytes = der.get(2..2 + count).ok_or_else(bad_encoding)?;
+        if bytes.first() == Some(&0) {
+            return Err(bad_encoding());
+        }
+        let length = bytes
+            .iter()
+            .try_fold(0usize, |v, b| v.checked_mul(256)?.checked_add(*b as usize))
+            .ok_or_else(bad_encoding)?;
+        if length < 128 {
+            return Err(bad_encoding());
+        }
+        (2 + count, length)
+    };
+    let end = header.checked_add(length).ok_or_else(bad_encoding)?;
+    let value = input.get(header..end).ok_or_else(bad_encoding)?;
+    *der = &input[end..];
+    Ok(value)
+}
+
+fn complete_der_sequence(mut der: &[u8]) -> Result<(), Error> {
+    der_value(&mut der, 0x30)?;
+    if !der.is_empty() {
+        return Err(bad_encoding());
+    }
+    Ok(())
+}
+
+fn parsed_certificate(der: &CertificateDer<'_>) -> Result<X509, Error> {
+    complete_der_sequence(der.as_ref())?;
+    X509::from_der(der.as_ref()).map_err(|_| bad_encoding())
+}
+
+fn invalid(message: &'static str) -> io::Error {
+    io::Error::new(io::ErrorKind::InvalidInput, message)
+}
+fn bad_encoding() -> Error {
+    Error::InvalidCertificate(CertificateError::BadEncoding)
+}
+fn bad_signature() -> Error {
+    Error::InvalidCertificate(CertificateError::BadSignature)
+}
+fn unsupported_signature() -> Error {
+    Error::General("unsupported MASQUE handshake signature".into())
+}
+
+struct MasqueVerifier {
+    peer: PKey<Public>,
+    skip_pin: bool,
+    version: Arc<AtomicU8>,
+}
+
+impl fmt::Debug for MasqueVerifier {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("MasqueVerifier")
+            .field("skip_pin", &self.skip_pin)
+            .finish_non_exhaustive()
+    }
+}
+
+impl MasqueVerifier {
+    fn verify_chain(
+        &self,
+        leaf: &CertificateDer<'_>,
+        chain: &[CertificateDer<'_>],
+    ) -> Result<(), Error> {
+        for der in std::iter::once(leaf).chain(chain) {
+            let cert = parsed_certificate(der)?;
+            if !self.skip_pin {
+                let key = cert.public_key().map_err(|_| bad_encoding())?;
+                if key.id() != Id::EC || !key.public_eq(&self.peer) {
+                    return Err(Error::General(
+                        "MASQUE peer certificate public key does not match".into(),
+                    ));
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn verify_and_publish(
+        &self,
+        message: &[u8],
+        cert: &CertificateDer<'_>,
+        dss: &DigitallySignedStruct,
+        version: u8,
+    ) -> Result<HandshakeSignatureValid, Error> {
+        verify_signature(message, cert, dss.scheme, dss.signature(), version)?;
+        match self.version.compare_exchange(
+            UNKNOWN_VERSION,
+            version,
+            Ordering::Release,
+            Ordering::Acquire,
+        ) {
+            Ok(_) => {}
+            Err(previous) if previous == version => {}
+            Err(_) => {
+                return Err(Error::General(
+                    "MASQUE TLS version changed during handshake".into(),
+                ));
+            }
+        }
+        Ok(HandshakeSignatureValid::assertion())
+    }
+}
+
+impl ServerCertVerifier for MasqueVerifier {
+    fn verify_server_cert(
+        &self,
+        leaf: &CertificateDer<'_>,
+        chain: &[CertificateDer<'_>],
+        _name: &ServerName<'_>,
+        _ocsp: &[u8],
+        _now: UnixTime,
+    ) -> Result<ServerCertVerified, Error> {
+        self.verify_chain(leaf, chain)?;
+        Ok(ServerCertVerified::assertion())
+    }
+    fn verify_tls12_signature(
+        &self,
+        message: &[u8],
+        cert: &CertificateDer<'_>,
+        dss: &DigitallySignedStruct,
+    ) -> Result<HandshakeSignatureValid, Error> {
+        self.verify_and_publish(message, cert, dss, VERSION_12)
+    }
+    fn verify_tls13_signature(
+        &self,
+        message: &[u8],
+        cert: &CertificateDer<'_>,
+        dss: &DigitallySignedStruct,
+    ) -> Result<HandshakeSignatureValid, Error> {
+        self.verify_and_publish(message, cert, dss, VERSION_13)
+    }
+    fn supported_verify_schemes(&self) -> Vec<SignatureScheme> {
+        VERIFY_SCHEMES
+            .into_iter()
+            .filter(|scheme| {
+                self.version.load(Ordering::Acquire) != VERSION_13 || !rsa_pkcs1(*scheme)
+            })
+            .collect()
+    }
+}
+
+fn ecdsa_digest(scheme: SignatureScheme) -> Option<MessageDigest> {
+    match scheme {
+        SignatureScheme::ECDSA_NISTP256_SHA256 => Some(MessageDigest::sha256()),
+        SignatureScheme::ECDSA_NISTP384_SHA384 => Some(MessageDigest::sha384()),
+        SignatureScheme::ECDSA_NISTP521_SHA512 => Some(MessageDigest::sha512()),
+        _ => None,
+    }
+}
+
+fn rsa_pkcs1(scheme: SignatureScheme) -> bool {
+    matches!(
+        scheme,
+        SignatureScheme::RSA_PKCS1_SHA256
+            | SignatureScheme::RSA_PKCS1_SHA384
+            | SignatureScheme::RSA_PKCS1_SHA512
+    )
+}
+
+fn rsa_digest(scheme: SignatureScheme) -> Option<MessageDigest> {
+    match scheme {
+        SignatureScheme::RSA_PSS_SHA256 | SignatureScheme::RSA_PKCS1_SHA256 => {
+            Some(MessageDigest::sha256())
+        }
+        SignatureScheme::RSA_PSS_SHA384 | SignatureScheme::RSA_PKCS1_SHA384 => {
+            Some(MessageDigest::sha384())
+        }
+        SignatureScheme::RSA_PSS_SHA512 | SignatureScheme::RSA_PKCS1_SHA512 => {
+            Some(MessageDigest::sha512())
+        }
+        _ => None,
+    }
+}
+
+fn verify_signature(
+    message: &[u8],
+    cert: &CertificateDer<'_>,
+    scheme: SignatureScheme,
+    signature: &[u8],
+    version: u8,
+) -> Result<(), Error> {
+    if !matches!(version, VERSION_12 | VERSION_13) {
+        return Err(unsupported_signature());
+    }
+    let key = parsed_certificate(cert)?
+        .public_key()
+        .map_err(|_| bad_encoding())?;
+    let native = match key.id() {
+        Id::EC => {
+            let digest = ecdsa_digest(scheme).ok_or_else(unsupported_signature)?;
+            let key_curve = curve(&key).map_err(|_| unsupported_signature())?;
+            if version == VERSION_13 && key_curve.tls13_scheme() != Some(scheme) {
+                return Err(unsupported_signature());
+            }
+            Verifier::new(digest, &key).map_err(|_| bad_signature())?
+        }
+        Id::RSA => {
+            let digest = rsa_digest(scheme).ok_or_else(unsupported_signature)?;
+            if version == VERSION_13 && rsa_pkcs1(scheme) {
+                return Err(unsupported_signature());
+            }
+            let mut verifier = Verifier::new(digest, &key).map_err(|_| bad_signature())?;
+            if rsa_pkcs1(scheme) {
+                verifier
+                    .set_rsa_padding(Padding::PKCS1)
+                    .map_err(|_| bad_signature())?;
+            } else {
+                verifier
+                    .set_rsa_padding(Padding::PKCS1_PSS)
+                    .map_err(|_| bad_signature())?;
+                verifier
+                    .set_rsa_pss_saltlen(RsaPssSaltlen::DIGEST_LENGTH)
+                    .map_err(|_| bad_signature())?;
+                verifier
+                    .set_rsa_mgf1_md(digest)
+                    .map_err(|_| bad_signature())?;
+            }
+            verifier
+        }
+        Id::ED25519 if scheme == SignatureScheme::ED25519 => {
+            Verifier::new_without_digest(&key).map_err(|_| bad_signature())?
+        }
+        _ => return Err(unsupported_signature()),
+    };
+    let mut native = native;
+    if native
+        .verify_oneshot(signature, message)
+        .map_err(|_| bad_signature())?
+    {
+        Ok(())
+    } else {
+        Err(bad_signature())
+    }
+}
+
+struct IdentityKey {
+    identity: Arc<Identity>,
+    version: Arc<AtomicU8>,
+}
+impl fmt::Debug for IdentityKey {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("MasqueIdentityKey").finish_non_exhaustive()
+    }
+}
+
+impl SigningKey for IdentityKey {
+    fn choose_scheme(&self, offered: &[SignatureScheme]) -> Option<Box<dyn Signer>> {
+        let version = self.version.load(Ordering::Acquire);
+        let mut candidates = [None; 3];
+        let mut count = 0;
+        for scheme in offered.iter().copied() {
+            if ecdsa_digest(scheme).is_none() || candidates.contains(&Some(scheme)) {
+                continue;
+            }
+            if version == VERSION_13 && self.identity.curve.tls13_scheme() != Some(scheme) {
+                continue;
+            }
+            candidates[count] = Some(scheme);
+            count += 1;
+        }
+        if count == 0 {
+            return None;
+        }
+        Some(Box::new(DeferredSigner {
+            identity: self.identity.clone(),
+            version: self.version.clone(),
+            candidates,
+            selected: OnceLock::new(),
+        }))
+    }
+    fn public_key(&self) -> Option<SubjectPublicKeyInfoDer<'_>> {
+        Some(self.identity.spki.as_slice().into())
+    }
+    fn algorithm(&self) -> SignatureAlgorithm {
+        SignatureAlgorithm::ECDSA
+    }
+}
+
+struct DeferredSigner {
+    identity: Arc<Identity>,
+    version: Arc<AtomicU8>,
+    candidates: [Option<SignatureScheme>; 3],
+    selected: OnceLock<Result<SignatureScheme, ()>>,
+}
+impl fmt::Debug for DeferredSigner {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("MasqueDeferredSigner")
+            .finish_non_exhaustive()
+    }
+}
+impl DeferredSigner {
+    fn selection(&self) -> Result<SignatureScheme, ()> {
+        *self.selected.get_or_init(|| {
+            let version = self.version.load(Ordering::Acquire);
+            if !matches!(version, VERSION_12 | VERSION_13) {
+                return Err(());
+            }
+            self.candidates
+                .iter()
+                .copied()
+                .flatten()
+                .find(|scheme| {
+                    version == VERSION_12 || self.identity.curve.tls13_scheme() == Some(*scheme)
+                })
+                .ok_or(())
+        })
+    }
+}
+impl Signer for DeferredSigner {
+    fn sign(&self, message: &[u8]) -> Result<Vec<u8>, Error> {
+        let scheme = self.selection().map_err(|_| unsupported_signature())?;
+        let digest = ecdsa_digest(scheme).ok_or_else(unsupported_signature)?;
+        let mut signer =
+            NativeSigner::new(digest, &self.identity.key).map_err(|_| bad_signature())?;
+        signer
+            .sign_oneshot_to_vec(message)
+            .map_err(|_| bad_signature())
+    }
+    fn scheme(&self) -> SignatureScheme {
+        // rustls asks for the scheme before `sign`. A premature/unsupported
+        // selection seals an error; `sign` fails before rustls emits a message.
+        self.selection()
+            .unwrap_or(SignatureScheme::ECDSA_NISTP256_SHA256)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use base64::engine::general_purpose::STANDARD;
+    use boring::{ec::EcGroup, rsa::Rsa};
+    use rustls::{
+        DistinguishedName, ProtocolVersion, ServerConfig,
+        pki_types::PrivateKeyDer,
+        server::danger::{ClientCertVerified, ClientCertVerifier},
+    };
+    use std::{sync::Mutex, time::Duration};
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+    use tokio_rustls::{TlsAcceptor, TlsConnector};
+
+    fn ec_key(nid: Nid) -> PKey<Private> {
+        PKey::from_ec_key(EcKey::generate(&EcGroup::from_curve_name(nid).unwrap()).unwrap())
+            .unwrap()
+    }
+
+    fn factory(client: &PKey<Private>, peer: &PKey<Private>, skip: bool) -> MasqueTls {
+        MasqueTls::new(
+            &STANDARD.encode(client.ec_key().unwrap().private_key_to_der().unwrap()),
+            &STANDARD.encode(peer.public_key_to_der().unwrap()),
+            skip,
+            &SecurityContext::new(),
+        )
+        .unwrap()
+    }
+
+    fn verifier(peer: &PKey<Private>, skip: bool, version: u8) -> MasqueVerifier {
+        MasqueVerifier {
+            peer: PKey::public_key_from_der(&peer.public_key_to_der().unwrap()).unwrap(),
+            skip_pin: skip,
+            version: Arc::new(AtomicU8::new(version)),
+        }
+    }
+
+    fn identity_key(factory: &MasqueTls, version: u8) -> IdentityKey {
+        IdentityKey {
+            identity: factory.identity.clone(),
+            version: Arc::new(AtomicU8::new(version)),
+        }
+    }
+
+    fn der(tag: u8, content: &[u8]) -> Vec<u8> {
+        let mut output = vec![tag];
+        if content.len() < 128 {
+            output.push(content.len() as u8);
+        } else if content.len() < 256 {
+            output.extend_from_slice(&[0x81, content.len() as u8]);
+        } else {
+            output.push(0x82);
+            output.extend_from_slice(&(content.len() as u16).to_be_bytes());
+        }
+        output.extend_from_slice(content);
+        output
+    }
+
+    #[test]
+    fn sec1_spki_curves_and_certificate_contract() {
+        for nid in [
+            Nid::SECP224R1,
+            Nid::X9_62_PRIME256V1,
+            Nid::SECP384R1,
+            Nid::SECP521R1,
+        ] {
+            let key = ec_key(nid);
+            let mut private = key.ec_key().unwrap().private_key_to_der().unwrap();
+            // Go's SEC1 parser ignores a suffix, unlike its public-key parser.
+            private.push(0);
+            let private = STANDARD.encode(private);
+            let public = STANDARD.encode(key.public_key_to_der().unwrap());
+            let client = MasqueTls::new(
+                &format!("\r\n{private}\n"),
+                &public,
+                true,
+                &SecurityContext::new(),
+            )
+            .unwrap();
+            let cert = parsed_certificate(&client.identity.certificate).unwrap();
+            assert_eq!(
+                cert.serial_number()
+                    .to_bn()
+                    .unwrap()
+                    .to_dec_str()
+                    .unwrap()
+                    .to_string(),
+                "0"
+            );
+            assert_eq!(cert.subject_name().entries().count(), 0);
+            assert_eq!(cert.issuer_name().entries().count(), 0);
+            let validity = cert.not_before().diff(cert.not_after()).unwrap();
+            assert_eq!((validity.days, validity.secs), (1, 0));
+            assert!(cert.public_key().unwrap().public_eq(&key));
+            assert!(!format!("{client:?}").contains(&private));
+
+            let encoded = key.ec_key().unwrap().private_key_to_der().unwrap();
+            let mut input = encoded.as_slice();
+            let mut fields = der_value(&mut input, 0x30).unwrap();
+            der_value(&mut fields, 2).unwrap();
+            let scalar = der_value(&mut fields, 4).unwrap();
+            let parameters = der_value(&mut fields, 0xa0).unwrap();
+            let mut padded = vec![0, 0];
+            padded.extend_from_slice(scalar);
+            let mut rewritten = der(2, &[1]);
+            rewritten.extend(der(4, &padded));
+            rewritten.extend(der(0xa0, parameters));
+            // A syntactically valid bitstring need not contain the scalar's
+            // actual point: the reference derives that point independently.
+            rewritten.extend(der(0xa1, &der(3, &[0, 0xff])));
+            let imported = sec1_private_key(&der(0x30, &rewritten)).unwrap();
+            assert!(PKey::from_ec_key(imported).unwrap().public_eq(&key));
+
+            let pkcs8 = STANDARD.encode(key.private_key_to_der_pkcs8().unwrap());
+            assert!(MasqueTls::new(&pkcs8, &public, false, &SecurityContext::new()).is_err());
+            let mut extra = key.public_key_to_der().unwrap();
+            extra.push(0);
+            assert!(
+                MasqueTls::new(
+                    &private,
+                    &STANDARD.encode(extra),
+                    true,
+                    &SecurityContext::new()
+                )
+                .is_err()
+            );
+        }
+        let ec = ec_key(Nid::X9_62_PRIME256V1);
+        let rsa = PKey::from_rsa(Rsa::generate(1024).unwrap()).unwrap();
+        let private = STANDARD.encode(ec.ec_key().unwrap().private_key_to_der().unwrap());
+        assert!(
+            MasqueTls::new(
+                &private,
+                &STANDARD.encode(rsa.public_key_to_der().unwrap()),
+                true,
+                &SecurityContext::new()
+            )
+            .is_err()
+        );
+        assert_eq!(decode_key("Zh==\r\n").unwrap().as_slice(), b"f");
+        assert!(decode_key("Zg== ").is_err());
+        assert!(decode_key("Zg").is_err());
+    }
+
+    #[test]
+    fn pin_requires_every_chain_key_and_skip_still_parses_der() {
+        let peer = ec_key(Nid::SECP521R1);
+        let other = ec_key(Nid::X9_62_PRIME256V1);
+        let rsa = PKey::from_rsa(Rsa::generate(1024).unwrap()).unwrap();
+        let leaf = certificate(&peer, Curve::P521).unwrap();
+        let same = certificate(&peer, Curve::P521).unwrap();
+        let different = certificate(&other, Curve::P256).unwrap();
+        let rsa_cert = certificate(&rsa, Curve::P256).unwrap();
+        let pinned = verifier(&peer, false, UNKNOWN_VERSION);
+        assert!(pinned.verify_chain(&leaf, &[same]).is_ok());
+        assert!(pinned.verify_chain(&leaf, &[different.clone()]).is_err());
+        assert!(pinned.verify_chain(&leaf, &[rsa_cert.clone()]).is_err());
+        assert!(pinned.verify_chain(&different, &[]).is_err());
+        let skipped = verifier(&peer, true, UNKNOWN_VERSION);
+        assert!(skipped.verify_chain(&rsa_cert, &[different]).is_ok());
+        assert!(
+            skipped
+                .verify_chain(&leaf, &[CertificateDer::from(vec![0x30, 0])])
+                .is_err()
+        );
+        let mut trailing = leaf.as_ref().to_vec();
+        trailing.push(0);
+        assert!(
+            skipped
+                .verify_chain(&CertificateDer::from(trailing), &[])
+                .is_err()
+        );
+        // No DNS-name, CA, or time policy is applied to a matching key.
+        assert!(
+            pinned
+                .verify_server_cert(
+                    &leaf,
+                    &[],
+                    &ServerName::try_from("different.invalid").unwrap(),
+                    &[],
+                    UnixTime::since_unix_epoch(Duration::ZERO)
+                )
+                .is_ok()
+        );
+    }
+
+    #[test]
+    fn tls12_cross_curve_hashes_and_tls13_curve_binding() {
+        let schemes = [
+            SignatureScheme::ECDSA_NISTP256_SHA256,
+            SignatureScheme::ECDSA_NISTP384_SHA384,
+            SignatureScheme::ECDSA_NISTP521_SHA512,
+        ];
+        for nid in [
+            Nid::SECP224R1,
+            Nid::X9_62_PRIME256V1,
+            Nid::SECP384R1,
+            Nid::SECP521R1,
+        ] {
+            let key = ec_key(nid);
+            let client = factory(&key, &key, false);
+            for scheme in schemes {
+                let signer = identity_key(&client, VERSION_12)
+                    .choose_scheme(&[scheme])
+                    .unwrap();
+                let signature = signer.sign(b"actual transcript").unwrap();
+                assert_eq!(signer.scheme(), scheme);
+                assert!(
+                    verify_signature(
+                        b"actual transcript",
+                        &client.identity.certificate,
+                        scheme,
+                        &signature,
+                        VERSION_12
+                    )
+                    .is_ok()
+                );
+                assert!(
+                    verify_signature(
+                        b"changed transcript",
+                        &client.identity.certificate,
+                        scheme,
+                        &signature,
+                        VERSION_12
+                    )
+                    .is_err()
+                );
+                assert_eq!(
+                    verify_signature(
+                        b"actual transcript",
+                        &client.identity.certificate,
+                        scheme,
+                        &signature,
+                        VERSION_13
+                    )
+                    .is_ok(),
+                    client.identity.curve.tls13_scheme() == Some(scheme)
+                );
+                assert_eq!(
+                    identity_key(&client, VERSION_13)
+                        .choose_scheme(&[scheme])
+                        .is_some(),
+                    client.identity.curve.tls13_scheme() == Some(scheme)
+                );
+            }
+            assert!(
+                identity_key(&client, VERSION_12)
+                    .choose_scheme(&[SignatureScheme::RSA_PSS_SHA256])
+                    .is_none()
+            );
+        }
+    }
+
+    #[test]
+    fn deferred_selection_seals_errors_and_obeys_peer_order() {
+        let key = ec_key(Nid::SECP521R1);
+        let client = factory(&key, &key, false);
+        let identity = identity_key(&client, UNKNOWN_VERSION);
+        let offered = [
+            SignatureScheme::ECDSA_NISTP384_SHA384,
+            SignatureScheme::ECDSA_NISTP256_SHA256,
+            SignatureScheme::ECDSA_NISTP521_SHA512,
+        ];
+        let early = identity.choose_scheme(&offered).unwrap();
+        let _ = early.scheme();
+        identity.version.store(VERSION_12, Ordering::Release);
+        assert!(early.sign(b"transcript").is_err());
+        let valid = identity.choose_scheme(&offered).unwrap();
+        assert_eq!(valid.scheme(), offered[0]);
+        assert!(valid.sign(b"transcript").is_ok());
+        let second = identity_key(&client, UNKNOWN_VERSION);
+        let deferred = second.choose_scheme(&offered).unwrap();
+        second.version.store(VERSION_13, Ordering::Release);
+        assert_eq!(deferred.scheme(), SignatureScheme::ECDSA_NISTP521_SHA512);
+        let invalid = identity_key(&client, UNKNOWN_VERSION);
+        let deferred = invalid.choose_scheme(&offered[..2]).unwrap();
+        invalid.version.store(VERSION_13, Ordering::Release);
+        assert!(deferred.sign(b"transcript").is_err());
+        let config1 = client.config(false).unwrap();
+        let config2 = client.config(false).unwrap();
+        assert!(!Arc::ptr_eq(&config1, &config2));
+        assert!(!Arc::ptr_eq(
+            &config1.client_auth_cert_resolver,
+            &config2.client_auth_cert_resolver
+        ));
+        assert_eq!(
+            client.config(true).unwrap().alpn_protocols,
+            [b"h3".to_vec()]
+        );
+    }
+
+    #[test]
+    fn skip_pin_preserves_rsa_and_ed25519_signature_checks() {
+        let rsa = PKey::from_rsa(Rsa::generate(1024).unwrap()).unwrap();
+        let cert = certificate(&rsa, Curve::P256).unwrap();
+        for scheme in [
+            SignatureScheme::RSA_PKCS1_SHA256,
+            SignatureScheme::RSA_PSS_SHA256,
+        ] {
+            let digest = rsa_digest(scheme).unwrap();
+            let mut signer = NativeSigner::new(digest, &rsa).unwrap();
+            if rsa_pkcs1(scheme) {
+                signer.set_rsa_padding(Padding::PKCS1).unwrap();
+            } else {
+                signer.set_rsa_padding(Padding::PKCS1_PSS).unwrap();
+                signer
+                    .set_rsa_pss_saltlen(RsaPssSaltlen::DIGEST_LENGTH)
+                    .unwrap();
+                signer.set_rsa_mgf1_md(digest).unwrap();
+            }
+            let signature = signer.sign_oneshot_to_vec(b"transcript").unwrap();
+            assert!(verify_signature(b"transcript", &cert, scheme, &signature, VERSION_12).is_ok());
+            assert_eq!(
+                verify_signature(b"transcript", &cert, scheme, &signature, VERSION_13).is_ok(),
+                !rsa_pkcs1(scheme)
+            );
+            assert!(verify_signature(b"other", &cert, scheme, &signature, VERSION_12).is_err());
+        }
+        let key = PKey::generate(Id::ED25519).unwrap();
+        let mut builder = X509::builder().unwrap();
+        builder.set_version(2).unwrap();
+        let serial = BigNum::from_u32(0).unwrap().to_asn1_integer().unwrap();
+        builder.set_serial_number(&serial).unwrap();
+        let name = X509Name::builder().unwrap().build();
+        builder.set_subject_name(&name).unwrap();
+        builder.set_issuer_name(&name).unwrap();
+        let before = Asn1Time::from_unix(0).unwrap();
+        let after = Asn1Time::from_unix(1).unwrap();
+        builder.set_not_before(&before).unwrap();
+        builder.set_not_after(&after).unwrap();
+        builder.set_pubkey(&key).unwrap();
+        // Certificate issuer trust is intentionally unrelated to the leaf's
+        // handshake key when pin verification is skipped.
+        builder.sign(&rsa, MessageDigest::sha256()).unwrap();
+        let cert = CertificateDer::from(builder.build().to_der().unwrap());
+        let signature = NativeSigner::new_without_digest(&key)
+            .unwrap()
+            .sign_oneshot_to_vec(b"transcript")
+            .unwrap();
+        assert!(
+            verify_signature(
+                b"transcript",
+                &cert,
+                SignatureScheme::ED25519,
+                &signature,
+                VERSION_13
+            )
+            .is_ok()
+        );
+        assert!(
+            verify_signature(
+                b"other",
+                &cert,
+                SignatureScheme::ED25519,
+                &signature,
+                VERSION_13
+            )
+            .is_err()
+        );
+    }
+
+    #[derive(Debug)]
+    struct ClientVerifier {
+        verifier: MasqueVerifier,
+        scheme: SignatureScheme,
+        seen: Arc<Mutex<Option<SignatureScheme>>>,
+    }
+    impl ClientCertVerifier for ClientVerifier {
+        fn root_hint_subjects(&self) -> &[DistinguishedName] {
+            &[]
+        }
+        fn verify_client_cert(
+            &self,
+            cert: &CertificateDer<'_>,
+            chain: &[CertificateDer<'_>],
+            _now: UnixTime,
+        ) -> Result<ClientCertVerified, Error> {
+            self.verifier.verify_chain(cert, chain)?;
+            Ok(ClientCertVerified::assertion())
+        }
+        fn verify_tls12_signature(
+            &self,
+            message: &[u8],
+            cert: &CertificateDer<'_>,
+            dss: &DigitallySignedStruct,
+        ) -> Result<HandshakeSignatureValid, Error> {
+            *self.seen.lock().unwrap() = Some(dss.scheme);
+            self.verifier
+                .verify_and_publish(message, cert, dss, VERSION_12)
+        }
+        fn verify_tls13_signature(
+            &self,
+            message: &[u8],
+            cert: &CertificateDer<'_>,
+            dss: &DigitallySignedStruct,
+        ) -> Result<HandshakeSignatureValid, Error> {
+            *self.seen.lock().unwrap() = Some(dss.scheme);
+            self.verifier
+                .verify_and_publish(message, cert, dss, VERSION_13)
+        }
+        fn supported_verify_schemes(&self) -> Vec<SignatureScheme> {
+            vec![self.scheme]
+        }
+    }
+
+    async fn memory_handshake(version: u8, client_scheme: SignatureScheme, rsa_peer: bool) {
+        let client_key = ec_key(Nid::SECP521R1);
+        let server_key = if rsa_peer {
+            PKey::from_rsa(Rsa::generate(2048).unwrap()).unwrap()
+        } else {
+            ec_key(Nid::SECP521R1)
+        };
+        let pin = if rsa_peer {
+            client_key.clone()
+        } else {
+            server_key.clone()
+        };
+        let client = factory(&client_key, &pin, rsa_peer);
+        let mut config = (*client.config(version == VERSION_13).unwrap()).clone();
+        if version == VERSION_12 {
+            // Restrict the memory peer instead of changing the production config.
+            config.alpn_protocols = vec![b"h2".to_vec()];
+        }
+        let server_cert = certificate(&server_key, Curve::P521).unwrap();
+        let server_signer: Arc<dyn SigningKey> = if rsa_peer {
+            rustls::crypto::ring::sign::any_supported_type(&PrivateKeyDer::Pkcs8(
+                server_key.private_key_to_der_pkcs8().unwrap().into(),
+            ))
+            .unwrap()
+        } else {
+            let server_factory = factory(&server_key, &client_key, false);
+            Arc::new(identity_key(&server_factory, version))
+        };
+        let seen = Arc::new(Mutex::new(None));
+        let server = ServerConfig::builder_with_provider(client.provider.clone())
+            .with_protocol_versions(&[if version == VERSION_12 {
+                &TLS12
+            } else {
+                &TLS13
+            }])
+            .unwrap()
+            .with_client_cert_verifier(Arc::new(ClientVerifier {
+                verifier: verifier(&client_key, false, version),
+                scheme: client_scheme,
+                seen: seen.clone(),
+            }))
+            .with_cert_resolver(Arc::new(SingleCertAndKey::from(CertifiedKey::new(
+                vec![server_cert],
+                server_signer,
+            ))));
+        let mut server = server;
+        server.alpn_protocols = config.alpn_protocols.clone();
+        let (client_io, server_io) = tokio::io::duplex(1024);
+        tokio::time::timeout(Duration::from_secs(3), async {
+            let consume = async {
+                let mut tls = TlsConnector::from(Arc::new(config))
+                    .connect(ServerName::try_from("masque.invalid").unwrap(), client_io)
+                    .await
+                    .unwrap();
+                assert_eq!(
+                    tls.get_ref().1.protocol_version(),
+                    Some(if version == VERSION_12 {
+                        ProtocolVersion::TLSv1_2
+                    } else {
+                        ProtocolVersion::TLSv1_3
+                    })
+                );
+                tls.write_all(b"ping").await.unwrap();
+                let mut reply = [0; 4];
+                tls.read_exact(&mut reply).await.unwrap();
+                assert_eq!(&reply, b"pong");
+            };
+            let serve = async {
+                let mut tls = TlsAcceptor::from(Arc::new(server))
+                    .accept(server_io)
+                    .await
+                    .unwrap();
+                let mut request = [0; 4];
+                tls.read_exact(&mut request).await.unwrap();
+                assert_eq!(&request, b"ping");
+                tls.write_all(b"pong").await.unwrap();
+            };
+            tokio::join!(consume, serve);
+        })
+        .await
+        .unwrap();
+        assert_eq!(*seen.lock().unwrap(), Some(client_scheme));
+    }
+
+    #[tokio::test]
+    async fn duplex_tls12_p521_sha256_and_tls13_p521_with_client_auth() {
+        memory_handshake(VERSION_12, SignatureScheme::ECDSA_NISTP256_SHA256, false).await;
+        memory_handshake(VERSION_13, SignatureScheme::ECDSA_NISTP521_SHA512, false).await;
+        memory_handshake(VERSION_13, SignatureScheme::ECDSA_NISTP521_SHA512, true).await;
+    }
+}
diff --git a/src/security/mod.rs b/src/security/mod.rs
index 42f206a..a01437b 100644
--- a/src/security/mod.rs
+++ b/src/security/mod.rs
@@ -6,11 +6,16 @@ mod boring;
 mod boring_resumption;
 #[cfg(feature = "tls-fingerprint")]
 mod boring_stream;
-#[cfg(feature = "outbound-vless")]
+#[cfg(feature = "stream-security")]
 mod client;
 mod context;
-#[cfg(feature = "outbound-vless")]
-mod ech;
+#[cfg(feature = "ech")]
+pub(crate) mod ech;
+mod identity;
+#[cfg(feature = "outbound-masque")]
+pub(crate) mod masque;
+#[cfg(feature = "quiche-h3-transport")]
+mod quiche_tls;
 mod resumption;
 #[cfg(feature = "shadow-tls-v3")]
 mod shadow_tls;
@@ -24,15 +29,20 @@ pub use shadow_tls::ShadowTlsClient;
 #[cfg(feature = "outbound-vless")]
 pub(crate) mod vision;
 
-#[cfg(feature = "outbound-vless")]
+#[cfg(feature = "stream-security")]
 pub use client::{REALITY_CLIENT_VERSION, SecurityClient};
 pub use context::SecurityContext;
+#[cfg(feature = "quiche-h3-transport")]
+pub(crate) use quiche_tls::QuicheTls;
 pub use stream::CLOSE_NOTIFY_TIMEOUT;
 pub use tls::{
     StandardTlsClient, TLS_RESUMPTION_SESSION_BUDGET, TlsCertificatePolicy, TlsClientIdentity,
     TlsClientOptions, TlsVersions,
 };
 
+#[cfg(all(test, feature = "stream-security"))]
+mod client_identity_tests;
+
 #[cfg(test)]
 fn test_profiles() -> &'static [Option<crate::config::ClientFingerprint>] {
     #[cfg(feature = "tls-fingerprint")]
@@ -40,10 +50,10 @@ fn test_profiles() -> &'static [Option<crate::config::ClientFingerprint>] {
         use crate::config::ClientFingerprint::*;
         &[
             None,
-            Some(Chrome120),
             Some(Chrome133),
             Some(Firefox120),
             Some(Safari16),
+            Some(Ios14),
         ]
     }
     #[cfg(not(feature = "tls-fingerprint"))]
@@ -51,3 +61,7 @@ fn test_profiles() -> &'static [Option<crate::config::ClientFingerprint>] {
         &[None]
     }
 }
+
+#[cfg(all(test, feature = "outbound-vless", feature = "tls-fingerprint"))]
+#[path = "ech_dynamic_tests.rs"]
+mod ech_dynamic_tests;
diff --git a/src/security/quiche_tls.rs b/src/security/quiche_tls.rs
new file mode 100644
index 0000000..c2907ad
--- /dev/null
+++ b/src/security/quiche_tls.rs
@@ -0,0 +1,260 @@
+//! QUIC TLS over the shared certificate policy and immutable identity material.
+//! The native backend owns handshake signatures; WebPKI still owns trust.
+use std::{io, sync::Arc};
+
+use boring::ssl::{
+    SslAlert, SslContextBuilder, SslMethod, SslOptions, SslSessionCacheMode, SslVerifyError,
+    SslVerifyMode, SslVersion,
+};
+use rustls::{
+    client::danger::ServerCertVerifier,
+    pki_types::{CertificateDer, ServerName, UnixTime},
+};
+
+use super::{SecurityContext, TlsClientOptions};
+
+const CERTIFICATE_BOUND: usize = 128 * 1024;
+
+/// A single physical connection's immutable policy and one-use TLS builder.
+/// Configure the connection before sending its first packet, then check the
+/// negotiated policy before publishing any application stream.
+pub(crate) struct QuicheTls {
+    builder: Option<SslContextBuilder>,
+    server_name: String,
+    alpn: Vec<Vec<u8>>,
+    required_alpn: Option<Vec<u8>>,
+    ech: Option<crate::config::StaticEchConfig>,
+}
+
+impl std::fmt::Debug for QuicheTls {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("QuicheTls")
+            .field("requires_ech", &self.ech.is_some())
+            .field("requires_alpn", &self.required_alpn.is_some())
+            .finish_non_exhaustive()
+    }
+}
+
+impl QuicheTls {
+    pub(super) fn standard(
+        context: &SecurityContext,
+        server_name: &str,
+        options: &TlsClientOptions,
+    ) -> io::Result<Self> {
+        let name = ServerName::try_from(server_name.to_owned()).map_err(|_| invalid())?;
+        if options.client_fingerprint.is_some() {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "client-fingerprint is not supported on QUIC",
+            ));
+        }
+        let ech = options
+            .ech
+            .as_ref()
+            .map(|ech| ech.for_backend(true))
+            .transpose()
+            .map_err(|_| io::Error::other("ECH has no compatible QUIC configuration"))?;
+        #[cfg(not(feature = "ech"))]
+        if ech.is_some() {
+            return Err(io::Error::new(
+                io::ErrorKind::Unsupported,
+                "ECH is not compiled in",
+            ));
+        }
+        if ech.as_ref().is_some_and(|ech| ech.is_dynamic()) {
+            return Err(io::Error::other(
+                "dynamic ECH requires a node resolution context",
+            ));
+        }
+        if ech.is_some() && !matches!(name, ServerName::DnsName(_)) {
+            return Err(invalid());
+        }
+        let verifier = Arc::new(super::verifier::CertificateVerifier::new(
+            context,
+            options.certificate.clone(),
+        )?);
+        let rejection_verifier =
+            super::verifier::CertificateVerifier::new(context, Default::default())?;
+        let mut builder = Self::builder()?;
+        builder.set_custom_verify_callback(SslVerifyMode::PEER, move |ssl| {
+            let reject = || SslVerifyError::Invalid(SslAlert::BAD_CERTIFICATE);
+            let certificates = peer_certificates(ssl).map_err(|_| reject())?;
+            let (leaf, rest) = certificates.split_first().ok_or_else(reject)?;
+            let outer_name = ssl.get_ech_name_override().map(|bytes| {
+                std::str::from_utf8(bytes)
+                    .ok()
+                    .and_then(|name| ServerName::try_from(name.to_owned()).ok())
+            });
+            let (verifier, name): (&dyn ServerCertVerifier, _) = match outer_name {
+                Some(Some(outer)) => (&rejection_verifier, outer),
+                Some(None) => return Err(reject()),
+                None => (verifier.as_ref(), name.clone()),
+            };
+            verifier
+                .verify_server_cert(
+                    leaf,
+                    rest,
+                    &name,
+                    ssl.ocsp_status().unwrap_or_default(),
+                    UnixTime::now(),
+                )
+                .map(|_| ())
+                .map_err(|_| reject())
+        });
+        if let Some(identity) = &options.identity {
+            let snapshot = identity.native_snapshot()?;
+            let identity = &snapshot.material;
+            let size = identity
+                .certificates
+                .iter()
+                .try_fold(identity.key.secret_der().len(), |size, cert| {
+                    size.checked_add(cert.len())
+                });
+            if size.is_none_or(|size| size > crate::config::MAX_CONFIG_BYTES) {
+                return Err(invalid());
+            }
+            let native = snapshot.native.as_ref().ok_or_else(invalid)?;
+            let (leaf, rest) = native.certificates.split_first().ok_or_else(invalid)?;
+            builder.set_certificate(leaf).map_err(|_| invalid())?;
+            for cert in rest {
+                builder
+                    .add_extra_chain_cert(cert.clone())
+                    .map_err(|_| invalid())?;
+            }
+            builder
+                .set_private_key(&native.key)
+                .map_err(|_| invalid())?;
+            builder.check_private_key().map_err(|_| invalid())?;
+        }
+        Self::from_builder(
+            builder,
+            server_name.to_owned(),
+            options.alpn.clone(),
+            options.required_alpn.clone(),
+            ech,
+        )
+    }
+
+    pub(super) fn builder() -> io::Result<SslContextBuilder> {
+        let mut builder = SslContextBuilder::new(SslMethod::tls()).map_err(|_| invalid())?;
+        builder
+            .set_min_proto_version(Some(SslVersion::TLS1_3))
+            .map_err(|_| invalid())?;
+        builder
+            .set_max_proto_version(Some(SslVersion::TLS1_3))
+            .map_err(|_| invalid())?;
+        builder.set_session_cache_mode(SslSessionCacheMode::OFF);
+        builder.set_options(SslOptions::NO_TICKET);
+        Ok(builder)
+    }
+
+    pub(super) fn from_builder(
+        builder: SslContextBuilder,
+        server_name: String,
+        alpn: Vec<Vec<u8>>,
+        required_alpn: Option<Vec<u8>>,
+        ech: Option<crate::config::StaticEchConfig>,
+    ) -> io::Result<Self> {
+        ServerName::try_from(server_name.clone()).map_err(|_| invalid())?;
+        if alpn.is_empty()
+            || alpn
+                .iter()
+                .any(|protocol| !(1..=255).contains(&protocol.len()))
+            || required_alpn
+                .as_ref()
+                .is_some_and(|required| !alpn.contains(required))
+        {
+            return Err(invalid());
+        }
+        Ok(Self {
+            builder: Some(builder),
+            server_name,
+            alpn,
+            required_alpn,
+            ech,
+        })
+    }
+
+    pub(crate) fn server_name(&self) -> &str {
+        &self.server_name
+    }
+
+    pub(crate) fn build_config(&mut self) -> io::Result<quiche::Config> {
+        let builder = self
+            .builder
+            .take()
+            .ok_or_else(|| io::Error::other("QUIC TLS configuration was already consumed"))?;
+        let mut config =
+            quiche::Config::with_boring_ssl_ctx_builder(quiche::PROTOCOL_VERSION, builder)
+                .map_err(|_| invalid())?;
+        let alpn = self.alpn.iter().map(Vec::as_slice).collect::<Vec<_>>();
+        config
+            .set_application_protos(&alpn)
+            .map_err(|_| invalid())?;
+        Ok(config)
+    }
+
+    pub(crate) fn prepare_connection<F: quiche::BufFactory>(
+        &self,
+        connection: &mut quiche::Connection<F>,
+    ) -> io::Result<()> {
+        #[cfg(feature = "ech")]
+        if let Some(ech) = &self.ech {
+            connection
+                .as_mut()
+                .set_ech_config_list(ech.as_bytes())
+                .map_err(|_| invalid())?;
+        }
+        #[cfg(not(feature = "ech"))]
+        let _ = connection;
+        Ok(())
+    }
+
+    pub(crate) fn check_handshake<F: quiche::BufFactory>(
+        &self,
+        connection: &mut quiche::Connection<F>,
+    ) -> io::Result<()> {
+        if !connection.is_established() {
+            return Err(io::Error::other("QUIC TLS handshake is incomplete"));
+        }
+        if self.ech.is_some() && !connection.as_mut().ech_accepted() {
+            return Err(io::Error::other("TLS ECH was not accepted"));
+        }
+        if self
+            .required_alpn
+            .as_ref()
+            .is_some_and(|required| connection.application_proto() != required.as_slice())
+        {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidData,
+                "TLS server did not negotiate the required ALPN",
+            ));
+        }
+        Ok(())
+    }
+}
+
+pub(super) fn peer_certificates(
+    ssl: &boring::ssl::SslRef,
+) -> io::Result<Vec<CertificateDer<'static>>> {
+    let chain = ssl.peer_cert_chain().ok_or_else(invalid)?;
+    let mut size = 0_usize;
+    chain
+        .iter()
+        .map(|certificate| {
+            let der = certificate.to_der().map_err(|_| invalid())?;
+            size = size.checked_add(der.len()).ok_or_else(invalid)?;
+            if size > CERTIFICATE_BOUND {
+                return Err(invalid());
+            }
+            Ok(CertificateDer::from(der))
+        })
+        .collect()
+}
+
+fn invalid() -> io::Error {
+    io::Error::new(
+        io::ErrorKind::InvalidInput,
+        "invalid QUIC TLS configuration",
+    )
+}
diff --git a/src/security/resumption.rs b/src/security/resumption.rs
index a606855..84c7e8b 100644
--- a/src/security/resumption.rs
+++ b/src/security/resumption.rs
@@ -1,6 +1,10 @@
 //! Exact per-node ticket bounds within the runtime's aggregate session budget.
 //! A node has one immutable SNI and verifier; caches never cross node policies.
-use std::{collections::VecDeque, sync::Mutex};
+use super::identity::IdentityEpoch;
+use std::{
+    collections::VecDeque,
+    sync::{Arc, Mutex, MutexGuard},
+};
 
 use rustls::{
     NamedGroup,
@@ -9,6 +13,7 @@ use rustls::{
 };
 
 struct State {
+    generation: u64,
     hint: Option<NamedGroup>,
     tls12: Option<Tls12ClientSessionValue>,
     tickets: VecDeque<Tls13ClientSessionValue>,
@@ -41,61 +46,106 @@ impl NodeSessionStore {
             name,
             capacity,
             state: Mutex::new(State {
+                generation: 0,
                 hint: None,
                 tls12: None,
                 tickets: VecDeque::with_capacity(capacity),
             }),
         }
     }
+
+    pub(super) fn for_epoch(self: &Arc<Self>, epoch: IdentityEpoch) -> Arc<dyn ClientSessionStore> {
+        Arc::new(EpochSessionStore {
+            store: self.clone(),
+            epoch,
+        })
+    }
+}
+
+struct EpochSessionStore {
+    store: Arc<NodeSessionStore>,
+    epoch: IdentityEpoch,
+}
+
+impl std::fmt::Debug for EpochSessionStore {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter
+            .debug_struct("EpochSessionStore")
+            .finish_non_exhaustive()
+    }
+}
+
+impl EpochSessionStore {
+    fn state(&self) -> Option<MutexGuard<'_, State>> {
+        let mut state = self.store.state.lock().ok()?;
+        if !self.epoch.is_current() || self.epoch.generation() < state.generation {
+            return None;
+        }
+        if self.epoch.generation() != state.generation {
+            state.generation = self.epoch.generation();
+            state.hint = None;
+            state.tls12 = None;
+            state.tickets.clear();
+        }
+        Some(state)
+    }
 }
 
-impl ClientSessionStore for NodeSessionStore {
+impl ClientSessionStore for EpochSessionStore {
     fn set_kx_hint(&self, name: ServerName<'static>, group: NamedGroup) {
-        if name == self.name {
-            self.state.lock().unwrap().hint = Some(group);
+        if name == self.store.name
+            && let Some(mut state) = self.state()
+        {
+            state.hint = Some(group);
         }
     }
     fn kx_hint(&self, name: &ServerName<'_>) -> Option<NamedGroup> {
-        if *name == self.name {
-            self.state.lock().unwrap().hint
+        if *name == self.store.name {
+            self.state().and_then(|state| state.hint)
         } else {
             None
         }
     }
     fn set_tls12_session(&self, name: ServerName<'static>, value: Tls12ClientSessionValue) {
-        if name != self.name || self.capacity == 0 {
+        if name != self.store.name || self.store.capacity == 0 {
             return;
         }
-        let mut state = self.state.lock().unwrap();
+        let Some(mut state) = self.state() else {
+            return;
+        };
         state.tickets.clear();
         state.tls12 = Some(value);
     }
     fn tls12_session(&self, name: &ServerName<'_>) -> Option<Tls12ClientSessionValue> {
-        if *name == self.name {
-            self.state.lock().unwrap().tls12.clone()
+        if *name == self.store.name {
+            self.state().and_then(|state| state.tls12.clone())
         } else {
             None
         }
     }
     fn remove_tls12_session(&self, name: &ServerName<'static>) {
-        if *name == self.name {
-            self.state.lock().unwrap().tls12 = None;
+        if *name == self.store.name
+            && let Some(mut state) = self.state()
+        {
+            state.tls12 = None;
         }
     }
     fn insert_tls13_ticket(&self, name: ServerName<'static>, value: Tls13ClientSessionValue) {
-        if name != self.name || self.capacity == 0 {
+        if name != self.store.name || self.store.capacity == 0 {
             return;
         }
-        let mut state = self.state.lock().unwrap();
+        let Some(mut state) = self.state() else {
+            return;
+        };
         state.tls12 = None;
-        if state.tickets.len() == self.capacity {
+        if state.tickets.len() == self.store.capacity {
             state.tickets.pop_front();
         }
         state.tickets.push_back(value);
     }
     fn take_tls13_ticket(&self, name: &ServerName<'static>) -> Option<Tls13ClientSessionValue> {
-        if *name == self.name {
-            self.state.lock().unwrap().tickets.pop_back()
+        if *name == self.store.name {
+            self.state().and_then(|mut state| state.tickets.pop_back())
         } else {
             None
         }
diff --git a/src/security/shadow_tls.rs b/src/security/shadow_tls.rs
index 7e7eebe..2b9196c 100644
--- a/src/security/shadow_tls.rs
+++ b/src/security/shadow_tls.rs
@@ -46,6 +46,12 @@ impl ShadowTlsClient {
                 &TlsClientOptions {
                     versions: TlsVersions::Tls13,
                     alpn: config.alpn.clone(),
+                    required_alpn: config.required_alpn.clone(),
+                    identity: config
+                        .identity
+                        .as_ref()
+                        .map(|identity| super::TlsClientIdentity::from_config(identity, context))
+                        .transpose()?,
                     certificate: config.certificate.clone(),
                     client_fingerprint: config.client_fingerprint,
                     ..Default::default()
diff --git a/src/security/shadow_tls_tests.rs b/src/security/shadow_tls_tests.rs
index 703a1ba..3dad1b6 100644
--- a/src/security/shadow_tls_tests.rs
+++ b/src/security/shadow_tls_tests.rs
@@ -47,11 +47,14 @@ fn material() -> Material {
         context: SecurityContext {
             provider,
             tls_roots: Arc::new(roots),
+            identities: Arc::default(),
         },
         options: ShadowTlsConfig {
             server_name: "cover.invalid".into(),
             password: String::from_utf8(PASSWORD.to_vec()).unwrap(),
             alpn: vec![],
+            required_alpn: None,
+            identity: None,
             certificate: Default::default(),
             client_fingerprint: None,
         },
@@ -98,7 +101,6 @@ impl rustls::sign::Signer for ForgedKey {
 
 #[tokio::test]
 async fn certificate_policy_and_native_signature_must_succeed_before_a_shadowtls_stream_exists() {
-    let _case = crate::resources::case_events::Case::new("SHADOWTLS-UNIT", "native_signature");
     for profile in super::test_profiles() {
         for failure in [
             "name",
@@ -361,7 +363,6 @@ impl FinishedFault {
 
 #[tokio::test]
 async fn a_forged_finished_is_rejected_even_when_record_aead_relay_mac_and_pin_are_valid() {
-    let _case = crate::resources::case_events::Case::new("SHADOWTLS-UNIT", "native_finished");
     for profile in super::test_profiles() {
         for policy in ["webpki", "skip", "pin"] {
             let mut material = material();
@@ -400,7 +401,6 @@ async fn a_forged_finished_is_rejected_even_when_record_aead_relay_mac_and_pin_a
 
 #[tokio::test]
 async fn authenticated_stream_ignores_residual_cover_and_preserves_partial_io_flush_and_eof() {
-    let _case = crate::resources::case_events::Case::new("SHADOWTLS-UNIT", "stream_io");
     for profile in super::test_profiles() {
         let mut material = material();
         material.options.client_fingerprint = *profile;
@@ -459,7 +459,6 @@ async fn authenticated_stream_ignores_residual_cover_and_preserves_partial_io_fl
 
 #[tokio::test]
 async fn cancelling_a_partial_authenticated_record_read_preserves_it_for_the_next_reader() {
-    let _case = crate::resources::case_events::Case::new("SHADOWTLS-UNIT", "read_cancel");
     let material = material();
     let client = ShadowTlsClient::new(&material.context, &material.options).unwrap();
     let (raw, mut peer) = tokio::io::duplex(73);
@@ -535,7 +534,6 @@ impl tokio::io::AsyncWrite for WriteGate {
 
 #[tokio::test(start_paused = true)]
 async fn shutdown_has_a_five_second_bound_even_when_the_caller_transport_never_becomes_writable() {
-    let _case = crate::resources::case_events::Case::new("SHADOWTLS-UNIT", "close_deadline");
     let material = material();
     let client = ShadowTlsClient::new(&material.context, &material.options).unwrap();
     let (raw, mut peer) = tokio::io::duplex(73);
diff --git a/src/security/tls.rs b/src/security/tls.rs
index 8bad1c8..e07ce82 100644
--- a/src/security/tls.rs
+++ b/src/security/tls.rs
@@ -1,4 +1,7 @@
-use std::{io, sync::Arc};
+use std::{
+    io,
+    sync::{Arc, Mutex},
+};
 
 use rustls::{
     ClientConfig,
@@ -11,6 +14,7 @@ use tokio_rustls::TlsConnector;
 use crate::dispatch::BoxStream;
 
 use super::SecurityContext;
+use super::identity::{ClientIdentitySource, IdentityEpoch, IdentityMaterial, IdentitySnapshot};
 
 pub(crate) const DEFAULT_TLS_BUFFER_LIMIT: usize = 64 * 1024;
 
@@ -29,7 +33,7 @@ pub enum TlsVersions {
 
 /// Immutable per-node, per-transport TLS options. Constructing another client
 /// always creates an independent resumption store, even for the same SNI.
-#[derive(Default)]
+#[derive(Default, Clone)]
 pub struct TlsClientOptions {
     pub ech: Option<crate::config::StaticEchConfig>,
     pub client_fingerprint: Option<crate::config::ClientFingerprint>,
@@ -54,12 +58,78 @@ impl std::fmt::Debug for TlsClientOptions {
     }
 }
 
-/// A node-owned certificate chain and matching key. The provider validates the
-/// key pair while constructing the client, before any supplied stream is used.
-/// No file loading, environment key logging or dynamic identity reload occurs.
+impl TlsClientOptions {
+    #[cfg(any(
+        test,
+        feature = "outbound-anytls",
+        feature = "outbound-trojan",
+        feature = "outbound-vmess",
+        feature = "outbound-socks5"
+    ))]
+    pub(crate) fn from_policy(
+        policy: &crate::config::TlsClientPolicy,
+        required_alpn: Option<&[u8]>,
+        context: &SecurityContext,
+    ) -> io::Result<Self> {
+        Ok(Self {
+            ech: policy.ech.clone(),
+            client_fingerprint: policy.client_fingerprint,
+            alpn: policy.alpn.clone(),
+            required_alpn: required_alpn.map(<[u8]>::to_vec),
+            certificate: policy.certificate.clone(),
+            identity: policy
+                .identity
+                .as_ref()
+                .map(|identity| TlsClientIdentity::from_config(identity, context))
+                .transpose()?,
+            ..Default::default()
+        })
+    }
+}
+
+/// Parsed inline material or an explicitly registered file-backed identity.
+/// Handshakes only snapshot published material; they never read a file.
+#[derive(Clone)]
 pub struct TlsClientIdentity {
-    pub(super) certificates: Vec<CertificateDer<'static>>,
-    pub(super) key: PrivateKeyDer<'static>,
+    storage: IdentityStorage,
+    #[cfg(any(feature = "tls-fingerprint", feature = "quiche-h3-transport"))]
+    native: Option<Arc<NativeIdentityClient>>,
+}
+
+#[derive(Clone)]
+enum IdentityStorage {
+    Inline(Arc<IdentityMaterial>),
+    Files(Arc<ClientIdentitySource>),
+}
+
+#[cfg(any(feature = "tls-fingerprint", feature = "quiche-h3-transport"))]
+struct NativeIdentityClient {
+    identity: TlsClientIdentity,
+    current: Mutex<Option<(u64, Arc<super::identity::NativeIdentity>)>>,
+    _lease: Option<Arc<()>>,
+}
+
+#[cfg(any(feature = "tls-fingerprint", feature = "quiche-h3-transport"))]
+impl NativeIdentityClient {
+    fn snapshot(&self) -> io::Result<IdentitySnapshot> {
+        let mut current = self
+            .current
+            .lock()
+            .map_err(|_| io::Error::other("TLS identity unavailable"))?;
+        let mut snapshot = self.identity.snapshot();
+        let native = match current.as_ref() {
+            Some((generation, native)) if *generation == snapshot.epoch.generation() => {
+                native.clone()
+            }
+            _ => {
+                let native = snapshot.material.native()?;
+                *current = Some((snapshot.epoch.generation(), native.clone()));
+                native
+            }
+        };
+        snapshot.native = Some(native);
+        Ok(snapshot)
+    }
 }
 
 impl TlsClientIdentity {
@@ -77,20 +147,87 @@ impl TlsClientIdentity {
         if keys.next().is_some() || certificates.is_empty() {
             return Err(invalid());
         }
-        rustls::sign::CertifiedKey::from_der(
-            certificates.clone(),
-            key.clone_key(),
-            &rustls::crypto::ring::default_provider(),
-        )
-        .map_err(|_| invalid())?;
-        Ok(Self { certificates, key })
+        let identity = Self::from_der(certificates, key);
+        identity.snapshot().material.validate()?;
+        Ok(identity)
     }
 
     pub fn from_der(
         certificates: Vec<CertificateDer<'static>>,
         key: PrivateKeyDer<'static>,
     ) -> Self {
-        Self { certificates, key }
+        Self {
+            storage: IdentityStorage::Inline(Arc::new(IdentityMaterial::new(certificates, key))),
+            #[cfg(any(feature = "tls-fingerprint", feature = "quiche-h3-transport"))]
+            native: None,
+        }
+    }
+
+    pub(crate) fn from_config(
+        identity: &crate::config::TlsIdentityPem,
+        context: &SecurityContext,
+    ) -> io::Result<Self> {
+        let initial = Self::from_pem(&identity.certificate, &identity.private_key)?;
+        let Some(origin) = &identity.origin else {
+            return Ok(initial);
+        };
+        let material = initial.snapshot().material;
+        material.validate()?;
+        let source = context.identities.register(
+            origin,
+            material,
+            identity
+                .certificate
+                .len()
+                .saturating_add(identity.private_key.len()),
+        )?;
+        Ok(Self {
+            storage: IdentityStorage::Files(source),
+            #[cfg(any(feature = "tls-fingerprint", feature = "quiche-h3-transport"))]
+            native: None,
+        })
+    }
+
+    pub(super) fn snapshot(&self) -> IdentitySnapshot {
+        match &self.storage {
+            IdentityStorage::Inline(material) => IdentitySnapshot {
+                material: material.clone(),
+                epoch: IdentityEpoch::default(),
+                #[cfg(any(feature = "tls-fingerprint", feature = "quiche-h3-transport"))]
+                native: None,
+            },
+            IdentityStorage::Files(source) => source.snapshot(),
+        }
+    }
+
+    #[cfg(any(feature = "tls-fingerprint", feature = "quiche-h3-transport"))]
+    pub(super) fn native_snapshot(&self) -> io::Result<IdentitySnapshot> {
+        self.for_native()?.native.as_ref().unwrap().snapshot()
+    }
+
+    #[cfg(any(feature = "tls-fingerprint", feature = "quiche-h3-transport"))]
+    pub(super) fn for_native(&self) -> io::Result<Self> {
+        if self.native.is_some() {
+            return Ok(self.clone());
+        }
+        let lease = match &self.storage {
+            IdentityStorage::Files(source) => Some(source.native_lease()?),
+            IdentityStorage::Inline(_) => None,
+        };
+        let client = Arc::new(NativeIdentityClient {
+            identity: self.clone(),
+            current: Mutex::new(None),
+            _lease: lease,
+        });
+        client.snapshot()?;
+        Ok(Self {
+            storage: self.storage.clone(),
+            native: Some(client),
+        })
+    }
+
+    fn reloadable(&self) -> bool {
+        matches!(self.storage, IdentityStorage::Files(_))
     }
 }
 
@@ -111,21 +248,66 @@ pub(crate) enum StandardTlsProfile {
 /// Reusable standard TLS client shared by protocol-specific outbound code.
 ///
 /// REALITY remains in [`super::SecurityClient`] with a distinct authentication
-/// and session policy. Ordinary unprofiled TLS and QUIC continue to use rustls.
+/// and session policy. Unprofiled stream TLS and Quinn continue to use rustls.
 #[derive(Clone)]
 pub struct StandardTlsClient {
-    connector: StandardConnector,
+    connector: Option<StandardConnector>,
+    rustls_identity: Option<Arc<RustlsIdentityClient>>,
     server_name: String,
     required_alpn: Option<Vec<u8>>,
     buffer_limit: usize,
     require_ech: bool,
+    dynamic_ech: Option<Arc<DynamicEchTls>>,
+    #[cfg(feature = "quiche-h3-transport")]
+    quiche_source: Option<Arc<QuicheSource>>,
+}
+
+struct RustlsIdentityClient {
+    identity: TlsClientIdentity,
+    current: Mutex<(u64, Arc<ClientConfig>)>,
+    sessions: Option<Arc<super::resumption::NodeSessionStore>>,
+}
+
+impl RustlsIdentityClient {
+    fn connector(&self) -> io::Result<TlsConnector> {
+        let mut current = self
+            .current
+            .lock()
+            .map_err(|_| io::Error::other("TLS identity unavailable"))?;
+        let snapshot = self.identity.snapshot();
+        if current.0 != snapshot.epoch.generation() {
+            let mut config = (*current.1).clone();
+            config.client_auth_cert_resolver = Arc::new(rustls::sign::SingleCertAndKey::from(
+                snapshot.material.certified_key()?,
+            ));
+            config.resumption = self
+                .sessions
+                .as_ref()
+                .map_or_else(Resumption::disabled, |store| {
+                    Resumption::store(store.for_epoch(snapshot.epoch.clone()))
+                });
+            *current = (snapshot.epoch.generation(), Arc::new(config));
+        }
+        Ok(TlsConnector::from(current.1.clone()))
+    }
+}
+
+#[cfg(feature = "quiche-h3-transport")]
+struct QuicheSource {
+    context: SecurityContext,
+    options: Mutex<TlsClientOptions>,
+}
+
+struct DynamicEchTls {
+    context: SecurityContext,
+    options: TlsClientOptions,
 }
 
 #[derive(Clone)]
 enum StandardConnector {
     Rustls(TlsConnector),
     #[cfg(feature = "tls-fingerprint")]
-    Boring(super::boring::BoringTlsClient),
+    Boring(Arc<super::boring::BoringTlsClient>),
 }
 
 impl std::fmt::Debug for StandardTlsClient {
@@ -139,13 +321,82 @@ impl std::fmt::Debug for StandardTlsClient {
 }
 
 impl StandardTlsClient {
-    #[cfg(any(
-        feature = "outbound-vless",
-        feature = "outbound-hysteria2",
-        feature = "outbound-tuic"
-    ))]
+    #[cfg(feature = "quiche-h3-transport")]
+    pub(crate) fn prepare_quiche_identity(&self) -> io::Result<()> {
+        if let Some(source) = &self.quiche_source {
+            let mut options = source
+                .options
+                .lock()
+                .map_err(|_| io::Error::other("TLS identity unavailable"))?;
+            options.identity = options
+                .identity
+                .as_ref()
+                .map(TlsClientIdentity::for_native)
+                .transpose()?;
+        }
+        Ok(())
+    }
+
+    #[cfg(feature = "quiche-h3-transport")]
+    pub(crate) fn quiche_config(&self) -> io::Result<super::QuicheTls> {
+        if self.dynamic_ech.is_some() {
+            return Err(io::Error::other(
+                "dynamic ECH requires a node resolution context",
+            ));
+        }
+        let source = self
+            .quiche_source
+            .as_ref()
+            .ok_or_else(|| io::Error::other("HTTP/3 requires H3 ALPN"))?;
+        self.prepare_quiche_identity()?;
+        let options = source
+            .options
+            .lock()
+            .map_err(|_| io::Error::other("TLS identity unavailable"))?
+            .clone();
+        super::QuicheTls::standard(&source.context, &self.server_name, &options)
+    }
+
+    #[cfg(feature = "quiche-h3-transport")]
+    pub(crate) async fn quiche_config_with_context(
+        &self,
+        context: &crate::outbound::EstablishContext,
+    ) -> io::Result<super::QuicheTls> {
+        let Some(dynamic) = &self.dynamic_ech else {
+            return self.quiche_config();
+        };
+        self.prepare_quiche_identity()?;
+        let source = self
+            .quiche_source
+            .as_ref()
+            .ok_or_else(|| io::Error::other("HTTP/3 requires H3 ALPN"))?;
+        let mut options = source
+            .options
+            .lock()
+            .map_err(|_| io::Error::other("TLS identity unavailable"))?
+            .clone();
+        options.ech = Some(
+            dynamic
+                .options
+                .ech
+                .as_ref()
+                .expect("dynamic ECH source")
+                .for_backend(true)
+                .map_err(|_| io::Error::other("ECH has no compatible QUIC configuration"))?
+                .resolve(&self.server_name, context)
+                .await?,
+        );
+        super::QuicheTls::standard(&dynamic.context, &self.server_name, &options)
+    }
+
+    #[cfg(feature = "quic-transport")]
     pub(crate) fn quic_config(&self) -> io::Result<(Arc<ClientConfig>, String)> {
-        match &self.connector {
+        if self.dynamic_ech.is_some() {
+            return Err(io::Error::other(
+                "dynamic ECH requires a node resolution context",
+            ));
+        }
+        match &self.current_connector()? {
             StandardConnector::Rustls(connector) => {
                 // XHTTP validates its exclusive h3 policy before construction.
                 // Hysteria2 also uses H3 but permits a custom negotiated ALPN.
@@ -190,32 +441,6 @@ impl StandardTlsClient {
         )
     }
 
-    #[cfg(feature = "outbound-anytls")]
-    pub(crate) fn for_anytls(
-        context: &SecurityContext,
-        server_name: impl Into<String>,
-        policy: &crate::config::AnyTlsCertificatePolicy,
-        resumption_sessions: usize,
-        buffer_limit: usize,
-    ) -> io::Result<Self> {
-        Self::with_options(
-            context,
-            server_name,
-            TlsClientOptions {
-                alpn: policy.alpn.clone(),
-                client_fingerprint: policy.client_fingerprint,
-                certificate: TlsCertificatePolicy {
-                    verification_name: None,
-                    skip_cert_verify: policy.skip_cert_verify,
-                    fingerprint: policy.fingerprint,
-                },
-                ..Default::default()
-            },
-            resumption_sessions,
-            buffer_limit,
-        )
-    }
-
     /// Wraps caller-supplied streams only: no socket, resolver, background task
     /// or unbounded shared cache is created here. The graph allocates ticket
     /// capacity from its existing aggregate budget; zero disables resumption.
@@ -229,6 +454,16 @@ impl StandardTlsClient {
         let server_name = server_name.into();
         let name = ServerName::try_from(server_name.clone())
             .map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "invalid TLS server name"))?;
+        let mut options = options;
+        if let Some(identity) = &options.identity {
+            identity.snapshot().material.validate()?;
+        }
+        options.ech = options
+            .ech
+            .as_ref()
+            .map(|ech| ech.for_backend(options.client_fingerprint.is_some()))
+            .transpose()
+            .map_err(|_| io::Error::other("ECH has no compatible configuration"))?;
         let require_ech = options.ech.is_some();
         if require_ech && !matches!(name, ServerName::DnsName(_)) {
             return Err(io::Error::new(
@@ -236,13 +471,39 @@ impl StandardTlsClient {
                 "ECH requires a DNS server name",
             ));
         }
-        #[cfg(not(feature = "outbound-vless"))]
+        #[cfg(not(feature = "ech"))]
         if require_ech {
             return Err(io::Error::new(
                 io::ErrorKind::Unsupported,
                 "ECH is not compiled in",
             ));
         }
+        if options
+            .ech
+            .as_ref()
+            .is_some_and(crate::config::StaticEchConfig::is_dynamic)
+        {
+            #[cfg(feature = "tls-fingerprint")]
+            if options.client_fingerprint.is_some() {
+                // DNS resolution rebuilds only ECH's physical TLS context.
+                // The node's native identity owner/cache survives those builds.
+                options.identity = options
+                    .identity
+                    .as_ref()
+                    .map(TlsClientIdentity::for_native)
+                    .transpose()?;
+            }
+            let mut plain = options.clone();
+            plain.ech = None;
+            plain.versions = TlsVersions::Tls13;
+            let mut client = Self::with_options(context, server_name, plain, 0, buffer_limit)?;
+            client.require_ech = true;
+            client.dynamic_ech = Some(Arc::new(DynamicEchTls {
+                context: context.clone(),
+                options,
+            }));
+            return Ok(client);
+        }
         if buffer_limit == 0 {
             return Err(io::Error::new(
                 io::ErrorKind::InvalidInput,
@@ -274,6 +535,18 @@ impl StandardTlsClient {
             ));
         }
 
+        #[cfg(feature = "quiche-h3-transport")]
+        let quiche_source = options
+            .alpn
+            .iter()
+            .any(|protocol| protocol == b"h3")
+            .then(|| {
+                Arc::new(QuicheSource {
+                    context: context.clone(),
+                    options: Mutex::new(options.clone()),
+                })
+            });
+
         if options.client_fingerprint.is_some() {
             #[cfg(not(feature = "tls-fingerprint"))]
             return Err(io::Error::new(
@@ -289,11 +562,15 @@ impl StandardTlsClient {
                     resumption_sessions,
                 )?;
                 return Ok(Self {
-                    connector: StandardConnector::Boring(client),
+                    connector: Some(StandardConnector::Boring(Arc::new(client))),
+                    rustls_identity: None,
                     server_name,
                     required_alpn: options.required_alpn,
                     buffer_limit,
                     require_ech,
+                    dynamic_ech: None,
+                    #[cfg(feature = "quiche-h3-transport")]
+                    quiche_source,
                 });
             }
         }
@@ -304,7 +581,7 @@ impl StandardTlsClient {
             TlsVersions::Tls12And13 => &[&TLS13, &TLS12],
         };
         let builder = ClientConfig::builder_with_provider(context.provider.clone());
-        #[cfg(feature = "outbound-vless")]
+        #[cfg(feature = "ech")]
         let builder = if let Some(ech) = &options.ech {
             let ech = rustls::client::EchConfig::new(ech.as_bytes().into(), super::ech::SUITES)
                 .map_err(|_| {
@@ -316,61 +593,179 @@ impl StandardTlsClient {
                 .with_protocol_versions(protocol_versions)
                 .map_err(io_other)?
         };
-        #[cfg(not(feature = "outbound-vless"))]
+        #[cfg(not(feature = "ech"))]
         let builder = builder
             .with_protocol_versions(protocol_versions)
             .map_err(io_other)?;
         let builder = builder.with_root_certificates(context.tls_roots.clone());
-        let mut config = if let Some(identity) = options.identity {
-            let identity_size = identity
-                .certificates
-                .iter()
-                .try_fold(identity.key.secret_der().len(), |size, cert| {
-                    size.checked_add(cert.len())
-                });
-            if identity_size.is_none_or(|size| size > crate::config::MAX_CONFIG_BYTES) {
-                return Err(io::Error::new(
-                    io::ErrorKind::InvalidInput,
-                    "TLS client identity exceeds the configuration bound",
-                ));
-            }
-            builder
-                .with_client_auth_cert(identity.certificates, identity.key)
-                .map_err(|_| {
-                    io::Error::new(io::ErrorKind::InvalidInput, "invalid TLS client identity")
-                })?
+        let identity_snapshot = options.identity.as_ref().map(TlsClientIdentity::snapshot);
+        let mut config = if let Some(identity) = &identity_snapshot {
+            builder.with_client_cert_resolver(Arc::new(rustls::sign::SingleCertAndKey::from(
+                identity.material.certified_key()?,
+            )))
         } else {
             builder.with_no_client_auth()
         };
-        config.resumption = if resumption_sessions == 0 || require_ech {
-            Resumption::disabled()
-        } else {
-            Resumption::store(Arc::new(super::resumption::NodeSessionStore::new(
+        let sessions = (resumption_sessions != 0 && !require_ech).then(|| {
+            Arc::new(super::resumption::NodeSessionStore::new(
                 name,
                 resumption_sessions,
-            )))
-        };
+            ))
+        });
+        config.resumption = sessions
+            .as_ref()
+            .map_or_else(Resumption::disabled, |store| {
+                Resumption::store(
+                    store.for_epoch(
+                        identity_snapshot
+                            .as_ref()
+                            .map(|identity| identity.epoch.clone())
+                            .unwrap_or_default(),
+                    ),
+                )
+            });
 
         config.alpn_protocols = options.alpn;
         config.dangerous().set_certificate_verifier(Arc::new(
             super::verifier::CertificateVerifier::new(context, options.certificate)?,
         ));
 
+        let config = Arc::new(config);
+        let rustls_identity =
+            options
+                .identity
+                .filter(TlsClientIdentity::reloadable)
+                .map(|identity| {
+                    Arc::new(RustlsIdentityClient {
+                        identity,
+                        current: Mutex::new((
+                            identity_snapshot.as_ref().unwrap().epoch.generation(),
+                            config.clone(),
+                        )),
+                        sessions,
+                    })
+                });
         Ok(Self {
-            connector: StandardConnector::Rustls(TlsConnector::from(Arc::new(config))),
+            connector: rustls_identity
+                .is_none()
+                .then(|| StandardConnector::Rustls(TlsConnector::from(config))),
+            rustls_identity,
             server_name,
             required_alpn: options.required_alpn,
             buffer_limit,
             require_ech,
+            dynamic_ech: None,
+            #[cfg(feature = "quiche-h3-transport")]
+            quiche_source,
         })
     }
 
+    fn current_connector(&self) -> io::Result<StandardConnector> {
+        self.rustls_identity.as_ref().map_or_else(
+            || {
+                self.connector
+                    .clone()
+                    .ok_or_else(|| io::Error::other("TLS connector unavailable"))
+            },
+            |identity| identity.connector().map(StandardConnector::Rustls),
+        )
+    }
+
+    async fn resolved(&self, context: &crate::outbound::EstablishContext) -> io::Result<Self> {
+        let Some(dynamic) = &self.dynamic_ech else {
+            return Ok(self.clone());
+        };
+        let mut options = dynamic.options.clone();
+        options.ech = Some(
+            options
+                .ech
+                .as_ref()
+                .expect("dynamic ECH source")
+                .resolve(&self.server_name, context)
+                .await?,
+        );
+        Self::with_options(
+            &dynamic.context,
+            &self.server_name,
+            options,
+            0,
+            self.buffer_limit,
+        )
+    }
+
+    pub(crate) async fn connect_with_context(
+        &self,
+        stream: BoxStream,
+        context: &crate::outbound::EstablishContext,
+    ) -> io::Result<BoxStream> {
+        self.resolved(context).await?.connect(stream).await
+    }
+
+    #[cfg(feature = "outbound-trusttunnel")]
+    pub(crate) async fn connect_h2_prior_knowledge(
+        &self,
+        stream: BoxStream,
+        context: &crate::outbound::EstablishContext,
+    ) -> io::Result<BoxStream> {
+        if self.required_alpn.as_deref() != Some(b"h2") {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "H2 prior knowledge requires an H2 TLS policy",
+            ));
+        }
+        self.resolved(context)
+            .await?
+            .connect_negotiated_inner(stream, true)
+            .await
+            .map(|(stream, _)| stream)
+    }
+
+    #[cfg(any(
+        feature = "outbound-vless",
+        feature = "outbound-hysteria2",
+        feature = "outbound-tuic",
+        feature = "outbound-trusttunnel"
+    ))]
+    pub(crate) async fn quic_config_with_context(
+        &self,
+        context: &crate::outbound::EstablishContext,
+    ) -> io::Result<(Arc<ClientConfig>, String)> {
+        self.resolved(context).await?.quic_config()
+    }
+
     pub async fn connect(&self, stream: BoxStream) -> io::Result<BoxStream> {
-        let connector = match &self.connector {
+        self.connect_negotiated(stream)
+            .await
+            .map(|(stream, _)| stream)
+    }
+
+    /// Returns the authenticated stream and the server's actual ALPN choice.
+    /// Existing required-ALPN/ECH checks apply before either becomes visible.
+    pub async fn connect_negotiated(
+        &self,
+        stream: BoxStream,
+    ) -> io::Result<(BoxStream, Option<Vec<u8>>)> {
+        self.connect_negotiated_inner(stream, false).await
+    }
+
+    async fn connect_negotiated_inner(
+        &self,
+        stream: BoxStream,
+        allow_missing_alpn: bool,
+    ) -> io::Result<(BoxStream, Option<Vec<u8>>)> {
+        if self.dynamic_ech.is_some() {
+            return Err(io::Error::other(
+                "dynamic ECH requires a node resolution context",
+            ));
+        }
+        let current = self.current_connector()?;
+        let connector = match &current {
             StandardConnector::Rustls(connector) => connector,
             #[cfg(feature = "tls-fingerprint")]
             StandardConnector::Boring(client) => {
-                return client.connect(stream, self.buffer_limit).await;
+                return client
+                    .connect_negotiated_with_policy(stream, self.buffer_limit, allow_missing_alpn)
+                    .await;
             }
         };
         let server_name = ServerName::try_from(self.server_name.clone())
@@ -386,16 +781,14 @@ impl StandardTlsClient {
             return Err(io::Error::other("TLS ECH was not accepted"));
         }
 
-        if let Some(required_alpn) = self.required_alpn.as_deref()
-            && tls.get_ref().1.alpn_protocol() != Some(required_alpn)
-        {
-            return Err(io::Error::new(
-                io::ErrorKind::InvalidData,
-                "TLS server did not negotiate the required ALPN",
-            ));
-        }
+        validate_alpn(
+            self.required_alpn.as_deref(),
+            tls.get_ref().1.alpn_protocol(),
+            allow_missing_alpn,
+        )?;
 
-        Ok(Box::new(super::stream::TlsStream::new(tls)))
+        let alpn = tls.get_ref().1.alpn_protocol().map(<[u8]>::to_vec);
+        Ok((Box::new(super::stream::TlsStream::new(tls)), alpn))
     }
 
     #[cfg(feature = "outbound-vless")]
@@ -410,7 +803,8 @@ impl StandardTlsClient {
                 "Vision with ECH is not supported",
             ));
         }
-        let connector = match &self.connector {
+        let current = self.current_connector()?;
+        let connector = match &current {
             StandardConnector::Rustls(connector) => connector,
             StandardConnector::Boring(client) => {
                 return client
@@ -445,6 +839,22 @@ impl StandardTlsClient {
     }
 }
 
+pub(super) fn validate_alpn(
+    required: Option<&[u8]>,
+    negotiated: Option<&[u8]>,
+    allow_missing: bool,
+) -> io::Result<()> {
+    if required.is_some_and(|required| {
+        negotiated != Some(required) && !(allow_missing && negotiated.is_none())
+    }) {
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidData,
+            "TLS server did not negotiate the required ALPN",
+        ));
+    }
+    Ok(())
+}
+
 fn io_other(error: impl std::error::Error + Send + Sync + 'static) -> io::Error {
     io::Error::other(error)
 }
diff --git a/src/security/tls_named_tests.rs b/src/security/tls_named_tests.rs
index 07082a9..ccdf1ac 100644
--- a/src/security/tls_named_tests.rs
+++ b/src/security/tls_named_tests.rs
@@ -59,7 +59,7 @@ async fn alps_exchange(
     let (io, peer) = tokio::io::duplex(16384);
     tokio::time::timeout(Duration::from_secs(3), async {
         let server = async {
-            let Ok(mut tls) = tokio_boring::SslStreamBuilder::new(ssl, peer)
+            let Ok(tls) = tokio_boring::SslStreamBuilder::new(ssl, peer)
                 .accept()
                 .await
             else {
@@ -67,21 +67,72 @@ async fn alps_exchange(
             };
             let negotiated = tls.ssl().peer_application_settings().is_some();
             let resumed = tls.ssl().session_reused();
-            let mut request = [0; 4];
-            let count = tls.read(&mut request).await.unwrap_or(0);
-            if count != 0 {
-                assert_eq!(&request[..count], &b"ping"[..count]);
-                tls.write_all(b"pong").await.unwrap();
-            }
+            let mut connection = h2::server::Builder::new()
+                .max_concurrent_streams(7)
+                .initial_window_size(32768)
+                .handshake::<_, bytes::Bytes>(tls)
+                .await
+                .unwrap();
+            let Some(Ok((mut request, mut respond))) = connection.accept().await else {
+                return (negotiated, 0, resumed);
+            };
+            let exchange = async {
+                let data = request.body_mut().data().await.unwrap().unwrap();
+                assert_eq!(data.as_ref(), b"ping");
+                request
+                    .body_mut()
+                    .flow_control()
+                    .release_capacity(data.len())
+                    .unwrap();
+                let mut response = respond
+                    .send_response(http::Response::new(()), false)
+                    .unwrap();
+                response
+                    .send_data(bytes::Bytes::from_static(b"pong"), true)
+                    .unwrap();
+                data.len()
+            };
+            let count = tokio::select! {
+                count = exchange => count,
+                _ = std::future::poll_fn(|cx| connection.poll_closed(cx)) => 0,
+            };
+            connection.graceful_shutdown();
+            let _ = std::future::poll_fn(|cx| connection.poll_closed(cx)).await;
             (negotiated, count, resumed)
         };
         let consumer = async {
-            let mut tls = client.connect(Box::new(io)).await?;
-            tls.write_all(b"ping").await?;
-            let mut response = [0; 4];
-            tls.read_exact(&mut response).await?;
-            assert_eq!(&response, b"pong");
-            Ok(())
+            let tls = client.connect(Box::new(io)).await?;
+            let (mut sender, connection) = h2::client::handshake(tls).await.map_err(io_other)?;
+            let exchange = async {
+                let (response, mut body) = sender
+                    .send_request(
+                        http::Request::builder()
+                            .uri("https://fixture.invalid/")
+                            .body(())
+                            .unwrap(),
+                        false,
+                    )
+                    .map_err(io_other)?;
+                body.send_data(bytes::Bytes::from_static(b"ping"), true)
+                    .map_err(io_other)?;
+                let mut response = response.await.map_err(io_other)?;
+                let data = response
+                    .body_mut()
+                    .data()
+                    .await
+                    .ok_or_else(|| io::Error::other("missing H2 response"))?
+                    .map_err(io_other)?;
+                assert_eq!(data.as_ref(), b"pong");
+                response
+                    .body_mut()
+                    .flow_control()
+                    .release_capacity(data.len())
+                    .map_err(io_other)?;
+                Ok::<(), io::Error>(())
+            };
+            let (business, driver) = tokio::join!(exchange, connection);
+            business?;
+            driver.map_err(io_other)
         };
         let (result, (negotiated, bytes, resumed)) = tokio::join!(consumer, server);
         (result, negotiated, bytes, resumed)
@@ -91,48 +142,41 @@ async fn alps_exchange(
 }
 
 #[tokio::test]
-async fn selected_profiles_enforce_alps_before_business_and_ticket_publication() {
+async fn selected_profiles_use_standard_h2_settings_when_the_server_supports_alps() {
     use crate::config::ClientFingerprint;
     let chain = chain(false);
-    for profile in crate::security::test_profiles().iter().copied().flatten() {
-        let chrome = matches!(
-            profile,
-            ClientFingerprint::Chrome120 | ClientFingerprint::Chrome133
-        );
-        let new_codepoint = profile == ClientFingerprint::Chrome133;
-        for settings in [
-            None,
-            Some(b"".as_slice()),
-            Some(b"\0\x03\0\0\0\x64".as_slice()),
-        ] {
-            let peer = native_peer(&chain);
-            let client = StandardTlsClient::with_options(
-                &trusted(&chain),
-                "fixture.invalid",
-                TlsClientOptions {
-                    client_fingerprint: Some(profile),
-                    alpn: vec![b"h2".to_vec()],
-                    required_alpn: Some(b"h2".to_vec()),
-                    ..Default::default()
-                },
-                4,
-                65536,
-            )
-            .unwrap();
-            let rejected = chrome && settings.is_some_and(|bytes| !bytes.is_empty());
-            let (result, negotiated, bytes, _) =
-                alps_exchange(&client, &peer, new_codepoint, settings).await;
-            assert_eq!(negotiated, chrome && settings.is_some());
-            if rejected {
-                assert_eq!(result.unwrap_err().kind(), io::ErrorKind::Unsupported);
-                assert_eq!(bytes, 0, "nonempty ALPS cannot admit application data");
-                let (result, _, bytes, resumed) =
-                    alps_exchange(&client, &peer, new_codepoint, Some(b"")).await;
-                result.unwrap();
-                assert_eq!(bytes, 4);
-                assert!(!resumed, "rejected ALPS cannot publish tickets");
-            } else {
+    for profile in [
+        ClientFingerprint::Chrome133,
+        ClientFingerprint::Firefox120,
+        ClientFingerprint::Safari16,
+        ClientFingerprint::Ios14,
+        ClientFingerprint::Edge85,
+        ClientFingerprint::Qq111,
+    ] {
+        for new_codepoint in [false, true] {
+            for settings in [
+                None,
+                Some(b"".as_slice()),
+                Some(b"\0\x03\0\0\0\x64".as_slice()),
+            ] {
+                let peer = native_peer(&chain);
+                let client = StandardTlsClient::with_options(
+                    &trusted(&chain),
+                    "fixture.invalid",
+                    TlsClientOptions {
+                        client_fingerprint: Some(profile),
+                        alpn: vec![b"h2".to_vec()],
+                        required_alpn: Some(b"h2".to_vec()),
+                        ..Default::default()
+                    },
+                    4,
+                    65536,
+                )
+                .unwrap();
+                let (result, negotiated, bytes, _) =
+                    alps_exchange(&client, &peer, new_codepoint, settings).await;
                 result.unwrap();
+                assert!(!negotiated, "the H2 consumer did not declare TLS ALPS");
                 assert_eq!(bytes, 4);
             }
         }
diff --git a/src/security/tls_named_wire_tests.rs b/src/security/tls_named_wire_tests.rs
index edae613..80eb69f 100644
--- a/src/security/tls_named_wire_tests.rs
+++ b/src/security/tls_named_wire_tests.rs
@@ -1,6 +1,5 @@
 //! Independent rustls memory peers for warm-wire/expiry and version rejection.
 use super::*;
-use base64::{Engine, engine::general_purpose::STANDARD};
 use std::{
     pin::Pin,
     task::{Context, Poll},
@@ -87,7 +86,6 @@ async fn observed_handshake(
 #[derive(Debug)]
 struct ShortTickets {
     inner: Arc<dyn rustls::server::ProducesTickets>,
-    issued: Arc<Mutex<Vec<usize>>>,
 }
 impl rustls::server::ProducesTickets for ShortTickets {
     fn enabled(&self) -> bool {
@@ -97,9 +95,7 @@ impl rustls::server::ProducesTickets for ShortTickets {
         2
     }
     fn encrypt(&self, plain: &[u8]) -> Option<Vec<u8>> {
-        let ticket = self.inner.encrypt(plain)?;
-        self.issued.lock().unwrap().push(ticket.len());
-        Some(ticket)
+        self.inner.encrypt(plain)
     }
     fn decrypt(&self, cipher: &[u8]) -> Option<Vec<u8>> {
         self.inner.decrypt(cipher)
@@ -108,23 +104,20 @@ impl rustls::server::ProducesTickets for ShortTickets {
 
 #[tokio::test]
 async fn selected_profiles_warm_wire_and_expired_tickets_use_real_handshakes() {
-    let mut observations = Vec::new();
     let mut clients = Vec::new();
     for (name, profile) in [
-        ("chrome120", crate::config::ClientFingerprint::Chrome120),
         ("chrome", crate::config::ClientFingerprint::Chrome133),
         ("firefox", crate::config::ClientFingerprint::Firefox120),
         ("safari", crate::config::ClientFingerprint::Safari16),
+        ("ios", crate::config::ClientFingerprint::Ios14),
     ] {
         for version in [&TLS12, &TLS13] {
             let chain = chain(false);
             let mut peer = server(&chain, version, false);
             // Only the advertised lifetime is short. The real ticket key stays
             // valid so full renegotiation proves the client's own expiry rule.
-            let issued = Arc::new(Mutex::new(Vec::new()));
             Arc::get_mut(&mut peer).unwrap().ticketer = Arc::new(ShortTickets {
                 inner: rustls::crypto::ring::Ticketer::new().unwrap(),
-                issued: issued.clone(),
             });
             let client = StandardTlsClient::with_options(
                 &trusted(&chain),
@@ -139,30 +132,24 @@ async fn selected_profiles_warm_wire_and_expired_tickets_use_real_handshakes() {
             )
             .unwrap();
             for (phase, expected) in [("cold", false), ("warm", true)] {
-                let prior_ticket_bytes = issued.lock().unwrap().last().copied();
-                let (resumed, bytes) = observed_handshake(&client, peer.clone()).await;
+                let (resumed, _) = observed_handshake(&client, peer.clone()).await;
                 assert_eq!(resumed, expected, "{name}/{version:?}/{phase}");
-                observations.push(serde_json::json!({"profile": name, "version": format!("{:?}", version.version), "phase": phase, "resumed": resumed, "prior_ticket_bytes": prior_ticket_bytes, "records_b64": STANDARD.encode(bytes)}));
             }
-            clients.push((name, version, client, peer, issued));
+            clients.push((name, version, client, peer));
         }
     }
     // Native ticket timestamps use real UNIX time, not Tokio's paused clock.
     tokio::time::sleep(Duration::from_secs(3)).await;
-    for (name, version, client, peer, issued) in clients {
-        let prior_ticket_bytes = issued.lock().unwrap().last().copied();
-        let (resumed, bytes) = observed_handshake(&client, peer).await;
-        // Safari16 does not offer the TLS1.2 session-ticket extension. Its
-        // stateful session ID has no server ticket-lifetime hint to expire.
-        let stateful_id = name == "safari" && version.version == rustls::ProtocolVersion::TLSv1_2;
+    for (name, version, client, peer) in clients {
+        let (resumed, _) = observed_handshake(&client, peer).await;
+        // Safari16/iOS14 do not offer the TLS1.2 session-ticket extension.
+        // Their stateful session IDs have no ticket-lifetime hint to expire.
+        let stateful_id =
+            matches!(name, "safari" | "ios") && version.version == rustls::ProtocolVersion::TLSv1_2;
         assert_eq!(
             resumed, stateful_id,
             "{name}/{version:?}: ticket hint expiry"
         );
-        observations.push(serde_json::json!({"profile": name, "version": format!("{:?}", version.version), "phase": "after-hint", "resumed": resumed, "prior_ticket_bytes": prior_ticket_bytes, "records_b64": STANDARD.encode(bytes)}));
-    }
-    if let Ok(path) = std::env::var("VOLE_FINGERPRINT_WARM_CAPTURE") {
-        std::fs::write(path, serde_json::to_vec_pretty(&observations).unwrap()).unwrap();
     }
 }
 
@@ -175,7 +162,7 @@ async fn named_reality_retains_browser_offer_but_rejects_tls12_server_hello() {
         let ordinary = client(
             &trusted(&chain),
             "fixture.invalid",
-            AnyTlsCertificatePolicy {
+            TlsClientPolicy {
                 client_fingerprint: profile,
                 ..Default::default()
             },
diff --git a/src/security/tls_quiche_tests.rs b/src/security/tls_quiche_tests.rs
new file mode 100644
index 0000000..486027e
--- /dev/null
+++ b/src/security/tls_quiche_tests.rs
@@ -0,0 +1,305 @@
+//! Memory-only authentication regressions using the actual QUIC TLS engine.
+use super::*;
+use crate::security::QuicheTls;
+use boring::{
+    pkey::PKey,
+    ssl::{SslContextBuilder, SslMethod, SslVerifyMode, SslVersion},
+    x509::X509,
+};
+
+fn peer(chain: &Chain, client_ca: Option<&Chain>) -> SslContextBuilder {
+    let mut builder = SslContextBuilder::new(SslMethod::tls()).unwrap();
+    builder
+        .set_min_proto_version(Some(SslVersion::TLS1_3))
+        .unwrap();
+    builder
+        .set_max_proto_version(Some(SslVersion::TLS1_3))
+        .unwrap();
+    builder
+        .set_certificate(&X509::from_der(&chain.certificates[0]).unwrap())
+        .unwrap();
+    for certificate in &chain.certificates[1..] {
+        builder
+            .add_extra_chain_cert(X509::from_der(certificate).unwrap())
+            .unwrap();
+    }
+    builder
+        .set_private_key(&PKey::private_key_from_der(chain.key.secret_der()).unwrap())
+        .unwrap();
+    if let Some(identity) = client_ca {
+        builder
+            .cert_store_mut()
+            .add_cert(X509::from_der(&identity.certificates[2]).unwrap())
+            .unwrap();
+        builder.set_verify(SslVerifyMode::PEER | SslVerifyMode::FAIL_IF_NO_PEER_CERT);
+    }
+    builder
+}
+
+fn options(policy: TlsCertificatePolicy) -> TlsClientOptions {
+    TlsClientOptions {
+        alpn: vec![b"h3".to_vec()],
+        required_alpn: Some(b"h3".to_vec()),
+        certificate: policy,
+        versions: TlsVersions::Tls13,
+        ..Default::default()
+    }
+}
+
+fn handshake(mut tls: QuicheTls, peer: SslContextBuilder) -> io::Result<()> {
+    let client_addr = "192.0.2.1:1234".parse().unwrap();
+    let server_addr = "192.0.2.2:443".parse().unwrap();
+    let mut config = tls.build_config()?;
+    config.enable_pacing(false);
+    let mut server_config =
+        ::quiche::Config::with_boring_ssl_ctx_builder(::quiche::PROTOCOL_VERSION, peer).unwrap();
+    server_config.set_application_protos(&[b"h3"]).unwrap();
+    server_config.enable_pacing(false);
+    let mut client = ::quiche::connect(
+        Some(tls.server_name()),
+        &::quiche::ConnectionId::from_ref(&[1; 20]),
+        client_addr,
+        server_addr,
+        &mut config,
+    )
+    .unwrap();
+    tls.prepare_connection(&mut client)?;
+    let mut server = ::quiche::accept(
+        &::quiche::ConnectionId::from_ref(&[2; 20]),
+        None,
+        server_addr,
+        client_addr,
+        &mut server_config,
+    )
+    .unwrap();
+    let mut packet = [0; 1500];
+    for _ in 0..64 {
+        transfer(
+            &mut client,
+            &mut server,
+            client_addr,
+            server_addr,
+            &mut packet,
+        )?;
+        transfer(
+            &mut server,
+            &mut client,
+            server_addr,
+            client_addr,
+            &mut packet,
+        )?;
+        if client.is_established() && server.is_established() {
+            return tls.check_handshake(&mut client);
+        }
+        if client.is_closed() || server.is_closed() {
+            break;
+        }
+    }
+    Err(io::Error::other("memory QUIC handshake did not complete"))
+}
+
+fn transfer(
+    sender: &mut ::quiche::Connection,
+    receiver: &mut ::quiche::Connection,
+    from: std::net::SocketAddr,
+    to: std::net::SocketAddr,
+    packet: &mut [u8],
+) -> io::Result<()> {
+    for _ in 0..64 {
+        match sender.send(packet) {
+            Ok((length, _)) => {
+                let result = receiver.recv(&mut packet[..length], ::quiche::RecvInfo { from, to });
+                if !matches!(result, Ok(_) | Err(::quiche::Error::Done)) {
+                    return Err(io::Error::other("memory QUIC authentication failed"));
+                }
+            }
+            Err(::quiche::Error::Done) => break,
+            Err(_) => return Err(io::Error::other("memory QUIC authentication failed")),
+        }
+    }
+    Ok(())
+}
+
+#[test]
+fn quiche_preserves_webpki_names_and_pin_precedence() {
+    let chain = chain(false);
+    for (context, name, policy, expected) in [
+        (trusted(&chain), "fixture.invalid", Default::default(), true),
+        (
+            SecurityContext::new(),
+            "fixture.invalid",
+            Default::default(),
+            false,
+        ),
+        (trusted(&chain), "other.invalid", Default::default(), false),
+        (
+            trusted(&chain),
+            "other.invalid",
+            TlsCertificatePolicy {
+                verification_name: Some("fixture.invalid".into()),
+                skip_cert_verify: true,
+                fingerprint: None,
+            },
+            true,
+        ),
+        (
+            SecurityContext::new(),
+            "other.invalid",
+            TlsCertificatePolicy {
+                fingerprint: Some(pin(&chain, 0)),
+                ..Default::default()
+            },
+            true,
+        ),
+        (
+            trusted(&chain),
+            "fixture.invalid",
+            TlsCertificatePolicy {
+                fingerprint: Some([0; 32]),
+                skip_cert_verify: true,
+                ..Default::default()
+            },
+            false,
+        ),
+        (
+            SecurityContext::new(),
+            "fixture.invalid",
+            TlsCertificatePolicy {
+                fingerprint: Some(pin(&chain, 1)),
+                ..Default::default()
+            },
+            true,
+        ),
+        (
+            SecurityContext::new(),
+            "other.invalid",
+            TlsCertificatePolicy {
+                fingerprint: Some(pin(&chain, 1)),
+                ..Default::default()
+            },
+            false,
+        ),
+    ] {
+        let client =
+            StandardTlsClient::with_options(&context, name, options(policy), 0, 65536).unwrap();
+        assert_eq!(
+            handshake(client.quiche_config().unwrap(), peer(&chain, None)).is_ok(),
+            expected
+        );
+    }
+    let expired = super::chain(true);
+    let client = StandardTlsClient::with_options(
+        &SecurityContext::new(),
+        "other.invalid",
+        options(TlsCertificatePolicy {
+            fingerprint: Some(pin(&expired, 0)),
+            ..Default::default()
+        }),
+        0,
+        65536,
+    )
+    .unwrap();
+    handshake(client.quiche_config().unwrap(), peer(&expired, None)).unwrap();
+}
+
+#[test]
+fn quiche_client_identity_is_verified_by_the_peer() {
+    let server = chain(false);
+    let trusted_identity = chain_with_usage(false, ExtendedKeyUsagePurpose::ClientAuth);
+    let other = chain_with_usage(false, ExtendedKeyUsagePurpose::ClientAuth);
+    for (identity, expected) in [
+        (Some(&trusted_identity), true),
+        (Some(&other), false),
+        (None, false),
+    ] {
+        let mut options = options(Default::default());
+        options.identity = identity.map(|chain| {
+            TlsClientIdentity::from_der(chain.certificates.clone(), chain.key.clone_key())
+        });
+        let client = StandardTlsClient::with_options(
+            &trusted(&server),
+            "fixture.invalid",
+            options,
+            0,
+            65536,
+        )
+        .unwrap();
+        assert_eq!(
+            handshake(
+                client.quiche_config().unwrap(),
+                peer(&server, Some(&trusted_identity))
+            )
+            .is_ok(),
+            expected
+        );
+    }
+}
+
+#[cfg(feature = "ech")]
+#[test]
+fn quiche_requires_real_ech_acceptance_and_reselects_the_native_backend() {
+    use boring::{hpke::HpkeKey, ssl::SslEchKeys};
+    use hpke::{Kem, Serializable};
+    use rand::SeedableRng;
+
+    let chain = chain(false);
+    let mut rng = rand::rngs::StdRng::try_from_rng(&mut rand::rngs::SysRng).unwrap();
+    let (private, public) = hpke::kem::X25519HkdfSha256::gen_keypair_with_rng(&mut rng);
+    let mut contents = vec![7, 0, 32, 0, 32];
+    contents.extend_from_slice(&public.to_bytes());
+    contents.extend_from_slice(&[0, 4, 0, 1, 0, 1, 0, 14]);
+    contents.extend_from_slice(b"public.invalid");
+    contents.extend_from_slice(&[0, 0]);
+    let mut config = vec![0xfe, 0x0d];
+    config.extend_from_slice(&(contents.len() as u16).to_be_bytes());
+    config.extend_from_slice(&contents);
+    let mut list = (config.len() as u16).to_be_bytes().to_vec();
+    list.extend_from_slice(&config);
+    let mut options = options(TlsCertificatePolicy {
+        fingerprint: Some(pin(&chain, 0)),
+        ..Default::default()
+    });
+    options.ech =
+        Some(crate::config::StaticEchConfig::from_config_list_for_backend(&list, false).unwrap());
+    let client =
+        StandardTlsClient::with_options(&trusted(&chain), "fixture.invalid", options, 0, 65536)
+            .unwrap();
+    for accept_ech in [true, false] {
+        let server = peer(&chain, None);
+        if accept_ech {
+            // The existing safe constructor imports X25519, despite its name.
+            let key = HpkeKey::dhkem_p256_sha256(&private.to_bytes()).unwrap();
+            let mut keys = SslEchKeys::builder().unwrap();
+            keys.add_key(true, &config, key).unwrap();
+            server.set_ech_keys(&keys.build()).unwrap();
+        }
+        assert_eq!(
+            handshake(client.quiche_config().unwrap(), server).is_ok(),
+            accept_ech,
+            "a matching pin must not admit rejected ECH"
+        );
+    }
+
+    // A rustls-compatible P-256-only source cannot silently become ECH GREASE
+    // when the same client switches to the native H3 backend.
+    let suite = crate::security::ech::SUITES[15];
+    let (key, _) = suite.generate_key_pair().unwrap();
+    let mut contents = vec![7];
+    contents.extend_from_slice(&u16::from(suite.suite().kem).to_be_bytes());
+    contents.extend_from_slice(&(key.0.len() as u16).to_be_bytes());
+    contents.extend_from_slice(&key.0);
+    contents.extend_from_slice(&[0, 4, 0, 1, 0, 1, 0, 14]);
+    contents.extend_from_slice(b"public.invalid");
+    contents.extend_from_slice(&[0, 0]);
+    let mut list = ((contents.len() + 4) as u16).to_be_bytes().to_vec();
+    list.extend_from_slice(&[0xfe, 0x0d]);
+    list.extend_from_slice(&(contents.len() as u16).to_be_bytes());
+    list.extend_from_slice(&contents);
+    let mut options = self::options(Default::default());
+    options.ech =
+        Some(crate::config::StaticEchConfig::from_config_list_for_backend(&list, false).unwrap());
+    let client =
+        StandardTlsClient::with_options(&trusted(&chain), "fixture.invalid", options, 0, 65536)
+            .unwrap();
+    assert!(client.quiche_config().is_err());
+}
diff --git a/src/security/tls_tests.rs b/src/security/tls_tests.rs
index 2032769..cd769d7 100644
--- a/src/security/tls_tests.rs
+++ b/src/security/tls_tests.rs
@@ -1,5 +1,8 @@
 use super::*;
-use crate::config::AnyTlsCertificatePolicy;
+
+#[path = "identity_rotation_tests.rs"]
+mod identity_rotation_memory_tests;
+use crate::config::TlsClientPolicy;
 use rcgen::{
     BasicConstraints, CertificateParams, CertifiedIssuer, DnType, ExtendedKeyUsagePurpose, IsCa,
     KeyPair, KeyUsagePurpose, date_time_ymd,
@@ -22,11 +25,42 @@ mod named;
 #[path = "tls_named_wire_tests.rs"]
 mod named_wire;
 
+#[cfg(feature = "quiche-h3-transport")]
+#[path = "tls_quiche_tests.rs"]
+mod quiche;
+
+#[cfg(feature = "outbound-trusttunnel")]
+#[path = "trusttunnel_alpn_tests.rs"]
+mod trusttunnel_alpn_memory;
+
 struct Chain {
     certificates: Vec<CertificateDer<'static>>,
     key: PrivateKeyDer<'static>,
 }
 
+impl Chain {
+    fn identity_pem(&self) -> crate::config::TlsIdentityPem {
+        use base64::{Engine as _, engine::general_purpose::STANDARD};
+        crate::config::TlsIdentityPem {
+            certificate: self
+                .certificates
+                .iter()
+                .map(|cert| {
+                    format!(
+                        "-----BEGIN CERTIFICATE-----\n{}\n-----END CERTIFICATE-----\n",
+                        STANDARD.encode(cert.as_ref())
+                    )
+                })
+                .collect(),
+            private_key: format!(
+                "-----BEGIN PRIVATE KEY-----\n{}\n-----END PRIVATE KEY-----\n",
+                STANDARD.encode(self.key.secret_der())
+            ),
+            origin: None,
+        }
+    }
+}
+
 fn ca(name: &str) -> CertificateParams {
     let mut params = CertificateParams::default();
     params.distinguished_name.push(DnType::CommonName, name);
@@ -78,27 +112,15 @@ fn trusted(chain: &Chain) -> SecurityContext {
     SecurityContext {
         provider: Arc::new(rustls::crypto::ring::default_provider()),
         tls_roots: Arc::new(roots),
+        identities: Arc::default(),
     }
 }
 
-fn client(
-    context: &SecurityContext,
-    name: &str,
-    policy: AnyTlsCertificatePolicy,
-) -> StandardTlsClient {
+fn client(context: &SecurityContext, name: &str, policy: TlsClientPolicy) -> StandardTlsClient {
     StandardTlsClient::with_options(
         context,
         name,
-        TlsClientOptions {
-            client_fingerprint: policy.client_fingerprint,
-            certificate: TlsCertificatePolicy {
-                verification_name: None,
-                skip_cert_verify: policy.skip_cert_verify,
-                fingerprint: policy.fingerprint,
-            },
-            alpn: policy.alpn,
-            ..Default::default()
-        },
+        TlsClientOptions::from_policy(&policy, None, context).unwrap(),
         4,
         DEFAULT_TLS_BUFFER_LIMIT,
     )
@@ -228,6 +250,41 @@ async fn named_fingerprint_uses_the_shared_webpki_policy_and_transport_alpn() {
     }
 }
 
+#[tokio::test]
+async fn configured_roots_authenticate_standard_and_named_tls_without_relaxing_names() {
+    use base64::{Engine as _, engine::general_purpose::STANDARD};
+    let chain = chain(false);
+    let pem = format!(
+        "-----BEGIN CERTIFICATE-----\n{}\n-----END CERTIFICATE-----\n",
+        STANDARD.encode(&chain.certificates[2])
+    );
+    let config = crate::config::Config::parse_yaml(
+        &serde_json::to_vec(&serde_json::json!({
+            "tls": {"custom-certifactes": [pem]},
+        }))
+        .unwrap(),
+    )
+    .unwrap();
+    let context = SecurityContext::with_certificates(&config.tls, Vec::new());
+    let server = server(&chain, &TLS13, false);
+    for profile in crate::security::test_profiles() {
+        for (name, expected) in [("fixture.invalid", true), ("different.invalid", false)] {
+            let client = StandardTlsClient::with_options(
+                &context,
+                name,
+                TlsClientOptions {
+                    client_fingerprint: *profile,
+                    ..Default::default()
+                },
+                0,
+                DEFAULT_TLS_BUFFER_LIMIT,
+            )
+            .unwrap();
+            assert_eq!(handshake(&client, server.clone()).await.0, expected);
+        }
+    }
+}
+
 #[cfg(feature = "tls-fingerprint")]
 #[tokio::test]
 async fn named_fingerprint_resumption_is_node_owned_and_disabled_at_zero_budget() {
@@ -370,7 +427,7 @@ async fn named_fingerprint_close_notify_has_a_five_second_bound() {
         let client = client(
             &trusted(&chain),
             "fixture.invalid",
-            AnyTlsCertificatePolicy {
+            TlsClientPolicy {
                 client_fingerprint: Some(profile),
                 ..Default::default()
             },
@@ -395,11 +452,6 @@ async fn named_fingerprint_close_notify_has_a_five_second_bound() {
 
 #[tokio::test]
 async fn webpki_rejects_untrusted_wrong_name_and_expired_unless_explicitly_skipped() {
-    #[cfg(any(test, feature = "interop-test"))]
-    let mut _case = crate::resources::case_events::Case::new(
-        "FOUNDATIONS-SECURITY",
-        "webpki_rejects_untrusted_wrong_name_and_expired_unless_explicitly_skipped",
-    );
     for &profile in crate::security::test_profiles() {
         for expired in [false, true] {
             let chain = chain(expired);
@@ -414,7 +466,7 @@ async fn webpki_rejects_untrusted_wrong_name_and_expired_unless_explicitly_skipp
                         &client(
                             &context,
                             name,
-                            AnyTlsCertificatePolicy {
+                            TlsClientPolicy {
                                 client_fingerprint: profile,
                                 ..Default::default()
                             }
@@ -425,9 +477,12 @@ async fn webpki_rejects_untrusted_wrong_name_and_expired_unless_explicitly_skipp
                     .0,
                     expected
                 );
-                let insecure = AnyTlsCertificatePolicy {
+                let insecure = TlsClientPolicy {
+                    certificate: TlsCertificatePolicy {
+                        skip_cert_verify: true,
+                        ..Default::default()
+                    },
                     client_fingerprint: profile,
-                    skip_cert_verify: true,
                     ..Default::default()
                 };
                 assert!(
@@ -442,11 +497,6 @@ async fn webpki_rejects_untrusted_wrong_name_and_expired_unless_explicitly_skipp
 
 #[tokio::test]
 async fn leaf_pin_is_trust_but_nonleaf_pin_checks_chain_name_and_expiry() {
-    #[cfg(any(test, feature = "interop-test"))]
-    let mut _case = crate::resources::case_events::Case::new(
-        "FOUNDATIONS-SECURITY",
-        "leaf_pin_is_trust_but_nonleaf_pin_checks_chain_name_and_expiry",
-    );
     for &profile in crate::security::test_profiles() {
         for expired in [false, true] {
             let chain = chain(expired);
@@ -454,10 +504,13 @@ async fn leaf_pin_is_trust_but_nonleaf_pin_checks_chain_name_and_expiry() {
             for index in 0..3 {
                 for name in ["fixture.invalid", "wrong.invalid"] {
                     for skip in [false, true] {
-                        let policy = AnyTlsCertificatePolicy {
+                        let policy = TlsClientPolicy {
+                            certificate: TlsCertificatePolicy {
+                                fingerprint: Some(pin(&chain, index)),
+                                skip_cert_verify: skip,
+                                ..Default::default()
+                            },
                             client_fingerprint: profile,
-                            fingerprint: Some(pin(&chain, index)),
-                            skip_cert_verify: skip,
                             ..Default::default()
                         };
                         let expected = index == 0 || (!expired && name == "fixture.invalid");
@@ -474,10 +527,13 @@ async fn leaf_pin_is_trust_but_nonleaf_pin_checks_chain_name_and_expiry() {
                     }
                 }
             }
-            let policy = AnyTlsCertificatePolicy {
+            let policy = TlsClientPolicy {
+                certificate: TlsCertificatePolicy {
+                    fingerprint: Some([0; 32]),
+                    skip_cert_verify: true,
+                    ..Default::default()
+                },
                 client_fingerprint: profile,
-                fingerprint: Some([0; 32]),
-                skip_cert_verify: true,
                 ..Default::default()
             };
             assert!(
@@ -496,10 +552,13 @@ async fn leaf_pin_is_trust_but_nonleaf_pin_checks_chain_name_and_expiry() {
                 key: chain.key.clone_key(),
             };
             unrelated.certificates.push(other.certificates[2].clone());
-            let policy = AnyTlsCertificatePolicy {
+            let policy = TlsClientPolicy {
+                certificate: TlsCertificatePolicy {
+                    fingerprint: Some(pin(&other, 2)),
+                    skip_cert_verify: true,
+                    ..Default::default()
+                },
                 client_fingerprint: profile,
-                fingerprint: Some(pin(&other, 2)),
-                skip_cert_verify: true,
                 ..Default::default()
             };
             assert!(
@@ -524,13 +583,7 @@ fn super_server(chain: &Chain) -> Arc<ServerConfig> {
 
 #[tokio::test]
 async fn ticket_storage_obeys_exact_node_budget_and_consumes_each_ticket_once() {
-    #[cfg(any(test, feature = "interop-test"))]
-    let mut _case = crate::resources::case_events::Case::new(
-        "FOUNDATIONS-SECURITY",
-        "ticket_storage_obeys_exact_node_budget_and_consumes_each_ticket_once",
-    );
     use crate::security::resumption::NodeSessionStore;
-    use rustls::client::ClientSessionStore;
     let chain = chain(false);
     let context = trusted(&chain);
     let name = ServerName::try_from("fixture.invalid").unwrap().to_owned();
@@ -538,12 +591,15 @@ async fn ticket_storage_obeys_exact_node_budget_and_consumes_each_ticket_once()
         for capacity in [0, 1, 4] {
             let store = Arc::new(NodeSessionStore::new(name.clone(), capacity));
             let mut client = client(&context, "fixture.invalid", Default::default());
-            let StandardConnector::Rustls(connector) = &client.connector else {
+            let Some(StandardConnector::Rustls(connector)) = &client.connector else {
                 panic!("unprofiled TLS uses rustls")
             };
             let mut config = connector.config().as_ref().clone();
-            config.resumption = Resumption::store(store.clone());
-            client.connector = StandardConnector::Rustls(TlsConnector::from(Arc::new(config)));
+            let epoch_store = store.for_epoch(Default::default());
+            config.resumption = Resumption::store(epoch_store.clone());
+            client.connector = Some(StandardConnector::Rustls(TlsConnector::from(Arc::new(
+                config,
+            ))));
             let mut server = server(&chain, version, false);
             Arc::get_mut(&mut server).unwrap().send_tls13_tickets = 8;
             assert!(handshake(&client, server.clone()).await.0);
@@ -554,19 +610,19 @@ async fn ticket_storage_obeys_exact_node_budget_and_consumes_each_ticket_once()
             };
             assert_eq!(store.stored_sessions(), expected);
             let wrong = ServerName::try_from("wrong.invalid").unwrap();
-            assert!(store.take_tls13_ticket(&wrong).is_none());
-            assert!(store.tls12_session(&wrong).is_none());
+            assert!(epoch_store.take_tls13_ticket(&wrong).is_none());
+            assert!(epoch_store.tls12_session(&wrong).is_none());
             if version == &TLS13 {
                 for _ in 0..expected {
-                    assert!(store.take_tls13_ticket(&name).is_some());
+                    assert!(epoch_store.take_tls13_ticket(&name).is_some());
                 }
-                assert!(store.take_tls13_ticket(&name).is_none());
+                assert!(epoch_store.take_tls13_ticket(&name).is_none());
             } else {
                 assert_eq!(
                     handshake(&client, server.clone()).await.1.resumed,
                     capacity > 0
                 );
-                store.remove_tls12_session(&name);
+                epoch_store.remove_tls12_session(&name);
             }
             assert_eq!(store.stored_sessions(), 0);
         }
@@ -575,19 +631,17 @@ async fn ticket_storage_obeys_exact_node_budget_and_consumes_each_ticket_once()
 
 #[tokio::test]
 async fn every_certificate_policy_verifies_tls12_and_tls13_handshake_signatures() {
-    #[cfg(any(test, feature = "interop-test"))]
-    let mut _case = crate::resources::case_events::Case::new(
-        "FOUNDATIONS-SECURITY",
-        "every_certificate_policy_verifies_tls12_and_tls13_handshake_signatures",
-    );
     for &profile in crate::security::test_profiles() {
         let chain = chain(false);
         for version in [&TLS12, &TLS13] {
             for fingerprint in [None, Some(pin(&chain, 0)), Some(pin(&chain, 1))] {
-                let policy = AnyTlsCertificatePolicy {
+                let policy = TlsClientPolicy {
+                    certificate: TlsCertificatePolicy {
+                        skip_cert_verify: true,
+                        fingerprint,
+                        ..Default::default()
+                    },
                     client_fingerprint: profile,
-                    skip_cert_verify: true,
-                    fingerprint,
                     ..Default::default()
                 };
                 let client = client(&SecurityContext::new(), "fixture.invalid", policy);
@@ -600,19 +654,17 @@ async fn every_certificate_policy_verifies_tls12_and_tls13_handshake_signatures(
 
 #[tokio::test]
 async fn vless_keeps_webpki_tls13_and_required_h2_after_anytls_connections() {
-    #[cfg(any(test, feature = "interop-test"))]
-    let mut _case = crate::resources::case_events::Case::new(
-        "FOUNDATIONS-SECURITY",
-        "vless_keeps_webpki_tls13_and_required_h2_after_anytls_connections",
-    );
     let chain = chain(false);
     let mut endpoint = server(&chain, &TLS13, false);
     Arc::get_mut(&mut endpoint).unwrap().alpn_protocols = vec![b"h2".to_vec()];
     let insecure = client(
         &SecurityContext::new(),
         "fixture.invalid",
-        AnyTlsCertificatePolicy {
-            skip_cert_verify: true,
+        TlsClientPolicy {
+            certificate: TlsCertificatePolicy {
+                skip_cert_verify: true,
+                ..Default::default()
+            },
             alpn: vec![b"h2".to_vec()],
             ..Default::default()
         },
@@ -643,18 +695,16 @@ async fn vless_keeps_webpki_tls13_and_required_h2_after_anytls_connections() {
 
 #[tokio::test]
 async fn alpn_and_tls_resumption_are_isolated_between_node_policies() {
-    #[cfg(any(test, feature = "interop-test"))]
-    let mut _case = crate::resources::case_events::Case::new(
-        "FOUNDATIONS-SECURITY",
-        "alpn_and_tls_resumption_are_isolated_between_node_policies",
-    );
     let chain = chain(false);
     let server = server(&chain, &TLS13, false);
     let context = trusted(&chain);
     let alpn = vec![b"custom".to_vec(), b"h2".to_vec(), b"http/1.1".to_vec()];
-    let policy = AnyTlsCertificatePolicy {
+    let policy = TlsClientPolicy {
+        certificate: TlsCertificatePolicy {
+            fingerprint: Some(pin(&chain, 2)),
+            ..Default::default()
+        },
         alpn: alpn.clone(),
-        fingerprint: Some(pin(&chain, 2)),
         ..Default::default()
     };
     let first = client(&context, "fixture.invalid", policy.clone());
@@ -682,9 +732,12 @@ async fn alpn_and_tls_resumption_are_isolated_between_node_policies() {
         .await
         .0
     );
-    let wrong = AnyTlsCertificatePolicy {
-        fingerprint: Some([0; 32]),
-        skip_cert_verify: true,
+    let wrong = TlsClientPolicy {
+        certificate: TlsCertificatePolicy {
+            fingerprint: Some([0; 32]),
+            skip_cert_verify: true,
+            ..Default::default()
+        },
         ..policy
     };
     assert!(
@@ -708,11 +761,6 @@ async fn alpn_and_tls_resumption_are_isolated_between_node_policies() {
 
 #[tokio::test]
 async fn explicit_verification_name_does_not_change_sni_or_allow_skip_to_override_it() {
-    #[cfg(any(test, feature = "interop-test"))]
-    let mut _case = crate::resources::case_events::Case::new(
-        "FOUNDATIONS-SECURITY",
-        "explicit_verification_name_does_not_change_sni_or_allow_skip_to_override_it",
-    );
     for &profile in crate::security::test_profiles() {
         let chain = chain(false);
         let context = trusted(&chain);
@@ -724,7 +772,7 @@ async fn explicit_verification_name_does_not_change_sni_or_allow_skip_to_overrid
             ("wrong.invalid", true, Some(pin(&chain, 1)), false),
             ("fixture.invalid", true, Some([0; 32]), false),
         ] {
-            let options = TlsClientOptions {
+            let policy = TlsClientPolicy {
                 client_fingerprint: profile,
                 certificate: TlsCertificatePolicy {
                     verification_name: Some(name.into()),
@@ -736,7 +784,7 @@ async fn explicit_verification_name_does_not_change_sni_or_allow_skip_to_overrid
             let client = StandardTlsClient::with_options(
                 &context,
                 "sni.invalid",
-                options,
+                TlsClientOptions::from_policy(&policy, None, &context).unwrap(),
                 1,
                 DEFAULT_TLS_BUFFER_LIMIT,
             )
@@ -750,11 +798,6 @@ async fn explicit_verification_name_does_not_change_sni_or_allow_skip_to_overrid
 
 #[tokio::test]
 async fn mutual_tls_identity_is_required_verified_and_not_shared_between_clients() {
-    #[cfg(any(test, feature = "interop-test"))]
-    let mut _case = crate::resources::case_events::Case::new(
-        "FOUNDATIONS-SECURITY",
-        "mutual_tls_identity_is_required_verified_and_not_shared_between_clients",
-    );
     for &profile in crate::security::test_profiles() {
         let chain = chain(false);
         let identity = chain_with_usage(false, ExtendedKeyUsagePurpose::ClientAuth);
@@ -782,17 +825,15 @@ async fn mutual_tls_identity_is_required_verified_and_not_shared_between_clients
                 (Some(&unknown), false),
                 (Some(&identity), true),
             ] {
-                let options = TlsClientOptions {
+                let policy = TlsClientPolicy {
                     client_fingerprint: profile,
-                    identity: cert.map(|cert| {
-                        TlsClientIdentity::from_der(cert.certificates.clone(), cert.key.clone_key())
-                    }),
+                    identity: cert.map(Chain::identity_pem),
                     ..Default::default()
                 };
                 let client = StandardTlsClient::with_options(
                     &trusted(&chain),
                     "fixture.invalid",
-                    options,
+                    TlsClientOptions::from_policy(&policy, None, &trusted(&chain)).unwrap(),
                     1,
                     DEFAULT_TLS_BUFFER_LIMIT,
                 )
@@ -813,11 +854,6 @@ async fn mutual_tls_identity_is_required_verified_and_not_shared_between_clients
 
 #[test]
 fn tls_options_reject_invalid_alpn_identity_and_budget_before_using_a_stream() {
-    #[cfg(any(test, feature = "interop-test"))]
-    let mut _case = crate::resources::case_events::Case::new(
-        "FOUNDATIONS-SECURITY",
-        "tls_options_reject_invalid_alpn_identity_and_budget_before_using_a_stream",
-    );
     let context = SecurityContext::new();
     for options in [
         TlsClientOptions {
@@ -868,11 +904,6 @@ fn tls_options_reject_invalid_alpn_identity_and_budget_before_using_a_stream() {
 
 #[tokio::test]
 async fn certificate_rejection_delivers_no_business_bytes_and_diagnostics_are_redacted() {
-    #[cfg(any(test, feature = "interop-test"))]
-    let mut _case = crate::resources::case_events::Case::new(
-        "FOUNDATIONS-SECURITY",
-        "certificate_rejection_delivers_no_business_bytes_and_diagnostics_are_redacted",
-    );
     for fingerprint in [None, Some([0; 32])] {
         let chain = chain(false);
         let client = StandardTlsClient::with_options(
@@ -924,11 +955,6 @@ async fn certificate_rejection_delivers_no_business_bytes_and_diagnostics_are_re
 
 #[tokio::test]
 async fn tls_close_write_sends_notify_without_closing_the_supplied_transport() {
-    #[cfg(any(test, feature = "interop-test"))]
-    let mut _case = crate::resources::case_events::Case::new(
-        "FOUNDATIONS-SECURITY",
-        "tls_close_write_sends_notify_without_closing_the_supplied_transport",
-    );
     for &profile in crate::security::test_profiles() {
         let chain = chain(false);
         let client = StandardTlsClient::with_options(
@@ -984,11 +1010,6 @@ async fn tls_close_write_sends_notify_without_closing_the_supplied_transport() {
 
 #[tokio::test]
 async fn tls_close_notify_flush_has_a_five_second_bound() {
-    #[cfg(any(test, feature = "interop-test"))]
-    let mut _case = crate::resources::case_events::Case::new(
-        "FOUNDATIONS-SECURITY",
-        "tls_close_notify_flush_has_a_five_second_bound",
-    );
     let chain = chain(false);
     let client = client(&trusted(&chain), "fixture.invalid", Default::default());
     let (client_io, server_io) = tokio::io::duplex(128);
@@ -1018,18 +1039,13 @@ async fn tls_close_notify_flush_has_a_five_second_bound() {
 
 #[tokio::test]
 async fn cancelling_tls_handshake_releases_the_caller_supplied_stream() {
-    #[cfg(any(test, feature = "interop-test"))]
-    let mut _case = crate::resources::case_events::Case::new(
-        "FOUNDATIONS-SECURITY",
-        "cancelling_tls_handshake_releases_the_caller_supplied_stream",
-    );
     for &profile in crate::security::test_profiles() {
         let (client_io, mut peer) = tokio::io::duplex(4096);
         let chain = chain(false);
         let client = client(
             &trusted(&chain),
             "fixture.invalid",
-            AnyTlsCertificatePolicy {
+            TlsClientPolicy {
                 client_fingerprint: profile,
                 ..Default::default()
             },
diff --git a/src/security/trusttunnel_alpn_tests.rs b/src/security/trusttunnel_alpn_tests.rs
new file mode 100644
index 0000000..fcacab8
--- /dev/null
+++ b/src/security/trusttunnel_alpn_tests.rs
@@ -0,0 +1,183 @@
+//! Authenticated TrustTunnel H2 over duplex IO, without host sockets.
+use super::*;
+use crate::{
+    config::{Config, ProxyProtocol},
+    dispatch::{BoxStream, DatagramTransport, DispatchError},
+    outbound::{
+        ConnectedStream, DatagramRequest, EstablishContext, OutboundConnector, UpstreamPath,
+        trusttunnel::TrustTunnelOutbound,
+    },
+    session::{Destination, InboundKind, StreamSession},
+};
+use async_trait::async_trait;
+use tokio_util::task::TaskTracker;
+
+struct MemoryUpstream(Mutex<Option<tokio::io::DuplexStream>>);
+
+#[async_trait]
+impl OutboundConnector for MemoryUpstream {
+    async fn connect_stream(
+        &self,
+        session: StreamSession,
+        _: &EstablishContext,
+    ) -> Result<ConnectedStream, DispatchError> {
+        let io = self
+            .0
+            .lock()
+            .unwrap()
+            .take()
+            .ok_or(DispatchError::NotAllowed)?;
+        Ok(ConnectedStream {
+            io: Box::new(io),
+            effective_peer: session.destination,
+        })
+    }
+
+    async fn open_datagram(
+        &self,
+        _: DatagramRequest,
+        _: &EstablishContext,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        Err(DispatchError::NotAllowed)
+    }
+}
+
+async fn serve_h2(peer: tokio::io::DuplexStream, tls: Arc<ServerConfig>) -> bool {
+    let Ok(tls) = tokio_rustls::TlsAcceptor::from(tls).accept(peer).await else {
+        return false;
+    };
+    let Ok(mut connection) = h2::server::handshake(tls).await else {
+        return false;
+    };
+    let Some(Ok((request, mut response))) = connection.accept().await else {
+        return false;
+    };
+    assert_eq!(request.method(), http::Method::CONNECT);
+    assert_eq!(request.uri().authority().unwrap(), "target.invalid:443");
+    assert_eq!(request.headers()["proxy-authorization"], "Basic dTpw");
+    let exchange = async {
+        let mut receive = request.into_body();
+        let data = receive.data().await.unwrap().unwrap();
+        assert_eq!(data.as_ref(), b"ping");
+        receive.flow_control().release_capacity(data.len()).unwrap();
+        response
+            .send_response(http::Response::new(()), false)
+            .unwrap()
+            .send_data(bytes::Bytes::from_static(b"pong"), true)
+            .unwrap();
+        true
+    };
+    let completed = tokio::select! {
+        completed = exchange => completed,
+        _ = std::future::poll_fn(|cx| connection.poll_closed(cx)) => false,
+    };
+    connection.graceful_shutdown();
+    let _ = std::future::poll_fn(|cx| connection.poll_closed(cx)).await;
+    completed
+}
+
+#[tokio::test]
+async fn trusttunnel_h2_prior_knowledge_alpn_memory() {
+    let chain = chain(false);
+    let context = trusted(&chain);
+    for &profile in crate::security::test_profiles() {
+        for (alpn, bad_pin, expected) in [
+            (Some(b"h2".as_slice()), false, true),
+            (Some(b"http/1.1".as_slice()), false, false),
+            (None, true, false),
+            (None, false, true),
+        ] {
+            let config = Config::parse_yaml(
+                b"proxies:\n  - name: tunnel\n    type: trusttunnel\n    server: fixture.invalid\n    port: 443\n    username: u\n    password: p\n    alpn: [h2, http/1.1]\n",
+            )
+            .unwrap();
+            let ProxyProtocol::TrustTunnel(mut config) = config.proxies[0].protocol.clone() else {
+                unreachable!();
+            };
+            config.tls.client_fingerprint = profile;
+            if bad_pin {
+                config.tls.certificate.fingerprint = Some([0xab; 32]);
+                config.tls.certificate.skip_cert_verify = true;
+            }
+            let mut endpoint = server(&chain, &TLS13, false);
+            Arc::get_mut(&mut endpoint).unwrap().alpn_protocols =
+                alpn.map_or_else(Vec::new, |protocol| vec![protocol.to_vec()]);
+            let (io, peer) = tokio::io::duplex(65536);
+            let peers = TaskTracker::new();
+            let peer = peers.spawn(async move {
+                tokio::time::timeout(Duration::from_secs(5), serve_h2(peer, endpoint)).await
+            });
+            let node = TrustTunnelOutbound::with_shared_security(
+                &config,
+                UpstreamPath::proxy(Arc::new(MemoryUpstream(Mutex::new(Some(io))))),
+                &context,
+                0,
+                DEFAULT_TLS_BUFFER_LIMIT,
+            )
+            .unwrap();
+            let result = tokio::time::timeout(Duration::from_secs(3), async {
+                let mut stream: BoxStream = node
+                    .connect_stream(
+                        StreamSession {
+                            metadata: Default::default(),
+                            inbound: InboundKind::InternalDns,
+                            source: "127.0.0.1:1000".parse().unwrap(),
+                            destination: Destination::Domain {
+                                host: "target.invalid".into(),
+                                port: 443,
+                            },
+                            sniffed_domain: None,
+                        },
+                        &EstablishContext::with_timeout(Duration::from_secs(3)),
+                    )
+                    .await
+                    .map_err(io::Error::other)?
+                    .io;
+                stream.write_all(b"ping").await?;
+                stream.flush().await?;
+                let mut response = Vec::new();
+                stream.read_to_end(&mut response).await?;
+                assert_eq!(response, b"pong");
+                stream.shutdown().await
+            })
+            .await;
+            tokio::time::timeout(Duration::from_secs(3), node.shutdown())
+                .await
+                .unwrap();
+            peers.close();
+            peers.wait().await;
+            let peer_completed = peer.await.unwrap().unwrap();
+            assert!(
+                result.is_ok(),
+                "profile={profile:?}, negotiated={alpn:?}, bad_pin={bad_pin}: client timed out"
+            );
+            assert_eq!(
+                result.as_ref().is_ok_and(|result| result.is_ok()),
+                expected,
+                "profile={profile:?}, negotiated={alpn:?}, bad_pin={bad_pin}, result={result:?}"
+            );
+            assert_eq!(peer_completed, expected);
+        }
+    }
+}
+
+#[tokio::test]
+async fn standard_required_h2_still_rejects_absent_alpn_memory() {
+    let chain = chain(false);
+    for &profile in crate::security::test_profiles() {
+        let client = StandardTlsClient::with_options(
+            &trusted(&chain),
+            "fixture.invalid",
+            TlsClientOptions {
+                client_fingerprint: profile,
+                alpn: vec![b"h2".to_vec()],
+                required_alpn: Some(b"h2".to_vec()),
+                ..Default::default()
+            },
+            0,
+            DEFAULT_TLS_BUFFER_LIMIT,
+        )
+        .unwrap();
+        assert!(!handshake(&client, server(&chain, &TLS13, false)).await.0);
+    }
+}
diff --git a/src/security/vision.rs b/src/security/vision.rs
index fe2173a..f65883a 100644
--- a/src/security/vision.rs
+++ b/src/security/vision.rs
@@ -25,6 +25,7 @@ mod tests {
         let context = SecurityContext {
             provider: provider.clone(),
             tls_roots: Arc::new(roots),
+            identities: Arc::default(),
         };
         let client = StandardTlsClient::with_options(
             &context,
@@ -87,10 +88,6 @@ mod tests {
     }
     #[tokio::test]
     async fn record_boundary_preserves_buffered_plaintext_and_coalesced_raw_tail_and_flush_order() {
-        let _case = crate::resources::case_events::Case::new(
-            "VLESS-UNIT",
-            "record_boundary_preserves_buffered_plaintext_and_coalesced_raw_tail_and_flush_order",
-        );
         for &profile in crate::security::test_profiles() {
             for limit in [1, 3, 65536] {
                 tokio::time::timeout(Duration::from_secs(3), async {
diff --git a/src/session.rs b/src/session.rs
index 04f5a0a..a5c66a0 100644
--- a/src/session.rs
+++ b/src/session.rs
@@ -103,20 +103,97 @@ impl fmt::Display for Destination {
 pub enum InboundKind {
     Tun,
     Http,
+    Https,
     Socks5,
     /// Core-originated DNS traffic sent through the raw proxy dispatcher.
     /// This context must never be passed back through the routing dispatcher.
     InternalDns,
-    /// Core-owned GeoData HTTPS traffic sent through the raw default proxy.
-    /// This context must never be passed through routing or fall back to direct.
+    /// Core-owned GeoData HTTPS traffic routed by the current mode and rules.
     InternalGeoData,
     /// Core-owned latency probe sent through a node-only default proxy graph.
     /// This context never enters the public inbound or routing pipeline.
     InternalMeasure,
 }
 
+/// Authenticated ingress identity owned by a request or authorized association.
+/// Debug never exposes usernames; the Arc does not retain credential/config state.
+#[derive(Clone, Default, PartialEq, Eq)]
+pub struct InboundMetadata {
+    pub local_port: u16,
+    pub user: Option<Arc<str>>,
+    /// Actual accepted socket address, distinct from its proxy request target.
+    pub local_address: Option<SocketAddr>,
+    pub(crate) original: Option<Arc<InboundSnapshot>>,
+}
+/// Immutable ingress facts, captured before sniffing/routing/upstream rewrites.
+/// It owns only small values, never a runtime/configuration generation.
+#[derive(Clone, PartialEq, Eq)]
+pub(crate) struct InboundSnapshot {
+    pub source: SocketAddr,
+    pub destination: Destination,
+    pub socket_destination: Option<SocketAddr>,
+    pub inbound: InboundKind,
+    pub user: Option<Arc<str>>,
+}
+impl fmt::Debug for InboundSnapshot {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("InboundSnapshot { .. }")
+    }
+}
+impl fmt::Debug for InboundMetadata {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter
+            .debug_struct("InboundMetadata")
+            .field("local_port", &self.local_port)
+            .field("authenticated", &self.user.is_some())
+            .finish()
+    }
+}
+impl InboundMetadata {
+    pub const fn new(local_port: u16) -> Self {
+        Self {
+            local_port,
+            user: None,
+            local_address: None,
+            original: None,
+        }
+    }
+    pub(crate) fn snapshot(
+        &self,
+        source: SocketAddr,
+        inbound: InboundKind,
+        destination: &Destination,
+    ) -> Arc<InboundSnapshot> {
+        self.original
+            .clone()
+            .unwrap_or_else(|| Arc::new(self.facts(source, inbound, destination)))
+    }
+    pub(crate) fn facts(
+        &self,
+        source: SocketAddr,
+        inbound: InboundKind,
+        destination: &Destination,
+    ) -> InboundSnapshot {
+        InboundSnapshot {
+            source,
+            destination: destination.clone(),
+            inbound,
+            user: self.user.clone(),
+            socket_destination: if inbound == InboundKind::Tun {
+                match destination {
+                    Destination::Ip(address) => Some(*address),
+                    _ => None,
+                }
+            } else {
+                self.local_address
+            },
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct StreamSession {
+    pub metadata: InboundMetadata,
     pub inbound: InboundKind,
     pub source: SocketAddr,
     pub destination: Destination,
@@ -126,9 +203,21 @@ pub struct StreamSession {
     /// `destination`, which preserves the original TUN IP target.
     pub sniffed_domain: Option<String>,
 }
+impl StreamSession {
+    pub(crate) fn capture_original(&mut self) {
+        if self.metadata.original.is_none() {
+            self.metadata.original = Some(self.metadata.snapshot(
+                self.source,
+                self.inbound,
+                &self.destination,
+            ));
+        }
+    }
+}
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct DatagramSession {
+    pub metadata: InboundMetadata,
     pub inbound: InboundKind,
     pub source: SocketAddr,
     max_response_payload_size: u16,
@@ -148,10 +237,11 @@ impl DatagramSession {
             InboundKind::InternalDns => INTERNAL_DNS_XUDP_MAX_RESPONSE_PAYLOAD_SIZE,
             InboundKind::InternalGeoData => XUDP_MAX_RESPONSE_PAYLOAD_SIZE,
             InboundKind::InternalMeasure => XUDP_MAX_RESPONSE_PAYLOAD_SIZE,
-            InboundKind::Http => XUDP_MAX_RESPONSE_PAYLOAD_SIZE,
+            InboundKind::Http | InboundKind::Https => XUDP_MAX_RESPONSE_PAYLOAD_SIZE,
             InboundKind::Socks5 => SOCKS5_UDP_PAYLOAD_LIMIT,
         };
         Self {
+            metadata: InboundMetadata::new(0),
             inbound,
             source,
             max_response_payload_size,
@@ -163,6 +253,7 @@ impl DatagramSession {
     pub(crate) const fn for_tun(source: SocketAddr, mtu: usize) -> Self {
         let payload_size = mtu.saturating_sub(IPV6_UDP_OVERHEAD);
         Self {
+            metadata: InboundMetadata::new(0),
             inbound: InboundKind::Tun,
             source,
             max_response_payload_size: if payload_size > u16::MAX as usize {
@@ -173,6 +264,12 @@ impl DatagramSession {
         }
     }
 
+    #[must_use]
+    pub fn with_metadata(mut self, metadata: InboundMetadata) -> Self {
+        self.metadata = metadata;
+        self
+    }
+
     #[must_use]
     #[cfg_attr(not(feature = "outbound-vless"), allow(dead_code))]
     pub(crate) const fn max_response_payload_size(&self) -> u16 {
diff --git a/src/sniffing.rs b/src/sniffing.rs
new file mode 100644
index 0000000..05abca1
--- /dev/null
+++ b/src/sniffing.rs
@@ -0,0 +1,316 @@
+//! Shared inbound sniffing policy. Configuration and GeoData are retained, not snapshots.
+use crate::{
+    config::{Network, RuleKind, RuleSpec, SnifferConfig},
+    routing::{GeoMatcher, RoutingContext},
+    session::Destination,
+};
+use std::{
+    net::{IpAddr, SocketAddr},
+    sync::Arc,
+};
+
+pub(crate) struct Policy {
+    pub(crate) config: Arc<SnifferConfig>,
+    geo: Arc<dyn GeoMatcher>,
+    force: crate::dns::fake_ip::DomainFilter,
+    skip: crate::dns::fake_ip::DomainFilter,
+}
+impl Policy {
+    pub(crate) fn new(config: Arc<SnifferConfig>, geo: Arc<dyn GeoMatcher>) -> Arc<Self> {
+        Arc::new(Self {
+            force: crate::dns::fake_ip::DomainFilter::new(&config.force_domain),
+            skip: crate::dns::fake_ip::DomainFilter::new(&config.skip_domain),
+            config,
+            geo,
+        })
+    }
+    pub(crate) fn plan(
+        self: &Arc<Self>,
+        source: SocketAddr,
+        destination: &Destination,
+        host: Option<&str>,
+        mapped: bool,
+    ) -> Result<Plan, crate::config::MatchFailure> {
+        let decision = crate::config::RuleDecision::default();
+        let snapshot = self.geo.routing_snapshot();
+        let geo = snapshot.as_deref().unwrap_or(self.geo.as_ref());
+        let blocked = address_matches(&self.config.skip_src_address, source.ip(), geo, &decision)?
+            || match destination {
+                Destination::Ip(address) => {
+                    address_matches(&self.config.skip_dst_address, address.ip(), geo, &decision)?
+                }
+                _ => false,
+            };
+        let active = self.config.enable
+            && !blocked
+            && ((host.is_none() && self.config.parse_pure_ip)
+                || (mapped && self.config.force_dns_mapping)
+                || match host {
+                    Some(host) => self.force.matches(host, geo, &decision)?,
+                    None => false,
+                });
+        Ok(Plan {
+            policy: self.clone(),
+            port: destination.port(),
+            active,
+            decision,
+        })
+    }
+}
+fn address_matches(
+    rules: &[RuleSpec],
+    ip: IpAddr,
+    geo: &dyn GeoMatcher,
+    decision: &crate::config::RuleDecision,
+) -> Result<bool, crate::config::MatchFailure> {
+    decision.visit()?;
+    let destination = Destination::Ip(SocketAddr::new(ip, 1));
+    let context = RoutingContext::new(Network::Tcp, &destination)
+        .expect("literal destination")
+        .with_decision(decision);
+    for rule in rules {
+        let matched = if let RuleKind::RuleSet {
+            content: Some(set), ..
+        } = &rule.kind
+        {
+            set.matches_ip(ip, geo, decision)?
+        } else {
+            match crate::routing::matches_rule(rule, &context, geo) {
+                Ok(matched) => matched,
+                Err(
+                    crate::routing::PredicateFailure::NeedsIpResolution
+                    | crate::routing::PredicateFailure::NeedsProcessLookup,
+                ) => false,
+                Err(crate::routing::PredicateFailure::Evaluation(failure)) => return Err(failure),
+            }
+        };
+        if matched {
+            return Ok(true);
+        }
+    }
+    Ok(false)
+}
+
+/// Per-request decision shared by the inbound adapters. A disabled plan performs no reads.
+#[derive(Clone)]
+pub struct Plan {
+    policy: Arc<Policy>,
+    port: u16,
+    active: bool,
+    decision: crate::config::RuleDecision,
+}
+impl Plan {
+    #[cfg(feature = "tun")]
+    pub(crate) fn with_cancellation(
+        self,
+        cancellation: tokio_util::sync::CancellationToken,
+    ) -> Self {
+        self.decision.set_cancellation(cancellation);
+        self
+    }
+    #[cfg(any(feature = "tun", test))]
+    pub(crate) fn standalone(config: Arc<SnifferConfig>, port: u16) -> Self {
+        Self {
+            active: config.enable,
+            decision: Default::default(),
+            port,
+            policy: Policy::new(config, Arc::new(crate::routing::EmptyGeoMatcher)),
+        }
+    }
+    pub(crate) fn accepts(&self, host: &str) -> Result<bool, crate::config::MatchFailure> {
+        let snapshot = self.policy.geo.routing_snapshot();
+        Ok(!self.policy.skip.matches(
+            host,
+            snapshot.as_deref().unwrap_or(self.policy.geo.as_ref()),
+            &self.decision,
+        )?)
+    }
+    pub(crate) fn tcp_enabled(&self) -> bool {
+        self.active
+            && (self.policy.config.matches_http_port(self.port)
+                || self.policy.config.matches_tls_port(self.port))
+    }
+    pub(crate) fn quic_enabled(&self) -> bool {
+        self.active && self.policy.config.matches_quic_port(self.port)
+    }
+    pub(crate) async fn sniff<R: tokio::io::AsyncRead + Unpin>(
+        &self,
+        reader: &mut R,
+        session: &mut crate::session::StreamSession,
+    ) -> Result<Vec<u8>, crate::config::MatchFailure> {
+        session.capture_original();
+        self.decision.check()?;
+        if !self.tcp_enabled() {
+            return Ok(Vec::new());
+        }
+        use crate::tcp_sniffer::{SniffOutcome, SniffProtocol, TcpSniffer};
+        let protocols = [
+            (
+                SniffProtocol::Tls,
+                self.policy.config.matches_tls_port(self.port),
+            ),
+            (
+                SniffProtocol::Http,
+                self.policy.config.matches_http_port(self.port),
+            ),
+        ]
+        .into_iter()
+        .filter_map(|(protocol, enabled)| enabled.then_some(protocol))
+        .collect();
+        let mut sniffer = TcpSniffer::with_protocols(protocols);
+        if let Ok(SniffOutcome::Matched { protocol, domain }) = sniffer.sniff(reader).await
+            && self.accepts(&domain)?
+        {
+            let override_destination = match protocol {
+                SniffProtocol::Http => self.policy.config.http_override,
+                SniffProtocol::Tls => self.policy.config.tls_override,
+            };
+            if override_destination {
+                session.destination = Destination::Domain {
+                    host: domain.clone(),
+                    port: self.port,
+                };
+            }
+            session.sniffed_domain = Some(domain);
+        }
+        Ok(sniffer.into_buffered())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        config::Config,
+        session::{InboundKind, StreamSession},
+    };
+    fn policy() -> Arc<Policy> {
+        let config = Config::parse_yaml(
+            br#"
+mixed-port: 1080
+sniffer:
+  enable: true
+  force-dns-mapping: true
+  parse-pure-ip: false
+  force-domain: ['+.force.example']
+  skip-domain: ['+.skip.example']
+  skip-src-address: [192.0.2.0/24]
+  skip-dst-address: [203.0.113.0/24]
+  override-destination: false
+  sniff:
+    HTTP:
+      ports: [443]
+    TLS:
+      ports: [443]
+      override-destination: true
+"#,
+        )
+        .unwrap();
+        Policy::new(
+            Arc::new(config.sniffer),
+            Arc::new(crate::routing::EmptyGeoMatcher),
+        )
+    }
+    #[test]
+    fn sniff_policy_distinguishes_mapping_forcing_and_exclusions() {
+        let policy = policy();
+        let source = "198.51.100.1:8000".parse().unwrap();
+        let destination = Destination::Ip("198.51.100.2:443".parse().unwrap());
+        assert!(
+            !policy
+                .plan(source, &destination, None, false)
+                .unwrap()
+                .tcp_enabled()
+        );
+        assert!(
+            policy
+                .plan(source, &destination, Some("mapped.example"), true)
+                .unwrap()
+                .tcp_enabled()
+        );
+        assert!(
+            !policy
+                .plan(source, &destination, Some("fake.example"), false)
+                .unwrap()
+                .tcp_enabled()
+        );
+        assert!(
+            policy
+                .plan(source, &destination, Some("api.force.example"), false)
+                .unwrap()
+                .tcp_enabled()
+        );
+        assert!(
+            !policy
+                .plan(
+                    "192.0.2.2:99".parse().unwrap(),
+                    &destination,
+                    Some("api.force.example"),
+                    true
+                )
+                .unwrap()
+                .tcp_enabled()
+        );
+        assert!(
+            !policy
+                .plan(
+                    source,
+                    &Destination::Ip("203.0.113.1:443".parse().unwrap()),
+                    Some("api.force.example"),
+                    true
+                )
+                .unwrap()
+                .tcp_enabled()
+        );
+    }
+    #[tokio::test]
+    async fn sniff_shared_prefix_selects_protocol_override_and_replays_every_byte() {
+        let policy = policy();
+        let destination = Destination::Ip("198.51.100.2:443".parse().unwrap());
+        let source = "198.51.100.1:8000".parse().unwrap();
+        let plan = policy
+            .plan(source, &destination, Some("api.force.example"), false)
+            .unwrap();
+        for (mut input, host, overridden) in [
+            (
+                b"GET / HTTP/1.1\r\nHost: http.example\r\n\r\n".to_vec(),
+                Some("http.example"),
+                false,
+            ),
+            (
+                crate::tcp_sniffer::tests::tls_client_hello("tls.example"),
+                Some("tls.example"),
+                true,
+            ),
+            (
+                crate::tcp_sniffer::tests::tls_client_hello("api.skip.example"),
+                None,
+                false,
+            ),
+        ] {
+            input.extend_from_slice(b"business-bytes");
+            let mut reader = input.as_slice();
+            let mut session = StreamSession {
+                metadata: Default::default(),
+                inbound: InboundKind::Tun,
+                source,
+                destination: destination.clone(),
+                sniffed_domain: None,
+            };
+            let prefix = plan.sniff(&mut reader, &mut session).await.unwrap();
+            assert_eq!([prefix.as_slice(), reader].concat(), input);
+            assert_eq!(session.sniffed_domain.as_deref(), host);
+            if overridden {
+                assert_eq!(
+                    session.destination,
+                    Destination::Domain {
+                        host: host.unwrap().into(),
+                        port: 443
+                    }
+                );
+            } else {
+                assert_eq!(session.destination, destination);
+            }
+        }
+    }
+}
diff --git a/src/tcp_sniffer.rs b/src/tcp_sniffer.rs
index 741a858..249f04a 100644
--- a/src/tcp_sniffer.rs
+++ b/src/tcp_sniffer.rs
@@ -1,7 +1,6 @@
 //! Bounded TCP first-payload sniffing for the TUN inbound.
 //!
-//! Sniffing is deliberately advisory: the extracted domain is routing
-//! metadata and never replaces the original IP destination. All bytes read
+//! The inbound applies the configured destination-override policy. All bytes read
 //! here remain available to the caller for replay after the outbound has been
 //! selected.
 
@@ -14,8 +13,11 @@ use tokio::{
 
 use crate::routing::normalize_domain_name;
 
-pub(crate) const TCP_SNIFF_MAX_BYTES: usize = 32 * 1024;
-pub(crate) const TCP_SNIFF_TIMEOUT: Duration = Duration::from_millis(200);
+#[path = "tcp_sniffer/http2.rs"]
+mod http2;
+
+pub(crate) const TCP_SNIFF_MAX_BYTES: usize = 64 * 1024;
+pub(crate) const TCP_SNIFF_TIMEOUT: Duration = Duration::from_secs(1);
 
 const READ_CHUNK_BYTES: usize = 2 * 1024;
 const TLS_HANDSHAKE_CONTENT_TYPE: u8 = 0x16;
@@ -58,7 +60,7 @@ pub(crate) enum ParseOutcome {
 /// Stateful bounded sniffer which retains every byte consumed from the
 /// intercepted stream until the caller takes the prefix for replay.
 pub(crate) struct TcpSniffer {
-    protocol: SniffProtocol,
+    protocols: Vec<SniffProtocol>,
     buffered: Vec<u8>,
 }
 
@@ -67,9 +69,13 @@ impl TcpSniffer {
     /// configuration. Port selection remains outside the parser so the same
     /// HTTP/TLS implementation can serve every configured TCP port.
     #[must_use]
+    #[cfg(test)]
     pub(crate) fn new(protocol: SniffProtocol) -> Self {
+        Self::with_protocols(vec![protocol])
+    }
+    pub(crate) fn with_protocols(protocols: Vec<SniffProtocol>) -> Self {
         Self {
-            protocol,
+            protocols,
             buffered: Vec::with_capacity(READ_CHUNK_BYTES),
         }
     }
@@ -83,20 +89,30 @@ impl TcpSniffer {
     where
         R: AsyncRead + Unpin,
     {
-        let deadline = Instant::now() + TCP_SNIFF_TIMEOUT;
+        let mut deadline = Instant::now() + TCP_SNIFF_TIMEOUT;
         loop {
-            match parse(self.protocol, &self.buffered) {
-                ParseOutcome::Matched(domain) => {
-                    return Ok(SniffOutcome::Matched {
-                        protocol: self.protocol,
-                        domain,
-                    });
-                }
-                ParseOutcome::EchExtensionPresent => {
-                    return Ok(SniffOutcome::EchExtensionPresent);
+            let mut active = Vec::with_capacity(self.protocols.len());
+            let mut ech = false;
+            for protocol in &self.protocols {
+                match parse(*protocol, &self.buffered) {
+                    ParseOutcome::Matched(domain) => {
+                        return Ok(SniffOutcome::Matched {
+                            protocol: *protocol,
+                            domain,
+                        });
+                    }
+                    ParseOutcome::NeedMoreData => active.push(*protocol),
+                    ParseOutcome::EchExtensionPresent => ech = true,
+                    ParseOutcome::NotMatched => {}
                 }
-                ParseOutcome::NotMatched => return Ok(SniffOutcome::NotMatched),
-                ParseOutcome::NeedMoreData => {}
+            }
+            self.protocols = active;
+            if self.protocols.is_empty() {
+                return Ok(if ech {
+                    SniffOutcome::EchExtensionPresent
+                } else {
+                    SniffOutcome::NotMatched
+                });
             }
 
             let remaining = TCP_SNIFF_MAX_BYTES.saturating_sub(self.buffered.len());
@@ -113,15 +129,13 @@ impl TcpSniffer {
                 Ok(Ok(count)) => count,
                 Ok(Err(error)) => return Err(error),
             };
+            if self.buffered.is_empty() {
+                deadline = Instant::now() + TCP_SNIFF_TIMEOUT;
+            }
             self.buffered.extend_from_slice(&chunk[..count]);
         }
     }
 
-    #[must_use]
-    pub(crate) fn buffered_len(&self) -> usize {
-        self.buffered.len()
-    }
-
     #[must_use]
     pub(crate) fn into_buffered(self) -> Vec<u8> {
         self.buffered
@@ -136,6 +150,16 @@ fn parse(protocol: SniffProtocol, input: &[u8]) -> ParseOutcome {
 }
 
 fn sniff_http_host(input: &[u8]) -> ParseOutcome {
+    if http2::PREFACE.starts_with(input) {
+        return ParseOutcome::NeedMoreData;
+    }
+    if input.starts_with(http2::PREFACE) {
+        return http2::sniff(input);
+    }
+    sniff_http1_host(input)
+}
+
+fn sniff_http1_host(input: &[u8]) -> ParseOutcome {
     let Some(headers_end) = find_bytes(input, b"\r\n\r\n") else {
         return if input.len() == TCP_SNIFF_MAX_BYTES {
             ParseOutcome::NotMatched
@@ -144,14 +168,14 @@ fn sniff_http_host(input: &[u8]) -> ParseOutcome {
         };
     };
     let headers = &input[..headers_end];
-    let Some(request_line_end) = find_bytes(headers, b"\r\n") else {
-        return ParseOutcome::NotMatched;
-    };
+    let request_line_end = find_bytes(headers, b"\r\n").unwrap_or(headers.len());
     if !is_http_request_line(&headers[..request_line_end]) {
         return ParseOutcome::NotMatched;
     }
 
+    let target_host = request_target_host(&headers[..request_line_end]);
     let mut host = None;
+    let mut saw_host = false;
     let mut cursor = request_line_end + 2;
     while cursor < headers.len() {
         let line_end =
@@ -163,18 +187,38 @@ fn sniff_http_host(input: &[u8]) -> ParseOutcome {
         if line[..colon].eq_ignore_ascii_case(b"host") {
             // Multiple Host fields are invalid for the routing hint even when
             // they happen to contain the same text.
-            if host.is_some() {
+            if saw_host {
                 return ParseOutcome::NotMatched;
             }
+            saw_host = true;
             host = normalize_host_header(&line[colon + 1..]);
-            if host.is_none() {
+            if host.is_none() && target_host.is_none() {
                 return ParseOutcome::NotMatched;
             }
         }
         cursor = line_end.saturating_add(2);
     }
 
-    host.map_or(ParseOutcome::NotMatched, ParseOutcome::Matched)
+    target_host
+        .or(host)
+        .map_or(ParseOutcome::NotMatched, ParseOutcome::Matched)
+}
+
+fn request_target_host(line: &[u8]) -> Option<String> {
+    let mut fields = line.split(|byte| *byte == b' ');
+    let method = fields.next()?;
+    let target = std::str::from_utf8(fields.next()?).ok()?;
+    if method.eq_ignore_ascii_case(b"CONNECT") {
+        return match crate::session::Destination::from_authority(target).ok()? {
+            crate::session::Destination::Domain { host, .. } => normalize_domain(&host),
+            crate::session::Destination::Ip(_) => None,
+        };
+    }
+    if target.starts_with('/') || target == "*" {
+        return None;
+    }
+    let url = url::Url::parse(target).ok()?;
+    normalize_domain(url.host_str()?)
 }
 
 fn early_http_decision(input: &[u8]) -> ParseOutcome {
@@ -546,7 +590,7 @@ fn advance(cursor: &mut usize, count: usize, length: usize) -> bool {
 }
 
 #[cfg(test)]
-mod tests {
+pub(crate) mod tests {
     use tokio::io::{AsyncWriteExt as _, duplex};
 
     use super::*;
@@ -555,7 +599,30 @@ mod tests {
         format!("GET / HTTP/1.1\r\nUser-Agent: test\r\nHost: {host}\r\n\r\n").into_bytes()
     }
 
-    fn tls_client_hello(host: &str) -> Vec<u8> {
+    #[test]
+    fn http_target_authority_precedes_host_and_connect_needs_no_host_header() {
+        for request in [
+            b"GET http://Target.Example:8080/path HTTP/1.1\r\nHost: other.example\r\n\r\n"
+                .as_slice(),
+            b"CONNECT target.example:443 HTTP/1.1\r\n\r\n",
+            b"GET https://target.example/path HTTP/1.1\r\n\r\n",
+        ] {
+            assert_eq!(
+                sniff_http_host(request),
+                ParseOutcome::Matched("target.example".into())
+            );
+        }
+        assert_eq!(
+            sniff_http_host(b"GET http://target.example/ HTTP/1.1\r\nHost: a.example\r\nHost: b.example\r\n\r\n"),
+            ParseOutcome::NotMatched
+        );
+        assert_eq!(
+            sniff_http_host(b"CONNECT target.example:0 HTTP/1.1\r\n\r\n"),
+            ParseOutcome::NotMatched
+        );
+    }
+
+    pub(crate) fn tls_client_hello(host: &str) -> Vec<u8> {
         tls_client_hello_with_extensions(&tls_server_name_extension(host))
     }
 
@@ -605,18 +672,6 @@ mod tests {
         record
     }
 
-    #[test]
-    fn constructor_preserves_the_configured_protocol() {
-        assert!(matches!(
-            TcpSniffer::new(SniffProtocol::Http).protocol,
-            SniffProtocol::Http
-        ));
-        assert!(matches!(
-            TcpSniffer::new(SniffProtocol::Tls).protocol,
-            SniffProtocol::Tls
-        ));
-    }
-
     #[test]
     fn http_host_is_normalized_and_optional_port_is_removed() {
         assert_eq!(
diff --git a/src/tcp_sniffer/http2.rs b/src/tcp_sniffer/http2.rs
new file mode 100644
index 0000000..6641d2a
--- /dev/null
+++ b/src/tcp_sniffer/http2.rs
@@ -0,0 +1,274 @@
+//! Passive, bounded HTTP/2 authority extraction; bytes are never consumed here.
+use super::{ParseOutcome, TCP_SNIFF_MAX_BYTES, normalize_host_header};
+
+pub(super) const PREFACE: &[u8] = b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n";
+const MAX_FRAME: usize = 16_384;
+const MAX_HEADERS: usize = 128;
+
+pub(super) fn sniff(input: &[u8]) -> ParseOutcome {
+    let mut cursor = PREFACE.len();
+    let mut first = true;
+    let mut header_stream = None;
+    let mut block = Vec::new();
+    for _ in 0..MAX_HEADERS {
+        let Some(header) = input.get(cursor..cursor + 9) else {
+            return ParseOutcome::NeedMoreData;
+        };
+        let length =
+            (usize::from(header[0]) << 16) | (usize::from(header[1]) << 8) | usize::from(header[2]);
+        let kind = header[3];
+        let flags = header[4];
+        let stream = u32::from_be_bytes(header[5..9].try_into().unwrap()) & 0x7fff_ffff;
+        if length > MAX_FRAME || (first && (kind != 4 || flags & 1 != 0)) {
+            return ParseOutcome::NotMatched;
+        }
+        if kind == 4 && (stream != 0 || (flags & 1 != 0 && length != 0) || length % 6 != 0) {
+            return ParseOutcome::NotMatched;
+        }
+        if let Some(active) = header_stream {
+            if kind != 9 || stream != active {
+                return ParseOutcome::NotMatched;
+            }
+        } else if kind == 9 || (kind == 1 && (stream == 0 || stream % 2 == 0)) {
+            return ParseOutcome::NotMatched;
+        }
+        cursor += 9;
+        if cursor + length > TCP_SNIFF_MAX_BYTES {
+            return ParseOutcome::NotMatched;
+        }
+        let Some(payload) = input.get(cursor..cursor + length) else {
+            return ParseOutcome::NeedMoreData;
+        };
+        first = false;
+        cursor += length;
+        if header_stream.is_none() && kind != 1 {
+            continue;
+        }
+        header_stream = Some(stream);
+        let mut start = 0;
+        let mut end = payload.len();
+        if kind == 1 {
+            if flags & 8 != 0 {
+                let Some(padding) = payload.first().copied() else {
+                    return ParseOutcome::NotMatched;
+                };
+                start = 1;
+                let Some(unpadded) = end.checked_sub(usize::from(padding)) else {
+                    return ParseOutcome::NotMatched;
+                };
+                end = unpadded;
+            }
+            if flags & 0x20 != 0 {
+                start += 5;
+            }
+        }
+        if start > end || block.len() + end - start > TCP_SNIFF_MAX_BYTES {
+            return ParseOutcome::NotMatched;
+        }
+        block.extend_from_slice(&payload[start..end]);
+        if flags & 4 != 0 {
+            return authority(block);
+        }
+    }
+    ParseOutcome::NotMatched
+}
+
+fn authority(mut block: Vec<u8>) -> ParseOutcome {
+    let mut decoder = httlib_hpack::Decoder::with_dynamic_size(4_096);
+    let mut field = Vec::with_capacity(1);
+    let mut authority = None;
+    let mut host = None;
+    let mut decoded = 0usize;
+    for _ in 0..MAX_HEADERS {
+        if block.is_empty() {
+            return authority
+                .or(host)
+                .map_or(ParseOutcome::NotMatched, ParseOutcome::Matched);
+        }
+        // The official codec assumes that literal strings and integer
+        // continuations are present. Validate their complete encoded boundaries
+        // before handing it untrusted bytes; malformed sniffing must fail open.
+        if instruction_length(&block).is_none() {
+            return ParseOutcome::NotMatched;
+        }
+        let before = block.len();
+        if decoder.decode_exact(&mut block, &mut field).is_err() || block.len() == before {
+            return ParseOutcome::NotMatched;
+        }
+        if let Some((name, value, _)) = field.pop() {
+            decoded = decoded
+                .saturating_add(name.len())
+                .saturating_add(value.len())
+                .saturating_add(32);
+            if decoded > TCP_SNIFF_MAX_BYTES {
+                return ParseOutcome::NotMatched;
+            }
+            let slot = match name.as_slice() {
+                b":authority" => &mut authority,
+                b"host" => &mut host,
+                _ => continue,
+            };
+            if slot.is_some() {
+                return ParseOutcome::NotMatched;
+            }
+            let Some(value) = normalize_host_header(&value) else {
+                return ParseOutcome::NotMatched;
+            };
+            *slot = Some(value);
+        }
+    }
+    ParseOutcome::NotMatched
+}
+
+fn instruction_length(bytes: &[u8]) -> Option<usize> {
+    let first = *bytes.first()?;
+    if first & 0x80 != 0 {
+        return integer(bytes, 7).map(|(_, length)| length);
+    }
+    if first & 0xe0 == 0x20 {
+        return integer(bytes, 5).map(|(_, length)| length);
+    }
+    let (index, mut cursor) = integer(bytes, if first & 0x40 != 0 { 6 } else { 4 })?;
+    if index == 0 {
+        cursor += string_length(bytes.get(cursor..)?)?;
+    }
+    cursor += string_length(bytes.get(cursor..)?)?;
+    Some(cursor)
+}
+
+fn integer(bytes: &[u8], prefix: u8) -> Option<(u32, usize)> {
+    let mask = (1u32 << prefix) - 1;
+    let mut value = u32::from(*bytes.first()?) & mask;
+    if value < mask {
+        return Some((value, 1));
+    }
+    for cursor in 1..5 {
+        let byte = *bytes.get(cursor)?;
+        value = value.checked_add(u32::from(byte & 0x7f).checked_shl((cursor as u32 - 1) * 7)?)?;
+        if byte & 0x80 == 0 {
+            return Some((value, cursor + 1));
+        }
+    }
+    None
+}
+
+fn string_length(bytes: &[u8]) -> Option<usize> {
+    let (length, prefix) = integer(bytes, 7)?;
+    let total = prefix.checked_add(length as usize)?;
+    (total <= bytes.len()).then_some(total)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn frame(kind: u8, flags: u8, stream: u32, payload: &[u8]) -> Vec<u8> {
+        let mut value = Vec::new();
+        value.extend_from_slice(&(payload.len() as u32).to_be_bytes()[1..]);
+        value.extend_from_slice(&[kind, flags]);
+        value.extend_from_slice(&stream.to_be_bytes());
+        value.extend_from_slice(payload);
+        value
+    }
+
+    fn request(frames: &[Vec<u8>]) -> Vec<u8> {
+        let mut bytes = PREFACE.to_vec();
+        bytes.extend(frame(4, 0, 0, &[]));
+        for frame in frames {
+            bytes.extend(frame);
+        }
+        bytes
+    }
+
+    // RFC 7541 C.4.1: Huffman-encoded www.example.com, indexed :authority.
+    const AUTHORITY: &[u8] = &[
+        0x82, 0x86, 0x84, 0x41, 0x8c, 0xf1, 0xe3, 0xc2, 0xe5, 0xf2, 0x3a, 0x6b, 0xa0, 0xab, 0x90,
+        0xf4, 0xff,
+    ];
+
+    #[test]
+    fn h2_sniff_reassembles_huffman_authority_and_rejects_interleaving() {
+        let good = request(&[
+            frame(1, 0, 1, &AUTHORITY[..6]),
+            frame(9, 4, 1, &AUTHORITY[6..]),
+        ]);
+        assert_eq!(
+            sniff(&good),
+            ParseOutcome::Matched("www.example.com".into())
+        );
+        for length in PREFACE.len()..good.len() {
+            assert_eq!(sniff(&good[..length]), ParseOutcome::NeedMoreData);
+        }
+        let interleaved = request(&[
+            frame(1, 0, 1, &AUTHORITY[..6]),
+            frame(4, 0, 0, &[]),
+            frame(9, 4, 1, &AUTHORITY[6..]),
+        ]);
+        assert_eq!(sniff(&interleaved), ParseOutcome::NotMatched);
+        let wrong_stream = request(&[
+            frame(1, 0, 1, &AUTHORITY[..6]),
+            frame(9, 4, 3, &AUTHORITY[6..]),
+        ]);
+        assert_eq!(sniff(&wrong_stream), ParseOutcome::NotMatched);
+    }
+
+    #[test]
+    fn h2_sniff_rejects_ambiguous_or_oversized_headers_before_large_payloads() {
+        let mut duplicate = AUTHORITY.to_vec();
+        duplicate.push(0xbe); // dynamic-table index 62 repeats :authority.
+        assert_eq!(
+            sniff(&request(&[frame(1, 4, 1, &duplicate)])),
+            ParseOutcome::NotMatched
+        );
+        // Table-size update to 4097 exceeds the initial peer table budget.
+        assert_eq!(authority(vec![0x3f, 0xe2, 0x1f]), ParseOutcome::NotMatched);
+        let mut oversized = request(&[]);
+        oversized.extend_from_slice(&[0, 0x40, 1, 1, 4, 0, 0, 0, 1]);
+        assert_eq!(sniff(&oversized), ParseOutcome::NotMatched);
+        let mut padded = vec![4];
+        padded.extend(AUTHORITY);
+        padded.extend_from_slice(&[0; 4]);
+        assert_eq!(
+            sniff(&request(&[frame(1, 12, 1, &padded)])),
+            ParseOutcome::Matched("www.example.com".into())
+        );
+    }
+
+    #[test]
+    fn h2_sniff_checks_truncated_literals_and_integers_before_the_codec() {
+        for first in 0..=255 {
+            let _ = authority(vec![first]);
+            let _ = authority(vec![first, 0xff]);
+        }
+        for malformed in [
+            vec![0x00],
+            vec![0x40],
+            vec![0x00, 0x01, b'x'],
+            vec![0x00, 0x01, b'x', 0xff],
+            vec![0xff],
+            vec![0xff, 0xff, 0xff, 0xff, 0xff],
+        ] {
+            assert_eq!(authority(malformed), ParseOutcome::NotMatched);
+        }
+        for length in 1..AUTHORITY.len() {
+            assert_eq!(
+                authority(AUTHORITY[..length].to_vec()),
+                ParseOutcome::NotMatched
+            );
+        }
+    }
+
+    #[tokio::test]
+    async fn h2_sniff_replays_the_exact_preface_and_frames() {
+        use tokio::io::AsyncWriteExt as _;
+        let bytes = request(&[frame(1, 4, 1, AUTHORITY)]);
+        let (mut sender, mut receiver) = tokio::io::duplex(4096);
+        sender.write_all(&bytes).await.unwrap();
+        let mut parser = super::super::TcpSniffer::new(super::super::SniffProtocol::Http);
+        assert!(matches!(
+            parser.sniff(&mut receiver).await.unwrap(),
+            super::super::SniffOutcome::Matched { domain, .. } if domain == "www.example.com"
+        ));
+        assert_eq!(parser.into_buffered(), bytes);
+    }
+}
diff --git a/src/transport/grpc.rs b/src/transport/grpc.rs
index 6e37f70..d3ae0a2 100644
--- a/src/transport/grpc.rs
+++ b/src/transport/grpc.rs
@@ -9,29 +9,63 @@ use std::{
     task::{Context, Poll, ready},
 };
 
+use super::h2_empty::Send as H2Send;
 use bytes::{Buf, Bytes, BytesMut};
 use futures_util::task::AtomicWaker;
-use h2::{RecvStream, SendStream, client::ResponseFuture};
+use h2::{RecvStream, client::ResponseFuture};
+#[cfg(feature = "outbound-trusttunnel")]
+use tokio::sync::oneshot;
 use tokio::{
     io::{AsyncRead, AsyncWrite, ReadBuf},
     task::{AbortHandle, JoinHandle},
     time::{Instant, timeout_at},
 };
 
+#[cfg(feature = "sing-mux")]
+use super::h2_write::CoalescedAck;
 use super::h2_write::{Payload, Receipt, Sender, Writes};
 use super::{STREAM_BUFFER_BYTES as LIMIT, STREAM_CHUNK_BYTES as CHUNK};
 use crate::dispatch::BoxStream;
 
+enum PendingResponse {
+    Direct(ResponseFuture),
+    #[cfg(feature = "outbound-trusttunnel")]
+    Observed(oneshot::Receiver<io::Result<http::Response<RecvStream>>>),
+}
+impl Future for PendingResponse {
+    type Output = io::Result<http::Response<RecvStream>>;
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        match self.get_mut() {
+            Self::Direct(response) => Pin::new(response)
+                .poll(cx)
+                .map(|result| result.map_err(|_| invalid())),
+            #[cfg(feature = "outbound-trusttunnel")]
+            Self::Observed(response) => Pin::new(response).poll(cx).map(|result| {
+                result.unwrap_or_else(|_| Err(io::ErrorKind::ConnectionAborted.into()))
+            }),
+        }
+    }
+}
+
 #[derive(Default)]
 struct Close {
     stopped: AtomicBool,
+    failed: AtomicBool,
     reader: AtomicWaker,
+    writer: AtomicWaker,
+    #[cfg(feature = "outbound-trusttunnel")]
+    response_cancel: Option<tokio_util::sync::CancellationToken>,
 }
 
 impl Close {
     fn stop(&self) {
         self.stopped.store(true, Ordering::SeqCst);
         self.reader.wake();
+        self.writer.wake();
+        #[cfg(feature = "outbound-trusttunnel")]
+        if let Some(cancel) = &self.response_cancel {
+            cancel.cancel();
+        }
     }
 }
 
@@ -200,15 +234,18 @@ struct Grpc {
     framing: Framing,
     half_close: bool,
     upload_closed: bool,
-    response: Option<ResponseFuture>,
+    response: Option<PendingResponse>,
+    response_deadline: bool,
     receive: Option<RecvStream>,
-    send: SendStream<Payload>,
+    send: H2Send,
     writes: Writes,
     pending: Option<Receipt>,
+    #[cfg(feature = "sing-mux")]
+    coalesced: Option<Arc<CoalescedAck>>,
     deadline: Pin<Box<tokio::time::Sleep>>,
     frame: Bytes,
     wire: BytesMut,
-    payload: Bytes,
+    remaining_payload: usize,
     queued: Bytes,
     eof: bool,
     data_eof: bool,
@@ -221,7 +258,9 @@ pub(super) async fn pooled_stream(
     sender: Sender,
     uri: &str,
     user_agent: &str,
+    half_close: bool,
     deadline: Instant,
+    policy: super::grpc_pool::ResponsePolicy,
     lease: super::grpc_pool::Lease,
 ) -> io::Result<BoxStream> {
     let request = http::Request::builder()
@@ -240,22 +279,33 @@ pub(super) async fn pooled_stream(
     let (response, send) = sender
         .send_request(request, false)
         .map_err(|_| io::Error::from(io::ErrorKind::ConnectionAborted))?;
-    Ok(Box::new(Grpc::new(
+    let mut stream = Grpc::new(
         response,
         send,
         Framing::Gun,
-        false,
+        half_close,
         deadline,
         Arc::default(),
         None,
         Some(lease),
         writes,
-    )))
+    );
+    // Client-first protocol owners bound complete request submission separately.
+    // Waiting for HTTP response headers must not reuse that setup deadline.
+    stream.response_deadline = matches!(policy, super::grpc_pool::ResponsePolicy::SetupDeadline);
+    Ok(Box::new(stream))
 }
 
 impl Drop for Grpc {
     fn drop(&mut self) {
+        #[cfg(feature = "sing-mux")]
+        if let Some(ack) = &self.coalesced {
+            ack.fail(io::ErrorKind::BrokenPipe);
+        }
         self.close.stop();
+        if let Some(lease) = &self._lease {
+            lease.close_stream();
+        }
         self.send.send_reset(h2::Reason::CANCEL);
         if let Some(abort) = &self.abort {
             abort.abort();
@@ -263,9 +313,152 @@ impl Drop for Grpc {
     }
 }
 
+#[cfg(feature = "outbound-trusttunnel")]
+pub(super) async fn pooled_connect(
+    sender: Sender,
+    request: http::Request<()>,
+    deadline: Instant,
+    mut lease: super::grpc_pool::Lease,
+    observer: Option<Arc<dyn Fn() + Send + Sync>>,
+) -> io::Result<(BoxStream, impl Future<Output = ()> + Send + 'static)> {
+    let writes = sender.writes;
+    let mut sender = timeout_at(deadline, sender.request.ready())
+        .await
+        .map_err(|_| io::Error::from(io::ErrorKind::TimedOut))?
+        .map_err(|_| io::Error::from(io::ErrorKind::ConnectionAborted))?;
+    let (response, send) = lease
+        .request(&mut sender, request, false)
+        .map_err(|_| invalid())?;
+    let admission = lease.admission();
+    let cancel = tokio_util::sync::CancellationToken::new();
+    let close = Arc::new(Close {
+        response_cancel: Some(cancel.clone()),
+        ..Default::default()
+    });
+    let (ready, receiver) = oneshot::channel();
+    let mut stream = Grpc::new(
+        response,
+        send,
+        Framing::Plain,
+        false,
+        deadline,
+        close.clone(),
+        None,
+        Some(lease),
+        writes,
+    );
+    let response = match stream.response.take().unwrap() {
+        PendingResponse::Direct(response) => response,
+        _ => unreachable!(),
+    };
+    stream.response = Some(PendingResponse::Observed(receiver));
+    // Physical establishment ends setup, as in Mihomo. A CONNECT peer may
+    // defer headers until client-first data; no expired setup timer is applied
+    // to an already established logical stream's later first read.
+    stream.response_deadline = false;
+    let headers = async move {
+        let result = tokio::select! {biased;
+            ()=cancel.cancelled()=>return,
+            result=response=>result.map_err(|_| invalid()).and_then(|response| {
+                if response.status() == 200 { Ok(response) } else { Err(invalid()) }
+            }),
+        };
+        if result.is_ok() {
+            if let Some(admission) = admission {
+                admission.activate();
+            }
+            if let Some(observer) = observer {
+                observer();
+            }
+        } else {
+            close.failed.store(true, Ordering::SeqCst);
+            close.stop();
+        }
+        let _ = ready.send(result);
+    };
+    Ok((Box::new(stream), headers))
+}
+
+#[cfg(feature = "outbound-trusttunnel")]
+pub(super) async fn connect_probe(
+    sender: Sender,
+    request: http::Request<()>,
+    deadline: Instant,
+    _lease: super::grpc_pool::Lease,
+) -> io::Result<()> {
+    let mut sender = timeout_at(deadline, sender.request.ready())
+        .await
+        .map_err(|_| io::Error::from(io::ErrorKind::TimedOut))?
+        .map_err(|_| invalid())?;
+    let (response, _send) = sender.send_request(request, true).map_err(|_| invalid())?;
+    let response = timeout_at(deadline, response)
+        .await
+        .map_err(|_| io::Error::from(io::ErrorKind::TimedOut))?
+        .map_err(|_| invalid())?;
+    if response.status() == 200 {
+        Ok(())
+    } else {
+        Err(invalid())
+    }
+}
+
+/// CONNECT-IP is usable only after the peer has accepted its request. Keep
+/// the logical stream owned while awaiting headers so cancellation resets only
+/// this request, and leave its first DATA frame for the caller.
+#[cfg(feature = "outbound-masque")]
+pub(super) async fn pooled_connect_admitted(
+    sender: Sender,
+    request: http::Request<()>,
+    deadline: Instant,
+    lease: super::grpc_pool::Lease,
+) -> io::Result<BoxStream> {
+    let writes = sender.writes;
+    let mut sender = timeout_at(deadline, sender.request.ready())
+        .await
+        .map_err(|_| io::Error::from(io::ErrorKind::TimedOut))?
+        .map_err(|_| io::Error::from(io::ErrorKind::ConnectionAborted))?;
+    let (response, send) = sender.send_request(request, false).map_err(|_| invalid())?;
+    let mut stream = Grpc::new(
+        response,
+        send,
+        Framing::Plain,
+        false,
+        deadline,
+        Arc::default(),
+        None,
+        Some(lease),
+        writes,
+    );
+    let response = match stream.response.take().unwrap() {
+        PendingResponse::Direct(response) => response,
+        #[cfg(feature = "outbound-trusttunnel")]
+        PendingResponse::Observed(_) => unreachable!(),
+    };
+    if Instant::now() >= deadline {
+        return Err(io::ErrorKind::TimedOut.into());
+    }
+    let response = timeout_at(deadline, response)
+        .await
+        .map_err(|_| io::Error::from(io::ErrorKind::TimedOut))?
+        .map_err(|_| invalid())?;
+    if Instant::now() >= deadline {
+        return Err(io::ErrorKind::TimedOut.into());
+    }
+    if response.status() != http::StatusCode::OK {
+        return Err(invalid());
+    }
+    stream.receive = Some(response.into_body());
+    stream.response_deadline = false;
+    Ok(Box::new(stream))
+}
+
 /// sing-mux uses plain HTTP/2 CONNECT streams, not gRPC records.
-#[cfg(feature = "outbound-vless")]
-pub(super) async fn mux_stream(sender: Sender, deadline: Instant) -> io::Result<BoxStream> {
+#[cfg(feature = "sing-mux")]
+pub(super) async fn mux_stream(
+    sender: Sender,
+    deadline: Instant,
+    autonomous: bool,
+) -> io::Result<BoxStream> {
     let writes = sender.writes;
     let mut sender = sender.request.ready().await.map_err(|_| invalid())?;
     let request = http::Request::builder()
@@ -274,17 +467,23 @@ pub(super) async fn mux_stream(sender: Sender, deadline: Instant) -> io::Result<
         .body(())
         .map_err(|_| invalid())?;
     let (response, send) = sender.send_request(request, false).map_err(|_| invalid())?;
-    Ok(Box::new(Grpc::new(
+    let mut stream = Grpc::new(
         response,
         send,
         Framing::Plain,
-        false,
+        true,
         deadline,
         Arc::default(),
         None,
         None,
         writes,
-    )))
+    );
+    stream.coalesced = autonomous.then(|| Arc::new(CoalescedAck::default()));
+    // sing-mux owns the logical setup deadline, including metadata and the
+    // optional Brutal exchange. A valid upload can outlive delayed H2 headers;
+    // do not hide a second response timer beneath its business-write boundary.
+    stream.response_deadline = false;
+    Ok(Box::new(stream))
 }
 
 fn invalid() -> io::Error {
@@ -299,7 +498,7 @@ impl Grpc {
     #[allow(clippy::too_many_arguments)]
     fn new(
         response: ResponseFuture,
-        send: SendStream<Payload>,
+        send: impl Into<H2Send>,
         framing: Framing,
         half_close: bool,
         deadline: Instant,
@@ -315,15 +514,18 @@ impl Grpc {
             framing,
             half_close,
             upload_closed: false,
-            response: Some(response),
+            response: Some(PendingResponse::Direct(response)),
+            response_deadline: true,
             receive: None,
-            send,
+            send: send.into(),
             deadline: Box::pin(tokio::time::sleep_until(deadline)),
             writes,
             pending: None,
+            #[cfg(feature = "sing-mux")]
+            coalesced: None,
             frame: Bytes::new(),
             wire: BytesMut::new(),
-            payload: Bytes::new(),
+            remaining_payload: 0,
             queued: Bytes::new(),
             eof: false,
             data_eof: false,
@@ -333,6 +535,7 @@ impl Grpc {
         }
     }
     fn drain(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        self.close.writer.register(cx.waker());
         if self.stopped() {
             return Poll::Ready(Err(io::ErrorKind::BrokenPipe.into()));
         }
@@ -341,6 +544,11 @@ impl Grpc {
         if self.send.poll_reset(cx).is_ready() {
             return Poll::Ready(Err(io::ErrorKind::BrokenPipe.into()));
         }
+        #[cfg(feature = "sing-mux")]
+        if let Some(ack) = &self.coalesced {
+            self.send.reserve_capacity(0);
+            return ack.poll_flushed(cx);
+        }
         for _ in 0..crate::limits::IO_POLL_BUDGET {
             if let Some(pending) = &mut self.pending {
                 ready!(Pin::new(pending).poll(cx)).map_err(|_| io::ErrorKind::BrokenPipe)??;
@@ -368,6 +576,47 @@ impl Grpc {
         Poll::Pending
     }
 
+    #[cfg(feature = "sing-mux")]
+    fn poll_coalesced_write(
+        &mut self,
+        cx: &mut Context<'_>,
+        input: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        let ack = self.coalesced.as_ref().expect("private h2mux writer");
+        ack.check(cx)?;
+        if self.send.poll_reset(cx).is_ready() {
+            ack.fail(io::ErrorKind::BrokenPipe);
+            return Poll::Ready(Err(io::ErrorKind::BrokenPipe.into()));
+        }
+        if input.is_empty() {
+            return Poll::Ready(Ok(0));
+        }
+        let wanted = input.len().min(CHUNK);
+        self.send.reserve_capacity(wanted);
+        let count = ready!(self.send.poll_capacity(cx))
+            .ok_or(io::ErrorKind::BrokenPipe)?
+            .map_err(|_| io::ErrorKind::BrokenPipe)?;
+        let count = wanted.min(count);
+        if count == 0 {
+            cx.waker().wake_by_ref();
+            return Poll::Pending;
+        }
+        let payload = self
+            .writes
+            .coalesced_payload(Bytes::copy_from_slice(&input[..count]), ack)?;
+        if self.send.send_data(payload, false).is_err() {
+            ack.fail(io::ErrorKind::BrokenPipe);
+            return Poll::Ready(Err(io::ErrorKind::BrokenPipe.into()));
+        }
+        // Retain demand for accepted buffered DATA, not the caller's unaccepted tail.
+        self.send.reserve_capacity(0);
+        // The existing h2 capacity includes max_send_buffer_size. No private
+        // tail/oneshot remains; its Connection owns every accepted byte.
+        Poll::Ready(Ok(count))
+    }
+
+    // Validate the complete bounded header before exposing any payload. A
+    // later truncated body remains an error after its valid prefix was read.
     fn record(&mut self) -> io::Result<bool> {
         if self.wire.len() < 5 {
             return Ok(false);
@@ -376,28 +625,103 @@ impl Grpc {
         if self.wire[0] != 0 || !(2..=LIMIT + 4).contains(&length) {
             return Err(invalid());
         }
-        if self.wire.len() < length + 5 {
+        if self.wire.len() < 7 {
             return Ok(false);
         }
         if self.wire[5] != 0x0a {
             return Err(invalid());
         }
         let mut value = 0;
-        let mut start = None;
         for index in 0..3 {
-            let byte = *self.wire.get(6 + index).ok_or_else(invalid)?;
+            let Some(&byte) = self.wire.get(6 + index) else {
+                return Ok(false);
+            };
             value |= usize::from(byte & 0x7f) << (7 * index);
             if byte & 0x80 == 0 {
-                start = Some(7 + index);
-                break;
+                if value > LIMIT || 7 + index + value != length + 5 {
+                    return Err(invalid());
+                }
+                self.remaining_payload = value;
+                self.wire.clear();
+                return Ok(true);
             }
         }
-        let start = start.ok_or_else(invalid)?;
-        if value > LIMIT || start + value != length + 5 {
-            return Err(invalid());
+        Err(invalid())
+    }
+    fn poll_gun_read(
+        &mut self,
+        cx: &mut Context<'_>,
+        output: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        let this = self;
+        for _ in 0..crate::limits::IO_POLL_BUDGET {
+            if this.remaining_payload != 0 && !this.frame.is_empty() {
+                let count = this
+                    .remaining_payload
+                    .min(this.frame.len())
+                    .min(output.remaining());
+                output.put_slice(&this.frame[..count]);
+                this.frame.advance(count);
+                this.remaining_payload -= count;
+                this.receive
+                    .as_mut()
+                    .unwrap()
+                    .flow_control()
+                    .release_capacity(count)
+                    .map_err(|_| invalid())?;
+                return Poll::Ready(Ok(()));
+            }
+            if this.remaining_payload == 0 {
+                if this.record()? {
+                    continue;
+                }
+                if !this.frame.is_empty() {
+                    // Only the five-byte gRPC prefix, tag and <=3 varint bytes
+                    // are staged; the declared payload stays in its h2 frame.
+                    let needed = match this.wire.len() {
+                        0..5 => 5,
+                        5..7 => 7,
+                        length => length + 1,
+                    };
+                    let count = (needed - this.wire.len()).min(this.frame.len());
+                    this.wire.extend_from_slice(&this.frame[..count]);
+                    this.frame.advance(count);
+                    this.receive
+                        .as_mut()
+                        .unwrap()
+                        .flow_control()
+                        .release_capacity(count)
+                        .map_err(|_| invalid())?;
+                    continue;
+                }
+            }
+            let receive = this.receive.as_mut().unwrap();
+            if !this.data_eof {
+                match ready!(receive.poll_data(cx)) {
+                    Some(Ok(frame)) => {
+                        this.frame = frame;
+                        continue;
+                    }
+                    Some(Err(_)) => return Poll::Ready(Err(invalid())),
+                    None => this.data_eof = true,
+                }
+            }
+            if this.remaining_payload != 0 || !this.wire.is_empty() {
+                return Poll::Ready(Err(invalid()));
+            }
+            let trailers = ready!(receive.poll_trailers(cx)).map_err(|_| invalid())?;
+            if trailers
+                .as_ref()
+                .and_then(|headers| headers.get("grpc-status"))
+                .is_some_and(|status| status != "0")
+            {
+                return Poll::Ready(Err(invalid()));
+            }
+            this.eof = true;
+            return Poll::Ready(Ok(()));
         }
-        self.payload = self.wire.split().freeze().slice(start..);
-        Ok(true)
+        cx.waker().wake_by_ref();
+        Poll::Pending
     }
 }
 
@@ -412,18 +736,21 @@ impl AsyncRead for Grpc {
             return Poll::Ready(Ok(()));
         }
         this.close.reader.register(cx.waker());
+        if this.close.failed.load(Ordering::SeqCst) {
+            return Poll::Ready(Err(invalid()));
+        }
         if this.stopped() || this.eof {
             return Poll::Ready(Ok(()));
         }
         if let Some(response) = &mut this.response {
             // Lazy setup still uses the original deadline, even when headers
             // are already queued. Established reads are not setup operations.
-            if this.deadline.as_mut().poll(cx).is_ready() {
+            if this.response_deadline && this.deadline.as_mut().poll(cx).is_ready() {
                 return Poll::Ready(Err(io::ErrorKind::TimedOut.into()));
             }
             match Pin::new(response).poll(cx) {
                 Poll::Ready(result) => {
-                    let response = result.map_err(|_| invalid())?;
+                    let response = result?;
                     if response.status() != 200
                         || (this.framing == Framing::Gun
                             && !response.headers().get("content-type").is_some_and(|value| {
@@ -469,59 +796,7 @@ impl AsyncRead for Grpc {
             cx.waker().wake_by_ref();
             return Poll::Pending;
         }
-        for _ in 0..crate::limits::IO_POLL_BUDGET {
-            if !this.payload.is_empty() {
-                let count = this.payload.len().min(output.remaining());
-                output.put_slice(&this.payload[..count]);
-                this.payload.advance(count);
-                return Poll::Ready(Ok(()));
-            }
-            if this.record()? {
-                continue;
-            }
-            let receive = this.receive.as_mut().unwrap();
-            if !this.frame.is_empty() {
-                let needed = if this.wire.len() < 5 {
-                    5
-                } else {
-                    5 + u32::from_be_bytes(this.wire[1..5].try_into().unwrap()) as usize
-                };
-                let count = (needed - this.wire.len()).min(this.frame.len());
-                this.wire.extend_from_slice(&this.frame[..count]);
-                this.frame.advance(count);
-                // Only consumed bytes replenish the peer's window.
-                receive
-                    .flow_control()
-                    .release_capacity(count)
-                    .map_err(|_| invalid())?;
-                continue;
-            }
-            if !this.data_eof {
-                match ready!(receive.poll_data(cx)) {
-                    Some(Ok(frame)) => {
-                        this.frame = frame;
-                        continue;
-                    }
-                    Some(Err(_)) => return Poll::Ready(Err(invalid())),
-                    None => this.data_eof = true,
-                }
-            }
-            if !this.wire.is_empty() {
-                return Poll::Ready(Err(invalid()));
-            }
-            let trailers = ready!(receive.poll_trailers(cx)).map_err(|_| invalid())?;
-            if trailers
-                .as_ref()
-                .and_then(|headers| headers.get("grpc-status"))
-                .is_some_and(|status| status != "0")
-            {
-                return Poll::Ready(Err(invalid()));
-            }
-            this.eof = true;
-            return Poll::Ready(Ok(()));
-        }
-        cx.waker().wake_by_ref();
-        Poll::Pending
+        this.poll_gun_read(cx, output)
     }
 }
 
@@ -531,9 +806,14 @@ impl AsyncWrite for Grpc {
         cx: &mut Context<'_>,
         input: &[u8],
     ) -> Poll<io::Result<usize>> {
+        self.close.writer.register(cx.waker());
         if self.stopped() || self.upload_closed {
             return Poll::Ready(Err(io::ErrorKind::BrokenPipe.into()));
         }
+        #[cfg(feature = "sing-mux")]
+        if self.coalesced.is_some() {
+            return self.poll_coalesced_write(cx, input);
+        }
         ready!(self.drain(cx))?;
         if input.is_empty() {
             return Poll::Ready(Ok(0));
@@ -578,6 +858,9 @@ impl AsyncWrite for Grpc {
         ready!(self.drain(cx))?;
         self.upload_closed = true;
         self.close.stop();
+        if let Some(lease) = &self._lease {
+            lease.close_stream();
+        }
         self.send.send_reset(h2::Reason::CANCEL);
         self.response = None;
         self.receive = None;
@@ -589,3 +872,135 @@ impl AsyncWrite for Grpc {
         Poll::Ready(Ok(()))
     }
 }
+
+#[cfg(all(test, feature = "sing-mux"))]
+mod coalesced_partial_memory_tests {
+    use super::*;
+    use std::time::Duration;
+    use tokio::io::AsyncWriteExt;
+
+    #[tokio::test]
+    async fn private_h2mux_partial_write_releases_unaccepted_reservation() {
+        let (raw, peer) = tokio::io::duplex(65536);
+        let (raw, writes) = Writes::wrap(Box::new(raw));
+        let (mut sender, connection) = h2::client::Builder::new()
+            .enable_push(false)
+            .max_send_buffer_size(CHUNK)
+            .handshake::<_, Payload>(raw)
+            .await
+            .unwrap();
+        let client = tokio::spawn(connection);
+        let (ready, ready_rx) = tokio::sync::oneshot::channel();
+        let (grown, grown_rx) = tokio::sync::oneshot::channel();
+        let (release, release_rx) = tokio::sync::oneshot::channel();
+        let peer = tokio::spawn(async move {
+            let mut connection = h2::server::Builder::new()
+                .initial_window_size(1)
+                .handshake::<_, Bytes>(peer)
+                .await
+                .unwrap();
+            let (request, mut reply) = connection.accept().await.unwrap().unwrap();
+            let output = reply.send_response(http::Response::new(()), false).unwrap();
+            drop(reply);
+            let mut input = request.into_body();
+            let mut ping = connection.ping_pong().unwrap();
+            macro_rules! drive {
+                ($future:expr) => {{
+                    let future = $future;
+                    tokio::pin!(future);
+                    loop {
+                        tokio::select! { biased;
+                            result = &mut future => break result,
+                            next = connection.accept() => {
+                                assert!(matches!(next, Some(Ok(_))), "peer closed before fixture release");
+                            }
+                        }
+                    }
+                }};
+            }
+            drive!(ping.ping(h2::Ping::opaque())).unwrap();
+            drive!(ping.ping(h2::Ping::opaque())).unwrap();
+            ready.send(()).unwrap();
+            let prefix = drive!(input.data()).unwrap().unwrap().to_vec();
+            // Keep this one received byte's flow credit until cleanup. The
+            // new stream window adds CHUNK-1 genuine peer credit, no payload.
+            connection.set_initial_window_size(CHUNK as u32).unwrap();
+            // h2 polls pending user PING before local SETTINGS. The second
+            // PING is ordered after SETTINGS, making its ACK a real barrier.
+            drive!(ping.ping(h2::Ping::opaque())).unwrap();
+            drive!(ping.ping(h2::Ping::opaque())).unwrap();
+            grown.send(prefix).unwrap();
+            drive!(release_rx).unwrap();
+            drop((input, output, ping));
+            while let Some(result) = connection.accept().await {
+                result.unwrap();
+            }
+        });
+        let request = http::Request::builder()
+            .method("CONNECT")
+            .uri("https://fixture.invalid")
+            .body(())
+            .unwrap();
+        let (response, send) = sender.send_request(request, false).unwrap();
+        let mut stream = Grpc::new(
+            response,
+            send,
+            Framing::Plain,
+            true,
+            Instant::now() + Duration::from_secs(3),
+            Arc::default(),
+            None,
+            None,
+            writes,
+        );
+        stream.coalesced = Some(Arc::new(CoalescedAck::default()));
+        stream.response_deadline = false;
+        tokio::time::timeout(Duration::from_secs(1), ready_rx)
+            .await
+            .unwrap()
+            .unwrap();
+        let payload = [b'p'; CHUNK];
+        let accepted = tokio::time::timeout(Duration::from_secs(1), stream.write(&payload))
+            .await
+            .unwrap()
+            .unwrap();
+        // Caller stays idle: no second write, flush or capacity reservation.
+        let prefix = tokio::time::timeout(Duration::from_secs(1), grown_rx)
+            .await
+            .unwrap()
+            .unwrap();
+        let unused = match &stream.send {
+            H2Send::Direct(native) => Some(native.capacity()),
+            H2Send::Shared(_) => None,
+        };
+        release.send(()).unwrap();
+        drop((stream, sender));
+        let client_result = tokio::time::timeout(Duration::from_secs(1), client)
+            .await
+            .unwrap()
+            .unwrap();
+        tokio::time::timeout(Duration::from_secs(1), peer)
+            .await
+            .unwrap()
+            .unwrap();
+        // Both drivers naturally joined before the behavioral assertions.
+        assert!(
+            client_result.is_ok(),
+            "client cleanup failed: {client_result:?}"
+        );
+        assert_eq!(accepted, 1, "peer stream-window fixture failed");
+        assert_eq!(
+            prefix, b"p",
+            "the idle caller delivered an unaccepted suffix"
+        );
+        assert_eq!(
+            unused,
+            Some(0),
+            "private h2mux must return unaccepted partial-write credit before caller idle"
+        );
+    }
+}
+
+#[cfg(test)]
+#[path = "grpc_gun_streaming_read_memory_tests.rs"]
+mod streaming_read_memory_tests;
diff --git a/src/transport/grpc_gun_streaming_read_memory_tests.rs b/src/transport/grpc_gun_streaming_read_memory_tests.rs
new file mode 100644
index 0000000..b694511
--- /dev/null
+++ b/src/transport/grpc_gun_streaming_read_memory_tests.rs
@@ -0,0 +1,298 @@
+//! Real Gun reader over actual h2 and a bounded in-memory byte transport.
+use super::*;
+use crate::resources::observation::ResourceProbe;
+use std::time::Duration;
+use tokio::{
+    io::{AsyncReadExt, AsyncWriteExt},
+    sync::oneshot,
+};
+use tokio_util::sync::CancellationToken;
+
+struct Peer {
+    stream: BoxStream,
+    driver: Option<Driver>,
+    tail: Option<oneshot::Sender<()>>,
+    cancel: CancellationToken,
+    task: JoinHandle<()>,
+}
+
+impl Peer {
+    fn release_tail(&mut self) {
+        self.tail.take().unwrap().send(()).unwrap();
+    }
+
+    async fn finish(self) {
+        drop(self.stream);
+        self.cancel.cancel();
+        if let Some(driver) = self.driver {
+            driver.stop().await.unwrap();
+        }
+        tokio::time::timeout(Duration::from_secs(3), self.task)
+            .await
+            .unwrap()
+            .unwrap();
+    }
+}
+
+fn message(payload: &[u8]) -> Bytes {
+    let mut wire = vec![0; 5];
+    wire.push(0x0a);
+    let mut length = payload.len();
+    while length > 127 {
+        wire.push((length as u8 & 0x7f) | 0x80);
+        length >>= 7;
+    }
+    wire.push(length as u8);
+    wire.extend_from_slice(payload);
+    let length = (wire.len() - 5) as u32;
+    wire[1..5].copy_from_slice(&length.to_be_bytes());
+    wire.into()
+}
+
+async fn peer(prefix: Vec<Bytes>, tail: Bytes, status: &'static str) -> Peer {
+    let (raw, supplied) = tokio::io::duplex(CHUNK);
+    let (ready, prepared) = oneshot::channel();
+    let (release, released) = oneshot::channel();
+    let cancel = CancellationToken::new();
+    let stop = cancel.clone();
+    let task = tokio::spawn(async move {
+        let mut connection = h2::server::Builder::new()
+            .handshake::<_, Bytes>(supplied)
+            .await
+            .unwrap();
+        let (_request, mut response) = connection.accept().await.unwrap().unwrap();
+        let headers = http::Response::builder()
+            .header("content-type", "application/grpc")
+            .body(())
+            .unwrap();
+        let mut output = response.send_response(headers, false).unwrap();
+        for part in prefix {
+            output.send_data(part, false).unwrap();
+        }
+        let mut ping = connection.ping_pong().unwrap();
+        macro_rules! drive {
+            ($future:expr) => {{
+                let future = $future;
+                tokio::pin!(future);
+                loop {
+                    tokio::select! { biased;
+                        () = stop.cancelled() => return,
+                        result = &mut future => break result,
+                        next = connection.accept() => {
+                            if !matches!(next, Some(Ok(_))) {
+                                return;
+                            }
+                        }
+                    }
+                }
+            }};
+        }
+        // The real round trip keeps the h2 driver live and observes receipt
+        // of the earlier DATA, without releasing the application's tail gate.
+        drive!(ping.ping(h2::Ping::opaque())).unwrap();
+        drive!(ping.ping(h2::Ping::opaque())).unwrap();
+        if ready.send(()).is_err() || drive!(released).is_err() {
+            return;
+        }
+        if !tail.is_empty() {
+            output.send_data(tail, false).unwrap();
+        }
+        let mut trailers = http::HeaderMap::new();
+        trailers.insert("grpc-status", http::HeaderValue::from_static(status));
+        output.send_trailers(trailers).unwrap();
+        loop {
+            tokio::select! {
+                () = stop.cancelled() => break,
+                next = connection.accept() => {
+                    if !matches!(next, Some(Ok(_))) {
+                        break;
+                    }
+                }
+            }
+        }
+    });
+    let (stream, driver) = grpc_duplex(
+        Box::new(raw),
+        "http://fixture.invalid/GunService/Tun",
+        Instant::now() + Duration::from_secs(3),
+    )
+    .await
+    .unwrap();
+    tokio::time::timeout(Duration::from_secs(3), prepared)
+        .await
+        .unwrap()
+        .unwrap();
+    Peer {
+        stream,
+        driver: Some(driver),
+        tail: Some(release),
+        cancel,
+        task,
+    }
+}
+
+#[tokio::test]
+async fn gun_reader_delivers_validated_prefix_before_withheld_message_tail() {
+    let probe = ResourceProbe::default();
+    let (first, zero, got, expected) = probe
+        .scope(async {
+            let expected: Vec<_> = (0..LIMIT).map(|n| (n % 251) as u8).collect();
+            let wire = message(&expected);
+            let header = wire.len() - expected.len();
+            let mut prefix: Vec<_> = (0..header).map(|n| wire.slice(n..n + 1)).collect();
+            prefix.push(wire.slice(header..header + 257));
+            let mut peer = peer(prefix, wire.slice(header + 257..), "0").await;
+            let zero = peer.stream.read(&mut []).await.unwrap();
+            let mut bytes = [0; 257];
+            let first = {
+                let reading = peer.stream.read(&mut bytes);
+                tokio::pin!(reading);
+                // Dropping a Pending borrowed read must retain parsing state.
+                futures_util::poll!(reading.as_mut())
+            };
+            let mut got = Vec::new();
+            if let Poll::Ready(Ok(count)) = &first {
+                got.extend_from_slice(&bytes[..*count]);
+            }
+            // Upload FIN must preserve the independently gated read half.
+            peer.stream.shutdown().await.unwrap();
+            peer.release_tail();
+            tokio::time::timeout(Duration::from_secs(3), peer.stream.read_to_end(&mut got))
+                .await
+                .unwrap()
+                .unwrap();
+            peer.finish().await;
+            (first, zero, got, expected)
+        })
+        .await;
+    assert!(probe.snapshot().is_idle(), "{:?}", probe.snapshot());
+    assert_eq!(zero, 0);
+    assert_eq!(got, expected, "streamed Gun bytes changed or duplicated");
+    assert!(
+        matches!(first, Poll::Ready(Ok(257))),
+        "Gun reader withheld a validated payload prefix until the message tail arrived"
+    );
+}
+
+#[tokio::test]
+async fn gun_reader_split_varints_zero_messages_and_back_to_back_records() {
+    for length in [1, 127, 128, CHUNK, LIMIT] {
+        let expected: Vec<_> = (0..length).map(|n| (n % 239) as u8).collect();
+        let empty = message(&[]);
+        let wire = message(&expected);
+        let header = wire.len() - length;
+        let mut parts = vec![empty];
+        parts.extend((0..header).map(|n| wire.slice(n..n + 1)));
+        parts.push(wire.slice(header..));
+        parts.push(message(b"next"));
+        // The original reader accepts these redundant varint encodings.
+        parts.push(Bytes::from_static(&[0, 0, 0, 0, 4, 0x0a, 0x81, 0, b'z']));
+        parts.push(Bytes::from_static(&[
+            0, 0, 0, 0, 5, 0x0a, 0x81, 0x80, 0, b'z',
+        ]));
+        let mut peer = peer(parts, Bytes::new(), "0").await;
+        peer.release_tail();
+        let mut got = Vec::new();
+        tokio::time::timeout(Duration::from_secs(3), peer.stream.read_to_end(&mut got))
+            .await
+            .unwrap()
+            .unwrap();
+        peer.finish().await;
+        let mut expected = expected;
+        expected.extend_from_slice(b"nextzz");
+        assert_eq!(got, expected);
+    }
+}
+
+#[tokio::test]
+async fn gun_reader_keeps_header_rejections_and_reports_truncated_body_after_prefix() {
+    let mut compressed = message(b"valid").to_vec();
+    compressed[0] = 1;
+    let mut tag = message(b"valid").to_vec();
+    tag[5] = 0x12;
+    let mut mismatch = message(b"valid").to_vec();
+    mismatch[6] = 4;
+    let mut excessive = vec![0; 5];
+    excessive[1..].copy_from_slice(&((LIMIT + 5) as u32).to_be_bytes());
+    for wire in [
+        Bytes::from(compressed),
+        Bytes::from(tag),
+        Bytes::from(mismatch),
+        Bytes::from(excessive),
+        Bytes::from_static(&[0, 0, 0, 0, 1, 0x0a]),
+        Bytes::from_static(&[0, 0, 0, 0, 2, 0x0a, 0x80, 0]),
+        Bytes::from_static(&[0, 0, 0, 0, 4, 0x0a, 0x80, 0x80, 0x80]),
+        Bytes::from_static(&[0, 0, 0]),
+    ] {
+        let mut peer = peer(vec![wire], Bytes::new(), "0").await;
+        peer.release_tail();
+        let mut got = Vec::new();
+        let result =
+            tokio::time::timeout(Duration::from_secs(3), peer.stream.read_to_end(&mut got))
+                .await
+                .unwrap();
+        peer.finish().await;
+        assert_eq!(result.unwrap_err().kind(), io::ErrorKind::InvalidData);
+        assert!(got.is_empty(), "invalid header exposed payload");
+    }
+    let wire = message(b"complete");
+    let mut peer = peer(vec![wire.slice(..wire.len() - 3)], Bytes::new(), "0").await;
+    peer.release_tail();
+    let mut got = Vec::new();
+    let result = tokio::time::timeout(Duration::from_secs(3), peer.stream.read_to_end(&mut got))
+        .await
+        .unwrap();
+    peer.finish().await;
+    assert_eq!(result.unwrap_err().kind(), io::ErrorKind::InvalidData);
+    assert_eq!(got, b"compl", "valid prefix was made artificially atomic");
+}
+
+#[tokio::test]
+async fn gun_reader_partial_header_cancellation_and_active_stop_keep_owned_progress() {
+    let wire = message(b"cancelled-header");
+    let mut partial = peer(vec![wire.slice(..3)], wire.slice(3..), "0").await;
+    let mut bytes = [0; 32];
+    let pending = {
+        let reading = partial.stream.read(&mut bytes);
+        tokio::pin!(reading);
+        futures_util::poll!(reading.as_mut()).is_pending()
+    };
+    partial.release_tail();
+    let mut got = Vec::new();
+    tokio::time::timeout(Duration::from_secs(3), partial.stream.read_to_end(&mut got))
+        .await
+        .unwrap()
+        .unwrap();
+    partial.finish().await;
+    assert!(pending, "incomplete header produced a false EOF");
+    assert_eq!(got, b"cancelled-header");
+
+    let probe = ResourceProbe::default();
+    probe
+        .scope(async {
+            let wire = message(b"prefix-and-withheld-tail");
+            let first = wire.len() - b"prefix-and-withheld-tail".len() + 6;
+            let mut active = peer(vec![wire.slice(..first)], wire.slice(first..), "0").await;
+            let mut prefix = [0; 6];
+            tokio::time::timeout(
+                Duration::from_secs(3),
+                active.stream.read_exact(&mut prefix),
+            )
+            .await
+            .unwrap()
+            .unwrap();
+            let waiting = {
+                let reading = active.stream.read(&mut bytes);
+                tokio::pin!(reading);
+                futures_util::poll!(reading.as_mut()).is_pending()
+            };
+            active.driver.take().unwrap().stop().await.unwrap();
+            let stopped = active.stream.read(&mut bytes).await.unwrap();
+            active.finish().await;
+            assert!(waiting);
+            assert_eq!(prefix, *b"prefix");
+            assert_eq!(stopped, 0);
+        })
+        .await;
+    assert!(probe.snapshot().is_idle(), "{:?}", probe.snapshot());
+}
diff --git a/src/transport/grpc_pool.rs b/src/transport/grpc_pool.rs
index 6b8de59..1600cbc 100644
--- a/src/transport/grpc_pool.rs
+++ b/src/transport/grpc_pool.rs
@@ -1,6 +1,6 @@
 //! Node-owned gRPC physical connections. Policy matches Mihomo's two threshold
 //! branches; bounded idle retention does not impose a business-flow quota.
-use super::h2_write::{Sender, Writes};
+use super::h2_write::{Payload, Sender, Writes};
 use crate::{config::GrpcOptions, dispatch::BoxStream};
 use std::{
     future::Future,
@@ -23,10 +23,35 @@ use tokio_util::{sync::CancellationToken, task::TaskTracker};
 const MAX_IDLE_CONNECTIONS: usize = crate::limits::GRPC_IDLE_CONNECTIONS;
 const PING_TIMEOUT: Duration = Duration::from_secs(crate::limits::GRPC_PING_TIMEOUT_SECONDS as u64);
 
+#[derive(Clone, Copy)]
+pub(super) enum ResponsePolicy {
+    SetupDeadline,
+    #[cfg(any(
+        feature = "outbound-vmess",
+        feature = "outbound-vless",
+        feature = "outbound-trojan"
+    ))]
+    ClientFirst,
+}
+
+enum RequestKind<'a> {
+    Grpc(&'a str),
+    #[cfg(feature = "outbound-trusttunnel")]
+    Connect(http::Request<()>, Option<Arc<dyn Fn() + Send + Sync>>),
+    #[cfg(feature = "outbound-masque")]
+    ConnectAdmitted(http::Request<()>),
+}
+
 pub struct GrpcPool {
     options: GrpcOptions,
+    stream_receive_window: u32,
+    response_policy: ResponsePolicy,
+    half_close: bool,
+    empty_data: bool,
     connections: Arc<SyncMutex<Vec<Connection>>>,
     opening: Mutex<()>,
+    admission: SyncMutex<()>,
+    idle_timeout: Option<Duration>,
     cancellation: CancellationToken,
     tasks: TaskTracker,
 }
@@ -34,12 +59,64 @@ impl GrpcPool {
     pub fn new(options: GrpcOptions) -> Self {
         Self {
             options,
+            stream_receive_window: super::STREAM_BUFFER_BYTES as u32,
+            response_policy: ResponsePolicy::SetupDeadline,
+            half_close: false,
+            empty_data: false,
             connections: Arc::default(),
             opening: Mutex::default(),
+            admission: SyncMutex::default(),
+            idle_timeout: None,
             cancellation: CancellationToken::new(),
             tasks: TaskTracker::new(),
         }
     }
+    /// Callers bound complete protocol request submission with the setup deadline.
+    /// Keep the client-first response policy fixed across pooled connections.
+    #[cfg(any(feature = "outbound-vmess", feature = "outbound-vless"))]
+    pub(crate) fn new_client_first(options: GrpcOptions) -> Self {
+        let mut pool = Self::new(options);
+        pool.response_policy = ResponsePolicy::ClientFirst;
+        pool
+    }
+    #[cfg(feature = "outbound-trusttunnel")]
+    pub(crate) fn connect_client() -> Self {
+        let mut pool = Self::new(GrpcOptions {
+            max_connections: 1,
+            min_streams: 0,
+            ..Default::default()
+        });
+        pool.idle_timeout = Some(Duration::from_secs(30));
+        pool.empty_data = true;
+        pool
+    }
+    #[cfg(feature = "outbound-masque")]
+    pub(crate) fn masque_ip() -> Self {
+        let mut pool = Self::new(GrpcOptions {
+            max_connections: 1,
+            min_streams: 0,
+            ping_interval: 30,
+            ..Default::default()
+        });
+        // One CONNECT-IP response carries the node's inner IP traffic.
+        pool.stream_receive_window = 128 * 1024;
+        pool
+    }
+    /// Trojan keeps its response and lease after upload END_STREAM.
+    #[cfg(any(test, feature = "outbound-trojan"))]
+    pub(crate) fn duplex(options: GrpcOptions) -> Self {
+        let mut pool = Self::new(options);
+        pool.half_close = true;
+        pool
+    }
+    /// Trojan bounds authentication submission separately and keeps receiving
+    /// after upload END_STREAM while waiting for the first HTTP response.
+    #[cfg(feature = "outbound-trojan")]
+    pub(crate) fn duplex_client_first(options: GrpcOptions) -> Self {
+        let mut pool = Self::duplex(options);
+        pool.response_policy = ResponsePolicy::ClientFirst;
+        pool
+    }
     /// The factory is invoked only for a new physical connection. A reused
     /// transport keeps its original upstream selection and TLS identity.
     pub async fn open<F, Fut>(
@@ -48,6 +125,88 @@ impl GrpcPool {
         deadline: Instant,
         connect: F,
     ) -> io::Result<BoxStream>
+    where
+        F: FnOnce() -> Fut,
+        Fut: Future<Output = io::Result<BoxStream>>,
+    {
+        self.open_request(RequestKind::Grpc(uri), deadline, connect)
+            .await
+    }
+    /// An unframed CONNECT stream shares the same physical-IO ownership and
+    /// pool policy as gRPC, without importing gRPC headers or record framing.
+    #[cfg(feature = "outbound-trusttunnel")]
+    pub(crate) async fn open_connect<F, Fut>(
+        &self,
+        request: http::Request<()>,
+        deadline: Instant,
+        connect: F,
+    ) -> io::Result<BoxStream>
+    where
+        F: FnOnce() -> Fut,
+        Fut: Future<Output = io::Result<BoxStream>>,
+    {
+        self.open_request(RequestKind::Connect(request, None), deadline, connect)
+            .await
+    }
+    #[cfg(feature = "outbound-trusttunnel")]
+    pub(crate) async fn open_connect_observed<F, Fut>(
+        &self,
+        request: http::Request<()>,
+        deadline: Instant,
+        observer: Arc<dyn Fn() + Send + Sync>,
+        connect: F,
+    ) -> io::Result<BoxStream>
+    where
+        F: FnOnce() -> Fut,
+        Fut: Future<Output = io::Result<BoxStream>>,
+    {
+        self.open_request(
+            RequestKind::Connect(request, Some(observer)),
+            deadline,
+            connect,
+        )
+        .await
+    }
+    #[cfg(feature = "outbound-masque")]
+    pub(crate) async fn open_connect_admitted<F, Fut>(
+        &self,
+        request: http::Request<()>,
+        deadline: Instant,
+        connect: F,
+    ) -> io::Result<BoxStream>
+    where
+        F: FnOnce() -> Fut,
+        Fut: Future<Output = io::Result<BoxStream>>,
+    {
+        self.open_request(RequestKind::ConnectAdmitted(request), deadline, connect)
+            .await
+    }
+    #[cfg(feature = "outbound-trusttunnel")]
+    pub(crate) async fn probe<F, Fut>(
+        &self,
+        request: http::Request<()>,
+        deadline: Instant,
+        connect: F,
+    ) -> io::Result<()>
+    where
+        F: FnOnce() -> Fut,
+        Fut: Future<Output = io::Result<BoxStream>>,
+    {
+        let operation = async {
+            let (sender, lease) = self.acquire(connect).await?;
+            super::grpc::connect_probe(sender, request, deadline, lease).await
+        };
+        tokio::select! {biased;
+            ()=self.cancellation.cancelled()=>Err(io::ErrorKind::ConnectionAborted.into()),
+            result=timeout_at(deadline,operation)=>result.map_err(|_|io::Error::from(io::ErrorKind::TimedOut))?,
+        }
+    }
+    async fn open_request<F, Fut>(
+        &self,
+        request: RequestKind<'_>,
+        deadline: Instant,
+        connect: F,
+    ) -> io::Result<BoxStream>
     where
         F: FnOnce() -> Fut,
         Fut: Future<Output = io::Result<BoxStream>>,
@@ -55,57 +214,114 @@ impl GrpcPool {
         let operation = async {
             // Only physical creation is serialized; waiting callers own their
             // deadline/cancellation and no detached queue or worker is created.
-            let (sender, lease) = {
-                let _opening = self.opening.lock().await;
-                let existing = {
-                    let mut connections = self.connections.lock().unwrap();
-                    connections.retain(|connection| !connection.closed.load(Ordering::Acquire));
-                    connections
-                        .iter()
-                        .min_by_key(|connection| connection.active.load(Ordering::Acquire))
-                        .filter(|connection| {
-                            let active = connection.active.load(Ordering::Acquire);
-                            active == 0
-                                || if self.options.max_connections > 0 {
-                                    connections.len() >= self.options.max_connections
-                                        || active < self.options.min_streams
-                                } else {
-                                    self.options.max_streams > 0
-                                        && active < self.options.max_streams
-                                }
-                        })
-                        .map(|connection| connection.reserve(&self.connections))
-                        .transpose()?
-                };
-                match existing {
-                    Some(pair) => pair,
-                    None => {
-                        let raw = connect().await?;
-                        let connection = self.establish(raw).await?;
-                        let pair = connection.reserve(&self.connections)?;
-                        self.connections.lock().unwrap().push(connection);
-                        pair
+            let (sender, lease) = self.acquire(connect).await?;
+            match request {
+                RequestKind::Grpc(uri) => {
+                    super::grpc::pooled_stream(
+                        sender,
+                        uri,
+                        &self.options.user_agent,
+                        self.half_close,
+                        deadline,
+                        self.response_policy,
+                        lease,
+                    )
+                    .await
+                }
+                #[cfg(feature = "outbound-trusttunnel")]
+                RequestKind::Connect(request, observer) => {
+                    let (stream, response) =
+                        super::grpc::pooled_connect(sender, request, deadline, lease, observer)
+                            .await?;
+                    let _admission = self.admission.lock().unwrap();
+                    if self.cancellation.is_cancelled() {
+                        return Err(io::ErrorKind::ConnectionAborted.into());
                     }
+                    let cancellation = self.cancellation.clone();
+                    self.tasks.spawn(crate::resources::observation::task(async move {
+                        tokio::select! {biased; ()=cancellation.cancelled()=>{}, ()=response=>{}}
+                    }));
+                    Ok(stream)
                 }
-            };
-            super::grpc::pooled_stream(sender, uri, &self.options.user_agent, deadline, lease).await
+                #[cfg(feature = "outbound-masque")]
+                RequestKind::ConnectAdmitted(request) => {
+                    super::grpc::pooled_connect_admitted(sender, request, deadline, lease).await
+                }
+            }
         };
         tokio::select! {biased;
             ()=self.cancellation.cancelled()=>Err(io::ErrorKind::ConnectionAborted.into()),
             result=timeout_at(deadline,operation)=>result.map_err(|_|io::Error::from(io::ErrorKind::TimedOut))?,
         }
     }
+    async fn acquire<F, Fut>(&self, connect: F) -> io::Result<(Sender, Lease)>
+    where
+        F: FnOnce() -> Fut,
+        Fut: Future<Output = io::Result<BoxStream>>,
+    {
+        let _opening = self.opening.lock().await;
+        let existing = {
+            let mut connections = self.connections.lock().unwrap();
+            connections.retain(|connection| !connection.closed.load(Ordering::Acquire));
+            connections
+                .iter()
+                .min_by_key(|connection| connection.active.load(Ordering::Acquire))
+                .filter(|connection| {
+                    let active = connection.active.load(Ordering::Acquire);
+                    active == 0
+                        || if self.options.max_connections > 0 {
+                            connections.len() >= self.options.max_connections
+                                || active < self.options.min_streams
+                        } else {
+                            self.options.max_streams > 0 && active < self.options.max_streams
+                        }
+                })
+                .map(|connection| connection.reserve(&self.connections))
+                .transpose()?
+        };
+        match existing {
+            Some(pair) => Ok(pair),
+            None => {
+                let raw = connect().await?;
+                let connection = self.establish(raw).await?;
+                let pair = connection.reserve(&self.connections)?;
+                let _admission = self.admission.lock().unwrap();
+                if self.cancellation.is_cancelled() {
+                    return Err(io::ErrorKind::ConnectionAborted.into());
+                }
+                self.connections.lock().unwrap().push(connection);
+                Ok(pair)
+            }
+        }
+    }
     async fn establish(&self, raw: BoxStream) -> io::Result<Connection> {
+        let empty = self.empty_data.then(super::h2_empty::Registry::default);
+        let raw = match &empty {
+            Some(registry) => registry.wrap(raw),
+            None => raw,
+        };
         let last_read = Arc::new(SyncMutex::new(Instant::now()));
         let (raw, writes) = Writes::wrap(raw);
-        let (sender, mut connection) = h2::client::Builder::new()
+        let mut builder = h2::client::Builder::new();
+        builder
             .enable_push(false)
-            .initial_window_size(super::STREAM_BUFFER_BYTES as u32)
+            .initial_window_size(self.stream_receive_window)
             .initial_connection_window_size((2 * super::STREAM_BUFFER_BYTES) as u32)
             .max_frame_size(super::STREAM_CHUNK_BYTES as u32)
             .max_header_list_size(super::STREAM_CHUNK_BYTES as u32)
             .max_concurrent_streams(0)
-            .max_send_buffer_size(super::STREAM_CHUNK_BYTES)
+            .max_send_buffer_size(super::STREAM_CHUNK_BYTES);
+        #[cfg(any(
+            feature = "outbound-vmess",
+            feature = "outbound-vless",
+            feature = "outbound-trojan"
+        ))]
+        if matches!(self.response_policy, ResponsePolicy::ClientFirst) {
+            // A queued request is not a completed H2 handshake. Keep request
+            // flush pending until peer SETTINGS, under the caller's deadline.
+            builder.initial_max_send_streams(0);
+        }
+        let (sender, mut connection) = builder
             .handshake(ActivityIo {
                 raw: Box::new(raw),
                 last_read: last_read.clone(),
@@ -114,19 +330,48 @@ impl GrpcPool {
             .map_err(|_| io::Error::from(io::ErrorKind::ConnectionAborted))?;
         let mut ping = connection.ping_pong().expect("single PING owner");
         let closed = Arc::new(AtomicBool::new(false));
-        let lifetime = Lifetime(closed.clone());
+        let lifetime = Lifetime(closed.clone(), empty.clone());
         let token = self.cancellation.child_token();
         let cancellation = token.clone();
         let interval = self.options.ping_interval;
+        let active = Arc::new(AtomicUsize::new(0));
+        let idle_since = Arc::new(SyncMutex::new(Some(Instant::now())));
+        let activity = Arc::new(tokio::sync::Notify::new());
+        let idle = idle_since.clone();
+        let idle_timeout = self.idle_timeout;
+        let registry = Arc::downgrade(&self.connections);
+        let driver_closed = closed.clone();
+        let driver_active = active.clone();
         let observation =
             crate::resources::observation::track(crate::resources::observation::ResourceKind::Task);
+        let _admission = self.admission.lock().unwrap();
+        if self.cancellation.is_cancelled() {
+            return Err(io::ErrorKind::ConnectionAborted.into());
+        }
+        let driver_activity = activity.clone();
         self.tasks.spawn(crate::resources::observation::bind(async move {
             let _observation=observation;
             let _lifetime=lifetime;
             if interval==0 {
-                tokio::select! {biased;
-                    ()=cancellation.cancelled()=>{},
-                    _=&mut connection=>{},
+                loop {
+                    let notified = driver_activity.notified();
+                    let expires = idle_timeout.and_then(|timeout| idle.lock().unwrap().map(|since| since + timeout));
+                    tokio::select! {biased;
+                        ()=cancellation.cancelled()=>break,
+                        _=&mut connection=>break,
+                        ()=notified=>{},
+                        ()=async { match expires { Some(deadline)=>tokio::time::sleep_until(deadline).await, None=>std::future::pending().await } }=>{
+                            // Reserve and retire share the registry barrier.
+                            // Publish retirement before a caller can reserve
+                            // this connection after the idle decision.
+                            let Some(registry) = registry.upgrade() else { break; };
+                            let _connections = registry.lock().unwrap();
+                            if driver_active.load(Ordering::Acquire)==0 && idle_timeout.zip(*idle.lock().unwrap()).is_some_and(|(timeout,since)|Instant::now()>=since+timeout) {
+                                driver_closed.store(true, Ordering::Release);
+                                break;
+                            }
+                        }
+                    }
                 }
                 return;
             }
@@ -153,8 +398,11 @@ impl GrpcPool {
                 request: sender,
                 writes,
             },
+            empty,
             closed,
-            active: Arc::default(),
+            active,
+            idle_since,
+            activity,
             token,
             _observation: crate::resources::observation::track(
                 crate::resources::observation::ResourceKind::Pool,
@@ -162,25 +410,667 @@ impl GrpcPool {
         })
     }
     pub fn begin_shutdown(&self) {
+        let _admission = self.admission.lock().unwrap();
+        for connection in self.connections.lock().unwrap().iter() {
+            if let Some(registry) = &connection.empty {
+                registry.stop();
+            }
+        }
         self.cancellation.cancel();
+        self.tasks.close();
     }
     pub async fn shutdown(&self) {
         self.begin_shutdown();
-        self.tasks.close();
         self.tasks.wait().await;
         self.connections.lock().unwrap().clear();
     }
 }
 impl Drop for GrpcPool {
     fn drop(&mut self) {
-        self.cancellation.cancel();
+        self.begin_shutdown();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::resources::observation::{ResourceKind, ResourceProbe};
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+    #[cfg(feature = "outbound-masque")]
+    #[tokio::test(start_paused = true)]
+    async fn masque_h2_scoped_receive_window_reaches_wire_and_joins_stop() {
+        let observation = ResourceProbe::default();
+        let advertised = observation
+            .scope(async {
+                let mut owners = vec![
+                    ("generic", GrpcPool::new(GrpcOptions::default()), 64 * 1024),
+                    ("masque-ip", GrpcPool::masque_ip(), 128 * 1024),
+                ];
+                #[cfg(feature = "outbound-trusttunnel")]
+                owners.push(("trusttunnel", GrpcPool::connect_client(), 64 * 1024));
+                #[cfg(any(feature = "outbound-vmess", feature = "outbound-vless"))]
+                owners.push((
+                    "client-first",
+                    GrpcPool::new_client_first(GrpcOptions::default()),
+                    64 * 1024,
+                ));
+                let mut advertised = Vec::new();
+                for (name, pool, expected) in owners {
+                    let (raw, mut peer) = tokio::io::duplex(65536);
+                    // Supply the peer's empty SETTINGS; inspect the real h2
+                    // client's preface, SETTINGS and connection WINDOW_UPDATE.
+                    peer.write_all(&[0, 0, 0, 4, 0, 0, 0, 0, 0]).await.unwrap();
+                    let connection = pool.establish(Box::new(raw)).await.unwrap();
+                    let (window, connection_window) =
+                        timeout_at(Instant::now() + Duration::from_secs(5), async {
+                            let mut preface = [0; 24];
+                            peer.read_exact(&mut preface).await.unwrap();
+                            assert_eq!(&preface, b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n");
+                            let mut window = None;
+                            let mut connection_window = None;
+                            while window.is_none() || connection_window.is_none() {
+                                let mut header = [0; 9];
+                                peer.read_exact(&mut header).await.unwrap();
+                                let len = (usize::from(header[0]) << 16)
+                                    | (usize::from(header[1]) << 8)
+                                    | usize::from(header[2]);
+                                assert!(len <= 16 * 1024);
+                                let stream = u32::from_be_bytes(header[5..9].try_into().unwrap())
+                                    & 0x7fff_ffff;
+                                let mut body = vec![0; len];
+                                peer.read_exact(&mut body).await.unwrap();
+                                match header[3] {
+                                    4 if stream == 0 && header[4] & 1 == 0 => {
+                                        assert_eq!(body.len() % 6, 0);
+                                        for setting in body.chunks_exact(6) {
+                                            if setting[..2] == [0, 4] {
+                                                window = Some(u32::from_be_bytes(
+                                                    setting[2..].try_into().unwrap(),
+                                                ));
+                                            }
+                                        }
+                                    }
+                                    8 if stream == 0 => {
+                                        assert_eq!(body.len(), 4);
+                                        let increment =
+                                            u32::from_be_bytes(body.try_into().unwrap())
+                                                & 0x7fff_ffff;
+                                        connection_window = Some(65535 + increment);
+                                    }
+                                    _ => {}
+                                }
+                            }
+                            (window.unwrap(), connection_window.unwrap())
+                        })
+                        .await
+                        .unwrap();
+                    pool.shutdown().await;
+                    assert!(pool.tasks.is_empty());
+                    assert!(connection.closed.load(Ordering::Acquire));
+                    assert_eq!(observation.snapshot().current(ResourceKind::Task), 0);
+                    drop(connection);
+                    drop(peer);
+                    advertised.push((name, window, connection_window, expected));
+                }
+                advertised
+            })
+            .await;
+        assert!(observation.snapshot().is_idle());
+        for (name, window, connection_window, expected) in advertised {
+            assert_eq!(window, expected, "MASQUE_H2_SCOPED_STREAM_WINDOW: {name}");
+            assert_eq!(connection_window, 128 * 1024, "{name} connection window");
+        }
+    }
+
+    #[cfg(feature = "outbound-masque")]
+    struct MasqueRequest {
+        receive: h2::RecvStream,
+        response: h2::server::SendResponse<bytes::Bytes>,
+    }
+
+    #[cfg(feature = "outbound-masque")]
+    fn masque_request(authority: &str) -> http::Request<()> {
+        http::Request::builder()
+            .method("CONNECT")
+            .uri(http::Uri::builder().authority(authority).build().unwrap())
+            .header("cf-connect-proto", "cf-connect-ip")
+            .header("pq-enabled", "false")
+            .header("user-agent", "")
+            .body(())
+            .unwrap()
+    }
+
+    #[cfg(feature = "outbound-masque")]
+    async fn masque_peer(
+        peer: tokio::io::DuplexStream,
+        requests: tokio::sync::mpsc::Sender<MasqueRequest>,
+    ) {
+        let mut connection = h2::server::handshake(peer).await.unwrap();
+        while let Some(Ok((request, response))) = connection.accept().await {
+            assert_eq!(request.method(), "CONNECT");
+            assert!(request.uri().scheme().is_none());
+            assert!(request.extensions().get::<h2::ext::Protocol>().is_none());
+            assert_eq!(request.headers()["cf-connect-proto"], "cf-connect-ip");
+            assert_eq!(request.headers()["pq-enabled"], "false");
+            assert_eq!(request.headers()["user-agent"], "");
+            assert!(!request.headers().contains_key("capsule-protocol"));
+            if requests
+                .send(MasqueRequest {
+                    receive: request.into_body(),
+                    response,
+                })
+                .await
+                .is_err()
+            {
+                return;
+            }
+        }
+    }
+
+    #[cfg(feature = "outbound-masque")]
+    #[tokio::test(start_paused = true)]
+    async fn masque_h2_admission_preserves_data_and_sibling_until_joined_stop() {
+        let observation = ResourceProbe::default();
+        observation
+            .scope(async {
+                let peers = TaskTracker::new();
+                let pool = GrpcPool::masque_ip();
+                let count = AtomicUsize::new(0);
+                let (requests, mut accepted) = tokio::sync::mpsc::channel(4);
+                let factory = || async {
+                    count.fetch_add(1, Ordering::SeqCst);
+                    let (raw, peer) = tokio::io::duplex(65536);
+                    peers.spawn(masque_peer(peer, requests.clone()));
+                    Ok(Box::new(raw) as BoxStream)
+                };
+                let mut opening = Box::pin(pool.open_connect_admitted(
+                    masque_request("first.invalid:443"),
+                    Instant::now() + Duration::from_secs(5),
+                    factory,
+                ));
+                let mut first_peer = tokio::select! {
+                    request=accepted.recv()=>request.unwrap(),
+                    result=&mut opening=>panic!("CONNECT returned before response: {}", result.is_ok()),
+                };
+                std::future::poll_fn(|cx| {
+                    assert!(opening.as_mut().poll(cx).is_pending());
+                    Poll::Ready(())
+                })
+                .await;
+                let mut first_send = first_peer
+                    .response
+                    .send_response(http::Response::new(()), false)
+                    .unwrap();
+                first_send
+                    .send_data(bytes::Bytes::from_static(b"server-first"), false)
+                    .unwrap();
+                let mut first = opening.await.unwrap();
+                tokio::time::advance(Duration::from_secs(6)).await;
+                let mut prefix = [0; 12];
+                first.read_exact(&mut prefix).await.unwrap();
+                assert_eq!(&prefix, b"server-first");
+
+                let mut opening = Box::pin(pool.open_connect_admitted(
+                    masque_request("sibling.invalid:443"),
+                    Instant::now() + Duration::from_secs(5),
+                    factory,
+                ));
+                let mut sibling_peer = tokio::select! {
+                    request=accepted.recv()=>request.unwrap(),
+                    result=&mut opening=>panic!("CONNECT returned before response: {}", result.is_ok()),
+                };
+                let mut sibling_send = sibling_peer
+                    .response
+                    .send_response(http::Response::new(()), false)
+                    .unwrap();
+                let mut sibling = opening.await.unwrap();
+
+                let mut opening = Box::pin(pool.open_connect_admitted(
+                    masque_request("reject.invalid:443"),
+                    Instant::now() + Duration::from_secs(5),
+                    factory,
+                ));
+                let mut rejected = tokio::select! {
+                    request=accepted.recv()=>request.unwrap(),
+                    result=&mut opening=>panic!("CONNECT returned before response: {}", result.is_ok()),
+                };
+                let _rejected_send = rejected
+                    .response
+                    .send_response(
+                        http::Response::builder().status(201).body(()).unwrap(),
+                        false,
+                    )
+                    .unwrap();
+                assert_eq!(opening.await.err().unwrap().kind(), io::ErrorKind::InvalidData);
+                assert!(rejected.receive.data().await.unwrap().is_err());
+
+                first.write_all(b"past-deadline").await.unwrap();
+                first.flush().await.unwrap();
+                let upload = first_peer.receive.data().await.unwrap().unwrap();
+                assert_eq!(upload.as_ref(), b"past-deadline");
+                first_peer
+                    .receive
+                    .flow_control()
+                    .release_capacity(upload.len())
+                    .unwrap();
+                first.shutdown().await.unwrap();
+                assert!(first_peer.receive.data().await.unwrap().is_err());
+                sibling_send
+                    .send_data(bytes::Bytes::from_static(b"alive"), false)
+                    .unwrap();
+                let mut echo = [0; 5];
+                sibling.read_exact(&mut echo).await.unwrap();
+                assert_eq!(&echo, b"alive");
+                assert_eq!(count.load(Ordering::SeqCst), 1);
+                assert_eq!(observation.snapshot().current(ResourceKind::Task), 1);
+                pool.shutdown().await;
+                assert!(pool.tasks.is_empty());
+                assert_eq!(observation.snapshot().current(ResourceKind::Task), 0);
+                assert!(sibling.write_all(b"stopped").await.is_err());
+                drop(first);
+                drop(sibling);
+                drop(first_send);
+                drop(sibling_send);
+                peers.close();
+                peers.wait().await;
+            })
+            .await;
+        assert!(observation.snapshot().is_idle());
+    }
+
+    #[cfg(feature = "outbound-masque")]
+    #[tokio::test(start_paused = true)]
+    async fn masque_h2_cancel_timeout_and_stop_reset_pending_admission() {
+        let observation = ResourceProbe::default();
+        observation
+            .scope(async {
+                let peers = TaskTracker::new();
+                let pool = GrpcPool::masque_ip();
+                let count = AtomicUsize::new(0);
+                let (requests, mut accepted) = tokio::sync::mpsc::channel(4);
+                let factory = || async {
+                    count.fetch_add(1, Ordering::SeqCst);
+                    let (raw, peer) = tokio::io::duplex(65536);
+                    peers.spawn(masque_peer(peer, requests.clone()));
+                    Ok(Box::new(raw) as BoxStream)
+                };
+                let mut opening = Box::pin(pool.open_connect_admitted(
+                    masque_request("cancel.invalid:443"),
+                    Instant::now() + Duration::from_secs(5),
+                    factory,
+                ));
+                let mut cancelled = tokio::select! {
+                    request=accepted.recv()=>request.unwrap(),
+                    result=&mut opening=>panic!("CONNECT returned before response: {}", result.is_ok()),
+                };
+                drop(opening);
+                assert!(cancelled.receive.data().await.unwrap().is_err());
+
+                let mut opening = Box::pin(pool.open_connect_admitted(
+                    masque_request("timeout.invalid:443"),
+                    Instant::now() + Duration::from_secs(5),
+                    factory,
+                ));
+                let mut expired = tokio::select! {
+                    request=accepted.recv()=>request.unwrap(),
+                    result=&mut opening=>panic!("CONNECT returned before response: {}", result.is_ok()),
+                };
+                tokio::time::advance(Duration::from_secs(6)).await;
+                assert_eq!(opening.await.err().unwrap().kind(), io::ErrorKind::TimedOut);
+                assert!(expired.receive.data().await.unwrap().is_err());
+
+                let mut opening = Box::pin(pool.open_connect_admitted(
+                    masque_request("late-ready.invalid:443"),
+                    Instant::now() + Duration::from_secs(5),
+                    factory,
+                ));
+                let mut late = tokio::select! {
+                    request=accepted.recv()=>request.unwrap(),
+                    result=&mut opening=>panic!("CONNECT returned before response: {}", result.is_ok()),
+                };
+                let _late_send = late
+                    .response
+                    .send_response(http::Response::new(()), false)
+                    .unwrap();
+                // Let the independent driver process an accepted response,
+                // but do not poll admission again until setup has expired.
+                tokio::time::advance(Duration::from_secs(6)).await;
+                assert_eq!(opening.await.err().unwrap().kind(), io::ErrorKind::TimedOut);
+                assert!(late.receive.data().await.unwrap().is_err());
+                assert_eq!(count.load(Ordering::SeqCst), 1);
+
+                let mut opening = Box::pin(pool.open_connect_admitted(
+                    masque_request("stop.invalid:443"),
+                    Instant::now() + Duration::from_secs(5),
+                    factory,
+                ));
+                let _stopped = tokio::select! {
+                    request=accepted.recv()=>request.unwrap(),
+                    result=&mut opening=>panic!("CONNECT returned before response: {}", result.is_ok()),
+                };
+                pool.shutdown().await;
+                assert_eq!(
+                    opening.await.err().unwrap().kind(),
+                    io::ErrorKind::ConnectionAborted
+                );
+                assert!(pool.tasks.is_empty());
+                assert_eq!(observation.snapshot().current(ResourceKind::Task), 0);
+                peers.close();
+                peers.wait().await;
+            })
+            .await;
+        assert!(observation.snapshot().is_idle());
+    }
+
+    #[cfg(feature = "outbound-trusttunnel")]
+    #[tokio::test]
+    async fn trusttunnel_rejected_headers_wake_a_flow_control_blocked_writer() {
+        let pool = GrpcPool::connect_client();
+        let peers = TaskTracker::new();
+        let reject = Arc::new(tokio::sync::Notify::new());
+        let (accepted, ready) = tokio::sync::oneshot::channel();
+        let (raw, peer) = tokio::io::duplex(65536);
+        let signal = reject.clone();
+        let streams = peers.clone();
+        peers.spawn(async move {
+            let mut connection = h2::server::Builder::new()
+                .initial_window_size(0)
+                .handshake::<_, bytes::Bytes>(peer)
+                .await
+                .unwrap();
+            let (request, mut response) = connection.accept().await.unwrap().unwrap();
+            streams.spawn(async move {
+                accepted.send(()).unwrap();
+                signal.notified().await;
+                let send = response
+                    .send_response(
+                        http::Response::builder().status(403).body(()).unwrap(),
+                        false,
+                    )
+                    .unwrap();
+                let _send = send;
+                let mut receive = request.into_body();
+                while receive.data().await.is_some_and(|data| data.is_ok()) {}
+            });
+            while connection.accept().await.is_some() {}
+        });
+        let request = http::Request::builder()
+            .method("CONNECT")
+            .uri(
+                http::Uri::builder()
+                    .authority("example.invalid:443")
+                    .build()
+                    .unwrap(),
+            )
+            .body(())
+            .unwrap();
+        let mut stream = pool
+            .open_connect(request, Instant::now() + Duration::from_secs(5), || async {
+                Ok(Box::new(raw) as BoxStream)
+            })
+            .await
+            .unwrap();
+        ready.await.unwrap();
+        for _ in 0..4 {
+            tokio::task::yield_now().await;
+        }
+        stream.write_all(b"blocked").await.unwrap();
+        let (pending, reached) = tokio::sync::oneshot::channel();
+        let mut pending = Some(pending);
+        let writer = tokio::spawn(async move {
+            let mut flush = Box::pin(stream.flush());
+            std::future::poll_fn(|cx| {
+                let result = flush.as_mut().poll(cx);
+                if result.is_pending()
+                    && let Some(signal) = pending.take()
+                {
+                    let _ = signal.send(());
+                }
+                result
+            })
+            .await
+        });
+        reached.await.unwrap();
+        reject.notify_one();
+        // Timeout observes the child join; its wake cannot re-poll the blocked
+        // flush and hide a missing Close writer notification.
+        assert!(
+            tokio::time::timeout(Duration::from_secs(1), writer)
+                .await
+                .unwrap()
+                .unwrap()
+                .is_err()
+        );
+        pool.shutdown().await;
+        peers.close();
+        peers.wait().await;
+    }
+
+    #[cfg(feature = "outbound-trusttunnel")]
+    #[tokio::test(start_paused = true)]
+    async fn trusttunnel_h2_probe_idle_retirement_and_stop_admission() {
+        let observation = ResourceProbe::default();
+        observation
+            .scope(async {
+                let peers = TaskTracker::new();
+                let count = AtomicUsize::new(0);
+                let pool = GrpcPool::connect_client();
+                let factory = || async {
+                    count.fetch_add(1, Ordering::SeqCst);
+                    let (raw, peer) = tokio::io::duplex(65536);
+                    let streams = peers.clone();
+                    peers.spawn(async move {
+                        let mut connection = h2::server::handshake(peer).await.unwrap();
+                        while let Some(Ok((request, mut response))) = connection.accept().await {
+                            if request.uri().authority().unwrap().as_str() == "_check" {
+                                assert!(request.body().is_end_stream());
+                                response
+                                    .send_response(http::Response::new(()), true)
+                                    .unwrap();
+                            } else {
+                                let mut send = response
+                                    .send_response(http::Response::new(()), false)
+                                    .unwrap();
+                                streams.spawn(async move {
+                                    let mut receive = request.into_body();
+                                    while let Some(Ok(data)) = receive.data().await {
+                                        receive
+                                            .flow_control()
+                                            .release_capacity(data.len())
+                                            .unwrap();
+                                        if send.send_data(data, false).is_err() {
+                                            return;
+                                        }
+                                    }
+                                });
+                            }
+                        }
+                    });
+                    Ok(Box::new(raw) as BoxStream)
+                };
+                let request = |target| {
+                    http::Request::builder()
+                        .method("CONNECT")
+                        .uri(http::Uri::builder().authority(target).build().unwrap())
+                        .body(())
+                        .unwrap()
+                };
+                let mut first = pool
+                    .open_connect(
+                        request("example.invalid:443"),
+                        Instant::now() + Duration::from_secs(5),
+                        factory,
+                    )
+                    .await
+                    .unwrap();
+                first.write_all(b"first").await.unwrap();
+                first.flush().await.unwrap();
+                tokio::time::advance(Duration::from_secs(6)).await;
+                // Headers arrived before the read: an expired setup deadline must
+                // not invalidate an established CONNECT response.
+                let mut echo = [0; 5];
+                first.read_exact(&mut echo).await.unwrap();
+                assert_eq!(&echo, b"first");
+                first.shutdown().await.unwrap();
+                drop(first);
+                pool.probe(
+                    request("_check"),
+                    Instant::now() + Duration::from_secs(7),
+                    factory,
+                )
+                .await
+                .unwrap();
+                assert_eq!(count.load(Ordering::SeqCst), 1);
+                tokio::time::advance(Duration::from_secs(31)).await;
+                for _ in 0..4 {
+                    tokio::task::yield_now().await;
+                }
+                let mut second = pool
+                    .open_connect(
+                        request("example.invalid:443"),
+                        Instant::now() + Duration::from_secs(5),
+                        factory,
+                    )
+                    .await
+                    .unwrap();
+                assert_eq!(count.load(Ordering::SeqCst), 2);
+                second.write_all(b"again").await.unwrap();
+                second.flush().await.unwrap();
+                second.read_exact(&mut echo).await.unwrap();
+                assert_eq!(&echo, b"again");
+                pool.shutdown().await;
+                assert!(second.write_all(b"stopped").await.is_err());
+                drop(second);
+                let (raw, _peer) = tokio::io::duplex(65536);
+                assert!(pool.establish(Box::new(raw)).await.is_err());
+                assert!(pool.tasks.is_empty());
+                assert!(
+                    pool.open_connect(
+                        request("example.invalid:443"),
+                        Instant::now() + Duration::from_secs(5),
+                        factory
+                    )
+                    .await
+                    .is_err()
+                );
+                assert_eq!(count.load(Ordering::SeqCst), 2);
+                peers.close();
+                peers.wait().await;
+            })
+            .await;
+        assert!(observation.snapshot().is_idle());
+    }
+
+    #[tokio::test]
+    async fn grpc_duplex_pool_keeps_response_and_sibling_after_end_stream_and_joins_stop() {
+        let probe = ResourceProbe::default();
+        probe
+            .scope(async {
+                tokio::time::timeout(Duration::from_secs(3), async {
+                    let tasks = TaskTracker::new();
+                    let count = Arc::new(AtomicUsize::new(0));
+                    let pool = GrpcPool::duplex(GrpcOptions::default());
+                    let factory = || async {
+                        count.fetch_add(1, Ordering::SeqCst);
+                        let (io, peer) = tokio::io::duplex(65536);
+                        let sessions = tasks.clone();
+                        tasks.spawn(async move {
+                            let mut connection = h2::server::handshake(peer).await.unwrap();
+                            while let Some(Ok((request, mut response))) = connection.accept().await
+                            {
+                                assert_eq!(request.headers()["user-agent"], "grpc-go/1.36.0");
+                                let mut send = response
+                                    .send_response(
+                                        http::Response::builder()
+                                            .status(200)
+                                            .header("content-type", "application/grpc")
+                                            .body(())
+                                            .unwrap(),
+                                        false,
+                                    )
+                                    .unwrap();
+                                let mut receive = request.into_body();
+                                sessions.spawn(async move {
+                                    while let Some(data) = receive.data().await {
+                                        let Ok(data) = data else {
+                                            return;
+                                        };
+                                        receive
+                                            .flow_control()
+                                            .release_capacity(data.len())
+                                            .unwrap();
+                                        if send.send_data(data, false).is_err() {
+                                            return;
+                                        }
+                                    }
+                                    send.send_data(
+                                        bytes::Bytes::from_static(b"\0\0\0\0\x06\x0a\x04tail"),
+                                        false,
+                                    )
+                                    .unwrap();
+                                    let mut trailers = http::HeaderMap::new();
+                                    trailers.insert("grpc-status", "0".parse().unwrap());
+                                    send.send_trailers(trailers).unwrap();
+                                });
+                            }
+                        });
+                        Ok(Box::new(io) as BoxStream)
+                    };
+                    let deadline = Instant::now() + Duration::from_secs(2);
+                    let mut first = pool
+                        .open("http://example.com/GunService/Tun", deadline, factory)
+                        .await
+                        .unwrap();
+                    let mut sibling = pool
+                        .open("http://example.com/GunService/Tun", deadline, factory)
+                        .await
+                        .unwrap();
+                    assert_eq!(count.load(Ordering::SeqCst), 1);
+                    first.write_all(b"first").await.unwrap();
+                    first.shutdown().await.unwrap();
+                    first.shutdown().await.unwrap();
+                    // Upload is closed, but its response and physical lease survive.
+                    assert!(first.write_all(b"closed").await.is_err());
+                    assert_eq!(
+                        pool.connections.lock().unwrap()[0]
+                            .active
+                            .load(Ordering::Acquire),
+                        2
+                    );
+                    let mut response = Vec::new();
+                    first.read_to_end(&mut response).await.unwrap();
+                    assert_eq!(response, b"firsttail");
+                    sibling.write_all(b"alive").await.unwrap();
+                    sibling.flush().await.unwrap();
+                    let mut echo = [0; 5];
+                    sibling.read_exact(&mut echo).await.unwrap();
+                    assert_eq!(&echo, b"alive");
+                    assert_eq!(probe.snapshot().current(ResourceKind::Task), 1);
+                    pool.shutdown().await;
+                    assert_eq!(probe.snapshot().current(ResourceKind::Task), 0);
+                    assert_eq!(probe.snapshot().current(ResourceKind::Pool), 0);
+                    assert!(sibling.write_all(b"stopped").await.is_err());
+                    drop(first);
+                    drop(sibling);
+                    tasks.close();
+                    tasks.wait().await;
+                })
+                .await
+                .unwrap();
+            })
+            .await;
+        assert!(probe.snapshot().is_idle());
     }
 }
 struct Connection {
     sender: Sender,
+    empty: Option<super::h2_empty::Registry>,
     active: Arc<AtomicUsize>,
     closed: Arc<AtomicBool>,
     token: CancellationToken,
+    idle_since: Arc<SyncMutex<Option<Instant>>>,
+    activity: Arc<tokio::sync::Notify>,
     _observation: crate::resources::observation::Guard,
 }
 impl Connection {
@@ -190,24 +1080,36 @@ impl Connection {
                 count.checked_add(1)
             })
             .map_err(|_| io::Error::from(io::ErrorKind::OutOfMemory))?;
+        *self.idle_since.lock().unwrap() = None;
+        self.activity.notify_one();
         Ok((
             self.sender.clone(),
             Lease {
                 active: self.active.clone(),
                 closed: self.closed.clone(),
                 pool: Arc::downgrade(pool),
+                idle_since: self.idle_since.clone(),
+                activity: self.activity.clone(),
+                empty: self.empty.clone(),
+                ticket: None,
             },
         ))
     }
 }
 impl Drop for Connection {
     fn drop(&mut self) {
+        if let Some(registry) = &self.empty {
+            registry.stop();
+        }
         self.token.cancel();
     }
 }
-struct Lifetime(Arc<AtomicBool>);
+struct Lifetime(Arc<AtomicBool>, Option<super::h2_empty::Registry>);
 impl Drop for Lifetime {
     fn drop(&mut self) {
+        if let Some(registry) = &self.1 {
+            registry.stop();
+        }
         self.0.store(true, Ordering::Release);
     }
 }
@@ -216,19 +1118,53 @@ pub(super) struct Lease {
     active: Arc<AtomicUsize>,
     closed: Arc<AtomicBool>,
     pool: std::sync::Weak<SyncMutex<Vec<Connection>>>,
+    idle_since: Arc<SyncMutex<Option<Instant>>>,
+    activity: Arc<tokio::sync::Notify>,
+    empty: Option<super::h2_empty::Registry>,
+    ticket: Option<super::h2_empty::Ticket>,
 }
 impl Lease {
+    pub(super) fn request(
+        &mut self,
+        sender: &mut h2::client::SendRequest<Payload>,
+        request: http::Request<()>,
+        end: bool,
+    ) -> Result<(h2::client::ResponseFuture, super::h2_empty::Send), h2::Error> {
+        if let Some(registry) = &self.empty {
+            let (response, send, ticket) = registry.request(sender, request, end)?;
+            self.ticket = Some(ticket);
+            Ok((response, send))
+        } else {
+            sender
+                .send_request(request, end)
+                .map(|(response, send)| (response, send.into()))
+        }
+    }
+    pub(super) fn admission(&self) -> Option<super::h2_empty::Admission> {
+        self.ticket.as_ref().map(super::h2_empty::Ticket::admission)
+    }
+    pub(super) fn close_stream(&self) {
+        if let Some(ticket) = &self.ticket {
+            ticket.close();
+        }
+    }
     pub(super) fn stopped(&self) -> bool {
         self.closed.load(Ordering::Acquire)
     }
 }
 impl Drop for Lease {
     fn drop(&mut self) {
-        if self.active.fetch_sub(1, Ordering::AcqRel) == 1
-            && let Some(pool) = self.pool.upgrade()
-        {
+        self.ticket.take();
+        let pool = self.pool.upgrade();
+        let mut connections = pool.as_ref().map(|pool| pool.lock().unwrap());
+        if self.active.fetch_sub(1, Ordering::AcqRel) == 1 {
+            *self.idle_since.lock().unwrap() = Some(Instant::now());
+            self.activity.notify_one();
+            let Some(connections) = &mut connections else {
+                return;
+            };
             let mut idle = 0;
-            pool.lock().unwrap().retain(|connection| {
+            connections.retain(|connection| {
                 if connection.closed.load(Ordering::Acquire) {
                     return false;
                 }
diff --git a/src/transport/h2_empty.rs b/src/transport/h2_empty.rs
new file mode 100644
index 0000000..a1407c3
--- /dev/null
+++ b/src/transport/h2_empty.rs
@@ -0,0 +1,1022 @@
+//! TrustTunnel's legal empty DATA compatibility at the supplied H2 IO boundary.
+//! Official h2 still owns decoding, flow control and every non-noop frame.
+use super::h2_write::Payload;
+use crate::dispatch::BoxStream;
+use futures_util::task::AtomicWaker;
+use std::{
+    collections::BTreeMap,
+    io,
+    pin::Pin,
+    sync::{
+        Arc, Mutex, TryLockError, Weak,
+        atomic::{AtomicBool, Ordering},
+    },
+    task::{Context, Poll, Wake, Waker},
+};
+use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+
+#[derive(Clone, Default)]
+pub(super) struct Registry(Arc<RegistryInner>);
+
+#[derive(Default)]
+struct RegistryInner {
+    streams: Mutex<BTreeMap<u32, Arc<Slot>>>,
+    reader: Arc<AtomicWaker>,
+    waiting: AtomicBool,
+    stopped: AtomicBool,
+    #[cfg(test)]
+    filtered: std::sync::atomic::AtomicUsize,
+}
+
+struct Slot {
+    admitted: AtomicBool,
+    closed: AtomicBool,
+    send: Weak<SharedSend>,
+}
+
+pub(super) struct Ticket {
+    registry: Weak<RegistryInner>,
+    id: u32,
+    slot: Arc<Slot>,
+}
+
+pub(super) struct Admission(Weak<Slot>);
+
+impl Admission {
+    pub fn activate(&self) {
+        if let Some(slot) = self.0.upgrade()
+            && !slot.closed.load(Ordering::Acquire)
+        {
+            slot.admitted.store(true, Ordering::Release);
+        }
+    }
+}
+
+impl Ticket {
+    pub fn admission(&self) -> Admission {
+        Admission(Arc::downgrade(&self.slot))
+    }
+    pub fn close(&self) {
+        self.slot.closed.store(true, Ordering::Release);
+    }
+}
+
+impl Drop for Ticket {
+    fn drop(&mut self) {
+        self.close();
+        if let Some(registry) = self.registry.upgrade() {
+            registry.streams.lock().unwrap().remove(&self.id);
+            registry.wake_waiter();
+        }
+    }
+}
+
+impl RegistryInner {
+    fn wake_waiter(&self) {
+        if self.waiting.swap(false, Ordering::AcqRel) {
+            self.reader.wake();
+        }
+    }
+}
+
+impl Registry {
+    pub fn wrap(&self, raw: BoxStream) -> BoxStream {
+        Box::new(EmptyIo {
+            raw,
+            registry: self.clone(),
+            header: [0; 9],
+            have: 0,
+            emitted: 0,
+            ready: false,
+            remaining: 0,
+            progress: false,
+            eof: false,
+            continuation: None,
+            disabled: false,
+            consecutive: 0,
+            failed: false,
+        })
+    }
+
+    pub fn request(
+        &self,
+        sender: &mut h2::client::SendRequest<Payload>,
+        request: http::Request<()>,
+        end: bool,
+    ) -> Result<(h2::client::ResponseFuture, Send, Ticket), h2::Error> {
+        // Register the actual ID before the connection reader can inspect its
+        // response. Its try_lock path never blocks while h2 holds another lock.
+        let mut streams = self.0.streams.lock().unwrap();
+        let result = sender.send_request(request, end).map(|(response, raw)| {
+            let id = raw.stream_id().as_u32();
+            let send = Arc::new(SharedSend {
+                raw: Mutex::new(raw),
+                wake: Arc::new(StreamWake {
+                    writer: AtomicWaker::new(),
+                    reader: self.0.reader.clone(),
+                    waiting: AtomicBool::new(false),
+                }),
+            });
+            let slot = Arc::new(Slot {
+                admitted: AtomicBool::new(false),
+                closed: AtomicBool::new(self.0.stopped.load(Ordering::Acquire)),
+                send: Arc::downgrade(&send),
+            });
+            streams.insert(id, slot.clone());
+            (
+                response,
+                Send::Shared(send),
+                Ticket {
+                    registry: Arc::downgrade(&self.0),
+                    id,
+                    slot,
+                },
+            )
+        });
+        drop(streams);
+        self.0.wake_waiter();
+        result
+    }
+
+    pub fn stop(&self) {
+        self.0.stopped.store(true, Ordering::Release);
+        let mut streams = self.0.streams.lock().unwrap();
+        for slot in streams.values() {
+            slot.closed.store(true, Ordering::Release);
+        }
+        streams.clear();
+        drop(streams);
+        self.0.wake_waiter();
+    }
+
+    fn slot(&self, id: u32, cx: &mut Context<'_>) -> Poll<Option<Arc<Slot>>> {
+        self.0.reader.register(cx.waker());
+        let mut streams = self.0.streams.try_lock();
+        if matches!(streams, Err(TryLockError::WouldBlock)) {
+            self.0.waiting.store(true, Ordering::Release);
+            streams = self.0.streams.try_lock();
+        }
+        match streams {
+            Ok(streams) => {
+                let slot = streams.get(&id).cloned();
+                drop(streams);
+                self.0.wake_waiter();
+                Poll::Ready(slot)
+            }
+            Err(TryLockError::WouldBlock) => Poll::Pending,
+            Err(TryLockError::Poisoned(_)) => Poll::Ready(None),
+        }
+    }
+
+    fn open(slot: &Slot) -> bool {
+        slot.admitted.load(Ordering::Acquire) && !slot.closed.load(Ordering::Acquire)
+    }
+
+    fn eligible(&self, id: u32, cx: &mut Context<'_>) -> Poll<bool> {
+        if self.0.stopped.load(Ordering::Acquire) {
+            return Poll::Ready(false);
+        }
+        let Some(slot) = std::task::ready!(self.slot(id, cx)) else {
+            return Poll::Ready(false);
+        };
+        if !Self::open(&slot) {
+            return Poll::Ready(false);
+        }
+        let Some(send) = slot.send.upgrade() else {
+            slot.closed.store(true, Ordering::Release);
+            return Poll::Ready(false);
+        };
+        let mut raw = send.raw.try_lock();
+        if matches!(raw, Err(TryLockError::WouldBlock)) {
+            send.wake.waiting.store(true, Ordering::Release);
+            raw = send.raw.try_lock();
+        }
+        let mut raw = match raw {
+            Ok(raw) => raw,
+            Err(TryLockError::WouldBlock) => return Poll::Pending,
+            Err(TryLockError::Poisoned(_)) => return Poll::Ready(false),
+        };
+        let waker = Waker::from(send.wake.clone());
+        let reset = raw.poll_reset(&mut Context::from_waker(&waker));
+        drop(raw);
+        send.wake.release_waiter();
+        if reset.is_ready() {
+            slot.closed.store(true, Ordering::Release);
+        }
+        Poll::Ready(reset.is_pending() && Self::open(&slot))
+    }
+
+    #[cfg(test)]
+    pub fn filtered(&self) -> usize {
+        self.0.filtered.load(Ordering::Acquire)
+    }
+}
+
+struct StreamWake {
+    writer: AtomicWaker,
+    reader: Arc<AtomicWaker>,
+    waiting: AtomicBool,
+}
+
+impl StreamWake {
+    fn release_waiter(&self) {
+        if self.waiting.swap(false, Ordering::AcqRel) {
+            self.reader.wake();
+        }
+    }
+}
+
+impl Wake for StreamWake {
+    fn wake(self: Arc<Self>) {
+        self.wake_by_ref();
+    }
+    fn wake_by_ref(self: &Arc<Self>) {
+        self.writer.wake();
+        self.reader.wake();
+    }
+}
+
+pub(super) struct SharedSend {
+    raw: Mutex<h2::SendStream<Payload>>,
+    wake: Arc<StreamWake>,
+}
+
+pub(super) enum Send {
+    Direct(h2::SendStream<Payload>),
+    Shared(Arc<SharedSend>),
+}
+
+impl From<h2::SendStream<Payload>> for Send {
+    fn from(raw: h2::SendStream<Payload>) -> Self {
+        Self::Direct(raw)
+    }
+}
+
+impl Send {
+    fn with<T>(&mut self, operation: impl FnOnce(&mut h2::SendStream<Payload>) -> T) -> T {
+        match self {
+            Self::Direct(raw) => operation(raw),
+            Self::Shared(send) => {
+                let mut raw = send.raw.lock().unwrap();
+                let result = operation(&mut raw);
+                drop(raw);
+                send.wake.release_waiter();
+                result
+            }
+        }
+    }
+    fn poll<T>(
+        &mut self,
+        cx: &mut Context<'_>,
+        operation: impl FnOnce(&mut h2::SendStream<Payload>, &mut Context<'_>) -> T,
+    ) -> T {
+        match self {
+            Self::Direct(raw) => operation(raw, cx),
+            Self::Shared(send) => {
+                send.wake.writer.register(cx.waker());
+                let waker = Waker::from(send.wake.clone());
+                let mut raw = send.raw.lock().unwrap();
+                let result = operation(&mut raw, &mut Context::from_waker(&waker));
+                drop(raw);
+                send.wake.release_waiter();
+                result
+            }
+        }
+    }
+    pub fn reserve_capacity(&mut self, size: usize) {
+        self.with(|raw| raw.reserve_capacity(size));
+    }
+    pub fn poll_capacity(
+        &mut self,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<usize, h2::Error>>> {
+        self.poll(cx, |raw, cx| raw.poll_capacity(cx))
+    }
+    pub fn poll_reset(&mut self, cx: &mut Context<'_>) -> Poll<Result<h2::Reason, h2::Error>> {
+        self.poll(cx, |raw, cx| raw.poll_reset(cx))
+    }
+    pub fn send_data(&mut self, payload: Payload, end: bool) -> Result<(), h2::Error> {
+        self.with(|raw| raw.send_data(payload, end))
+    }
+    pub fn send_reset(&mut self, reason: h2::Reason) {
+        self.with(|raw| raw.send_reset(reason));
+    }
+}
+
+struct EmptyIo {
+    raw: BoxStream,
+    registry: Registry,
+    header: [u8; 9],
+    have: usize,
+    emitted: usize,
+    ready: bool,
+    remaining: usize,
+    progress: bool,
+    eof: bool,
+    continuation: Option<u32>,
+    disabled: bool,
+    consecutive: usize,
+    failed: bool,
+}
+
+impl EmptyIo {
+    fn frame(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<bool>> {
+        let length = (usize::from(self.header[0]) << 16)
+            | (usize::from(self.header[1]) << 8)
+            | usize::from(self.header[2]);
+        let kind = self.header[3];
+        let flags = self.header[4];
+        let wire_id = u32::from_be_bytes(self.header[5..9].try_into().unwrap());
+        let id = wire_id & 0x7fff_ffff;
+        let valid_id = id != 0 && wire_id == id;
+        // Resolve locks before changing parser state: Pending retries the same
+        // header and must not commit a CONTINUATION transition twice.
+        let slot = if valid_id && matches!(kind, 0 | 1 | 3) {
+            std::task::ready!(self.registry.slot(id, cx))
+        } else {
+            None
+        };
+        let candidate = kind == 0
+            && length == 0
+            && flags == 0
+            && valid_id
+            && id & 1 == 1
+            && !self.disabled
+            && self.continuation.is_none();
+        let eligible = candidate && std::task::ready!(self.registry.eligible(id, cx));
+        if let Some(expected) = self.continuation
+            && (kind != 9 || id != expected)
+        {
+            self.disabled = true;
+        }
+        if kind == 9 {
+            if self.continuation != Some(id) {
+                self.disabled = true;
+            } else if flags & 4 != 0 {
+                self.continuation = None;
+            }
+        } else if kind == 1 && flags & 4 == 0 {
+            self.continuation = Some(id);
+        }
+        if kind == 7 {
+            self.disabled = true;
+        }
+        if let Some(slot) = slot {
+            if kind == 3
+                || (matches!(kind, 0 | 1) && flags & 1 != 0)
+                || (kind == 1 && slot.admitted.load(Ordering::Acquire))
+            {
+                slot.closed.store(true, Ordering::Release);
+            }
+            self.progress = kind == 0 && length > 0 && flags & 8 == 0 && Registry::open(&slot);
+        }
+        if eligible {
+            self.consecutive += 1;
+            if self.consecutive > 100 {
+                self.failed = true;
+                return Poll::Ready(Err(io::Error::new(
+                    io::ErrorKind::InvalidData,
+                    "HTTP2 consecutive empty DATA limit",
+                )));
+            }
+            #[cfg(test)]
+            self.registry.0.filtered.fetch_add(1, Ordering::Relaxed);
+            return Poll::Ready(Ok(true));
+        }
+        self.remaining = length;
+        Poll::Ready(Ok(false))
+    }
+}
+
+impl AsyncRead for EmptyIo {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        out: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        let this = self.get_mut();
+        if out.remaining() == 0 {
+            return Poll::Ready(Ok(()));
+        }
+        if this.failed {
+            return Poll::Ready(Err(io::ErrorKind::InvalidData.into()));
+        }
+        for _ in 0..crate::limits::IO_POLL_BUDGET {
+            if this.ready && this.emitted < this.have {
+                let count = (this.have - this.emitted).min(out.remaining());
+                out.put_slice(&this.header[this.emitted..this.emitted + count]);
+                this.emitted += count;
+                if this.emitted == this.have && this.remaining == 0 {
+                    this.ready = false;
+                    this.have = 0;
+                    this.emitted = 0;
+                }
+                return Poll::Ready(Ok(()));
+            }
+            if this.remaining > 0 {
+                let limit = this.remaining.min(out.remaining());
+                let mut part = ReadBuf::new(out.initialize_unfilled_to(limit));
+                let result = Pin::new(&mut this.raw).poll_read(cx, &mut part);
+                let count = part.filled().len();
+                out.advance(count);
+                this.remaining -= count;
+                if this.remaining == 0 {
+                    if this.progress {
+                        this.consecutive = 0;
+                    }
+                    this.progress = false;
+                    this.ready = false;
+                    this.have = 0;
+                    this.emitted = 0;
+                }
+                // Never read ahead past a forwarded frame. h2 must process
+                // it (including internal resets) before we inspect a noop.
+                return result;
+            }
+            if this.eof {
+                return Poll::Ready(Ok(()));
+            }
+            if this.have < 9 {
+                let mut header = ReadBuf::new(&mut this.header[this.have..]);
+                std::task::ready!(Pin::new(&mut this.raw).poll_read(cx, &mut header))?;
+                let count = header.filled().len();
+                this.have += count;
+                if count == 0 {
+                    this.eof = true;
+                    this.ready = this.have != 0;
+                    continue;
+                }
+                if this.have < 9 {
+                    continue;
+                }
+            }
+            if std::task::ready!(this.frame(cx))? {
+                this.have = 0;
+                this.emitted = 0;
+            } else {
+                this.ready = true;
+            }
+        }
+        cx.waker().wake_by_ref();
+        Poll::Pending
+    }
+}
+
+impl AsyncWrite for EmptyIo {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        data: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        Pin::new(&mut self.raw).poll_write(cx, data)
+    }
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.raw).poll_flush(cx)
+    }
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.raw).poll_shutdown(cx)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::h2_write::{Payload, Writes};
+    use super::{Registry, Send, Ticket};
+    use crate::{
+        dispatch::BoxStream,
+        resources::observation::{self, ResourceKind, ResourceProbe},
+    };
+    use bytes::Bytes;
+    use std::{future::poll_fn, time::Duration};
+    use tokio::{
+        io::{AsyncReadExt, AsyncWriteExt, DuplexStream},
+        sync::{mpsc, oneshot},
+        time::timeout,
+    };
+    use tokio_util::{sync::CancellationToken, task::TaskTracker};
+
+    const DEADLINE: Duration = Duration::from_secs(5);
+
+    struct Client {
+        registry: Registry,
+        sender: Option<h2::client::SendRequest<Payload>>,
+        cancellation: CancellationToken,
+        tasks: TaskTracker,
+        completed: Option<oneshot::Receiver<Option<Result<(), h2::Error>>>>,
+    }
+
+    impl Client {
+        async fn new(
+            raw: DuplexStream,
+            cancellation: CancellationToken,
+            tasks: TaskTracker,
+        ) -> Self {
+            let registry = Registry::default();
+            let (raw, _writes) = Writes::wrap(Box::new(raw) as BoxStream);
+            let (sender, connection) = h2::client::Builder::new()
+                .enable_push(false)
+                .initial_window_size(64 * 1024)
+                .initial_connection_window_size(128 * 1024)
+                .handshake::<_, Payload>(registry.wrap(Box::new(raw)))
+                .await
+                .unwrap();
+            let (done, completed) = oneshot::channel();
+            let cancel = cancellation.clone();
+            tasks.spawn(observation::task(async move {
+                let result = tokio::select! { biased;
+                    () = cancel.cancelled() => None,
+                    result = connection => Some(result),
+                };
+                let _ = done.send(result);
+            }));
+            Self {
+                registry,
+                sender: Some(sender),
+                cancellation,
+                tasks,
+                completed: Some(completed),
+            }
+        }
+
+        async fn request(&mut self) -> (h2::client::ResponseFuture, Send, Ticket, u32) {
+            let sender = self.sender.as_mut().unwrap();
+            poll_fn(|cx| sender.poll_ready(cx)).await.unwrap();
+            let request = http::Request::builder()
+                .method("CONNECT")
+                .uri(
+                    http::Uri::builder()
+                        .authority("memory.invalid:443")
+                        .build()
+                        .unwrap(),
+                )
+                .body(())
+                .unwrap();
+            let (response, send, ticket) = self.registry.request(sender, request, false).unwrap();
+            let id = response.stream_id().as_u32();
+            (response, send, ticket, id)
+        }
+
+        async fn failure(&mut self) -> h2::Error {
+            self.completed
+                .take()
+                .unwrap()
+                .await
+                .unwrap()
+                .expect("driver was cancelled before its protocol result")
+                .expect_err("driver accepted the invalid sequence")
+        }
+
+        async fn stop(&mut self) {
+            self.registry.stop();
+            self.cancellation.cancel();
+            self.tasks.close();
+            self.tasks.wait().await;
+            assert!(self.tasks.is_empty());
+            self.sender.take();
+            if let Some(completed) = self.completed.take() {
+                let _ = completed.await.unwrap();
+            }
+        }
+    }
+
+    impl Drop for Client {
+        fn drop(&mut self) {
+            self.registry.stop();
+            self.cancellation.cancel();
+        }
+    }
+
+    struct Request {
+        response: h2::server::SendResponse<Bytes>,
+        _receive: h2::RecvStream,
+    }
+
+    async fn official_peer() -> (Client, mpsc::Receiver<Request>) {
+        let (raw, peer) = tokio::io::duplex(64 * 1024);
+        let tasks = TaskTracker::new();
+        let cancellation = CancellationToken::new();
+        let cancel = cancellation.clone();
+        let (requests, accepted) = mpsc::channel(2);
+        tasks.spawn(observation::task(async move {
+            let handshake = tokio::select! { biased;
+                () = cancel.cancelled() => return,
+                result = h2::server::handshake(peer) => result,
+            };
+            let Ok(mut connection) = handshake else {
+                return;
+            };
+            loop {
+                let request = tokio::select! { biased;
+                    () = cancel.cancelled() => break,
+                    request = connection.accept() => request,
+                };
+                let Some(Ok((request, response))) = request else {
+                    break;
+                };
+                let owned = Request {
+                    response,
+                    _receive: request.into_body(),
+                };
+                tokio::select! { biased;
+                    () = cancel.cancelled() => break,
+                    result = requests.send(owned) => if result.is_err() { break; },
+                }
+            }
+        }));
+        (Client::new(raw, cancellation, tasks).await, accepted)
+    }
+
+    async fn body(receive: &mut h2::RecvStream) -> Vec<u8> {
+        let mut output = Vec::new();
+        while let Some(frame) = receive.data().await {
+            let frame = frame.unwrap();
+            output.extend_from_slice(&frame);
+            receive
+                .flow_control()
+                .release_capacity(frame.len())
+                .unwrap();
+        }
+        output
+    }
+
+    async fn next_data(receive: &mut h2::RecvStream) -> Bytes {
+        loop {
+            let frame = receive.data().await.unwrap().unwrap();
+            receive
+                .flow_control()
+                .release_capacity(frame.len())
+                .unwrap();
+            if !frame.is_empty() {
+                return frame;
+            }
+        }
+    }
+
+    fn frame(kind: u8, flags: u8, id: u32, payload: &[u8]) -> Vec<u8> {
+        let length = payload.len() as u32;
+        let mut bytes = Vec::with_capacity(9 + payload.len());
+        bytes.extend_from_slice(&length.to_be_bytes()[1..]);
+        bytes.extend_from_slice(&[kind, flags]);
+        bytes.extend_from_slice(&id.to_be_bytes());
+        bytes.extend_from_slice(payload);
+        bytes
+    }
+
+    async fn read_frame(peer: &mut DuplexStream) -> (u8, u8, u32, Vec<u8>) {
+        let mut head = [0; 9];
+        peer.read_exact(&mut head).await.unwrap();
+        let length = u32::from_be_bytes([0, head[0], head[1], head[2]]) as usize;
+        assert!(length <= 16 * 1024);
+        let mut payload = vec![0; length];
+        peer.read_exact(&mut payload).await.unwrap();
+        (
+            head[3],
+            head[4],
+            u32::from_be_bytes(head[5..9].try_into().unwrap()) & 0x7fff_ffff,
+            payload,
+        )
+    }
+
+    async fn raw_peer() -> (Client, DuplexStream) {
+        let (raw, mut peer) = tokio::io::duplex(64 * 1024);
+        let client = Client::new(raw, CancellationToken::new(), TaskTracker::new()).await;
+        let mut preface = [0; 24];
+        peer.read_exact(&mut preface).await.unwrap();
+        assert_eq!(&preface, b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n");
+        let (kind, flags, id, _) = read_frame(&mut peer).await;
+        assert_eq!((kind, flags, id), (4, 0, 0));
+        let mut settings = frame(4, 0, 0, &[]);
+        settings.extend(frame(4, 1, 0, &[]));
+        peer.write_all(&settings).await.unwrap();
+        (client, peer)
+    }
+
+    async fn request_reached_peer(peer: &mut DuplexStream, id: u32) {
+        loop {
+            let (kind, flags, incoming_id, _) = read_frame(peer).await;
+            if kind == 1 && incoming_id == id {
+                assert_ne!(flags & 4, 0, "small request should fit one HEADERS frame");
+                return;
+            }
+        }
+    }
+
+    async fn admit_raw(
+        peer: &mut DuplexStream,
+        response: h2::client::ResponseFuture,
+        ticket: &Ticket,
+        id: u32,
+        content_length_zero: bool,
+    ) -> h2::RecvStream {
+        request_reached_peer(peer, id).await;
+        // HPACK indexed :status=200, optionally followed by a literal header.
+        let mut headers = vec![0x88];
+        if content_length_zero {
+            headers.extend_from_slice(&[0x00, 14]);
+            headers.extend_from_slice(b"content-length");
+            headers.extend_from_slice(&[1, b'0']);
+        }
+        peer.write_all(&frame(1, 4, id, &headers)).await.unwrap();
+        let response = response.await.unwrap();
+        assert_eq!(response.status(), 200);
+        ticket.admission().activate();
+        response.into_body()
+    }
+
+    #[tokio::test]
+    async fn interleaved_empty_data_preserves_payload_final_sibling_and_joined_stop() {
+        let probe = ResourceProbe::default();
+        timeout(
+            DEADLINE,
+            probe.scope(async {
+                let (mut client, mut requests) = official_peer().await;
+                let (first_response, mut first_send, first_ticket, _) = client.request().await;
+                let mut first_request = requests.recv().await.unwrap();
+                let mut first_peer = first_request
+                    .response
+                    .send_response(http::Response::new(()), false)
+                    .unwrap();
+                let mut first_receive = first_response.await.unwrap().into_body();
+                first_ticket.admission().activate();
+
+                let (sibling_response, _sibling_send, sibling_ticket, _) = client.request().await;
+                let mut sibling_request = requests.recv().await.unwrap();
+                let mut sibling_peer = sibling_request
+                    .response
+                    .send_response(http::Response::new(()), false)
+                    .unwrap();
+                let mut sibling_receive = sibling_response.await.unwrap().into_body();
+                sibling_ticket.admission().activate();
+
+                for value in 0..101u8 {
+                    first_peer.send_data(Bytes::new(), false).unwrap();
+                    first_peer
+                        .send_data(Bytes::copy_from_slice(&[value]), false)
+                        .unwrap();
+                }
+                first_peer.send_data(Bytes::new(), true).unwrap();
+                assert_eq!(
+                    body(&mut first_receive).await,
+                    (0..101u8).collect::<Vec<_>>()
+                );
+                assert_eq!(client.registry.filtered(), 101);
+                first_ticket.close();
+                first_send.send_reset(h2::Reason::CANCEL);
+                sibling_peer
+                    .send_data(Bytes::from_static(b"alive"), false)
+                    .unwrap();
+                assert_eq!(next_data(&mut sibling_receive).await.as_ref(), b"alive");
+                assert_eq!(
+                    client.registry.filtered(),
+                    101,
+                    "final DATA must remain visible to h2"
+                );
+
+                client.stop().await;
+                assert!(!matches!(sibling_receive.data().await, Some(Ok(_))));
+                assert_eq!(probe.snapshot().current(ResourceKind::Task), 0);
+                assert!(probe.snapshot().peak(ResourceKind::Task) >= 2);
+            }),
+        )
+        .await
+        .unwrap();
+        assert!(probe.snapshot().is_idle());
+    }
+
+    #[tokio::test]
+    async fn ineligible_and_invalid_data_remain_owned_by_the_official_h2_validator() {
+        let probe = ResourceProbe::default();
+        timeout(
+            DEADLINE,
+            probe.scope(async {
+                // DATA before response HEADERS and DATA on an unknown stream.
+                for unknown in [false, true] {
+                    let (mut client, mut peer) = raw_peer().await;
+                    let (_response, _send, _ticket, id) = client.request().await;
+                    request_reached_peer(&mut peer, id).await;
+                    peer.write_all(&frame(0, 0, if unknown { id + 2 } else { id }, &[]))
+                        .await
+                        .unwrap();
+                    assert_eq!(
+                        client.failure().await.reason(),
+                        Some(h2::Reason::PROTOCOL_ERROR)
+                    );
+                    assert_eq!(client.registry.filtered(), 0);
+                    client.stop().await;
+                }
+
+                // A DATA frame cannot interrupt even an already admitted stream's
+                // unfinished trailing header block.
+                {
+                    let (mut client, mut peer) = raw_peer().await;
+                    let (response, _send, ticket, id) = client.request().await;
+                    let _receive = admit_raw(&mut peer, response, &ticket, id, false).await;
+                    let mut bytes = frame(1, 0, id, &[]);
+                    bytes.extend(frame(0, 0, id, &[]));
+                    peer.write_all(&bytes).await.unwrap();
+                    assert_eq!(
+                        client.failure().await.reason(),
+                        Some(h2::Reason::PROTOCOL_ERROR)
+                    );
+                    assert_eq!(client.registry.filtered(), 0);
+                    client.stop().await;
+                }
+
+                // A valid split response becomes eligible only after the official
+                // decoder has accepted its CONTINUATION and final response.
+                {
+                    let (mut client, mut peer) = raw_peer().await;
+                    let (response, _send, ticket, id) = client.request().await;
+                    request_reached_peer(&mut peer, id).await;
+                    let mut bytes = frame(1, 0, id, &[0x88]);
+                    bytes.extend(frame(9, 4, id, &[]));
+                    peer.write_all(&bytes).await.unwrap();
+                    let mut receive = response.await.unwrap().into_body();
+                    ticket.admission().activate();
+                    let mut bytes = frame(0, 0, id, &[]);
+                    bytes.extend(frame(0, 0, id, b"continued"));
+                    bytes.extend(frame(0, 1, id, &[]));
+                    peer.write_all(&bytes).await.unwrap();
+                    assert_eq!(body(&mut receive).await, b"continued");
+                    assert_eq!(client.registry.filtered(), 1);
+                    client.stop().await;
+                }
+
+                // Padding consumes flow control even when its application payload
+                // is empty. Neither PADDED DATA nor final empty DATA may be filtered.
+                {
+                    let (mut client, mut peer) = raw_peer().await;
+                    let (response, _send, ticket, id) = client.request().await;
+                    let mut receive = admit_raw(&mut peer, response, &ticket, id, false).await;
+                    let mut bytes = frame(0, 8, id, &[0]);
+                    bytes.extend(frame(0, 0, id, b"padded"));
+                    bytes.extend(frame(0, 1, id, &[]));
+                    peer.write_all(&bytes).await.unwrap();
+                    assert_eq!(body(&mut receive).await, b"padded");
+                    assert_eq!(client.registry.filtered(), 0);
+                    client.stop().await;
+                }
+
+                // Close, Drop and registry Stop must each win over a late
+                // admission callback while the underlying h2 stream is alive.
+                for revocation in 0..3 {
+                    let (mut client, mut peer) = raw_peer().await;
+                    let (response, _send, ticket, id) = client.request().await;
+                    let mut receive = admit_raw(&mut peer, response, &ticket, id, false).await;
+                    let late = ticket.admission();
+                    match revocation {
+                        0 => ticket.close(),
+                        1 => drop(ticket),
+                        2 => client.registry.stop(),
+                        _ => unreachable!(),
+                    }
+                    late.activate();
+                    let mut bytes = frame(0, 0, id, &[]);
+                    bytes.extend(frame(0, 0, id, b"closed-ticket"));
+                    peer.write_all(&bytes).await.unwrap();
+                    assert_eq!(next_data(&mut receive).await.as_ref(), b"closed-ticket");
+                    assert_eq!(
+                        client.registry.filtered(),
+                        0,
+                        "revocation {revocation} was undone"
+                    );
+                    client.stop().await;
+                }
+
+                // Empty DATA after remote END_STREAM must still reach h2's
+                // closed-stream validation; it is not an eligible no-op.
+                {
+                    let (mut client, mut peer) = raw_peer().await;
+                    let (response, _send, ticket, id) = client.request().await;
+                    let _receive = admit_raw(&mut peer, response, &ticket, id, false).await;
+                    let mut bytes = frame(0, 1, id, &[]);
+                    bytes.extend(frame(0, 0, id, &[]));
+                    peer.write_all(&bytes).await.unwrap();
+                    assert_eq!(
+                        client.failure().await.reason(),
+                        Some(h2::Reason::PROTOCOL_ERROR)
+                    );
+                    assert_eq!(client.registry.filtered(), 0);
+                    client.stop().await;
+                }
+
+                // A content-length violation causes an internally generated stream reset.
+                // Its following empty DATA is in the SAME peer write, before the
+                // queued RST_STREAM needs to reach the peer. A sibling marker proves
+                // the client processed the complete input batch without swallowing it.
+                {
+                    let (mut client, mut peer) = raw_peer().await;
+                    let (response, _send, ticket, id) = client.request().await;
+                    let mut receive = admit_raw(&mut peer, response, &ticket, id, true).await;
+                    let (response, _sibling_send, sibling_ticket, sibling_id) =
+                        client.request().await;
+                    let mut sibling =
+                        admit_raw(&mut peer, response, &sibling_ticket, sibling_id, false).await;
+                    let mut bytes = frame(0, 0, id, b"x");
+                    bytes.extend(frame(0, 0, id, &[]));
+                    bytes.extend(frame(0, 0, sibling_id, b"alive"));
+                    peer.write_all(&bytes).await.unwrap();
+                    let error = receive.data().await.unwrap().unwrap_err();
+                    assert_eq!(error.reason(), Some(h2::Reason::PROTOCOL_ERROR));
+                    assert_eq!(next_data(&mut sibling).await.as_ref(), b"alive");
+                    assert_eq!(
+                        client.registry.filtered(),
+                        0,
+                        "internally reset stream DATA was filtered"
+                    );
+                    client.stop().await;
+                }
+            }),
+        )
+        .await
+        .unwrap();
+        assert!(probe.snapshot().is_idle());
+    }
+
+    #[tokio::test]
+    async fn consecutive_empty_data_without_payload_progress_is_bounded_and_stopped() {
+        let probe = ResourceProbe::default();
+        timeout(
+            DEADLINE,
+            probe.scope(async {
+                let (mut client, mut requests) = official_peer().await;
+                let (response, _send, ticket, _) = client.request().await;
+                let mut request = requests.recv().await.unwrap();
+                let mut peer = request
+                    .response
+                    .send_response(http::Response::new(()), false)
+                    .unwrap();
+                let _receive = response.await.unwrap().into_body();
+                ticket.admission().activate();
+                for _ in 0..101 {
+                    peer.send_data(Bytes::new(), false).unwrap();
+                }
+                let error = client.failure().await;
+                assert!(error.is_io() || error.reason() == Some(h2::Reason::ENHANCE_YOUR_CALM));
+                assert_eq!(
+                    client.registry.filtered(),
+                    100,
+                    "101st empty frame must terminate a no-progress flood"
+                );
+                client.stop().await;
+                assert_eq!(probe.snapshot().current(ResourceKind::Task), 0);
+            }),
+        )
+        .await
+        .unwrap();
+        assert!(probe.snapshot().is_idle());
+    }
+    // Insert inside h2_empty.rs's existing `mod tests`; no network peer is created.
+    #[tokio::test]
+    async fn registry_contention_retries_split_headers_without_disabling_noop_admission() {
+        let (mut peer, raw) = tokio::io::duplex(64);
+        let registry = Registry::default();
+        let mut io = super::EmptyIo {
+            raw: Box::new(raw),
+            registry: registry.clone(),
+            header: [0; 9],
+            have: 0,
+            emitted: 0,
+            ready: false,
+            remaining: 0,
+            progress: false,
+            eof: false,
+            continuation: None,
+            disabled: false,
+            consecutive: 0,
+            failed: false,
+        };
+        let mut expected = frame(1, 0, 1, &[0x88]);
+        expected.extend(frame(9, 4, 1, &[]));
+        peer.write_all(&expected).await.unwrap();
+
+        let mut cx = std::task::Context::from_waker(futures_util::task::noop_waker_ref());
+        let mut storage = [0; 32];
+        let mut output = tokio::io::ReadBuf::new(&mut storage);
+        // The mutex is held only across this synchronous poll, never across await.
+        let held = registry.0.streams.lock().unwrap();
+        assert!(
+            tokio::io::AsyncRead::poll_read(std::pin::Pin::new(&mut io), &mut cx, &mut output)
+                .is_pending()
+        );
+        assert!(output.filled().is_empty());
+        drop(held);
+
+        let mut received = Vec::with_capacity(expected.len());
+        for _ in 0..3 {
+            output.clear();
+            assert!(matches!(
+                tokio::io::AsyncRead::poll_read(std::pin::Pin::new(&mut io), &mut cx, &mut output),
+                std::task::Poll::Ready(Ok(()))
+            ));
+            received.extend_from_slice(output.filled());
+            assert!(
+                !io.disabled,
+                "retry turned a valid header chain into an error"
+            );
+        }
+        assert_eq!(received, expected);
+        assert_eq!(io.continuation, None);
+        assert_eq!(io.consecutive, 0);
+    }
+}
diff --git a/src/transport/h2_write.rs b/src/transport/h2_write.rs
index 921f013..efb4fcd 100644
--- a/src/transport/h2_write.rs
+++ b/src/transport/h2_write.rs
@@ -1,8 +1,11 @@
-//! Per-write completion at the supplied IO's flush boundary, not H1/H2 enqueue.
-//! Each logical writer keeps at most one outstanding payload/receipt. No extra
-//! driver, protocol decoder, socket, or connection-wide admission limit.
+//! Strong receipts at the supplied IO's flush boundary. Private autonomous
+//! h2mux writers coalesce confirmation state without per-DATA oneshots.
 use crate::dispatch::BoxStream;
 use bytes::{Buf, Bytes};
+#[cfg(feature = "sing-mux")]
+use futures_util::task::AtomicWaker;
+#[cfg(feature = "sing-mux")]
+use std::sync::Weak;
 use std::{
     io,
     pin::Pin,
@@ -26,10 +29,158 @@ pub(super) struct Sender {
 #[derive(Clone, Default, Debug)]
 pub(super) struct Writes(Arc<Mutex<State>>);
 
+#[derive(Debug)]
+enum Done {
+    Strong(Completion),
+    #[cfg(feature = "sing-mux")]
+    Coalesced(Arc<CoalescedAck>, u64),
+}
+
+#[derive(Debug)]
+enum Encoded {
+    Strong(Completion),
+    #[cfg(feature = "sing-mux")]
+    Coalesced(Weak<CoalescedAck>),
+}
+
 #[derive(Default, Debug)]
 struct State {
     closed: bool,
-    encoded: Vec<Completion>,
+    encoded: Vec<Encoded>,
+    #[cfg(feature = "sing-mux")]
+    prune_remaining: usize,
+}
+
+#[cfg(feature = "sing-mux")]
+#[derive(Default, Debug)]
+pub(super) struct CoalescedAck {
+    state: Mutex<AckState>,
+    wake: AtomicWaker,
+}
+
+#[cfg(feature = "sing-mux")]
+#[derive(Default, Debug)]
+struct AckState {
+    submitted: u64,
+    encoded: u64,
+    flushed: u64,
+    registered: bool,
+    error: Option<io::ErrorKind>,
+}
+
+#[cfg(feature = "sing-mux")]
+impl CoalescedAck {
+    pub(super) fn check(&self, cx: &mut Context<'_>) -> io::Result<()> {
+        self.wake.register(cx.waker());
+        self.state
+            .lock()
+            .unwrap()
+            .error
+            .map_or(Ok(()), |error| Err(error.into()))
+    }
+
+    pub(super) fn poll_flushed(&self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        self.wake.register(cx.waker());
+        let state = self.state.lock().unwrap();
+        if let Some(error) = state.error {
+            Poll::Ready(Err(error.into()))
+        } else if state.flushed == state.submitted {
+            Poll::Ready(Ok(()))
+        } else {
+            Poll::Pending
+        }
+    }
+
+    pub(super) fn fail(&self, error: io::ErrorKind) {
+        self.state.lock().unwrap().error.get_or_insert(error);
+        self.wake.wake();
+    }
+}
+
+impl State {
+    // Always called under Writes; nested lock order is Writes -> Ack.
+    fn record(&mut self, done: Done) -> Option<Done> {
+        match done {
+            Done::Strong(done) => {
+                if self.closed {
+                    Some(Done::Strong(done))
+                } else {
+                    self.encoded.push(Encoded::Strong(done));
+                    None
+                }
+            }
+            #[cfg(feature = "sing-mux")]
+            Done::Coalesced(ack, ticket) => {
+                let mut progress = ack.state.lock().unwrap();
+                if self.closed || progress.error.is_some() {
+                    progress.error.get_or_insert(io::ErrorKind::BrokenPipe);
+                    drop(progress);
+                    return Some(Done::Coalesced(ack, ticket));
+                }
+                progress.encoded = ticket;
+                if !progress.registered {
+                    progress.registered = true;
+                    // Only a newly registered writer reaches this branch.
+                    // Amortize scans over the surviving list, not tiny DATA.
+                    if self.prune_remaining == 0 {
+                        self.encoded.retain(|entry| match entry {
+                            Encoded::Strong(_) => true,
+                            Encoded::Coalesced(weak) => weak.strong_count() != 0,
+                        });
+                        self.prune_remaining = self.encoded.len().max(16);
+                    }
+                    self.prune_remaining -= 1;
+                    self.encoded.push(Encoded::Coalesced(Arc::downgrade(&ack)));
+                }
+                None
+            }
+        }
+    }
+
+    // Only the h2 Connection advances Payloads and flushes its supplied IO.
+    // Its codec drains encoded bytes before entering raw.poll_flush. Marking
+    // and deregistration stay in one Writes critical section; wake outside it.
+    fn finish(&mut self, _error: Option<io::ErrorKind>) -> Vec<Encoded> {
+        let encoded = std::mem::take(&mut self.encoded);
+        #[cfg(feature = "sing-mux")]
+        {
+            self.prune_remaining = 0;
+        }
+        #[cfg(feature = "sing-mux")]
+        for entry in &encoded {
+            if let Encoded::Coalesced(weak) = entry
+                && let Some(ack) = weak.upgrade()
+            {
+                let mut progress = ack.state.lock().unwrap();
+                progress.registered = false;
+                if let Some(error) = _error {
+                    progress.error.get_or_insert(error);
+                } else if progress.error.is_none() {
+                    progress.flushed = progress.encoded;
+                }
+            }
+        }
+        encoded
+    }
+}
+
+fn notify_finished(encoded: Vec<Encoded>, error: Option<io::ErrorKind>, strong: bool) {
+    for entry in encoded {
+        match entry {
+            Encoded::Strong(done) => {
+                if strong {
+                    let _ = done.send(error.map_or(Ok(()), |error| Err(error.into())));
+                }
+                // Driver Drop still cancels the legacy oneshot as before.
+            }
+            #[cfg(feature = "sing-mux")]
+            Encoded::Coalesced(weak) => {
+                if let Some(ack) = weak.upgrade() {
+                    ack.wake.wake();
+                }
+            }
+        }
+    }
 }
 
 impl Writes {
@@ -39,6 +190,8 @@ impl Writes {
             FlushIo {
                 raw,
                 writes: writes.clone(),
+                #[cfg(feature = "sing-mux")]
+                wrote_since_flush: false,
             },
             writes,
         )
@@ -50,17 +203,44 @@ impl Writes {
         (
             Payload {
                 bytes,
-                done: Some(done),
+                done: Some(Done::Strong(done)),
                 writes: self.clone(),
             },
             receipt,
         )
     }
+
+    #[cfg(feature = "sing-mux")]
+    pub(super) fn coalesced_payload(
+        &self,
+        bytes: Bytes,
+        ack: &Arc<CoalescedAck>,
+    ) -> io::Result<Payload> {
+        assert!(!bytes.is_empty());
+        let ticket = {
+            let state = self.0.lock().unwrap();
+            if state.closed {
+                return Err(io::ErrorKind::BrokenPipe.into());
+            }
+            let mut progress = ack.state.lock().unwrap();
+            if let Some(error) = progress.error {
+                return Err(error.into());
+            }
+            // FIFO tickets wrap; equality tracks bounded outstanding progress.
+            progress.submitted = progress.submitted.wrapping_add(1);
+            progress.submitted
+        };
+        Ok(Payload {
+            bytes,
+            done: Some(Done::Coalesced(ack.clone(), ticket)),
+            writes: self.clone(),
+        })
+    }
 }
 
 pub(super) struct Payload {
     bytes: Bytes,
-    done: Option<Completion>,
+    done: Option<Done>,
     writes: Writes,
 }
 
@@ -74,6 +254,15 @@ impl Payload {
     }
 }
 
+impl Drop for Payload {
+    fn drop(&mut self) {
+        #[cfg(feature = "sing-mux")]
+        if let Some(Done::Coalesced(ack, _)) = &self.done {
+            ack.fail(io::ErrorKind::BrokenPipe);
+        }
+    }
+}
+
 impl std::fmt::Debug for Payload {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("H2Payload")
@@ -87,19 +276,22 @@ impl Buf for Payload {
         self.bytes.remaining()
     }
     fn chunk(&self) -> &[u8] {
-        self.bytes.chunk()
+        let bytes = self.bytes.chunk();
+        // Keep a whole packet-up POST in one backing, but feed HTTP's supplied
+        // IO in streaming-sized pieces instead of buffering 64 KiB in TLS.
+        &bytes[..bytes.len().min(crate::limits::XHTTP_BODY_CHUNK)]
     }
     fn advance(&mut self, count: usize) {
         self.bytes.advance(count);
         if self.bytes.is_empty()
             && let Some(done) = self.done.take()
         {
-            let mut state = self.writes.0.lock().unwrap();
-            if !state.closed {
-                // Encoding may only have copied into h2's own buffer. The IO
-                // wrapper acknowledges this after that buffer reaches raw.flush.
-                state.encoded.push(done);
+            let notification = self.writes.0.lock().unwrap().record(done);
+            #[cfg(feature = "sing-mux")]
+            if let Some(Done::Coalesced(ack, _)) = &notification {
+                ack.wake.wake();
             }
+            drop(notification); // Legacy cancellation also happens lock-free.
         }
     }
 }
@@ -107,16 +299,19 @@ impl Buf for Payload {
 struct FlushIo {
     raw: BoxStream,
     writes: Writes,
+    #[cfg(feature = "sing-mux")]
+    wrote_since_flush: bool,
 }
-
 impl Drop for FlushIo {
     fn drop(&mut self) {
-        let mut state = self.writes.0.lock().unwrap();
-        state.closed = true;
-        state.encoded.clear();
+        let encoded = {
+            let mut state = self.writes.0.lock().unwrap();
+            state.closed = true;
+            state.finish(Some(io::ErrorKind::BrokenPipe))
+        };
+        notify_finished(encoded, Some(io::ErrorKind::BrokenPipe), false);
     }
 }
-
 impl AsyncRead for FlushIo {
     fn poll_read(
         mut self: Pin<&mut Self>,
@@ -126,26 +321,44 @@ impl AsyncRead for FlushIo {
         Pin::new(&mut self.raw).poll_read(cx, out)
     }
 }
-
 impl AsyncWrite for FlushIo {
     fn poll_write(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
         input: &[u8],
     ) -> Poll<io::Result<usize>> {
-        Pin::new(&mut self.raw).poll_write(cx, input)
+        let result = Pin::new(&mut self.raw).poll_write(cx, input);
+        #[cfg(feature = "sing-mux")]
+        if matches!(&result, Poll::Ready(Ok(count)) if *count > 0) {
+            self.wrote_since_flush = true;
+        }
+        result
     }
     fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        let result = std::task::ready!(Pin::new(&mut self.raw).poll_flush(cx));
-        let encoded = std::mem::take(&mut self.writes.0.lock().unwrap().encoded);
-        for done in encoded {
-            let _ = done.send(
-                result
-                    .as_ref()
-                    .map(|_| ())
-                    .map_err(|e| io::Error::from(e.kind())),
-            );
+        let result = Pin::new(&mut self.raw).poll_flush(cx);
+        #[cfg(feature = "sing-mux")]
+        {
+            // A chained h2 DATA can drain before its stronger IO flush is
+            // ready. Re-poll productive private owners once so already queued
+            // frames can fill the same bounded PacketUp batch.
+            let repoll = result.is_pending() && std::mem::take(&mut self.wrote_since_flush) && {
+                let state = self.writes.0.lock().unwrap();
+                state.encoded.iter().any(
+                    |entry| matches!(entry, Encoded::Coalesced(weak) if weak.strong_count() != 0),
+                )
+            };
+            if repoll {
+                cx.waker().wake_by_ref();
+            }
+        }
+        let result = std::task::ready!(result);
+        #[cfg(feature = "sing-mux")]
+        {
+            self.wrote_since_flush = false;
         }
+        let error = result.as_ref().err().map(io::Error::kind);
+        let encoded = self.writes.0.lock().unwrap().finish(error);
+        notify_finished(encoded, error, true);
         Poll::Ready(result)
     }
     fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
@@ -237,4 +450,368 @@ mod tests {
         drop(raw);
         assert!(receipt.await.is_err());
     }
+
+    #[cfg(feature = "sing-mux")]
+    #[tokio::test]
+    async fn coalesced_writer_bounds_markers_and_never_flushes_unencoded_or_failed_payloads() {
+        use std::{
+            sync::atomic::AtomicUsize,
+            task::{Wake, Waker},
+        };
+        #[derive(Default)]
+        struct Count(AtomicUsize);
+        impl Wake for Count {
+            fn wake(self: Arc<Self>) {
+                self.0.fetch_add(1, Ordering::SeqCst);
+            }
+        }
+        let counter = Arc::new(Count::default());
+        let waker = Waker::from(counter.clone());
+        let mut cx = Context::from_waker(&waker);
+        let gate = Arc::new(AtomicU8::new(0));
+        let (mut raw, writes) = Writes::wrap(Box::new(Gate(gate.clone())));
+        let ack = Arc::new(CoalescedAck::default());
+        for _ in 0..256 {
+            let mut payload = writes
+                .coalesced_payload(Bytes::from_static(b"a"), &ack)
+                .unwrap();
+            payload.advance(1);
+            drop(payload);
+        }
+        let markers = writes.0.lock().unwrap().encoded.len();
+        for _ in 0..1024 {
+            let short = Arc::new(CoalescedAck::default());
+            let mut payload = writes
+                .coalesced_payload(Bytes::from_static(b"s"), &short)
+                .unwrap();
+            payload.advance(1);
+            drop(payload);
+            drop(short);
+        }
+        let short_flow_markers = writes.0.lock().unwrap().encoded.len();
+        assert!(ack.poll_flushed(&mut cx).is_pending());
+        assert!(Pin::new(&mut raw).poll_flush(&mut cx).is_pending());
+        assert!(ack.poll_flushed(&mut cx).is_pending());
+        let sibling = Arc::new(CoalescedAck::default());
+        let mut partial = writes
+            .coalesced_payload(Bytes::from_static(b"xy"), &sibling)
+            .unwrap();
+        partial.advance(1);
+        gate.store(1, Ordering::SeqCst);
+        raw.flush().await.unwrap();
+        assert!(matches!(ack.poll_flushed(&mut cx), Poll::Ready(Ok(()))));
+        assert!(
+            sibling.poll_flushed(&mut cx).is_pending(),
+            "a sibling flush acknowledged unencoded bytes"
+        );
+        partial.advance(1);
+        drop(partial);
+        raw.flush().await.unwrap();
+        assert!(matches!(sibling.poll_flushed(&mut cx), Poll::Ready(Ok(()))));
+        let unencoded = Arc::new(CoalescedAck::default());
+        let payload = writes
+            .coalesced_payload(Bytes::from_static(b"cancel"), &unencoded)
+            .unwrap();
+        assert!(unencoded.poll_flushed(&mut cx).is_pending());
+        let before_cancel = counter.0.load(Ordering::SeqCst);
+        drop(payload);
+        assert!(counter.0.load(Ordering::SeqCst) > before_cancel);
+        assert!(matches!(
+            unencoded.poll_flushed(&mut cx),
+            Poll::Ready(Err(_))
+        ));
+        let failed = Arc::new(CoalescedAck::default());
+        let mut payload = writes
+            .coalesced_payload(Bytes::from_static(b"fail"), &failed)
+            .unwrap();
+        payload.advance(4);
+        gate.store(2, Ordering::SeqCst);
+        assert!(failed.poll_flushed(&mut cx).is_pending());
+        let before_failure = counter.0.load(Ordering::SeqCst);
+        assert_eq!(
+            raw.flush().await.unwrap_err().kind(),
+            io::ErrorKind::ConnectionReset
+        );
+        assert!(counter.0.load(Ordering::SeqCst) > before_failure);
+        assert!(
+            matches!(failed.poll_flushed(&mut cx), Poll::Ready(Err(error)) if error.kind() == io::ErrorKind::ConnectionReset)
+        );
+        let stopped = Arc::new(CoalescedAck::default());
+        let mut payload = writes
+            .coalesced_payload(Bytes::from_static(b"stop"), &stopped)
+            .unwrap();
+        payload.advance(4);
+        assert!(stopped.poll_flushed(&mut cx).is_pending());
+        let before_stop = counter.0.load(Ordering::SeqCst);
+        drop(raw);
+        assert!(counter.0.load(Ordering::SeqCst) > before_stop);
+        assert!(matches!(stopped.poll_flushed(&mut cx), Poll::Ready(Err(_))));
+        assert_eq!(
+            markers, 1,
+            "one logical writer accumulated per-payload completion markers"
+        );
+        assert!(
+            short_flow_markers < 64,
+            "blocked flush retained short-flow markers without cleanup: {short_flow_markers}"
+        );
+    }
+}
+
+#[cfg(all(test, feature = "sing-mux"))]
+mod productive_repoll_memory_tests {
+    use super::*;
+    use futures_util::task::noop_waker;
+    use std::{
+        sync::atomic::{AtomicU8, AtomicUsize, Ordering},
+        task::{Wake, Waker},
+    };
+
+    #[derive(Default)]
+    struct Count(AtomicUsize);
+    impl Wake for Count {
+        fn wake(self: Arc<Self>) {
+            self.wake_by_ref();
+        }
+        fn wake_by_ref(self: &Arc<Self>) {
+            self.0.fetch_add(1, Ordering::SeqCst);
+        }
+    }
+
+    #[derive(Default)]
+    struct Control {
+        write: AtomicU8,
+        flush: AtomicU8,
+    }
+    struct MemoryIo(Arc<Control>);
+    impl AsyncRead for MemoryIo {
+        fn poll_read(
+            self: Pin<&mut Self>,
+            _: &mut Context<'_>,
+            _: &mut ReadBuf<'_>,
+        ) -> Poll<io::Result<()>> {
+            Poll::Pending
+        }
+    }
+    impl AsyncWrite for MemoryIo {
+        fn poll_write(
+            self: Pin<&mut Self>,
+            _: &mut Context<'_>,
+            input: &[u8],
+        ) -> Poll<io::Result<usize>> {
+            match self.0.write.load(Ordering::SeqCst) {
+                0 => Poll::Ready(Ok(input.len())),
+                1 => Poll::Pending,
+                2 => Poll::Ready(Err(io::ErrorKind::BrokenPipe.into())),
+                _ => Poll::Ready(Ok(0)),
+            }
+        }
+        fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Result<()>> {
+            match self.0.flush.load(Ordering::SeqCst) {
+                0 => Poll::Pending,
+                1 => Poll::Ready(Ok(())),
+                _ => Poll::Ready(Err(io::ErrorKind::ConnectionReset.into())),
+            }
+        }
+        fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            self.poll_flush(cx)
+        }
+    }
+
+    struct Fixture {
+        raw: BoxStream,
+        writes: Writes,
+        control: Arc<Control>,
+        driver: Arc<Count>,
+        waker: Waker,
+    }
+    impl Fixture {
+        fn new() -> Self {
+            let control = Arc::new(Control::default());
+            let driver = Arc::new(Count::default());
+            let (raw, writes) = Writes::wrap(Box::new(MemoryIo(control.clone())));
+            Self {
+                raw: Box::new(raw),
+                writes,
+                control,
+                waker: Waker::from(driver.clone()),
+                driver,
+            }
+        }
+        fn write(&mut self, input: &[u8]) -> Poll<io::Result<usize>> {
+            let mut cx = Context::from_waker(&self.waker);
+            Pin::new(&mut self.raw).poll_write(&mut cx, input)
+        }
+        fn flush(&mut self) -> Poll<io::Result<()>> {
+            let mut cx = Context::from_waker(&self.waker);
+            Pin::new(&mut self.raw).poll_flush(&mut cx)
+        }
+        fn wakes(&self) -> usize {
+            self.driver.0.load(Ordering::SeqCst)
+        }
+        fn coalesced(&self) -> Arc<CoalescedAck> {
+            let ack = Arc::new(CoalescedAck::default());
+            let mut payload = self
+                .writes
+                .coalesced_payload(Bytes::from_static(b"private"), &ack)
+                .unwrap();
+            payload.advance(7);
+            drop(payload);
+            ack
+        }
+        fn strong(&self) -> Receipt {
+            let (mut payload, receipt) = self.writes.payload(Bytes::from_static(b"strong"));
+            payload.advance(6);
+            drop(payload);
+            receipt
+        }
+    }
+
+    fn acknowledged(ack: &CoalescedAck) -> Poll<io::Result<()>> {
+        // Logical confirmation must not share the physical driver's counter.
+        let waker = noop_waker();
+        ack.poll_flushed(&mut Context::from_waker(&waker))
+    }
+
+    #[tokio::test]
+    async fn ordinary_owner_never_self_wakes_for_a_productive_pending_flush() {
+        let mut fixture = Fixture::new();
+        let mut receipt = fixture.strong();
+        assert!(matches!(fixture.write(b"wire"), Poll::Ready(Ok(4))));
+        assert!(fixture.flush().is_pending());
+        assert_eq!(
+            fixture.wakes(),
+            0,
+            "ordinary strong owner gained private wakes"
+        );
+        assert!(matches!(
+            receipt.try_recv(),
+            Err(oneshot::error::TryRecvError::Empty)
+        ));
+        fixture.control.flush.store(1, Ordering::SeqCst);
+        assert!(matches!(fixture.flush(), Poll::Ready(Ok(()))));
+        receipt.await.unwrap().unwrap();
+        assert_eq!(fixture.wakes(), 0);
+    }
+
+    #[tokio::test]
+    async fn productive_pending_repoll_is_once_per_new_positive_write() {
+        let mut fixture = Fixture::new();
+        let ack = fixture.coalesced();
+        assert!(fixture.flush().is_pending());
+        assert_eq!(fixture.wakes(), 0, "marker presence alone scheduled work");
+        assert!(matches!(fixture.write(b"wire"), Poll::Ready(Ok(4))));
+        assert!(fixture.flush().is_pending());
+        assert_eq!(
+            fixture.wakes(),
+            1,
+            "productive private flush needs one re-poll"
+        );
+        for _ in 0..128 {
+            assert!(fixture.flush().is_pending());
+        }
+        assert_eq!(
+            fixture.wakes(),
+            1,
+            "Pending without progress self-woke repeatedly"
+        );
+        assert!(acknowledged(&ack).is_pending());
+        assert!(matches!(fixture.write(b"next"), Poll::Ready(Ok(4))));
+        assert!(fixture.flush().is_pending());
+        assert_eq!(
+            fixture.wakes(),
+            2,
+            "new positive progress did not re-arm once"
+        );
+        assert!(acknowledged(&ack).is_pending());
+    }
+
+    #[tokio::test]
+    async fn pending_failed_and_zero_writes_do_not_arm_repoll() {
+        for mode in 0..4 {
+            let mut fixture = Fixture::new();
+            let ack = fixture.coalesced();
+            fixture.control.write.store(mode, Ordering::SeqCst);
+            let input = if mode == 0 { &b""[..] } else { &b"wire"[..] };
+            let result = fixture.write(input);
+            match mode {
+                0 | 3 => assert!(matches!(result, Poll::Ready(Ok(0)))),
+                1 => assert!(result.is_pending()),
+                _ => assert!(matches!(result, Poll::Ready(Err(_)))),
+            }
+            assert!(fixture.flush().is_pending());
+            assert_eq!(fixture.wakes(), 0, "non-progress write armed mode {mode}");
+            assert!(acknowledged(&ack).is_pending());
+        }
+    }
+
+    #[tokio::test]
+    async fn only_true_flush_confirms_both_receipt_kinds_and_clears_progress() {
+        let mut fixture = Fixture::new();
+        let ack = fixture.coalesced();
+        let mut receipt = fixture.strong();
+        assert!(matches!(fixture.write(b"wire"), Poll::Ready(Ok(4))));
+        assert!(fixture.flush().is_pending());
+        assert!(matches!(
+            receipt.try_recv(),
+            Err(oneshot::error::TryRecvError::Empty)
+        ));
+        assert!(acknowledged(&ack).is_pending());
+        fixture.control.flush.store(1, Ordering::SeqCst);
+        assert!(matches!(fixture.flush(), Poll::Ready(Ok(()))));
+        receipt.await.unwrap().unwrap();
+        assert!(matches!(acknowledged(&ack), Poll::Ready(Ok(()))));
+        fixture.driver.0.store(0, Ordering::SeqCst);
+        fixture.control.flush.store(0, Ordering::SeqCst);
+        assert!(fixture.flush().is_pending());
+        assert_eq!(
+            fixture.wakes(),
+            0,
+            "completed flush retained stale progress"
+        );
+    }
+
+    #[tokio::test]
+    async fn error_and_driver_drop_fail_waiters_without_private_rescheduling() {
+        let mut fixture = Fixture::new();
+        let ack = fixture.coalesced();
+        let receipt = fixture.strong();
+        assert!(matches!(fixture.write(b"wire"), Poll::Ready(Ok(4))));
+        fixture.control.flush.store(2, Ordering::SeqCst);
+        assert!(matches!(fixture.flush(), Poll::Ready(Err(error))
+            if error.kind() == io::ErrorKind::ConnectionReset));
+        assert_eq!(fixture.wakes(), 0, "flush error scheduled a progress retry");
+        assert_eq!(
+            receipt.await.unwrap().unwrap_err().kind(),
+            io::ErrorKind::ConnectionReset
+        );
+        assert!(matches!(acknowledged(&ack), Poll::Ready(Err(error))
+            if error.kind() == io::ErrorKind::ConnectionReset));
+
+        let mut fixture = Fixture::new();
+        let ack = fixture.coalesced();
+        let receipt = fixture.strong();
+        assert!(matches!(fixture.write(b"wire"), Poll::Ready(Ok(4))));
+        let driver = fixture.driver.clone();
+        drop(fixture.raw);
+        assert!(
+            receipt.await.is_err(),
+            "driver Drop reported a strong receipt"
+        );
+        assert!(matches!(acknowledged(&ack), Poll::Ready(Err(_))));
+        assert_eq!(
+            driver.0.load(Ordering::SeqCst),
+            0,
+            "driver Drop scheduled new work"
+        );
+    }
+
+    #[tokio::test]
+    async fn expired_coalesced_owner_does_not_qualify_ordinary_progress() {
+        let mut fixture = Fixture::new();
+        let ack = fixture.coalesced();
+        drop(ack);
+        assert!(matches!(fixture.write(b"wire"), Poll::Ready(Ok(4))));
+        assert!(fixture.flush().is_pending());
+        assert_eq!(fixture.wakes(), 0, "dead private marker scheduled work");
+    }
 }
diff --git a/src/transport/h3_connect.rs b/src/transport/h3_connect.rs
new file mode 100644
index 0000000..67c3014
--- /dev/null
+++ b/src/transport/h3_connect.rs
@@ -0,0 +1,1621 @@
+//! Shared HTTP/3 CONNECT sessions over supplied datagrams. Each protocol
+//! chooses its admission, response and idle policy; the pool owns its tasks.
+use crate::{
+    dispatch::BoxStream,
+    resources::observation::{self, ResourceKind},
+    transport::{quic, quiche_h3},
+};
+use bytes::{Buf, Bytes};
+use futures_util::task::AtomicWaker;
+use std::{
+    future::Future,
+    io,
+    pin::Pin,
+    sync::{
+        Arc, Mutex, Weak,
+        atomic::{AtomicBool, Ordering},
+    },
+    task::{Context, Poll, ready},
+    time::Duration,
+};
+use tokio::{
+    io::{AsyncRead, AsyncWrite, ReadBuf},
+    sync::{Notify, oneshot},
+    time::{Instant, timeout_at},
+};
+use tokio_util::{sync::CancellationToken, task::TaskTracker};
+
+const IDLE: Duration = Duration::from_secs(30);
+const QUIC_IDLE: Duration = Duration::from_secs(74);
+const CHUNK: usize = crate::transport::STREAM_CHUNK_BYTES;
+type Sender = quiche_h3::Client;
+type SendStream = quiche_h3::SendStream;
+type RecvStream = quiche_h3::RecvStream;
+type SendOperation = Pin<Box<dyn Future<Output = (SendHalf, io::Result<()>)> + Send + 'static>>;
+type Observer = Arc<dyn Fn() + Send + Sync>;
+
+pub(crate) use quiche_h3::Transport as QuicTransport;
+
+#[cfg(feature = "outbound-masque")]
+pub(crate) struct IpConnect {
+    pub capsules: BoxStream,
+    pub datagrams: IpDatagrams,
+}
+
+/// The associated request owns its lease. The IP engine owns this handle
+/// together with that request and reads only its registered DATAGRAM flow.
+pub(crate) struct IpDatagrams {
+    connection: quiche_h3::Client,
+    physical: Arc<Physical>,
+    request_id: u64,
+}
+
+#[cfg(feature = "outbound-masque")]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum IpDatagramSendError {
+    TooLarge { packet_budget: usize },
+    Closed,
+}
+
+#[cfg(feature = "outbound-masque")]
+impl IpDatagrams {
+    pub fn packet_budget(&self) -> usize {
+        self.connection
+            .max_datagram_size()
+            .map_or(0, |maximum| self.packet_budget_from(maximum))
+    }
+    fn packet_budget_from(&self, maximum: usize) -> usize {
+        maximum.saturating_sub(
+            crate::transport::masque_codec::varint_len(self.request_id / 4).unwrap_or(8) + 1,
+        )
+    }
+    /// Waits for actual path discovery without allocating another packet or
+    /// task. The owner supplies its existing setup or packet deadline; an
+    /// insufficient peer/path limit never becomes a fabricated usable MTU.
+    pub async fn wait_packet_budget(&self, minimum: usize, deadline: Instant) -> io::Result<usize> {
+        wait_for_packet_budget(&self.physical.cancel, minimum, deadline, || {
+            self.connection
+                .max_datagram_size()
+                .map(|maximum| self.packet_budget_from(maximum))
+        })
+        .await
+    }
+    pub async fn send(&self, packet: &[u8]) -> Result<(), IpDatagramSendError> {
+        if self.physical.cancel.is_cancelled() {
+            return Err(IpDatagramSendError::Closed);
+        }
+        let maximum = self
+            .connection
+            .max_datagram_size()
+            .ok_or(IpDatagramSendError::Closed)?;
+        let packet_budget = self.packet_budget_from(maximum);
+        if packet.len() > packet_budget {
+            return Err(IpDatagramSendError::TooLarge { packet_budget });
+        }
+        let frame =
+            crate::transport::masque_codec::encode_h3_datagram(self.request_id, packet, maximum)
+                .map_err(|_| IpDatagramSendError::Closed)?;
+        tokio::select! { biased;
+            ()=self.physical.cancel.cancelled()=>Err(IpDatagramSendError::Closed),
+            result=self.connection.send_datagram_wait(frame)=>match result {
+                Ok(())=>Ok(()),
+                Err(error) if error.kind() == io::ErrorKind::InvalidInput=>Err(IpDatagramSendError::TooLarge {
+                    packet_budget:self.packet_budget(),
+                }),
+                Err(_)=>Err(IpDatagramSendError::Closed),
+            },
+        }
+    }
+    pub async fn receive(&self) -> io::Result<Bytes> {
+        loop {
+            let frame = tokio::select! { biased;
+                ()=self.physical.cancel.cancelled()=>return Err(closed()),
+                result=self.connection.read_datagram(self.request_id)=>result.map_err(|_|closed())?,
+            };
+            let Ok(packet) = crate::transport::masque_codec::decode_h3_datagram(
+                &frame,
+                self.request_id,
+                frame.len(),
+            ) else {
+                continue;
+            };
+            let offset = frame.len() - packet.len();
+            return Ok(frame.slice(offset..));
+        }
+    }
+}
+
+#[cfg(feature = "outbound-masque")]
+async fn wait_for_packet_budget(
+    cancel: &CancellationToken,
+    minimum: usize,
+    deadline: Instant,
+    budget: impl Fn() -> Option<usize>,
+) -> io::Result<usize> {
+    let wait = async {
+        loop {
+            if cancel.is_cancelled() {
+                return Err(closed());
+            }
+            let maximum = budget().ok_or_else(closed)?;
+            if maximum >= minimum {
+                return Ok(maximum);
+            }
+            // Poll the actual native path budget without assuming a probe succeeded.
+            tokio::select! { biased;
+                ()=cancel.cancelled()=>return Err(closed()),
+                ()=tokio::time::sleep(Duration::from_millis(20))=>{},
+            }
+        }
+    };
+    timeout_at(deadline, wait)
+        .await
+        .map_err(|_| io::Error::from(io::ErrorKind::TimedOut))?
+}
+
+#[derive(Default)]
+struct Usage {
+    active: usize,
+    idle_since: Option<Instant>,
+    retiring: bool,
+    closed: bool,
+}
+struct Physical {
+    usage: Mutex<Usage>,
+    connection: Mutex<Option<quiche_h3::Client>>,
+    activity: Notify,
+    cancel: CancellationToken,
+    idle_timeout: Option<Duration>,
+}
+impl Physical {
+    fn reserve(self: &Arc<Self>) -> io::Result<Lease> {
+        let mut usage = self.usage.lock().unwrap();
+        if usage.closed || usage.retiring || self.cancel.is_cancelled() {
+            return Err(closed());
+        }
+        usage.active = usage
+            .active
+            .checked_add(1)
+            .ok_or_else(|| io::Error::from(io::ErrorKind::OutOfMemory))?;
+        usage.idle_since = None;
+        drop(usage);
+        self.activity.notify_one();
+        Ok(Lease(self.clone()))
+    }
+    fn is_closed(&self) -> bool {
+        self.usage.lock().unwrap().closed || self.cancel.is_cancelled()
+    }
+    // The reservation and retirement decisions share this lock. Publishing
+    // closed here precedes any later caller's attempt to reserve the session.
+    fn retire_idle(&self, now: Instant) -> bool {
+        let mut usage = self.usage.lock().unwrap();
+        if usage.active == 0
+            && (usage.retiring
+                || self.idle_timeout.is_some_and(|timeout| {
+                    usage.idle_since.is_some_and(|since| now >= since + timeout)
+                }))
+        {
+            usage.closed = true;
+            true
+        } else {
+            false
+        }
+    }
+}
+struct Lease(Arc<Physical>);
+impl Drop for Lease {
+    fn drop(&mut self) {
+        let mut usage = self.0.usage.lock().unwrap();
+        usage.active -= 1;
+        if usage.active == 0 {
+            usage.idle_since = Some(Instant::now());
+        }
+        drop(usage);
+        self.0.activity.notify_one();
+    }
+}
+struct Entry {
+    sender: Sender,
+    physical: Arc<Physical>,
+    draining: bool,
+}
+impl Entry {
+    fn retire(&mut self) {
+        self.draining = true;
+        self.physical.usage.lock().unwrap().retiring = true;
+        self.physical.activity.notify_one();
+    }
+}
+impl Drop for Entry {
+    fn drop(&mut self) {
+        // An unpublished Entry must promptly cancel its setup. Only the
+        // explicit GOAWAY retirement of a published Entry preserves siblings.
+        if !self.draining {
+            self.physical.cancel.cancel();
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum Flavor {
+    TrustTunnel,
+    #[cfg(feature = "outbound-masque")]
+    MasqueL4,
+    #[cfg(feature = "outbound-masque")]
+    MasqueIp,
+}
+impl Flavor {
+    fn deferred(self) -> bool {
+        self == Self::TrustTunnel
+    }
+    fn accepts(self, status: http::StatusCode) -> bool {
+        if self.deferred() || self.ip() {
+            status == 200
+        } else {
+            status.is_success()
+        }
+    }
+    fn ip(self) -> bool {
+        #[cfg(feature = "outbound-masque")]
+        {
+            self == Self::MasqueIp
+        }
+        #[cfg(not(feature = "outbound-masque"))]
+        {
+            false
+        }
+    }
+}
+
+pub(crate) struct Pool {
+    connection: Arc<Mutex<Option<Entry>>>,
+    opening: tokio::sync::Mutex<()>,
+    admission: Mutex<()>,
+    cancellation: CancellationToken,
+    tasks: TaskTracker,
+    congestion: Option<quiche::CongestionControlAlgorithm>,
+    flavor: Flavor,
+}
+impl Pool {
+    pub fn new(congestion: Option<quiche::CongestionControlAlgorithm>) -> Self {
+        Self {
+            connection: Arc::default(),
+            opening: tokio::sync::Mutex::new(()),
+            admission: Mutex::new(()),
+            cancellation: CancellationToken::new(),
+            tasks: TaskTracker::new(),
+            congestion,
+            flavor: Flavor::TrustTunnel,
+        }
+    }
+    #[cfg(feature = "outbound-masque")]
+    pub fn masque_l4(congestion: Option<quiche::CongestionControlAlgorithm>) -> Self {
+        let mut pool = Self::new(congestion);
+        pool.flavor = Flavor::MasqueL4;
+        pool
+    }
+    #[cfg(feature = "outbound-masque")]
+    pub fn masque_ip(congestion: Option<quiche::CongestionControlAlgorithm>) -> Self {
+        let mut pool = Self::new(congestion);
+        pool.flavor = Flavor::MasqueIp;
+        pool
+    }
+    // Managed tasks observe cancellation themselves, so their cleanup is
+    // awaited rather than dropped by an outer cancellation select.
+    fn spawn(&self, future: impl Future<Output = ()> + Send + 'static) -> io::Result<()> {
+        let _admission = self.admission.lock().unwrap();
+        if self.cancellation.is_cancelled() {
+            return Err(closed());
+        }
+        self.tasks.spawn(observation::task(future));
+        Ok(())
+    }
+    pub async fn open_connect<F, Fut>(
+        &self,
+        request: http::Request<()>,
+        deadline: Instant,
+        observer: Option<Observer>,
+        connect: F,
+    ) -> io::Result<BoxStream>
+    where
+        F: FnOnce() -> Fut + Send + 'static,
+        Fut: Future<Output = io::Result<QuicTransport>> + Send + 'static,
+    {
+        self.open(request, deadline, observer, connect)
+            .await
+            .map(|(stream, _)| stream)
+    }
+    #[cfg(feature = "outbound-masque")]
+    pub async fn open_ip_connect<F, Fut>(
+        &self,
+        request: http::Request<()>,
+        deadline: Instant,
+        connect: F,
+    ) -> io::Result<IpConnect>
+    where
+        F: FnOnce() -> Fut + Send + 'static,
+        Fut: Future<Output = io::Result<QuicTransport>> + Send + 'static,
+    {
+        let (capsules, datagrams) = self.open(request, deadline, None, connect).await?;
+        Ok(IpConnect {
+            capsules,
+            datagrams: datagrams.ok_or_else(closed)?,
+        })
+    }
+    async fn open<F, Fut>(
+        &self,
+        request: http::Request<()>,
+        deadline: Instant,
+        observer: Option<Observer>,
+        connect: F,
+    ) -> io::Result<(BoxStream, Option<IpDatagrams>)>
+    where
+        F: FnOnce() -> Fut + Send + 'static,
+        Fut: Future<Output = io::Result<QuicTransport>> + Send + 'static,
+    {
+        let operation = async {
+            let _waiter = observation::track(ResourceKind::Waiter);
+            let (mut sender, lease) = self.acquire(deadline, connect).await?;
+            let request = sender.send_request(request).await.map_err(|error| {
+                retire_on_connection_error(&lease, &error);
+                closed()
+            })?;
+            let datagrams = if self.flavor.ip() {
+                lease
+                    .0
+                    .connection
+                    .lock()
+                    .unwrap()
+                    .as_ref()
+                    .ok_or_else(closed)?
+                    .register_datagrams(request.id().into_inner())?;
+                Some(IpDatagrams {
+                    connection: lease
+                        .0
+                        .connection
+                        .lock()
+                        .unwrap()
+                        .as_ref()
+                        .cloned()
+                        .ok_or_else(closed)?,
+                    physical: lease.0.clone(),
+                    request_id: request.id().into_inner(),
+                })
+            } else {
+                None
+            };
+            let (send, receive) = request.split();
+            let close = Arc::new(Close::default());
+            let (ready, response) = oneshot::channel();
+            let cancellation = self.cancellation.clone();
+            let headers_close = close.clone();
+            let headers_physical = lease.0.clone();
+            let flavor = self.flavor;
+            self.spawn(async move {
+                let mut receive = ReceiveHalf(receive);
+                let result = tokio::select! {biased;
+                    ()=cancellation.cancelled()=>Err(closed()),
+                    ()=headers_close.cancel.cancelled()=>Err(closed()),
+                    ()=headers_physical.cancel.cancelled()=>Err(closed()),
+                    response=receive.0.recv_response()=>response
+                        .map_err(|error| { retire_physical(&headers_physical, &error); closed() })
+                        .and_then(|response|if flavor.accepts(response.status()) {Ok(())} else {Err(closed())}),
+                };
+                if result.is_ok() {
+                    if let Some(observer) = observer {
+                        observer();
+                    }
+                } else {
+                    headers_close.stop(true);
+                }
+                let _ = ready.send(result.map(|()| receive));
+            })?;
+            let mut stream = Stream {
+                response: Some(response),
+                receive: None,
+                send: Some(SendHalf { stream: send }),
+                pending: None,
+                data: Bytes::new(),
+                close,
+                lease: Some(lease),
+                finishing: false,
+                finished: false,
+                _observation: observation::track(ResourceKind::Session),
+            };
+            if !self.flavor.deferred() {
+                let receive = stream
+                    .response
+                    .take()
+                    .unwrap()
+                    .await
+                    .map_err(|_| closed())??;
+                stream.receive = Some(receive);
+            }
+            Ok((Box::new(stream) as BoxStream, datagrams))
+        };
+        tokio::select! {biased;
+            ()=self.cancellation.cancelled()=>Err(closed()),
+            result=timeout_at(deadline,operation)=>result.map_err(|_|io::Error::from(io::ErrorKind::TimedOut))?,
+        }
+    }
+    pub async fn probe<F, Fut>(
+        &self,
+        request: http::Request<()>,
+        deadline: Instant,
+        connect: F,
+    ) -> io::Result<()>
+    where
+        F: FnOnce() -> Fut + Send + 'static,
+        Fut: Future<Output = io::Result<QuicTransport>> + Send + 'static,
+    {
+        let operation = async {
+            let _waiter = observation::track(ResourceKind::Waiter);
+            let (mut sender, lease) = self.acquire(deadline, connect).await?;
+            let request = sender.send_request(request).await.map_err(|error| {
+                retire_on_connection_error(&lease, &error);
+                closed()
+            })?;
+            let (send, receive) = request.split();
+            let mut send = SendHalf { stream: send };
+            let mut receive = ReceiveHalf(receive);
+            // A probe has no body. FIN is required; ordinary business CONNECT
+            // leaves its upload open for the initial client-first bytes.
+            send.stream.finish().await.map_err(|_| closed())?;
+            let response = receive.0.recv_response().await.map_err(|_| closed())?;
+            if response.status() == 200 {
+                Ok(())
+            } else {
+                Err(closed())
+            }
+        };
+        tokio::select! {biased;
+            ()=self.cancellation.cancelled()=>Err(closed()),
+            result=timeout_at(deadline,operation)=>result.map_err(|_|io::Error::from(io::ErrorKind::TimedOut))?,
+        }
+    }
+    async fn acquire<F, Fut>(&self, deadline: Instant, connect: F) -> io::Result<(Sender, Lease)>
+    where
+        F: FnOnce() -> Fut + Send + 'static,
+        Fut: Future<Output = io::Result<QuicTransport>> + Send + 'static,
+    {
+        let _opening = self.opening.lock().await;
+        {
+            let _admission = self.admission.lock().unwrap();
+            if self.cancellation.is_cancelled() {
+                return Err(closed());
+            }
+            let mut current = self.connection.lock().unwrap();
+            if let Some(entry) = current.as_mut() {
+                let available = entry.sender.can_open_request();
+                if !available {
+                    entry.retire();
+                }
+                match available.then(|| entry.physical.reserve()) {
+                    Some(Ok(lease)) => return Ok((entry.sender.clone(), lease)),
+                    Some(Err(error)) if error.kind() != io::ErrorKind::ConnectionAborted => {
+                        return Err(error);
+                    }
+                    _ => {}
+                }
+                current.take();
+            }
+        }
+        let cancel = self.cancellation.child_token();
+        let physical = Arc::new(Physical {
+            usage: Mutex::new(Usage {
+                idle_since: Some(Instant::now()),
+                ..Default::default()
+            }),
+            connection: Mutex::new(None),
+            activity: Notify::new(),
+            cancel,
+            idle_timeout: self.flavor.deferred().then_some(IDLE),
+        });
+        let (ready, response) = oneshot::channel();
+        let congestion = self.congestion;
+        let registry = Arc::downgrade(&self.connection);
+        self.spawn(drive(
+            connect,
+            deadline,
+            physical.clone(),
+            registry,
+            congestion,
+            self.flavor,
+            ready,
+        ))?;
+        let mut setup = SetupCancel(Some(physical.cancel.clone()));
+        let entry = response.await.map_err(|_| closed())??;
+        let _admission = self.admission.lock().unwrap();
+        if self.cancellation.is_cancelled() {
+            return Err(closed());
+        }
+        let lease = entry.physical.reserve()?;
+        let sender = entry.sender.clone();
+        *self.connection.lock().unwrap() = Some(entry);
+        setup.0.take();
+        Ok((sender, lease))
+    }
+    pub fn begin_shutdown(&self) {
+        let _admission = self.admission.lock().unwrap();
+        self.cancellation.cancel();
+        self.tasks.close();
+    }
+    pub async fn shutdown(&self) {
+        self.begin_shutdown();
+        self.tasks.wait().await;
+        self.connection.lock().unwrap().take();
+    }
+}
+struct SetupCancel(Option<CancellationToken>);
+impl Drop for SetupCancel {
+    fn drop(&mut self) {
+        if let Some(cancel) = &self.0 {
+            cancel.cancel();
+        }
+    }
+}
+impl Drop for Pool {
+    fn drop(&mut self) {
+        self.begin_shutdown();
+    }
+}
+
+async fn drive<F, Fut>(
+    connect: F,
+    deadline: Instant,
+    physical: Arc<Physical>,
+    registry: Weak<Mutex<Option<Entry>>>,
+    congestion: Option<quiche::CongestionControlAlgorithm>,
+    flavor: Flavor,
+    ready: oneshot::Sender<io::Result<Entry>>,
+) where
+    F: FnOnce() -> Fut + Send + 'static,
+    Fut: Future<Output = io::Result<QuicTransport>> + Send + 'static,
+{
+    let mut ready = Some(ready);
+    let raw = tokio::select! {biased;
+        () = physical.cancel.cancelled() => Err(closed()),
+        result = timeout_at(deadline, connect()) => result.map_err(|_| io::Error::from(io::ErrorKind::TimedOut)).and_then(|result| result),
+    };
+    let mut pool_observation = None;
+    if let Ok(raw) = raw {
+        let options = quiche_h3::Options {
+            idle: if flavor.deferred() {
+                QUIC_IDLE
+            } else {
+                Duration::from_secs(74)
+            },
+            keepalive: (!flavor.deferred()).then_some(Duration::from_secs(30)),
+            datagrams: flavor.ip(),
+            congestion: congestion.unwrap_or(quiche::CongestionControlAlgorithm::CUBIC),
+            send_capacity_factor: if flavor == Flavor::TrustTunnel {
+                0.5
+            } else {
+                1.0
+            },
+            ..Default::default()
+        };
+        match quiche_h3::Driver::new(raw, options).await {
+            Ok((sender, driver)) => {
+                let driver_cancel = CancellationToken::new();
+                let driver = driver.run(driver_cancel.clone());
+                tokio::pin!(driver);
+                let mut driver_finished = false;
+                let setup = tokio::select! {biased;
+                    () = physical.cancel.cancelled() => Err(closed()),
+                    _ = &mut driver => { driver_finished = true; Err(closed()) },
+                    result = timeout_at(deadline, sender.ready(flavor.ip())) => result.map_err(|_| io::Error::from(io::ErrorKind::TimedOut)).and_then(|result| result),
+                };
+                if let Err(error) = setup {
+                    let _ = ready.take().unwrap().send(Err(error));
+                } else {
+                    *physical.connection.lock().unwrap() = Some(sender.clone());
+                    pool_observation = Some(observation::track(ResourceKind::Pool));
+                    if ready
+                        .take()
+                        .unwrap()
+                        .send(Ok(Entry {
+                            sender,
+                            physical: physical.clone(),
+                            draining: false,
+                        }))
+                        .is_err()
+                    {
+                        physical.cancel.cancel();
+                    }
+                    loop {
+                        let activity = physical.activity.notified();
+                        if physical.retire_idle(Instant::now()) {
+                            break;
+                        }
+                        let expires = physical
+                            .usage
+                            .lock()
+                            .unwrap()
+                            .idle_since
+                            .zip(physical.idle_timeout)
+                            .map(|(since, timeout)| since + timeout);
+                        tokio::select! {biased;
+                            () = physical.cancel.cancelled() => break,
+                            _ = &mut driver => { driver_finished = true; break; },
+                            () = activity => {},
+                            () = async { match expires { Some(deadline) => tokio::time::sleep_until(deadline).await, None => std::future::pending().await } } => { if physical.retire_idle(Instant::now()) { break; } },
+                        }
+                    }
+                }
+                driver_cancel.cancel();
+                if !driver_finished {
+                    let _ = driver.await;
+                }
+            }
+            Err(error) => {
+                let _ = ready.take().unwrap().send(Err(error));
+            }
+        }
+    } else if let Err(error) = raw {
+        let _ = ready.take().unwrap().send(Err(error));
+    }
+    physical.usage.lock().unwrap().closed = true;
+    physical.cancel.cancel();
+    physical.connection.lock().unwrap().take();
+    if let Some(registry) = registry.upgrade() {
+        let mut current = registry.lock().unwrap();
+        if current
+            .as_ref()
+            .is_some_and(|entry| Arc::ptr_eq(&entry.physical, &physical))
+        {
+            current.take();
+        }
+    }
+    drop(pool_observation);
+}
+
+fn retire_on_connection_error(lease: &Lease, error: &io::Error) {
+    retire_physical(&lease.0, error);
+}
+fn retire_physical(physical: &Physical, _: &io::Error) {
+    // h3's default stable API deliberately hides its internal error variants.
+    // A stream error alone must not abort its siblings. The public QUIC state
+    // identifies actual physical closure; the control driver retires H3 errors.
+    if physical
+        .connection
+        .lock()
+        .unwrap()
+        .as_ref()
+        .is_some_and(|connection| connection.close_reason().is_some())
+    {
+        physical.usage.lock().unwrap().closed = true;
+        physical.cancel.cancel();
+    }
+}
+fn closed() -> io::Error {
+    io::Error::from(io::ErrorKind::ConnectionAborted)
+}
+
+#[derive(Default)]
+struct Close {
+    stopped: AtomicBool,
+    failed: AtomicBool,
+    reader: AtomicWaker,
+    writer: AtomicWaker,
+    cancel: CancellationToken,
+}
+impl Close {
+    fn stop(&self, failed: bool) {
+        if failed {
+            self.failed.store(true, Ordering::Release);
+        }
+        self.stopped.store(true, Ordering::Release);
+        self.cancel.cancel();
+        self.reader.wake();
+        self.writer.wake();
+    }
+}
+struct SendHalf {
+    stream: SendStream,
+}
+impl Drop for SendHalf {
+    fn drop(&mut self) {
+        self.stream.stop_stream(quiche_h3::REQUEST_CANCELLED);
+    }
+}
+struct ReceiveHalf(RecvStream);
+impl Drop for ReceiveHalf {
+    fn drop(&mut self) {
+        self.0.stop_sending(quiche_h3::REQUEST_CANCELLED);
+    }
+}
+struct Stream {
+    response: Option<oneshot::Receiver<io::Result<ReceiveHalf>>>,
+    receive: Option<ReceiveHalf>,
+    send: Option<SendHalf>,
+    // This future owns the send half and at most one CHUNK. Returning accepted
+    // bytes immediately makes cancellation/re-polling unable to duplicate DATA.
+    pending: Option<SendOperation>,
+    data: Bytes,
+    close: Arc<Close>,
+    lease: Option<Lease>,
+    finishing: bool,
+    finished: bool,
+    _observation: observation::Guard,
+}
+impl Stream {
+    fn stopped(&self) -> bool {
+        self.close.stopped.load(Ordering::Acquire)
+            || self.lease.as_ref().is_none_or(|lease| lease.0.is_closed())
+    }
+    fn drain(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        self.close.writer.register(cx.waker());
+        self.progress(cx)
+    }
+    fn progress(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        if self.stopped() {
+            return Poll::Ready(Err(closed()));
+        }
+        if let Some(pending) = &mut self.pending {
+            let (send, result) = ready!(pending.as_mut().poll(cx));
+            self.pending = None;
+            self.send = Some(send);
+            if result.is_err() {
+                self.close.stop(true);
+            }
+            result?;
+        }
+        Poll::Ready(Ok(()))
+    }
+    fn end(&mut self) {
+        self.close.stop(false);
+        self.response = None;
+        self.receive = None;
+        self.pending = None;
+        self.send = None;
+        self.data = Bytes::new();
+        self.lease.take();
+        self.finished = true;
+    }
+}
+impl Drop for Stream {
+    fn drop(&mut self) {
+        self.end();
+    }
+}
+impl AsyncRead for Stream {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buffer: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        self.close.reader.register(cx.waker());
+        if buffer.remaining() == 0 {
+            return Poll::Ready(Ok(()));
+        }
+        if self.stopped() {
+            return Poll::Ready(Err(closed()));
+        }
+        // A caller may write once and then read without flushing. Advance the
+        // accepted DATA with this read's waker, but do not gate reading on send
+        // credit: the peer's response can be needed to release that credit.
+        if let Poll::Ready(Err(error)) = self.progress(cx) {
+            return Poll::Ready(Err(error));
+        }
+        if let Some(response) = &mut self.response {
+            let received = ready!(Pin::new(response).poll(cx)).map_err(|_| closed())??;
+            self.response = None;
+            self.receive = Some(received);
+        }
+        // Limit control-frame/data work per poll, just as shared stream IO does.
+        for _ in 0..32 {
+            if !self.data.is_empty() {
+                let count = self.data.len().min(buffer.remaining());
+                buffer.put_slice(&self.data[..count]);
+                self.data.advance(count);
+                return Poll::Ready(Ok(()));
+            }
+            let Some(receive) = self.receive.as_mut() else {
+                return Poll::Ready(Ok(()));
+            };
+            match ready!(receive.0.poll_recv_data(cx)) {
+                Ok(Some(mut data)) => self.data = data.copy_to_bytes(data.remaining()),
+                Ok(None) => {
+                    self.receive = None;
+                    return Poll::Ready(Ok(()));
+                }
+                Err(error) => {
+                    if let Some(lease) = &self.lease {
+                        retire_on_connection_error(lease, &error);
+                    }
+                    self.close.stop(true);
+                    return Poll::Ready(Err(closed()));
+                }
+            }
+        }
+        cx.waker().wake_by_ref();
+        Poll::Pending
+    }
+}
+impl AsyncWrite for Stream {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        input: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        if self.finishing || self.finished {
+            return Poll::Ready(Err(io::ErrorKind::BrokenPipe.into()));
+        }
+        ready!(self.drain(cx))?;
+        if input.is_empty() {
+            return Poll::Ready(Ok(0));
+        }
+        let count = input.len().min(CHUNK);
+        let bytes = Bytes::copy_from_slice(&input[..count]);
+        let mut send = self.send.take().unwrap();
+        self.pending = Some(Box::pin(async move {
+            let result = send.stream.send_data(bytes).await.map_err(|_| closed());
+            (send, result)
+        }));
+        if let Poll::Ready(Err(error)) = self.progress(cx) {
+            return Poll::Ready(Err(error));
+        }
+        Poll::Ready(Ok(count))
+    }
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        if self.finished {
+            return Poll::Ready(Ok(()));
+        }
+        self.drain(cx)
+    }
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        if self.finished {
+            return Poll::Ready(Ok(()));
+        }
+        if let Poll::Ready(Err(error)) = self.drain(cx) {
+            self.end();
+            return Poll::Ready(Err(error));
+        }
+        if self.pending.is_some() {
+            return Poll::Pending;
+        }
+        if !self.finishing {
+            self.finishing = true;
+            let mut send = self.send.take().unwrap();
+            self.pending = Some(Box::pin(async move {
+                let result = tokio::time::timeout(quic::CLOSE_TIMEOUT, send.stream.finish())
+                    .await
+                    .map_err(|_| io::Error::from(io::ErrorKind::TimedOut))
+                    .and_then(|result| result.map_err(|_| closed()));
+                (send, result)
+            }));
+            cx.waker().wake_by_ref();
+            return Poll::Pending;
+        }
+        self.end();
+        Poll::Ready(Ok(()))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        dispatch::{DatagramBudget, DatagramTransport, DispatchError},
+        resources::observation::ResourceProbe,
+        session::{Datagram, Destination},
+    };
+    use async_trait::async_trait;
+    use std::{io::IoSliceMut, net::SocketAddr, sync::atomic::AtomicUsize};
+    use tokio::{
+        io::{AsyncReadExt, AsyncWriteExt},
+        sync::mpsc,
+    };
+
+    #[cfg(feature = "outbound-masque")]
+    #[tokio::test(start_paused = true)]
+    async fn masque_ip_budget_wait_observes_growth_and_enforces_stop_and_deadline() {
+        let cancel = CancellationToken::new();
+        let maximum = AtomicUsize::new(1198);
+        let deadline = Instant::now() + Duration::from_secs(2);
+        let wait = wait_for_packet_budget(&cancel, 1280, deadline, || {
+            Some(maximum.load(Ordering::Acquire))
+        });
+        tokio::pin!(wait);
+        tokio::select! { biased;
+            result=&mut wait=>panic!("insufficient budget became ready: {result:?}"),
+            ()=tokio::time::sleep(Duration::from_millis(40))=>{},
+        }
+        maximum.store(1300, Ordering::Release);
+        assert_eq!(wait.await.unwrap(), 1300);
+
+        let deadline = Instant::now() + Duration::from_millis(50);
+        let error = wait_for_packet_budget(&cancel, 1280, deadline, || Some(1198))
+            .await
+            .unwrap_err();
+        assert_eq!(error.kind(), io::ErrorKind::TimedOut);
+
+        cancel.cancel();
+        let error = wait_for_packet_budget(
+            &cancel,
+            1280,
+            Instant::now() + Duration::from_secs(2),
+            || Some(1400),
+        )
+        .await
+        .unwrap_err();
+        assert_eq!(error.kind(), io::ErrorKind::ConnectionAborted);
+    }
+
+    #[derive(Clone, Copy)]
+    enum PacketInput {
+        Unique,
+        OwnerBacked,
+    }
+    struct Packets {
+        input: PacketInput,
+        send: mpsc::Sender<Bytes>,
+        receive: mpsc::Receiver<Bytes>,
+        peer: SocketAddr,
+        closed: Arc<AtomicUsize>,
+    }
+    #[async_trait]
+    impl DatagramTransport for Packets {
+        fn supports_shared_destinations(&self) -> bool {
+            false
+        }
+
+        fn payload_budget(&self, _: &Destination) -> DatagramBudget {
+            DatagramBudget::new(1400, 1400)
+        }
+        async fn send(&mut self, datagram: Datagram) -> Result<(), DispatchError> {
+            assert_eq!(datagram.remote, Destination::Ip(self.peer));
+            self.send
+                .send(datagram.payload)
+                .await
+                .map_err(|_| DispatchError::NotAllowed)
+        }
+        async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+            let payload = self.receive.recv().await.ok_or(DispatchError::NotAllowed)?;
+            let payload = match self.input {
+                PacketInput::Unique => payload,
+                // from_owner stays immutable even if its inner Bytes later
+                // becomes unique while the adapter prefetches more packets.
+                PacketInput::OwnerBacked => Bytes::from_owner(payload),
+            };
+            Ok(Datagram {
+                remote: Destination::Ip(self.peer),
+                payload,
+                sniffed_domain: None,
+            })
+        }
+        async fn close(&mut self) -> Result<(), DispatchError> {
+            self.closed.fetch_add(1, Ordering::AcqRel);
+            self.receive.close();
+            Ok(())
+        }
+    }
+    #[derive(Debug)]
+    struct Socket {
+        send: mpsc::Sender<Bytes>,
+        receive: Mutex<mpsc::Receiver<Bytes>>,
+        peer: SocketAddr,
+        local: SocketAddr,
+    }
+    #[derive(Debug)]
+    struct Writable(Mutex<tokio_util::sync::PollSender<Bytes>>);
+    impl quinn::UdpPoller for Writable {
+        fn poll_writable(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            let mut sender = self.0.lock().unwrap();
+            if ready!(sender.poll_reserve(cx)).is_ok() {
+                sender.abort_send();
+            }
+            Poll::Ready(Ok(()))
+        }
+    }
+    impl quinn::AsyncUdpSocket for Socket {
+        fn create_io_poller(self: Arc<Self>) -> Pin<Box<dyn quinn::UdpPoller>> {
+            Box::pin(Writable(Mutex::new(tokio_util::sync::PollSender::new(
+                self.send.clone(),
+            ))))
+        }
+        fn try_send(&self, datagram: &quinn::udp::Transmit<'_>) -> io::Result<()> {
+            assert_eq!(datagram.destination, self.peer);
+            match self
+                .send
+                .try_send(Bytes::copy_from_slice(datagram.contents))
+            {
+                Ok(()) | Err(mpsc::error::TrySendError::Closed(_)) => Ok(()),
+                Err(mpsc::error::TrySendError::Full(_)) => Err(io::ErrorKind::WouldBlock.into()),
+            }
+        }
+        fn poll_recv(
+            &self,
+            cx: &mut Context<'_>,
+            buffers: &mut [IoSliceMut<'_>],
+            meta: &mut [quinn::udp::RecvMeta],
+        ) -> Poll<io::Result<usize>> {
+            let Some(packet) = ready!(self.receive.lock().unwrap().poll_recv(cx)) else {
+                return Poll::Pending;
+            };
+            buffers[0][..packet.len()].copy_from_slice(&packet);
+            meta[0] = quinn::udp::RecvMeta {
+                addr: self.peer,
+                len: packet.len(),
+                stride: packet.len(),
+                ecn: None,
+                dst_ip: Some(self.local.ip()),
+            };
+            Poll::Ready(Ok(1))
+        }
+        fn local_addr(&self) -> io::Result<SocketAddr> {
+            Ok(self.local)
+        }
+    }
+    const LARGE_DUPLEX_BYTES: usize = 512 * 1024;
+
+    struct Peer {
+        client: crate::security::StandardTlsClient,
+        server: rustls::ServerConfig,
+        cancel: CancellationToken,
+        tasks: TaskTracker,
+        calls: AtomicUsize,
+        closed: Arc<AtomicUsize>,
+        checks: AtomicUsize,
+        reject: Arc<Notify>,
+        goaway: Notify,
+        duplex_fin: Mutex<Option<oneshot::Sender<io::Result<usize>>>>,
+        input: PacketInput,
+        l4: bool,
+    }
+    impl Peer {
+        fn new() -> Arc<Self> {
+            let identity = rcgen::generate_simple_self_signed(vec!["localhost".into()]).unwrap();
+            let mut roots = rustls::RootCertStore::empty();
+            roots.add(identity.cert.der().clone()).unwrap();
+            let provider = Arc::new(rustls::crypto::ring::default_provider());
+            let client = crate::security::StandardTlsClient::with_options(
+                &crate::security::SecurityContext::with_tls_roots(roots),
+                "localhost",
+                crate::security::TlsClientOptions {
+                    alpn: vec![b"h3".to_vec()],
+                    required_alpn: Some(b"h3".to_vec()),
+                    versions: crate::security::TlsVersions::Tls13,
+                    ..Default::default()
+                },
+                0,
+                64 * 1024,
+            )
+            .unwrap();
+            let mut server = rustls::ServerConfig::builder_with_provider(provider)
+                .with_safe_default_protocol_versions()
+                .unwrap()
+                .with_no_client_auth()
+                .with_single_cert(
+                    vec![identity.cert.der().clone()],
+                    rustls::pki_types::PrivateKeyDer::Pkcs8(
+                        identity.signing_key.serialize_der().into(),
+                    ),
+                )
+                .unwrap();
+            server.alpn_protocols = vec![b"h3".to_vec()];
+            Arc::new(Self {
+                client,
+                server,
+                cancel: CancellationToken::new(),
+                tasks: TaskTracker::new(),
+                calls: AtomicUsize::new(0),
+                closed: Arc::new(AtomicUsize::new(0)),
+                checks: AtomicUsize::new(0),
+                reject: Arc::new(Notify::new()),
+                goaway: Notify::new(),
+                duplex_fin: Mutex::new(None),
+                input: PacketInput::Unique,
+                l4: false,
+            })
+        }
+        #[cfg(feature = "outbound-masque")]
+        fn l4() -> Arc<Self> {
+            let mut peer = Self::new();
+            Arc::get_mut(&mut peer).unwrap().l4 = true;
+            peer
+        }
+        async fn connect(self: Arc<Self>) -> io::Result<QuicTransport> {
+            self.calls.fetch_add(1, Ordering::AcqRel);
+            let local: SocketAddr = "192.0.2.1:443".parse().unwrap();
+            let peer: SocketAddr = "192.0.2.2:41000".parse().unwrap();
+            let (to_client, from_server) = mpsc::channel(32);
+            let (to_server, from_client) = mpsc::channel(32);
+            let socket = Arc::new(Socket {
+                send: to_client,
+                receive: Mutex::new(from_client),
+                local,
+                peer,
+            });
+            let crypto =
+                quinn::crypto::rustls::QuicServerConfig::try_from(self.server.clone()).unwrap();
+            let mut config = quinn::ServerConfig::with_crypto(Arc::new(crypto));
+            Arc::get_mut(&mut config.transport)
+                .unwrap()
+                .mtu_discovery_config(None)
+                .stream_receive_window(1024_u32.into());
+            let runtime = Arc::new(quic::OwnedRuntime::new(CancellationToken::new()));
+            let endpoint = quinn::Endpoint::new_with_abstract_socket(
+                quinn::EndpointConfig::default(),
+                Some(config),
+                socket,
+                runtime.clone(),
+            )
+            .unwrap();
+            let owner = self.clone();
+            self.tasks.spawn(async move {
+                let serve=async {
+                    let connected=endpoint.accept().await.unwrap().await.unwrap();
+                    let mut connection=h3::server::builder().build::<_,Bytes>(h3_quinn::Connection::new(connected)).await.unwrap();
+                    loop {
+                        let request = tokio::select! {
+                            ()=owner.goaway.notified()=>{
+                                connection.shutdown(0).await.unwrap();
+                                continue;
+                            },
+                            result=connection.accept()=>match result {
+                                Ok(Some(request))=>request,
+                                _=>break,
+                            }
+                        };
+                        let (request,mut stream)=request.resolve_request().await.unwrap();
+                        assert_eq!(request.method(),http::Method::CONNECT);
+                        assert!(request.uri().scheme().is_none());
+                        assert!(request.uri().path_and_query().is_none());
+                        if owner.l4 {
+                            assert!(!request.headers().contains_key("proxy-authorization"));
+                        } else {
+                            assert_eq!(request.headers()["proxy-authorization"],"Basic dTpw");
+                        }
+                        let target=request.uri().authority().unwrap().as_str().to_owned();
+                        let handler=owner.clone();
+                        owner.tasks.spawn(async move {
+                            let handle=async {
+                                if target=="_check" {
+                                    assert!(stream.recv_data().await.unwrap().is_none());
+                                    stream.send_response(http::Response::new(())).await.unwrap();
+                                    stream.finish().await.unwrap();
+                                    handler.checks.fetch_add(1,Ordering::AcqRel);
+                                } else if target=="reject.invalid:443" {
+                                    if !handler.l4 { handler.reject.notified().await; }
+                                    stream.send_response(http::Response::builder().status(407).body(()).unwrap()).await.unwrap();
+                                    stream.finish().await.unwrap();
+                                } else if target=="large-duplex.invalid:443" {
+                                    let witness=handler.duplex_fin.lock().unwrap().take().unwrap();
+                                    let result=async {
+                                        let (mut send,mut receive)=stream.split();
+                                        let mut received=0;
+                                        while let Some(mut data)=receive.recv_data().await.map_err(|error|io::Error::other(error.to_string()))? {
+                                            let data=data.copy_to_bytes(data.remaining());
+                                            if data.is_empty() {continue;}
+                                            if data.len()>LARGE_DUPLEX_BYTES-received || data.iter().enumerate().any(|(index,byte)|*byte!=((received+index) as u8).wrapping_mul(31).wrapping_add(7)) {
+                                                return Err(io::Error::other("large duplex peer payload mismatch"));
+                                            }
+                                            if received==0 {send.send_response(http::Response::new(())).await.map_err(|error|io::Error::other(error.to_string()))?;}
+                                            received+=data.len();
+                                            send.send_data(data).await.map_err(|error|io::Error::other(error.to_string()))?;
+                                            if received==LARGE_DUPLEX_BYTES {send.finish().await.map_err(|error|io::Error::other(error.to_string()))?;}
+                                        }
+                                        // recv_data(None) is the peer's real request FIN witness.
+                                        if received!=LARGE_DUPLEX_BYTES {return Err(io::Error::other("large duplex peer received a short body"));}
+                                        Ok::<_,io::Error>(received)
+                                    }.await;
+                                    let _=witness.send(result);
+                                } else {
+                                    if handler.l4 {
+                                        stream.send_response(http::Response::builder().status(204).body(()).unwrap()).await.unwrap();
+                                    }
+                                    let first=stream.recv_data().await.unwrap().unwrap();
+                                    let mut first=first;
+                                    let first=first.copy_to_bytes(first.remaining());
+                                    if !handler.l4 { stream.send_response(http::Response::new(())).await.unwrap(); }
+                                    stream.send_data(first).await.unwrap();
+                                    while let Ok(Some(mut data))=stream.recv_data().await {
+                                        let data=data.copy_to_bytes(data.remaining());
+                                        if stream.send_data(data).await.is_err() {break;}
+                                    }
+                                    let _=stream.finish().await;
+                                }
+                            };
+                            tokio::select! {biased; ()=handler.cancel.cancelled()=>{}, ()=handle=>{}}
+                        });
+                    }
+                };
+                tokio::select! {biased; ()=owner.cancel.cancelled()=>{}, ()=serve=>{}}
+                endpoint.close(0_u8.into(),b"");
+                runtime.stop().await;
+            });
+            Ok(QuicTransport {
+                transport: Box::new(Packets {
+                    input: self.input,
+                    send: to_server,
+                    receive: from_server,
+                    peer: local,
+                    closed: self.closed.clone(),
+                }),
+                peer: local,
+                budget: DatagramBudget::new(1400, 1400),
+                tls: self.client.quiche_config()?,
+                server_name: "localhost".into(),
+            })
+        }
+        async fn stop(&self) {
+            self.cancel.cancel();
+            self.tasks.close();
+            self.tasks.wait().await;
+        }
+    }
+    fn request(target: &str) -> http::Request<()> {
+        http::Request::builder()
+            .method(http::Method::CONNECT)
+            .uri(http::Uri::builder().authority(target).build().unwrap())
+            .header("proxy-authorization", "Basic dTpw")
+            .header("user-agent", "memory")
+            .body(())
+            .unwrap()
+    }
+    async fn open(pool: &Pool, peer: &Arc<Peer>, target: &str) -> BoxStream {
+        let peer = peer.clone();
+        pool.open_connect(
+            request(target),
+            Instant::now() + Duration::from_secs(5),
+            None,
+            move || peer.connect(),
+        )
+        .await
+        .unwrap()
+    }
+    async fn echo(stream: &mut BoxStream, data: &[u8]) {
+        stream.write_all(data).await.unwrap();
+        // No flush: a single client-first write followed by a read must move
+        // DATA even though both protocol halves share this byte-stream owner.
+        let mut response = vec![0; data.len()];
+        stream.read_exact(&mut response).await.unwrap();
+        assert_eq!(response, data);
+    }
+    #[cfg(feature = "outbound-masque")]
+    #[tokio::test]
+    async fn masque_l4_waits_for_2xx_and_rejection_keeps_independent_sibling_alive() {
+        let observation = ResourceProbe::default();
+        observation
+            .scope(async {
+                let peer = Peer::l4();
+                let pool = Pool::masque_l4(None);
+                let open = |target: &str| {
+                    let factory = peer.clone();
+                    let request = http::Request::builder()
+                        .method(http::Method::CONNECT)
+                        .uri(http::Uri::builder().authority(target).build().unwrap())
+                        .body(())
+                        .unwrap();
+                    pool.open_connect(
+                        request,
+                        Instant::now() + Duration::from_secs(3),
+                        None,
+                        move || factory.connect(),
+                    )
+                };
+                let mut first = open("echo.invalid:443").await.unwrap();
+                // The peer sends 204 before any DATA: a deferred or 200-only
+                // implementation would hang or reject this actual CONNECT stream.
+                let mut second = open("echo.invalid:443").await.unwrap();
+                echo(&mut first, b"first").await;
+                echo(&mut second, b"second").await;
+                assert!(open("reject.invalid:443").await.is_err());
+                echo(&mut second, b"after-rejection").await;
+                first.shutdown().await.unwrap();
+                echo(&mut second, b"after-close").await;
+                assert_eq!(peer.calls.load(Ordering::Acquire), 1);
+                let physical = pool
+                    .connection
+                    .lock()
+                    .unwrap()
+                    .as_ref()
+                    .unwrap()
+                    .physical
+                    .clone();
+                assert!(physical.idle_timeout.is_none());
+                pool.shutdown().await;
+                assert!(second.write_all(b"after-stop").await.is_err());
+                assert!(open("echo.invalid:443").await.is_err());
+                assert_eq!(peer.calls.load(Ordering::Acquire), 1);
+                drop((first, second, pool, physical));
+                peer.stop().await;
+                assert_eq!(peer.closed.load(Ordering::Acquire), 1);
+            })
+            .await;
+        assert!(observation.snapshot().is_idle());
+    }
+    #[tokio::test]
+    async fn trusttunnel_h3_deferred_headers_share_streams_probe_and_join_stop() {
+        let observation = ResourceProbe::default();
+        observation
+            .scope(async {
+                let peer = Peer::new();
+                let pool = Pool::new(quiche_h3::congestion_controller("bbr"));
+                let mut first = open(&pool, &peer, "echo.invalid:443").await;
+                let mut second = open(&pool, &peer, "echo.invalid:443").await;
+                assert_eq!(peer.calls.load(Ordering::Acquire), 1);
+                echo(&mut first, b"client-first").await;
+                echo(&mut second, b"second").await;
+                first.shutdown().await.unwrap();
+                echo(&mut second, b"survives-sibling-close").await;
+                let factory = peer.clone();
+                pool.probe(
+                    request("_check"),
+                    Instant::now() + Duration::from_secs(7),
+                    move || factory.connect(),
+                )
+                .await
+                .unwrap();
+                assert_eq!(peer.checks.load(Ordering::Acquire), 1);
+                assert_eq!(
+                    pool.connection
+                        .lock()
+                        .unwrap()
+                        .as_ref()
+                        .unwrap()
+                        .physical
+                        .usage
+                        .lock()
+                        .unwrap()
+                        .active,
+                    1
+                );
+                pool.shutdown().await;
+                assert!(second.write_all(b"after-stop").await.is_err());
+                let calls = peer.calls.load(Ordering::Acquire);
+                let factory = peer.clone();
+                assert!(
+                    pool.probe(
+                        request("_check"),
+                        Instant::now() + Duration::from_secs(7),
+                        move || factory.connect()
+                    )
+                    .await
+                    .is_err()
+                );
+                assert_eq!(peer.calls.load(Ordering::Acquire), calls);
+                drop((first, second, pool));
+                peer.stop().await;
+                assert_eq!(peer.closed.load(Ordering::Acquire), 1);
+            })
+            .await;
+        assert!(observation.snapshot().is_idle());
+    }
+    #[tokio::test]
+    async fn trusttunnel_h3_large_duplex_data_fin_and_joined_stop() {
+        large_duplex_ingress(PacketInput::Unique).await;
+    }
+    #[tokio::test]
+    async fn quiche_h3_owner_backed_ingress_preserves_duplex_fin_and_joined_stop() {
+        large_duplex_ingress(PacketInput::OwnerBacked).await;
+    }
+    async fn large_duplex_ingress(input: PacketInput) {
+        use futures_util::FutureExt;
+        use std::panic::{AssertUnwindSafe, resume_unwind};
+
+        let observation = ResourceProbe::default();
+        let (result, cleanup, calls, closed, empty) = observation
+            .scope(async {
+                let mut peer = Peer::new();
+                Arc::get_mut(&mut peer).unwrap().input = input;
+                let pool = Pool::new(None);
+                let (finished, fin) = oneshot::channel();
+                *peer.duplex_fin.lock().unwrap() = Some(finished);
+                let result =
+                    AssertUnwindSafe(tokio::time::timeout(Duration::from_secs(15), async {
+                        let stream = open(&pool, &peer, "large-duplex.invalid:443").await;
+                        let (mut read, mut write) = tokio::io::split(stream);
+                        let payload = (0..LARGE_DUPLEX_BYTES)
+                            .map(|index| (index as u8).wrapping_mul(31).wrapping_add(7))
+                            .collect::<Vec<_>>();
+                        let read_complete = Notify::new();
+                        let upload = async {
+                            write.write_all(&payload).await?;
+                            write.flush().await?;
+                            // Shutdown ends this whole logical CONNECT stream; keep
+                            // the reader alive until the concurrent echo is complete.
+                            read_complete.notified().await;
+                            write.shutdown().await
+                        };
+                        let download = async {
+                            let mut echoed = vec![0; LARGE_DUPLEX_BYTES];
+                            read.read_exact(&mut echoed).await?;
+                            if echoed != payload {
+                                return Err(io::Error::other(
+                                    "large duplex client payload mismatch",
+                                ));
+                            }
+                            let mut extra = [0];
+                            if read.read(&mut extra).await? != 0 {
+                                return Err(io::Error::other(
+                                    "large duplex response exceeded its body",
+                                ));
+                            }
+                            read_complete.notify_one();
+                            Ok::<_, io::Error>(())
+                        };
+                        tokio::try_join!(upload, download)?;
+                        let received = fin.await.map_err(|_| {
+                            io::Error::other("large duplex peer did not report FIN")
+                        })??;
+                        if received != LARGE_DUPLEX_BYTES {
+                            return Err(io::Error::other(
+                                "large duplex FIN witness had a short body",
+                            ));
+                        }
+                        Ok::<_, io::Error>(())
+                    }))
+                    .catch_unwind()
+                    .await;
+                // Always join the owned client and memory peer before exposing
+                // the operation's timeout, IO error, or panic to the test runner.
+                let cleanup = tokio::time::timeout(Duration::from_secs(5), async {
+                    pool.shutdown().await;
+                    peer.stop().await;
+                })
+                .await;
+                let calls = peer.calls.load(Ordering::Acquire);
+                let closed = peer.closed.load(Ordering::Acquire);
+                let empty = pool.tasks.is_empty() && peer.tasks.is_empty();
+                drop((pool, peer));
+                (result, cleanup, calls, closed, empty)
+            })
+            .await;
+        let result = match result {
+            Ok(result) => result,
+            Err(panic) => resume_unwind(panic),
+        };
+        cleanup.expect("large duplex Stop did not join within its bound");
+        assert!(empty);
+        assert_eq!(calls, 1);
+        assert_eq!(closed, 1);
+        assert!(observation.snapshot().is_idle());
+        result
+            .expect("large duplex DATA/FIN timed out")
+            .expect("large duplex DATA/FIN failed");
+    }
+    #[tokio::test]
+    async fn trusttunnel_h3_rejected_headers_wake_stalled_write_without_read() {
+        let observation = ResourceProbe::default();
+        observation
+            .scope(async {
+                let peer = Peer::new();
+                let pool = Pool::new(None);
+                let mut stream = open(&pool, &peer, "reject.invalid:443").await;
+                let bytes = vec![1; 256 * 1024];
+                let blocked = stream.write_all(&bytes);
+                let mut blocked = Box::pin(blocked);
+                tokio::select! {
+                    result=&mut blocked=>panic!("write completed before rejection: {result:?}"),
+                    ()=tokio::time::sleep(Duration::from_millis(20))=>{},
+                }
+                peer.reject.notify_one();
+                assert!(
+                    tokio::time::timeout(Duration::from_secs(2), &mut blocked)
+                        .await
+                        .unwrap()
+                        .is_err()
+                );
+                drop(blocked);
+                pool.shutdown().await;
+                drop(stream);
+                peer.stop().await;
+            })
+            .await;
+        assert!(observation.snapshot().is_idle());
+    }
+    #[tokio::test(start_paused = true)]
+    async fn trusttunnel_h3_idle_session_retires_and_next_request_reconnects() {
+        let observation = ResourceProbe::default();
+        observation
+            .scope(async {
+                let peer = Peer::new();
+                let pool = Pool::new(None);
+                let mut first = open(&pool, &peer, "echo.invalid:443").await;
+                echo(&mut first, b"before-idle").await;
+                first.shutdown().await.unwrap();
+                drop(first);
+                tokio::time::advance(IDLE + Duration::from_secs(1)).await;
+                tokio::time::timeout(Duration::from_secs(3), async {
+                    while peer.closed.load(Ordering::Acquire) == 0 {
+                        tokio::time::sleep(Duration::from_millis(1)).await;
+                    }
+                })
+                .await
+                .unwrap();
+                let mut second = open(&pool, &peer, "echo.invalid:443").await;
+                echo(&mut second, b"after-idle").await;
+                assert_eq!(peer.calls.load(Ordering::Acquire), 2);
+                pool.shutdown().await;
+                drop((second, pool));
+                peer.stop().await;
+                assert_eq!(peer.closed.load(Ordering::Acquire), 2);
+            })
+            .await;
+        assert!(observation.snapshot().is_idle());
+    }
+    #[tokio::test]
+    async fn trusttunnel_h3_goaway_reconnects_without_cancelling_accepted_sibling() {
+        let observation = ResourceProbe::default();
+        observation
+            .scope(async {
+                let peer = Peer::new();
+                let pool = Pool::new(None);
+                let mut first = open(&pool, &peer, "echo.invalid:443").await;
+                echo(&mut first, b"before-goaway").await;
+                peer.goaway.notify_one();
+                tokio::time::timeout(Duration::from_secs(2), async {
+                    loop {
+                        if !pool
+                            .connection
+                            .lock()
+                            .unwrap()
+                            .as_ref()
+                            .unwrap()
+                            .sender
+                            .can_open_request()
+                        {
+                            break;
+                        }
+                        tokio::task::yield_now().await;
+                    }
+                })
+                .await
+                .unwrap();
+                let mut second = open(&pool, &peer, "echo.invalid:443").await;
+                assert_eq!(peer.calls.load(Ordering::Acquire), 2);
+                assert_eq!(observation.snapshot().current(ResourceKind::Pool), 2);
+                echo(&mut first, b"old-accepted-stream-survives").await;
+                echo(&mut second, b"new-session").await;
+                first.shutdown().await.unwrap();
+                drop(first);
+                tokio::time::timeout(Duration::from_secs(3), async {
+                    while peer.closed.load(Ordering::Acquire) == 0 {
+                        tokio::time::sleep(Duration::from_millis(1)).await;
+                    }
+                })
+                .await
+                .unwrap();
+                echo(&mut second, b"after-old-session-retired").await;
+                pool.shutdown().await;
+                drop((second, pool));
+                peer.stop().await;
+                assert_eq!(peer.closed.load(Ordering::Acquire), 2);
+            })
+            .await;
+        assert!(observation.snapshot().is_idle());
+    }
+    #[tokio::test]
+    async fn trusttunnel_h3_cancelled_creation_is_joined_and_cannot_reopen_after_stop() {
+        let observation = ResourceProbe::default();
+        observation.scope(async {
+            let pool=Pool::new(None);
+            let started=Arc::new(Notify::new());
+            let finished=Arc::new(AtomicBool::new(false));
+            struct Released(Arc<AtomicBool>);
+            impl Drop for Released {fn drop(&mut self) {self.0.store(true,Ordering::Release);}}
+            let opening=pool.open_connect(request("echo.invalid:443"),Instant::now()+Duration::from_secs(30),None,{
+                let started=started.clone();let finished=finished.clone();
+                move||async move {
+                    let _released=Released(finished);
+                    started.notify_one();
+                    std::future::pending::<io::Result<QuicTransport>>().await
+                }
+            });
+                let mut opening = Box::pin(opening);
+            tokio::select! { result=&mut opening=>panic!("setup completed: {}",result.is_ok()), ()=started.notified()=>{} }
+            drop(opening);
+                tokio::time::timeout(Duration::from_secs(2),async {
+                    while !finished.load(Ordering::Acquire) { tokio::task::yield_now().await; }
+                }).await.unwrap();
+            pool.shutdown().await;
+            assert!(finished.load(Ordering::Acquire));
+            assert!(pool.tasks.is_empty());
+            assert!(pool.spawn(async {}).is_err());
+        }).await;
+        assert!(observation.snapshot().is_idle());
+    }
+}
diff --git a/src/transport/http_obfs.rs b/src/transport/http_obfs.rs
index 1cf41b9..837ec39 100644
--- a/src/transport/http_obfs.rs
+++ b/src/transport/http_obfs.rs
@@ -106,11 +106,11 @@ pub async fn http_obfs(
     .await
     .map_err(|_| io::Error::from(io::ErrorKind::TimedOut))??;
     let (mut reader, writer) = tokio::io::split(stream);
+    // The complete request prefix was submitted within the setup deadline.
+    // An official peer can wait for application output before its first reply.
     // No task or socket: the caller's first read drives the response header.
     let response = Box::pin(async move {
-        let (_, tail) = timeout_at(deadline, read_response(&mut reader))
-            .await
-            .map_err(|_| io::Error::from(io::ErrorKind::TimedOut))??;
+        let (_, tail) = read_response(&mut reader).await?;
         Ok((reader, Bytes::from(tail)))
     });
     Ok(Box::new(HttpStream {
diff --git a/src/transport/masque_codec.rs b/src/transport/masque_codec.rs
new file mode 100644
index 0000000..dee3557
--- /dev/null
+++ b/src/transport/masque_codec.rs
@@ -0,0 +1,535 @@
+//! Bounded MASQUE framing from RFC 9000, RFC 9297, RFC 9298 and RFC 9484.
+//! Capsule DATAGRAM values remain opaque: the request owner supplies the
+//! HTTP Datagram context where required by its negotiated protocol.
+
+use bytes::Bytes;
+use std::{
+    io,
+    net::{IpAddr, Ipv4Addr, Ipv6Addr},
+};
+
+pub(crate) const DATAGRAM: u64 = 0;
+pub(crate) const ADDRESS_ASSIGN: u64 = 1;
+pub(crate) const ADDRESS_REQUEST: u64 = 2;
+pub(crate) const ROUTE_ADVERTISEMENT: u64 = 3;
+pub(crate) const MAX_VARINT: u64 = (1 << 62) - 1;
+
+fn invalid() -> io::Error {
+    io::Error::new(io::ErrorKind::InvalidData, "invalid MASQUE framing")
+}
+
+pub(crate) fn varint_len(value: u64) -> io::Result<usize> {
+    match value {
+        0..=63 => Ok(1),
+        64..=16_383 => Ok(2),
+        16_384..=1_073_741_823 => Ok(4),
+        1_073_741_824..=MAX_VARINT => Ok(8),
+        _ => Err(invalid()),
+    }
+}
+
+pub(crate) fn encode_varint(value: u64, output: &mut Vec<u8>) -> io::Result<()> {
+    let len = varint_len(value)?;
+    let start = output.len();
+    output.extend_from_slice(&value.to_be_bytes()[8 - len..]);
+    output[start] |= match len {
+        1 => 0,
+        2 => 0x40,
+        4 => 0x80,
+        8 => 0xc0,
+        _ => unreachable!(),
+    };
+    Ok(())
+}
+
+/// An incomplete integer is not an error. QUIC permits non-minimal encoding.
+pub(crate) fn decode_varint(input: &[u8]) -> io::Result<Option<(u64, usize)>> {
+    let Some(first) = input.first() else {
+        return Ok(None);
+    };
+    let len = 1 << (first >> 6);
+    if input.len() < len {
+        return Ok(None);
+    }
+    let value = input[1..len]
+        .iter()
+        .fold(u64::from(first & 0x3f), |v, byte| {
+            (v << 8) | u64::from(*byte)
+        });
+    Ok(Some((value, len)))
+}
+
+fn quarter_stream_id(raw_request_stream_id: u64) -> io::Result<u64> {
+    if raw_request_stream_id > MAX_VARINT || raw_request_stream_id & 3 != 0 {
+        return Err(invalid());
+    }
+    Ok(raw_request_stream_id / 4)
+}
+
+pub(crate) fn encode_h3_datagram(
+    raw_request_stream_id: u64,
+    payload: &[u8],
+    wire_budget: usize,
+) -> io::Result<Bytes> {
+    let quarter = quarter_stream_id(raw_request_stream_id)?;
+    let len = varint_len(quarter)?
+        .checked_add(1)
+        .and_then(|header| header.checked_add(payload.len()))
+        .filter(|len| *len <= wire_budget)
+        .ok_or_else(invalid)?;
+    let mut output = Vec::with_capacity(len);
+    encode_varint(quarter, &mut output)?;
+    output.push(0); // Context ID zero, encoded in its shortest representation.
+    output.extend_from_slice(payload);
+    Ok(Bytes::from(output))
+}
+
+pub(crate) fn decode_h3_datagram(
+    input: &[u8],
+    expected_raw_request_stream_id: u64,
+    wire_budget: usize,
+) -> io::Result<&[u8]> {
+    let expected = quarter_stream_id(expected_raw_request_stream_id)?;
+    if input.len() > wire_budget {
+        return Err(invalid());
+    }
+    let (quarter, consumed) = decode_varint(input)?.ok_or_else(invalid)?;
+    if quarter > (MAX_VARINT / 4) || quarter != expected {
+        return Err(invalid());
+    }
+    let (context, context_len) = decode_varint(&input[consumed..])?.ok_or_else(invalid)?;
+    if context != 0 {
+        return Err(invalid());
+    }
+    Ok(&input[consumed + context_len..])
+}
+
+pub(crate) struct Capsule {
+    pub(crate) kind: u64,
+    pub(crate) value: Bytes,
+}
+
+impl std::fmt::Debug for Capsule {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("MasqueCapsule")
+            .field("kind", &self.kind)
+            .field("value_len", &self.value.len())
+            .finish()
+    }
+}
+
+fn capsule_len(kind: u64, value_len: usize, max_value_len: usize) -> io::Result<usize> {
+    if value_len > max_value_len {
+        return Err(invalid());
+    }
+    let wire_len = u64::try_from(value_len).map_err(|_| invalid())?;
+    varint_len(kind)?
+        .checked_add(varint_len(wire_len)?)
+        .and_then(|header| header.checked_add(value_len))
+        .ok_or_else(invalid)
+}
+
+pub(crate) fn encode_capsule(kind: u64, value: &[u8], max_value_len: usize) -> io::Result<Bytes> {
+    let len = capsule_len(kind, value.len(), max_value_len)?;
+    let mut output = Vec::with_capacity(len);
+    encode_varint(kind, &mut output)?;
+    encode_varint(value.len() as u64, &mut output)?;
+    output.extend_from_slice(value);
+    Ok(Bytes::from(output))
+}
+
+/// Append one whole capsule only when it fits. Validation and a no-fit result
+/// leave an existing prefix untouched; callers can independently send big values.
+#[cfg(feature = "outbound-masque")]
+pub(crate) fn try_append_capsule(
+    kind: u64,
+    value: &[u8],
+    max_value_len: usize,
+    output: &mut Vec<u8>,
+    max_output_len: usize,
+) -> io::Result<bool> {
+    let len = capsule_len(kind, value.len(), max_value_len)?;
+    if output
+        .len()
+        .checked_add(len)
+        .is_none_or(|end| end > max_output_len)
+    {
+        return Ok(false);
+    }
+    encode_varint(kind, output)?;
+    encode_varint(value.len() as u64, output)?;
+    output.extend_from_slice(value);
+    Ok(true)
+}
+
+/// One incremental parser owns at most one capsule value and an eight-byte
+/// integer prefix. Unknown values are discarded without allocation. A failed
+/// parser is retired; its partial bytes cannot be interpreted as a new capsule.
+pub(crate) struct CapsuleDecoder {
+    max_value_len: usize,
+    kind: Option<u64>,
+    length: Option<usize>,
+    remaining: usize,
+    integer: [u8; 8],
+    integer_len: usize,
+    value: Vec<u8>,
+    retired: bool,
+}
+
+impl CapsuleDecoder {
+    pub(crate) fn new(max_value_len: usize) -> Self {
+        Self {
+            max_value_len,
+            kind: None,
+            length: None,
+            remaining: 0,
+            integer: [0; 8],
+            integer_len: 0,
+            value: Vec::new(),
+            retired: false,
+        }
+    }
+
+    /// Consume a prefix and return at most one complete known capsule. The
+    /// caller retains any unconsumed suffix. Completing an unknown capsule
+    /// returns its consumed byte count with no capsule.
+    pub(crate) fn feed(&mut self, input: &[u8]) -> io::Result<(usize, Option<Capsule>)> {
+        if self.retired {
+            return Err(invalid());
+        }
+        let result = self.feed_inner(input);
+        if result.is_err() {
+            self.retired = true;
+            self.value = Vec::new();
+        }
+        result
+    }
+
+    fn feed_inner(&mut self, input: &[u8]) -> io::Result<(usize, Option<Capsule>)> {
+        let mut consumed = 0;
+        if self.kind.is_none() {
+            let (count, kind) = self.read_integer(&input[consumed..])?;
+            consumed += count;
+            let Some(kind) = kind else {
+                return Ok((consumed, None));
+            };
+            self.kind = Some(kind);
+        }
+        if self.length.is_none() {
+            let (count, length) = self.read_integer(&input[consumed..])?;
+            consumed += count;
+            let Some(length) = length else {
+                return Ok((consumed, None));
+            };
+            let length = usize::try_from(length).map_err(|_| invalid())?;
+            if length > self.max_value_len {
+                return Err(invalid());
+            }
+            self.length = Some(length);
+            self.remaining = length;
+            if self.known() {
+                self.value = Vec::with_capacity(length);
+            }
+        }
+        let count = self.remaining.min(input.len() - consumed);
+        if self.known() {
+            self.value
+                .extend_from_slice(&input[consumed..consumed + count]);
+        }
+        consumed += count;
+        self.remaining -= count;
+        if self.remaining != 0 {
+            return Ok((consumed, None));
+        }
+        let kind = self.kind.take().expect("capsule type read");
+        self.length = None;
+        let capsule = matches!(
+            kind,
+            DATAGRAM | ADDRESS_ASSIGN | ADDRESS_REQUEST | ROUTE_ADVERTISEMENT
+        )
+        .then(|| Capsule {
+            kind,
+            value: Bytes::from(std::mem::take(&mut self.value)),
+        });
+        Ok((consumed, capsule))
+    }
+
+    fn known(&self) -> bool {
+        matches!(
+            self.kind,
+            Some(DATAGRAM | ADDRESS_ASSIGN | ADDRESS_REQUEST | ROUTE_ADVERTISEMENT)
+        )
+    }
+
+    fn read_integer(&mut self, input: &[u8]) -> io::Result<(usize, Option<u64>)> {
+        let mut consumed = 0;
+        while consumed < input.len() {
+            self.integer[self.integer_len] = input[consumed];
+            self.integer_len += 1;
+            consumed += 1;
+            if let Some((value, _)) = decode_varint(&self.integer[..self.integer_len])? {
+                self.integer_len = 0;
+                return Ok((consumed, Some(value)));
+            }
+        }
+        Ok((consumed, None))
+    }
+
+    /// Check end-of-stream without accepting a truncated header or value.
+    pub(crate) fn finish(&mut self) -> io::Result<()> {
+        if self.retired || self.kind.is_some() || self.integer_len != 0 {
+            self.retired = true;
+            self.value = Vec::new();
+            return Err(io::Error::new(
+                io::ErrorKind::UnexpectedEof,
+                "truncated MASQUE capsule",
+            ));
+        }
+        Ok(())
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(crate) struct AddressPrefix {
+    pub(crate) request_id: u64,
+    pub(crate) address: IpAddr,
+    pub(crate) prefix_len: u8,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(crate) struct Route {
+    pub(crate) start: IpAddr,
+    pub(crate) end: IpAddr,
+    pub(crate) protocol: u8,
+}
+
+fn take<'a>(input: &mut &'a [u8], count: usize) -> io::Result<&'a [u8]> {
+    let value = input.get(..count).ok_or_else(invalid)?;
+    *input = &input[count..];
+    Ok(value)
+}
+
+fn read_address(input: &mut &[u8], family: u8) -> io::Result<IpAddr> {
+    match family {
+        4 => Ok(
+            Ipv4Addr::from(<[u8; 4]>::try_from(take(input, 4)?).expect("address length")).into(),
+        ),
+        6 => Ok(
+            Ipv6Addr::from(<[u8; 16]>::try_from(take(input, 16)?).expect("address length")).into(),
+        ),
+        _ => Err(invalid()),
+    }
+}
+
+/// Wire prefixes must be masked. Configured local addresses are a separate
+/// consumer and must not be passed through this capsule-specific parser.
+pub(crate) fn parse_addresses(
+    kind: u64,
+    mut input: &[u8],
+    max_entries: usize,
+) -> io::Result<Vec<AddressPrefix>> {
+    if !matches!(kind, ADDRESS_ASSIGN | ADDRESS_REQUEST)
+        || (kind == ADDRESS_REQUEST && input.is_empty())
+    {
+        return Err(invalid());
+    }
+    let mut prefixes = Vec::new();
+    while !input.is_empty() {
+        if prefixes.len() >= max_entries {
+            return Err(invalid());
+        }
+        let (request_id, consumed) = decode_varint(input)?.ok_or_else(invalid)?;
+        input = &input[consumed..];
+        if kind == ADDRESS_REQUEST && request_id == 0 {
+            return Err(invalid());
+        }
+        let family = take(&mut input, 1)?[0];
+        let address = read_address(&mut input, family)?;
+        let prefix_len = take(&mut input, 1)?[0];
+        let (bits, value) = match address {
+            IpAddr::V4(address) => (32, u128::from(u32::from(address))),
+            IpAddr::V6(address) => (128, u128::from(address)),
+        };
+        if usize::from(prefix_len) > bits {
+            return Err(invalid());
+        }
+        let host_bits = bits - usize::from(prefix_len);
+        let host_mask = if host_bits == 128 {
+            u128::MAX
+        } else {
+            (1u128 << host_bits) - 1
+        };
+        if value & host_mask != 0 {
+            return Err(invalid());
+        }
+        prefixes.push(AddressPrefix {
+            request_id,
+            address,
+            prefix_len,
+        });
+    }
+    Ok(prefixes)
+}
+
+/// Retain each route as advertised. The frozen reference consumer checks
+/// individual ranges, without imposing an additional cross-entry ordering.
+pub(crate) fn parse_routes(mut input: &[u8], max_entries: usize) -> io::Result<Vec<Route>> {
+    let mut routes = Vec::new();
+    while !input.is_empty() {
+        if routes.len() >= max_entries {
+            return Err(invalid());
+        }
+        let family = take(&mut input, 1)?[0];
+        let start = read_address(&mut input, family)?;
+        let end = read_address(&mut input, family)?;
+        if start > end {
+            return Err(invalid());
+        }
+        let protocol = take(&mut input, 1)?[0];
+        routes.push(Route {
+            start,
+            end,
+            protocol,
+        });
+    }
+    Ok(routes)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn masque_varint_and_h3_datagram_wire_vectors_preserve_actual_stream_association() {
+        for (value, expected) in [
+            (37, vec![0x25]),
+            (15_293, vec![0x7b, 0xbd]),
+            (494_878_333, vec![0x9d, 0x7f, 0x3e, 0x7d]),
+            (
+                151_288_809_941_952_652,
+                vec![0xc2, 0x19, 0x7c, 0x5e, 0xff, 0x14, 0xe8, 0x8c],
+            ),
+        ] {
+            let mut encoded = Vec::new();
+            encode_varint(value, &mut encoded).unwrap();
+            assert_eq!(encoded, expected);
+            for prefix in 0..expected.len() {
+                assert!(decode_varint(&expected[..prefix]).unwrap().is_none());
+            }
+            assert_eq!(
+                decode_varint(&expected).unwrap(),
+                Some((value, expected.len()))
+            );
+        }
+        assert!(encode_varint(1 << 62, &mut Vec::new()).is_err());
+        let framed = encode_h3_datagram(256, b"udp", 6).unwrap();
+        assert_eq!(framed.as_ref(), &[0x40, 0x40, 0, b'u', b'd', b'p']);
+        assert_eq!(decode_h3_datagram(&framed, 256, 6).unwrap(), b"udp");
+        assert!(decode_h3_datagram(&framed, 252, 6).is_err());
+        assert!(encode_h3_datagram(1, b"", 8).is_err());
+        assert!(encode_h3_datagram(256, b"udp", 5).is_err());
+        assert_eq!(decode_h3_datagram(&[0x40, 0, 0x40, 0], 0, 4).unwrap(), b"");
+        assert!(decode_h3_datagram(&[0, 1], 0, 2).is_err());
+        assert!(decode_h3_datagram(&[0xff; 8], 0, 8).is_err());
+    }
+
+    #[test]
+    fn masque_capsule_incremental_split_coalesced_and_unknown_skip_stay_bounded() {
+        let mut encoded = encode_capsule(64, &[0xaa; 64], 64).unwrap().to_vec();
+        encoded.extend_from_slice(&encode_capsule(DATAGRAM, &[0, 0xde, 0xad], 64).unwrap());
+        encoded.extend_from_slice(&encode_capsule(ADDRESS_ASSIGN, b"", 64).unwrap());
+        for split in 1..encoded.len() {
+            let mut decoder = CapsuleDecoder::new(64);
+            let mut received = Vec::new();
+            for chunk in encoded.chunks(split) {
+                let mut input = chunk;
+                while !input.is_empty() {
+                    let (consumed, capsule) = decoder.feed(input).unwrap();
+                    assert!(consumed > 0);
+                    input = &input[consumed..];
+                    if let Some(capsule) = capsule {
+                        received.push(capsule);
+                    }
+                    assert!(decoder.value.capacity() <= 64);
+                }
+            }
+            decoder.finish().unwrap();
+            assert_eq!(received.len(), 2);
+            assert_eq!(received[0].kind, DATAGRAM);
+            assert_eq!(received[0].value.as_ref(), &[0, 0xde, 0xad]);
+            assert_eq!(received[1].kind, ADDRESS_ASSIGN);
+            assert!(received[1].value.is_empty());
+        }
+        let mut decoder = CapsuleDecoder::new(63);
+        assert!(decoder.feed(&encoded).is_err());
+        assert_eq!(decoder.value.capacity(), 0);
+        assert!(decoder.feed(&[0, 0]).is_err());
+        let mut decoder = CapsuleDecoder::new(64);
+        decoder.feed(&[0, 3, 0]).unwrap();
+        assert_eq!(
+            decoder.finish().unwrap_err().kind(),
+            io::ErrorKind::UnexpectedEof
+        );
+    }
+
+    #[test]
+    fn masque_control_capsules_preserve_both_families_rejections_and_route_protocols() {
+        // RFC9484 entries: unsolicited IPv4 /24, requested IPv6 /128 rejection.
+        let mut addresses = vec![0, 4, 192, 0, 2, 0, 24, 7, 6];
+        addresses.extend_from_slice(&[0; 16]);
+        addresses.push(128);
+        let assigned = parse_addresses(ADDRESS_ASSIGN, &addresses, 2).unwrap();
+        assert_eq!(assigned.len(), 2);
+        assert_eq!(assigned[0].address, IpAddr::V4(Ipv4Addr::new(192, 0, 2, 0)));
+        assert_eq!(assigned[1].request_id, 7);
+        assert_eq!(assigned[1].prefix_len, 128);
+        assert!(assigned[1].address.is_unspecified());
+        assert!(parse_addresses(ADDRESS_ASSIGN, &addresses, 1).is_err());
+        assert!(parse_addresses(ADDRESS_REQUEST, &addresses, 2).is_err());
+        assert!(parse_addresses(ADDRESS_REQUEST, b"", 2).is_err());
+        assert!(parse_addresses(ADDRESS_ASSIGN, &[0, 4, 192, 0, 2, 1, 24], 2).is_err());
+        assert!(parse_addresses(ADDRESS_REQUEST, &[1, 4, 0, 0, 0, 0, 32], 1).is_ok());
+        let routes = [4, 192, 0, 2, 1, 192, 0, 2, 9, 17];
+        let decoded = parse_routes(&routes, 1).unwrap();
+        assert_eq!(decoded[0].protocol, 17);
+        assert!(parse_routes(&routes[..8], 1).is_err());
+        assert!(parse_routes(&[4, 192, 0, 2, 9, 192, 0, 2, 1, 0], 1).is_err());
+        assert!(parse_routes(b"", 0).unwrap().is_empty());
+    }
+
+    #[cfg(feature = "outbound-masque")]
+    #[test]
+    fn masque_capsule_append_fit_and_rejection_preserve_the_existing_wire_prefix() {
+        let mut wire = vec![0, 1, 0xaa];
+        let prefix = wire.clone();
+        assert!(!try_append_capsule(DATAGRAM, &[0xbb, 0xcc], 2, &mut wire, 6).unwrap());
+        assert_eq!(wire, prefix);
+        assert!(try_append_capsule(DATAGRAM, &[0xbb, 0xcc], 2, &mut wire, 7).unwrap());
+        assert_eq!(wire, [0, 1, 0xaa, 0, 2, 0xbb, 0xcc]);
+        let prefix = wire.clone();
+        assert!(try_append_capsule(MAX_VARINT + 1, b"", 2, &mut wire, 64).is_err());
+        assert_eq!(wire, prefix);
+        assert!(try_append_capsule(DATAGRAM, &[0; 3], 2, &mut wire, 64).is_err());
+        assert_eq!(wire, prefix);
+        let mut decoder = CapsuleDecoder::new(2);
+        let mut input = wire.as_slice();
+        let mut values = Vec::new();
+        while !input.is_empty() {
+            let (consumed, capsule) = decoder.feed(input).unwrap();
+            assert!(consumed > 0);
+            input = &input[consumed..];
+            if let Some(capsule) = capsule {
+                assert_eq!(capsule.kind, DATAGRAM);
+                values.push(capsule.value);
+            }
+        }
+        decoder.finish().unwrap();
+        assert_eq!(
+            values,
+            [
+                Bytes::from_static(&[0xaa]),
+                Bytes::from_static(&[0xbb, 0xcc])
+            ]
+        );
+    }
+}
diff --git a/src/transport/mod.rs b/src/transport/mod.rs
index 703ae48..e1c9b98 100644
--- a/src/transport/mod.rs
+++ b/src/transport/mod.rs
@@ -1,6 +1,20 @@
 //! Outbound wire transports.
+#[cfg(any(feature = "sing-mux", feature = "outbound-shadowsocks"))]
+pub(crate) mod smux;
+#[cfg(feature = "outbound-shadowsocks")]
+pub(crate) mod ss_framed;
 
-#[cfg(feature = "outbound-vless")]
+#[cfg(feature = "quinn-h3-transport")]
+pub(crate) mod quinn_h3;
+
+#[cfg(feature = "quiche-h3-transport")]
+pub(crate) mod quiche_h3;
+
+#[cfg(any(feature = "outbound-trusttunnel", feature = "outbound-masque"))]
+pub(crate) mod h3_connect;
+#[cfg(feature = "outbound-masque")]
+pub(crate) mod masque_codec;
+#[cfg(feature = "sing-mux")]
 pub(crate) mod sing_mux;
 #[cfg(feature = "outbound-vless")]
 pub mod xhttp;
@@ -26,6 +40,8 @@ mod grpc;
 #[cfg(feature = "stream-transport")]
 mod grpc_pool;
 #[cfg(feature = "stream-transport")]
+mod h2_empty;
+#[cfg(feature = "stream-transport")]
 mod h2_write;
 #[cfg(feature = "stream-transport")]
 pub use grpc::{Driver as StreamDriver, grpc, grpc_duplex, legacy_h2};
diff --git a/src/transport/quic.rs b/src/transport/quic.rs
index 3d7f587..58644be 100644
--- a/src/transport/quic.rs
+++ b/src/transport/quic.rs
@@ -3,6 +3,20 @@
 mod runtime;
 pub(crate) use runtime::OwnedRuntime;
 
+#[cfg(all(
+    target_os = "linux",
+    any(feature = "outbound-tuic", feature = "quinn-h3-transport")
+))]
+mod linux_udp;
+#[cfg(all(
+    target_os = "linux",
+    any(feature = "outbound-tuic", feature = "quinn-h3-transport")
+))]
+mod physical;
+mod policy;
+pub(crate) use policy::datagram_payload_limit;
+pub use policy::{RECEIVE_WINDOW_POLICY, ReceiveWindowPolicy, configure_receive_windows};
+
 use std::{
     collections::VecDeque,
     io::{self, IoSliceMut},
@@ -63,6 +77,7 @@ impl Shared {
         drop(state);
         self.reader.wake();
         self.writer.wake();
+        self.changed.notify_waiters();
     }
 }
 
@@ -71,6 +86,11 @@ pub struct DatagramSocket {
     peer: SocketAddr,
     budget: DatagramBudget,
     shared: Arc<Shared>,
+    #[cfg(all(
+        target_os = "linux",
+        any(feature = "outbound-tuic", feature = "quinn-h3-transport")
+    ))]
+    physical: Option<Box<physical::Socket>>,
 }
 
 impl std::fmt::Debug for DatagramSocket {
@@ -82,6 +102,24 @@ impl std::fmt::Debug for DatagramSocket {
 }
 
 impl DatagramSocket {
+    #[cfg(any(feature = "outbound-tuic", feature = "quinn-h3-transport"))]
+    pub(crate) fn configure_transport(&self, limits: &mut quinn::TransportConfig) {
+        #[cfg(all(
+            target_os = "linux",
+            any(feature = "outbound-tuic", feature = "quinn-h3-transport")
+        ))]
+        let enabled = self
+            .physical
+            .as_ref()
+            .is_some_and(|socket| socket.transmit_segments() > 1);
+        #[cfg(not(all(
+            target_os = "linux",
+            any(feature = "outbound-tuic", feature = "quinn-h3-transport")
+        )))]
+        let enabled = false;
+        limits.enable_segmentation_offload(enabled);
+    }
+
     /// The endpoint must configure its QUIC MTU no larger than this budget.
     pub fn budget(&self) -> DatagramBudget {
         self.budget
@@ -90,12 +128,58 @@ impl DatagramSocket {
     pub fn stats(&self) -> Stats {
         self.shared.state.lock().unwrap().stats
     }
+
+    /// Transfers one validated packet to an owner which can consume storage.
+    /// The borrowed AsyncUdpSocket path remains available to other engines.
+    #[cfg(feature = "quiche-h3-transport")]
+    pub(crate) fn poll_recv_owned(&self, cx: &mut Context<'_>) -> Poll<io::Result<Bytes>> {
+        let mut state = self.shared.state.lock().unwrap();
+        if state.closed {
+            return Poll::Ready(Err(state.error.unwrap_or(io::ErrorKind::BrokenPipe).into()));
+        }
+        let was_full = state.incoming.len() == QUEUE_LIMIT;
+        let Some(payload) = state.incoming.pop_front() else {
+            self.shared.reader.register(cx.waker());
+            return Poll::Pending;
+        };
+        drop(state);
+        if was_full {
+            self.shared.changed.notify_one();
+        }
+        Poll::Ready(Ok(payload))
+    }
+
+    /// Waits for previously enqueued packets to pass the controlled transport.
+    /// This is local IO progress, not acknowledgement by the QUIC peer.
+    pub(crate) fn poll_transmitted(
+        &self,
+        cx: &mut Context<'_>,
+        count: usize,
+    ) -> Poll<io::Result<()>> {
+        let state = self.shared.state.lock().unwrap();
+        if state.closed {
+            return Poll::Ready(Err(state.error.unwrap_or(io::ErrorKind::BrokenPipe).into()));
+        }
+        if state.stats.sent >= count {
+            Poll::Ready(Ok(()))
+        } else {
+            // Progress is published under the same lock, so register only
+            // the blocked operation without a gap for a lost notification.
+            self.shared.writer.register(cx.waker());
+            Poll::Pending
+        }
+    }
 }
 
 pub struct DatagramDriver {
     shared: Arc<Shared>,
     cancel: CancellationToken,
     task: Option<JoinHandle<io::Result<()>>>,
+    #[cfg(all(
+        target_os = "linux",
+        any(feature = "outbound-tuic", feature = "quinn-h3-transport")
+    ))]
+    physical: Option<physical::Retirement>,
 }
 
 impl DatagramDriver {
@@ -120,12 +204,103 @@ impl Drop for DatagramDriver {
     fn drop(&mut self) {
         self.cancel.cancel();
         self.shared.finish(None);
+        #[cfg(all(
+            target_os = "linux",
+            any(feature = "outbound-tuic", feature = "quinn-h3-transport")
+        ))]
+        if let Some(physical) = &self.physical {
+            physical.retire();
+        }
         if let Some(task) = self.task.take() {
             task.abort();
         }
     }
 }
 
+/// Protected physical IO remains owned by its original transport and Dialer.
+/// This lease does not provide another socket factory or expose descriptor IO.
+#[cfg(all(
+    target_os = "linux",
+    any(feature = "outbound-tuic", feature = "quinn-h3-transport")
+))]
+#[doc(hidden)]
+pub struct PhysicalQuicLease {
+    pub(crate) socket: Arc<crate::dialer::PhysicalDatagram>,
+    pub(crate) settings: crate::config::QuicSocketSettings,
+}
+
+#[cfg(any(feature = "outbound-tuic", feature = "quinn-h3-transport"))]
+pub(crate) async fn attach_quinn(
+    transport: Box<dyn DatagramTransport>,
+    peer: SocketAddr,
+    budget: DatagramBudget,
+) -> io::Result<(Arc<DatagramSocket>, DatagramDriver)> {
+    #[cfg(all(
+        target_os = "linux",
+        any(feature = "outbound-tuic", feature = "quinn-h3-transport")
+    ))]
+    let mut transport = transport;
+    if peer.port() == 0 || peer.ip().is_unspecified() || peer.ip().is_multicast() {
+        return Err(io::ErrorKind::InvalidInput.into());
+    }
+    let budget = budget.intersect(transport.payload_budget(&Destination::Ip(peer)));
+    budget.quic_payload_limit()?;
+    #[cfg(all(
+        target_os = "linux",
+        any(feature = "outbound-tuic", feature = "quinn-h3-transport")
+    ))]
+    if let Some(lease) = transport
+        .lease_quic_socket(peer)
+        .await
+        .map_err(dispatch_error)?
+    {
+        let shared = Arc::new(Shared::default());
+        let physical = match physical::Socket::new(lease, peer, budget, shared.clone()) {
+            Ok(Some(socket)) => socket,
+            // Optional receive-ECN metadata is unavailable. Retain this same
+            // protected transport and its original bounded packet path.
+            Ok(None) => return attach(transport, peer, budget),
+            Err(error) => {
+                let _ = tokio::time::timeout(CLOSE_TIMEOUT, transport.close()).await;
+                return Err(error);
+            }
+        };
+        let retirement = physical.retirement();
+        let task_retirement = retirement.clone();
+        let socket = Arc::new(DatagramSocket {
+            peer,
+            budget,
+            shared: shared.clone(),
+            physical: Some(Box::new(physical)),
+        });
+        let cancel = CancellationToken::new();
+        let task_cancel = cancel.clone();
+        let task_shared = shared.clone();
+        let task = crate::resources::observation::spawn(async move {
+            // The native endpoint directly polls the same protected socket;
+            // no packet queue, auxiliary receive pump, or keepalive is added.
+            task_cancel.cancelled().await;
+            task_shared.finish(None);
+            task_retirement.retire();
+            let result = tokio::time::timeout(CLOSE_TIMEOUT, transport.close()).await;
+            drop(transport);
+            result
+                .map_err(|_| io::ErrorKind::TimedOut)?
+                .map_err(dispatch_error)
+        });
+        return Ok((
+            socket,
+            DatagramDriver {
+                shared,
+                cancel,
+                task: Some(task),
+                physical: Some(retirement),
+            },
+        ));
+    }
+    attach(transport, peer, budget)
+}
+
 pub fn attach(
     transport: Box<dyn DatagramTransport>,
     peer: SocketAddr,
@@ -155,6 +330,11 @@ pub fn attach_mapped(
         peer: logical_peer,
         budget,
         shared: shared.clone(),
+        #[cfg(all(
+            target_os = "linux",
+            any(feature = "outbound-tuic", feature = "quinn-h3-transport")
+        ))]
+        physical: None,
     });
     let cancel = CancellationToken::new();
     let task_shared = shared.clone();
@@ -183,6 +363,11 @@ pub fn attach_mapped(
             shared,
             cancel,
             task: Some(task),
+            #[cfg(all(
+                target_os = "linux",
+                any(feature = "outbound-tuic", feature = "quinn-h3-transport")
+            ))]
+            physical: None,
         },
     ))
 }
@@ -195,12 +380,31 @@ async fn drive(
     cancel: &CancellationToken,
 ) -> io::Result<()> {
     let mut has_sent = false;
+    let mut receive_scratch = Vec::new();
+    let mut pending_send: Option<crate::dispatch::OwnedDatagramSend> = None;
     loop {
-        let can_receive = shared.state.lock().unwrap().incoming.len() < QUEUE_LIMIT;
+        let (can_receive, can_send) = {
+            let state = shared.state.lock().unwrap();
+            (
+                state.incoming.len() < QUEUE_LIMIT,
+                pending_send.is_none() && !state.outgoing.is_empty(),
+            )
+        };
         tokio::select! {
             _ = cancel.cancelled() => return Ok(()),
             _ = shared.changed.notified() => {},
-            received = transport.receive(), if has_sent && can_receive => {
+            sent = async { pending_send.as_mut().expect("owned send branch").as_mut().await }, if pending_send.is_some() => {
+                sent.map_err(dispatch_error)?;
+                pending_send.take();
+                has_sent = true;
+                let mut state = shared.state.lock().unwrap();
+                state.stats.sent += 1;
+                shared.writer.wake();
+            },
+            // Notify permits coalesce. A producer may have queued several
+            // packets before this owner runs, so queued TX is itself ready.
+            _ = std::future::ready(()), if can_send => {},
+            received = receive_packet(transport, &mut receive_scratch), if has_sent && can_receive => {
                 let datagram = received.map_err(dispatch_error)?;
                 let mut state = shared.state.lock().unwrap();
                 if datagram.remote != Destination::Ip(peer) {
@@ -223,23 +427,46 @@ async fn drive(
                 }
             }
         }
-        let payload = shared.state.lock().unwrap().outgoing.pop_front();
-        if let Some(payload) = payload {
-            shared.writer.wake();
-            tokio::select! {
-                _ = cancel.cancelled() => return Ok(()),
-                sent = transport.send(Datagram { remote: Destination::Ip(peer), payload, sniffed_domain: None }) => sent.map_err(dispatch_error)?,
-            }
-            has_sent = true;
-            let mut state = shared.state.lock().unwrap();
-            state.stats.sent += 1;
-            if !state.outgoing.is_empty() {
-                shared.changed.notify_one();
+        if pending_send.is_none() {
+            let payload = shared.state.lock().unwrap().outgoing.pop_front();
+            if let Some(payload) = payload {
+                shared.writer.wake();
+                let packet = Datagram {
+                    remote: Destination::Ip(peer),
+                    payload,
+                    sniffed_domain: None,
+                };
+                match transport.send_owned(packet) {
+                    Ok(send) => pending_send = Some(send),
+                    Err(packet) => {
+                        // An upstream without an owned path keeps its existing
+                        // cancellation-safe send; never open another socket.
+                        tokio::select! {
+                            _ = cancel.cancelled() => return Ok(()),
+                            sent = transport.send(packet) => sent.map_err(dispatch_error)?,
+                        }
+                        has_sent = true;
+                        let mut state = shared.state.lock().unwrap();
+                        state.stats.sent += 1;
+                        shared.writer.wake();
+                    }
+                }
             }
         }
     }
 }
 
+async fn receive_packet(
+    transport: &mut dyn DatagramTransport,
+    scratch: &mut Vec<u8>,
+) -> Result<Datagram, DispatchError> {
+    if transport.supports_poll_receive() {
+        std::future::poll_fn(|context| transport.poll_receive(context, scratch)).await
+    } else {
+        transport.receive().await
+    }
+}
+
 fn dispatch_error(error: DispatchError) -> io::Error {
     match error {
         DispatchError::NotAllowed => io::ErrorKind::PermissionDenied,
@@ -259,7 +486,6 @@ impl std::fmt::Debug for PacketPoller {
 
 impl UdpPoller for PacketPoller {
     fn poll_writable(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        self.0.writer.register(cx.waker());
         let state = self.0.state.lock().unwrap();
         if state.closed {
             return Poll::Ready(Err(state.error.unwrap_or(io::ErrorKind::BrokenPipe).into()));
@@ -267,6 +493,7 @@ impl UdpPoller for PacketPoller {
         if state.outgoing.len() < QUEUE_LIMIT {
             Poll::Ready(Ok(()))
         } else {
+            self.0.writer.register(cx.waker());
             Poll::Pending
         }
     }
@@ -274,10 +501,24 @@ impl UdpPoller for PacketPoller {
 
 impl AsyncUdpSocket for DatagramSocket {
     fn create_io_poller(self: Arc<Self>) -> Pin<Box<dyn UdpPoller>> {
+        #[cfg(all(
+            target_os = "linux",
+            any(feature = "outbound-tuic", feature = "quinn-h3-transport")
+        ))]
+        if let Some(socket) = &self.physical {
+            return socket.create_io_poller();
+        }
         Box::pin(PacketPoller(self.shared.clone()))
     }
 
     fn try_send(&self, transmit: &quinn::udp::Transmit<'_>) -> io::Result<()> {
+        #[cfg(all(
+            target_os = "linux",
+            any(feature = "outbound-tuic", feature = "quinn-h3-transport")
+        ))]
+        if let Some(socket) = &self.physical {
+            return socket.try_send(transmit);
+        }
         if transmit.destination != self.peer
             || transmit.contents.len() > usize::from(self.budget.transmit())
             || transmit.segment_size.is_some()
@@ -292,6 +533,7 @@ impl AsyncUdpSocket for DatagramSocket {
         if state.outgoing.len() == QUEUE_LIMIT {
             return Err(io::ErrorKind::WouldBlock.into());
         }
+        let was_empty = state.outgoing.is_empty();
         state
             .outgoing
             .push_back(Bytes::copy_from_slice(transmit.contents));
@@ -302,7 +544,9 @@ impl AsyncUdpSocket for DatagramSocket {
             QUEUE_LIMIT,
         );
         drop(state);
-        self.shared.changed.notify_one();
+        if was_empty {
+            self.shared.changed.notify_one();
+        }
         Ok(())
     }
 
@@ -312,32 +556,63 @@ impl AsyncUdpSocket for DatagramSocket {
         buffers: &mut [IoSliceMut<'_>],
         meta: &mut [quinn::udp::RecvMeta],
     ) -> Poll<io::Result<usize>> {
-        self.shared.reader.register(cx.waker());
+        #[cfg(all(
+            target_os = "linux",
+            any(feature = "outbound-tuic", feature = "quinn-h3-transport")
+        ))]
+        if let Some(socket) = &self.physical {
+            return socket.poll_recv(cx, buffers, meta);
+        }
         let mut state = self.shared.state.lock().unwrap();
         if state.closed {
             return Poll::Ready(Err(state.error.unwrap_or(io::ErrorKind::BrokenPipe).into()));
         }
         let Some(payload) = state.incoming.front() else {
+            self.shared.reader.register(cx.waker());
             return Poll::Pending;
         };
         if buffers.is_empty() || meta.is_empty() || buffers[0].len() < payload.len() {
             return Poll::Ready(Err(io::ErrorKind::InvalidInput.into()));
         }
-        buffers[0][..payload.len()].copy_from_slice(payload);
-        meta[0] = quinn::udp::RecvMeta {
-            addr: self.peer,
-            len: payload.len(),
-            stride: payload.len(),
-            ecn: None,
-            dst_ip: None,
-        };
-        state.incoming.pop_front();
-        // Resume the single transport owner when the consumer frees capacity.
-        self.shared.changed.notify_one();
-        Poll::Ready(Ok(1))
+        let was_full = state.incoming.len() == QUEUE_LIMIT;
+        let mut received = 0;
+        for (buffer, metadata) in buffers.iter_mut().zip(meta.iter_mut()) {
+            let Some(payload) = state.incoming.front() else {
+                break;
+            };
+            // A short later buffer must not discard a packet or hide the
+            // packets already copied into the caller's batch.
+            if buffer.len() < payload.len() {
+                break;
+            }
+            buffer[..payload.len()].copy_from_slice(payload);
+            *metadata = quinn::udp::RecvMeta {
+                addr: self.peer,
+                len: payload.len(),
+                stride: payload.len(),
+                ecn: None,
+                dst_ip: None,
+            };
+            state.incoming.pop_front();
+            received += 1;
+        }
+        drop(state);
+        // Only a full queue suppresses the owner's physical receive. Other
+        // consumption must leave its already pending receive undisturbed.
+        if was_full {
+            self.shared.changed.notify_one();
+        }
+        Poll::Ready(Ok(received))
     }
 
     fn local_addr(&self) -> io::Result<SocketAddr> {
+        #[cfg(all(
+            target_os = "linux",
+            any(feature = "outbound-tuic", feature = "quinn-h3-transport")
+        ))]
+        if let Some(socket) = &self.physical {
+            return socket.local_addr();
+        }
         // Logical socket metadata only. Vole's public datagram transport owns
         // physical sockets and intentionally does not expose their bound ports.
         Ok(if self.peer.is_ipv4() {
@@ -350,6 +625,796 @@ impl AsyncUdpSocket for DatagramSocket {
     }
 
     fn may_fragment(&self) -> bool {
+        #[cfg(all(
+            target_os = "linux",
+            any(feature = "outbound-tuic", feature = "quinn-h3-transport")
+        ))]
+        if let Some(socket) = &self.physical {
+            return socket.may_fragment();
+        }
         false
     }
+    fn max_transmit_segments(&self) -> usize {
+        #[cfg(all(
+            target_os = "linux",
+            any(feature = "outbound-tuic", feature = "quinn-h3-transport")
+        ))]
+        if let Some(socket) = &self.physical {
+            return socket.transmit_segments();
+        }
+        1
+    }
+    // GRO is explicitly disabled on the native owned socket. Keep the same
+    // per-datagram receive allocation and packet boundaries on every path.
+    fn max_receive_segments(&self) -> usize {
+        1
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    struct Sink {
+        sent: Arc<AtomicUsize>,
+        changed: Arc<Notify>,
+    }
+    #[async_trait::async_trait]
+    impl DatagramTransport for Sink {
+        fn supports_shared_destinations(&self) -> bool {
+            false
+        }
+
+        async fn send(&mut self, _: Datagram) -> Result<(), DispatchError> {
+            self.sent.fetch_add(1, Ordering::AcqRel);
+            self.changed.notify_one();
+            Ok(())
+        }
+        async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+            std::future::pending().await
+        }
+    }
+    #[tokio::test]
+    async fn quic_memory_coalesced_notifications_drain_all_queued_packets_without_rx() {
+        let sent = Arc::new(AtomicUsize::new(0));
+        let changed = Arc::new(Notify::new());
+        let peer = "192.0.2.1:443".parse().unwrap();
+        let (socket, driver) = attach(
+            Box::new(Sink {
+                sent: sent.clone(),
+                changed: changed.clone(),
+            }),
+            peer,
+            DatagramBudget::new(1400, 1400),
+        )
+        .unwrap();
+        // No await until all notifications have coalesced. The peer never
+        // replies, so queued output must itself keep the owner runnable.
+        for _ in 0..16 {
+            socket
+                .try_send(&quinn::udp::Transmit {
+                    destination: peer,
+                    ecn: None,
+                    contents: b"packet",
+                    segment_size: None,
+                    src_ip: None,
+                })
+                .unwrap();
+        }
+        let result = tokio::time::timeout(std::time::Duration::from_secs(1), async {
+            while sent.load(Ordering::Acquire) < 16 {
+                changed.notified().await;
+            }
+        })
+        .await;
+        driver.stop().await.unwrap();
+        assert!(result.is_ok());
+        assert_eq!(sent.load(Ordering::Acquire), 16);
+    }
+}
+
+#[cfg(test)]
+mod pending_waker_tests {
+    use super::*;
+    use std::{
+        future::Future,
+        sync::atomic::{AtomicUsize, Ordering},
+        task::{Wake, Waker},
+        time::Duration,
+    };
+    use tokio::sync::{Semaphore, mpsc};
+
+    #[derive(Default)]
+    struct Count(AtomicUsize);
+    impl Wake for Count {
+        fn wake(self: Arc<Self>) {
+            self.0.fetch_add(1, Ordering::Relaxed);
+        }
+        fn wake_by_ref(self: &Arc<Self>) {
+            self.0.fetch_add(1, Ordering::Relaxed);
+        }
+    }
+    impl Count {
+        fn get(&self) -> usize {
+            self.0.load(Ordering::Relaxed)
+        }
+    }
+    struct Carrier {
+        input: mpsc::Receiver<Datagram>,
+        credit: Arc<Semaphore>,
+        starts: Arc<AtomicUsize>,
+        reads: Arc<AtomicUsize>,
+        closed: Arc<AtomicUsize>,
+        leases: Arc<AtomicUsize>,
+        owned: bool,
+        polled: bool,
+    }
+    struct SendLease(Arc<AtomicUsize>);
+    impl Drop for SendLease {
+        fn drop(&mut self) {
+            self.0.fetch_sub(1, Ordering::Relaxed);
+        }
+    }
+    #[async_trait::async_trait]
+    impl DatagramTransport for Carrier {
+        fn supports_shared_destinations(&self) -> bool {
+            false
+        }
+
+        fn supports_poll_receive(&self) -> bool {
+            self.polled
+        }
+        fn poll_receive(
+            &mut self,
+            context: &mut Context<'_>,
+            _: &mut Vec<u8>,
+        ) -> Poll<Result<Datagram, DispatchError>> {
+            self.reads.fetch_add(1, Ordering::Relaxed);
+            self.input
+                .poll_recv(context)
+                .map(|packet| packet.ok_or(DispatchError::ConnectionRefused))
+        }
+        fn send_owned(
+            &mut self,
+            datagram: Datagram,
+        ) -> Result<crate::dispatch::OwnedDatagramSend, Datagram> {
+            if !self.owned {
+                return Err(datagram);
+            }
+            let starts = self.starts.clone();
+            let credit = self.credit.clone();
+            self.leases.fetch_add(1, Ordering::Relaxed);
+            let lease = SendLease(self.leases.clone());
+            Ok(Box::pin(async move {
+                let _lease = lease;
+                starts.fetch_add(1, Ordering::Relaxed);
+                credit
+                    .acquire_owned()
+                    .await
+                    .map_err(|_| DispatchError::ConnectionRefused)?
+                    .forget();
+                Ok(())
+            }))
+        }
+        async fn send(&mut self, _: Datagram) -> Result<(), DispatchError> {
+            self.starts.fetch_add(1, Ordering::Relaxed);
+            self.credit
+                .acquire()
+                .await
+                .map_err(|_| DispatchError::ConnectionRefused)?
+                .forget();
+            Ok(())
+        }
+        async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+            assert!(
+                !self.polled,
+                "polled carrier used boxed asynchronous receive"
+            );
+            self.reads.fetch_add(1, Ordering::Relaxed);
+            self.input
+                .recv()
+                .await
+                .ok_or(DispatchError::ConnectionRefused)
+        }
+        async fn close(&mut self) -> Result<(), DispatchError> {
+            assert_eq!(
+                self.leases.load(Ordering::Relaxed),
+                0,
+                "physical send survived close"
+            );
+            self.closed.fetch_add(1, Ordering::Relaxed);
+            Ok(())
+        }
+    }
+    struct Fixture {
+        socket: Arc<DatagramSocket>,
+        driver: DatagramDriver,
+        input: mpsc::Sender<Datagram>,
+        credit: Arc<Semaphore>,
+        starts: Arc<AtomicUsize>,
+        reads: Arc<AtomicUsize>,
+        closed: Arc<AtomicUsize>,
+        leases: Arc<AtomicUsize>,
+        peer: SocketAddr,
+    }
+    fn fixture(gated: bool) -> io::Result<Fixture> {
+        fixture_mode(gated, false)
+    }
+    fn fixture_mode(gated: bool, owned: bool) -> io::Result<Fixture> {
+        fixture_polled(gated, owned, false)
+    }
+    fn fixture_polled(gated: bool, owned: bool, polled: bool) -> io::Result<Fixture> {
+        let (input, receive) = mpsc::channel(64);
+        let credit = Arc::new(Semaphore::new(if gated { 0 } else { 64 }));
+        let starts = Arc::new(AtomicUsize::new(0));
+        let reads = Arc::new(AtomicUsize::new(0));
+        let closed = Arc::new(AtomicUsize::new(0));
+        let leases = Arc::new(AtomicUsize::new(0));
+        let peer = "192.0.2.1:443".parse().unwrap();
+        let (socket, driver) = attach(
+            Box::new(Carrier {
+                input: receive,
+                credit: credit.clone(),
+                starts: starts.clone(),
+                reads: reads.clone(),
+                closed: closed.clone(),
+                leases: leases.clone(),
+                owned,
+                polled,
+            }),
+            peer,
+            DatagramBudget::new(1400, 1400),
+        )?;
+        Ok(Fixture {
+            socket,
+            driver,
+            input,
+            credit,
+            starts,
+            reads,
+            closed,
+            leases,
+            peer,
+        })
+    }
+    fn send(fixture: &Fixture) -> io::Result<()> {
+        fixture.socket.try_send(&quinn::udp::Transmit {
+            destination: fixture.peer,
+            ecn: None,
+            contents: b"outbound",
+            segment_size: None,
+            src_ip: None,
+        })
+    }
+    fn inject(fixture: &Fixture, payload: &'static [u8]) -> io::Result<()> {
+        fixture
+            .input
+            .try_send(Datagram {
+                remote: Destination::Ip(fixture.peer),
+                payload: Bytes::from_static(payload),
+                sniffed_domain: None,
+            })
+            .map_err(|_| io::Error::from(io::ErrorKind::BrokenPipe))
+    }
+    async fn wait_for(mut condition: impl FnMut() -> bool) -> io::Result<()> {
+        tokio::time::timeout(Duration::from_secs(1), async {
+            while !condition() {
+                tokio::task::yield_now().await;
+            }
+        })
+        .await
+        .map_err(|_| io::ErrorKind::TimedOut.into())
+    }
+    fn ready<T>(poll: Poll<io::Result<T>>) -> io::Result<T> {
+        match poll {
+            Poll::Ready(result) => result,
+            Poll::Pending => Err(io::ErrorKind::WouldBlock.into()),
+        }
+    }
+    #[tokio::test]
+    async fn quic_memory_owned_send_keeps_receive_live_while_physical_write_waits() {
+        let fixture = fixture_mode(true, true).unwrap();
+        let result = async {
+            fixture.credit.add_permits(1);
+            send(&fixture)?;
+            wait_for(|| fixture.socket.stats().sent == 1).await?;
+            send(&fixture)?;
+            wait_for(|| fixture.starts.load(Ordering::Relaxed) == 2).await?;
+            inject(&fixture, b"reply while write waits")?;
+            wait_for(|| fixture.socket.stats().received == 1).await?;
+            let completed_while_blocked = fixture.socket.stats().sent;
+            fixture.credit.add_permits(1);
+            wait_for(|| fixture.socket.stats().sent == 2).await?;
+            Ok::<_, io::Error>(completed_while_blocked)
+        }
+        .await;
+        fixture.driver.stop().await.unwrap();
+        assert_eq!(fixture.closed.load(Ordering::Relaxed), 1);
+        assert_eq!(fixture.leases.load(Ordering::Relaxed), 0);
+        assert_eq!(fixture.starts.load(Ordering::Relaxed), 2);
+        assert_eq!(
+            result.expect("blocked physical send hid a ready receive"),
+            1
+        );
+    }
+    #[tokio::test]
+    async fn quic_memory_uses_polled_carrier_without_boxed_receive() {
+        let fixture = fixture_polled(false, true, true).unwrap();
+        let result = async {
+            send(&fixture)?;
+            wait_for(|| fixture.socket.stats().sent == 1).await?;
+            inject(&fixture, b"polled reply")?;
+            wait_for(|| fixture.socket.stats().received == 1).await
+        }
+        .await;
+        let stopped = fixture.driver.stop().await;
+        result.unwrap();
+        stopped.unwrap();
+        assert_eq!(fixture.closed.load(Ordering::Relaxed), 1);
+        assert!(fixture.reads.load(Ordering::Relaxed) > 0);
+    }
+    #[tokio::test]
+    async fn quic_memory_receive_batches_ready_packets_in_order() {
+        let fixture = fixture(false).unwrap();
+        let waker = Waker::from(Arc::new(Count::default()));
+        let result = async {
+            send(&fixture)?;
+            wait_for(|| fixture.socket.stats().sent == 1).await?;
+            inject(&fixture, b"first")?;
+            inject(&fixture, b"second")?;
+            wait_for(|| fixture.socket.stats().received == 2).await?;
+            let mut first = [0; 1400];
+            let mut second = [0; 1400];
+            let mut meta = [quinn::udp::RecvMeta::default(); 2];
+            let received = ready(fixture.socket.poll_recv(
+                &mut Context::from_waker(&waker),
+                &mut [IoSliceMut::new(&mut first), IoSliceMut::new(&mut second)],
+                &mut meta,
+            ))?;
+            Ok::<_, io::Error>((received, first, second, meta))
+        }
+        .await;
+        fixture.driver.stop().await.unwrap();
+        let (received, first, second, meta) = result.unwrap();
+        assert_eq!(
+            received, 2,
+            "ready packet batch was split into separate polls"
+        );
+        for (bytes, expected, metadata) in [
+            (&first[..], b"first".as_slice(), meta[0]),
+            (&second[..], b"second".as_slice(), meta[1]),
+        ] {
+            assert_eq!(&bytes[..metadata.len], expected);
+            assert_eq!(metadata.addr, fixture.peer);
+            assert_eq!(metadata.stride, metadata.len);
+        }
+        assert_eq!(fixture.closed.load(Ordering::Relaxed), 1);
+    }
+    #[tokio::test]
+    async fn quic_memory_stop_drops_owned_send_before_closing_carrier() {
+        let fixture = fixture_mode(true, true).unwrap();
+        send(&fixture).unwrap();
+        let result = wait_for(|| fixture.starts.load(Ordering::Relaxed) == 1).await;
+        let leases = fixture.leases.load(Ordering::Relaxed);
+        fixture.driver.stop().await.unwrap();
+        result.unwrap();
+        assert_eq!(leases, 1);
+        assert_eq!(fixture.leases.load(Ordering::Relaxed), 0);
+        assert_eq!(fixture.closed.load(Ordering::Relaxed), 1);
+        assert_eq!(fixture.socket.stats().sent, 0);
+    }
+    #[tokio::test]
+    async fn quic_memory_nonfull_receive_keeps_the_pending_carrier_read() {
+        let fixture = fixture(false).unwrap();
+        let waker = Waker::from(Arc::new(Count::default()));
+        let result = async {
+            send(&fixture)?;
+            wait_for(|| fixture.socket.stats().sent == 1).await?;
+            inject(&fixture, b"first")?;
+            wait_for(|| fixture.socket.stats().received == 1).await?;
+            let before = fixture.reads.load(Ordering::Relaxed);
+            let mut bytes = [0; 1400];
+            let mut meta = [quinn::udp::RecvMeta::default()];
+            ready(fixture.socket.poll_recv(
+                &mut Context::from_waker(&waker),
+                &mut [IoSliceMut::new(&mut bytes)],
+                &mut meta,
+            ))?;
+            assert_eq!(&bytes[..meta[0].len], b"first");
+            for _ in 0..4 {
+                tokio::task::yield_now().await;
+            }
+            let after = fixture.reads.load(Ordering::Relaxed);
+            inject(&fixture, b"second")?;
+            wait_for(|| fixture.socket.stats().received == 2).await?;
+            Ok::<_, io::Error>((before, after))
+        }
+        .await;
+        fixture.driver.stop().await.unwrap();
+        assert_eq!(fixture.closed.load(Ordering::Relaxed), 1);
+        let (before, after) = result.unwrap();
+        assert_eq!(after, before, "consumption restarted an unblocked read");
+    }
+    // These three RED cases exercise the real attached carrier and owner. No
+    // setter manufactures queue/credit/readiness, and no AtomicWaker is taken
+    // or cleared by the assertion. Stop is awaited before each failing assert.
+    #[tokio::test]
+    async fn quic_memory_ready_receive_does_not_register_for_next_packet() {
+        let fixture = fixture(false).unwrap();
+        let count = Arc::new(Count::default());
+        let waker = Waker::from(count.clone());
+        let result = async {
+            send(&fixture)?;
+            wait_for(|| fixture.socket.stats().sent == 1).await?;
+            inject(&fixture, b"first")?;
+            wait_for(|| fixture.socket.stats().received == 1).await?;
+            let mut bytes = [0; 1400];
+            let mut meta = [quinn::udp::RecvMeta::default()];
+            let received = ready(fixture.socket.poll_recv(
+                &mut Context::from_waker(&waker),
+                &mut [IoSliceMut::new(&mut bytes)],
+                &mut meta,
+            ))?;
+            let first = bytes[..meta[0].len].to_vec();
+            inject(&fixture, b"second")?;
+            wait_for(|| fixture.socket.stats().received == 2).await?;
+            Ok::<_, io::Error>((received, first, count.get()))
+        }
+        .await;
+        fixture.driver.stop().await.unwrap();
+        assert_eq!(fixture.closed.load(Ordering::Relaxed), 1);
+        let (received, payload, wakes) = result.unwrap();
+        assert_eq!(received, 1);
+        assert_eq!(payload, b"first");
+        assert_eq!(
+            wakes, 0,
+            "Ready receive retained a registration for later ingress"
+        );
+    }
+    #[tokio::test]
+    async fn quic_memory_ready_writable_does_not_register_for_later_send() {
+        let fixture = fixture(false).unwrap();
+        let count = Arc::new(Count::default());
+        let waker = Waker::from(count.clone());
+        let mut poller = fixture.socket.clone().create_io_poller();
+        let result = async {
+            ready(
+                poller
+                    .as_mut()
+                    .poll_writable(&mut Context::from_waker(&waker)),
+            )?;
+            send(&fixture)?;
+            wait_for(|| fixture.socket.stats().sent == 1).await?;
+            Ok::<_, io::Error>(count.get())
+        }
+        .await;
+        fixture.driver.stop().await.unwrap();
+        assert_eq!(fixture.closed.load(Ordering::Relaxed), 1);
+        assert_eq!(
+            result.unwrap(),
+            0,
+            "Ready writable retained a registration for later egress"
+        );
+    }
+    #[tokio::test]
+    async fn quic_memory_ready_transmitted_does_not_register_for_later_send() {
+        let fixture = fixture(false).unwrap();
+        let count = Arc::new(Count::default());
+        let waker = Waker::from(count.clone());
+        let result = async {
+            send(&fixture)?;
+            wait_for(|| fixture.socket.stats().sent == 1).await?;
+            ready(
+                fixture
+                    .socket
+                    .poll_transmitted(&mut Context::from_waker(&waker), 1),
+            )?;
+            send(&fixture)?;
+            wait_for(|| fixture.socket.stats().sent == 2).await?;
+            Ok::<_, io::Error>(count.get())
+        }
+        .await;
+        fixture.driver.stop().await.unwrap();
+        assert_eq!(fixture.closed.load(Ordering::Relaxed), 1);
+        assert_eq!(
+            result.unwrap(),
+            0,
+            "Ready transmission barrier retained a registration"
+        );
+    }
+    // Cancellation drops only the waiting future; the carrier/driver stays
+    // owned. A subsequent Pending caller gets the next real progress wake.
+    #[tokio::test]
+    async fn quic_memory_cancelled_receive_wait_replaced_by_pending_reader_is_woken() {
+        let fixture = fixture(false).unwrap();
+        let cancelled = Arc::new(Count::default());
+        let count = Arc::new(Count::default());
+        let first_waker = Waker::from(cancelled);
+        let waker = Waker::from(count.clone());
+        let result = async {
+            send(&fixture)?;
+            wait_for(|| fixture.socket.stats().sent == 1).await?;
+            let mut bytes = [0; 1400];
+            let mut meta = [quinn::udp::RecvMeta::default()];
+            let mut wait = Box::pin(std::future::poll_fn(|cx| {
+                fixture
+                    .socket
+                    .poll_recv(cx, &mut [IoSliceMut::new(&mut bytes)], &mut meta)
+            }));
+            let first_pending = wait
+                .as_mut()
+                .poll(&mut Context::from_waker(&first_waker))
+                .is_pending();
+            drop(wait);
+            let pending = fixture
+                .socket
+                .poll_recv(
+                    &mut Context::from_waker(&waker),
+                    &mut [IoSliceMut::new(&mut bytes)],
+                    &mut meta,
+                )
+                .is_pending();
+            inject(&fixture, b"resumed")?;
+            wait_for(|| count.get() > 0).await?;
+            let delivered = ready(fixture.socket.poll_recv(
+                &mut Context::from_waker(&waker),
+                &mut [IoSliceMut::new(&mut bytes)],
+                &mut meta,
+            ))?;
+            Ok::<_, io::Error>((
+                first_pending,
+                pending,
+                delivered,
+                bytes[..meta[0].len].to_vec(),
+            ))
+        }
+        .await;
+        fixture.driver.stop().await.unwrap();
+        assert_eq!(fixture.closed.load(Ordering::Relaxed), 1);
+        let (first_pending, pending, delivered, payload) = result.unwrap();
+        assert!(first_pending && pending);
+        assert_eq!(delivered, 1);
+        assert_eq!(payload, b"resumed");
+    }
+    #[tokio::test]
+    async fn quic_memory_pending_writable_wakes_on_real_queue_capacity() {
+        let fixture = fixture(true).unwrap();
+        let count = Arc::new(Count::default());
+        let waker = Waker::from(count.clone());
+        let mut poller = fixture.socket.clone().create_io_poller();
+        let result = async {
+            send(&fixture)?;
+            wait_for(|| fixture.starts.load(Ordering::Relaxed) == 1).await?;
+            for _ in 0..QUEUE_LIMIT {
+                send(&fixture)?;
+            }
+            let overflow = send(&fixture).err().map(|error| error.kind());
+            let pending = poller
+                .as_mut()
+                .poll_writable(&mut Context::from_waker(&waker))
+                .is_pending();
+            fixture.credit.add_permits(1);
+            wait_for(|| fixture.starts.load(Ordering::Relaxed) >= 2 && count.get() > 0).await?;
+            ready(
+                poller
+                    .as_mut()
+                    .poll_writable(&mut Context::from_waker(&waker)),
+            )?;
+            Ok::<_, io::Error>((overflow, pending))
+        }
+        .await;
+        fixture.driver.stop().await.unwrap();
+        assert_eq!(fixture.closed.load(Ordering::Relaxed), 1);
+        let (overflow, pending) = result.unwrap();
+        assert_eq!(overflow, Some(io::ErrorKind::WouldBlock));
+        assert!(pending);
+    }
+    #[tokio::test]
+    async fn quic_memory_pending_transmission_wakes_on_real_send_completion() {
+        let fixture = fixture(true).unwrap();
+        let count = Arc::new(Count::default());
+        let waker = Waker::from(count.clone());
+        let result = async {
+            send(&fixture)?;
+            wait_for(|| fixture.starts.load(Ordering::Relaxed) == 1).await?;
+            let pending = fixture
+                .socket
+                .poll_transmitted(&mut Context::from_waker(&waker), 1)
+                .is_pending();
+            fixture.credit.add_permits(1);
+            wait_for(|| fixture.socket.stats().sent == 1 && count.get() > 0).await?;
+            ready(
+                fixture
+                    .socket
+                    .poll_transmitted(&mut Context::from_waker(&waker), 1),
+            )?;
+            Ok::<_, io::Error>(pending)
+        }
+        .await;
+        fixture.driver.stop().await.unwrap();
+        assert_eq!(fixture.closed.load(Ordering::Relaxed), 1);
+        assert!(result.unwrap());
+    }
+
+    #[cfg(feature = "quiche-h3-transport")]
+    fn inject_payload(fixture: &Fixture, payload: Bytes) -> io::Result<()> {
+        fixture
+            .input
+            .try_send(Datagram {
+                remote: Destination::Ip(fixture.peer),
+                payload,
+                sniffed_domain: None,
+            })
+            .map_err(|_| io::Error::from(io::ErrorKind::BrokenPipe))
+    }
+
+    #[cfg(feature = "quiche-h3-transport")]
+    #[tokio::test]
+    async fn quic_memory_owned_receive_keeps_unique_storage_and_real_wakes() {
+        let fixture = fixture(false).unwrap();
+        let count = Arc::new(Count::default());
+        let waker = Waker::from(count.clone());
+        let result = async {
+            send(&fixture)?;
+            wait_for(|| fixture.socket.stats().sent == 1).await?;
+            let pending = fixture
+                .socket
+                .poll_recv_owned(&mut Context::from_waker(&waker))
+                .is_pending();
+            let payload = Bytes::copy_from_slice(b"owned allocation");
+            let pointer = payload.as_ptr() as usize;
+            inject_payload(&fixture, payload)?;
+            wait_for(|| fixture.socket.stats().received == 1 && count.get() > 0).await?;
+            let payload = ready(
+                fixture
+                    .socket
+                    .poll_recv_owned(&mut Context::from_waker(&waker)),
+            )?;
+            let same_storage = payload.as_ptr() as usize == pointer;
+            let bytes = payload.to_vec();
+            let mutable = payload
+                .try_into_mut()
+                .map_err(|_| io::Error::other("owned input lost uniqueness"))?;
+            let same_mutable_storage = mutable.as_ptr() as usize == pointer;
+            drop(mutable);
+            let before = count.get();
+            inject(&fixture, b"next")?;
+            wait_for(|| fixture.socket.stats().received == 2).await?;
+            let next = ready(
+                fixture
+                    .socket
+                    .poll_recv_owned(&mut Context::from_waker(&waker)),
+            )?;
+            let quiet_after_ready = count.get() == before;
+            let stopped_pending = fixture
+                .socket
+                .poll_recv_owned(&mut Context::from_waker(&waker))
+                .is_pending();
+            Ok::<_, io::Error>((
+                pending,
+                same_storage,
+                same_mutable_storage,
+                bytes,
+                next,
+                quiet_after_ready,
+                stopped_pending,
+                count.get(),
+            ))
+        }
+        .await;
+        fixture.driver.stop().await.unwrap();
+        let stopped = fixture
+            .socket
+            .poll_recv_owned(&mut Context::from_waker(&waker));
+        let state = fixture.socket.shared.state.lock().unwrap();
+        assert!(state.closed && state.incoming.is_empty() && state.outgoing.is_empty());
+        drop(state);
+        assert_eq!(fixture.closed.load(Ordering::Relaxed), 1);
+        let (
+            pending,
+            same_storage,
+            same_mutable_storage,
+            bytes,
+            next,
+            quiet_after_ready,
+            stopped_pending,
+            before_stop,
+        ) = result.unwrap();
+        assert!(pending && stopped_pending && quiet_after_ready);
+        assert!(
+            same_storage && same_mutable_storage,
+            "owned receive copied the real carrier allocation"
+        );
+        assert_eq!(bytes, b"owned allocation");
+        assert_eq!(next.as_ref(), b"next");
+        assert!(
+            count.get() > before_stop,
+            "Stop did not wake the actual pending reader"
+        );
+        assert!(
+            matches!(stopped, Poll::Ready(Err(error)) if error.kind() == io::ErrorKind::BrokenPipe)
+        );
+    }
+
+    #[cfg(feature = "quiche-h3-transport")]
+    #[tokio::test]
+    async fn quic_memory_owned_receive_resumes_full_carrier_and_preserves_shared_inputs() {
+        let fixture = fixture(false).unwrap();
+        let count = Arc::new(Count::default());
+        let waker = Waker::from(count);
+        let result = async {
+            send(&fixture)?;
+            wait_for(|| fixture.socket.stats().sent == 1).await?;
+            let shared = Bytes::copy_from_slice(b"shared input");
+            inject_payload(&fixture, shared.clone())?;
+            inject(&fixture, b"static input")?;
+            inject_payload(&fixture, Bytes::from_owner(vec![0x42; 17]))?;
+            for _ in 3..=QUEUE_LIMIT {
+                inject(&fixture, b"queued")?;
+            }
+            wait_for(|| fixture.socket.stats().received == QUEUE_LIMIT).await?;
+            let full = fixture.socket.shared.state.lock().unwrap().incoming.len();
+            let first = ready(
+                fixture
+                    .socket
+                    .poll_recv_owned(&mut Context::from_waker(&waker)),
+            )?;
+            let same_shared_storage = first.as_ptr() == shared.as_ptr();
+            let shared_bytes = first.to_vec();
+            let shared_is_readonly = first.try_into_mut().is_err();
+            wait_for(|| fixture.socket.stats().received == QUEUE_LIMIT + 1).await?;
+            let second = ready(
+                fixture
+                    .socket
+                    .poll_recv_owned(&mut Context::from_waker(&waker)),
+            )?;
+            let static_bytes = second.to_vec();
+            let static_is_readonly = second.try_into_mut().is_err();
+            let third = ready(
+                fixture
+                    .socket
+                    .poll_recv_owned(&mut Context::from_waker(&waker)),
+            )?;
+            let owner_bytes = third.to_vec();
+            let owner_is_readonly = third.try_into_mut().is_err();
+            Ok::<_, io::Error>((
+                full,
+                same_shared_storage,
+                shared_bytes,
+                shared.to_vec(),
+                shared_is_readonly,
+                static_bytes,
+                static_is_readonly,
+                owner_bytes,
+                owner_is_readonly,
+            ))
+        }
+        .await;
+        fixture.driver.stop().await.unwrap();
+        let state = fixture.socket.shared.state.lock().unwrap();
+        assert!(state.closed && state.incoming.is_empty() && state.outgoing.is_empty());
+        drop(state);
+        assert_eq!(fixture.closed.load(Ordering::Relaxed), 1);
+        let (
+            full,
+            same_shared_storage,
+            shared_bytes,
+            original_bytes,
+            shared_is_readonly,
+            static_bytes,
+            static_is_readonly,
+            owner_bytes,
+            owner_is_readonly,
+        ) = result.unwrap();
+        assert_eq!(full, QUEUE_LIMIT);
+        assert_eq!(fixture.socket.stats().received, QUEUE_LIMIT + 1);
+        assert!(
+            same_shared_storage && shared_is_readonly && static_is_readonly && owner_is_readonly
+        );
+        assert_eq!(shared_bytes, b"shared input");
+        assert_eq!(original_bytes, b"shared input");
+        assert_eq!(static_bytes, b"static input");
+        assert_eq!(owner_bytes, [0x42; 17]);
+    }
 }
diff --git a/src/transport/quic/linux_udp.rs b/src/transport/quic/linux_udp.rs
new file mode 100644
index 0000000..4f19cb5
--- /dev/null
+++ b/src/transport/quic/linux_udp.rs
@@ -0,0 +1,360 @@
+//! Linux ancillary messages on an existing protected UDP fd; no socket factory.
+use quinn::udp::{EcnCodepoint, RecvMeta, Transmit};
+use std::{
+    io::{self, IoSliceMut},
+    mem,
+    os::fd::AsRawFd,
+    ptr,
+    sync::atomic::{AtomicBool, Ordering},
+};
+use tokio::net::UdpSocket;
+
+const MAX_SEGMENTS: usize = 10;
+const UDP_SEGMENT: libc::c_int = 103;
+const UDP_GRO: libc::c_int = 104;
+
+pub(super) struct SocketState {
+    gso: AtomicBool,
+}
+impl SocketState {
+    pub(super) fn new(
+        io: &UdpSocket,
+        settings: crate::config::QuicSocketSettings,
+    ) -> io::Result<Option<Self>> {
+        // Do not rely on reporting GRO=1 while aggregation remains enabled.
+        match set_option(io, libc::SOL_UDP, UDP_GRO, 0) {
+            Ok(()) => {
+                if get_option(io, libc::SOL_UDP, UDP_GRO)? != 0 {
+                    return Err(io::ErrorKind::Unsupported.into());
+                }
+            }
+            Err(error) if error.raw_os_error() == Some(libc::ENOPROTOOPT) => {}
+            Err(error) => return Err(error),
+        }
+        if io.local_addr()?.is_ipv4() {
+            set_option(
+                io,
+                libc::IPPROTO_IP,
+                libc::IP_MTU_DISCOVER,
+                libc::IP_PMTUDISC_PROBE,
+            )?;
+            if !settings.disable_ecn
+                && set_option(io, libc::IPPROTO_IP, libc::IP_RECVTOS, 1).is_err()
+            {
+                return Ok(None);
+            }
+        } else {
+            set_option(
+                io,
+                libc::IPPROTO_IPV6,
+                libc::IPV6_MTU_DISCOVER,
+                libc::IP_PMTUDISC_PROBE,
+            )?;
+            set_option(io, libc::IPPROTO_IPV6, libc::IPV6_DONTFRAG, 1)?;
+            if !settings.disable_ecn
+                && set_option(io, libc::IPPROTO_IPV6, libc::IPV6_RECVTCLASS, 1).is_err()
+            {
+                return Ok(None);
+            }
+        }
+        Ok(Some(Self {
+            gso: AtomicBool::new(!settings.disable_gso),
+        }))
+    }
+    pub(super) fn may_fragment(&self) -> bool {
+        false
+    }
+    pub(super) fn max_gso_segments(&self) -> usize {
+        if self.gso.load(Ordering::Relaxed) {
+            MAX_SEGMENTS
+        } else {
+            1
+        }
+    }
+    pub(super) fn try_send(&self, io: &UdpSocket, transmit: &Transmit<'_>) -> io::Result<()> {
+        // Old batches were generated while GSO was enabled. If an earlier
+        // batch disabled it, discard these rather than partially replaying them.
+        if transmit.segment_size.is_some() && !self.gso.load(Ordering::Relaxed) {
+            return Ok(());
+        }
+        let destination = socket2::SockAddr::from(transmit.destination);
+        let mut control = Control::default();
+        let mut length = 0;
+        if let Some(ecn) = transmit.ecn {
+            let (level, kind) = if transmit.destination.is_ipv4() {
+                (libc::IPPROTO_IP, libc::IP_TOS)
+            } else {
+                (libc::IPPROTO_IPV6, libc::IPV6_TCLASS)
+            };
+            control.push(&mut length, level, kind, &(ecn as libc::c_int))?;
+        }
+        if let Some(segment) = transmit.segment_size {
+            let segment = u16::try_from(segment).map_err(|_| io::ErrorKind::InvalidInput)?;
+            control.push(&mut length, libc::SOL_UDP, UDP_SEGMENT, &segment)?;
+        }
+        let mut iov = libc::iovec {
+            iov_base: transmit.contents.as_ptr().cast_mut().cast(),
+            iov_len: transmit.contents.len(),
+        };
+        let mut header: libc::msghdr = unsafe { mem::zeroed() };
+        header.msg_name = destination.as_ptr().cast_mut().cast();
+        header.msg_namelen = destination.len();
+        header.msg_iov = &mut iov;
+        header.msg_iovlen = 1;
+        if length > 0 {
+            header.msg_control = control.0.as_mut_ptr().cast();
+            header.msg_controllen = length;
+        }
+        let sent = unsafe {
+            libc::sendmsg(
+                io.as_raw_fd(),
+                &header,
+                libc::MSG_DONTWAIT | libc::MSG_NOSIGNAL,
+            )
+        };
+        if sent >= 0 {
+            return if sent as usize == transmit.contents.len() {
+                Ok(())
+            } else {
+                Err(io::ErrorKind::WriteZero.into())
+            };
+        }
+        let error = io::Error::last_os_error();
+        if disables_gso(transmit, error.raw_os_error()) {
+            self.gso.store(false, Ordering::Relaxed);
+        }
+        Err(error)
+    }
+    pub(super) fn recv(
+        &self,
+        io: &UdpSocket,
+        buffers: &mut [IoSliceMut<'_>],
+        metadata: &mut [RecvMeta],
+    ) -> io::Result<usize> {
+        let (Some(buffer), Some(meta)) = (buffers.first_mut(), metadata.first_mut()) else {
+            return Err(io::ErrorKind::InvalidInput.into());
+        };
+        let mut source = socket2::SockAddrStorage::zeroed();
+        let mut control = Control::default();
+        let mut iov = libc::iovec {
+            iov_base: buffer.as_mut_ptr().cast(),
+            iov_len: buffer.len(),
+        };
+        let mut header: libc::msghdr = unsafe { mem::zeroed() };
+        header.msg_name =
+            unsafe { source.view_as::<libc::sockaddr_storage>() as *mut libc::sockaddr_storage }
+                .cast();
+        header.msg_namelen = source.size_of();
+        header.msg_iov = &mut iov;
+        header.msg_iovlen = 1;
+        header.msg_control = control.0.as_mut_ptr().cast();
+        header.msg_controllen = mem::size_of_val(&control);
+        let received = unsafe { libc::recvmsg(io.as_raw_fd(), &mut header, libc::MSG_DONTWAIT) };
+        if received < 0 {
+            return Err(io::Error::last_os_error());
+        }
+        let minimum =
+            match unsafe { source.view_as::<libc::sockaddr_storage>() }.ss_family as libc::c_int {
+                libc::AF_INET => mem::size_of::<libc::sockaddr_in>(),
+                libc::AF_INET6 => mem::size_of::<libc::sockaddr_in6>(),
+                _ => return Err(io::ErrorKind::InvalidData.into()),
+            };
+        if (header.msg_namelen as usize) < minimum
+            || (header.msg_namelen as usize) > mem::size_of_val(&source)
+        {
+            return Err(io::ErrorKind::InvalidData.into());
+        }
+        let address = unsafe { socket2::SockAddr::new(source, header.msg_namelen) }
+            .as_socket()
+            .ok_or(io::ErrorKind::InvalidData)?;
+        let length = if header.msg_flags & libc::MSG_TRUNC != 0 {
+            buffer.len().saturating_add(1)
+        } else {
+            received as usize
+        };
+        *meta = RecvMeta {
+            addr: address,
+            len: length,
+            stride: length,
+            ecn: if header.msg_flags & libc::MSG_CTRUNC == 0 {
+                control.ecn(header.msg_controllen)?
+            } else {
+                None
+            },
+            dst_ip: None,
+        };
+        Ok(1)
+    }
+}
+fn disables_gso(transmit: &Transmit<'_>, error: Option<i32>) -> bool {
+    transmit.segment_size.is_some()
+        && transmit.ecn.is_none()
+        && matches!(error, Some(libc::ENOPROTOOPT) | Some(libc::EOPNOTSUPP))
+}
+fn set_option(io: &UdpSocket, level: i32, name: i32, value: libc::c_int) -> io::Result<()> {
+    let result = unsafe {
+        libc::setsockopt(
+            io.as_raw_fd(),
+            level,
+            name,
+            (&value as *const libc::c_int).cast(),
+            mem::size_of_val(&value) as libc::socklen_t,
+        )
+    };
+    if result == 0 {
+        Ok(())
+    } else {
+        Err(io::Error::last_os_error())
+    }
+}
+fn get_option(io: &UdpSocket, level: i32, name: i32) -> io::Result<libc::c_int> {
+    let mut value: libc::c_int = 0;
+    let mut length = mem::size_of_val(&value) as libc::socklen_t;
+    let result = unsafe {
+        libc::getsockopt(
+            io.as_raw_fd(),
+            level,
+            name,
+            (&mut value as *mut libc::c_int).cast(),
+            &mut length,
+        )
+    };
+    if result == 0 && length as usize == mem::size_of_val(&value) {
+        Ok(value)
+    } else if result != 0 {
+        Err(io::Error::last_os_error())
+    } else {
+        Err(io::ErrorKind::InvalidData.into())
+    }
+}
+
+// u64 supplies cmsghdr alignment. The two possible send messages fit within 48B;
+// receive contains only IP_TOS/IPV6_TCLASS, never an unbounded metadata vector.
+#[derive(Default)]
+struct Control([u64; 8]);
+impl Control {
+    fn push<T: Copy>(
+        &mut self,
+        used: &mut usize,
+        level: i32,
+        kind: i32,
+        value: &T,
+    ) -> io::Result<()> {
+        let space = unsafe { libc::CMSG_SPACE(mem::size_of::<T>() as _) } as usize;
+        if *used > mem::size_of_val(self) || space > mem::size_of_val(self) - *used {
+            return Err(io::ErrorKind::InvalidInput.into());
+        }
+        unsafe {
+            let header = self
+                .0
+                .as_mut_ptr()
+                .cast::<u8>()
+                .add(*used)
+                .cast::<libc::cmsghdr>();
+            (*header).cmsg_level = level;
+            (*header).cmsg_type = kind;
+            (*header).cmsg_len = libc::CMSG_LEN(mem::size_of::<T>() as _) as usize;
+            ptr::write_unaligned(libc::CMSG_DATA(header).cast::<T>(), *value);
+        }
+        *used += space;
+        Ok(())
+    }
+    fn ecn(&self, used: usize) -> io::Result<Option<EcnCodepoint>> {
+        if used > mem::size_of_val(self) {
+            return Err(io::ErrorKind::InvalidData.into());
+        }
+        let base = self.0.as_ptr().cast::<u8>();
+        let mut offset = 0;
+        let minimum = unsafe { libc::CMSG_LEN(0) } as usize;
+        while used.saturating_sub(offset) >= mem::size_of::<libc::cmsghdr>() {
+            let header = unsafe { &*base.add(offset).cast::<libc::cmsghdr>() };
+            if header.cmsg_len < minimum || header.cmsg_len > used - offset {
+                return Err(io::ErrorKind::InvalidData.into());
+            }
+            let data = unsafe { base.add(offset + minimum) };
+            if header.cmsg_level == libc::IPPROTO_IP
+                && header.cmsg_type == libc::IP_TOS
+                && header.cmsg_len > minimum
+            {
+                return Ok(EcnCodepoint::from_bits(unsafe { *data }));
+            }
+            if header.cmsg_level == libc::IPPROTO_IPV6
+                && header.cmsg_type == libc::IPV6_TCLASS
+                && header.cmsg_len >= minimum + mem::size_of::<libc::c_int>()
+            {
+                return Ok(EcnCodepoint::from_bits(unsafe {
+                    ptr::read_unaligned(data.cast::<libc::c_int>())
+                } as u8));
+            }
+            let space = unsafe { libc::CMSG_SPACE((header.cmsg_len - minimum) as _) } as usize;
+            if space == 0 || space > used - offset {
+                break;
+            }
+            offset += space;
+        }
+        Ok(None)
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn physical_quic_memory_gso_segment_cap_is_ten_and_fallback_is_one() {
+        let state = SocketState {
+            gso: AtomicBool::new(true),
+        };
+        assert_eq!(state.max_gso_segments(), 10);
+        state.gso.store(false, Ordering::Relaxed);
+        assert_eq!(state.max_gso_segments(), 1);
+    }
+    #[test]
+    fn physical_quic_memory_linux_control_is_fixed_aligned_and_decodes_actual_ecn() {
+        let mut control = Control::default();
+        let mut used = 0;
+        control
+            .push(&mut used, libc::SOL_UDP, UDP_SEGMENT, &1200_u16)
+            .unwrap();
+        control
+            .push(&mut used, libc::IPPROTO_IP, libc::IP_TOS, &2_u8)
+            .unwrap();
+        assert!(used <= 48);
+        assert_eq!(control.ecn(used).unwrap(), Some(EcnCodepoint::Ect0));
+        let mut control = Control::default();
+        let mut used = 0;
+        control
+            .push(&mut used, libc::IPPROTO_IPV6, libc::IPV6_TCLASS, &3_i32)
+            .unwrap();
+        assert_eq!(control.ecn(used).unwrap(), Some(EcnCodepoint::Ce));
+        assert!(control.ecn(mem::size_of_val(&control) + 1).is_err());
+        assert!(control.push(&mut used, 0, 0, &[0_u8; 64]).is_err());
+    }
+    #[test]
+    fn physical_quic_memory_gso_disables_only_for_capability_errors_not_would_block() {
+        let mut transmit = Transmit {
+            destination: "192.0.2.1:443".parse().unwrap(),
+            contents: &[1; 2400],
+            ecn: None,
+            segment_size: Some(1200),
+            src_ip: None,
+        };
+        for value in [libc::ENOPROTOOPT, libc::EOPNOTSUPP] {
+            assert!(disables_gso(&transmit, Some(value)));
+        }
+        transmit.ecn = Some(EcnCodepoint::Ect0);
+        assert!(!disables_gso(&transmit, Some(libc::ENOPROTOOPT)));
+        transmit.ecn = None;
+        transmit.segment_size = None;
+        assert!(!disables_gso(&transmit, Some(libc::ENOPROTOOPT)));
+        transmit.segment_size = Some(1200);
+        for value in [
+            libc::EAGAIN,
+            libc::EINTR,
+            libc::EPERM,
+            libc::EMSGSIZE,
+            libc::EINVAL,
+            libc::EIO,
+        ] {
+            assert!(!disables_gso(&transmit, Some(value)));
+        }
+    }
+}
diff --git a/src/transport/quic/physical.rs b/src/transport/quic/physical.rs
new file mode 100644
index 0000000..646395b
--- /dev/null
+++ b/src/transport/quic/physical.rs
@@ -0,0 +1,630 @@
+//! QUIC metadata on a single already-protected DIRECT UDP socket.
+//! No codecs or proxy hops delegate this lease.
+use super::{DatagramBudget, PhysicalQuicLease, Shared, linux_udp::SocketState};
+use quinn::{
+    UdpPoller,
+    udp::{RecvMeta, Transmit},
+};
+use std::{
+    io::{self, IoSliceMut},
+    net::SocketAddr,
+    pin::Pin,
+    sync::{Arc, Mutex, RwLock},
+    task::{Context, Poll, Wake, Waker, ready},
+};
+use tokio::{io::Interest, sync::Notify};
+use tokio_util::sync::ReusableBoxFuture;
+
+#[cfg(all(test, feature = "tun"))]
+#[path = "physical_gate.rs"]
+mod gate;
+
+const MAX_SEGMENTS: usize = 10;
+const MAX_BATCH_BYTES: usize = 65_507;
+type Io = Arc<crate::dialer::PhysicalDatagram>;
+pub(super) type Retirement = Arc<Lease<Io>>;
+
+// Every retained socket/poller owns this revocable slot, never the fd itself.
+// A generic value permits a memory-only destructor/registration regression.
+pub(super) struct Lease<T> {
+    value: RwLock<Option<T>>,
+    ready: Arc<Ready>,
+}
+struct Ready(Notify);
+impl Wake for Ready {
+    fn wake(self: Arc<Self>) {
+        self.0.notify_waiters();
+    }
+    fn wake_by_ref(self: &Arc<Self>) {
+        self.0.notify_waiters();
+    }
+}
+impl<T> Lease<T> {
+    fn new(value: T) -> Arc<Self> {
+        Arc::new(Self {
+            value: RwLock::new(Some(value)),
+            ready: Arc::new(Ready(Notify::new())),
+        })
+    }
+    pub(super) fn retire(&self) {
+        self.value.write().unwrap().take();
+        self.ready.0.notify_waiters();
+    }
+}
+
+pub(super) struct Socket {
+    io: Retirement,
+    state: SocketState,
+    settings: crate::config::QuicSocketSettings,
+    peer: SocketAddr,
+    budget: DatagramBudget,
+    shared: Arc<Shared>,
+    // One reusable packet plus the same oversize-detection byte used by DIRECT.
+    // Allocate only when the protected socket is actually readable.
+    receive: Mutex<Vec<u8>>,
+}
+impl Socket {
+    pub(super) fn new(
+        lease: PhysicalQuicLease,
+        peer: SocketAddr,
+        budget: DatagramBudget,
+        shared: Arc<Shared>,
+    ) -> io::Result<Option<Self>> {
+        let Some(state) = SocketState::new(&lease.socket, lease.settings)? else {
+            return Ok(None);
+        };
+        Ok(Some(Self {
+            io: Lease::new(lease.socket),
+            state,
+            settings: lease.settings,
+            peer,
+            budget,
+            shared,
+            receive: Mutex::new(Vec::new()),
+        }))
+    }
+    pub(super) fn retirement(&self) -> Retirement {
+        self.io.clone()
+    }
+    fn check_open(&self) -> io::Result<()> {
+        let state = self.shared.state.lock().unwrap();
+        if state.closed {
+            Err(state.error.unwrap_or(io::ErrorKind::BrokenPipe).into())
+        } else {
+            Ok(())
+        }
+    }
+    pub(super) fn transmit_segments(&self) -> usize {
+        if self.settings.disable_gso {
+            1
+        } else {
+            self.state
+                .max_gso_segments()
+                .clamp(1, MAX_SEGMENTS)
+                .min((MAX_BATCH_BYTES / usize::from(self.budget.transmit())).max(1))
+        }
+    }
+    pub(super) fn local_addr(&self) -> io::Result<SocketAddr> {
+        self.io
+            .value
+            .read()
+            .unwrap()
+            .as_ref()
+            .ok_or(io::ErrorKind::BrokenPipe)?
+            .local_addr()
+    }
+    pub(super) fn may_fragment(&self) -> bool {
+        self.state.may_fragment()
+    }
+    pub(super) fn try_send(&self, transmit: &Transmit<'_>) -> io::Result<()> {
+        self.check_open()?;
+        let count = validate_transmit(
+            self.peer,
+            self.budget.transmit(),
+            if self.settings.disable_gso {
+                1
+            } else {
+                MAX_SEGMENTS.min((MAX_BATCH_BYTES / usize::from(self.budget.transmit())).max(1))
+            },
+            transmit,
+        )?;
+        let transmit = Transmit {
+            destination: transmit.destination,
+            ecn: if self.settings.disable_ecn {
+                None
+            } else {
+                transmit.ecn
+            },
+            contents: transmit.contents,
+            segment_size: transmit.segment_size,
+            // Explicit source overrides never escape physical binding policy.
+            src_ip: None,
+        };
+        // PMTU probe failures and unambiguous GSO-capability failures are
+        // accepted as packet losses for Quinn's normal ACK/retransmit logic.
+        // Never replay a possibly accepted prefix or hide address/policy/ECN errors.
+        let lease = self.io.value.read().unwrap();
+        let io = lease.as_ref().ok_or(io::ErrorKind::BrokenPipe)?;
+        match io.try_io(Interest::WRITABLE, || self.state.try_send(io, &transmit)) {
+            Ok(()) => {}
+            Err(error) if error.raw_os_error() == Some(libc::EMSGSIZE) => {}
+            Err(error)
+                if matches!(
+                    error.raw_os_error(),
+                    Some(libc::ENOPROTOOPT) | Some(libc::EOPNOTSUPP)
+                ) && transmit.segment_size.is_some()
+                    && transmit.ecn.is_none()
+                    && self.state.max_gso_segments() == 1 => {}
+            Err(error) => return Err(error),
+        }
+        self.shared.state.lock().unwrap().stats.sent += count;
+        Ok(())
+    }
+    pub(super) fn poll_recv(
+        &self,
+        cx: &mut Context<'_>,
+        buffers: &mut [IoSliceMut<'_>],
+        metadata: &mut [RecvMeta],
+    ) -> Poll<io::Result<usize>> {
+        if buffers.is_empty() || metadata.is_empty() {
+            return Poll::Ready(Err(io::ErrorKind::InvalidInput.into()));
+        }
+        self.shared.reader.register(cx.waker());
+        for _ in 0..crate::limits::IO_POLL_BUDGET {
+            self.check_open()?;
+            let lease = self.io.value.read().unwrap();
+            let io = lease.as_ref().ok_or(io::ErrorKind::BrokenPipe)?;
+            ready!(io.poll_recv_ready(cx))?;
+            let mut scratch = self.receive.lock().unwrap();
+            let required = usize::from(self.budget.receive()) + 1;
+            if scratch.len() < required {
+                scratch.resize(required, 0);
+            }
+            let mut meta = [RecvMeta::default()];
+            match io.try_io(Interest::READABLE, || {
+                self.state
+                    .recv(io, &mut [IoSliceMut::new(&mut scratch)], &mut meta)
+            }) {
+                Err(error) if error.kind() == io::ErrorKind::WouldBlock => continue,
+                Err(error) => return Poll::Ready(Err(error)),
+                Ok(0) => continue,
+                Ok(_) => {}
+            }
+            let mut meta = meta[0];
+            if meta.addr != self.peer {
+                self.shared.state.lock().unwrap().stats.rejected_source += 1;
+                continue;
+            }
+            if !valid_receive(self.peer, self.budget.receive(), &meta) {
+                self.shared.state.lock().unwrap().stats.rejected_oversize += 1;
+                continue;
+            }
+            if buffers[0].len() < meta.len {
+                return Poll::Ready(Err(io::ErrorKind::InvalidInput.into()));
+            }
+            buffers[0][..meta.len].copy_from_slice(&scratch[..meta.len]);
+            if self.settings.disable_ecn {
+                meta.ecn = None;
+            }
+            metadata[0] = meta;
+            self.shared.state.lock().unwrap().stats.received += 1;
+            return Poll::Ready(Ok(1));
+        }
+        // Source/oversize floods cannot monopolize the endpoint or defer Stop.
+        cx.waker().wake_by_ref();
+        Poll::Pending
+    }
+    pub(super) fn create_io_poller(&self) -> Pin<Box<dyn UdpPoller>> {
+        Box::pin(Writable {
+            io: self.io.clone(),
+            shared: self.shared.clone(),
+            future: Mutex::new(ReusableBoxFuture::new(writable(
+                self.io.clone(),
+                self.shared.clone(),
+                |io, cx| io.poll_send_ready(cx),
+            ))),
+        })
+    }
+}
+fn validate_transmit(
+    peer: SocketAddr,
+    budget: u16,
+    maximum: usize,
+    transmit: &Transmit<'_>,
+) -> io::Result<usize> {
+    if transmit.destination != peer || transmit.src_ip.is_some() || transmit.contents.is_empty() {
+        return Err(io::ErrorKind::InvalidInput.into());
+    }
+    let segment = transmit.segment_size.unwrap_or(transmit.contents.len());
+    if segment == 0
+        || segment > usize::from(budget)
+        || (transmit.segment_size.is_some() && maximum == 1)
+    {
+        return Err(io::ErrorKind::InvalidInput.into());
+    }
+    let count = transmit.contents.len().div_ceil(segment);
+    // A non-segmented IPv6 datagram keeps its existing directional budget
+    // (65,527 bytes). The conservative aggregate bound applies only to GSO.
+    if count > maximum.clamp(1, MAX_SEGMENTS)
+        || (transmit.segment_size.is_some()
+            && transmit.contents.len() > (usize::from(budget) * MAX_SEGMENTS).min(MAX_BATCH_BYTES))
+    {
+        return Err(io::ErrorKind::InvalidInput.into());
+    }
+    Ok(count)
+}
+fn valid_receive(peer: SocketAddr, maximum: u16, meta: &RecvMeta) -> bool {
+    meta.addr == peer && meta.len > 0 && meta.len <= usize::from(maximum) && meta.stride == meta.len
+}
+
+async fn writable<T: Send + Sync>(
+    io: Arc<Lease<T>>,
+    shared: Arc<Shared>,
+    poll: fn(&T, &mut Context<'_>) -> Poll<io::Result<()>>,
+) -> io::Result<()> {
+    // Every poller owns shutdown and readiness waiters. Neither future retains
+    // the physical IO across Pending; Stop wakes all of them.
+    let changed = shared.changed.notified();
+    tokio::pin!(changed);
+    changed.as_mut().enable();
+    {
+        let state = shared.state.lock().unwrap();
+        if state.closed {
+            return Err(state.error.unwrap_or(io::ErrorKind::BrokenPipe).into());
+        }
+    }
+    loop {
+        // All pollers register first. Tokio retains one common broadcast
+        // waker, containing only this Notify and no physical socket reference.
+        let ready = io.ready.0.notified();
+        tokio::pin!(ready);
+        ready.as_mut().enable();
+        let result = {
+            let value = io.value.read().unwrap();
+            let value = value.as_ref().ok_or(io::ErrorKind::BrokenPipe)?;
+            let waker = Waker::from(io.ready.clone());
+            poll(value, &mut Context::from_waker(&waker))
+        };
+        if let Poll::Ready(result) = result {
+            return result;
+        }
+        tokio::select! {
+            () = changed.as_mut() => return Err(io::ErrorKind::BrokenPipe.into()),
+            () = ready => {},
+        }
+    }
+}
+struct Writable {
+    io: Retirement,
+    shared: Arc<Shared>,
+    future: Mutex<ReusableBoxFuture<'static, io::Result<()>>>,
+}
+impl std::fmt::Debug for Writable {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("PhysicalQuicWritable")
+    }
+}
+impl UdpPoller for Writable {
+    fn poll_writable(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        self.shared.writer.register(cx.waker());
+        let state = self.shared.state.lock().unwrap();
+        if state.closed {
+            return Poll::Ready(Err(state.error.unwrap_or(io::ErrorKind::BrokenPipe).into()));
+        }
+        drop(state);
+        let mut future = self.future.lock().unwrap();
+        let result = future.poll(cx);
+        if result.is_ready() {
+            future.set(writable(self.io.clone(), self.shared.clone(), |io, cx| {
+                io.poll_send_ready(cx)
+            }));
+        }
+        result
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use quinn::udp::EcnCodepoint;
+    use std::{
+        future::Future,
+        sync::atomic::{AtomicBool, AtomicUsize, Ordering},
+    };
+
+    struct Probe {
+        _owner: Arc<()>,
+        ready: Arc<AtomicBool>,
+        registered: Arc<Mutex<Option<Waker>>>,
+        notify_during_registration: AtomicBool,
+    }
+    fn poll_probe(probe: &Probe, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        *probe.registered.lock().unwrap() = Some(cx.waker().clone());
+        if probe
+            .notify_during_registration
+            .swap(false, Ordering::Relaxed)
+        {
+            probe.ready.store(true, Ordering::Relaxed);
+            cx.waker().wake_by_ref();
+            return Poll::Pending;
+        }
+        if probe.ready.load(Ordering::Relaxed) {
+            Poll::Ready(Ok(()))
+        } else {
+            Poll::Pending
+        }
+    }
+    #[derive(Default)]
+    struct WakeCount(AtomicUsize);
+    impl Wake for WakeCount {
+        fn wake(self: Arc<Self>) {
+            self.0.fetch_add(1, Ordering::Relaxed);
+        }
+        fn wake_by_ref(self: &Arc<Self>) {
+            self.0.fetch_add(1, Ordering::Relaxed);
+        }
+    }
+    #[tokio::test]
+    async fn physical_quic_memory_revocation_releases_io_with_retained_broadcast_pollers() {
+        let owner = Arc::new(());
+        let weak = Arc::downgrade(&owner);
+        let ready = Arc::new(AtomicBool::new(false));
+        let registered = Arc::new(Mutex::new(None));
+        let lease = Lease::new(Probe {
+            _owner: owner,
+            ready: ready.clone(),
+            registered: registered.clone(),
+            notify_during_registration: AtomicBool::new(false),
+        });
+        let shared = Arc::new(Shared::default());
+        let first_wake = Arc::new(WakeCount::default());
+        let second_wake = Arc::new(WakeCount::default());
+        let first_waker = Waker::from(first_wake.clone());
+        let second_waker = Waker::from(second_wake.clone());
+        let mut first_cx = Context::from_waker(&first_waker);
+        let mut second_cx = Context::from_waker(&second_waker);
+        let mut first = Box::pin(writable(lease.clone(), shared.clone(), poll_probe));
+        let mut second = Box::pin(writable(lease.clone(), shared.clone(), poll_probe));
+        assert!(first.as_mut().poll(&mut first_cx).is_pending());
+        assert!(second.as_mut().poll(&mut second_cx).is_pending());
+        ready.store(true, Ordering::Relaxed);
+        registered.lock().unwrap().as_ref().unwrap().wake_by_ref();
+        assert!(first_wake.0.load(Ordering::Relaxed) > 0);
+        assert!(second_wake.0.load(Ordering::Relaxed) > 0);
+        assert!(matches!(
+            first.as_mut().poll(&mut first_cx),
+            Poll::Ready(Ok(()))
+        ));
+        assert!(matches!(
+            second.as_mut().poll(&mut second_cx),
+            Poll::Ready(Ok(()))
+        ));
+
+        // Pending waiters retain only the revocable slot, not its physical IO.
+        ready.store(false, Ordering::Relaxed);
+        let mut first = Box::pin(writable(lease.clone(), shared.clone(), poll_probe));
+        let mut second = Box::pin(writable(lease.clone(), shared.clone(), poll_probe));
+        assert!(first.as_mut().poll(&mut first_cx).is_pending());
+        assert!(second.as_mut().poll(&mut second_cx).is_pending());
+        lease.retire();
+        assert!(weak.upgrade().is_none());
+        for (future, cx) in [(&mut first, &mut first_cx), (&mut second, &mut second_cx)] {
+            assert!(
+                matches!(future.as_mut().poll(cx), Poll::Ready(Err(error)) if error.kind() == io::ErrorKind::BrokenPipe)
+            );
+        }
+
+        // An immediate reactor wake between registration and Pending is kept.
+        let lease = Lease::new(Probe {
+            _owner: Arc::new(()),
+            ready: Arc::new(AtomicBool::new(false)),
+            registered: Arc::new(Mutex::new(None)),
+            notify_during_registration: AtomicBool::new(true),
+        });
+        let mut waiter = Box::pin(writable(lease.clone(), shared.clone(), poll_probe));
+        assert!(matches!(
+            waiter.as_mut().poll(&mut first_cx),
+            Poll::Ready(Ok(()))
+        ));
+        lease.retire();
+
+        // A retained real poller may be polled repeatedly after retirement.
+        let retired = Arc::new(Lease::<Io> {
+            value: RwLock::new(None),
+            ready: Arc::new(Ready(Notify::new())),
+        });
+        let mut poller = Box::pin(Writable {
+            io: retired.clone(),
+            shared: shared.clone(),
+            future: Mutex::new(ReusableBoxFuture::new(writable(
+                retired.clone(),
+                shared.clone(),
+                |io, cx| io.poll_send_ready(cx),
+            ))),
+        });
+        for _ in 0..3 {
+            assert!(
+                matches!(poller.as_mut().poll_writable(&mut first_cx), Poll::Ready(Err(error)) if error.kind() == io::ErrorKind::BrokenPipe)
+            );
+        }
+        let notification = retired.ready.0.notified();
+        tokio::pin!(notification);
+        assert!(notification.as_mut().poll(&mut first_cx).is_pending());
+        let driver = super::super::DatagramDriver {
+            shared,
+            cancel: tokio_util::sync::CancellationToken::new(),
+            task: None,
+            physical: Some(retired.clone()),
+        };
+        drop(driver);
+        assert!(notification.as_mut().poll(&mut first_cx).is_ready());
+    }
+    #[test]
+    fn physical_quic_memory_concurrent_read_leases_delay_retirement_until_both_release() {
+        use std::sync::mpsc::{RecvTimeoutError, sync_channel};
+
+        const DEADLINE: std::time::Duration = std::time::Duration::from_secs(5);
+        const STILL_HELD: std::time::Duration = std::time::Duration::from_millis(25);
+        struct DropRecord {
+            _owner: Arc<()>,
+            dropped: Arc<AtomicUsize>,
+        }
+        impl Drop for DropRecord {
+            fn drop(&mut self) {
+                self.dropped.fetch_add(1, Ordering::SeqCst);
+            }
+        }
+
+        let owner = Arc::new(());
+        let weak = Arc::downgrade(&owner);
+        let dropped = Arc::new(AtomicUsize::new(0));
+        let lease = Lease::new(DropRecord {
+            _owner: owner,
+            dropped: dropped.clone(),
+        });
+        std::thread::scope(|scope| {
+            let (entered_tx, entered_rx) = sync_channel(2);
+            let (left_tx, left_rx) = sync_channel(2);
+            let mut releases = Vec::with_capacity(2);
+            let mut readers = Vec::with_capacity(2);
+            for _ in 0..2 {
+                let held = lease.clone();
+                let entered = entered_tx.clone();
+                let left = left_tx.clone();
+                let (release_tx, release_rx) = sync_channel(1);
+                releases.push(release_tx);
+                readers.push(scope.spawn(move || {
+                    let guard = held.value.read().unwrap();
+                    assert!(guard.is_some());
+                    entered.try_send(()).unwrap();
+                    // A failed parent assertion drops the release sender;
+                    // timeout/disconnection also releases the actual guard.
+                    let release = release_rx.recv_timeout(DEADLINE);
+                    drop(guard);
+                    left.try_send(()).unwrap();
+                    release.expect("read lease release deadline");
+                }));
+            }
+            // Both notifications occur while the actual read guards are held.
+            // This would time out if the lease still serialized its readers.
+            entered_rx.recv_timeout(DEADLINE).unwrap();
+            entered_rx.recv_timeout(DEADLINE).unwrap();
+            assert!(matches!(
+                lease.value.try_write(),
+                Err(std::sync::TryLockError::WouldBlock)
+            ));
+
+            let (attempt_tx, attempt_rx) = sync_channel(1);
+            let (done_tx, done_rx) = sync_channel(1);
+            let retiring = lease.clone();
+            let writer = scope.spawn(move || {
+                attempt_tx.try_send(()).unwrap();
+                retiring.retire();
+                done_tx.try_send(()).unwrap();
+            });
+            attempt_rx.recv_timeout(DEADLINE).unwrap();
+            assert!(matches!(
+                done_rx.recv_timeout(STILL_HELD),
+                Err(RecvTimeoutError::Timeout)
+            ));
+            assert_eq!(dropped.load(Ordering::SeqCst), 0);
+
+            releases[0].try_send(()).unwrap();
+            left_rx.recv_timeout(DEADLINE).unwrap();
+            assert!(matches!(
+                lease.value.try_write(),
+                Err(std::sync::TryLockError::WouldBlock)
+            ));
+            assert!(matches!(
+                done_rx.recv_timeout(STILL_HELD),
+                Err(RecvTimeoutError::Timeout)
+            ));
+            assert_eq!(dropped.load(Ordering::SeqCst), 0);
+            assert_eq!(weak.strong_count(), 1);
+
+            releases[1].try_send(()).unwrap();
+            left_rx.recv_timeout(DEADLINE).unwrap();
+            done_rx.recv_timeout(DEADLINE).unwrap();
+            for reader in readers {
+                reader.join().unwrap();
+            }
+            writer.join().unwrap();
+        });
+        assert!(lease.value.read().unwrap().is_none());
+        assert!(weak.upgrade().is_none());
+        assert_eq!(dropped.load(Ordering::SeqCst), 1);
+        lease.retire();
+        assert_eq!(dropped.load(Ordering::SeqCst), 1);
+    }
+
+    #[test]
+    fn physical_quic_memory_transmit_limits_each_segment_peer_and_source_without_queues() {
+        let peer = "192.0.2.1:443".parse().unwrap();
+        let mut packet = Transmit {
+            destination: peer,
+            contents: &[1; 1201],
+            ecn: Some(EcnCodepoint::Ect0),
+            segment_size: Some(1200),
+            src_ip: None,
+        };
+        assert_eq!(validate_transmit(peer, 1200, 8, &packet).unwrap(), 2);
+        assert!(validate_transmit(peer, 1200, 1, &packet).is_err());
+        packet.contents = &[1; 10 * 1200];
+        assert_eq!(validate_transmit(peer, 1200, 64, &packet).unwrap(), 10);
+        packet.contents = &[1; 10 * 1200 + 1];
+        assert!(validate_transmit(peer, 1200, 64, &packet).is_err());
+        packet.contents = &[1; 1200];
+        packet.segment_size = None;
+        assert_eq!(validate_transmit(peer, 1200, 1, &packet).unwrap(), 1);
+        packet.src_ip = Some("192.0.2.2".parse().unwrap());
+        assert!(validate_transmit(peer, 1200, 8, &packet).is_err());
+        packet.src_ip = None;
+        packet.destination.set_port(444);
+        assert!(validate_transmit(peer, 1200, 8, &packet).is_err());
+        packet.destination = peer;
+        packet.segment_size = Some(0);
+        assert!(validate_transmit(peer, 1200, 8, &packet).is_err());
+    }
+    #[test]
+    fn physical_quic_memory_unsegmented_ipv6_preserves_directional_budget() {
+        let peer = "[2001:db8::1]:443".parse().unwrap();
+        let bytes = vec![1; 65_527];
+        let mut packet = Transmit {
+            destination: peer,
+            contents: &bytes,
+            ecn: None,
+            segment_size: None,
+            src_ip: None,
+        };
+        assert_eq!(validate_transmit(peer, 65_527, 1, &packet).unwrap(), 1);
+        assert!(validate_transmit(peer, 65_507, 1, &packet).is_err());
+        // The same payload is too large when advertised as an aggregate.
+        packet.segment_size = Some(32_768);
+        assert!(validate_transmit(peer, 65_527, 8, &packet).is_err());
+        packet.contents = &bytes[..65_507];
+        assert_eq!(validate_transmit(peer, 65_527, 8, &packet).unwrap(), 2);
+    }
+    #[test]
+    fn physical_quic_memory_receive_requires_exact_peer_complete_packet_and_no_gro() {
+        let peer = "[2001:db8::1]:443".parse().unwrap();
+        let mut meta = RecvMeta {
+            addr: peer,
+            len: 1200,
+            stride: 1200,
+            ecn: Some(EcnCodepoint::Ce),
+            dst_ip: Some("2001:db8::2".parse().unwrap()),
+        };
+        assert!(valid_receive(peer, 1200, &meta));
+        meta.len += 1;
+        assert!(!valid_receive(peer, 1200, &meta));
+        meta.len = 1200;
+        meta.stride = 600;
+        assert!(!valid_receive(peer, 1200, &meta));
+        meta.stride = 1200;
+        meta.addr.set_port(444);
+        assert!(!valid_receive(peer, 1200, &meta));
+        meta.addr = peer;
+        meta.len = 0;
+        meta.stride = 0;
+        assert!(!valid_receive(peer, 1200, &meta));
+    }
+}
diff --git a/src/transport/quic/physical_gate.rs b/src/transport/quic/physical_gate.rs
new file mode 100644
index 0000000..6f4a677
--- /dev/null
+++ b/src/transport/quic/physical_gate.rs
@@ -0,0 +1,275 @@
+//! Explicit isolated Linux/TUN resource gate; creates no server or listener.
+use super::super::{DatagramDriver, DatagramSocket, attach_quinn};
+use crate::{
+    ResourceLimits, TunFraming,
+    dialer::{Dialer, PhysicalDatagram},
+    dispatch::{BoxStream, DatagramBudget, DatagramTransport, DispatchError, Dispatcher},
+    outbound::DirectOutbound,
+    platform::{TunFd, TunIo},
+    resources::observation::{ResourceKind, ResourceProbe},
+    session::{Datagram, DatagramSession, Destination, StreamSession},
+    tun_runtime::TunRuntime,
+};
+use async_trait::async_trait;
+use bytes::Bytes;
+use quinn::{
+    AsyncUdpSocket, UdpPoller,
+    udp::{RecvMeta, Transmit},
+};
+use serde::Deserialize;
+use std::{
+    fs,
+    future::poll_fn,
+    io::{self, IoSliceMut},
+    net::SocketAddr,
+    os::fd::AsRawFd,
+    path::PathBuf,
+    pin::Pin,
+    sync::{Arc, Mutex, Weak},
+    task::{Context, Poll, Waker, ready},
+    time::Duration,
+};
+use tokio::time::timeout;
+use tokio_util::sync::CancellationToken;
+
+#[derive(Deserialize)]
+struct Spec {
+    peer: SocketAddr,
+    mode: String,
+}
+struct Held {
+    socket: Arc<DatagramSocket>,
+    pollers: Vec<Pin<Box<dyn UdpPoller>>>,
+    driver: Option<DatagramDriver>,
+    weak: Weak<PhysicalDatagram>,
+    fd: i32,
+    inode: u64,
+}
+struct Gate {
+    dialer: Dialer,
+    peer: SocketAddr,
+    held: Arc<Mutex<Option<Held>>>,
+}
+struct Bridge {
+    socket: Arc<DatagramSocket>,
+    peer: SocketAddr,
+    poller: Pin<Box<dyn UdpPoller>>,
+}
+
+#[async_trait]
+impl Dispatcher for Gate {
+    async fn connect_tcp(&self, _: StreamSession) -> Result<BoxStream, DispatchError> {
+        Err(DispatchError::NotAllowed)
+    }
+    async fn open_datagram(
+        &self,
+        session: DatagramSession,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        assert!(
+            self.held.lock().unwrap().is_none(),
+            "one finite TUN flow only"
+        );
+        let direct = DirectOutbound::new(self.dialer.clone());
+        let raw = direct.open_datagram(session).await?;
+        let (socket, driver) =
+            attach_quinn(raw, self.peer, DatagramBudget::new(1500, 1500)).await?;
+        let (fd, inode, weak) = {
+            let native = socket.physical.as_ref().expect("native DIRECT socket");
+            let lease = native.io.value.read().unwrap();
+            let io = lease.as_ref().unwrap();
+            let fd = io.as_raw_fd();
+            let mut stat = std::mem::MaybeUninit::<libc::stat>::uninit();
+            assert_eq!(unsafe { libc::fstat(fd, stat.as_mut_ptr()) }, 0);
+            (fd, unsafe { stat.assume_init() }.st_ino, Arc::downgrade(io))
+        };
+        let mut pollers = vec![
+            socket.clone().create_io_poller(),
+            socket.clone().create_io_poller(),
+        ];
+        for poller in &mut pollers {
+            assert!(matches!(
+                poller
+                    .as_mut()
+                    .poll_writable(&mut Context::from_waker(Waker::noop())),
+                Poll::Ready(Ok(())) | Poll::Pending
+            ));
+        }
+        let bridge = Bridge {
+            poller: socket.clone().create_io_poller(),
+            socket: socket.clone(),
+            peer: self.peer,
+        };
+        *self.held.lock().unwrap() = Some(Held {
+            socket,
+            pollers,
+            driver: Some(driver),
+            weak,
+            fd,
+            inode,
+        });
+        Ok(Box::new(bridge))
+    }
+}
+#[async_trait]
+impl DatagramTransport for Bridge {
+    fn supports_shared_destinations(&self) -> bool {
+        // This retirement fixture accepts exactly the configured peer.
+        false
+    }
+
+    async fn send(&mut self, packet: Datagram) -> Result<(), DispatchError> {
+        if packet.remote != Destination::Ip(self.peer) {
+            return Err(DispatchError::NotAllowed);
+        }
+        poll_fn(|cx| {
+            match self.socket.try_send(&Transmit {
+                destination: self.peer,
+                contents: &packet.payload,
+                ecn: None,
+                segment_size: None,
+                src_ip: None,
+            }) {
+                Err(error) if error.kind() == io::ErrorKind::WouldBlock => {
+                    ready!(self.poller.as_mut().poll_writable(cx))?;
+                    cx.waker().wake_by_ref();
+                    Poll::Pending
+                }
+                result => Poll::Ready(result),
+            }
+        })
+        .await
+        .map_err(DispatchError::from)
+    }
+    async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+        let mut bytes = [0; 1501];
+        let mut meta = [RecvMeta::default()];
+        poll_fn(|cx| {
+            self.socket
+                .poll_recv(cx, &mut [IoSliceMut::new(&mut bytes)], &mut meta)
+        })
+        .await?;
+        Ok(Datagram {
+            remote: Destination::Ip(meta[0].addr),
+            payload: Bytes::copy_from_slice(&bytes[..meta[0].len]),
+            sniffed_domain: None,
+        })
+    }
+    async fn close(&mut self) -> Result<(), DispatchError> {
+        Ok(())
+    }
+}
+
+#[tokio::test]
+#[ignore = "requires an explicitly owned isolated Linux container and real TUN"]
+async fn real_tun_native_udp_retirement_gate() {
+    assert_eq!(std::env::var("VOLE_INTEROP_ISOLATED").as_deref(), Ok("1"));
+    let root = PathBuf::from(std::env::var_os("VOLE_D05_GATE_DIR").unwrap());
+    let fd: i32 = std::env::var("VOLE_D05_TUN_FD").unwrap().parse().unwrap();
+    let spec: Spec = serde_json::from_slice(&fs::read(root.join("spec.json")).unwrap()).unwrap();
+    assert!(matches!(spec.mode.as_str(), "stop" | "drop"));
+    assert!(!spec.peer.ip().is_loopback() && spec.peer.port() == 24541);
+    let config = crate::config::Config::parse_yaml(
+        b"routing-mark: 42\nexperimental: {quic-go-disable-gso: true, quic-go-disable-ecn: true}\n",
+    )
+    .unwrap();
+    let dialer = Dialer::default()
+        .with_egress(&config.egress)
+        .with_connections(config.connections);
+    let held = Arc::new(Mutex::new(None));
+    let gate = Arc::new(Gate {
+        dialer: dialer.clone(),
+        peer: spec.peer,
+        held: held.clone(),
+    });
+    let tun = TunIo::new(TunFd::duplicate(fd).unwrap(), TunFraming::RawIp).unwrap();
+    let runtime = TunRuntime::new(
+        tun,
+        ResourceLimits::default(),
+        gate,
+        None,
+        false,
+        false,
+        None,
+    )
+    .unwrap();
+    let cancellation = CancellationToken::new();
+    let probe = ResourceProbe::default();
+    let task_probe = probe.clone();
+    let task_cancel = cancellation.clone();
+    let mut running = tokio::spawn(async move { task_probe.scope(runtime.run(task_cancel)).await });
+    fs::write(root.join("ready"), b"real-tun-runtime-created").unwrap();
+    timeout(Duration::from_secs(20), async {
+        loop {
+            tokio::select! {
+                result = &mut running => panic!("TUN ended before explicit stop: {result:?}"),
+                () = tokio::time::sleep(Duration::from_millis(10)) => {
+                    if root.join("stop").exists() { break; }
+                }
+            }
+        }
+    })
+    .await
+    .expect("explicit gate stop not requested");
+    let mut held = held
+        .lock()
+        .unwrap()
+        .take()
+        .expect("actual TUN UDP flow established");
+    assert_eq!(probe.snapshot().current(ResourceKind::Socket), 1);
+    let mut driver = held.driver.take().unwrap();
+    timeout(Duration::from_secs(2), async {
+        if spec.mode == "stop" {
+            driver.stop().await.unwrap();
+        } else {
+            // Retain the private task handle solely to witness its actual join.
+            let task = driver.task.take().unwrap();
+            drop(driver);
+            task.abort();
+            assert!(task.await.unwrap_err().is_cancelled());
+        }
+    })
+    .await
+    .expect("native UDP owner did not join");
+    // No file/report is opened between retirement and these descriptor checks.
+    let mut stat = std::mem::MaybeUninit::<libc::stat>::uninit();
+    let fd_closed = unsafe { libc::fstat(held.fd, stat.as_mut_ptr()) } == -1
+        && io::Error::last_os_error().raw_os_error() == Some(libc::EBADF)
+        && unsafe { libc::fcntl(held.fd, libc::F_GETFD) } == -1
+        && io::Error::last_os_error().raw_os_error() == Some(libc::EBADF);
+    assert!(
+        fd_closed,
+        "retained QUIC handles kept the physical fd alive"
+    );
+    assert!(held.weak.upgrade().is_none());
+    assert_eq!(probe.snapshot().current(ResourceKind::Socket), 0);
+    assert_eq!(
+        held.socket.local_addr().unwrap_err().kind(),
+        io::ErrorKind::BrokenPipe
+    );
+    for poller in &mut held.pollers {
+        for _ in 0..3 {
+            assert!(
+                matches!(poller.as_mut().poll_writable(&mut Context::from_waker(Waker::noop())), Poll::Ready(Err(error)) if error.kind() == io::ErrorKind::BrokenPipe)
+            );
+        }
+    }
+    cancellation.cancel();
+    timeout(Duration::from_secs(2), async {
+        running.await.unwrap().unwrap();
+        dialer.shutdown().await;
+    })
+    .await
+    .unwrap();
+    fs::write(
+        root.join("events.json"),
+        serde_json::to_vec(&serde_json::json!({
+            "mode": spec.mode, "fd": held.fd, "inode": held.inode,
+            "fd_closed": fd_closed, "weak_dropped": true, "sockets_after_stop": 0,
+            "retained_pollers": held.pollers.len(), "stop_joined": true,
+        }))
+        .unwrap(),
+    )
+    .unwrap();
+    // Keep the closed socket and pollers live until all Stop assertions finish.
+    drop(held);
+}
diff --git a/src/transport/quic/policy.rs b/src/transport/quic/policy.rs
new file mode 100644
index 0000000..12c86d2
--- /dev/null
+++ b/src/transport/quic/policy.rs
@@ -0,0 +1,167 @@
+//! Receive credit expressed using only official Quinn transport APIs.
+use crate::config::QuicReceiveWindow;
+
+/// These policies use fixed receive credit, without adaptive windows.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ReceiveWindowPolicy {
+    /// Keep the normalized initial credit for the connection's lifetime.
+    Initial,
+    /// Authorize the larger normalized initial/maximum credit from startup.
+    Maximum,
+    /// Use bounded intermediate stream credit and initial aggregate credit.
+    Middle,
+}
+
+/// Default fixed receive-credit strategy for protocol outbounds.
+pub const RECEIVE_WINDOW_POLICY: ReceiveWindowPolicy = ReceiveWindowPolicy::Middle;
+
+const MIDDLE_STREAM_CREDIT: u64 = 4 * 1024 * 1024;
+
+impl ReceiveWindowPolicy {
+    fn stream_credit(self, window: QuicReceiveWindow) -> u64 {
+        match self {
+            Self::Initial => window.initial,
+            Self::Maximum => window.initial.max(window.maximum),
+            Self::Middle => window.initial.max(window.maximum.min(MIDDLE_STREAM_CREDIT)),
+        }
+    }
+
+    fn connection_credit(self, window: QuicReceiveWindow) -> u64 {
+        match self {
+            Self::Maximum => window.initial.max(window.maximum),
+            Self::Initial | Self::Middle => window.initial,
+        }
+    }
+}
+
+/// Configure independent fixed per-stream and aggregate receive credit.
+///
+/// The caller supplies normalized, wire-representable sizes. Credit bounds
+/// unread data; it does not eagerly allocate a payload buffer of that size.
+pub fn configure_receive_windows(
+    transport: &mut quinn::TransportConfig,
+    stream: QuicReceiveWindow,
+    connection: QuicReceiveWindow,
+    policy: ReceiveWindowPolicy,
+) -> std::io::Result<()> {
+    let wire = |credit| {
+        quinn::VarInt::from_u64(credit)
+            .map_err(|_| std::io::Error::from(std::io::ErrorKind::InvalidInput))
+    };
+    transport
+        .stream_receive_window(wire(policy.stream_credit(stream))?)
+        .receive_window(wire(policy.connection_credit(connection))?);
+    Ok(())
+}
+
+/// Payload capacity for a canonically encoded DATAGRAM with a length field.
+/// Received payload validation cannot recover the peer's actual frame encoding.
+pub(crate) fn datagram_payload_limit(frame_limit: u16) -> usize {
+    let limit = usize::from(frame_limit);
+    // Limits currently stop at 1400, so the length uses one or two bytes.
+    if limit <= 65 {
+        limit.saturating_sub(2).min(63)
+    } else {
+        limit.saturating_sub(3)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn fixed_window_variants_preserve_independent_normalized_bounds() {
+        let stream = QuicReceiveWindow {
+            initial: 10,
+            maximum: 100,
+        };
+        let connection = QuicReceiveWindow {
+            initial: 300,
+            maximum: 200,
+        };
+        assert_eq!(ReceiveWindowPolicy::Initial.stream_credit(stream), 10);
+        assert_eq!(ReceiveWindowPolicy::Maximum.stream_credit(stream), 100);
+        for policy in [
+            ReceiveWindowPolicy::Initial,
+            ReceiveWindowPolicy::Maximum,
+            ReceiveWindowPolicy::Middle,
+        ] {
+            assert_eq!(policy.connection_credit(connection), 300);
+            configure_receive_windows(
+                &mut quinn::TransportConfig::default(),
+                stream,
+                connection,
+                policy,
+            )
+            .unwrap();
+        }
+        assert!(
+            configure_receive_windows(
+                &mut quinn::TransportConfig::default(),
+                QuicReceiveWindow {
+                    initial: 1 << 62,
+                    maximum: 1
+                },
+                connection,
+                ReceiveWindowPolicy::Maximum,
+            )
+            .is_err()
+        );
+    }
+
+    #[test]
+    fn middle_window_bounds_stream_credit_without_expanding_aggregate() {
+        let policy = ReceiveWindowPolicy::Middle;
+        let mib = 1024 * 1024;
+        let tuic_stream = QuicReceiveWindow {
+            initial: 15 * mib / 10,
+            maximum: 15 * mib,
+        };
+        let tuic_connection = QuicReceiveWindow {
+            initial: 64 * mib / 10,
+            maximum: 64 * mib,
+        };
+        assert_eq!(policy.stream_credit(tuic_stream), 4 * mib);
+        assert_eq!(policy.connection_credit(tuic_connection), 64 * mib / 10);
+        for (initial, maximum, expected) in [
+            (mib, 2 * mib, 2 * mib),
+            (8 * mib, 8 * mib, 8 * mib),
+            (7 * mib, 3 * mib, 7 * mib),
+            (5 * mib, 5 * mib, 5 * mib),
+        ] {
+            let window = QuicReceiveWindow { initial, maximum };
+            assert_eq!(policy.stream_credit(window), expected);
+            assert_eq!(policy.connection_credit(window), initial);
+        }
+        let error = configure_receive_windows(
+            &mut quinn::TransportConfig::default(),
+            tuic_stream,
+            QuicReceiveWindow {
+                initial: 1 << 62,
+                maximum: 1,
+            },
+            policy,
+        )
+        .unwrap_err();
+        assert_eq!(error.kind(), std::io::ErrorKind::InvalidInput);
+    }
+
+    #[test]
+    fn canonical_datagram_capacity_accounts_for_varint_boundary() {
+        for (frame, payload) in [
+            (0, 0),
+            (1, 0),
+            (2, 0),
+            (3, 1),
+            (65, 63),
+            (66, 63),
+            (67, 64),
+            (80, 77),
+            (1281, 1278),
+            (1400, 1397),
+        ] {
+            assert_eq!(datagram_payload_limit(frame), payload);
+        }
+    }
+}
diff --git a/src/transport/quiche_h3.rs b/src/transport/quiche_h3.rs
new file mode 100644
index 0000000..1b98fc7
--- /dev/null
+++ b/src/transport/quiche_h3.rs
@@ -0,0 +1,1742 @@
+//! Official quiche HTTP/3 over the shared protected datagram adapter.
+//!
+//! One owner drives QUIC and HTTP/3. Application handles use short synchronous
+//! locks; they never own a socket, resolver, native worker, or event channel.
+use crate::{
+    dispatch::{DatagramBudget, DatagramTransport},
+    security::QuicheTls,
+    transport::quic,
+};
+use bytes::{Buf, Bytes};
+use futures_util::{future::poll_fn, task::AtomicWaker};
+use http::{Request, Response};
+use quiche::h3::NameValue;
+use quinn::AsyncUdpSocket;
+use std::{
+    collections::{BTreeMap, VecDeque},
+    io,
+    net::SocketAddr,
+    sync::{Arc, Mutex},
+    task::{Context, Poll},
+    time::Duration,
+};
+use tokio::sync::Notify;
+use tokio_util::sync::CancellationToken;
+
+pub(crate) const REQUEST_CANCELLED: u64 = 0x10c;
+const CHUNK: usize = crate::transport::STREAM_CHUNK_BYTES;
+const BODY_LIMIT: usize = crate::transport::STREAM_BUFFER_BYTES;
+const DATAGRAM_QUEUE: usize = 64;
+const WORK: usize = 32;
+const RECEIVE_BATCH: usize = 16;
+
+#[derive(Clone, Debug, Default)]
+struct OwnedBuffers;
+impl quiche::BufFactory for OwnedBuffers {
+    type Buf = Bytes;
+    type DgramBuf = Bytes;
+
+    fn buf_from_slice(input: &[u8]) -> Bytes {
+        Bytes::copy_from_slice(input)
+    }
+
+    fn dgram_buf_from_slice(input: &[u8]) -> Bytes {
+        Bytes::copy_from_slice(input)
+    }
+}
+type NativeConnection = quiche::Connection<OwnedBuffers>;
+
+/// Protocol token for a locally admitted extended CONNECT request.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) struct Protocol(pub &'static str);
+impl Protocol {
+    pub const CF_CONNECT_IP: Self = Self("cf-connect-ip");
+}
+
+pub(crate) struct Transport {
+    pub transport: Box<dyn DatagramTransport>,
+    pub peer: SocketAddr,
+    pub budget: DatagramBudget,
+    pub tls: QuicheTls,
+    pub server_name: String,
+}
+#[derive(Clone, Copy)]
+pub(crate) struct Options {
+    pub stream_window: u64,
+    pub connection_window: u64,
+    pub idle: Duration,
+    pub keepalive: Option<Duration>,
+    pub datagrams: bool,
+    pub headers: u64,
+    pub congestion: quiche::CongestionControlAlgorithm,
+    pub send_capacity_factor: f64,
+}
+impl Default for Options {
+    fn default() -> Self {
+        Self {
+            stream_window: 128 * 1024,
+            connection_window: 256 * 1024,
+            idle: Duration::from_secs(74),
+            keepalive: None,
+            datagrams: false,
+            headers: CHUNK as u64,
+            congestion: quiche::CongestionControlAlgorithm::CUBIC,
+            send_capacity_factor: 1.0,
+        }
+    }
+}
+#[derive(Default)]
+struct Signals {
+    read: AtomicWaker,
+    write: AtomicWaker,
+    datagram: AtomicWaker,
+}
+struct Body {
+    signals: Arc<Signals>,
+    headers: Option<Response<()>>,
+    headers_received: bool,
+    trailers_received: bool,
+    data: VecDeque<Bytes>,
+    buffered: usize,
+    readable: bool,
+    finished: bool,
+    failed: bool,
+    receive_owned: bool,
+    send_owned: bool,
+    send_finished: bool,
+    datagrams: Option<VecDeque<Bytes>>,
+}
+impl Body {
+    fn new(signals: Arc<Signals>) -> Self {
+        Self {
+            signals,
+            headers: None,
+            headers_received: false,
+            trailers_received: false,
+            data: VecDeque::new(),
+            buffered: 0,
+            readable: false,
+            finished: false,
+            failed: false,
+            receive_owned: true,
+            send_owned: true,
+            send_finished: false,
+            datagrams: None,
+        }
+    }
+    fn wake(&self) {
+        self.signals.read.wake();
+        self.signals.write.wake();
+        self.signals.datagram.wake();
+    }
+}
+struct State {
+    connection: Option<NativeConnection>,
+    h3: Option<quiche::h3::Connection>,
+    streams: BTreeMap<u64, Body>,
+    closed: bool,
+    goaway: bool,
+    ready: bool,
+    datagram_budget: Option<usize>,
+    settings: Option<Vec<(u64, u64)>>,
+}
+struct Shared {
+    state: Mutex<State>,
+    changed: Notify,
+    status: Notify,
+}
+impl Shared {
+    fn finish(&self) {
+        let mut state = self.state.lock().unwrap();
+        state.closed = true;
+        for body in state.streams.values_mut() {
+            body.failed = true;
+            body.data.clear();
+            body.buffered = 0;
+            body.wake();
+        }
+        state.streams.clear();
+        state.h3.take();
+        state.connection.take();
+        state.datagram_budget = None;
+        drop(state);
+        self.status.notify_waiters();
+        self.changed.notify_one();
+    }
+}
+#[derive(Clone)]
+pub(crate) struct Client {
+    shared: Arc<Shared>,
+}
+impl std::fmt::Debug for Client {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Http3Client").finish_non_exhaustive()
+    }
+}
+pub(crate) struct Driver {
+    shared: Arc<Shared>,
+    socket: Arc<quic::DatagramSocket>,
+    datagram: Option<quic::DatagramDriver>,
+    tls: QuicheTls,
+    options: Options,
+    peer: SocketAddr,
+    local: SocketAddr,
+    mtu: usize,
+}
+impl Driver {
+    pub(crate) async fn new(mut raw: Transport, options: Options) -> io::Result<(Client, Self)> {
+        let prepared = (|| {
+            if raw.server_name != raw.tls.server_name()
+                || raw.peer.port() == 0
+                || raw.peer.ip().is_unspecified()
+                || raw.peer.ip().is_multicast()
+            {
+                return Err(invalid());
+            }
+            let budget = raw.budget.intersect(
+                raw.transport
+                    .payload_budget(&crate::session::Destination::Ip(raw.peer)),
+            );
+            let mtu = budget.quic_payload_limit()? as usize;
+            let local = if raw.peer.is_ipv4() {
+                "0.0.0.0:0"
+            } else {
+                "[::]:0"
+            }
+            .parse()
+            .unwrap();
+            let mut config = raw.tls.build_config()?;
+            config
+                .set_max_idle_timeout(options.idle.as_millis().try_into().map_err(|_| invalid())?);
+            config.set_max_recv_udp_payload_size(budget.receive() as usize);
+            config.set_max_send_udp_payload_size(mtu);
+            config.discover_pmtu(true);
+            config.set_initial_max_data(options.connection_window);
+            config.set_initial_max_stream_data_bidi_local(options.stream_window);
+            config.set_initial_max_stream_data_bidi_remote(options.stream_window);
+            config.set_initial_max_stream_data_uni(CHUNK as u64);
+            config.set_initial_max_streams_bidi(0);
+            config.set_initial_max_streams_uni(8);
+            config.set_max_connection_window(options.connection_window);
+            config.set_max_stream_window(options.stream_window);
+            config.set_cc_algorithm(options.congestion);
+            config.set_send_capacity_factor(options.send_capacity_factor);
+            config.enable_dgram(options.datagrams, DATAGRAM_QUEUE, DATAGRAM_QUEUE);
+            let mut cid = [0_u8; 20];
+            boring::rand::rand_bytes(&mut cid).map_err(failure)?;
+            let mut connection = quiche::connect_with_buffer_factory::<OwnedBuffers>(
+                Some(raw.tls.server_name()),
+                &quiche::ConnectionId::from_ref(&cid),
+                local,
+                raw.peer,
+                &mut config,
+            )
+            .map_err(failure)?;
+            raw.tls.prepare_connection(&mut connection)?;
+            Ok::<_, io::Error>((connection, budget, local, mtu))
+        })();
+        let (connection, budget, local, mtu) = match prepared {
+            Ok(prepared) => prepared,
+            Err(error) => {
+                let _ = tokio::time::timeout(quic::CLOSE_TIMEOUT, raw.transport.close()).await;
+                return Err(error);
+            }
+        };
+        let (socket, datagram) = quic::attach(raw.transport, raw.peer, budget)?;
+        let shared = Arc::new(Shared {
+            state: Mutex::new(State {
+                connection: Some(connection),
+                h3: None,
+                streams: BTreeMap::new(),
+                closed: false,
+                goaway: false,
+                ready: false,
+                datagram_budget: None,
+                settings: None,
+            }),
+            changed: Notify::new(),
+            status: Notify::new(),
+        });
+        Ok((
+            Client {
+                shared: shared.clone(),
+            },
+            Self {
+                shared,
+                socket,
+                datagram: Some(datagram),
+                tls: raw.tls,
+                options,
+                peer: raw.peer,
+                local,
+                mtu,
+            },
+        ))
+    }
+    /// This future owns the adapter until its close and join have completed.
+    pub(crate) async fn run(mut self, cancel: CancellationToken) -> io::Result<()> {
+        let result = self.drive(&cancel).await;
+        self.shared.finish();
+        if let Some(datagram) = self.datagram.take() {
+            let closed = datagram.stop().await;
+            return result.and(closed);
+        }
+        result
+    }
+    async fn drive(&mut self, cancel: &CancellationToken) -> io::Result<()> {
+        // Shared/static upstream packets retain the original bounded scratch
+        // fallback. Unique packets can be decrypted in their owned storage.
+        let mut incoming = Vec::new();
+        let mut output = vec![0; self.mtu];
+        let mut pending: Option<(usize, std::time::Instant)> = None;
+        let mut writable = self.socket.clone().create_io_poller();
+        let mut closing = None;
+        let mut close_sent = false;
+        let mut queued = 0;
+        let mut transmitted = 0;
+        let mut quiet_until = None;
+        let mut keepalive = self
+            .options
+            .keepalive
+            .map(|delay| tokio::time::Instant::now() + delay);
+        loop {
+            // One native-pop allowance for the complete owner turn, including
+            // the outer H3 pass, inline RX and the publication pass below.
+            let mut datagram_work = WORK;
+            if cancel.is_cancelled() && closing.is_none() {
+                closing = Some(tokio::time::Instant::now() + quic::CLOSE_TIMEOUT);
+                let mut state = self.shared.state.lock().unwrap();
+                // Retire admission immediately. Existing halves may still
+                // receive ACKs and send already accepted upload data below.
+                state.goaway = true;
+                self.shared.status.notify_waiters();
+                quiet_until = Some(
+                    tokio::time::Instant::now() + retire_grace(state.connection.as_ref().unwrap()),
+                );
+            }
+            let notify = self.shared.changed.notified();
+            {
+                let mut state = self.shared.state.lock().unwrap();
+                if state
+                    .connection
+                    .as_mut()
+                    .unwrap()
+                    .timeout()
+                    .is_some_and(|delay| delay.is_zero())
+                {
+                    state.connection.as_mut().unwrap().on_timeout();
+                }
+                if state.connection.as_mut().unwrap().is_closed()
+                    || closing.is_some_and(|at| tokio::time::Instant::now() >= at)
+                {
+                    break;
+                }
+                if state.connection.as_mut().unwrap().is_established() && !state.ready {
+                    self.tls
+                        .check_handshake(state.connection.as_mut().unwrap())?;
+                    let mut options = quiche::h3::Config::new().map_err(failure)?;
+                    options.set_max_field_section_size(self.options.headers);
+                    options.enable_extended_connect(true);
+                    state.h3 = Some(
+                        quiche::h3::Connection::with_transport(
+                            state.connection.as_mut().unwrap(),
+                            &options,
+                        )
+                        .map_err(failure)?,
+                    );
+                    state.ready = true;
+                    self.shared.status.notify_waiters();
+                }
+                process_h3(&mut state, &mut datagram_work)?;
+                state.datagram_budget = state.connection.as_mut().unwrap().dgram_max_writable_len();
+                if closing.is_none()
+                    && keepalive.is_some_and(|at| tokio::time::Instant::now() >= at)
+                {
+                    let _ = state.connection.as_mut().unwrap().send_ack_eliciting();
+                    keepalive = self
+                        .options
+                        .keepalive
+                        .map(|delay| tokio::time::Instant::now() + delay);
+                }
+                // Wakes application backpressure after ACK/credit processing.
+                for body in state.streams.values() {
+                    body.signals.write.wake();
+                }
+                self.shared.status.notify_waiters();
+            }
+            let mut native_idle = false;
+            let mut timeout = {
+                let mut sending = self.shared.state.lock().unwrap();
+                for _ in 0..WORK {
+                    if pending.is_none() {
+                        let sent = sending.connection.as_mut().unwrap().send(&mut output);
+                        match sent {
+                            Ok((n, info)) if info.to == self.peer => pending = Some((n, info.at)),
+                            Ok(_) => return Err(invalid()),
+                            Err(quiche::Error::Done) => {
+                                native_idle = true;
+                                break;
+                            }
+                            Err(error) => return Err(failure(error)),
+                        }
+                    }
+                    let (n, at) = pending.unwrap();
+                    if at > std::time::Instant::now() {
+                        break;
+                    }
+                    match self.socket.try_send(&quinn::udp::Transmit {
+                        destination: self.peer,
+                        ecn: None,
+                        contents: &output[..n],
+                        segment_size: None,
+                        src_ip: None,
+                    }) {
+                        Ok(()) => {
+                            pending = None;
+                            queued += 1;
+                        }
+                        Err(error) if error.kind() == io::ErrorKind::WouldBlock => break,
+                        Err(error) => return Err(error),
+                    }
+                }
+                // Native send arms recovery timers, including an isolated PTO.
+                sending
+                    .connection
+                    .as_ref()
+                    .unwrap()
+                    .timeout()
+                    .map(|delay| tokio::time::Instant::now() + delay)
+            };
+            let sent = self.socket.stats().sent;
+            if sent != transmitted {
+                transmitted = sent;
+                if closing.is_some() && !close_sent {
+                    let state = self.shared.state.lock().unwrap();
+                    quiet_until = Some(
+                        tokio::time::Instant::now()
+                            + retire_grace(state.connection.as_ref().unwrap()),
+                    );
+                }
+            }
+            if closing.is_some()
+                && !close_sent
+                && native_idle
+                && pending.is_none()
+                && transmitted >= queued
+                && quiet_until.is_some_and(|at| tokio::time::Instant::now() >= at)
+            {
+                // FIN acceptance is not an ACK barrier. Give native queues and
+                // the controlled transport bounded continued IO before close
+                // can preempt them; never extend the original close deadline.
+                let mut state = self.shared.state.lock().unwrap();
+                let connection = state.connection.as_mut().unwrap();
+                let _ = connection.close(true, 0x100, b"");
+                // Close may replace the timer sampled after the send loop.
+                timeout = connection
+                    .timeout()
+                    .map(|delay| tokio::time::Instant::now() + delay);
+                close_sent = true;
+                drop(state);
+                self.shared.changed.notify_one();
+            }
+            let deadline = timeout
+                .into_iter()
+                .chain(closing)
+                .chain(keepalive.filter(|_| closing.is_none()))
+                .chain(quiet_until.filter(|_| {
+                    closing.is_some() && !close_sent && pending.is_none() && transmitted >= queued
+                }))
+                .chain(
+                    pending
+                        .filter(|(_, at)| *at > std::time::Instant::now())
+                        .map(|(_, at)| tokio::time::Instant::from_std(at)),
+                )
+                .min();
+            let recv = poll_fn(|cx| {
+                let mut state = self.shared.state.lock().unwrap();
+                let mut received = false;
+                // A previous drain may have exhausted this turn's allowance.
+                // Return to control/send/timeout work even if no UDP arrives.
+                if self.options.datagrams
+                    && state.connection.as_ref().unwrap().dgram_recv_queue_len() != 0
+                {
+                    return Poll::Ready(Ok(()));
+                }
+                // Decode one ready burst before delivering H3 bodies and
+                // waking writers. Never wait for a batch to fill or retain
+                // additional packet buffers, and bound owner work per poll.
+                for _ in 0..RECEIVE_BATCH {
+                    match self.socket.poll_recv_owned(cx) {
+                        Poll::Ready(Ok(payload)) => {
+                            let info = quiche::RecvInfo {
+                                from: self.peer,
+                                to: self.local,
+                            };
+                            let connection = state.connection.as_mut().unwrap();
+                            let result = match payload.try_into_mut() {
+                                Ok(mut payload) => connection.recv(&mut payload, info),
+                                Err(payload) => {
+                                    if incoming.is_empty() {
+                                        incoming.resize(self.socket.budget().receive() as usize, 0);
+                                    }
+                                    incoming[..payload.len()].copy_from_slice(&payload);
+                                    connection.recv(&mut incoming[..payload.len()], info)
+                                }
+                            };
+                            match result {
+                                Ok(_) | Err(quiche::Error::Done) => {}
+                                Err(error) => {
+                                    // Inline frames are still private under
+                                    // State; do not publish them on failure.
+                                    if self.options.datagrams {
+                                        state.closed = true;
+                                    }
+                                    return Poll::Ready(Err(failure(error)));
+                                }
+                            }
+                            received = true;
+                            if self.options.datagrams {
+                                if state.connection.as_ref().unwrap().is_closed() {
+                                    // The next outer turn performs the usual
+                                    // finish/adapter stop. Readers must see
+                                    // native close before any batched frame.
+                                    state.closed = true;
+                                    break;
+                                }
+                                if state.h3.is_some()
+                                    && let Err(error) =
+                                        drain_datagrams(&mut state, &mut datagram_work)
+                                {
+                                    state.closed = true;
+                                    return Poll::Ready(Err(error));
+                                }
+                                if datagram_work == 0 {
+                                    break;
+                                }
+                            }
+                            // Before H3 is ready, keep the existing immediate
+                            // return so settings/control admission runs first.
+                            if state.connection.as_ref().unwrap().dgram_recv_queue_len() != 0 {
+                                break;
+                            }
+                        }
+                        Poll::Ready(Err(error)) => {
+                            if self.options.datagrams {
+                                state.closed = true;
+                            }
+                            return Poll::Ready(Err(error));
+                        }
+                        Poll::Pending => break,
+                    }
+                }
+                if received && self.options.datagrams && !state.closed {
+                    let connection = state.connection.as_mut().unwrap();
+                    if connection.timeout().is_some_and(|delay| delay.is_zero()) {
+                        connection.on_timeout();
+                    }
+                    if connection.is_closed()
+                        || closing.is_some_and(|at| tokio::time::Instant::now() >= at)
+                    {
+                        state.closed = true;
+                    }
+                }
+                if received && self.options.datagrams && !state.closed {
+                    // State stays locked across RX, native insertion, H3
+                    // FIN/RESET and reliable-body delivery. Already-runnable
+                    // readers cannot observe a batch before its terminal
+                    // events; wake suppression alone would not ensure this.
+                    // This is one extra bounded H3 pass, not one per UDP.
+                    // Its native drain shares the same allowance above.
+                    if let Err(error) = process_h3(&mut state, &mut datagram_work) {
+                        state.closed = true;
+                        return Poll::Ready(Err(error));
+                    }
+                }
+                if received {
+                    Poll::Ready(Ok(()))
+                } else {
+                    Poll::Pending
+                }
+            });
+            tokio::select! {
+                biased;
+                () = cancel.cancelled(), if closing.is_none() => {},
+                received = recv => { received?; },
+                () = notify => {},
+                result = poll_fn(|cx| self.socket.poll_transmitted(cx, queued)), if closing.is_some() && !close_sent && pending.is_none() && transmitted < queued => { result?; },
+                result = poll_fn(|cx| writable.as_mut().poll_writable(cx)), if pending.is_some_and(|(_, at)| at <= std::time::Instant::now()) => { result?; },
+                () = async { match deadline { Some(at) => tokio::time::sleep_until(at).await, None => std::future::pending().await } } => {
+                    let mut state = self.shared.state.lock().unwrap();
+                    if state.connection.as_mut().unwrap().timeout().is_some_and(|delay| delay.is_zero()) { state.connection.as_mut().unwrap().on_timeout(); }
+                },
+            }
+        }
+        Ok(())
+    }
+}
+// A retirement grace follows real transport progress and measured RTT. It is
+// only an opportunity to deliver queued data, never proof of remote receipt.
+fn retire_grace(connection: &NativeConnection) -> Duration {
+    connection
+        .path_stats()
+        .filter(|path| path.active)
+        .map(|path| path.rtt)
+        .max()
+        .unwrap_or(Duration::ZERO)
+        .saturating_mul(2)
+        .saturating_add(Duration::from_millis(25))
+        .min(quic::CLOSE_TIMEOUT)
+}
+fn process_h3(state: &mut State, datagram_work: &mut usize) -> io::Result<()> {
+    let Some(h3) = state.h3.as_mut() else {
+        return Ok(());
+    };
+    for _ in 0..WORK {
+        match h3.poll(state.connection.as_mut().unwrap()) {
+            Ok((id, quiche::h3::Event::Headers { list, .. })) => {
+                let Some(body) = state.streams.get_mut(&id) else {
+                    let _ = state.connection.as_mut().unwrap().stream_shutdown(
+                        id,
+                        quiche::Shutdown::Read,
+                        REQUEST_CANCELLED,
+                    );
+                    continue;
+                };
+                let (status, headers) = parse_headers(list)?;
+                if let Some(status) = status {
+                    if status.is_informational() {
+                        continue;
+                    }
+                    if body.headers_received {
+                        body.failed = true;
+                    } else {
+                        body.headers_received = true;
+                        let mut response = Response::new(());
+                        *response.status_mut() = status;
+                        *response.version_mut() = http::Version::HTTP_3;
+                        *response.headers_mut() = headers;
+                        body.headers = Some(response);
+                    }
+                } else if body.headers_received && !body.trailers_received {
+                    body.trailers_received = true;
+                } else {
+                    body.failed = true;
+                }
+                body.signals.read.wake();
+            }
+            Ok((id, quiche::h3::Event::Data)) => {
+                if let Some(body) = state.streams.get_mut(&id) {
+                    body.readable = true;
+                }
+            }
+            Ok((id, quiche::h3::Event::Finished)) => {
+                if let Some(body) = state.streams.get_mut(&id) {
+                    body.finished = true;
+                    body.signals.read.wake();
+                }
+            }
+            Ok((id, quiche::h3::Event::Reset(_))) => {
+                if let Some(body) = state.streams.get_mut(&id) {
+                    body.failed = true;
+                    body.wake();
+                }
+            }
+            Ok((_, quiche::h3::Event::GoAway)) => {
+                state.goaway = true;
+            }
+            Ok(_) => {}
+            Err(quiche::h3::Error::Done) => break,
+            Err(error) => return Err(failure(error)),
+        }
+    }
+    if state.settings.is_none() {
+        state.settings = h3.peer_settings_raw().map(|settings| settings.to_vec());
+    }
+    let mut buf = [0; CHUNK];
+    for (&id, body) in &mut state.streams {
+        for _ in 0..BODY_LIMIT / CHUNK {
+            if !body.readable || body.buffered == BODY_LIMIT || !body.receive_owned {
+                break;
+            }
+            let maximum = buf.len().min(BODY_LIMIT - body.buffered);
+            match h3.recv_body(state.connection.as_mut().unwrap(), id, &mut buf[..maximum]) {
+                Ok(n) => {
+                    body.buffered += n;
+                    body.data.push_back(Bytes::copy_from_slice(&buf[..n]));
+                    body.signals.read.wake();
+                }
+                Err(quiche::h3::Error::Done) => {
+                    body.readable = false;
+                    break;
+                }
+                Err(_) => {
+                    body.failed = true;
+                    body.wake();
+                    break;
+                }
+            }
+        }
+    }
+    drain_datagrams(state, datagram_work)
+}
+fn drain_datagrams(state: &mut State, remaining: &mut usize) -> io::Result<()> {
+    // Unknown, invalid-flow and full-Body frames consume the same allowance;
+    // moving existing Bytes never creates a new flow or intermediate queue.
+    while *remaining != 0 {
+        match state.connection.as_mut().unwrap().dgram_recv_buf() {
+            Ok(frame) => {
+                *remaining -= 1;
+                if frame.len() > CHUNK {
+                    return Err(failure(quiche::Error::BufferTooShort));
+                }
+                let Some((flow, _)) = varint(&frame) else {
+                    continue;
+                };
+                let Some(id) = flow.checked_mul(4) else {
+                    continue;
+                };
+                let Some(queue) = state
+                    .streams
+                    .get_mut(&id)
+                    .and_then(|body| body.datagrams.as_mut())
+                else {
+                    continue;
+                };
+                if queue.len() < DATAGRAM_QUEUE {
+                    queue.push_back(frame);
+                    state.streams[&id].signals.datagram.wake();
+                }
+            }
+            Err(quiche::Error::Done) => break,
+            Err(error) => return Err(failure(error)),
+        }
+    }
+    Ok(())
+}
+fn parse_headers(
+    list: Vec<quiche::h3::Header>,
+) -> io::Result<(Option<http::StatusCode>, http::HeaderMap)> {
+    let mut status = None;
+    let mut headers = http::HeaderMap::new();
+    let mut bytes = 0;
+    for header in list {
+        bytes += header.name().len() + header.value().len();
+        if bytes > CHUNK {
+            return Err(invalid());
+        }
+        if header.name() == b":status" {
+            if status.is_some() {
+                return Err(invalid());
+            }
+            status = Some(http::StatusCode::from_bytes(header.value()).map_err(|_| invalid())?);
+        } else if header.name().starts_with(b":") {
+            return Err(invalid());
+        } else {
+            headers.append(
+                http::HeaderName::from_bytes(header.name()).map_err(|_| invalid())?,
+                http::HeaderValue::from_bytes(header.value()).map_err(|_| invalid())?,
+            );
+        }
+    }
+    Ok((status, headers))
+}
+impl Client {
+    pub(crate) async fn ready(&self, require_datagram_settings: bool) -> io::Result<()> {
+        loop {
+            let notified = self.shared.status.notified();
+            tokio::pin!(notified);
+            notified.as_mut().enable();
+            {
+                let state = self.shared.state.lock().unwrap();
+                if state.closed {
+                    return Err(closed());
+                }
+                if state.ready {
+                    if !require_datagram_settings {
+                        return Ok(());
+                    }
+                    if let Some(settings) = state.settings.as_ref() {
+                        return if settings.iter().any(|&(id, value)| id == 0x33 && value == 1) {
+                            Ok(())
+                        } else {
+                            Err(invalid())
+                        };
+                    }
+                }
+            }
+            notified.await;
+        }
+    }
+    pub(crate) fn can_open_request(&self) -> bool {
+        let state = self.shared.state.lock().unwrap();
+        !state.closed && !state.goaway && state.ready
+    }
+    pub(crate) fn close_reason(&self) -> Option<()> {
+        let state = self.shared.state.lock().unwrap();
+        (state.closed
+            || state
+                .connection
+                .as_ref()
+                .is_none_or(NativeConnection::is_closed))
+        .then_some(())
+    }
+    pub(crate) async fn send_request(&mut self, request: Request<()>) -> io::Result<RequestStream> {
+        let headers = request_headers(&request)?;
+        loop {
+            let notified = self.shared.status.notified();
+            tokio::pin!(notified);
+            notified.as_mut().enable();
+            {
+                let mut state = self.shared.state.lock().unwrap();
+                if state.closed || state.goaway {
+                    return Err(closed());
+                }
+                let State {
+                    connection,
+                    h3,
+                    streams,
+                    ..
+                } = &mut *state;
+                if let Some(h3) = h3.as_mut() {
+                    match h3.send_request(connection.as_mut().unwrap(), &headers, false) {
+                        Ok(id) => {
+                            let signals = Arc::new(Signals::default());
+                            streams.insert(id, Body::new(signals.clone()));
+                            drop(state);
+                            self.shared.changed.notify_one();
+                            return Ok(RequestStream {
+                                send: SendStream {
+                                    client: self.clone(),
+                                    id,
+                                    signals: signals.clone(),
+                                },
+                                receive: RecvStream {
+                                    client: self.clone(),
+                                    id,
+                                    signals,
+                                },
+                            });
+                        }
+                        Err(quiche::h3::Error::StreamBlocked)
+                        | Err(quiche::h3::Error::TransportError(quiche::Error::StreamLimit)) => {}
+                        Err(error) => return Err(failure(error)),
+                    }
+                }
+            }
+            notified.await;
+        }
+    }
+    pub(crate) fn max_datagram_size(&self) -> Option<usize> {
+        self.shared.state.lock().unwrap().datagram_budget
+    }
+    pub(crate) fn register_datagrams(&self, id: u64) -> io::Result<()> {
+        self.shared
+            .state
+            .lock()
+            .unwrap()
+            .streams
+            .get_mut(&id)
+            .ok_or_else(closed)?
+            .datagrams = Some(VecDeque::new());
+        Ok(())
+    }
+    pub(crate) async fn send_datagram_wait(&self, frame: Bytes) -> io::Result<()> {
+        loop {
+            let notified = self.shared.status.notified();
+            tokio::pin!(notified);
+            notified.as_mut().enable();
+            {
+                let mut state = self.shared.state.lock().unwrap();
+                if state.closed {
+                    return Err(closed());
+                }
+                match state
+                    .connection
+                    .as_mut()
+                    .unwrap()
+                    .dgram_send_buf(frame.clone())
+                {
+                    Ok(()) => {
+                        drop(state);
+                        self.shared.changed.notify_one();
+                        return Ok(());
+                    }
+                    Err(quiche::Error::Done) => {}
+                    Err(quiche::Error::BufferTooShort) => {
+                        return Err(io::ErrorKind::InvalidInput.into());
+                    }
+                    Err(error) => return Err(failure(error)),
+                }
+            }
+            notified.await;
+        }
+    }
+    pub(crate) async fn read_datagram(&self, id: u64) -> io::Result<Bytes> {
+        poll_fn(|cx| {
+            let mut state = self.shared.state.lock().unwrap();
+            if state.closed {
+                return Poll::Ready(Err(closed()));
+            }
+            let body = state.streams.get_mut(&id).ok_or_else(closed)?;
+            if body.failed || body.finished || !body.receive_owned {
+                return Poll::Ready(Err(closed()));
+            }
+            let queue = body.datagrams.as_mut().ok_or_else(closed)?;
+            if let Some(frame) = queue.pop_front() {
+                Poll::Ready(Ok(frame))
+            } else {
+                // The owner also holds State when delivering progress. Only
+                // blocked operations register, with no gap for a lost wake.
+                body.signals.datagram.register(cx.waker());
+                Poll::Pending
+            }
+        })
+        .await
+    }
+}
+fn request_headers(request: &Request<()>) -> io::Result<Vec<quiche::h3::Header>> {
+    let mut headers = vec![quiche::h3::Header::new(
+        b":method",
+        request.method().as_str().as_bytes(),
+    )];
+    let connect = request.method() == http::Method::CONNECT;
+    let protocol = request.extensions().get::<Protocol>();
+    if !connect || protocol.is_some() {
+        headers.push(quiche::h3::Header::new(
+            b":scheme",
+            request.uri().scheme_str().ok_or_else(invalid)?.as_bytes(),
+        ));
+        headers.push(quiche::h3::Header::new(
+            b":path",
+            request
+                .uri()
+                .path_and_query()
+                .map_or("/", |path| path.as_str())
+                .as_bytes(),
+        ));
+    }
+    headers.push(quiche::h3::Header::new(
+        b":authority",
+        request
+            .uri()
+            .authority()
+            .ok_or_else(invalid)?
+            .as_str()
+            .as_bytes(),
+    ));
+    if let Some(protocol) = protocol {
+        headers.push(quiche::h3::Header::new(b":protocol", protocol.0.as_bytes()));
+    }
+    for (name, value) in request.headers() {
+        if name != http::header::HOST {
+            headers.push(quiche::h3::Header::new(
+                name.as_str().as_bytes(),
+                value.as_bytes(),
+            ));
+        }
+    }
+    if headers
+        .iter()
+        .map(|header| header.name().len() + header.value().len())
+        .sum::<usize>()
+        > CHUNK
+    {
+        return Err(invalid());
+    }
+    Ok(headers)
+}
+pub(crate) struct RequestStream {
+    send: SendStream,
+    receive: RecvStream,
+}
+impl RequestStream {
+    pub(crate) fn id(&self) -> StreamId {
+        StreamId(self.send.id)
+    }
+    pub(crate) fn split(self) -> (SendStream, RecvStream) {
+        (self.send, self.receive)
+    }
+}
+pub(crate) struct StreamId(u64);
+impl StreamId {
+    pub(crate) fn into_inner(self) -> u64 {
+        self.0
+    }
+}
+pub(crate) struct SendStream {
+    client: Client,
+    id: u64,
+    signals: Arc<Signals>,
+}
+impl SendStream {
+    pub(crate) async fn send_data(&mut self, mut data: Bytes) -> io::Result<()> {
+        while !data.is_empty() {
+            let maximum = data.len().min(CHUNK);
+            let mut chunk = data.slice(..maximum);
+            let n = poll_fn(|cx| {
+                let mut state = self.client.shared.state.lock().unwrap();
+                if state.closed
+                    || state
+                        .streams
+                        .get(&self.id)
+                        .is_none_or(|body| body.failed || !body.send_owned || body.send_finished)
+                {
+                    return Poll::Ready(Err(closed()));
+                }
+                let State { connection, h3, .. } = &mut *state;
+                match h3.as_mut().unwrap().send_body_zc(
+                    connection.as_mut().unwrap(),
+                    self.id,
+                    &mut chunk,
+                    false,
+                ) {
+                    Ok(n) if n > 0 => {
+                        drop(state);
+                        self.client.shared.changed.notify_one();
+                        Poll::Ready(Ok(n))
+                    }
+                    Ok(_) | Err(quiche::h3::Error::Done) => {
+                        self.signals.write.register(cx.waker());
+                        Poll::Pending
+                    }
+                    Err(error) => Poll::Ready(Err(failure(error))),
+                }
+            })
+            .await?;
+            data.advance(n);
+        }
+        Ok(())
+    }
+    pub(crate) async fn finish(&mut self) -> io::Result<()> {
+        poll_fn(|cx| {
+            let mut state = self.client.shared.state.lock().unwrap();
+            if state.closed
+                || state
+                    .streams
+                    .get(&self.id)
+                    .is_none_or(|body| body.failed || !body.send_owned)
+            {
+                return Poll::Ready(Err(closed()));
+            }
+            if state.streams[&self.id].send_finished {
+                return Poll::Ready(Ok(()));
+            }
+            let State { connection, h3, .. } = &mut *state;
+            match h3
+                .as_mut()
+                .unwrap()
+                .send_body(connection.as_mut().unwrap(), self.id, &[], true)
+            {
+                Ok(_) => {
+                    state.streams.get_mut(&self.id).unwrap().send_finished = true;
+                    drop(state);
+                    self.client.shared.changed.notify_one();
+                    Poll::Ready(Ok(()))
+                }
+                Err(quiche::h3::Error::Done) => {
+                    self.signals.write.register(cx.waker());
+                    Poll::Pending
+                }
+                Err(error) => Poll::Ready(Err(failure(error))),
+            }
+        })
+        .await
+    }
+    pub(crate) fn stop_stream(&mut self, code: u64) {
+        stop_half(&self.client, self.id, true, code);
+    }
+}
+impl Drop for SendStream {
+    fn drop(&mut self) {
+        stop_half(&self.client, self.id, true, REQUEST_CANCELLED);
+    }
+}
+pub(crate) struct RecvStream {
+    client: Client,
+    id: u64,
+    signals: Arc<Signals>,
+}
+impl RecvStream {
+    pub(crate) async fn recv_response(&mut self) -> io::Result<Response<()>> {
+        poll_fn(|cx| {
+            let mut state = self.client.shared.state.lock().unwrap();
+            if state.closed {
+                return Poll::Ready(Err(closed()));
+            }
+            let Some(body) = state.streams.get_mut(&self.id) else {
+                return Poll::Ready(Err(closed()));
+            };
+            if body.failed || !body.receive_owned {
+                return Poll::Ready(Err(closed()));
+            }
+            if let Some(headers) = body.headers.take() {
+                return Poll::Ready(Ok(headers));
+            }
+            if body.finished {
+                return Poll::Ready(Err(invalid()));
+            }
+            self.signals.read.register(cx.waker());
+            Poll::Pending
+        })
+        .await
+    }
+    pub(crate) fn poll_recv_data(
+        &mut self,
+        cx: &mut Context<'_>,
+    ) -> Poll<io::Result<Option<Bytes>>> {
+        let mut state = self.client.shared.state.lock().unwrap();
+        if state.closed {
+            return Poll::Ready(Err(closed()));
+        }
+        let Some(body) = state.streams.get_mut(&self.id) else {
+            return Poll::Ready(Err(closed()));
+        };
+        if body.failed || !body.receive_owned {
+            return Poll::Ready(Err(closed()));
+        }
+        if let Some(data) = body.data.pop_front() {
+            body.buffered -= data.len();
+            drop(state);
+            self.client.shared.changed.notify_one();
+            return Poll::Ready(Ok(Some(data)));
+        }
+        if body.finished {
+            return Poll::Ready(Ok(None));
+        }
+        self.signals.read.register(cx.waker());
+        Poll::Pending
+    }
+    pub(crate) fn stop_sending(&mut self, code: u64) {
+        stop_half(&self.client, self.id, false, code);
+    }
+}
+impl Drop for RecvStream {
+    fn drop(&mut self) {
+        stop_half(&self.client, self.id, false, REQUEST_CANCELLED);
+    }
+}
+fn stop_half(client: &Client, id: u64, send: bool, code: u64) {
+    let mut state = client.shared.state.lock().unwrap();
+    let Some(body) = state.streams.get_mut(&id) else {
+        return;
+    };
+    let owned = if send {
+        &mut body.send_owned
+    } else {
+        &mut body.receive_owned
+    };
+    if !*owned {
+        return;
+    }
+    *owned = false;
+    let graceful = if send {
+        body.send_finished
+    } else {
+        body.finished
+    };
+    if !send {
+        body.data.clear();
+        body.buffered = 0;
+        body.datagrams.take();
+    }
+    let remove = !body.send_owned && !body.receive_owned;
+    if !graceful {
+        let _ = state.connection.as_mut().unwrap().stream_shutdown(
+            id,
+            if send {
+                quiche::Shutdown::Write
+            } else {
+                quiche::Shutdown::Read
+            },
+            code,
+        );
+    }
+    if remove {
+        state.streams.remove(&id);
+    }
+    drop(state);
+    client.shared.changed.notify_one();
+}
+fn varint(bytes: &[u8]) -> Option<(u64, usize)> {
+    let first = *bytes.first()?;
+    let len = 1 << (first >> 6);
+    if bytes.len() < len {
+        return None;
+    }
+    let mut value = u64::from(first & 63);
+    for byte in &bytes[1..len] {
+        value = (value << 8) | u64::from(*byte);
+    }
+    Some((value, len))
+}
+fn invalid() -> io::Error {
+    io::ErrorKind::InvalidData.into()
+}
+fn closed() -> io::Error {
+    io::ErrorKind::ConnectionAborted.into()
+}
+fn failure(_: impl std::fmt::Display) -> io::Error {
+    io::Error::other("HTTP/3 transport failed")
+}
+
+/// Meta BBR labels select the public quiche BBRv2 controller.
+pub(crate) fn congestion_controller(name: &str) -> Option<quiche::CongestionControlAlgorithm> {
+    Some(match name {
+        "cubic" => quiche::CongestionControlAlgorithm::CUBIC,
+        "new_reno" => quiche::CongestionControlAlgorithm::Reno,
+        "bbr" | "bbr_meta_v1" | "bbr_meta_v2" => {
+            quiche::CongestionControlAlgorithm::Bbr2Gcongestion
+        }
+        _ => return None,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        dispatch::DispatchError,
+        security::{SecurityContext, StandardTlsClient, TlsClientOptions, TlsVersions},
+        session::{Datagram, Destination},
+    };
+    use async_trait::async_trait;
+    use tokio::sync::mpsc;
+
+    struct Packets {
+        send: mpsc::Sender<Bytes>,
+        receive: mpsc::Receiver<Bytes>,
+        peer: SocketAddr,
+        closed: Arc<std::sync::atomic::AtomicBool>,
+    }
+    #[async_trait]
+    impl DatagramTransport for Packets {
+        fn supports_shared_destinations(&self) -> bool {
+            false
+        }
+
+        fn payload_budget(&self, _: &Destination) -> DatagramBudget {
+            DatagramBudget::new(1400, 1400)
+        }
+        async fn send(&mut self, datagram: Datagram) -> Result<(), DispatchError> {
+            assert_eq!(datagram.remote, Destination::Ip(self.peer));
+            self.send
+                .send(datagram.payload)
+                .await
+                .map_err(|_| DispatchError::NotAllowed)
+        }
+        async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+            Ok(Datagram {
+                remote: Destination::Ip(self.peer),
+                payload: self.receive.recv().await.ok_or(DispatchError::NotAllowed)?,
+                sniffed_domain: None,
+            })
+        }
+        async fn close(&mut self) -> Result<(), DispatchError> {
+            self.closed
+                .store(true, std::sync::atomic::Ordering::Release);
+            self.receive.close();
+            Ok(())
+        }
+    }
+
+    /// Real TLS/QUIC/HTTP3 peer entirely in bounded memory channels. The server
+    /// sends unsolicited flow IDs without allowing those IDs to admit clients.
+    async fn peer(
+        mut packets: mpsc::Receiver<Bytes>,
+        outgoing: mpsc::Sender<Bytes>,
+        mut config: quiche::Config,
+        cancel: CancellationToken,
+        flood: usize,
+        progress: Arc<std::sync::atomic::AtomicUsize>,
+    ) {
+        let local: SocketAddr = "192.0.2.1:443".parse().unwrap();
+        let remote: SocketAddr = "0.0.0.0:0".parse().unwrap();
+        let first = tokio::select! {
+            () = cancel.cancelled() => return,
+            first = packets.recv() => first,
+        };
+        let Some(mut first) = first.map(|packet| packet.to_vec()) else {
+            return;
+        };
+        let header = quiche::Header::from_slice(&mut first, 20).unwrap();
+        let cid = header.dcid.into_owned();
+        let mut connection = quiche::accept(&cid, None, local, remote, &mut config).unwrap();
+        connection
+            .recv(
+                &mut first,
+                quiche::RecvInfo {
+                    from: remote,
+                    to: local,
+                },
+            )
+            .unwrap();
+        let mut h3 = None;
+        let mut request = None;
+        let mut flooded = 0;
+        let mut response = false;
+        let mut legitimate = false;
+        let mut buf = [0; 1400];
+        let mut pending = None;
+        loop {
+            if connection.is_established() && h3.is_none() {
+                let mut config = quiche::h3::Config::new().unwrap();
+                config.enable_extended_connect(true);
+                h3 =
+                    Some(quiche::h3::Connection::with_transport(&mut connection, &config).unwrap());
+            }
+            if let Some(h3) = h3.as_mut() {
+                while let Ok((id, event)) = h3.poll(&mut connection) {
+                    if let quiche::h3::Event::Headers { list, .. } = event {
+                        assert!(list.iter().any(|header| header.name() == b":protocol"
+                            && header.value() == b"cf-connect-ip"));
+                        request = Some(id);
+                    }
+                }
+                if let Some(id) = request {
+                    if !response {
+                        match h3.send_response(
+                            &mut connection,
+                            id,
+                            &[quiche::h3::Header::new(b":status", b"200")],
+                            false,
+                        ) {
+                            Ok(()) => response = true,
+                            Err(quiche::h3::Error::StreamBlocked) => {}
+                            Err(error) => panic!("{error:?}"),
+                        }
+                    }
+                    for _ in 0..64 {
+                        if flooded < flood {
+                            // Each unknown request-flow ID fits one two-byte
+                            // varint and has no associated admitted stream.
+                            let flow = 0x4000_u16 | (1000 + flooded) as u16;
+                            let mut frame = flow.to_be_bytes().to_vec();
+                            frame.push(0);
+                            frame.extend_from_slice(&[0x55; 128]);
+                            match connection.dgram_send(&frame) {
+                                Ok(()) => {
+                                    flooded += 1;
+                                    progress.store(flooded, std::sync::atomic::Ordering::Release);
+                                }
+                                Err(quiche::Error::Done) => break,
+                                Err(error) => panic!("{error:?}"),
+                            }
+                        } else if !legitimate {
+                            let frame = [((id / 4) as u8), 0, 0x42];
+                            match connection.dgram_send(&frame) {
+                                Ok(()) => legitimate = true,
+                                Err(quiche::Error::Done) => {}
+                                Err(error) => panic!("{error:?}"),
+                            }
+                            break;
+                        } else {
+                            break;
+                        }
+                    }
+                }
+            }
+            // One pending output packet keeps a full memory channel from
+            // blocking peer receive/ACK processing on this same task.
+            if pending.is_none() {
+                match connection.send(&mut buf) {
+                    Ok((n, info)) => {
+                        pending = Some((Bytes::copy_from_slice(&buf[..n]), info.at));
+                    }
+                    Err(quiche::Error::Done) => {}
+                    Err(error) => panic!("{error:?}"),
+                }
+            }
+            if connection.is_closed() {
+                // A remote QUIC close does not close a physical UDP socket.
+                // Keep the memory transport alive through the client's Stop.
+                cancel.cancelled().await;
+                break;
+            }
+            let now = std::time::Instant::now();
+            let deadline = connection
+                .timeout()
+                .map(|delay| now + delay)
+                .into_iter()
+                .chain(
+                    pending
+                        .as_ref()
+                        .filter(|(_, at)| *at > now)
+                        .map(|(_, at)| *at),
+                )
+                .min()
+                .unwrap_or(now + Duration::from_secs(2));
+            tokio::select! {
+                () = cancel.cancelled() => break,
+                received = packets.recv() => {
+                    let Some(received) = received else { break; };
+                    let mut received = received.to_vec();
+                    let _ = connection.recv(&mut received, quiche::RecvInfo { from: remote, to: local });
+                },
+                permit = outgoing.reserve(), if pending.as_ref().is_some_and(|(_, at)| *at <= now) => {
+                    let Ok(permit) = permit else { break; };
+                    permit.send(pending.take().unwrap().0);
+                },
+                () = tokio::time::sleep_until(deadline.into()) => {
+                    if connection.timeout().is_some_and(|delay| delay.is_zero()) {
+                        connection.on_timeout();
+                    }
+                },
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn quiche_h3_memory_failed_preparation_closes_owned_transport_without_sending() {
+        let tls = StandardTlsClient::with_options(
+            &SecurityContext::new(),
+            "localhost",
+            TlsClientOptions {
+                alpn: vec![b"h3".to_vec()],
+                required_alpn: Some(b"h3".to_vec()),
+                versions: TlsVersions::Tls13,
+                ..Default::default()
+            },
+            0,
+            BODY_LIMIT,
+        )
+        .unwrap()
+        .quiche_config()
+        .unwrap();
+        let (send, mut sent) = mpsc::channel(32);
+        let (_incoming, receive) = mpsc::channel(32);
+        let closed = Arc::new(std::sync::atomic::AtomicBool::new(false));
+        let peer = "192.0.2.1:443".parse().unwrap();
+        let result = Driver::new(
+            Transport {
+                transport: Box::new(Packets {
+                    send,
+                    receive,
+                    peer,
+                    closed: closed.clone(),
+                }),
+                peer,
+                budget: DatagramBudget::new(1400, 1400),
+                tls,
+                server_name: "another.invalid".into(),
+            },
+            Default::default(),
+        )
+        .await;
+        assert!(result.is_err());
+        assert!(closed.load(std::sync::atomic::Ordering::Acquire));
+        assert!(sent.recv().await.is_none());
+    }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn quiche_h3_memory_isolated_initial_loss_uses_fresh_pto_and_joins_stop() {
+        let identity = rcgen::generate_simple_self_signed(vec!["localhost".into()]).unwrap();
+        let mut roots = rustls::RootCertStore::empty();
+        roots.add(identity.cert.der().clone()).unwrap();
+        let tls = StandardTlsClient::with_options(
+            &SecurityContext::with_tls_roots(roots),
+            "localhost",
+            TlsClientOptions {
+                alpn: vec![b"h3".to_vec()],
+                required_alpn: Some(b"h3".to_vec()),
+                versions: TlsVersions::Tls13,
+                ..Default::default()
+            },
+            0,
+            BODY_LIMIT,
+        )
+        .unwrap()
+        .quiche_config()
+        .unwrap();
+        let mut builder =
+            boring::ssl::SslContextBuilder::new(boring::ssl::SslMethod::tls()).unwrap();
+        builder
+            .set_certificate(&boring::x509::X509::from_der(identity.cert.der()).unwrap())
+            .unwrap();
+        builder
+            .set_private_key(
+                &boring::pkey::PKey::private_key_from_der(&identity.signing_key.serialize_der())
+                    .unwrap(),
+            )
+            .unwrap();
+        let mut config =
+            quiche::Config::with_boring_ssl_ctx_builder(quiche::PROTOCOL_VERSION, builder).unwrap();
+        config.set_application_protos(&[b"h3"]).unwrap();
+        config.set_curves_list("X25519").unwrap();
+        config.verify_peer(false);
+        config.set_max_idle_timeout(10000);
+        config.set_max_send_udp_payload_size(1400);
+        config.set_max_recv_udp_payload_size(1400);
+        config.set_initial_max_data(1024 * 1024);
+        config.set_initial_max_stream_data_bidi_remote(128 * 1024);
+        config.set_initial_max_stream_data_bidi_local(128 * 1024);
+        config.set_initial_max_stream_data_uni(16 * 1024);
+        config.set_initial_max_streams_bidi(256);
+        config.set_initial_max_streams_uni(8);
+        config.enable_dgram(true, 64, 64);
+        let (to_server, mut from_client) = mpsc::channel(32);
+        let (to_client, from_server) = mpsc::channel(32);
+        let closed = Arc::new(std::sync::atomic::AtomicBool::new(false));
+        let (client, driver) = Driver::new(
+            Transport {
+                transport: Box::new(Packets {
+                    send: to_server,
+                    receive: from_server,
+                    peer: "192.0.2.1:443".parse().unwrap(),
+                    closed: closed.clone(),
+                }),
+                peer: "192.0.2.1:443".parse().unwrap(),
+                budget: DatagramBudget::new(1400, 1400),
+                tls,
+                server_name: "localhost".into(),
+            },
+            Options {
+                datagrams: true,
+                ..Default::default()
+            },
+        )
+        .await
+        .unwrap();
+        // Keep this loss probe to a single Initial. A large PQ ClientHello
+        // could require paced extra packets that wake the old driver by chance.
+        {
+            let mut state = client.shared.state.lock().unwrap();
+            let ssl: &mut boring::ssl::SslRef = state.connection.as_mut().unwrap().as_mut();
+            ssl.set_curves_list("X25519").unwrap();
+        }
+        let server_cancel = CancellationToken::new();
+        let peer_cancel = server_cancel.clone();
+        let (dropped, observed_drop) = tokio::sync::oneshot::channel();
+        let mut server = tokio::spawn(async move {
+            let first = tokio::select! {
+                () = peer_cancel.cancelled() => return,
+                first = from_client.recv() => first,
+            };
+            let Some(mut first) = first.map(|packet: Bytes| packet.to_vec()) else {
+                return;
+            };
+            let initial = quiche::Header::from_slice(&mut first, 20)
+                .is_ok_and(|header| header.ty == quiche::Type::Initial);
+            // No input, app request or synthetic wake reaches the driver until
+            // its real native PTO produces another packet after this loss.
+            let _ = dropped.send(initial);
+            if initial {
+                peer(
+                    from_client,
+                    to_client,
+                    config,
+                    peer_cancel,
+                    0,
+                    Arc::new(std::sync::atomic::AtomicUsize::new(0)),
+                )
+                .await;
+            }
+        });
+        let cancel = CancellationToken::new();
+        let mut task = tokio::spawn(driver.run(cancel.clone()));
+        let result = tokio::time::timeout(Duration::from_secs(4), async {
+            if !observed_drop
+                .await
+                .map_err(|_| "Initial drop was not witnessed")?
+            {
+                return Err("the dropped packet was not an Initial");
+            }
+            let (fresh_pto, first_flight) = {
+                let state = client.shared.state.lock().unwrap();
+                let connection = state.connection.as_ref().unwrap();
+                (connection.timeout(), connection.stats().sent)
+            };
+            let fresh_pto = fresh_pto.ok_or("native send did not arm its PTO")?;
+            if first_flight != 1 || fresh_pto > Duration::from_secs(2) {
+                return Err("the first lost Initial was not an isolated flight");
+            }
+            tokio::time::timeout(fresh_pto + Duration::from_millis(500), client.ready(true))
+                .await
+                .map_err(|_| "isolated Initial loss did not recover at the fresh PTO")?
+                .map_err(|_| "native H3 preparation failed after Initial loss")
+        })
+        .await;
+        // Retire and join both sides before asserting, including the RED path
+        // where the server has not received its first surviving Initial.
+        cancel.cancel();
+        let driver_join = tokio::time::timeout(Duration::from_secs(2), &mut task).await;
+        let driver_stopped = matches!(driver_join, Ok(Ok(Ok(()))));
+        if driver_join.is_err() {
+            task.abort();
+            let _ = task.await;
+        }
+        server_cancel.cancel();
+        let server_join = tokio::time::timeout(Duration::from_secs(2), &mut server).await;
+        let server_stopped = matches!(server_join, Ok(Ok(())));
+        if server_join.is_err() {
+            server.abort();
+            let _ = server.await;
+        }
+        assert!(matches!(&result, Ok(Ok(()))), "{result:?}");
+        assert!(
+            driver_stopped,
+            "client driver failed to stop and join: {driver_join:?}"
+        );
+        assert!(
+            server_stopped,
+            "server failed to stop and join: {server_join:?}"
+        );
+        assert!(closed.load(std::sync::atomic::Ordering::Acquire));
+    }
+
+    #[tokio::test]
+    async fn quiche_h3_memory_settings_unknown_flow_dispatch_and_joined_stop() {
+        let identity = rcgen::generate_simple_self_signed(vec!["localhost".into()]).unwrap();
+        let mut roots = rustls::RootCertStore::empty();
+        roots.add(identity.cert.der().clone()).unwrap();
+        let tls = StandardTlsClient::with_options(
+            &SecurityContext::with_tls_roots(roots),
+            "localhost",
+            TlsClientOptions {
+                alpn: vec![b"h3".to_vec()],
+                required_alpn: Some(b"h3".to_vec()),
+                versions: TlsVersions::Tls13,
+                ..Default::default()
+            },
+            0,
+            BODY_LIMIT,
+        )
+        .unwrap()
+        .quiche_config()
+        .unwrap();
+        let mut builder =
+            boring::ssl::SslContextBuilder::new(boring::ssl::SslMethod::tls()).unwrap();
+        builder
+            .set_certificate(&boring::x509::X509::from_der(identity.cert.der()).unwrap())
+            .unwrap();
+        builder
+            .set_private_key(
+                &boring::pkey::PKey::private_key_from_der(&identity.signing_key.serialize_der())
+                    .unwrap(),
+            )
+            .unwrap();
+        let mut config =
+            quiche::Config::with_boring_ssl_ctx_builder(quiche::PROTOCOL_VERSION, builder).unwrap();
+        config.set_application_protos(&[b"h3"]).unwrap();
+        config.verify_peer(false);
+        config.set_max_idle_timeout(10000);
+        config.set_max_send_udp_payload_size(1400);
+        config.set_max_recv_udp_payload_size(1400);
+        config.set_initial_max_data(1024 * 1024);
+        config.set_initial_max_stream_data_bidi_remote(128 * 1024);
+        config.set_initial_max_stream_data_bidi_local(128 * 1024);
+        config.set_initial_max_stream_data_uni(16 * 1024);
+        config.set_initial_max_streams_bidi(256);
+        config.set_initial_max_streams_uni(8);
+        config.enable_dgram(true, 64, 64);
+        let (to_server, from_client) = mpsc::channel(32);
+        let (to_client, from_server) = mpsc::channel(32);
+        let closed = Arc::new(std::sync::atomic::AtomicBool::new(false));
+        let server_cancel = CancellationToken::new();
+        let flooded = Arc::new(std::sync::atomic::AtomicUsize::new(0));
+        let server = tokio::spawn(peer(
+            from_client,
+            to_client,
+            config,
+            server_cancel.clone(),
+            10_000,
+            flooded.clone(),
+        ));
+        let (mut client, driver) = Driver::new(
+            Transport {
+                transport: Box::new(Packets {
+                    send: to_server,
+                    receive: from_server,
+                    peer: "192.0.2.1:443".parse().unwrap(),
+                    closed: closed.clone(),
+                }),
+                peer: "192.0.2.1:443".parse().unwrap(),
+                budget: DatagramBudget::new(1400, 1400),
+                tls,
+                server_name: "localhost".into(),
+            },
+            Options {
+                datagrams: true,
+                ..Default::default()
+            },
+        )
+        .await
+        .unwrap();
+        let cancel = CancellationToken::new();
+        let task = tokio::spawn(driver.run(cancel.clone()));
+        let phase = std::sync::atomic::AtomicUsize::new(0);
+        let retained_ready_wakers = std::sync::atomic::AtomicUsize::new(0);
+        let operation = async {
+            client.ready(true).await.unwrap();
+            phase.store(1, std::sync::atomic::Ordering::Release);
+            let mut request = Request::builder()
+                .method(http::Method::CONNECT)
+                .uri("https://example.invalid/")
+                .body(())
+                .unwrap();
+            request.extensions_mut().insert(Protocol::CF_CONNECT_IP);
+            let stream = client.send_request(request).await.unwrap();
+            let id = stream.id().into_inner();
+            client.register_datagrams(id).unwrap();
+            let (mut send, mut receive) = stream.split();
+            assert_eq!(receive.recv_response().await.unwrap().status(), 200);
+            retained_ready_wakers.fetch_add(
+                usize::from(receive.signals.read.take().is_some()),
+                std::sync::atomic::Ordering::Relaxed,
+            );
+            send.send_data(Bytes::from_static(b"accepted"))
+                .await
+                .unwrap();
+            retained_ready_wakers.fetch_add(
+                usize::from(send.signals.write.take().is_some()),
+                std::sync::atomic::Ordering::Relaxed,
+            );
+            phase.store(2, std::sync::atomic::Ordering::Release);
+            assert_eq!(
+                client.read_datagram(id).await.unwrap().as_ref(),
+                &[0, 0, 0x42]
+            );
+            let state = client.shared.state.lock().unwrap();
+            retained_ready_wakers.fetch_add(
+                usize::from(state.streams[&id].signals.datagram.take().is_some()),
+                std::sync::atomic::Ordering::Relaxed,
+            );
+            assert_eq!(state.streams.len(), 1);
+            assert!(state.streams[&id].datagrams.as_ref().unwrap().len() <= DATAGRAM_QUEUE);
+            assert_eq!(
+                state
+                    .settings
+                    .as_ref()
+                    .unwrap()
+                    .iter()
+                    .find(|&&(setting, _)| setting == 0x33)
+                    .unwrap()
+                    .1,
+                1
+            );
+        };
+        let result = tokio::time::timeout(Duration::from_secs(10), operation).await;
+        cancel.cancel();
+        let _ = task.await.unwrap();
+        server_cancel.cancel();
+        server.await.unwrap();
+        assert!(closed.load(std::sync::atomic::Ordering::Acquire));
+        assert!(client.close_reason().is_some());
+        assert!(client.shared.state.lock().unwrap().connection.is_none());
+        assert!(client.shared.state.lock().unwrap().streams.is_empty());
+        assert_eq!(
+            retained_ready_wakers.load(std::sync::atomic::Ordering::Relaxed),
+            0,
+            "completed H3 operations retained waiters after successful progress"
+        );
+        assert!(
+            result.is_ok(),
+            "memory H3 timed out at phase {}, unknown frames enqueued {}",
+            phase.load(std::sync::atomic::Ordering::Acquire),
+            flooded.load(std::sync::atomic::Ordering::Acquire)
+        );
+    }
+}
+
+#[cfg(test)]
+#[path = "quiche_h3_native_ready_batch_memory_tests.rs"]
+mod native_ready_batch_memory_tests;
diff --git a/src/transport/quiche_h3_native_ready_batch_memory_tests.rs b/src/transport/quiche_h3_native_ready_batch_memory_tests.rs
new file mode 100644
index 0000000..2d49214
--- /dev/null
+++ b/src/transport/quiche_h3_native_ready_batch_memory_tests.rs
@@ -0,0 +1,384 @@
+//! UNCOMPILED / UNRUN review draft. Memory-only real quiche wire exchange.
+//! No listeners, background tasks, timers, production probes, or new limits.
+use super::*;
+use futures_util::FutureExt;
+
+struct Wire {
+    client: Client,
+    peer: NativeConnection,
+    peer_h3: quiche::h3::Connection,
+    ids: [u64; 2],
+    local: SocketAddr,
+    remote: SocketAddr,
+}
+
+// Quiche's actual packet encoder/decoder; this fixture does not model pacing.
+fn transfer(
+    from: &mut NativeConnection,
+    to: &mut NativeConnection,
+    source: SocketAddr,
+    destination: SocketAddr,
+) -> usize {
+    let mut packet = [0; 1400];
+    let mut count = 0;
+    for _ in 0..128 {
+        match from.send(&mut packet) {
+            Ok((n, _)) => {
+                to.recv(
+                    &mut packet[..n],
+                    quiche::RecvInfo {
+                        from: source,
+                        to: destination,
+                    },
+                )
+                .unwrap();
+                count += 1;
+            }
+            Err(quiche::Error::Done) => return count,
+            Err(error) => panic!("memory quiche send: {error:?}"),
+        }
+    }
+    panic!("memory packet-transfer bound exceeded");
+}
+
+impl Wire {
+    fn new() -> Self {
+        let identity = rcgen::generate_simple_self_signed(vec!["localhost".into()]).unwrap();
+        let config = || {
+            let mut builder =
+                boring::ssl::SslContextBuilder::new(boring::ssl::SslMethod::tls()).unwrap();
+            builder
+                .set_certificate(&boring::x509::X509::from_der(identity.cert.der()).unwrap())
+                .unwrap();
+            builder
+                .set_private_key(
+                    &boring::pkey::PKey::private_key_from_der(
+                        &identity.signing_key.serialize_der(),
+                    )
+                    .unwrap(),
+                )
+                .unwrap();
+            let mut config =
+                quiche::Config::with_boring_ssl_ctx_builder(quiche::PROTOCOL_VERSION, builder)
+                    .unwrap();
+            config.set_application_protos(&[b"h3"]).unwrap();
+            config.verify_peer(false); // Only this generated in-memory identity.
+            config.set_max_idle_timeout(10_000);
+            config.set_max_recv_udp_payload_size(1400);
+            config.set_max_send_udp_payload_size(1400);
+            config.set_initial_max_data(1024 * 1024);
+            config.set_initial_max_stream_data_bidi_local(128 * 1024);
+            config.set_initial_max_stream_data_bidi_remote(128 * 1024);
+            config.set_initial_max_stream_data_uni(16 * 1024);
+            config.set_initial_max_streams_bidi(256);
+            config.set_initial_max_streams_uni(8);
+            config.enable_dgram(true, DATAGRAM_QUEUE, DATAGRAM_QUEUE);
+            config
+        };
+        let local: SocketAddr = "192.0.2.2:44301".parse().unwrap();
+        let remote: SocketAddr = "192.0.2.1:443".parse().unwrap();
+        let cid = [1; 20];
+        let mut client = quiche::connect_with_buffer_factory::<OwnedBuffers>(
+            Some("localhost"),
+            &quiche::ConnectionId::from_ref(&cid),
+            local,
+            remote,
+            &mut config(),
+        )
+        .unwrap();
+        let mut first = [0; 1400];
+        let (n, _) = client.send(&mut first).unwrap();
+        let header = quiche::Header::from_slice(&mut first[..n], 20).unwrap();
+        let dcid = header.dcid.into_owned();
+        let mut peer = quiche::accept_with_buf_factory::<OwnedBuffers>(
+            &dcid,
+            None,
+            remote,
+            local,
+            &mut config(),
+        )
+        .unwrap();
+        peer.recv(
+            &mut first[..n],
+            quiche::RecvInfo {
+                from: local,
+                to: remote,
+            },
+        )
+        .unwrap();
+        for _ in 0..128 {
+            transfer(&mut peer, &mut client, remote, local);
+            transfer(&mut client, &mut peer, local, remote);
+            if client.is_established() && peer.is_established() {
+                break;
+            }
+        }
+        assert!(client.is_established() && peer.is_established());
+        let mut h3_config = quiche::h3::Config::new().unwrap();
+        h3_config.enable_extended_connect(true);
+        let h3 = quiche::h3::Connection::with_transport(&mut client, &h3_config).unwrap();
+        let mut peer_h3 = quiche::h3::Connection::with_transport(&mut peer, &h3_config).unwrap();
+        let mut state = State {
+            connection: Some(client),
+            h3: Some(h3),
+            streams: BTreeMap::new(),
+            closed: false,
+            goaway: false,
+            ready: true,
+            datagram_budget: None,
+            settings: None,
+        };
+        // SETTINGS must be actually received before extended CONNECT admission.
+        for _ in 0..4 {
+            transfer(state.connection.as_mut().unwrap(), &mut peer, local, remote);
+            loop {
+                match peer_h3.poll(&mut peer) {
+                    Ok(_) => {}
+                    Err(quiche::h3::Error::Done) => break,
+                    Err(error) => panic!("memory H3 settings: {error:?}"),
+                }
+            }
+            transfer(&mut peer, state.connection.as_mut().unwrap(), remote, local);
+            publish(&mut state, &mut { WORK });
+        }
+        let mut ids = [0; 2];
+        for id in &mut ids {
+            let mut request = Request::builder()
+                .method(http::Method::CONNECT)
+                .uri("https://example.invalid/")
+                .body(())
+                .unwrap();
+            request.extensions_mut().insert(Protocol::CF_CONNECT_IP);
+            let headers = request_headers(&request).unwrap();
+            *id = state
+                .h3
+                .as_mut()
+                .unwrap()
+                .send_request(state.connection.as_mut().unwrap(), &headers, false)
+                .unwrap();
+            let mut body = Body::new(Arc::new(Signals::default()));
+            body.datagrams = Some(VecDeque::new());
+            state.streams.insert(*id, body);
+        }
+        for _ in 0..4 {
+            transfer(state.connection.as_mut().unwrap(), &mut peer, local, remote);
+            while let Ok((id, event)) = peer_h3.poll(&mut peer) {
+                if let quiche::h3::Event::Headers { .. } = event {
+                    peer_h3
+                        .send_response(
+                            &mut peer,
+                            id,
+                            &[quiche::h3::Header::new(b":status", b"200")],
+                            false,
+                        )
+                        .unwrap();
+                }
+            }
+            transfer(&mut peer, state.connection.as_mut().unwrap(), remote, local);
+            publish(&mut state, &mut { WORK });
+        }
+        for id in ids {
+            assert_eq!(state.streams[&id].headers.as_ref().unwrap().status(), 200);
+        }
+        Self {
+            client: Client {
+                shared: Arc::new(Shared {
+                    state: Mutex::new(state),
+                    changed: Notify::new(),
+                    status: Notify::new(),
+                }),
+            },
+            peer,
+            peer_h3,
+            ids,
+            local,
+            remote,
+        }
+    }
+    fn enqueue(&mut self, id: u64, marker: u8) {
+        assert!(id / 4 < 64);
+        self.peer
+            .dgram_send_buf(Bytes::from(vec![(id / 4) as u8, 0, marker]))
+            .unwrap();
+    }
+    fn receive_wire(&mut self) {
+        let mut state = self.client.shared.state.lock().unwrap();
+        assert!(
+            transfer(
+                &mut self.peer,
+                state.connection.as_mut().unwrap(),
+                self.remote,
+                self.local
+            ) != 0
+        );
+    }
+    fn publish(&self, remaining: &mut usize) {
+        publish(&mut self.client.shared.state.lock().unwrap(), remaining);
+    }
+}
+
+// Candidate adapter: the real two production functions, not a copied algorithm.
+// Baseline adapter is supplied separately. Select ONLY the two terminal tests
+// against baseline; its owner does not have the candidate's shared allowance.
+fn publish(state: &mut State, remaining: &mut usize) {
+    super::drain_datagrams(state, remaining).unwrap();
+    super::process_h3(state, remaining).unwrap();
+}
+
+#[test]
+fn quiche_h3_native_memory_wire_shared_32_allowance() {
+    let mut wire = Wire::new();
+    for marker in 0..64 {
+        wire.enqueue(wire.ids[0], marker);
+    }
+    wire.receive_wire();
+    let mut remaining = WORK;
+    wire.publish(&mut remaining);
+    assert_eq!(remaining, 0);
+    for _ in 0..2 {
+        wire.publish(&mut remaining);
+    }
+    {
+        let state = wire.client.shared.state.lock().unwrap();
+        assert_eq!(
+            state.connection.as_ref().unwrap().dgram_recv_queue_len(),
+            32
+        );
+        assert_eq!(
+            state.streams[&wire.ids[0]]
+                .datagrams
+                .as_ref()
+                .unwrap()
+                .len(),
+            32
+        );
+    }
+    wire.publish(&mut { WORK });
+    for marker in 0..64 {
+        let frame = wire
+            .client
+            .read_datagram(wire.ids[0])
+            .now_or_never()
+            .unwrap()
+            .unwrap();
+        assert_eq!(frame.as_ref(), &[(wire.ids[0] / 4) as u8, 0, marker]);
+    }
+    assert!(
+        wire.client
+            .read_datagram(wire.ids[0])
+            .now_or_never()
+            .is_none()
+    );
+}
+
+#[test]
+fn quiche_h3_native_memory_invalid_unknown_full_consume_allowance() {
+    let mut wire = Wire::new();
+    for marker in 0..64 {
+        wire.enqueue(wire.ids[0], marker);
+    }
+    wire.receive_wire();
+    wire.publish(&mut { WORK });
+    wire.publish(&mut { WORK });
+    // All three drop paths count; no input may admit a new map entry.
+    for marker in 0..33 {
+        let frame = match marker % 3 {
+            0 => vec![0xc0],                               // Incomplete 8-byte varint.
+            1 => vec![63, 0, marker],                      // Unknown request flow ID.
+            _ => vec![(wire.ids[0] / 4) as u8, 0, marker], // Existing full Body.
+        };
+        wire.peer.dgram_send_buf(Bytes::from(frame)).unwrap();
+    }
+    wire.receive_wire();
+    let mut remaining = WORK;
+    wire.publish(&mut remaining);
+    let state = wire.client.shared.state.lock().unwrap();
+    assert_eq!(remaining, 0);
+    assert_eq!(state.streams.len(), 2);
+    assert_eq!(state.connection.as_ref().unwrap().dgram_recv_queue_len(), 1);
+    assert_eq!(
+        state.streams[&wire.ids[0]]
+            .datagrams
+            .as_ref()
+            .unwrap()
+            .len(),
+        DATAGRAM_QUEUE
+    );
+}
+
+#[test]
+fn quiche_h3_native_memory_actual_terminal_closes_only_its_registered_flow() {
+    // After quiche actually reports empty FIN or RESET, existing read_datagram
+    // semantics reject that flow. No cross-stream DATAGRAM/FIN wire order claim.
+    for reset in [false, true] {
+        let mut wire = Wire::new();
+        wire.enqueue(wire.ids[0], 0x41);
+        wire.enqueue(wire.ids[1], 0x42);
+        if reset {
+            wire.peer
+                .stream_shutdown(wire.ids[0], quiche::Shutdown::Write, REQUEST_CANCELLED)
+                .unwrap();
+        } else {
+            wire.peer_h3
+                .send_body(&mut wire.peer, wire.ids[0], b"", true)
+                .unwrap();
+        }
+        wire.receive_wire();
+        wire.publish(&mut { WORK });
+        {
+            let state = wire.client.shared.state.lock().unwrap();
+            let body = &state.streams[&wire.ids[0]];
+            assert!(if reset { body.failed } else { body.finished });
+            assert!(!state.streams[&wire.ids[1]].failed);
+        }
+        assert!(
+            wire.client
+                .read_datagram(wire.ids[0])
+                .now_or_never()
+                .unwrap()
+                .is_err()
+        );
+        let sibling = wire
+            .client
+            .read_datagram(wire.ids[1])
+            .now_or_never()
+            .unwrap()
+            .unwrap();
+        assert_eq!(sibling.as_ref(), &[(wire.ids[1] / 4) as u8, 0, 0x42]);
+    }
+}
+
+#[test]
+fn quiche_h3_native_memory_data_fin_preserves_delivered_prefix_until_finished_poll() {
+    let mut wire = Wire::new();
+    wire.enqueue(wire.ids[0], 0x41);
+    wire.enqueue(wire.ids[0], 0x42);
+    wire.peer_h3
+        .send_body(&mut wire.peer, wire.ids[0], b"capsule", true)
+        .unwrap();
+    wire.receive_wire();
+    wire.publish(&mut { WORK });
+    {
+        let state = wire.client.shared.state.lock().unwrap();
+        // Quiche records Finished while recv_body consumes the final DATA.
+        // It is delivered by the NEXT h3.poll, not retroactively in this pass.
+        assert!(!state.streams[&wire.ids[0]].finished);
+        assert_eq!(state.streams[&wire.ids[0]].buffered, b"capsule".len());
+    }
+    let prefix = wire
+        .client
+        .read_datagram(wire.ids[0])
+        .now_or_never()
+        .unwrap()
+        .unwrap();
+    assert_eq!(prefix.as_ref(), &[(wire.ids[0] / 4) as u8, 0, 0x41]);
+    wire.publish(&mut { WORK });
+    assert!(wire.client.shared.state.lock().unwrap().streams[&wire.ids[0]].finished);
+    assert!(
+        wire.client
+            .read_datagram(wire.ids[0])
+            .now_or_never()
+            .unwrap()
+            .is_err()
+    );
+}
diff --git a/src/transport/quinn_h3.rs b/src/transport/quinn_h3.rs
new file mode 100644
index 0000000..c40449d
--- /dev/null
+++ b/src/transport/quinn_h3.rs
@@ -0,0 +1,403 @@
+//! HTTP/3 over an already established, caller-owned Quinn connection.
+//!
+//! TLS admission, protected datagram IO, deadlines, pools and task joins remain
+//! with the caller. The control driver must be polled for the entire connection
+//! lifetime. Request FIN does not wait for a transport ACK.
+
+use bytes::Bytes;
+use h3::{
+    ConnectionState,
+    quic::{self, ConnectionErrorIncoming, StreamErrorIncoming, StreamId, WriteBuf},
+};
+use std::{
+    sync::{
+        Arc,
+        atomic::{AtomicBool, Ordering},
+    },
+    task::{Context, Poll},
+};
+
+#[path = "quinn_h3_budget.rs"]
+mod budget;
+
+pub(crate) type RequestStream = h3::client::RequestStream<BidiStream, Bytes>;
+pub(crate) type SendStream = h3::client::RequestStream<GuardedSend, Bytes>;
+pub(crate) type RecvStream = h3::client::RequestStream<GuardedRecv, Bytes>;
+pub(crate) type ControlDriver = h3::client::Connection<Backend, Bytes>;
+
+#[derive(Clone)]
+pub(crate) struct Client {
+    sender: h3::client::SendRequest<Streams, Bytes>,
+    retiring: Arc<AtomicBool>,
+}
+
+impl std::fmt::Debug for Client {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter
+            .debug_struct("QuinnH3Client")
+            .field("can_open_request", &self.can_open_request())
+            .finish_non_exhaustive()
+    }
+}
+
+impl Client {
+    /// A pool admission snapshot; send_request also checks the shared H3 state.
+    pub(crate) fn can_open_request(&self) -> bool {
+        !self.retiring.load(Ordering::Acquire)
+            && self.sender.get_conn_error().is_none()
+            && !self.sender.is_closing()
+    }
+
+    pub(crate) fn retire(&self) {
+        self.retiring.store(true, Ordering::Release);
+    }
+
+    pub(crate) async fn send_request(
+        &mut self,
+        request: http::Request<()>,
+    ) -> Result<RequestStream, h3::error::StreamError> {
+        if self.retiring.load(Ordering::Acquire) {
+            return Err(h3::error::StreamError::RemoteClosing);
+        }
+        self.sender.send_request(request).await
+    }
+}
+
+pub(crate) async fn attach(
+    connection: quinn::Connection,
+    header_limit: u64,
+) -> Result<(Client, ControlDriver), h3::error::ConnectionError> {
+    let (control, sender) = h3::client::builder()
+        .max_field_section_size(header_limit)
+        .build(Backend {
+            inner: h3_quinn::Connection::new(connection.clone()),
+            connection,
+            header_limit,
+        })
+        .await?;
+    Ok((
+        Client {
+            sender,
+            retiring: Arc::new(AtomicBool::new(false)),
+        },
+        control,
+    ))
+}
+
+/// The official backend keeps QUIC I/O, framing and buffering. These delegates
+/// bound retained non-DATA frames and preserve request-half cancellation,
+/// including HEADERS still being written before h3 returns a RequestStream.
+pub(crate) struct Backend {
+    inner: h3_quinn::Connection,
+    connection: quinn::Connection,
+    header_limit: u64,
+}
+
+impl quic::Connection<Bytes> for Backend {
+    type RecvStream = GuardedRecv;
+    type OpenStreams = Streams;
+
+    fn poll_accept_recv(
+        &mut self,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<Self::RecvStream, ConnectionErrorIncoming>> {
+        quic::Connection::<Bytes>::poll_accept_recv(&mut self.inner, cx).map(|result| {
+            result.map(|stream| {
+                GuardedRecv::new(
+                    stream,
+                    self.header_limit,
+                    true,
+                    Some(self.connection.clone()),
+                )
+            })
+        })
+    }
+
+    fn poll_accept_bidi(
+        &mut self,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<Self::BidiStream, ConnectionErrorIncoming>> {
+        quic::Connection::<Bytes>::poll_accept_bidi(&mut self.inner, cx)
+            .map(|result| result.map(|stream| BidiStream::new(stream, self.header_limit)))
+    }
+
+    fn opener(&self) -> Self::OpenStreams {
+        Streams {
+            inner: quic::Connection::<Bytes>::opener(&self.inner),
+            header_limit: self.header_limit,
+        }
+    }
+}
+
+pub(crate) struct Streams {
+    inner: h3_quinn::OpenStreams,
+    header_limit: u64,
+}
+
+impl Clone for Streams {
+    fn clone(&self) -> Self {
+        Self {
+            inner: self.inner.clone(),
+            header_limit: self.header_limit,
+        }
+    }
+}
+
+impl quic::OpenStreams<Bytes> for Backend {
+    type SendStream = h3_quinn::SendStream<Bytes>;
+    type BidiStream = BidiStream;
+
+    fn poll_open_bidi(
+        &mut self,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<Self::BidiStream, StreamErrorIncoming>> {
+        quic::OpenStreams::<Bytes>::poll_open_bidi(&mut self.inner, cx)
+            .map(|result| result.map(|stream| BidiStream::new(stream, self.header_limit)))
+    }
+
+    fn poll_open_send(
+        &mut self,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<Self::SendStream, StreamErrorIncoming>> {
+        quic::OpenStreams::<Bytes>::poll_open_send(&mut self.inner, cx)
+    }
+
+    fn close(&mut self, code: h3::error::Code, reason: &[u8]) {
+        quic::OpenStreams::<Bytes>::close(&mut self.inner, code, reason);
+    }
+}
+
+impl quic::OpenStreams<Bytes> for Streams {
+    type SendStream = h3_quinn::SendStream<Bytes>;
+    type BidiStream = BidiStream;
+
+    fn poll_open_bidi(
+        &mut self,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<Self::BidiStream, StreamErrorIncoming>> {
+        quic::OpenStreams::<Bytes>::poll_open_bidi(&mut self.inner, cx)
+            .map(|result| result.map(|stream| BidiStream::new(stream, self.header_limit)))
+    }
+
+    fn poll_open_send(
+        &mut self,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<Self::SendStream, StreamErrorIncoming>> {
+        quic::OpenStreams::<Bytes>::poll_open_send(&mut self.inner, cx)
+    }
+
+    fn close(&mut self, code: h3::error::Code, reason: &[u8]) {
+        quic::OpenStreams::<Bytes>::close(&mut self.inner, code, reason);
+    }
+}
+
+pub(crate) struct BidiStream {
+    send: GuardedSend,
+    receive: GuardedRecv,
+}
+
+impl BidiStream {
+    fn new(stream: h3_quinn::BidiStream<Bytes>, header_limit: u64) -> Self {
+        let (send, receive) = quic::BidiStream::<Bytes>::split(stream);
+        Self {
+            send: GuardedSend {
+                inner: send,
+                finished: false,
+            },
+            receive: GuardedRecv::new(receive, header_limit, false, None),
+        }
+    }
+}
+
+impl quic::BidiStream<Bytes> for BidiStream {
+    type SendStream = GuardedSend;
+    type RecvStream = GuardedRecv;
+
+    fn split(self) -> (Self::SendStream, Self::RecvStream) {
+        (self.send, self.receive)
+    }
+}
+
+impl quic::SendStream<Bytes> for BidiStream {
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), StreamErrorIncoming>> {
+        quic::SendStream::<Bytes>::poll_ready(&mut self.send, cx)
+    }
+
+    fn send_data<T: Into<WriteBuf<Bytes>>>(&mut self, data: T) -> Result<(), StreamErrorIncoming> {
+        quic::SendStream::<Bytes>::send_data(&mut self.send, data)
+    }
+
+    fn poll_finish(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), StreamErrorIncoming>> {
+        quic::SendStream::<Bytes>::poll_finish(&mut self.send, cx)
+    }
+
+    fn reset(&mut self, code: u64) {
+        quic::SendStream::<Bytes>::reset(&mut self.send, code);
+    }
+
+    fn send_id(&self) -> StreamId {
+        quic::SendStream::<Bytes>::send_id(&self.send)
+    }
+}
+
+impl quic::RecvStream for BidiStream {
+    type Buf = Bytes;
+
+    fn poll_data(
+        &mut self,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<Option<Self::Buf>, StreamErrorIncoming>> {
+        quic::RecvStream::poll_data(&mut self.receive, cx)
+    }
+
+    fn stop_sending(&mut self, code: u64) {
+        quic::RecvStream::stop_sending(&mut self.receive, code);
+    }
+
+    fn recv_id(&self) -> StreamId {
+        quic::RecvStream::recv_id(&self.receive)
+    }
+}
+
+pub(crate) struct GuardedSend {
+    inner: h3_quinn::SendStream<Bytes>,
+    finished: bool,
+}
+
+impl quic::SendStream<Bytes> for GuardedSend {
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), StreamErrorIncoming>> {
+        quic::SendStream::<Bytes>::poll_ready(&mut self.inner, cx)
+    }
+
+    fn send_data<T: Into<WriteBuf<Bytes>>>(&mut self, data: T) -> Result<(), StreamErrorIncoming> {
+        quic::SendStream::<Bytes>::send_data(&mut self.inner, data)
+    }
+
+    fn poll_finish(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), StreamErrorIncoming>> {
+        let result = quic::SendStream::<Bytes>::poll_finish(&mut self.inner, cx);
+        if matches!(result, Poll::Ready(Ok(()))) {
+            self.finished = true;
+        }
+        result
+    }
+
+    fn reset(&mut self, code: u64) {
+        quic::SendStream::<Bytes>::reset(&mut self.inner, code);
+        self.finished = true;
+    }
+
+    fn send_id(&self) -> StreamId {
+        quic::SendStream::<Bytes>::send_id(&self.inner)
+    }
+}
+
+impl Drop for GuardedSend {
+    fn drop(&mut self) {
+        if !self.finished {
+            quic::SendStream::<Bytes>::reset(
+                &mut self.inner,
+                h3::error::Code::H3_REQUEST_CANCELLED.value(),
+            );
+        }
+    }
+}
+
+pub(crate) struct GuardedRecv {
+    inner: Option<h3_quinn::RecvStream>,
+    id: StreamId,
+    pending: bool,
+    stopped: Option<u64>,
+    budget: budget::Budget,
+    buffered: Bytes,
+    connection: Option<quinn::Connection>,
+}
+
+impl GuardedRecv {
+    fn new(
+        stream: h3_quinn::RecvStream,
+        header_limit: u64,
+        unidirectional: bool,
+        connection: Option<quinn::Connection>,
+    ) -> Self {
+        let id = quic::RecvStream::recv_id(&stream);
+        Self {
+            inner: Some(stream),
+            id,
+            pending: false,
+            stopped: None,
+            budget: budget::Budget::new(header_limit, unidirectional),
+            buffered: Bytes::new(),
+            connection,
+        }
+    }
+}
+
+impl quic::RecvStream for GuardedRecv {
+    type Buf = Bytes;
+
+    fn poll_data(
+        &mut self,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<Option<Self::Buf>, StreamErrorIncoming>> {
+        if let Some(error_code) = self.stopped {
+            return Poll::Ready(Err(StreamErrorIncoming::StreamTerminated { error_code }));
+        }
+        if self.buffered.is_empty() {
+            let result = quic::RecvStream::poll_data(self.inner.as_mut().unwrap(), cx);
+            self.pending = result.is_pending();
+            match result {
+                Poll::Ready(Ok(Some(bytes))) => self.buffered = bytes,
+                other => return other,
+            }
+        }
+        let length = match self.budget.prefix(&self.buffered) {
+            Ok(length) => length,
+            Err(code) => {
+                self.stop_sending(code.value());
+                if self.budget.is_control() {
+                    // A prefix can already include the control stream type. If
+                    // rejected before h3 sees that type, a plain reset would be
+                    // tolerated as an unclassified uni stream ending early.
+                    self.connection
+                        .as_ref()
+                        .unwrap()
+                        .close(quinn::VarInt::from_u64(code.value()).unwrap(), b"");
+                    return Poll::Ready(Err(StreamErrorIncoming::ConnectionErrorIncoming {
+                        connection_error: ConnectionErrorIncoming::ApplicationClose {
+                            error_code: code.value(),
+                        },
+                    }));
+                }
+                return Poll::Ready(Err(StreamErrorIncoming::StreamTerminated {
+                    error_code: code.value(),
+                }));
+            }
+        };
+        // Keep at most one native chunk, with no payload copy or read-ahead.
+        Poll::Ready(Ok(Some(self.buffered.split_to(length))))
+    }
+
+    fn stop_sending(&mut self, code: u64) {
+        if self.stopped.is_some() {
+            return;
+        }
+        self.buffered = Bytes::new();
+        if self.pending {
+            // h3-quinn 0.0.10 has moved its raw stream into a private future.
+            // Ownership Drop is safe and sends the native default STOP(0);
+            // it cannot preserve a requested wire code in this Pending state.
+            self.inner.take();
+        } else {
+            quic::RecvStream::stop_sending(self.inner.as_mut().unwrap(), code);
+        }
+        self.stopped = Some(code);
+    }
+
+    fn recv_id(&self) -> StreamId {
+        self.id
+    }
+}
+
+#[cfg(test)]
+#[path = "quinn_h3_tests.rs"]
+pub(crate) mod tests;
diff --git a/src/transport/quinn_h3_budget.rs b/src/transport/quinn_h3_budget.rs
new file mode 100644
index 0000000..bbdd093
--- /dev/null
+++ b/src/transport/quinn_h3_budget.rs
@@ -0,0 +1,193 @@
+//! Frame-aligned delivery and prefix budgets before the official H3 decoder.
+//! DATA is skipped by length; payload slices share the native Quinn backing.
+use h3::error::Code;
+
+#[derive(Default)]
+struct Varint {
+    left: u8,
+    value: u64,
+    started: bool,
+}
+
+impl Varint {
+    fn push(&mut self, byte: u8) -> Option<u64> {
+        if self.started {
+            self.value = (self.value << 8) | u64::from(byte);
+            self.left -= 1;
+        } else {
+            self.started = true;
+            self.left = (1 << (byte >> 6)) - 1;
+            self.value = u64::from(byte & 63);
+        }
+        (self.left == 0).then_some(self.value)
+    }
+}
+
+enum State {
+    UniType(Varint),
+    PushId(Varint),
+    FrameType(Varint),
+    FrameLength(Varint),
+    Payload(u64),
+    Bypass,
+}
+
+pub(super) struct Budget {
+    state: State,
+    frame_type: u64,
+    header_wire: u64,
+    control: bool,
+}
+
+impl Budget {
+    pub(super) fn new(header_limit: u64, unidirectional: bool) -> Self {
+        Self {
+            state: if unidirectional {
+                State::UniType(Varint::default())
+            } else {
+                State::FrameType(Varint::default())
+            },
+            frame_type: 0,
+            header_wire: header_limit.saturating_add(header_limit / 2),
+            control: false,
+        }
+    }
+
+    pub(super) fn is_control(&self) -> bool {
+        self.control
+    }
+
+    /// Separate a frame's header from its payload and the following frame.
+    /// h3 0.0.8 polls for another chunk before consuming its buffered DATA.
+    /// Returning coalesced frames would let that buffer grow outside Quinn's
+    /// receive window even while the application is reading slowly.
+    pub(super) fn prefix(&mut self, bytes: &[u8]) -> Result<usize, Code> {
+        let mut offset = 0;
+        while offset < bytes.len() {
+            match &mut self.state {
+                State::Bypass => return Ok(bytes.len()),
+                State::Payload(left) => {
+                    let n = (*left).min((bytes.len() - offset) as u64) as usize;
+                    offset += n;
+                    *left -= n as u64;
+                    if *left == 0 {
+                        self.state = State::FrameType(Varint::default());
+                    }
+                    return Ok(offset);
+                }
+                State::UniType(value) => {
+                    let value = value.push(bytes[offset]);
+                    offset += 1;
+                    if let Some(value) = value {
+                        self.control = value == 0;
+                        self.state = match value {
+                            0 => State::FrameType(Varint::default()),
+                            1 => State::PushId(Varint::default()),
+                            // QPACK is not H3 framing. The official backend
+                            // retains its QPACK streams and aborts unknown uni.
+                            _ => State::Bypass,
+                        };
+                        return Ok(offset);
+                    }
+                }
+                State::PushId(value) => {
+                    let value = value.push(bytes[offset]);
+                    offset += 1;
+                    if value.is_some() {
+                        self.state = State::FrameType(Varint::default());
+                        return Ok(offset);
+                    }
+                }
+                State::FrameType(value) => {
+                    let value = value.push(bytes[offset]);
+                    offset += 1;
+                    if let Some(value) = value {
+                        self.frame_type = value;
+                        if value == 0x41 {
+                            // The official codec's WebTransport bidi marker
+                            // has a session ID instead of a frame length.
+                            self.state = State::Bypass;
+                            return Ok(offset);
+                        }
+                        self.state = State::FrameLength(Varint::default());
+                    }
+                }
+                State::FrameLength(value) => {
+                    let value = value.push(bytes[offset]);
+                    offset += 1;
+                    if let Some(length) = value {
+                        check_length(self.frame_type, length, self.header_wire)?;
+                        self.state = if length == 0 {
+                            State::FrameType(Varint::default())
+                        } else {
+                            State::Payload(length)
+                        };
+                        return Ok(offset);
+                    }
+                }
+            }
+        }
+        Ok(offset)
+    }
+
+    #[cfg(test)]
+    pub(super) fn check(&mut self, mut bytes: &[u8]) -> Result<(), Code> {
+        while !bytes.is_empty() {
+            let count = self.prefix(bytes)?;
+            bytes = &bytes[count..];
+        }
+        Ok(())
+    }
+}
+
+fn check_length(frame: u64, length: u64, header_wire: u64) -> Result<(), Code> {
+    match frame {
+        // The official decoder stores DATA's remaining length in usize.
+        // Refuse a valid wire length that this target cannot represent rather
+        // than letting its conversion truncate framing. This is a target
+        // resource limit, not a DATA body cap: all QUIC lengths fit on 64-bit.
+        0 => usize::try_from(length)
+            .map(|_| ())
+            .map_err(|_| Code::H3_EXCESSIVE_LOAD),
+        1 if length <= header_wire => Ok(()),
+        1 => Err(Code::H3_EXCESSIVE_LOAD),
+        3 | 7 | 13 if (1..=8).contains(&length) => Ok(()),
+        3 | 7 | 13 => Err(Code::H3_FRAME_ERROR),
+        4 if length <= 256 => Ok(()),
+        4 => Err(Code::H3_FRAME_ERROR),
+        5 if length == 0 => Err(Code::H3_FRAME_ERROR),
+        5 if length <= header_wire.saturating_add(8) => Ok(()),
+        5 => Err(Code::H3_EXCESSIVE_LOAD),
+        // The official codec buffers unknown frames before ignoring them.
+        // Bound that buffering to the encoded-header budget instead of the
+        // quiche backend's 16 MiB skip limit, which does not retain a payload.
+        _ if length <= header_wire => Ok(()),
+        _ => Err(Code::H3_EXCESSIVE_LOAD),
+    }
+}
+
+#[cfg(all(test, target_pointer_width = "32"))]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn data_length_overflow_is_rejected_at_prefix_without_body() {
+        // Literal HTTP/3 DATA prefixes: 2^32-1 is representable; 2^32 is not.
+        // No payload is allocated or consumed for either declaration.
+        let mut valid = Budget::new(16 * 1024, false);
+        assert!(
+            valid
+                .check(&[0, 0xc0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff])
+                .is_ok()
+        );
+        let oversized = [0, 0xc0, 0, 0, 1, 0, 0, 0, 0];
+        for split in 0..oversized.len() {
+            let mut budget = Budget::new(16 * 1024, false);
+            assert!(budget.check(&oversized[..split]).is_ok());
+            assert_eq!(
+                budget.check(&oversized[split..]),
+                Err(Code::H3_EXCESSIVE_LOAD)
+            );
+        }
+    }
+}
diff --git a/src/transport/quinn_h3_cancel_tests.rs b/src/transport/quinn_h3_cancel_tests.rs
new file mode 100644
index 0000000..0f4609c
--- /dev/null
+++ b/src/transport/quinn_h3_cancel_tests.rs
@@ -0,0 +1,366 @@
+use super::*;
+use tokio::sync::oneshot;
+
+fn request(path: &str) -> http::Request<()> {
+    http::Request::get(format!("https://localhost{path}"))
+        .body(())
+        .unwrap()
+}
+
+async fn response(stream: &mut ServerStream, payload: Bytes) {
+    stream
+        .send_response(http::Response::builder().status(200).body(()).unwrap())
+        .await
+        .unwrap();
+    stream.send_data(payload).await.unwrap();
+    stream.finish().await.unwrap();
+}
+
+async fn receive(stream: &mut RequestStream) -> Vec<u8> {
+    assert_eq!(stream.recv_response().await.unwrap().status(), 200);
+    let mut data = Vec::new();
+    while let Some(mut chunk) = stream.recv_data().await.unwrap() {
+        data.extend_from_slice(&chunk.copy_to_bytes(chunk.remaining()));
+        assert!(data.len() <= 64 * 1024);
+    }
+    let _ = stream.recv_trailers().await.unwrap();
+    data
+}
+
+#[derive(Clone, Copy, Debug)]
+enum ReadPhase {
+    Headers,
+    Body,
+    Trailers,
+}
+
+async fn drop_pending_query(phase: ReadPhase, explicit_cancel: bool) {
+    let mut pair = Pair::new(64 * 1024).await;
+    let (mut client, mut server) = pair.h3().await;
+    let native = pair.client.clone();
+    let (first_ready, ready) = oneshot::channel();
+    let (release, released) = oneshot::channel();
+    let (observed, result) = oneshot::channel();
+    pair.spawn(async move {
+        let (request, mut first) = server
+            .accept()
+            .await
+            .unwrap()
+            .unwrap()
+            .resolve_request()
+            .await
+            .unwrap();
+        assert_eq!(request.uri().path(), "/cancel");
+        assert!(first.recv_data().await.unwrap().is_none());
+        if !matches!(phase, ReadPhase::Headers) {
+            first
+                .send_response(http::Response::builder().status(200).body(()).unwrap())
+                .await
+                .unwrap();
+        }
+        if matches!(phase, ReadPhase::Trailers) {
+            first
+                .send_data(Bytes::from_static(b"partial"))
+                .await
+                .unwrap();
+            let mut trailers = http::HeaderMap::new();
+            trailers.insert("x-fixture", http::HeaderValue::from_static("trailer"));
+            first.send_trailers(trailers).await.unwrap();
+        }
+        first_ready.send(()).unwrap();
+        let (request, mut sibling) = server
+            .accept()
+            .await
+            .unwrap()
+            .unwrap()
+            .resolve_request()
+            .await
+            .unwrap();
+        assert_eq!(request.uri().path(), "/sibling");
+        assert!(sibling.recv_data().await.unwrap().is_none());
+        response(&mut sibling, Bytes::from_static(b"sibling-body")).await;
+        released.await.unwrap();
+        if matches!(phase, ReadPhase::Trailers) {
+            // No DATA is legal after trailers. The sibling already proves the
+            // connection remains usable; releasing this half completes cleanup.
+            drop(first);
+            observed.send(None).unwrap();
+        } else {
+            let outcome = async {
+                if matches!(phase, ReadPhase::Headers) {
+                    first
+                        .send_response(http::Response::builder().status(200).body(()).unwrap())
+                        .await?;
+                }
+                first.send_data(Bytes::from(vec![b'x'; 128 * 1024])).await
+            }
+            .await;
+            let code = match outcome {
+                Err(h3::error::StreamError::RemoteTerminate { code }) => code.value(),
+                other => panic!("canceled receiver must stop peer upload: {other:?}"),
+            };
+            observed.send(Some(code)).unwrap();
+        }
+        // Keep polling H3 control until the fixture's synchronized Stop.
+        let _ = server.accept().await;
+    });
+    settle(pair, async move {
+        let mut stream = client.send_request(request("/cancel")).await.unwrap();
+        let id = stream.id();
+        stream.finish().await.unwrap();
+        ready.await.unwrap();
+        match phase {
+            ReadPhase::Headers => {
+                let mut reading = Box::pin(stream.recv_response());
+                assert!(poll_fn(|cx| Poll::Ready(reading.as_mut().poll(cx).is_pending())).await);
+                drop(reading);
+            }
+            ReadPhase::Body => {
+                assert_eq!(stream.recv_response().await.unwrap().status(), 200);
+                let mut reading = Box::pin(stream.recv_data());
+                assert!(poll_fn(|cx| Poll::Ready(reading.as_mut().poll(cx).is_pending())).await);
+                drop(reading);
+            }
+            ReadPhase::Trailers => {
+                assert_eq!(stream.recv_response().await.unwrap().status(), 200);
+                let mut body = Vec::new();
+                while let Some(mut data) = stream.recv_data().await.unwrap() {
+                    body.extend_from_slice(&data.copy_to_bytes(data.remaining()));
+                }
+                assert_eq!(body, b"partial");
+                let mut reading = Box::pin(stream.recv_trailers());
+                assert!(poll_fn(|cx| Poll::Ready(reading.as_mut().poll(cx).is_pending())).await);
+                drop(reading);
+            }
+        }
+        if explicit_cancel {
+            stream.stop_sending(h3::error::Code::H3_REQUEST_CANCELLED);
+            assert_eq!(
+                stream.id(),
+                id,
+                "a Pending read must not hide its stream ID"
+            );
+        }
+        drop(stream);
+        assert!(client.can_open_request());
+        let mut sibling = client.send_request(request("/sibling")).await.unwrap();
+        sibling.finish().await.unwrap();
+        assert_eq!(receive(&mut sibling).await, b"sibling-body");
+        assert!(native.close_reason().is_none());
+        release.send(()).unwrap();
+        if let Some(code) = result.await.unwrap() {
+            assert_eq!(code, 0, "official raw receive Drop uses STOP_SENDING(0)");
+        }
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn dropped_pending_headers_preserves_sibling_and_stop() {
+    drop_pending_query(ReadPhase::Headers, false).await;
+}
+
+#[tokio::test]
+async fn dropped_pending_body_preserves_sibling_and_stop() {
+    drop_pending_query(ReadPhase::Body, false).await;
+}
+
+#[tokio::test]
+async fn dropped_pending_trailers_preserves_sibling_and_stop() {
+    drop_pending_query(ReadPhase::Trailers, false).await;
+}
+
+#[tokio::test]
+async fn explicit_pending_body_cancel_preserves_sibling_and_stop() {
+    drop_pending_query(ReadPhase::Body, true).await;
+}
+
+#[tokio::test]
+async fn canceled_backpressured_headers_preserves_sibling_and_stop() {
+    let mut pair = Pair::new(64).await;
+    let (mut client, mut server) = pair.h3().await;
+    let native = pair.client.clone();
+    settle(pair, async move {
+        let large = http::Request::get("https://localhost/cancel-headers")
+            .header(
+                "x-fixture",
+                "abcdefghijklmNOPQRSTUVWXYZ0123456789".repeat(128),
+            )
+            .body(())
+            .unwrap();
+        let mut sending = Box::pin(client.send_request(large));
+        assert!(
+            poll_fn(|cx| Poll::Ready(sending.as_mut().poll(cx).is_pending())).await,
+            "actual native 64-byte receive credit must block HEADERS transmission"
+        );
+        drop(sending);
+        let rejected = server
+            .accept()
+            .await
+            .unwrap()
+            .unwrap()
+            .resolve_request()
+            .await
+            .err()
+            .expect("the peer must reject the incomplete canceled HEADERS");
+        assert!(
+            !matches!(rejected, h3::error::StreamError::ConnectionError(_)),
+            "canceling a request must not kill the physical connection: {rejected:?}"
+        );
+        assert!(native.close_reason().is_none());
+        let exchange = async {
+            let mut sibling = client.send_request(request("/sibling")).await.unwrap();
+            sibling.finish().await.unwrap();
+            assert_eq!(receive(&mut sibling).await, b"header-cancel-sibling");
+        };
+        let peer = async {
+            let (request, mut stream) = server
+                .accept()
+                .await
+                .unwrap()
+                .unwrap()
+                .resolve_request()
+                .await
+                .unwrap();
+            assert_eq!(request.uri().path(), "/sibling");
+            assert!(stream.recv_data().await.unwrap().is_none());
+            response(&mut stream, Bytes::from_static(b"header-cancel-sibling")).await;
+            // Continue driving peer critical streams while the client finishes.
+            let _ = server.accept().await;
+        };
+        // The peer accept loop stays alive through the full response; it can
+        // then be canceled when the client has consumed body/trailers/EOF.
+        tokio::pin!(peer);
+        tokio::select! {
+            () = exchange => {},
+            () = &mut peer => panic!("peer completed before the sibling response"),
+        }
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn upload_credit_recovers_all_data_and_fin_without_ack_barrier() {
+    let mut pair = Pair::new(1024).await;
+    let (mut client, mut server) = pair.h3().await;
+    let payload = Bytes::from((0..65_673).map(|n| (n % 251) as u8).collect::<Vec<_>>());
+    let expected = payload.clone();
+    settle(pair, async move {
+        let request = http::Request::post("https://localhost/upload")
+            .body(())
+            .unwrap();
+        let stream = client.send_request(request).await.unwrap();
+        let (mut upload, mut download) = stream.split();
+        let exchange = async {
+            let writing = async move {
+                let mut sending = Box::pin(upload.send_data(payload));
+                assert!(poll_fn(|cx| Poll::Ready(sending.as_mut().poll(cx).is_pending())).await);
+                sending.as_mut().await.unwrap();
+                drop(sending);
+                upload.finish().await.unwrap();
+                // Native FIN is enough here. Drop must preserve accepted data
+                // while the shared physical connection continues to run.
+                drop(upload);
+            };
+            let reading = async {
+                assert_eq!(download.recv_response().await.unwrap().status(), 200);
+                let mut body = Vec::new();
+                while let Some(mut data) = download.recv_data().await.unwrap() {
+                    body.extend_from_slice(&data.copy_to_bytes(data.remaining()));
+                }
+                assert_eq!(body, b"upload-complete");
+                assert!(download.recv_trailers().await.unwrap().is_none());
+            };
+            tokio::join!(writing, reading);
+        };
+        let peer = async {
+            let (request, mut stream) = server
+                .accept()
+                .await
+                .unwrap()
+                .unwrap()
+                .resolve_request()
+                .await
+                .unwrap();
+            assert_eq!(request.method(), http::Method::POST);
+            let mut body = Vec::new();
+            while let Some(mut data) = stream.recv_data().await.unwrap() {
+                body.extend_from_slice(&data.copy_to_bytes(data.remaining()));
+                assert!(body.len() <= expected.len());
+            }
+            assert_eq!(body, expected);
+            assert!(stream.recv_trailers().await.unwrap().is_none());
+            response(&mut stream, Bytes::from_static(b"upload-complete")).await;
+            let _ = server.accept().await;
+        };
+        tokio::pin!(peer);
+        tokio::select! {
+            () = exchange => {},
+            () = &mut peer => panic!("peer completed before upload response"),
+        }
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn dropped_backpressured_data_resets_upload_and_preserves_sibling() {
+    let mut pair = Pair::new(1024).await;
+    let (mut client, mut server) = pair.h3().await;
+    let (accepted, ready) = oneshot::channel();
+    let (observed, reset) = oneshot::channel();
+    pair.spawn(async move {
+        let (_, mut first) = server
+            .accept()
+            .await
+            .unwrap()
+            .unwrap()
+            .resolve_request()
+            .await
+            .unwrap();
+        accepted.send(()).unwrap();
+        let error = first
+            .recv_data()
+            .await
+            .err()
+            .expect("unfinished DATA must reset");
+        match error {
+            h3::error::StreamError::RemoteTerminate { code } => {
+                assert_eq!(code, h3::error::Code::H3_REQUEST_CANCELLED);
+            }
+            other => panic!("expected request cancellation reset, got {other:?}"),
+        }
+        observed.send(()).unwrap();
+        let (_, mut sibling) = server
+            .accept()
+            .await
+            .unwrap()
+            .unwrap()
+            .resolve_request()
+            .await
+            .unwrap();
+        assert!(sibling.recv_data().await.unwrap().is_none());
+        response(&mut sibling, Bytes::from_static(b"data-cancel-sibling")).await;
+        let _ = server.accept().await;
+    });
+    settle(pair, async move {
+        let mut stream = client
+            .send_request(
+                http::Request::post("https://localhost/cancel-data")
+                    .body(())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+        ready.await.unwrap();
+        let mut sending = Box::pin(stream.send_data(Bytes::from(vec![b'x'; 64 * 1024])));
+        assert!(poll_fn(|cx| Poll::Ready(sending.as_mut().poll(cx).is_pending())).await);
+        drop(sending);
+        drop(stream);
+        reset.await.unwrap();
+        let mut sibling = client.send_request(request("/sibling")).await.unwrap();
+        sibling.finish().await.unwrap();
+        assert_eq!(receive(&mut sibling).await, b"data-cancel-sibling");
+        assert!(client.can_open_request());
+    })
+    .await;
+}
diff --git a/src/transport/quinn_h3_tests.rs b/src/transport/quinn_h3_tests.rs
new file mode 100644
index 0000000..84979e4
--- /dev/null
+++ b/src/transport/quinn_h3_tests.rs
@@ -0,0 +1,288 @@
+//! Real QUIC/H3 cancellation regressions over bounded in-memory datagrams.
+use super::*;
+use crate::transport::quic::OwnedRuntime;
+use bytes::Buf;
+use futures_util::{FutureExt, future::poll_fn};
+use std::{
+    future::Future,
+    io::{self, IoSliceMut},
+    net::SocketAddr,
+    panic::{AssertUnwindSafe, resume_unwind},
+    pin::Pin,
+    sync::{Arc, Mutex},
+    task::{Context, Poll, ready},
+    time::Duration,
+};
+use tokio::{sync::mpsc, task::JoinHandle, time::timeout};
+use tokio_util::sync::CancellationToken;
+
+const LIMIT: Duration = Duration::from_secs(5);
+pub(crate) type Server = h3::server::Connection<h3_quinn::Connection, Bytes>;
+type ServerStream = h3::server::RequestStream<h3_quinn::BidiStream<Bytes>, Bytes>;
+
+#[derive(Debug)]
+struct Socket {
+    send: mpsc::Sender<Bytes>,
+    receive: Mutex<mpsc::Receiver<Bytes>>,
+    local: SocketAddr,
+    peer: SocketAddr,
+}
+
+#[derive(Debug)]
+struct Writable(Mutex<tokio_util::sync::PollSender<Bytes>>);
+
+impl quinn::UdpPoller for Writable {
+    fn poll_writable(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let mut send = self.0.lock().unwrap();
+        match ready!(send.poll_reserve(cx)) {
+            Ok(()) => {
+                send.abort_send();
+                Poll::Ready(Ok(()))
+            }
+            Err(_) => Poll::Ready(Err(io::ErrorKind::BrokenPipe.into())),
+        }
+    }
+}
+
+impl quinn::AsyncUdpSocket for Socket {
+    fn create_io_poller(self: Arc<Self>) -> Pin<Box<dyn quinn::UdpPoller>> {
+        Box::pin(Writable(Mutex::new(tokio_util::sync::PollSender::new(
+            self.send.clone(),
+        ))))
+    }
+
+    fn try_send(&self, packet: &quinn::udp::Transmit<'_>) -> io::Result<()> {
+        assert_eq!(packet.destination, self.peer);
+        assert!(packet.segment_size.is_none());
+        self.send
+            .try_send(Bytes::copy_from_slice(packet.contents))
+            .map_err(|error| match error {
+                mpsc::error::TrySendError::Full(_) => io::ErrorKind::WouldBlock.into(),
+                mpsc::error::TrySendError::Closed(_) => io::ErrorKind::BrokenPipe.into(),
+            })
+    }
+
+    fn poll_recv(
+        &self,
+        cx: &mut Context<'_>,
+        buffers: &mut [IoSliceMut<'_>],
+        metadata: &mut [quinn::udp::RecvMeta],
+    ) -> Poll<io::Result<usize>> {
+        let Some(packet) = ready!(self.receive.lock().unwrap().poll_recv(cx)) else {
+            return Poll::Ready(Err(io::ErrorKind::BrokenPipe.into()));
+        };
+        assert!(packet.len() <= buffers[0].len());
+        buffers[0][..packet.len()].copy_from_slice(&packet);
+        metadata[0] = quinn::udp::RecvMeta {
+            addr: self.peer,
+            len: packet.len(),
+            stride: packet.len(),
+            ecn: None,
+            dst_ip: Some(self.local.ip()),
+        };
+        Poll::Ready(Ok(1))
+    }
+
+    fn local_addr(&self) -> io::Result<SocketAddr> {
+        Ok(self.local)
+    }
+}
+
+/// Reuse the existing bounded passive socket for production-driver fixtures.
+#[cfg(feature = "outbound-vless")]
+pub(crate) fn memory_socket(
+    send: mpsc::Sender<Bytes>,
+    receive: mpsc::Receiver<Bytes>,
+    local: SocketAddr,
+    peer: SocketAddr,
+) -> Arc<dyn quinn::AsyncUdpSocket> {
+    Arc::new(Socket {
+        send,
+        receive: Mutex::new(receive),
+        local,
+        peer,
+    })
+}
+
+pub(crate) struct Pair {
+    pub(crate) client: quinn::Connection,
+    server: quinn::Connection,
+    client_endpoint: quinn::Endpoint,
+    server_endpoint: quinn::Endpoint,
+    pub(crate) client_runtime: Arc<OwnedRuntime>,
+    server_runtime: Arc<OwnedRuntime>,
+    cancel: CancellationToken,
+    tasks: Vec<JoinHandle<()>>,
+}
+
+impl Pair {
+    pub(crate) async fn new(server_stream_credit: u32) -> Self {
+        let identity = rcgen::generate_simple_self_signed(vec!["localhost".into()]).unwrap();
+        let provider = Arc::new(rustls::crypto::ring::default_provider());
+        let mut roots = rustls::RootCertStore::empty();
+        roots.add(identity.cert.der().clone()).unwrap();
+        let mut client_tls = rustls::ClientConfig::builder_with_provider(provider.clone())
+            .with_protocol_versions(&[&rustls::version::TLS13])
+            .unwrap()
+            .with_root_certificates(roots)
+            .with_no_client_auth();
+        client_tls.alpn_protocols = vec![b"h3".to_vec()];
+        let mut server_tls = rustls::ServerConfig::builder_with_provider(provider)
+            .with_protocol_versions(&[&rustls::version::TLS13])
+            .unwrap()
+            .with_no_client_auth()
+            .with_single_cert(
+                vec![identity.cert.der().clone()],
+                rustls::pki_types::PrivateKeyDer::Pkcs8(
+                    identity.signing_key.serialize_der().into(),
+                ),
+            )
+            .unwrap();
+        server_tls.alpn_protocols = vec![b"h3".to_vec()];
+        let mut client_config = quinn::ClientConfig::new(Arc::new(
+            quinn::crypto::rustls::QuicClientConfig::try_from(client_tls).unwrap(),
+        ));
+        client_config.transport_config(Arc::new(transport(64 * 1024)));
+        let mut server_config = quinn::ServerConfig::with_crypto(Arc::new(
+            quinn::crypto::rustls::QuicServerConfig::try_from(server_tls).unwrap(),
+        ));
+        server_config.transport_config(Arc::new(transport(server_stream_credit)));
+        let client_address: SocketAddr = "192.0.2.1:44001".parse().unwrap();
+        let server_address: SocketAddr = "192.0.2.2:443".parse().unwrap();
+        let (to_client, from_server) = mpsc::channel(32);
+        let (to_server, from_client) = mpsc::channel(32);
+        let client_runtime = Arc::new(OwnedRuntime::new(CancellationToken::new()));
+        let server_runtime = Arc::new(OwnedRuntime::new(CancellationToken::new()));
+        let mut client_endpoint = quinn::Endpoint::new_with_abstract_socket(
+            quinn::EndpointConfig::default(),
+            None,
+            Arc::new(Socket {
+                send: to_server,
+                receive: Mutex::new(from_server),
+                local: client_address,
+                peer: server_address,
+            }),
+            client_runtime.clone(),
+        )
+        .unwrap();
+        client_endpoint.set_default_client_config(client_config);
+        let server_endpoint = quinn::Endpoint::new_with_abstract_socket(
+            quinn::EndpointConfig::default(),
+            Some(server_config),
+            Arc::new(Socket {
+                send: to_client,
+                receive: Mutex::new(from_client),
+                local: server_address,
+                peer: client_address,
+            }),
+            server_runtime.clone(),
+        )
+        .unwrap();
+        let (client, server) = timeout(LIMIT, async {
+            tokio::join!(
+                client_endpoint
+                    .connect(server_address, "localhost")
+                    .unwrap(),
+                async { server_endpoint.accept().await.unwrap().await }
+            )
+        })
+        .await
+        .unwrap();
+        let client = client.unwrap();
+        let server = server.unwrap();
+        let handshake = client
+            .handshake_data()
+            .unwrap()
+            .downcast::<quinn::crypto::rustls::HandshakeData>()
+            .unwrap();
+        assert_eq!(handshake.protocol.as_deref(), Some(b"h3".as_slice()));
+        Self {
+            client,
+            server,
+            client_endpoint,
+            server_endpoint,
+            client_runtime,
+            server_runtime,
+            cancel: CancellationToken::new(),
+            tasks: Vec::new(),
+        }
+    }
+
+    pub(crate) fn spawn(&mut self, future: impl Future<Output = ()> + Send + 'static) {
+        let cancel = self.cancel.clone();
+        self.tasks.push(tokio::spawn(async move {
+            tokio::select! { biased; () = cancel.cancelled() => {}, () = future => {} }
+        }));
+    }
+
+    pub(crate) async fn h3(&mut self) -> (Client, Server) {
+        let (client, mut control) = attach(self.client.clone(), 16 * 1024).await.unwrap();
+        let keep_client = client.clone();
+        self.spawn(async move {
+            let _keep_client = keep_client;
+            let _ = control.wait_idle().await;
+        });
+        let server = h3::server::builder()
+            .max_field_section_size(16 * 1024)
+            .build::<_, Bytes>(h3_quinn::Connection::new(self.server.clone()))
+            .await
+            .unwrap();
+        (client, server)
+    }
+
+    pub(crate) async fn stop(mut self) {
+        self.client_endpoint.close(0_u8.into(), b"");
+        self.server_endpoint.close(0_u8.into(), b"");
+        self.cancel.cancel();
+        let mut failed_task = None;
+        for task in self.tasks.drain(..) {
+            if let Err(error) = task.await {
+                failed_task.get_or_insert(error);
+            }
+        }
+        let _ = timeout(LIMIT, async {
+            tokio::join!(
+                self.client_endpoint.wait_idle(),
+                self.server_endpoint.wait_idle()
+            )
+        })
+        .await;
+        self.client_runtime.stop().await;
+        self.server_runtime.stop().await;
+        if let Some(error) = failed_task {
+            resume_unwind(error.into_panic());
+        }
+    }
+}
+
+fn transport(stream_credit: u32) -> quinn::TransportConfig {
+    let mut config = quinn::TransportConfig::default();
+    config
+        .initial_mtu(1200)
+        .min_mtu(1200)
+        .mtu_discovery_config(None)
+        .max_concurrent_bidi_streams(8_u8.into())
+        .max_concurrent_uni_streams(8_u8.into())
+        .stream_receive_window(stream_credit.into())
+        .receive_window((128_u32 * 1024).into())
+        .send_window(64 * 1024)
+        .max_idle_timeout(Some(Duration::from_secs(10).try_into().unwrap()));
+    config
+}
+
+async fn settle(pair: Pair, future: impl Future<Output = ()>) {
+    let result = AssertUnwindSafe(timeout(LIMIT, future))
+        .catch_unwind()
+        .await;
+    pair.stop().await;
+    match result {
+        Ok(result) => result.expect("bounded memory H3 operation timed out"),
+        Err(panic) => resume_unwind(panic),
+    }
+}
+
+#[path = "quinn_h3_cancel_tests.rs"]
+mod cancellation;
+
+#[path = "quinn_h3_wire_tests.rs"]
+mod wire_budget;
diff --git a/src/transport/quinn_h3_wire_tests.rs b/src/transport/quinn_h3_wire_tests.rs
new file mode 100644
index 0000000..a9378f2
--- /dev/null
+++ b/src/transport/quinn_h3_wire_tests.rs
@@ -0,0 +1,272 @@
+//! The peer sends only an HTTP/3 frame prefix, never the oversized payload.
+use super::*;
+use tokio::sync::oneshot;
+
+#[test]
+fn receive_prefixes_progress_across_empty_data_and_bypass_qpack() {
+    // Empty DATA, one-byte DATA and another empty DATA. Every native chunk
+    // split must retain all wire bytes and yield nonempty framing prefixes.
+    let wire = [0, 0, 0, 1, 42, 0, 0];
+    for size in 1..=wire.len() {
+        let mut budget = super::super::budget::Budget::new(16 * 1024, false);
+        let mut count = 0;
+        for mut chunk in wire.chunks(size) {
+            while !chunk.is_empty() {
+                let length = budget.prefix(chunk).unwrap();
+                assert!(length > 0 && length <= chunk.len());
+                count += length;
+                chunk = &chunk[length..];
+            }
+        }
+        assert_eq!(count, wire.len());
+    }
+    let mut qpack = super::super::budget::Budget::new(0, true);
+    assert_eq!(qpack.prefix(&[2, 255, 255]).unwrap(), 1);
+    assert_eq!(qpack.prefix(&[255, 255]).unwrap(), 2);
+}
+
+#[tokio::test]
+async fn small_data_frames_do_not_release_unbounded_receive_credit() {
+    use std::sync::atomic::AtomicUsize;
+
+    let mut pair = Pair::new(64 * 1024).await;
+    let (mut client, server_control) = pair.h3().await;
+    let server = pair.server.clone();
+    let sent = Arc::new(AtomicUsize::new(0));
+    let progress = sent.clone();
+    pair.spawn(async move {
+        let _server_control = server_control;
+        let (mut send, mut receive) = server.accept_bi().await.unwrap();
+        assert!(!receive.read_to_end(16 * 1024).await.unwrap().is_empty());
+        send.write_all(&[1, 3, 0, 0, 0xd9]).await.unwrap();
+        // Coalesced tiny DATA frames reproduce a continuously ready stream:
+        // one native QUIC chunk holds many application deliveries.
+        let batch = [0, 8, 1, 2, 3, 4, 5, 6, 7, 8].repeat(1000);
+        loop {
+            if send.write_all(&batch).await.is_err() {
+                break;
+            }
+            progress.fetch_add(batch.len(), Ordering::Relaxed);
+        }
+    });
+    settle(pair, async move {
+        let mut stream = client
+            .send_request(
+                http::Request::get("https://localhost/backpressure")
+                    .body(())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+        stream.finish().await.unwrap();
+        assert_eq!(stream.recv_response().await.unwrap().status(), 200);
+        let mut delivered = 0;
+        while delivered < 4096 {
+            let mut data = stream.recv_data().await.unwrap().unwrap();
+            while data.has_remaining() {
+                assert_eq!(data.get_u8(), (delivered % 8 + 1) as u8);
+                delivered += 1;
+            }
+            // Let the native driver refill its bounded window before the next
+            // application read. No real sockets or network peer are involved.
+            tokio::time::sleep(Duration::from_millis(1)).await;
+        }
+        assert_eq!(delivered, 4096);
+        let accepted = sent.load(Ordering::Relaxed);
+        // Includes both QUIC receive credit and the peer's bounded send queue.
+        // Consuming 4 KiB must not unlock a stream of prefetched DATA frames.
+        assert!(
+            accepted <= 256 * 1024,
+            "peer accepted {accepted} bytes after {delivered} application bytes"
+        );
+    })
+    .await;
+}
+
+#[test]
+fn every_prefix_split_rejects_after_complete_declared_length() {
+    // Non-minimal 8-byte QUIC varints are valid. These independent wire
+    // fixtures complement native IO tests, whose packet coalescing does not
+    // guarantee a particular receive-chunk boundary.
+    let headers = [0xc0, 0, 0, 0, 0, 0, 0, 1, 0x80, 0, 0x60, 1];
+    let settings = [
+        0xc0, 0, 0, 0, 0, 0, 0, 0, 0xc0, 0, 0, 0, 0, 0, 0, 4, 0x41, 1,
+    ];
+    for (wire, uni, expected) in [
+        (
+            headers.as_slice(),
+            false,
+            h3::error::Code::H3_EXCESSIVE_LOAD,
+        ),
+        (settings.as_slice(), true, h3::error::Code::H3_FRAME_ERROR),
+    ] {
+        for split in 0..wire.len() {
+            let mut budget = super::super::budget::Budget::new(16 * 1024, uni);
+            assert!(budget.check(&wire[..split]).is_ok());
+            assert_eq!(budget.check(&wire[split..]), Err(expected));
+        }
+    }
+}
+
+#[tokio::test]
+async fn oversized_headers_prefix_is_rejected_before_payload_and_preserves_sibling() {
+    rejected_request_prefix(&[1, 0x80, 0, 0x60, 1]).await;
+}
+
+async fn rejected_request_prefix(prefix: &'static [u8]) {
+    let mut pair = Pair::new(64 * 1024).await;
+    let (mut client, server_control) = pair.h3().await;
+    let server = pair.server.clone();
+    let native_client = pair.client.clone();
+    let (sent, prefix_sent) = oneshot::channel();
+    pair.spawn(async move {
+        // Retain the official server's critical streams; raw bidi IO below
+        // supplies the malformed response without passing its encoder.
+        let _server_control = server_control;
+        let (mut first, mut request) = server.accept_bi().await.unwrap();
+        assert!(!request.read_to_end(16 * 1024).await.unwrap().is_empty());
+        first.write_all(prefix).await.unwrap();
+        sent.send(()).unwrap();
+        let (mut sibling, mut request) = server.accept_bi().await.unwrap();
+        assert!(!request.read_to_end(16 * 1024).await.unwrap().is_empty());
+        // QPACK field section prefix 0/0 and static :status=200 (index 25),
+        // followed by DATA("sibling"); no dynamic QPACK state is involved.
+        sibling
+            .write_all(&[
+                1, 3, 0, 0, 0xd9, 0, 7, b's', b'i', b'b', b'l', b'i', b'n', b'g',
+            ])
+            .await
+            .unwrap();
+        sibling.finish().unwrap();
+        // Keep the first response open: no payload and no FIN can turn this
+        // into a decoded-field or incomplete-frame test instead of a prefix cap.
+        let _first = first;
+        std::future::pending::<()>().await;
+    });
+    settle(pair, async move {
+        let mut stream = client
+            .send_request(
+                http::Request::get("https://localhost/oversize")
+                    .body(())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+        stream.finish().await.unwrap();
+        prefix_sent.await.unwrap();
+        let response = timeout(Duration::from_millis(500), stream.recv_response())
+            .await
+            .expect("oversized HEADERS prefix must be rejected without waiting for its payload");
+        assert!(response.is_err());
+        drop(stream);
+        assert!(native_client.close_reason().is_none());
+        assert!(client.can_open_request());
+        let mut sibling = client
+            .send_request(
+                http::Request::get("https://localhost/sibling")
+                    .body(())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+        sibling.finish().await.unwrap();
+        assert_eq!(sibling.recv_response().await.unwrap().status(), 200);
+        let mut body = Vec::new();
+        while let Some(mut data) = sibling.recv_data().await.unwrap() {
+            body.extend_from_slice(&data.copy_to_bytes(data.remaining()));
+        }
+        assert_eq!(body, b"sibling");
+        assert!(sibling.recv_trailers().await.unwrap().is_none());
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn oversized_unknown_frame_prefix_is_rejected_before_payload_and_preserves_sibling() {
+    // Unknown frame 31, declared 32 KiB: above the Core retention budget.
+    rejected_request_prefix(&[31, 0x80, 0, 0x80, 0]).await;
+}
+
+async fn rejected_control_prefix(prefix: &'static [u8]) {
+    let mut pair = Pair::new(64 * 1024).await;
+    let (client, mut control) = attach(pair.client.clone(), 16 * 1024).await.unwrap();
+    pair.spawn(async move {
+        let _client = client;
+        let _ = control.wait_idle().await;
+    });
+    let server = pair.server.clone();
+    pair.spawn(async move {
+        let mut stream = server.open_uni().await.unwrap();
+        stream.write_all(prefix).await.unwrap();
+        let _stream = stream;
+        // The absence of payload/FIN cannot produce a parser EOF error.
+        std::future::pending::<()>().await;
+    });
+    let client = pair.client.clone();
+    settle(pair, async move {
+        let _ = timeout(Duration::from_millis(500), client.closed())
+            .await
+            .expect("invalid control prefix must close before its payload arrives");
+        assert!(client.close_reason().is_some());
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn oversized_settings_prefix_is_rejected_before_payload_and_stop_joins() {
+    // Uni control(0), SETTINGS(4), length 257 (maximum is 256).
+    rejected_control_prefix(&[0, 4, 0x41, 1]).await;
+}
+
+#[tokio::test]
+async fn oversized_varint_control_prefix_is_rejected_before_payload_and_stop_joins() {
+    // A valid empty SETTINGS precedes GOAWAY with an impossible 9-byte ID.
+    rejected_control_prefix(&[0, 4, 0, 7, 9]).await;
+}
+
+#[tokio::test]
+async fn fragmented_headers_and_large_data_progress_without_body_scanning() {
+    let mut pair = Pair::new(64 * 1024).await;
+    let (mut client, server_control) = pair.h3().await;
+    let server = pair.server.clone();
+    let payload = Bytes::from((0..65_537).map(|n| (n % 251) as u8).collect::<Vec<_>>());
+    let expected = payload.clone();
+    pair.spawn(async move {
+        let _server_control = server_control;
+        let (mut send, mut receive) = server.accept_bi().await.unwrap();
+        assert!(!receive.read_to_end(16 * 1024).await.unwrap().is_empty());
+        // HEADERS type encoded in 8 bytes, length in 2, then static QPACK 200.
+        // Separate writes/yields exercise prefix progress across native IO.
+        for byte in [0xc0, 0, 0, 0, 0, 0, 0, 1, 0x40, 3, 0, 0, 0xd9] {
+            send.write_all(&[byte]).await.unwrap();
+            tokio::task::yield_now().await;
+        }
+        // DATA length exceeds the non-DATA cap. Payload contains all octets,
+        // including byte patterns that resemble oversized frame prefixes.
+        send.write_all(&[0, 0x80, 1, 0, 1]).await.unwrap();
+        send.write_all(&payload).await.unwrap();
+        send.finish().unwrap();
+        std::future::pending::<()>().await;
+    });
+    settle(pair, async move {
+        let mut stream = client
+            .send_request(
+                http::Request::get("https://localhost/data")
+                    .body(())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+        stream.finish().await.unwrap();
+        assert_eq!(stream.recv_response().await.unwrap().status(), 200);
+        let mut body = Vec::new();
+        while let Some(mut data) = stream.recv_data().await.unwrap() {
+            body.extend_from_slice(&data.copy_to_bytes(data.remaining()));
+            assert!(body.len() <= expected.len());
+        }
+        assert_eq!(body, expected);
+        assert!(stream.recv_trailers().await.unwrap().is_none());
+        assert!(client.can_open_request());
+    })
+    .await;
+}
diff --git a/src/transport/sing_mux.rs b/src/transport/sing_mux.rs
index fa9ae2b..d8f23d6 100644
--- a/src/transport/sing_mux.rs
+++ b/src/transport/sing_mux.rs
@@ -1,4 +1,4 @@
-//! Node-owned sing-mux sessions over supplied authenticated VLESS byte streams.
+//! Node-owned sing-mux sessions over supplied authenticated protocol streams.
 //! No sockets, resolver, global pool, or detached protocol tasks live here.
 use crate::{
     config::{SingMuxConfig, SingMuxProtocol},
@@ -24,17 +24,27 @@ use tokio::{
 use tokio_util::{sync::CancellationToken, task::TaskTracker};
 
 const IDLE_RETAINED: usize = crate::limits::SING_MUX_IDLE_CONNECTIONS;
+mod brutal;
 pub(crate) mod datagram;
 mod h2_driver;
 mod padding;
 mod smux_driver;
 mod yamux_driver;
+pub(crate) struct SuppliedStream {
+    pub io: BoxStream,
+    #[cfg(target_os = "linux")]
+    pub control: Option<crate::dialer::tcp_control::Control>,
+    #[cfg(feature = "outbound-vless")]
+    pub h3_udp: Option<Weak<super::xhttp::UdpAssociationControl>>,
+}
 pub(crate) struct Pool {
     options: SingMuxConfig,
+    autonomous_writes: bool,
     state: Arc<Mutex<State>>,
     opening: tokio::sync::Mutex<()>,
     cancel: CancellationToken,
     tasks: TaskTracker,
+    drained: Option<Arc<tokio::sync::Notify>>,
 }
 #[derive(Default)]
 struct State {
@@ -47,6 +57,14 @@ struct Connection {
     issued: AtomicUsize,
     cancel: CancellationToken,
     _observation: observation::Guard,
+    #[cfg(feature = "outbound-vless")]
+    h3_udp: Option<Weak<super::xhttp::UdpAssociationControl>>,
+}
+struct Reservation {
+    sender: Sender,
+    lease: Lease,
+    #[cfg(feature = "outbound-vless")]
+    h3_udp: Option<Weak<super::xhttp::UdpAssociationControl>>,
 }
 #[derive(Clone)]
 enum Sender {
@@ -61,17 +79,39 @@ impl Drop for Connection {
 }
 impl Pool {
     pub(crate) fn new(options: SingMuxConfig) -> Self {
+        let drained = options.brutal.map(|_| Arc::new(tokio::sync::Notify::new()));
         Self {
             options,
+            autonomous_writes: false,
             state: Arc::default(),
             opening: Default::default(),
             cancel: CancellationToken::new(),
             tasks: TaskTracker::new(),
+            drained,
         }
     }
+    pub(crate) fn set_autonomous_writes(&mut self, enabled: bool, h2_packet_up: bool) {
+        self.autonomous_writes = enabled
+            && !self.options.padding
+            && (self.options.protocol == SingMuxProtocol::Smux
+                || (self.options.protocol == SingMuxProtocol::H2Mux && h2_packet_up));
+    }
+    pub(crate) fn autonomous_writes(&self) -> bool {
+        self.autonomous_writes
+    }
     pub(crate) fn only_tcp(&self) -> bool {
         self.options.only_tcp
     }
+    #[cfg(feature = "outbound-vless")]
+    pub(crate) fn captures_h3_udp(&self) -> bool {
+        self.options.protocol == SingMuxProtocol::H2Mux
+            && !self.options.only_tcp
+            && !self.options.padding
+    }
+    #[cfg(target_os = "linux")]
+    pub(crate) fn brutal_enabled(&self) -> bool {
+        self.options.brutal.is_some()
+    }
     pub(crate) async fn open<F, Fut>(
         &self,
         target: &Destination,
@@ -81,42 +121,55 @@ impl Pool {
     ) -> io::Result<BoxStream>
     where
         F: FnOnce() -> Fut,
-        Fut: Future<Output = io::Result<BoxStream>>,
+        Fut: Future<Output = io::Result<SuppliedStream>>,
     {
         let operation = async {
-            let (sender, lease) = {
+            let mut connect = Some(connect);
+            let reservation = {
                 let _opening = self.opening.lock().await;
-                let existing = {
-                    let mut state = self.state.lock().unwrap();
-                    if state.closed {
-                        return Err(io::ErrorKind::ConnectionAborted.into());
+                loop {
+                    // notify_one stores a permit if the final lease drains
+                    // between the state check and polling this waiter. The
+                    // opening lock permits only one retirement waiter.
+                    let notified = self.drained.as_ref().map(|notify| notify.notified());
+                    let (existing, retiring) = {
+                        let mut state = self.state.lock().unwrap();
+                        if state.closed {
+                            return Err(io::ErrorKind::ConnectionAborted.into());
+                        }
+                        state.connections.retain(|c| !c.cancel.is_cancelled());
+                        let existing = state
+                            .connections
+                            .iter()
+                            .filter(|c| c.can_admit())
+                            .min_by_key(|c| c.active.load(Ordering::Acquire))
+                            .filter(|c| {
+                                let active = c.active.load(Ordering::Acquire);
+                                self.options.brutal.is_some()
+                                    || active == 0
+                                    || if self.options.max_connections > 0 {
+                                        state.connections.len() >= self.options.max_connections
+                                            || active < self.options.min_streams
+                                    } else {
+                                        self.options.max_streams > 0
+                                            && active < self.options.max_streams
+                                    }
+                            })
+                            .map(|c| c.reserve(&self.state, self.drained.as_ref()));
+                        let retiring = self.options.brutal.is_some()
+                            && existing.is_none()
+                            && !state.connections.is_empty();
+                        (existing, retiring)
+                    };
+                    if let Some(pair) = existing {
+                        break pair;
+                    }
+                    if retiring {
+                        notified.expect("Brutal retirement notification").await;
+                        continue;
                     }
-                    state.connections.retain(|c| !c.cancel.is_cancelled());
-                    state
-                        .connections
-                        .iter()
-                        .filter(|c| {
-                            !matches!(c.sender, Sender::Yamux(_))
-                                || c.issued.load(Ordering::Acquire) < yamux_driver::STREAMS
-                        })
-                        .min_by_key(|c| c.active.load(Ordering::Acquire))
-                        .filter(|c| {
-                            let active = c.active.load(Ordering::Acquire);
-                            active == 0
-                                || if self.options.max_connections > 0 {
-                                    state.connections.len() >= self.options.max_connections as usize
-                                        || active < self.options.min_streams as usize
-                                } else {
-                                    self.options.max_streams > 0
-                                        && active < self.options.max_streams as usize
-                                }
-                        })
-                        .map(|c| c.reserve(&self.state))
-                };
-                if let Some(pair) = existing {
-                    pair
-                } else {
-                    let mut raw = connect().await?;
+                    let supplied = connect.take().expect("one physical creation")().await?;
+                    let mut raw = supplied.io;
                     let protocol = match self.options.protocol {
                         SingMuxProtocol::Smux => 0,
                         SingMuxProtocol::Yamux => 1,
@@ -136,30 +189,60 @@ impl Pool {
                         raw = Box::new(padding::Padding::new(raw));
                     }
                     let connection = self.establish(raw).await?;
+                    #[cfg(feature = "outbound-vless")]
+                    let connection = {
+                        let mut connection = connection;
+                        connection.h3_udp = supplied.h3_udp;
+                        connection
+                    };
+                    if let Some(options) = self.options.brutal {
+                        // This control stream consumes an actual transport ID
+                        // even though it never becomes a business lease.
+                        connection.issued.fetch_add(1, Ordering::AcqRel);
+                        let mut control = connection
+                            .sender
+                            .open(deadline, self.autonomous_writes)
+                            .await?;
+                        let rate = brutal::exchange(&mut control, options.up, options.down).await?;
+                        #[cfg(target_os = "linux")]
+                        if let Some(physical) = supplied.control
+                            && let Err(error) = physical.apply_brutal(rate)
+                        {
+                            tracing::debug!(error_kind = ?error.kind(), "local TCP Brutal unavailable");
+                        }
+                        #[cfg(not(target_os = "linux"))]
+                        let _ = rate;
+                    }
                     let mut state = self.state.lock().unwrap();
                     if state.closed {
                         return Err(io::ErrorKind::ConnectionAborted.into());
                     }
-                    let pair = connection.reserve(&self.state);
+                    let pair = connection.reserve(&self.state, self.drained.as_ref());
                     state.connections.push(connection);
-                    pair
+                    break pair;
                 }
             };
-            let mut raw = match sender {
-                Sender::H2(sender) => super::grpc::mux_stream(sender, deadline).await?,
-                Sender::Yamux(sender) => sender.open().await?,
-                Sender::Smux(sender) => sender.open().await?,
-            };
+            let mut raw = reservation
+                .sender
+                .open(deadline, self.autonomous_writes)
+                .await?;
             let mut request = Vec::with_capacity(262);
             request.extend_from_slice(&(if udp { 3_u16 } else { 0 }).to_be_bytes());
             crate::socks5::encode_address(target, &mut request)?;
             raw.write_all(&request).await?;
             raw.flush().await?;
+            #[cfg(feature = "outbound-vless")]
+            if udp && let Some(control) = reservation.h3_udp.and_then(|control| control.upgrade()) {
+                // Local metadata flush, not peer status or a transport ACK.
+                control.raise();
+            }
             Ok(Box::new(ResponseStream {
                 raw: Some(raw),
-                lease: Some(lease),
+                lease: Some(reservation.lease),
                 response: false,
-                deadline: Box::pin(tokio::time::sleep_until(deadline)),
+                half_close: self.options.protocol != SingMuxProtocol::Smux,
+                upload_closed: false,
+                deadline: Some(Box::pin(tokio::time::sleep_until(deadline))),
             }) as BoxStream)
         };
         tokio::select! { biased;
@@ -169,7 +252,8 @@ impl Pool {
     }
     async fn establish(&self, raw: BoxStream) -> io::Result<Connection> {
         if self.options.protocol == SingMuxProtocol::Smux {
-            let (sender, driver) = smux_driver::new(raw);
+            let (sender, driver) =
+                smux_driver::new_with_autonomous_writes(raw, self.autonomous_writes);
             return self.own(Sender::Smux(sender), driver);
         }
         if self.options.protocol == SingMuxProtocol::Yamux {
@@ -186,6 +270,7 @@ impl Pool {
     ) -> io::Result<Connection> {
         let cancel = self.cancel.child_token();
         let token = cancel.clone();
+        let drained = self.drained.clone();
         let state = self.state.lock().unwrap();
         if state.closed {
             return Err(io::ErrorKind::ConnectionAborted.into());
@@ -195,6 +280,9 @@ impl Pool {
             let _guard = guard;
             tokio::select! { biased; ()=token.cancelled()=>{}, _=driver=>{} }
             token.cancel();
+            if let Some(drained) = drained {
+                drained.notify_one();
+            }
         }));
         Ok(Connection {
             sender,
@@ -202,6 +290,8 @@ impl Pool {
             issued: AtomicUsize::new(0),
             cancel,
             _observation: observation::track(ResourceKind::Pool),
+            #[cfg(feature = "outbound-vless")]
+            h3_udp: None,
         })
     }
     pub(crate) fn begin_stop(&self) {
@@ -221,8 +311,25 @@ impl Drop for Pool {
         self.begin_stop();
     }
 }
+impl Sender {
+    async fn open(&self, deadline: Instant, autonomous: bool) -> io::Result<BoxStream> {
+        match self {
+            Self::H2(sender) => super::grpc::mux_stream(sender.clone(), deadline, autonomous).await,
+            Self::Yamux(sender) => sender.open().await,
+            Self::Smux(sender) => sender.open().await,
+        }
+    }
+}
 impl Connection {
-    fn reserve(&self, pool: &Arc<Mutex<State>>) -> (Sender, Lease) {
+    fn can_admit(&self) -> bool {
+        !matches!(self.sender, Sender::Yamux(_))
+            || self.issued.load(Ordering::Acquire) < yamux_driver::STREAMS
+    }
+    fn reserve(
+        &self,
+        pool: &Arc<Mutex<State>>,
+        drained: Option<&Arc<tokio::sync::Notify>>,
+    ) -> Reservation {
         self.active.fetch_add(1, Ordering::AcqRel);
         // A dropped logical lease is not proof that yamux has processed its
         // reset. Its public poll_new_outbound closes the entire connection on
@@ -230,24 +337,29 @@ impl Connection {
         // number of issued streams; let existing ones drain on the old driver.
         // This is a per-transport retirement budget, never a node-wide quota.
         self.issued.fetch_add(1, Ordering::AcqRel);
-        (
-            self.sender.clone(),
-            Lease {
+        Reservation {
+            sender: self.sender.clone(),
+            lease: Lease {
                 active: self.active.clone(),
                 pool: Arc::downgrade(pool),
+                drained: drained.cloned(),
             },
-        )
+            #[cfg(feature = "outbound-vless")]
+            h3_udp: self.h3_udp.clone(),
+        }
     }
 }
 struct Lease {
     active: Arc<AtomicUsize>,
     pool: Weak<Mutex<State>>,
+    drained: Option<Arc<tokio::sync::Notify>>,
 }
 impl Drop for Lease {
     fn drop(&mut self) {
-        if self.active.fetch_sub(1, Ordering::AcqRel) == 1
-            && let Some(pool) = self.pool.upgrade()
-        {
+        if self.active.fetch_sub(1, Ordering::AcqRel) != 1 {
+            return;
+        }
+        if let Some(pool) = self.pool.upgrade() {
             let mut idle = 0;
             pool.lock().unwrap().connections.retain(|c| {
                 if c.cancel.is_cancelled() {
@@ -265,13 +377,32 @@ impl Drop for Lease {
                 idle <= IDLE_RETAINED
             });
         }
+        if let Some(drained) = &self.drained {
+            drained.notify_one();
+        }
     }
 }
 struct ResponseStream {
     raw: Option<BoxStream>,
     lease: Option<Lease>,
     response: bool,
-    deadline: Pin<Box<tokio::time::Sleep>>,
+    half_close: bool,
+    upload_closed: bool,
+    deadline: Option<Pin<Box<tokio::time::Sleep>>>,
+}
+impl ResponseStream {
+    fn check_setup(&mut self, cx: &mut Context<'_>) -> io::Result<()> {
+        if self
+            .deadline
+            .as_mut()
+            .is_some_and(|deadline| deadline.as_mut().poll(cx).is_ready())
+        {
+            self.raw.take();
+            self.lease.take();
+            return Err(io::ErrorKind::TimedOut.into());
+        }
+        Ok(())
+    }
 }
 impl AsyncRead for ResponseStream {
     fn poll_read(
@@ -282,12 +413,8 @@ impl AsyncRead for ResponseStream {
         if out.remaining() == 0 || self.raw.is_none() {
             return Poll::Ready(Ok(()));
         }
+        self.check_setup(cx)?;
         if !self.response {
-            // A pooled physical connection does not extend this logical
-            // stream's setup deadline, including an already-buffered status.
-            if self.deadline.as_mut().poll(cx).is_ready() {
-                return Poll::Ready(Err(io::ErrorKind::TimedOut.into()));
-            }
             let mut status = [0];
             let mut buf = ReadBuf::new(&mut status);
             ready!(Pin::new(self.raw.as_mut().unwrap()).poll_read(cx, &mut buf))?;
@@ -300,6 +427,7 @@ impl AsyncRead for ResponseStream {
                 )));
             }
             self.response = true;
+            self.deadline = None;
         }
         Pin::new(self.raw.as_mut().unwrap()).poll_read(cx, out)
     }
@@ -310,17 +438,37 @@ impl AsyncWrite for ResponseStream {
         cx: &mut Context<'_>,
         buf: &[u8],
     ) -> Poll<io::Result<usize>> {
-        Pin::new(self.raw.as_mut().ok_or(io::ErrorKind::BrokenPipe)?).poll_write(cx, buf)
+        if self.upload_closed {
+            return Poll::Ready(Err(io::ErrorKind::BrokenPipe.into()));
+        }
+        self.check_setup(cx)?;
+        let result =
+            Pin::new(self.raw.as_mut().ok_or(io::ErrorKind::BrokenPipe)?).poll_write(cx, buf);
+        if matches!(result, Poll::Ready(Ok(written)) if written > 0) {
+            // A peer may delay both HTTP headers and mux status until target
+            // data exists. Only actual business writes reach this wrapper;
+            // Pool::open has already flushed the mux request metadata.
+            self.deadline = None;
+        }
+        result
     }
     fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        self.check_setup(cx)?;
         Pin::new(self.raw.as_mut().ok_or(io::ErrorKind::BrokenPipe)?).poll_flush(cx)
     }
     fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        if self.upload_closed {
+            return Poll::Ready(Ok(()));
+        }
+        self.check_setup(cx)?;
         if let Some(raw) = &mut self.raw {
             ready!(Pin::new(raw).poll_shutdown(cx))?;
         }
-        self.raw.take();
-        self.lease.take();
+        self.upload_closed = true;
+        if !self.half_close {
+            self.raw.take();
+            self.lease.take();
+        }
         Poll::Ready(Ok(()))
     }
 }
@@ -330,6 +478,45 @@ mod tests {
     use super::*;
     use tokio::io::AsyncReadExt;
 
+    #[tokio::test]
+    async fn half_close_keeps_the_read_side_and_lease_until_drop() {
+        for half_close in [false, true] {
+            let (raw, mut peer) = tokio::io::duplex(16);
+            let active = Arc::new(AtomicUsize::new(1));
+            let mut stream = ResponseStream {
+                raw: Some(Box::new(raw)),
+                lease: Some(Lease {
+                    active: active.clone(),
+                    pool: Weak::new(),
+                    drained: None,
+                }),
+                response: true,
+                half_close,
+                upload_closed: false,
+                deadline: None,
+            };
+            stream.write_all(b"upload").await.unwrap();
+            stream.shutdown().await.unwrap();
+            stream.shutdown().await.unwrap();
+            let mut uploaded = Vec::new();
+            peer.read_to_end(&mut uploaded).await.unwrap();
+            assert_eq!(uploaded, b"upload");
+            assert_eq!(active.load(Ordering::Acquire), usize::from(half_close));
+            if half_close {
+                peer.write_all(b"tail").await.unwrap();
+                peer.shutdown().await.unwrap();
+                let mut tail = Vec::new();
+                stream.read_to_end(&mut tail).await.unwrap();
+                assert_eq!(tail, b"tail");
+                assert_eq!(active.load(Ordering::Acquire), 1);
+            } else {
+                assert_eq!(stream.read(&mut [0; 4]).await.unwrap(), 0);
+            }
+            drop(stream);
+            assert_eq!(active.load(Ordering::Acquire), 0);
+        }
+    }
+
     #[tokio::test(start_paused = true)]
     async fn lazy_status_obeys_setup_deadline_but_established_reads_do_not() {
         for timing in ["late-first-poll", "late-after-pending", "established"] {
@@ -338,7 +525,11 @@ mod tests {
                 raw: Some(Box::new(raw)),
                 lease: None,
                 response: false,
-                deadline: Box::pin(tokio::time::sleep(std::time::Duration::from_secs(1))),
+                half_close: true,
+                upload_closed: false,
+                deadline: Some(Box::pin(tokio::time::sleep(
+                    std::time::Duration::from_secs(1),
+                ))),
             };
             if timing == "late-after-pending" {
                 assert!(futures_util::poll!(std::pin::pin!(stream.read_u8())).is_pending());
@@ -361,12 +552,339 @@ mod tests {
                     io::ErrorKind::TimedOut,
                     "{timing}"
                 );
-                // A late response cannot revive a stream after a timeout.
+                // Timeout closes the supplied IO and lease; late writes or
+                // already-buffered status cannot revive this logical stream.
+                assert!(stream.raw.is_none());
+                assert!(stream.lease.is_none());
+                assert!(stream.write(b"late").await.is_err());
+                assert_eq!(stream.read(&mut [0]).await.unwrap(), 0);
+            }
+        }
+    }
+    fn pending_status(raw: BoxStream, deadline: Instant) -> ResponseStream {
+        ResponseStream {
+            raw: Some(raw),
+            lease: None,
+            response: false,
+            half_close: true,
+            upload_closed: false,
+            deadline: Some(Box::pin(tokio::time::sleep_until(deadline))),
+        }
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn h2mux_unread_siblings_do_not_block_a_short_response() {
+        use crate::transport::h2_write::{Payload, Writes};
+        use std::time::Duration;
+
+        let (raw, peer) = tokio::io::duplex(65536);
+        let (peer, writes) = Writes::wrap(Box::new(peer));
+        let (accepted, mut requests) = tokio::sync::mpsc::channel(1);
+        let peer_driver = tokio::spawn(async move {
+            let mut connection = h2::server::Builder::new()
+                .handshake::<_, Payload>(peer)
+                .await
+                .unwrap();
+            while let Some(Ok(request)) = connection.accept().await {
+                if accepted.send(request).await.is_err() {
+                    break;
+                }
+            }
+        });
+        let (sender, driver) = h2_driver::new(Box::new(raw)).await.unwrap();
+        let client_driver = tokio::spawn(driver);
+        let sender = Sender::H2(sender);
+        let deadline = Instant::now() + Duration::from_secs(5);
+        let mut streams = Vec::new();
+        let mut peer_streams = Vec::new();
+        let mut short_receipt = None;
+
+        for index in 0..3 {
+            let mut raw = sender.open(deadline, false).await.unwrap();
+            let metadata = [0, if index == 2 { 3 } else { 0 }, 1, 192, 0, 2, 1, 1, 187];
+            raw.write_all(&metadata).await.unwrap();
+            raw.flush().await.unwrap();
+            let (request, mut response) = requests.recv().await.unwrap();
+            let mut input = request.into_body();
+            let first = input.data().await.unwrap().unwrap();
+            assert_eq!(first.as_ref(), metadata);
+            input.flow_control().release_capacity(first.len()).unwrap();
+            let mut output = response
+                .send_response(http::Response::new(()), false)
+                .unwrap();
+            let body = if index == 2 {
+                Bytes::from_static(&[0, 42])
+            } else {
+                let mut body = vec![b'a' + index; 65536];
+                body[0] = 0;
+                Bytes::from(body)
+            };
+            let (payload, receipt) = writes.payload(body);
+            output.send_data(payload, false).unwrap();
+            if index < 2 {
+                // The held streams consume actual connection credit before
+                // opening the short stream; enqueueing DATA alone is no proof.
+                tokio::time::timeout(Duration::from_secs(1), receipt)
+                    .await
+                    .unwrap()
+                    .unwrap()
+                    .unwrap();
+            } else {
+                short_receipt = Some(receipt);
+            }
+            streams.push(pending_status(raw, deadline));
+            peer_streams.push((input, output));
+        }
+
+        let mut short = streams.pop().unwrap();
+        let short_response =
+            tokio::time::timeout(Duration::from_millis(100), short.read_u8()).await;
+        // Neither held sibling has been read or dropped at this point. The
+        // short stream must make progress without borrowing their credit.
+        for (index, stream) in streams.iter_mut().enumerate() {
+            let mut payload = vec![0; 65535];
+            tokio::time::timeout(Duration::from_secs(1), stream.read_exact(&mut payload))
+                .await
+                .unwrap()
+                .unwrap();
+            assert!(payload.iter().all(|byte| *byte == b'a' + index as u8));
+        }
+        tokio::time::timeout(Duration::from_secs(1), short_receipt.unwrap())
+            .await
+            .unwrap()
+            .unwrap()
+            .unwrap();
+        drop(short);
+        drop(streams);
+        drop(peer_streams);
+        client_driver.abort();
+        let _ = client_driver.await;
+        peer_driver.abort();
+        let _ = peer_driver.await;
+        assert!(
+            matches!(short_response, Ok(Ok(42))),
+            "unread siblings blocked the short response: {short_response:?}"
+        );
+    }
+
+    enum NoBusinessWrite {
+        Pending,
+        Zero,
+        Error,
+    }
+    impl AsyncRead for NoBusinessWrite {
+        fn poll_read(
+            self: Pin<&mut Self>,
+            _: &mut Context<'_>,
+            _: &mut ReadBuf<'_>,
+        ) -> Poll<io::Result<()>> {
+            Poll::Pending
+        }
+    }
+    impl AsyncWrite for NoBusinessWrite {
+        fn poll_write(
+            self: Pin<&mut Self>,
+            _: &mut Context<'_>,
+            _: &[u8],
+        ) -> Poll<io::Result<usize>> {
+            match self.get_mut() {
+                Self::Pending => Poll::Pending,
+                Self::Zero => Poll::Ready(Ok(0)),
+                Self::Error => Poll::Ready(Err(io::ErrorKind::ConnectionReset.into())),
+            }
+        }
+        fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Poll::Ready(Ok(()))
+        }
+        fn poll_shutdown(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Poll::Ready(Ok(()))
+        }
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn empty_pending_and_error_writes_do_not_release_setup_deadline() {
+        for raw in [
+            NoBusinessWrite::Pending,
+            NoBusinessWrite::Zero,
+            NoBusinessWrite::Error,
+        ] {
+            let mut stream = pending_status(
+                Box::new(raw),
+                Instant::now() + std::time::Duration::from_secs(1),
+            );
+            let _ = futures_util::poll!(std::pin::pin!(stream.write(b"payload")));
+            assert!(stream.deadline.is_some());
+            tokio::time::advance(std::time::Duration::from_secs(2)).await;
+            assert_eq!(
+                stream.write(b"late").await.unwrap_err().kind(),
+                io::ErrorKind::TimedOut
+            );
+            assert!(stream.raw.is_none());
+        }
+        for operation in ["empty-write", "flush", "shutdown"] {
+            let (raw, _peer) = tokio::io::duplex(16);
+            let mut stream = pending_status(
+                Box::new(raw),
+                Instant::now() + std::time::Duration::from_secs(1),
+            );
+            match operation {
+                "empty-write" => assert_eq!(stream.write(&[]).await.unwrap(), 0),
+                "flush" => stream.flush().await.unwrap(),
+                "shutdown" => stream.shutdown().await.unwrap(),
+                _ => unreachable!(),
+            }
+            assert!(stream.deadline.is_some(), "{operation}");
+            assert_eq!(stream.read(&mut []).await.unwrap(), 0);
+            tokio::time::advance(std::time::Duration::from_secs(2)).await;
+            assert_eq!(
+                stream.read_u8().await.unwrap_err().kind(),
+                io::ErrorKind::TimedOut
+            );
+            assert!(stream.raw.is_none());
+        }
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn h2mux_upload_outlives_delayed_headers_and_validates_late_status() {
+        for status in [Some(0), Some(1), Some(2), None] {
+            let (raw, peer) = tokio::io::duplex(65536);
+            let (accepted, mut requests) = tokio::sync::mpsc::channel(1);
+            let peer_driver = tokio::spawn(async move {
+                let mut connection = h2::server::handshake(peer).await.unwrap();
+                while let Some(Ok(request)) = connection.accept().await {
+                    if accepted.send(request).await.is_err() {
+                        break;
+                    }
+                }
+            });
+            let (sender, driver) = h2_driver::new(Box::new(raw)).await.unwrap();
+            let client_driver = tokio::spawn(driver);
+            let deadline = Instant::now() + std::time::Duration::from_secs(10);
+            let mut raw = Sender::H2(sender).open(deadline, false).await.unwrap();
+            let metadata = [0, 0, 1, 192, 0, 2, 1, 1, 187];
+            raw.write_all(&metadata).await.unwrap();
+            raw.flush().await.unwrap();
+            let (request, mut response) = requests.recv().await.unwrap();
+            let mut input = request.into_body();
+            let first = input.data().await.unwrap().unwrap();
+            assert_eq!(first.as_ref(), metadata);
+            input.flow_control().release_capacity(first.len()).unwrap();
+            let mut stream = pending_status(raw, deadline);
+            assert!(futures_util::poll!(std::pin::pin!(stream.read_u8())).is_pending());
+            stream.write_all(b"before").await.unwrap();
+            stream.flush().await.unwrap();
+            let first = input.data().await.unwrap().unwrap();
+            assert_eq!(first.as_ref(), b"before");
+            input.flow_control().release_capacity(first.len()).unwrap();
+            assert!(stream.deadline.is_none());
+
+            tokio::time::advance(std::time::Duration::from_secs(11)).await;
+            assert!(futures_util::poll!(std::pin::pin!(stream.read_u8())).is_pending());
+            stream.write_all(b"after").await.unwrap();
+            stream.flush().await.unwrap();
+            let second = input.data().await.unwrap().unwrap();
+            assert_eq!(second.as_ref(), b"after");
+            input.flow_control().release_capacity(second.len()).unwrap();
+            let mut output = response
+                .send_response(http::Response::new(()), false)
+                .unwrap();
+            match status {
+                Some(status) => output
+                    .send_data(Bytes::copy_from_slice(&[status, 42]), false)
+                    .unwrap(),
+                None => output.send_data(Bytes::new(), true).unwrap(),
+            }
+            if status == Some(0) {
+                assert_eq!(stream.read_u8().await.unwrap(), 42);
+                stream.shutdown().await.unwrap();
+                while let Some(bytes) = input.data().await {
+                    assert!(
+                        bytes.unwrap().is_empty(),
+                        "upload FIN must carry no extra payload"
+                    );
+                }
+                output.send_data(Bytes::from_static(b"tail"), true).unwrap();
+                let mut tail = Vec::new();
+                stream.read_to_end(&mut tail).await.unwrap();
+                assert_eq!(tail, b"tail");
+            } else {
                 assert_eq!(
                     stream.read_u8().await.unwrap_err().kind(),
-                    io::ErrorKind::TimedOut
+                    io::ErrorKind::ConnectionRefused
                 );
+                assert!(stream.raw.is_none());
             }
+            drop(stream);
+            drop(input);
+            drop(output);
+            client_driver.abort();
+            let _ = client_driver.await;
+            peer_driver.abort();
+            let _ = peer_driver.await;
         }
     }
+
+    #[cfg(feature = "outbound-vless")]
+    #[tokio::test(start_paused = true)]
+    async fn brutal_control_reply_still_uses_the_original_setup_deadline() {
+        let (raw, mut peer) = tokio::io::duplex(65536);
+        let observed = Arc::new(std::sync::atomic::AtomicBool::new(false));
+        let peer_observed = observed.clone();
+        let peer_driver = tokio::spawn(async move {
+            let mut protocol = [0; 2];
+            peer.read_exact(&mut protocol).await.unwrap();
+            assert_eq!(protocol, [0, 2]);
+            let mut connection = h2::server::handshake(peer).await.unwrap();
+            let mut requests = tokio::task::JoinSet::new();
+            while let Some(Ok((request, response))) = connection.accept().await {
+                let observed = peer_observed.clone();
+                requests.spawn(async move {
+                    let mut input = request.into_body();
+                    while let Some(Ok(bytes)) = input.data().await {
+                        observed.store(true, Ordering::SeqCst);
+                        input.flow_control().release_capacity(bytes.len()).unwrap();
+                    }
+                    drop(response);
+                });
+            }
+            while let Some(result) = requests.join_next().await {
+                result.unwrap();
+            }
+        });
+        let config = crate::config::Config::parse_yaml(
+            br#"proxies:
+- name: edge
+  type: vless
+  server: example.test
+  port: 443
+  uuid: 07070707-0707-0707-0707-070707070707
+  smux: {enabled: true, brutal-opts: {enabled: true, up: 8, down: 8}}
+rules: ['MATCH,DIRECT']
+"#,
+        )
+        .unwrap();
+        let pool = Pool::new(config.proxies[0].smux.clone().unwrap());
+        let start = Instant::now();
+        let result = pool
+            .open(
+                &Destination::Ip("192.0.2.1:443".parse().unwrap()),
+                false,
+                start + std::time::Duration::from_secs(1),
+                || async move {
+                    Ok(SuppliedStream {
+                        io: Box::new(raw),
+                        #[cfg(target_os = "linux")]
+                        control: None,
+                        #[cfg(feature = "outbound-vless")]
+                        h3_udp: None,
+                    })
+                },
+            )
+            .await;
+        assert_eq!(result.err().unwrap().kind(), io::ErrorKind::TimedOut);
+        assert_eq!(Instant::now() - start, std::time::Duration::from_secs(1));
+        assert!(observed.load(Ordering::SeqCst));
+        pool.stop().await;
+        peer_driver.await.unwrap();
+    }
 }
diff --git a/src/transport/sing_mux/brutal.rs b/src/transport/sing_mux/brutal.rs
new file mode 100644
index 0000000..8484fb6
--- /dev/null
+++ b/src/transport/sing_mux/brutal.rs
@@ -0,0 +1,122 @@
+//! Mihomo sing-mux's one control exchange, before business admission.
+use crate::dispatch::BoxStream;
+use std::io;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+const DOMAIN: &[u8] = b"_BrutalBwExchange";
+const MAX_ERROR_BYTES: u64 = 256;
+
+pub(super) async fn exchange(io: &mut BoxStream, up: u64, down: u64) -> io::Result<u64> {
+    exchange_inner(io, up, down)
+        .await
+        .map_err(|error| io::Error::new(error.kind(), "sing-mux Brutal negotiation failed"))
+}
+
+async fn exchange_inner(io: &mut BoxStream, up: u64, down: u64) -> io::Result<u64> {
+    // This reserved target has port zero; it is protocol control, never a
+    // routable business Destination or a request for the local DNS resolver.
+    let mut request = [0_u8; 2 + 2 + DOMAIN.len() + 2 + 8];
+    request[2] = crate::socks5::ADDRESS_DOMAIN;
+    request[3] = DOMAIN.len() as u8;
+    request[4..4 + DOMAIN.len()].copy_from_slice(DOMAIN);
+    request[6 + DOMAIN.len()..].copy_from_slice(&down.to_be_bytes());
+    io.write_all(&request).await?;
+    io.flush().await?;
+    match io.read_u8().await? {
+        0 => {}
+        1 => {
+            discard_error(io).await?;
+            return Err(io::ErrorKind::ConnectionRefused.into());
+        }
+        _ => return Err(io::ErrorKind::InvalidData.into()),
+    }
+    match io.read_u8().await? {
+        1 => Ok(up.min(io.read_u64().await?)),
+        0 => {
+            discard_error(io).await?;
+            Err(io::ErrorKind::ConnectionRefused.into())
+        }
+        _ => Err(io::ErrorKind::InvalidData.into()),
+    }
+}
+
+async fn discard_error(io: &mut BoxStream) -> io::Result<()> {
+    let mut length = 0_u64;
+    for shift in (0..70).step_by(7) {
+        let byte = io.read_u8().await?;
+        if shift == 63 && byte > 1 {
+            return Err(io::ErrorKind::InvalidData.into());
+        }
+        length |= u64::from(byte & 0x7f) << shift;
+        if length > MAX_ERROR_BYTES {
+            return Err(io::ErrorKind::InvalidData.into());
+        }
+        if byte & 0x80 == 0 {
+            let mut message = [0; MAX_ERROR_BYTES as usize];
+            io.read_exact(&mut message[..length as usize]).await?;
+            return Ok(());
+        }
+    }
+    Err(io::ErrorKind::InvalidData.into())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn brutal_exchange_handles_fragmented_reply_and_padding() {
+        for padding in [false, true] {
+            let (client, server) = tokio::io::duplex(4096);
+            let mut client: BoxStream = Box::new(client);
+            let mut server: BoxStream = Box::new(server);
+            if padding {
+                client = Box::new(super::super::padding::Padding::new(client));
+                server = Box::new(super::super::padding::Padding::new(server));
+            }
+            let peer = async {
+                let mut request = [0; 31];
+                server.read_exact(&mut request).await.unwrap();
+                assert_eq!(&request[..4], &[0, 0, 3, 17]);
+                assert_eq!(&request[4..21], DOMAIN);
+                assert_eq!(&request[21..23], &[0, 0]);
+                assert_eq!(
+                    u64::from_be_bytes(request[23..].try_into().unwrap()),
+                    900_000
+                );
+                for byte in [0, 1].into_iter().chain(700_000_u64.to_be_bytes()) {
+                    server.write_all(&[byte]).await.unwrap();
+                    server.flush().await.unwrap();
+                    tokio::task::yield_now().await;
+                }
+            };
+            let (rate, ()) = tokio::join!(exchange(&mut client, 800_000, 900_000), peer);
+            assert_eq!(rate.unwrap(), 700_000);
+        }
+    }
+
+    #[tokio::test]
+    async fn brutal_rejects_bounded_errors_truncation_and_invalid_status() {
+        for response in [
+            b"\x00\x00\x06secret".as_slice(),
+            b"\x01\x06secret",
+            b"\x00\x00\x81\x02", // 257-byte error declaration.
+            b"\x00\x00\x80\x80\x80\x80\x80\x80\x80\x80\x80\x02",
+            b"\x00\x01\x00", // Truncated negotiated rate.
+            b"\x00\x02",     // Non-boolean success.
+        ] {
+            let (client, mut server) = tokio::io::duplex(64);
+            let mut client: BoxStream = Box::new(client);
+            let peer = async {
+                server.read_exact(&mut [0; 31]).await.unwrap();
+                server.write_all(response).await.unwrap();
+                server.shutdown().await.unwrap();
+            };
+            let (result, ()) = tokio::join!(exchange(&mut client, 1, 1), peer);
+            assert_eq!(
+                result.unwrap_err().to_string(),
+                "sing-mux Brutal negotiation failed"
+            );
+        }
+    }
+}
diff --git a/src/transport/sing_mux/datagram.rs b/src/transport/sing_mux/datagram.rs
index aa456de..1eea11a 100644
--- a/src/transport/sing_mux/datagram.rs
+++ b/src/transport/sing_mux/datagram.rs
@@ -1,5 +1,5 @@
-//! Address-per-packet sing-mux UDP. Partial reads survive cancellation; a
-//! partially sent frame poisons this logical stream, never its siblings.
+//! Address-per-packet sing-mux UDP. Partial reads and one pending write survive
+//! cancellation so literal destinations can share one source-owned wire.
 use crate::{
     dispatch::{BoxStream, DatagramBudget, DatagramTransport, DispatchError},
     dns::resolution::ResolutionContext,
@@ -21,8 +21,14 @@ pub(crate) struct DatagramIo {
     resolution: ResolutionContext,
     deadline: Instant,
     first: bool,
+    flush_each_frame: bool,
+    pending_write: Option<PendingWrite>,
     cancel: CancellationToken,
 }
+struct PendingWrite {
+    wire: Vec<u8>,
+    offset: usize,
+}
 impl DatagramIo {
     pub(crate) fn new(
         io: BoxStream,
@@ -38,21 +44,72 @@ impl DatagramIo {
             resolution,
             deadline,
             first: true,
+            flush_each_frame: true,
+            pending_write: None,
             cancel,
         }
     }
+    pub(crate) fn with_autonomous_writes(mut self) -> Self {
+        self.flush_each_frame = false;
+        self
+    }
+
+    // A cancelled logical target may already have submitted a frame prefix.
+    // Finish exactly that retained frame before the next send or receive;
+    // never duplicate bytes or add a per-target payload queue.
+    async fn flush_pending(&mut self) -> io::Result<()> {
+        if self.pending_write.is_none() {
+            return Ok(());
+        }
+        if self.first && Instant::now() >= self.deadline {
+            return Err(io::ErrorKind::TimedOut.into());
+        }
+        let first = self.first;
+        let flush = first || self.flush_each_frame;
+        let deadline = self.deadline;
+        let cancel = self.cancel.clone();
+        let write = async {
+            let pending = self.pending_write.as_mut().expect("pending sing-mux frame");
+            let io = self.io.as_mut().ok_or(io::ErrorKind::BrokenPipe)?;
+            while pending.offset < pending.wire.len() {
+                let written = io.write(&pending.wire[pending.offset..]).await?;
+                if written == 0 {
+                    return Err(io::Error::from(io::ErrorKind::WriteZero));
+                }
+                pending.offset += written;
+            }
+            if flush {
+                io.flush().await?;
+            }
+            Ok(())
+        };
+        tokio::select! { biased;
+            ()=cancel.cancelled()=>return Err(io::ErrorKind::ConnectionAborted.into()),
+            result=async {
+                if first {
+                    tokio::time::timeout_at(deadline, write)
+                        .await.map_err(|_| io::ErrorKind::TimedOut)?
+                } else {
+                    write.await
+                }
+            }=>result?,
+        }
+        self.first = false;
+        self.pending_write = None;
+        Ok(())
+    }
     async fn fill(&mut self, length: usize) -> io::Result<()> {
         if length > u16::MAX as usize + 261 {
             return Err(io::ErrorKind::InvalidData.into());
         }
         let mut scratch = [0; 1024];
+        // Bounded read-ahead amortizes short address and length reads.
         while self.input.len() < length {
-            let count = (length - self.input.len()).min(scratch.len());
             let n = self
                 .io
                 .as_mut()
                 .ok_or(io::ErrorKind::BrokenPipe)?
-                .read(&mut scratch[..count])
+                .read(&mut scratch)
                 .await?;
             if n == 0 {
                 return Err(io::ErrorKind::UnexpectedEof.into());
@@ -78,8 +135,13 @@ impl DatagramIo {
         if length == 0 {
             return Err(io::ErrorKind::InvalidData.into());
         }
-        self.fill(address_len + 2 + length).await?;
-        let payload = self.input.split().freeze().slice(address_len + 2..);
+        let frame_len = address_len + 2 + length;
+        self.fill(frame_len).await?;
+        let payload = self
+            .input
+            .split_to(frame_len)
+            .freeze()
+            .slice(address_len + 2..);
         Ok(Datagram {
             remote,
             payload,
@@ -89,6 +151,9 @@ impl DatagramIo {
 }
 #[async_trait]
 impl DatagramTransport for DatagramIo {
+    fn supports_shared_destinations(&self) -> bool {
+        true
+    }
     fn payload_budget(&self, _: &Destination) -> DatagramBudget {
         self.budget
     }
@@ -99,40 +164,39 @@ impl DatagramTransport for DatagramIo {
         {
             return Err(io::Error::from(io::ErrorKind::InvalidInput).into());
         }
-        let deadline = if self.first {
-            self.deadline
-        } else {
-            Instant::now() + crate::outbound::DEFAULT_ESTABLISH_TIMEOUT
-        };
-        let peer = tokio::select! { biased;
-            ()=self.cancel.cancelled()=>return Err(DispatchError::NotAllowed),
-            peer=self.resolution.resolve_ip(&packet.remote,deadline)=>peer?,
-        };
-        let mut wire = Vec::with_capacity(packet.payload.len() + 21);
-        crate::socks5::encode_address(&peer.into(), &mut wire)?;
-        wire.extend_from_slice(&(packet.payload.len() as u16).to_be_bytes());
-        wire.extend_from_slice(&packet.payload);
-        let mut io = self
-            .io
-            .take()
-            .ok_or_else(|| io::Error::from(io::ErrorKind::BrokenPipe))?;
-        tokio::select! { biased;
-            ()=self.cancel.cancelled()=>return Err(DispatchError::NotAllowed),
-            result=async {
-                let write=async {io.write_all(&wire).await?;io.flush().await};
-                if self.first {tokio::time::timeout_at(deadline,write).await.map_err(|_|io::ErrorKind::TimedOut)?} else {write.await}
-            }=>result?,
+        if self.io.is_none() {
+            return Err(io::Error::from(io::ErrorKind::BrokenPipe).into());
         }
-        self.first = false;
-        self.io = Some(io);
-        Ok(())
+        let result = async {
+            self.flush_pending().await?;
+            let deadline = if self.first {
+                self.deadline
+            } else {
+                Instant::now() + crate::outbound::DEFAULT_ESTABLISH_TIMEOUT
+            };
+            let peer = tokio::select! { biased;
+                ()=self.cancel.cancelled()=>return Err(DispatchError::NotAllowed),
+                peer=self.resolution.resolve_ip(&packet.remote,deadline)=>peer?,
+            };
+            let mut wire = Vec::with_capacity(packet.payload.len() + 21);
+            crate::socks5::encode_address(&peer.into(), &mut wire)?;
+            wire.extend_from_slice(&(packet.payload.len() as u16).to_be_bytes());
+            wire.extend_from_slice(&packet.payload);
+            self.pending_write = Some(PendingWrite { wire, offset: 0 });
+            self.flush_pending().await.map_err(DispatchError::from)
+        }
+        .await;
+        if result.is_err() {
+            self.close().await?;
+        }
+        result
     }
     async fn receive(&mut self) -> Result<Datagram, DispatchError> {
         let cancel = self.cancel.clone();
         for count in 0_usize.. {
             let result = tokio::select! {biased;
                 ()=cancel.cancelled()=>Err(io::ErrorKind::ConnectionAborted.into()),
-                result=self.next()=>result,
+                result=async {self.flush_pending().await?;self.next().await}=>result,
             };
             match result {
                 Ok(packet) if packet.payload.len() <= self.budget.receive() as usize => {
@@ -152,7 +216,324 @@ impl DatagramTransport for DatagramIo {
     }
     async fn close(&mut self) -> Result<(), DispatchError> {
         self.io.take();
+        self.pending_write = None;
         self.input.clear();
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use bytes::Bytes;
+    use std::{
+        pin::Pin,
+        sync::{
+            Arc,
+            atomic::{AtomicBool, AtomicUsize, Ordering},
+        },
+        task::{Context, Poll},
+        time::Duration,
+    };
+    use tokio::io::{AsyncRead, AsyncWrite, DuplexStream, ReadBuf};
+
+    #[derive(Clone)]
+    struct Gates {
+        write_bytes: Arc<AtomicUsize>,
+        flush_blocked: Arc<AtomicBool>,
+        read_calls: Arc<AtomicUsize>,
+    }
+    impl Gates {
+        fn release(&self) {
+            self.write_bytes.store(usize::MAX, Ordering::SeqCst);
+            self.flush_blocked.store(false, Ordering::SeqCst);
+        }
+    }
+    struct GatedIo {
+        raw: DuplexStream,
+        gates: Gates,
+    }
+    impl AsyncRead for GatedIo {
+        fn poll_read(
+            mut self: Pin<&mut Self>,
+            cx: &mut Context<'_>,
+            out: &mut ReadBuf<'_>,
+        ) -> Poll<io::Result<()>> {
+            self.gates.read_calls.fetch_add(1, Ordering::SeqCst);
+            Pin::new(&mut self.raw).poll_read(cx, out)
+        }
+    }
+    impl AsyncWrite for GatedIo {
+        fn poll_write(
+            mut self: Pin<&mut Self>,
+            cx: &mut Context<'_>,
+            input: &[u8],
+        ) -> Poll<io::Result<usize>> {
+            let count = self
+                .gates
+                .write_bytes
+                .load(Ordering::SeqCst)
+                .min(input.len());
+            if count == 0 {
+                return Poll::Pending;
+            }
+            let written =
+                std::task::ready!(Pin::new(&mut self.raw).poll_write(cx, &input[..count]))?;
+            self.gates.write_bytes.fetch_sub(written, Ordering::SeqCst);
+            Poll::Ready(Ok(written))
+        }
+        fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            if self.gates.flush_blocked.load(Ordering::SeqCst) {
+                Poll::Pending
+            } else {
+                Pin::new(&mut self.raw).poll_flush(cx)
+            }
+        }
+        fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Pin::new(&mut self.raw).poll_shutdown(cx)
+        }
+    }
+    fn fixture(partial_write: bool) -> (DatagramIo, DuplexStream, Gates) {
+        let (raw, peer) = tokio::io::duplex(4096);
+        let gates = Gates {
+            write_bytes: Arc::new(AtomicUsize::new(if partial_write { 3 } else { usize::MAX })),
+            flush_blocked: Arc::new(AtomicBool::new(!partial_write)),
+            read_calls: Arc::new(AtomicUsize::new(0)),
+        };
+        (
+            DatagramIo::new(
+                Box::new(GatedIo {
+                    raw,
+                    gates: gates.clone(),
+                }),
+                DatagramBudget::new(1452, 1452),
+                ResolutionContext::default(),
+                Instant::now() + Duration::from_secs(5),
+                CancellationToken::new(),
+            ),
+            peer,
+            gates,
+        )
+    }
+    fn packet(remote: &str, payload: &'static [u8]) -> Datagram {
+        Datagram {
+            remote: remote.parse::<std::net::SocketAddr>().unwrap().into(),
+            payload: Bytes::from_static(payload),
+            sniffed_domain: None,
+        }
+    }
+    fn wire(packet: &Datagram) -> Vec<u8> {
+        let mut bytes = Vec::new();
+        crate::socks5::encode_address(&packet.remote, &mut bytes).unwrap();
+        bytes.extend_from_slice(&(packet.payload.len() as u16).to_be_bytes());
+        bytes.extend_from_slice(&packet.payload);
+        bytes
+    }
+
+    #[tokio::test]
+    async fn autonomous_udp_preserves_first_setup_flush_and_skips_only_later_barriers() {
+        for autonomous in [false, true] {
+            let (transport, mut peer, gates) = fixture(false);
+            let mut transport = if autonomous {
+                transport.with_autonomous_writes()
+            } else {
+                transport
+            };
+            let first = packet("192.0.2.1:53", b"first");
+            let second = packet("198.51.100.1:54", b"second");
+            assert!(futures_util::poll!(transport.send(first.clone())).is_pending());
+            assert!(
+                transport.first,
+                "the first frame still owns its setup flush"
+            );
+            assert_eq!(
+                transport.pending_write.as_ref().unwrap().offset,
+                wire(&first).len()
+            );
+            gates.release();
+            transport.flush_pending().await.unwrap();
+            gates.flush_blocked.store(true, Ordering::SeqCst);
+            let result = futures_util::poll!(transport.send(second.clone()));
+            assert_eq!(result.is_ready(), autonomous);
+            if autonomous {
+                assert!(matches!(result, Poll::Ready(Ok(()))));
+                assert!(transport.pending_write.is_none());
+            } else {
+                assert!(transport.pending_write.is_some());
+            }
+            gates.release();
+            transport.flush_pending().await.unwrap();
+            let mut expected = wire(&first);
+            expected.extend(wire(&second));
+            let mut actual = vec![0; expected.len()];
+            peer.read_exact(&mut actual).await.unwrap();
+            assert_eq!(actual, expected);
+        }
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn autonomous_first_flush_keeps_original_deadline_after_cancellation() {
+        let (transport, mut peer, gates) = fixture(false);
+        let mut transport = transport.with_autonomous_writes();
+        let first = packet("192.0.2.1:53", b"first");
+        let second = packet("198.51.100.1:54", b"second");
+        assert!(futures_util::poll!(transport.send(first.clone())).is_pending());
+        tokio::time::advance(Duration::from_secs(6)).await;
+        gates.release();
+        assert!(matches!(
+            transport.send(second).await,
+            Err(DispatchError::TimedOut)
+        ));
+        assert!(transport.io.is_none() && transport.pending_write.is_none());
+        let mut actual = Vec::new();
+        peer.read_to_end(&mut actual).await.unwrap();
+        assert_eq!(
+            actual,
+            wire(&first),
+            "deadline must not admit another frame"
+        );
+    }
+
+    #[tokio::test]
+    async fn cancelled_partial_write_and_flush_resume_before_send_or_receive() {
+        for partial_write in [true, false] {
+            for resume_receive in [true, false] {
+                let (mut transport, mut peer, gates) = fixture(partial_write);
+                assert!(transport.supports_shared_destinations());
+                let first = packet("192.0.2.1:53", b"first");
+                let second = packet("198.51.100.1:54", b"second");
+                assert!(futures_util::poll!(transport.send(first.clone())).is_pending());
+                let pending = transport.pending_write.as_ref().unwrap();
+                assert_eq!(
+                    pending.offset,
+                    if partial_write { 3 } else { wire(&first).len() }
+                );
+                assert_eq!(pending.wire, wire(&first));
+                assert!(
+                    transport.io.is_some(),
+                    "cancel must retain the physical IO owner"
+                );
+                gates.release();
+                let mut expected = wire(&first);
+                if resume_receive {
+                    peer.write_all(&wire(&second)).await.unwrap();
+                    let response = transport.receive().await.unwrap();
+                    assert_eq!(response.remote, second.remote);
+                    assert_eq!(response.payload, second.payload);
+                } else {
+                    transport.send(second.clone()).await.unwrap();
+                    expected.extend_from_slice(&wire(&second));
+                }
+                assert!(transport.pending_write.is_none());
+                let mut actual = vec![0; expected.len()];
+                peer.read_exact(&mut actual).await.unwrap();
+                assert_eq!(
+                    actual, expected,
+                    "cancelled prefixes must not be duplicated"
+                );
+                transport.close().await.unwrap();
+                assert_eq!(peer.read(&mut [0; 1]).await.unwrap(), 0);
+            }
+        }
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn cancelled_first_frame_keeps_its_deadline_but_established_frames_do_not() {
+        let first = packet("192.0.2.1:53", b"first");
+        let second = packet("198.51.100.1:54", b"second");
+        let (mut transport, mut peer, gates) = fixture(true);
+        assert!(futures_util::poll!(transport.send(first.clone())).is_pending());
+        tokio::time::advance(Duration::from_secs(6)).await;
+        gates.release();
+        assert!(matches!(
+            transport.send(second.clone()).await,
+            Err(DispatchError::TimedOut)
+        ));
+        assert!(transport.io.is_none());
+        assert!(transport.pending_write.is_none());
+        let mut actual = Vec::new();
+        peer.read_to_end(&mut actual).await.unwrap();
+        assert_eq!(actual, wire(&first)[..3]);
+
+        let (mut established, mut peer, gates) = fixture(false);
+        gates.release();
+        established.send(first.clone()).await.unwrap();
+        tokio::time::advance(Duration::from_secs(6)).await;
+        established.send(second.clone()).await.unwrap();
+        let mut expected = wire(&first);
+        expected.extend_from_slice(&wire(&second));
+        let mut actual = vec![0; expected.len()];
+        peer.read_exact(&mut actual).await.unwrap();
+        assert_eq!(actual, expected);
+        established.close().await.unwrap();
+    }
+
+    #[tokio::test]
+    async fn close_and_stop_discard_a_pending_frame_without_more_io() {
+        for stop in [false, true] {
+            let (mut transport, mut peer, _gates) = fixture(true);
+            let first = packet("192.0.2.1:53", b"first");
+            assert!(futures_util::poll!(transport.send(first.clone())).is_pending());
+            if stop {
+                transport.cancel.cancel();
+                assert!(transport.receive().await.is_err());
+            } else {
+                transport.close().await.unwrap();
+            }
+            transport.close().await.unwrap();
+            assert!(transport.io.is_none());
+            assert!(transport.pending_write.is_none());
+            let mut actual = Vec::new();
+            peer.read_to_end(&mut actual).await.unwrap();
+            assert_eq!(actual, wire(&first)[..3]);
+            assert!(transport.send(first).await.is_err());
+        }
+    }
+
+    #[tokio::test]
+    async fn scratch_read_ahead_amortizes_reads_and_keeps_cancelled_record_ownership() {
+        // Independent literal wire: IPv4 address, port, u16 length, payload.
+        let mut bytes = vec![1, 192, 0, 2, 1, 0, 53, 3, 232];
+        bytes.extend_from_slice(&[0x51; 1000]);
+        let first_length = bytes.len();
+        bytes.extend_from_slice(&[1, 198, 51, 100, 2, 0, 54, 0, 3, b'e', b'n', b'd']);
+        for cut in [0, 1, 8, 13, 1008] {
+            let (mut transport, mut peer, gates) = fixture(false);
+            if cut != 0 {
+                peer.write_all(&bytes[..cut]).await.unwrap();
+                {
+                    let mut receiving = transport.receive();
+                    assert!(futures_util::poll!(receiving.as_mut()).is_pending());
+                }
+                assert_eq!(transport.input.as_ref(), &bytes[..cut]);
+            }
+            peer.write_all(&bytes[cut..]).await.unwrap();
+            let before = gates.read_calls.load(Ordering::SeqCst);
+            let first = transport.receive().await.unwrap();
+            assert_eq!(
+                first.remote,
+                Destination::Ip("192.0.2.1:53".parse().unwrap())
+            );
+            assert_eq!(first.payload.as_ref(), &[0x51; 1000]);
+            assert_eq!(
+                gates.read_calls.load(Ordering::SeqCst) - before,
+                1,
+                "one available scratch read must cover the remaining first record and sibling"
+            );
+            assert_eq!(transport.input.as_ref(), &bytes[first_length..]);
+            let before_sibling = gates.read_calls.load(Ordering::SeqCst);
+            let sibling = transport.receive().await.unwrap();
+            assert_eq!(
+                sibling.remote,
+                Destination::Ip("198.51.100.2:54".parse().unwrap())
+            );
+            assert_eq!(sibling.payload.as_ref(), b"end");
+            assert_eq!(gates.read_calls.load(Ordering::SeqCst), before_sibling);
+            assert!(transport.input.is_empty());
+            // Keep the first payload live while consuming its shared sibling tail.
+            assert_eq!(first.payload.as_ref(), &[0x51; 1000]);
+            transport.close().await.unwrap();
+            assert_eq!(peer.read(&mut [0; 1]).await.unwrap(), 0);
+        }
+    }
+}
diff --git a/src/transport/sing_mux/h2_driver.rs b/src/transport/sing_mux/h2_driver.rs
index 5cd126c..ae90512 100644
--- a/src/transport/sing_mux/h2_driver.rs
+++ b/src/transport/sing_mux/h2_driver.rs
@@ -9,7 +9,9 @@ pub(super) async fn new(raw: BoxStream) -> io::Result<(Sender, impl Future<Outpu
     let (sender, mut connection) = h2::client::Builder::new()
         .enable_push(false)
         .initial_window_size(65536)
-        .initial_connection_window_size(131072)
+        // Leave bounded connection credit for other streams when a few TCP
+        // consumers hold their individual receive windows.
+        .initial_connection_window_size(524288)
         .max_frame_size(16384)
         .max_header_list_size(16384)
         .max_concurrent_streams(0)
@@ -80,3 +82,354 @@ impl AsyncWrite for ActivityIo {
         Pin::new(&mut self.raw).poll_shutdown(cx)
     }
 }
+
+#[cfg(test)]
+mod prequeued_flush_memory_tests {
+    use super::*;
+    use bytes::Bytes;
+    use futures_util::task::AtomicWaker;
+    use std::{
+        sync::atomic::{AtomicBool, AtomicUsize, Ordering},
+        task::{Wake, Waker},
+    };
+    use tokio::io::DuplexStream;
+
+    #[derive(Default)]
+    struct Count(AtomicUsize);
+    impl Wake for Count {
+        fn wake(self: Arc<Self>) {
+            self.wake_by_ref();
+        }
+        fn wake_by_ref(self: &Arc<Self>) {
+            self.0.fetch_add(1, Ordering::SeqCst);
+        }
+    }
+    impl Count {
+        fn take(&self) -> usize {
+            self.0.swap(0, Ordering::SeqCst)
+        }
+    }
+
+    #[derive(Default)]
+    struct Gate {
+        blocked: AtomicBool,
+        pending: AtomicUsize,
+        written: AtomicUsize,
+        wake: AtomicWaker,
+    }
+    struct MemoryIo {
+        raw: DuplexStream,
+        gate: Arc<Gate>,
+    }
+    impl AsyncRead for MemoryIo {
+        fn poll_read(
+            mut self: Pin<&mut Self>,
+            cx: &mut Context<'_>,
+            out: &mut ReadBuf<'_>,
+        ) -> Poll<io::Result<()>> {
+            Pin::new(&mut self.raw).poll_read(cx, out)
+        }
+    }
+    impl AsyncWrite for MemoryIo {
+        fn poll_write(
+            mut self: Pin<&mut Self>,
+            cx: &mut Context<'_>,
+            input: &[u8],
+        ) -> Poll<io::Result<usize>> {
+            match Pin::new(&mut self.raw).poll_write(cx, input) {
+                Poll::Ready(Ok(count)) => {
+                    self.gate.written.fetch_add(count, Ordering::SeqCst);
+                    Poll::Ready(Ok(count))
+                }
+                result => result,
+            }
+        }
+        fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            self.gate.wake.register(cx.waker());
+            if self.gate.blocked.load(Ordering::SeqCst) {
+                self.gate.pending.fetch_add(1, Ordering::SeqCst);
+                Poll::Pending
+            } else {
+                Pin::new(&mut self.raw).poll_flush(cx)
+            }
+        }
+        fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Pin::new(&mut self.raw).poll_shutdown(cx)
+        }
+    }
+
+    struct Fixture {
+        driver: Pin<Box<dyn Future<Output = ()> + Send>>,
+        server: h2::server::Connection<MemoryIo, Bytes>,
+        sender: Option<Sender>,
+        stream: Option<BoxStream>,
+        input: Option<h2::RecvStream>,
+        output: Option<h2::SendStream<Bytes>>,
+        gate: Arc<Gate>,
+        peer_gate: Arc<Gate>,
+        driver_count: Arc<Count>,
+        peer_count: Arc<Count>,
+        caller_waker: Waker,
+        received: Vec<u8>,
+        held: Vec<Bytes>,
+        driver_done: bool,
+        peer_done: bool,
+        peer_eof: bool,
+    }
+    impl Fixture {
+        async fn open() -> Self {
+            let (raw, peer) = tokio::io::duplex(65536);
+            let gate = Arc::new(Gate::default());
+            let peer_gate = Arc::new(Gate::default());
+            let (client, server) = tokio::join!(
+                new(Box::new(MemoryIo {
+                    raw,
+                    gate: gate.clone(),
+                })),
+                h2::server::Builder::new().handshake::<_, Bytes>(MemoryIo {
+                    raw: peer,
+                    gate: peer_gate.clone(),
+                }),
+            );
+            let (sender, driver) = client.unwrap();
+            let mut fixture = Self {
+                driver: Box::pin(driver),
+                server: server.unwrap(),
+                sender: Some(sender.clone()),
+                stream: None,
+                input: None,
+                output: None,
+                gate,
+                peer_gate,
+                driver_count: Arc::default(),
+                peer_count: Arc::default(),
+                caller_waker: Waker::from(Arc::new(Count::default())),
+                received: Vec::new(),
+                held: Vec::new(),
+                driver_done: false,
+                peer_done: false,
+                peer_eof: false,
+            };
+            let mut opening = Box::pin(crate::transport::grpc::mux_stream(
+                sender,
+                Instant::now() + Duration::from_secs(3),
+                true,
+            ));
+            for _ in 0..64 {
+                fixture.driver_count.take();
+                fixture.peer_count.take();
+                if fixture.stream.is_none() {
+                    let mut cx = Context::from_waker(&fixture.caller_waker);
+                    if let Poll::Ready(result) = opening.as_mut().poll(&mut cx) {
+                        fixture.stream = Some(result.unwrap());
+                    }
+                }
+                fixture.drive();
+                if fixture.stream.is_some()
+                    && fixture.input.is_some()
+                    && fixture.driver_count.0.load(Ordering::SeqCst) == 0
+                    && fixture.peer_count.0.load(Ordering::SeqCst) == 0
+                {
+                    return fixture;
+                }
+            }
+            panic!("fixture handshake did not reach counted-waker quiescence");
+        }
+
+        fn drive(&mut self) {
+            let driver_waker = Waker::from(self.driver_count.clone());
+            let mut driver_cx = Context::from_waker(&driver_waker);
+            if !self.driver_done {
+                self.driver_done = self.driver.as_mut().poll(&mut driver_cx).is_ready();
+            }
+            let peer_waker = Waker::from(self.peer_count.clone());
+            let mut peer_cx = Context::from_waker(&peer_waker);
+            if !self.peer_done {
+                match self.server.poll_accept(&mut peer_cx) {
+                    Poll::Ready(Some(Ok((request, mut reply)))) => {
+                        assert!(self.input.is_none(), "fixture opened a second request");
+                        self.output =
+                            Some(reply.send_response(http::Response::new(()), false).unwrap());
+                        self.input = Some(request.into_body());
+                    }
+                    Poll::Ready(Some(Err(error))) => panic!("memory peer failed: {error}"),
+                    Poll::Ready(None) => self.peer_done = true,
+                    Poll::Pending => {}
+                }
+            }
+        }
+
+        fn collect(&mut self) {
+            let peer_waker = Waker::from(self.peer_count.clone());
+            let mut cx = Context::from_waker(&peer_waker);
+            let body = self.input.as_mut().expect("fixture CONNECT request");
+            loop {
+                match body.poll_data(&mut cx) {
+                    Poll::Ready(Some(Ok(bytes))) => {
+                        self.received.extend_from_slice(&bytes);
+                        // No released flow credit or response data rescues the driver.
+                        self.held.push(bytes);
+                    }
+                    Poll::Ready(Some(Err(error))) => panic!("memory body failed: {error}"),
+                    Poll::Ready(None) => {
+                        self.peer_eof = true;
+                        break;
+                    }
+                    Poll::Pending => break,
+                }
+            }
+        }
+
+        fn admit(&mut self, bytes: &[u8]) {
+            let mut cx = Context::from_waker(&self.caller_waker);
+            match Pin::new(self.stream.as_mut().unwrap()).poll_write(&mut cx, bytes) {
+                Poll::Ready(Ok(count)) => {
+                    assert_eq!(count, bytes.len(), "fixture partial admission")
+                }
+                result => panic!("fixture DATA was not immediately admitted: {result:?}"),
+            }
+        }
+
+        fn naturally_drive_until_quiet(&mut self) -> usize {
+            let mut polls = 0;
+            for _ in 0..32 {
+                if self.driver_count.take() == 0 {
+                    return polls;
+                }
+                self.drive();
+                self.collect();
+                polls += 1;
+            }
+            panic!("automatic driver phase did not quiesce after bounded work");
+        }
+
+        fn finish(mut self) {
+            self.gate.blocked.store(false, Ordering::SeqCst);
+            self.gate.wake.wake();
+            let mut flushed = false;
+            let mut shutdown = false;
+            for _ in 0..64 {
+                self.drive();
+                let mut cx = Context::from_waker(&self.caller_waker);
+                let stream = self.stream.as_mut().unwrap();
+                if !flushed {
+                    match Pin::new(&mut *stream).poll_flush(&mut cx) {
+                        Poll::Ready(Ok(())) => flushed = true,
+                        Poll::Ready(Err(error)) => panic!("memory flush cleanup failed: {error}"),
+                        Poll::Pending => {}
+                    }
+                }
+                if flushed && !shutdown {
+                    match Pin::new(stream).poll_shutdown(&mut cx) {
+                        Poll::Ready(Ok(())) => shutdown = true,
+                        Poll::Ready(Err(error)) => panic!("memory FIN cleanup failed: {error}"),
+                        Poll::Pending => {}
+                    }
+                }
+                self.collect();
+                if shutdown && self.peer_eof {
+                    break;
+                }
+            }
+            self.output
+                .as_mut()
+                .unwrap()
+                .send_data(Bytes::new(), true)
+                .unwrap();
+            let mut client_eof = false;
+            for _ in 0..64 {
+                self.drive();
+                let mut cx = Context::from_waker(&self.caller_waker);
+                let mut byte = [0];
+                let mut out = ReadBuf::new(&mut byte);
+                match Pin::new(self.stream.as_mut().unwrap()).poll_read(&mut cx, &mut out) {
+                    Poll::Ready(Ok(())) => {
+                        assert!(out.filled().is_empty(), "unexpected response DATA");
+                        client_eof = true;
+                        break;
+                    }
+                    Poll::Ready(Err(error)) => panic!("memory read cleanup failed: {error}"),
+                    Poll::Pending => {}
+                }
+            }
+            drop((
+                self.stream.take(),
+                self.sender.take(),
+                self.input.take(),
+                self.output.take(),
+            ));
+            self.held.clear();
+            for _ in 0..64 {
+                self.drive();
+                if self.driver_done && self.peer_done {
+                    break;
+                }
+            }
+            assert!(
+                flushed
+                    && shutdown
+                    && self.peer_eof
+                    && client_eof
+                    && self.driver_done
+                    && self.peer_done,
+                "memory fixture did not naturally join: flush={flushed}, FIN={shutdown}, peer_EOF={}, client_EOF={client_eof}, driver={}, peer={}",
+                self.peer_eof,
+                self.driver_done,
+                self.peer_done,
+            );
+        }
+    }
+
+    #[tokio::test]
+    async fn already_queued_large_data_progresses_before_pending_raw_flush_completes() {
+        let mut fixture = Fixture::open().await;
+        let peer_before = fixture.peer_gate.written.load(Ordering::SeqCst);
+        fixture.gate.blocked.store(true, Ordering::SeqCst);
+        fixture.driver_count.take();
+        let a = [b'a'; 2048];
+        let b = [b'b'; 2048];
+        // Both DATA frames are admitted before any driver flush registration.
+        fixture.admit(&a);
+        fixture.admit(&b);
+        let natural_polls = fixture.naturally_drive_until_quiet();
+        let independent = fixture.received.len();
+        let pending = fixture.gate.pending.load(Ordering::SeqCst);
+        assert!(
+            natural_polls > 0,
+            "fixture never received the initial native driver wake"
+        );
+        assert!(
+            pending > 0,
+            "fixture never reached the blocked physical flush"
+        );
+        assert!(!fixture.driver_done && !fixture.peer_done && !fixture.peer_eof);
+        // An external re-poll is a counterfactual, never counted as autonomy.
+        fixture.drive();
+        fixture.collect();
+        let rescued = fixture.received.len();
+        assert_eq!(fixture.received, [a.as_slice(), b.as_slice()].concat());
+        assert_eq!(
+            fixture.peer_gate.written.load(Ordering::SeqCst),
+            peer_before,
+            "peer emitted credit/control/data during the observation"
+        );
+        let mut cx = Context::from_waker(&fixture.caller_waker);
+        assert!(
+            Pin::new(fixture.stream.as_mut().unwrap())
+                .poll_flush(&mut cx)
+                .is_pending(),
+            "explicit logical flush completed before physical flush"
+        );
+        fixture.finish();
+        assert_eq!(
+            rescued,
+            a.len() + b.len(),
+            "external re-poll did not rescue both DATA frames"
+        );
+        assert_eq!(
+            independent,
+            a.len() + b.len(),
+            "already queued h2mux DATA must progress after a productive pending flush: independent={independent}, rescued={rescued}, natural_polls={natural_polls}"
+        );
+    }
+}
diff --git a/src/transport/sing_mux/smux_driver.rs b/src/transport/sing_mux/smux_driver.rs
index ac9a6a0..8b2954b 100644
--- a/src/transport/sing_mux/smux_driver.rs
+++ b/src/transport/sing_mux/smux_driver.rs
@@ -1,395 +1,2 @@
-//! Independent smux v1 client framing. One owned reader/writer pair, bounded
-//! physical write queue and per-stream receive queues; no detached workers.
-use super::*;
-use bytes::Buf;
-use std::collections::HashMap;
-use std::sync::atomic::AtomicBool;
-use tokio::{
-    io::{AsyncReadExt, AsyncWriteExt},
-    sync::{Notify, mpsc, oneshot},
-};
-use tokio_util::sync::PollSender;
-
-const CHUNK: usize = crate::limits::SING_MUX_CHUNK;
-struct Frame {
-    cmd: u8,
-    id: u32,
-    data: Bytes,
-    done: oneshot::Sender<io::Result<()>>,
-}
-struct Entry {
-    receive: mpsc::Sender<Bytes>,
-    close: CancellationToken,
-    remote_fin: Arc<AtomicBool>,
-}
-struct State {
-    closed: bool,
-    next: u32,
-    streams: HashMap<u32, Entry>,
-}
-struct Shared {
-    state: Mutex<State>,
-    changed: Notify,
-}
-#[derive(Clone)]
-pub(super) struct Client {
-    shared: Arc<Shared>,
-    write: mpsc::Sender<Frame>,
-}
-impl Client {
-    pub(super) async fn open(&self) -> io::Result<BoxStream> {
-        let permit = self
-            .write
-            .clone()
-            .reserve_owned()
-            .await
-            .map_err(|_| io::ErrorKind::ConnectionAborted)?;
-        let (tx, receive) = mpsc::channel(crate::limits::SMUX_RECEIVE_QUEUE);
-        let close = CancellationToken::new();
-        let remote_fin = Arc::new(AtomicBool::new(false));
-        let (id, done) = {
-            let mut state = self.shared.state.lock().unwrap();
-            if state.closed {
-                return Err(io::ErrorKind::ConnectionAborted.into());
-            }
-            state.next = state
-                .next
-                .checked_add(2)
-                .ok_or(io::ErrorKind::ConnectionAborted)?;
-            let id = state.next;
-            state.streams.insert(
-                id,
-                Entry {
-                    receive: tx,
-                    close: close.clone(),
-                    remote_fin: remote_fin.clone(),
-                },
-            );
-            let (tx, rx) = oneshot::channel();
-            permit.send(Frame {
-                cmd: 0,
-                id,
-                data: Bytes::new(),
-                done: tx,
-            });
-            (id, rx)
-        };
-        let stream = Stream {
-            id,
-            shared: self.shared.clone(),
-            write: PollSender::new(self.write.clone()),
-            receive,
-            close: close.clone(),
-            cancelled: Box::pin(close.cancelled_owned()),
-            remote_fin,
-            pending: None,
-            data: Bytes::new(),
-        };
-        // Cancellation drops the newly registered logical stream and queues FIN.
-        done.await.map_err(|_| io::ErrorKind::ConnectionAborted)??;
-        Ok(Box::new(stream))
-    }
-}
-struct Lifetime(Arc<Shared>);
-impl Drop for Lifetime {
-    fn drop(&mut self) {
-        let mut state = self.0.state.lock().unwrap();
-        state.closed = true;
-        for (_, entry) in state.streams.drain() {
-            entry.close.cancel();
-        }
-    }
-}
-pub(super) fn new(raw: BoxStream) -> (Client, impl Future<Output = ()> + Send) {
-    let shared = Arc::new(Shared {
-        state: Mutex::new(State {
-            closed: false,
-            next: 1,
-            streams: HashMap::new(),
-        }),
-        changed: Notify::new(),
-    });
-    let lifetime = Lifetime(shared.clone());
-    let (write, mut frames) = mpsc::channel::<Frame>(crate::limits::SING_MUX_COMMAND_QUEUE);
-    let client = Client {
-        shared: shared.clone(),
-        write,
-    };
-    let (mut reader, mut writer) = tokio::io::split(raw);
-    let read_shared = shared.clone();
-    let read = async move {
-        loop {
-            let mut header = [0; 8];
-            reader.read_exact(&mut header).await?;
-            let cmd = header[1];
-            let length = u16::from_le_bytes(header[2..4].try_into().unwrap()) as usize;
-            let id = u32::from_le_bytes(header[4..8].try_into().unwrap());
-            if header[0] != 1 || !matches!(cmd, 1..=3) || (cmd != 2 && length != 0) {
-                return Err::<(), _>(io::Error::from(io::ErrorKind::InvalidData));
-            }
-            if cmd == 1 {
-                if let Some(entry) = read_shared.state.lock().unwrap().streams.remove(&id) {
-                    entry.remote_fin.store(true, Ordering::Release);
-                }
-                continue;
-            }
-            if cmd == 3 || length == 0 {
-                tokio::task::yield_now().await;
-                continue;
-            }
-            let mut data = vec![0; length];
-            reader.read_exact(&mut data).await?;
-            let target = read_shared
-                .state
-                .lock()
-                .unwrap()
-                .streams
-                .get(&id)
-                .map(|e| (e.receive.clone(), e.close.clone()));
-            if let Some((receive, close)) = target {
-                tokio::select! {biased;()=close.cancelled()=>{},_=receive.send(data.into())=>{}}
-            }
-        }
-    };
-    let write = async move {
-        let mut processed = 0;
-        loop {
-            // A canceled stream always has a FIN path even if the data queue is
-            // full. No unbounded "control queue" and no try_send/drop fallback.
-            let closing = {
-                let mut state = shared.state.lock().unwrap();
-                let id = state
-                    .streams
-                    .iter()
-                    .find(|(_, e)| e.close.is_cancelled())
-                    .map(|(id, _)| *id);
-                id.and_then(|id| state.streams.remove(&id).map(|_| id))
-            };
-            if let Some(id) = closing {
-                send(&mut writer, 1, id, &[]).await?;
-            } else {
-                let frame = tokio::select! {
-                    ()=shared.changed.notified()=>continue,
-                    frame=frames.recv()=>{let Some(frame)=frame else {return Ok::<(),io::Error>(());};frame}
-                };
-                let alive = shared
-                    .state
-                    .lock()
-                    .unwrap()
-                    .streams
-                    .get(&frame.id)
-                    .is_some_and(|e| !e.close.is_cancelled());
-                if !alive {
-                    let _ = frame.done.send(Err(io::ErrorKind::BrokenPipe.into()));
-                    continue;
-                }
-                let result = send(&mut writer, frame.cmd, frame.id, &frame.data).await;
-                let failed = result.is_err();
-                let _ = frame.done.send(result);
-                if failed {
-                    return Err(io::ErrorKind::ConnectionAborted.into());
-                }
-            }
-            processed += 1;
-            if processed == crate::limits::IO_POLL_BUDGET {
-                processed = 0;
-                tokio::task::yield_now().await;
-            }
-        }
-    };
-    let driver = async move {
-        let _lifetime = lifetime;
-        tokio::select! {
-            _=read=>{},
-            _=write=>{}
-        }
-    };
-    (client, driver)
-}
-async fn send<W: AsyncWrite + Unpin>(
-    writer: &mut W,
-    cmd: u8,
-    id: u32,
-    data: &[u8],
-) -> io::Result<()> {
-    let mut header = [0; 8];
-    header[0] = 1;
-    header[1] = cmd;
-    header[2..4].copy_from_slice(&(data.len() as u16).to_le_bytes());
-    header[4..8].copy_from_slice(&id.to_le_bytes());
-    writer.write_all(&header).await?;
-    writer.write_all(data).await?;
-    writer.flush().await
-}
-struct Stream {
-    id: u32,
-    shared: Arc<Shared>,
-    write: PollSender<Frame>,
-    receive: mpsc::Receiver<Bytes>,
-    close: CancellationToken,
-    cancelled: Pin<Box<dyn Future<Output = ()> + Send>>,
-    remote_fin: Arc<AtomicBool>,
-    pending: Option<oneshot::Receiver<io::Result<()>>>,
-    data: Bytes,
-}
-impl Stream {
-    fn stop(&mut self) {
-        self.close.cancel();
-        self.shared.changed.notify_one();
-        self.pending.take();
-        self.write.abort_send();
-        self.receive.close();
-        self.data = Bytes::new();
-    }
-    fn flush_pending(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        if self.cancelled.as_mut().poll(cx).is_ready() {
-            return Poll::Ready(Err(io::ErrorKind::BrokenPipe.into()));
-        }
-        if let Some(pending) = &mut self.pending {
-            ready!(Pin::new(pending).poll(cx)).map_err(|_| io::ErrorKind::BrokenPipe)??;
-            self.pending = None;
-        }
-        Poll::Ready(Ok(()))
-    }
-}
-impl Drop for Stream {
-    fn drop(&mut self) {
-        self.stop();
-    }
-}
-impl AsyncRead for Stream {
-    fn poll_read(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        out: &mut ReadBuf<'_>,
-    ) -> Poll<io::Result<()>> {
-        if out.remaining() == 0 || self.cancelled.as_mut().poll(cx).is_ready() {
-            return Poll::Ready(Ok(()));
-        }
-        if self.data.is_empty() {
-            match ready!(self.receive.poll_recv(cx)) {
-                Some(data) => self.data = data,
-                None => return Poll::Ready(Ok(())),
-            }
-        }
-        let n = out.remaining().min(self.data.len());
-        out.put_slice(&self.data[..n]);
-        self.data.advance(n);
-        Poll::Ready(Ok(()))
-    }
-}
-impl AsyncWrite for Stream {
-    fn poll_write(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &[u8],
-    ) -> Poll<io::Result<usize>> {
-        ready!(self.flush_pending(cx))?;
-        if self.remote_fin.load(Ordering::Acquire) {
-            return Poll::Ready(Err(io::ErrorKind::BrokenPipe.into()));
-        }
-        if buf.is_empty() {
-            return Poll::Ready(Ok(0));
-        }
-        ready!(self.write.poll_reserve(cx)).map_err(|_| io::ErrorKind::BrokenPipe)?;
-        let size = buf.len().min(CHUNK);
-        let (tx, rx) = oneshot::channel();
-        let id = self.id;
-        self.write
-            .send_item(Frame {
-                cmd: 2,
-                id,
-                data: Bytes::copy_from_slice(&buf[..size]),
-                done: tx,
-            })
-            .map_err(|_| io::ErrorKind::BrokenPipe)?;
-        self.pending = Some(rx);
-        Poll::Ready(Ok(size))
-    }
-    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        self.flush_pending(cx)
-    }
-    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        if self.close.is_cancelled() {
-            return Poll::Ready(Ok(()));
-        }
-        ready!(self.flush_pending(cx))?;
-        self.stop();
-        Poll::Ready(Ok(()))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::time::Duration;
-
-    #[tokio::test]
-    async fn shutdown_flushes_the_pending_frame_before_fin() {
-        tokio::time::timeout(Duration::from_secs(2), async {
-            let (raw, mut peer) = tokio::io::duplex(16);
-            let (client, driver) = new(Box::new(raw));
-            let task = tokio::spawn(driver);
-            let mut stream = client.open().await.unwrap();
-            let mut syn = [0; 8];
-            peer.read_exact(&mut syn).await.unwrap();
-            let receive = tokio::spawn(async move {
-                let mut received = Vec::new();
-                loop {
-                    let mut header = [0; 8];
-                    peer.read_exact(&mut header).await.unwrap();
-                    assert_eq!(&header[4..], &syn[4..]);
-                    if header[1] == 1 {
-                        break;
-                    }
-                    assert_eq!(header[1], 2);
-                    let size = u16::from_le_bytes([header[2], header[3]]) as usize;
-                    let mut data = vec![0; size];
-                    peer.read_exact(&mut data).await.unwrap();
-                    received.extend(data);
-                }
-                received
-            });
-            let payload = vec![b'x'; 1024];
-            stream.write_all(&payload).await.unwrap();
-            stream.shutdown().await.unwrap();
-            let received = receive.await.unwrap();
-            task.await.unwrap();
-            assert_eq!(received.len(), payload.len());
-            assert_eq!(received, payload);
-        })
-        .await
-        .unwrap();
-    }
-
-    #[tokio::test]
-    async fn malformed_smux_headers_close_the_owned_driver_before_reading_a_body() {
-        #[cfg(feature = "interop-test")]
-        let _case = crate::resources::case_events::Case::new(
-            "XHTTP-UNIT",
-            "malformed_smux_headers_close_the_owned_driver_before_reading_a_body",
-        );
-        for (version, command, length) in [(2, 2, 0), (1, 0, 0), (1, 4, 0), (1, 1, 1), (1, 3, 1)] {
-            tokio::time::timeout(Duration::from_secs(1), async {
-                let (raw, mut peer) = tokio::io::duplex(64);
-                let (client, driver) = new(Box::new(raw));
-                let task = tokio::spawn(driver);
-                let mut logical = client.open().await.unwrap();
-                let mut syn = [0; 8];
-                peer.read_exact(&mut syn).await.unwrap();
-                assert_eq!(syn, [1, 0, 0, 0, 3, 0, 0, 0]);
-                // No body is supplied: malformed control framing must terminate
-                // immediately rather than waiting for attacker-controlled data.
-                peer.write_all(&[version, command, length, 0, 3, 0, 0, 0])
-                    .await
-                    .unwrap();
-                task.await.unwrap();
-                assert_eq!(logical.read(&mut [0]).await.unwrap(), 0);
-                assert!(logical.write_all(b"closed").await.is_err());
-                assert!(client.open().await.is_err());
-            })
-            .await
-            .unwrap();
-        }
-    }
-}
+//! Preserve the sing-mux v1 framing contract through the shared raw driver.
+pub(super) use crate::transport::smux::{Client, new_with_autonomous_writes};
diff --git a/src/transport/smux.rs b/src/transport/smux.rs
new file mode 100644
index 0000000..a5a2a80
--- /dev/null
+++ b/src/transport/smux.rs
@@ -0,0 +1,1661 @@
+//! Independent smux v1 client framing. One owned reader/writer pair, bounded
+//! physical write queue and connection-budgeted receive queues; no detached workers.
+use crate::dispatch::BoxStream;
+use bytes::Buf;
+use bytes::Bytes;
+use futures_util::task::AtomicWaker;
+use std::collections::HashMap;
+use std::sync::atomic::AtomicBool;
+use std::{
+    future::Future,
+    io,
+    pin::Pin,
+    sync::{
+        Arc, Mutex,
+        atomic::{AtomicU32, AtomicU64, Ordering},
+    },
+    task::{Context, Poll, ready},
+};
+use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+use tokio::{
+    io::{AsyncReadExt, AsyncWriteExt},
+    sync::{Notify, mpsc, oneshot},
+};
+use tokio_util::sync::CancellationToken;
+use tokio_util::sync::PollSender;
+
+#[derive(Clone, Copy)]
+pub(crate) struct Options {
+    pub version: u8,
+    pub frame_size: usize,
+    pub receive_buffer: usize,
+    pub stream_buffer: usize,
+    pub keepalive: Option<std::time::Duration>,
+}
+impl Default for Options {
+    fn default() -> Self {
+        Self {
+            version: 1,
+            frame_size: crate::limits::SING_MUX_CHUNK,
+            receive_buffer: 4 * 1024 * 1024,
+            stream_buffer: crate::limits::SMUX_RECEIVE_QUEUE * crate::limits::SING_MUX_CHUNK,
+            keepalive: None,
+        }
+    }
+}
+struct Packet {
+    data: Bytes,
+    _permit: tokio::sync::OwnedSemaphorePermit,
+}
+// Charge each queued frame for its payload and a conservative bookkeeping fee.
+// This is a connection admission budget, not a process RSS bound. A legal
+// quota-sized frame must still make progress when the configured quota is small.
+fn receive_charge(length: usize, budget: usize) -> usize {
+    (length + 128).min(budget)
+}
+struct Flow {
+    written: AtomicU32,
+    consumed: AtomicU32,
+    peer_consumed: AtomicU32,
+    peer_window: AtomicU32,
+    update: AtomicBool,
+    changed: AtomicWaker,
+}
+impl Flow {
+    fn new() -> Self {
+        Self {
+            written: AtomicU32::new(0),
+            consumed: AtomicU32::new(0),
+            peer_consumed: AtomicU32::new(0),
+            peer_window: AtomicU32::new(262144),
+            update: AtomicBool::new(false),
+            changed: AtomicWaker::new(),
+        }
+    }
+    fn credit(&self) -> u32 {
+        self.peer_window.load(Ordering::Acquire).saturating_sub(
+            self.written
+                .load(Ordering::Acquire)
+                .wrapping_sub(self.peer_consumed.load(Ordering::Acquire)),
+        )
+    }
+}
+enum Command {
+    Frame(Frame),
+    Flush(oneshot::Sender<io::Result<()>>),
+}
+struct Frame {
+    cmd: u8,
+    id: u32,
+    data: Bytes,
+    done: oneshot::Sender<io::Result<()>>,
+}
+struct Entry {
+    receive: mpsc::Sender<Packet>,
+    flow: Arc<Flow>,
+    close: CancellationToken,
+    remote_fin: Arc<AtomicBool>,
+}
+struct State {
+    closed: bool,
+    next: u32,
+    streams: HashMap<u32, Entry>,
+}
+struct Shared {
+    state: Mutex<State>,
+    changed: Notify,
+    options: Options,
+    autonomous_writes: bool,
+}
+#[derive(Clone)]
+pub(crate) struct Client {
+    shared: Arc<Shared>,
+    write: mpsc::Sender<Command>,
+}
+impl Client {
+    pub(crate) async fn open(&self) -> io::Result<BoxStream> {
+        let permit = self
+            .write
+            .clone()
+            .reserve_owned()
+            .await
+            .map_err(|_| io::ErrorKind::ConnectionAborted)?;
+        let budget = self.shared.options.receive_buffer;
+        // Allocation permits bound live frames, so no individual stream queue
+        // fills before the connection-wide byte budget is exhausted.
+        let capacity = budget / receive_charge(1, budget);
+        let (tx, receive) = mpsc::channel(capacity);
+        let flow = Arc::new(Flow::new());
+        let close = CancellationToken::new();
+        let remote_fin = Arc::new(AtomicBool::new(false));
+        let (id, done) = {
+            let mut state = self.shared.state.lock().unwrap();
+            if state.closed {
+                return Err(io::ErrorKind::ConnectionAborted.into());
+            }
+            state.next = state
+                .next
+                .checked_add(2)
+                .ok_or(io::ErrorKind::ConnectionAborted)?;
+            let id = state.next;
+            state.streams.insert(
+                id,
+                Entry {
+                    receive: tx,
+                    flow: flow.clone(),
+                    close: close.clone(),
+                    remote_fin: remote_fin.clone(),
+                },
+            );
+            let (tx, rx) = oneshot::channel();
+            permit.send(Command::Frame(Frame {
+                cmd: 0,
+                id,
+                data: Bytes::new(),
+                done: tx,
+            }));
+            (id, rx)
+        };
+        let stream = Stream {
+            id,
+            shared: self.shared.clone(),
+            write: PollSender::new(self.write.clone()),
+            receive: Some(receive),
+            close: close.clone(),
+            cancelled: Box::pin(close.cancelled_owned()),
+            remote_fin,
+            pending: None,
+            pending_is_flush: false,
+            dirty: false,
+            data: Bytes::new(),
+            receive_permit: None,
+            flow,
+            since_update: 0,
+        };
+        // Cancellation drops the newly registered logical stream and queues FIN.
+        done.await.map_err(|_| io::ErrorKind::ConnectionAborted)??;
+        Ok(Box::new(stream))
+    }
+}
+struct Lifetime(Arc<Shared>);
+impl Drop for Lifetime {
+    fn drop(&mut self) {
+        let mut state = self.0.state.lock().unwrap();
+        state.closed = true;
+        for (_, entry) in state.streams.drain() {
+            entry.close.cancel();
+            entry.flow.changed.wake();
+        }
+    }
+}
+pub(crate) fn new(raw: BoxStream) -> (Client, impl Future<Output = ()> + Send) {
+    with_options(raw, Options::default()).expect("valid default smux options")
+}
+#[cfg(any(feature = "sing-mux", test))]
+pub(crate) fn new_with_autonomous_writes(
+    raw: BoxStream,
+    autonomous_writes: bool,
+) -> (Client, impl Future<Output = ()> + Send) {
+    configure(raw, Options::default(), autonomous_writes).expect("valid default smux options")
+}
+pub(crate) fn with_options(
+    raw: BoxStream,
+    options: Options,
+) -> io::Result<(Client, impl Future<Output = ()> + Send)> {
+    configure(raw, options, false)
+}
+fn configure(
+    raw: BoxStream,
+    options: Options,
+    autonomous_writes: bool,
+) -> io::Result<(Client, impl Future<Output = ()> + Send)> {
+    if !(1..=2).contains(&options.version)
+        || !(1..=65535).contains(&options.frame_size)
+        || options.receive_buffer == 0
+        || options.receive_buffer > 8 * 1024 * 1024
+        || options.stream_buffer == 0
+        || options.stream_buffer > options.receive_buffer
+        || options.keepalive.is_some_and(|d| d.is_zero())
+    {
+        return Err(io::ErrorKind::InvalidInput.into());
+    }
+    let receive_budget = Arc::new(tokio::sync::Semaphore::new(options.receive_buffer));
+    let epoch = tokio::time::Instant::now();
+    let last_read = Arc::new(AtomicU64::new(0));
+    let shared = Arc::new(Shared {
+        state: Mutex::new(State {
+            closed: false,
+            next: 1,
+            streams: HashMap::new(),
+        }),
+        changed: Notify::new(),
+        options,
+        autonomous_writes,
+    });
+    let lifetime = Lifetime(shared.clone());
+    let (write, mut frames) = mpsc::channel::<Command>(crate::limits::SING_MUX_COMMAND_QUEUE);
+    let client = Client {
+        shared: shared.clone(),
+        write,
+    };
+    let (mut reader, mut writer) = tokio::io::split(raw);
+    let read_shared = shared.clone();
+    let read_last = last_read.clone();
+    let read = async move {
+        let mut processed = 0;
+        loop {
+            if processed == crate::limits::IO_POLL_BUDGET {
+                processed = 0;
+                tokio::task::yield_now().await;
+            }
+            processed += 1;
+            let mut header = [0; 8];
+            reader.read_exact(&mut header).await?;
+            let cmd = header[1];
+            let length = u16::from_le_bytes(header[2..4].try_into().unwrap()) as usize;
+            let id = u32::from_le_bytes(header[4..8].try_into().unwrap());
+            if header[0] != options.version
+                || !matches!(cmd, 1..=4)
+                || (cmd == 4 && (options.version != 2 || length != 8))
+                || (matches!(cmd, 1 | 3) && length != 0)
+            {
+                return Err::<(), _>(io::Error::from(io::ErrorKind::InvalidData));
+            }
+            read_last.store(epoch.elapsed().as_millis() as u64, Ordering::Release);
+            if cmd == 4 {
+                let mut update = [0; 8];
+                reader.read_exact(&mut update).await?;
+                if let Some(entry) = read_shared.state.lock().unwrap().streams.get(&id) {
+                    let consumed = u32::from_le_bytes(update[..4].try_into().unwrap());
+                    let window = u32::from_le_bytes(update[4..].try_into().unwrap());
+                    if window > i32::MAX as u32
+                        || entry
+                            .flow
+                            .written
+                            .load(Ordering::Acquire)
+                            .wrapping_sub(consumed)
+                            > i32::MAX as u32
+                    {
+                        return Err(io::ErrorKind::InvalidData.into());
+                    }
+                    entry.flow.peer_consumed.store(consumed, Ordering::Release);
+                    entry.flow.peer_window.store(window, Ordering::Release);
+                    entry.flow.changed.wake();
+                }
+                continue;
+            }
+            if cmd == 1 {
+                if let Some(entry) = read_shared.state.lock().unwrap().streams.remove(&id) {
+                    entry.remote_fin.store(true, Ordering::Release);
+                    entry.flow.changed.wake();
+                }
+                continue;
+            }
+            if cmd == 3 || length == 0 {
+                tokio::task::yield_now().await;
+                continue;
+            }
+            if length > options.stream_buffer || length > options.receive_buffer {
+                return Err(io::ErrorKind::InvalidData.into());
+            }
+            let permit = receive_budget
+                .clone()
+                .acquire_many_owned(receive_charge(length, options.receive_buffer) as u32)
+                .await
+                .map_err(|_| io::ErrorKind::ConnectionAborted)?;
+            let mut data = vec![0; length];
+            reader.read_exact(&mut data).await?;
+            let target = read_shared
+                .state
+                .lock()
+                .unwrap()
+                .streams
+                .get(&id)
+                .map(|e| (e.receive.clone(), e.close.clone()));
+            if let Some((receive, close)) = target {
+                tokio::select! {biased;()=close.cancelled()=>{},_=receive.send(Packet {data:data.into(),_permit:permit})=>{}}
+            }
+        }
+    };
+    let write = async move {
+        let mut processed = 0;
+        // Keep only completion senders, never a second payload queue.
+        let mut completions = Vec::with_capacity(crate::limits::SING_MUX_COMMAND_QUEUE);
+        let duration = options
+            .keepalive
+            .unwrap_or(std::time::Duration::from_secs(24 * 3600));
+        let mut keepalive =
+            tokio::time::interval_at(tokio::time::Instant::now() + duration, duration);
+        keepalive.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
+        loop {
+            // A canceled stream always has a FIN path even if the data queue is
+            // full. No unbounded "control queue" and no try_send/drop fallback.
+            let closing = {
+                let mut state = shared.state.lock().unwrap();
+                let id = state
+                    .streams
+                    .iter()
+                    .find(|(_, e)| e.close.is_cancelled())
+                    .map(|(id, _)| *id);
+                id.and_then(|id| state.streams.remove(&id).map(|_| id))
+            };
+            if let Some(id) = closing {
+                send(&mut writer, options.version, 1, id, &[]).await?;
+            } else if options.version == 2 && {
+                let update = {
+                    let state = shared.state.lock().unwrap();
+                    state.streams.iter().find_map(|(id, e)| {
+                        e.flow
+                            .update
+                            .swap(false, Ordering::AcqRel)
+                            .then(|| (*id, e.flow.consumed.load(Ordering::Acquire)))
+                    })
+                };
+                if let Some((id, consumed)) = update {
+                    let mut data = [0; 8];
+                    data[..4].copy_from_slice(&consumed.to_le_bytes());
+                    data[4..].copy_from_slice(&(options.stream_buffer as u32).to_le_bytes());
+                    send(&mut writer, options.version, 4, id, &data).await?;
+                    true
+                } else {
+                    false
+                }
+            } {
+            } else {
+                let frame = tokio::select! {
+                    ()=shared.changed.notified()=>continue,
+                    _=keepalive.tick(),if options.keepalive.is_some()=>{
+                        if epoch.elapsed().as_millis() as u64-last_read.load(Ordering::Acquire)>3*duration.as_millis() as u64 {return Err(io::ErrorKind::TimedOut.into());}
+                        send(&mut writer,options.version,3,0,&[]).await?;continue;
+                    },
+                    frame=frames.recv()=>{let Some(frame)=frame else {return Ok::<(),io::Error>(());};frame}
+                };
+                let mut command = frame;
+                let mut count = 0;
+                let mut bytes = 0_usize;
+                let mut result = Ok(());
+                loop {
+                    let mut flush_barrier = false;
+                    match command {
+                        Command::Flush(done) => {
+                            // FIFO after all earlier DATA writes. Its receiver
+                            // remains in Stream even if a flush future is dropped.
+                            completions.push(done);
+                            flush_barrier = true;
+                        }
+                        Command::Frame(Frame {
+                            cmd,
+                            id,
+                            data,
+                            done,
+                        }) => {
+                            let alive = shared
+                                .state
+                                .lock()
+                                .unwrap()
+                                .streams
+                                .get(&id)
+                                .is_some_and(|entry| !entry.close.is_cancelled());
+                            if alive {
+                                bytes += 8 + data.len();
+                                result =
+                                    write_frame(&mut writer, options.version, cmd, id, &data).await;
+                                if autonomous_writes && cmd == 2 {
+                                    // This capability is restricted to owned
+                                    // XHTTP drivers that advance accepted bodies
+                                    // independently. It never weakens explicit flush.
+                                    let _ = done.send(match &result {
+                                        Ok(()) => Ok(()),
+                                        Err(error) => Err(error.kind().into()),
+                                    });
+                                } else {
+                                    completions.push(done);
+                                }
+                            } else {
+                                let _ = done.send(Err(io::ErrorKind::BrokenPipe.into()));
+                            }
+                            // No second payload queue: at most the original
+                            // command queue plus the currently written frame.
+                            drop(data);
+                        }
+                    }
+                    count += 1;
+                    let control_pending = {
+                        let state = shared.state.lock().unwrap();
+                        state.streams.values().any(|entry| {
+                            entry.close.is_cancelled()
+                                || (options.version == 2
+                                    && entry.flow.update.load(Ordering::Acquire))
+                        })
+                    };
+                    if flush_barrier
+                        || result.is_err()
+                        || count == crate::limits::SING_MUX_COMMAND_QUEUE
+                        || processed + count >= crate::limits::IO_POLL_BUDGET
+                        || bytes + 8 + options.frame_size > 64 * 1024
+                        || control_pending
+                    {
+                        break;
+                    }
+                    match frames.try_recv() {
+                        Ok(next) => command = next,
+                        Err(_) => break,
+                    }
+                }
+                if result.is_ok() && !completions.is_empty() {
+                    result = writer.flush().await;
+                }
+                let error = result.err().map(|error| error.kind());
+                for done in completions.drain(..) {
+                    let _ = done.send(match error {
+                        Some(kind) => Err(kind.into()),
+                        None => Ok(()),
+                    });
+                }
+                if error.is_some() {
+                    return Err(io::ErrorKind::ConnectionAborted.into());
+                }
+                processed += count;
+                if processed >= crate::limits::IO_POLL_BUDGET {
+                    processed = 0;
+                    tokio::task::yield_now().await;
+                }
+                continue;
+            }
+            processed += 1;
+            if processed >= crate::limits::IO_POLL_BUDGET {
+                processed = 0;
+                tokio::task::yield_now().await;
+            }
+        }
+    };
+    let driver = async move {
+        let _lifetime = lifetime;
+        tokio::select! {
+            _=read=>{},
+            _=write=>{}
+        }
+    };
+    Ok((client, driver))
+}
+async fn send<W: AsyncWrite + Unpin>(
+    writer: &mut W,
+    version: u8,
+    cmd: u8,
+    id: u32,
+    data: &[u8],
+) -> io::Result<()> {
+    write_frame(writer, version, cmd, id, data).await?;
+    writer.flush().await
+}
+async fn write_frame<W: AsyncWrite + Unpin>(
+    writer: &mut W,
+    version: u8,
+    cmd: u8,
+    id: u32,
+    data: &[u8],
+) -> io::Result<()> {
+    let mut header = [0; 8];
+    header[0] = version;
+    header[1] = cmd;
+    header[2..4].copy_from_slice(&(data.len() as u16).to_le_bytes());
+    header[4..8].copy_from_slice(&id.to_le_bytes());
+    writer.write_all(&header).await?;
+    writer.write_all(data).await
+}
+struct Stream {
+    id: u32,
+    shared: Arc<Shared>,
+    write: PollSender<Command>,
+    receive: Option<mpsc::Receiver<Packet>>,
+    receive_permit: Option<tokio::sync::OwnedSemaphorePermit>,
+    flow: Arc<Flow>,
+    since_update: u32,
+    close: CancellationToken,
+    cancelled: Pin<Box<dyn Future<Output = ()> + Send>>,
+    remote_fin: Arc<AtomicBool>,
+    pending: Option<oneshot::Receiver<io::Result<()>>>,
+    pending_is_flush: bool,
+    dirty: bool,
+    data: Bytes,
+}
+impl Stream {
+    fn stop(&mut self) {
+        self.close.cancel();
+        self.shared.changed.notify_one();
+        self.pending.take();
+        self.write.abort_send();
+        self.receive.take();
+        self.data = Bytes::new();
+        self.receive_permit.take();
+    }
+    fn flush_pending(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        if self.cancelled.as_mut().poll(cx).is_ready() {
+            self.stop();
+            return Poll::Ready(Err(io::ErrorKind::BrokenPipe.into()));
+        }
+        if let Some(pending) = &mut self.pending {
+            ready!(Pin::new(pending).poll(cx)).map_err(|_| io::ErrorKind::BrokenPipe)??;
+            self.pending = None;
+            if self.pending_is_flush {
+                self.pending_is_flush = false;
+                self.dirty = false;
+            }
+        }
+        Poll::Ready(Ok(()))
+    }
+    fn poll_flush_barrier(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        ready!(self.flush_pending(cx))?;
+        if !self.shared.autonomous_writes || !self.dirty {
+            return Poll::Ready(Ok(()));
+        }
+        ready!(self.write.poll_reserve(cx)).map_err(|_| io::ErrorKind::BrokenPipe)?;
+        let (done, completed) = oneshot::channel();
+        self.write
+            .send_item(Command::Flush(done))
+            .map_err(|_| io::ErrorKind::BrokenPipe)?;
+        self.pending = Some(completed);
+        self.pending_is_flush = true;
+        self.flush_pending(cx)
+    }
+}
+impl Drop for Stream {
+    fn drop(&mut self) {
+        self.stop();
+    }
+}
+impl AsyncRead for Stream {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        out: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        if out.remaining() == 0 {
+            return Poll::Ready(Ok(()));
+        }
+        if self.cancelled.as_mut().poll(cx).is_ready() {
+            self.stop();
+            return Poll::Ready(Ok(()));
+        }
+        if self.data.is_empty() {
+            let Some(receive) = self.receive.as_mut() else {
+                return Poll::Ready(Ok(()));
+            };
+            match ready!(receive.poll_recv(cx)) {
+                Some(packet) => {
+                    self.data = packet.data;
+                    self.receive_permit = Some(packet._permit);
+                }
+                None => return Poll::Ready(Ok(())),
+            }
+        }
+        let n = out.remaining().min(self.data.len());
+        out.put_slice(&self.data[..n]);
+        self.data.advance(n);
+        if self.data.is_empty() {
+            // Advancing Bytes does not release its backing allocation. Retain
+            // the whole admission permit until that allocation is dropped.
+            self.data = Bytes::new();
+            self.receive_permit.take();
+        }
+        if self.shared.options.version == 2 {
+            let before = self.flow.consumed.fetch_add(n as u32, Ordering::AcqRel);
+            self.since_update = self.since_update.wrapping_add(n as u32);
+            if before == 0 || self.since_update as usize >= self.shared.options.stream_buffer / 2 {
+                self.since_update = 0;
+                self.flow.update.store(true, Ordering::Release);
+                self.shared.changed.notify_one();
+            }
+        }
+        Poll::Ready(Ok(()))
+    }
+}
+impl AsyncWrite for Stream {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        ready!(self.flush_pending(cx))?;
+        self.flow.changed.register(cx.waker());
+        if self.remote_fin.load(Ordering::Acquire) {
+            return Poll::Ready(Err(io::ErrorKind::BrokenPipe.into()));
+        }
+        if buf.is_empty() {
+            return Poll::Ready(Ok(0));
+        }
+        let credit = if self.shared.options.version == 2 {
+            self.flow.credit() as usize
+        } else {
+            usize::MAX
+        };
+        if credit == 0 {
+            // A window-blocked flow must leave queue capacity for other streams.
+            self.write.abort_send();
+            return Poll::Pending;
+        }
+        ready!(self.write.poll_reserve(cx)).map_err(|_| io::ErrorKind::BrokenPipe)?;
+        let size = buf.len().min(self.shared.options.frame_size).min(credit);
+        let (tx, rx) = oneshot::channel();
+        let id = self.id;
+        self.flow.written.fetch_add(size as u32, Ordering::AcqRel);
+        self.write
+            .send_item(Command::Frame(Frame {
+                cmd: 2,
+                id,
+                data: Bytes::copy_from_slice(&buf[..size]),
+                done: tx,
+            }))
+            .map_err(|_| io::ErrorKind::BrokenPipe)?;
+        self.pending = Some(rx);
+        self.dirty = true;
+        Poll::Ready(Ok(size))
+    }
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        self.poll_flush_barrier(cx)
+    }
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        if self.close.is_cancelled() {
+            self.stop();
+            return Poll::Ready(Ok(()));
+        }
+        ready!(self.poll_flush_barrier(cx))?;
+        self.stop();
+        Poll::Ready(Ok(()))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::time::Duration;
+
+    fn metered_peer(
+        options: Options,
+    ) -> (
+        Client,
+        impl Future<Output = ()> + Send,
+        tokio::io::DuplexStream,
+        Arc<FlushGateState>,
+    ) {
+        let (raw, peer) = tokio::io::duplex(4096);
+        let meter = Arc::new(FlushGateState::default());
+        meter.mode.store(1, Ordering::Release);
+        let (client, driver) = with_options(
+            Box::new(FlushGate {
+                raw,
+                state: meter.clone(),
+            }),
+            options,
+        )
+        .expect("valid memory receive fixture options");
+        (client, driver, peer, meter)
+    }
+
+    async fn drive_ready_once<F: Future<Output = ()>>(mut driver: Pin<&mut F>) -> io::Result<()> {
+        let result = std::future::poll_fn(|cx| {
+            let mut ready = std::pin::pin!(tokio::task::unconstrained(driver.as_mut()));
+            Poll::Ready(ready.as_mut().poll(cx))
+        })
+        .await;
+        if result.is_pending() {
+            Ok(())
+        } else {
+            Err(io::Error::other("memory smux driver ended unexpectedly"))
+        }
+    }
+
+    async fn open_memory_stream<F: Future<Output = ()>>(
+        client: &Client,
+        driver: Pin<&mut F>,
+        peer: &mut tokio::io::DuplexStream,
+    ) -> io::Result<(BoxStream, u32)> {
+        let mut opening = Box::pin(client.open());
+        if !futures_util::poll!(opening.as_mut()).is_pending() {
+            return Err(io::Error::other("stream opened before its SYN was driven"));
+        }
+        drive_ready_once(driver).await?;
+        let stream = opening.await?;
+        let mut syn = [0; 8];
+        peer.read_exact(&mut syn).await?;
+        let id = u32::from_le_bytes(syn[4..].try_into().unwrap());
+        if syn[..4] != [1, 0, 0, 0] || id % 2 != 1 {
+            return Err(io::Error::other(
+                "memory receive fixture saw an invalid SYN",
+            ));
+        }
+        Ok((stream, id))
+    }
+
+    fn memory_frame(wire: &mut Vec<u8>, cmd: u8, id: u32, data: &[u8]) {
+        wire.extend_from_slice(&[1, cmd]);
+        wire.extend_from_slice(&(data.len() as u16).to_le_bytes());
+        wire.extend_from_slice(&id.to_le_bytes());
+        wire.extend_from_slice(data);
+    }
+
+    async fn read_memory<F: Future<Output = ()>>(
+        stream: &mut BoxStream,
+        mut driver: Pin<&mut F>,
+        data: &mut [u8],
+    ) -> io::Result<()> {
+        let mut reading = Box::pin(stream.read_exact(data));
+        std::future::poll_fn(|cx| {
+            if let Poll::Ready(result) = reading.as_mut().poll(cx) {
+                return Poll::Ready(result.map(|_| ()));
+            }
+            let mut ready = std::pin::pin!(tokio::task::unconstrained(driver.as_mut()));
+            if ready.as_mut().poll(cx).is_ready() {
+                return Poll::Ready(Err(io::Error::other(
+                    "memory smux driver ended while reading",
+                )));
+            }
+            reading.as_mut().poll(cx).map(|result| result.map(|_| ()))
+        })
+        .await
+    }
+
+    async fn read_once(stream: &mut BoxStream, data: &mut [u8]) -> Poll<io::Result<usize>> {
+        let mut reading = Box::pin(stream.read(data));
+        futures_util::poll!(reading.as_mut())
+    }
+
+    async fn memory_peer_eof(peer: &mut tokio::io::DuplexStream) -> bool {
+        // Drain only a bounded amount of existing SYN/FIN control output.
+        let mut tail = Vec::new();
+        let mut bounded = peer.take(4097);
+        let ended =
+            tokio::time::timeout(Duration::from_secs(2), bounded.read_to_end(&mut tail)).await;
+        matches!(ended, Ok(Ok(_))) && tail.len() < 4097
+    }
+
+    #[tokio::test]
+    async fn ready_data_reader_yields_within_one_io_poll_budget() {
+        let (client, driver, mut peer, meter) = metered_peer(Options {
+            frame_size: 16 * 1024,
+            // Keep the legacy fixture wide enough not to mask missing fairness.
+            stream_buffer: 2 * 1024 * 1024,
+            ..Options::default()
+        });
+        let mut driver = Box::pin(driver);
+        let observed = tokio::time::timeout(Duration::from_secs(2), async {
+            let (stream, id) = open_memory_stream(&client, driver.as_mut(), &mut peer).await?;
+            let mut wire = Vec::new();
+            for value in 0..128_u8 {
+                memory_frame(&mut wire, 2, id, &[value]);
+            }
+            peer.write_all(&wire).await?;
+            let before = meter.read_bytes.load(Ordering::Acquire);
+            drive_ready_once(driver.as_mut()).await?;
+            let read_bytes = meter.read_bytes.load(Ordering::Acquire) - before;
+            drop(stream);
+            Ok::<_, io::Error>(read_bytes)
+        })
+        .await;
+        drop(driver);
+        let closed = client.shared.state.lock().unwrap().closed;
+        let eof = memory_peer_eof(&mut peer).await;
+        assert!(
+            closed && eof,
+            "reader fairness fixture did not close driver/peer"
+        );
+        let read_bytes = observed
+            .expect("reader fairness fixture watchdog expired")
+            .expect("reader fairness fixture failed before DATA observation");
+        assert!(
+            read_bytes >= 9,
+            "reader fairness fixture did not advance DATA"
+        );
+        let frames_read = read_bytes / 9;
+        assert!(
+            frames_read <= crate::limits::IO_POLL_BUDGET,
+            "ready smux DATA reader exceeded one IO poll budget: read {frames_read} complete frames"
+        );
+    }
+
+    #[tokio::test]
+    async fn unread_stream_does_not_block_sibling_data_and_fin() {
+        let (client, driver, mut peer, _meter) = metered_peer(Options::default());
+        let mut driver = Box::pin(driver);
+        let observed = tokio::time::timeout(Duration::from_secs(2), async {
+            let (unread, first) = open_memory_stream(&client, driver.as_mut(), &mut peer).await?;
+            let (mut sibling, second) =
+                open_memory_stream(&client, driver.as_mut(), &mut peer).await?;
+            let mut wire = Vec::new();
+            for value in b"abcde" {
+                memory_frame(&mut wire, 2, first, &[*value]);
+            }
+            memory_frame(&mut wire, 2, second, b"z");
+            memory_frame(&mut wire, 1, second, &[]);
+            peer.write_all(&wire).await?;
+            drive_ready_once(driver.as_mut()).await?;
+            let mut byte = [0];
+            let progressed = match read_once(&mut sibling, &mut byte).await {
+                Poll::Pending => false,
+                Poll::Ready(Ok(1)) => true,
+                _ => return Err(io::Error::other("sibling ended before its queued DATA")),
+            };
+            let eof = if progressed {
+                matches!(read_once(&mut sibling, &mut [0]).await, Poll::Ready(Ok(0)))
+            } else {
+                false
+            };
+            drop((unread, sibling));
+            Ok::<_, io::Error>((progressed, byte, eof))
+        })
+        .await;
+        drop(driver);
+        let closed = client.shared.state.lock().unwrap().closed;
+        let eof = memory_peer_eof(&mut peer).await;
+        assert!(closed && eof, "sibling fixture did not close driver/peer");
+        let (progressed, byte, sibling_eof) = observed
+            .expect("sibling fixture watchdog expired")
+            .expect("sibling fixture failed before receive observation");
+        assert!(!progressed || byte == *b"z", "sibling DATA content changed");
+        assert!(
+            progressed && sibling_eof,
+            "unread smux stream blocked sibling DATA/FIN despite spare connection budget"
+        );
+    }
+
+    #[tokio::test]
+    async fn receive_storage_budget_bounds_tiny_frames_and_waits_for_full_consumption() {
+        let quota = 512;
+        let (client, driver, mut peer, meter) = metered_peer(Options {
+            frame_size: 128,
+            receive_buffer: quota,
+            stream_buffer: quota,
+            ..Options::default()
+        });
+        let mut driver = Box::pin(driver);
+        let observed = tokio::time::timeout(Duration::from_secs(2), async {
+            let (mut stream, id) = open_memory_stream(&client, driver.as_mut(), &mut peer).await?;
+            let mut wire = Vec::new();
+            for value in 0..256_usize {
+                memory_frame(&mut wire, 2, id, &[value as u8]);
+            }
+            peer.write_all(&wire).await?;
+            for _ in 0..16 {
+                drive_ready_once(driver.as_mut()).await?;
+            }
+            let before = meter.read_bytes.load(Ordering::Acquire);
+            drive_ready_once(driver.as_mut()).await?;
+            let idle = meter.read_bytes.load(Ordering::Acquire);
+            let mut byte = [0];
+            read_memory(&mut stream, driver.as_mut(), &mut byte).await?;
+            let mut valid = byte == [0];
+            drive_ready_once(driver.as_mut()).await?;
+            let after_one = meter.read_bytes.load(Ordering::Acquire);
+            for expected in 1..256_usize {
+                read_memory(&mut stream, driver.as_mut(), &mut byte).await?;
+                valid &= byte == [expected as u8];
+            }
+            let mut next = Vec::new();
+            memory_frame(&mut next, 2, id, &vec![b'p'; quota]);
+            memory_frame(&mut next, 2, id, b"q");
+            peer.write_all(&next).await?;
+            for _ in 0..4 {
+                drive_ready_once(driver.as_mut()).await?;
+            }
+            let before_partial = meter.read_bytes.load(Ordering::Acquire);
+            read_memory(&mut stream, driver.as_mut(), &mut byte).await?;
+            valid &= byte == *b"p";
+            for _ in 0..4 {
+                drive_ready_once(driver.as_mut()).await?;
+            }
+            let after_partial = meter.read_bytes.load(Ordering::Acquire);
+            let mut rest = vec![0; quota - 1];
+            read_memory(&mut stream, driver.as_mut(), &mut rest).await?;
+            valid &= rest.iter().all(|value| *value == b'p');
+            for _ in 0..4 {
+                drive_ready_once(driver.as_mut()).await?;
+            }
+            let after_full = meter.read_bytes.load(Ordering::Acquire);
+            read_memory(&mut stream, driver.as_mut(), &mut byte).await?;
+            valid &= byte == *b"q";
+            drop(stream);
+            Ok::<_, io::Error>((
+                valid,
+                before,
+                idle,
+                after_one,
+                wire.len(),
+                before_partial,
+                after_partial,
+                after_full,
+            ))
+        })
+        .await;
+        drop(driver);
+        let closed = client.shared.state.lock().unwrap().closed;
+        let eof = memory_peer_eof(&mut peer).await;
+        assert!(
+            closed && eof,
+            "receive budget fixture did not close driver/peer"
+        );
+        let (valid, before, idle, after_one, input, before_partial, after_partial, after_full) =
+            observed
+                .expect("receive budget fixture watchdog expired")
+                .expect("receive budget fixture failed before observations");
+        assert!(
+            valid && before >= 9,
+            "receive budget fixture changed or did not receive DATA"
+        );
+        let storage_floor = std::mem::size_of::<Packet>() + 1;
+        let retained_before = before / 9;
+        let retained_after = (after_one / 9).saturating_sub(1);
+        assert!(
+            before < input
+                && idle == before
+                && retained_before * storage_floor <= quota
+                && retained_after * storage_floor <= quota,
+            "small smux frames bypassed the connection receive storage budget"
+        );
+        assert!(
+            after_one > before,
+            "consuming a frame did not restore receive progress"
+        );
+        assert_eq!(
+            after_partial, before_partial,
+            "partially read smux frame returned its backing budget early"
+        );
+        assert!(
+            after_full > after_partial,
+            "draining a frame did not release its receive budget"
+        );
+    }
+
+    #[tokio::test]
+    async fn local_shutdown_releases_queued_budget_while_remote_fin_preserves_data() {
+        let quota = 512;
+        let (client, driver, mut peer, meter) = metered_peer(Options {
+            frame_size: 128,
+            receive_buffer: quota,
+            stream_buffer: quota,
+            ..Options::default()
+        });
+        let mut driver = Box::pin(driver);
+        let observed = tokio::time::timeout(Duration::from_secs(2), async {
+            let (mut stopped, first) =
+                open_memory_stream(&client, driver.as_mut(), &mut peer).await?;
+            let (mut remote, second) =
+                open_memory_stream(&client, driver.as_mut(), &mut peer).await?;
+            let (mut next, third) = open_memory_stream(&client, driver.as_mut(), &mut peer).await?;
+            let mut wire = Vec::new();
+            memory_frame(&mut wire, 2, first, &vec![b'a'; quota]);
+            memory_frame(&mut wire, 2, second, &vec![b'b'; quota]);
+            memory_frame(&mut wire, 1, second, &[]);
+            memory_frame(&mut wire, 2, third, b"z");
+            peer.write_all(&wire).await?;
+            for _ in 0..4 {
+                drive_ready_once(driver.as_mut()).await?;
+            }
+            let before = meter.read_bytes.load(Ordering::Acquire);
+            stopped.shutdown().await?;
+            for _ in 0..4 {
+                drive_ready_once(driver.as_mut()).await?;
+            }
+            let after = meter.read_bytes.load(Ordering::Acquire);
+            let fin_seen = !client
+                .shared
+                .state
+                .lock()
+                .unwrap()
+                .streams
+                .contains_key(&second);
+            let mut byte = [0];
+            let next_blocked = matches!(read_once(&mut next, &mut byte).await, Poll::Pending);
+            let mut data_valid = false;
+            let mut remote_eof = false;
+            let mut next_ready = false;
+            if fin_seen {
+                let mut data = vec![0; quota];
+                read_memory(&mut remote, driver.as_mut(), &mut data).await?;
+                data_valid = data.iter().all(|value| *value == b'b');
+                remote_eof = matches!(read_once(&mut remote, &mut [0]).await, Poll::Ready(Ok(0)));
+                for _ in 0..4 {
+                    drive_ready_once(driver.as_mut()).await?;
+                }
+                next_ready = matches!(read_once(&mut next, &mut byte).await, Poll::Ready(Ok(1)))
+                    && byte == *b"z";
+            }
+            // Retain the shutdown stream throughout the release observation.
+            drop((stopped, remote, next));
+            Ok::<_, io::Error>((
+                after > before && fin_seen,
+                next_blocked,
+                data_valid,
+                remote_eof,
+                next_ready,
+            ))
+        })
+        .await;
+        drop(driver);
+        let closed = client.shared.state.lock().unwrap().closed;
+        let eof = memory_peer_eof(&mut peer).await;
+        assert!(
+            closed && eof,
+            "shutdown budget fixture did not close driver/peer"
+        );
+        let (released, blocked, valid, remote_eof, resumed) = observed
+            .expect("shutdown budget fixture watchdog expired")
+            .expect("shutdown budget fixture failed before observations");
+        assert!(
+            blocked,
+            "remote FIN returned queued DATA budget before consumption"
+        );
+        assert!(
+            released,
+            "local smux shutdown retained queued budget while its stream was held"
+        );
+        assert!(
+            valid && remote_eof,
+            "remote FIN discarded queued DATA or failed to end after draining"
+        );
+        assert!(
+            resumed,
+            "draining the remote FIN stream did not restore sibling progress"
+        );
+    }
+
+    #[tokio::test]
+    async fn shutdown_after_driver_exit_releases_a_retained_stream_receiver() {
+        let (client, driver, mut peer, _meter) = metered_peer(Options::default());
+        let mut driver = Box::pin(driver);
+        let setup = tokio::time::timeout(Duration::from_secs(2), async {
+            let (stream, id) = open_memory_stream(&client, driver.as_mut(), &mut peer).await?;
+            let sender = client.shared.state.lock().unwrap().streams[&id]
+                .receive
+                .clone();
+            let mut wire = Vec::new();
+            memory_frame(&mut wire, 2, id, b"queued");
+            peer.write_all(&wire).await?;
+            drive_ready_once(driver.as_mut()).await?;
+            Ok::<_, io::Error>((stream, sender))
+        })
+        .await;
+        drop(driver);
+        let closed = client.shared.state.lock().unwrap().closed;
+        let eof = memory_peer_eof(&mut peer).await;
+        let (mut stream, sender) = setup
+            .expect("driver-exit fixture watchdog expired")
+            .expect("driver-exit fixture failed before receive observation");
+        let shutdown = tokio::time::timeout(Duration::from_secs(2), stream.shutdown()).await;
+        let released = sender.is_closed();
+        drop((stream, sender));
+        assert!(
+            closed && eof,
+            "driver-exit fixture did not close driver/peer"
+        );
+        assert!(
+            matches!(shutdown, Ok(Ok(()))),
+            "cancelled stream shutdown did not complete"
+        );
+        assert!(
+            released,
+            "shutdown after driver exit retained its receive queue"
+        );
+    }
+
+    #[tokio::test]
+    async fn small_legal_receive_quotas_allow_a_whole_frame_and_continue() {
+        for quota in [1, 63, 512] {
+            let (client, driver, mut peer, meter) = metered_peer(Options {
+                frame_size: quota,
+                receive_buffer: quota,
+                stream_buffer: quota,
+                ..Options::default()
+            });
+            let mut driver = Box::pin(driver);
+            let observed = tokio::time::timeout(Duration::from_secs(2), async {
+                let (mut stream, id) =
+                    open_memory_stream(&client, driver.as_mut(), &mut peer).await?;
+                let mut wire = Vec::new();
+                memory_frame(&mut wire, 2, id, &vec![b'a'; quota]);
+                memory_frame(&mut wire, 2, id, &vec![b'b'; quota]);
+                peer.write_all(&wire).await?;
+                for _ in 0..4 {
+                    drive_ready_once(driver.as_mut()).await?;
+                }
+                let before = meter.read_bytes.load(Ordering::Acquire);
+                let mut first = vec![0; quota];
+                read_memory(&mut stream, driver.as_mut(), &mut first).await?;
+                for _ in 0..4 {
+                    drive_ready_once(driver.as_mut()).await?;
+                }
+                let after = meter.read_bytes.load(Ordering::Acquire);
+                let mut second = vec![0; quota];
+                read_memory(&mut stream, driver.as_mut(), &mut second).await?;
+                let valid = first.iter().all(|value| *value == b'a')
+                    && second.iter().all(|value| *value == b'b');
+                drop(stream);
+                Ok::<_, io::Error>((before >= quota + 8, after > before, valid))
+            })
+            .await;
+            drop(driver);
+            let closed = client.shared.state.lock().unwrap().closed;
+            let eof = memory_peer_eof(&mut peer).await;
+            assert!(
+                closed && eof,
+                "small quota fixture did not close driver/peer"
+            );
+            let (received, resumed, valid) = observed
+                .expect("small quota fixture watchdog expired")
+                .expect("small quota fixture rejected or stalled a legal whole frame");
+            assert!(
+                received && resumed && valid,
+                "legal smux receive quota {quota} did not progress"
+            );
+        }
+    }
+
+    #[derive(Default)]
+    struct FlushGateState {
+        // 0: blocked; 1: successful physical flush; 2: physical error.
+        mode: std::sync::atomic::AtomicU8,
+        flushes: std::sync::atomic::AtomicUsize,
+        read_bytes: std::sync::atomic::AtomicUsize,
+        changed: AtomicWaker,
+    }
+    struct FlushGate {
+        raw: tokio::io::DuplexStream,
+        state: Arc<FlushGateState>,
+    }
+    impl AsyncRead for FlushGate {
+        fn poll_read(
+            mut self: Pin<&mut Self>,
+            cx: &mut Context<'_>,
+            out: &mut ReadBuf<'_>,
+        ) -> Poll<io::Result<()>> {
+            let before = out.filled().len();
+            let result = Pin::new(&mut self.raw).poll_read(cx, out);
+            let count = out.filled().len() - before;
+            if count != 0 {
+                self.state.read_bytes.fetch_add(count, Ordering::AcqRel);
+            }
+            result
+        }
+    }
+    impl AsyncWrite for FlushGate {
+        fn poll_write(
+            mut self: Pin<&mut Self>,
+            cx: &mut Context<'_>,
+            data: &[u8],
+        ) -> Poll<io::Result<usize>> {
+            Pin::new(&mut self.raw).poll_write(cx, data)
+        }
+        fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            self.state.changed.register(cx.waker());
+            match self.state.mode.load(Ordering::Acquire) {
+                0 => Poll::Pending,
+                2 => Poll::Ready(Err(io::ErrorKind::ConnectionReset.into())),
+                _ => {
+                    ready!(Pin::new(&mut self.raw).poll_flush(cx))?;
+                    self.state.flushes.fetch_add(1, Ordering::AcqRel);
+                    Poll::Ready(Ok(()))
+                }
+            }
+        }
+        fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Pin::new(&mut self.raw).poll_shutdown(cx)
+        }
+    }
+
+    #[tokio::test]
+    async fn autonomous_data_keeps_explicit_flush_strong_and_cancelled_barrier_unique() {
+        tokio::time::timeout(Duration::from_secs(2), async {
+            let (raw, mut peer) = tokio::io::duplex(1024);
+            let gate = Arc::new(FlushGateState::default());
+            gate.mode.store(1, Ordering::Release);
+            let (client, driver) = new_with_autonomous_writes(
+                Box::new(FlushGate {
+                    raw,
+                    state: gate.clone(),
+                }),
+                true,
+            );
+            let mut driver = Box::pin(driver);
+            let mut opening = Box::pin(client.open());
+            assert!(futures_util::poll!(opening.as_mut()).is_pending());
+            assert!(futures_util::poll!(driver.as_mut()).is_pending());
+            let mut stream = opening.await.unwrap();
+            let mut syn = [0; 8];
+            peer.read_exact(&mut syn).await.unwrap();
+            assert_eq!(gate.flushes.load(Ordering::Acquire), 1);
+
+            gate.mode.store(0, Ordering::Release);
+            for payload in [b"one", b"two"] {
+                stream.write_all(payload).await.unwrap();
+                assert!(futures_util::poll!(driver.as_mut()).is_pending());
+            }
+            let mut wire = [0; 22];
+            peer.read_exact(&mut wire).await.unwrap();
+            assert_eq!(&wire[..4], &[1, 2, 3, 0]);
+            assert_eq!(&wire[8..11], b"one");
+            assert_eq!(&wire[11..15], &[1, 2, 3, 0]);
+            assert_eq!(&wire[19..], b"two");
+            assert_eq!(
+                gate.flushes.load(Ordering::Acquire),
+                1,
+                "accepted DATA must not require a successful physical flush"
+            );
+
+            let mut first_flush = Box::pin(stream.flush());
+            assert!(futures_util::poll!(first_flush.as_mut()).is_pending());
+            assert!(futures_util::poll!(driver.as_mut()).is_pending());
+            drop(first_flush);
+            let mut resumed_flush = Box::pin(stream.flush());
+            assert!(futures_util::poll!(resumed_flush.as_mut()).is_pending());
+            assert_eq!(
+                client.write.capacity(),
+                crate::limits::SING_MUX_COMMAND_QUEUE,
+                "retrying must retain the in-flight barrier, not queue another"
+            );
+            gate.mode.store(1, Ordering::Release);
+            gate.changed.wake();
+            assert!(futures_util::poll!(driver.as_mut()).is_pending());
+            resumed_flush.await.unwrap();
+            assert_eq!(gate.flushes.load(Ordering::Acquire), 2);
+        })
+        .await
+        .unwrap();
+    }
+
+    #[tokio::test]
+    async fn autonomous_shutdown_orders_flush_before_fin_and_stop_releases_waiters() {
+        tokio::time::timeout(Duration::from_secs(2), async {
+            for outcome in [1, 2, 3] {
+                let (raw, mut peer) = tokio::io::duplex(1024);
+                let gate = Arc::new(FlushGateState::default());
+                gate.mode.store(1, Ordering::Release);
+                let (client, driver) = new_with_autonomous_writes(
+                    Box::new(FlushGate {
+                        raw,
+                        state: gate.clone(),
+                    }),
+                    true,
+                );
+                let mut driver = Some(Box::pin(driver));
+                let mut opening = Box::pin(client.open());
+                assert!(futures_util::poll!(opening.as_mut()).is_pending());
+                assert!(futures_util::poll!(driver.as_mut().unwrap().as_mut()).is_pending());
+                let mut stream = opening.await.unwrap();
+                let mut syn = [0; 8];
+                peer.read_exact(&mut syn).await.unwrap();
+                gate.mode.store(0, Ordering::Release);
+                stream.write_all(b"one").await.unwrap();
+                assert!(futures_util::poll!(driver.as_mut().unwrap().as_mut()).is_pending());
+                let mut shutdown = Box::pin(stream.shutdown());
+                assert!(futures_util::poll!(shutdown.as_mut()).is_pending());
+                assert!(futures_util::poll!(driver.as_mut().unwrap().as_mut()).is_pending());
+                let mut frame = [0; 11];
+                peer.read_exact(&mut frame).await.unwrap();
+                assert_eq!(&frame[..4], &[1, 2, 3, 0]);
+                assert_eq!(&frame[8..], b"one");
+                {
+                    let mut next = [0];
+                    let reading = peer.read(&mut next);
+                    tokio::pin!(reading);
+                    assert!(
+                        futures_util::poll!(reading.as_mut()).is_pending(),
+                        "FIN must not overtake a pending explicit payload flush"
+                    );
+                }
+                if outcome == 3 {
+                    // This is the node owner's cancellation boundary: dropping
+                    // its one driver closes both halves and all logical waiters.
+                    drop(driver.take());
+                } else {
+                    gate.mode.store(outcome, Ordering::Release);
+                    gate.changed.wake();
+                    assert_eq!(
+                        futures_util::poll!(driver.as_mut().unwrap().as_mut()).is_ready(),
+                        outcome == 2
+                    );
+                }
+                let shutdown_result = shutdown.await;
+                if outcome == 1 {
+                    assert!(shutdown_result.is_ok());
+                    assert!(futures_util::poll!(driver.as_mut().unwrap().as_mut()).is_pending());
+                    let mut fin = [0; 8];
+                    peer.read_exact(&mut fin).await.unwrap();
+                    assert_eq!(&fin[..4], &[1, 1, 0, 0]);
+                    assert_eq!(&fin[4..], &syn[4..]);
+                    assert_eq!(gate.flushes.load(Ordering::Acquire), 3);
+                } else {
+                    // Driver exit already cancels the stream, so shutdown
+                    // may be idempotent while explicit flush still fails.
+                    assert!(stream.flush().await.is_err());
+                    assert!(client.shared.state.lock().unwrap().closed);
+                    assert!(client.open().await.is_err());
+                }
+                drop(stream);
+                drop(driver);
+            }
+        })
+        .await
+        .unwrap();
+    }
+
+    #[tokio::test]
+    async fn concurrent_frames_share_one_real_flush_and_never_ack_early() {
+        tokio::time::timeout(Duration::from_secs(2), async {
+            // Exercise physical success, physical flush error and owner Stop
+            // after all queued payloads have been written but not flushed.
+            for outcome in [1, 2, 3] {
+                let (raw, mut peer) = tokio::io::duplex(1024);
+                let gate = Arc::new(FlushGateState::default());
+                gate.mode.store(1, Ordering::Release);
+                let (client, driver) = new(Box::new(FlushGate {
+                    raw,
+                    state: gate.clone(),
+                }));
+                let mut driver = Some(Box::pin(driver));
+                let mut openings = (0..3).map(|_| Box::pin(client.open())).collect::<Vec<_>>();
+                for opening in &mut openings {
+                    assert!(futures_util::poll!(opening.as_mut()).is_pending());
+                }
+                assert!(futures_util::poll!(driver.as_mut().unwrap().as_mut()).is_pending());
+                let mut streams = Vec::new();
+                for opening in openings {
+                    streams.push(opening.await.unwrap());
+                }
+                assert_eq!(gate.flushes.load(Ordering::Acquire), 1);
+                let mut syn = [0; 24];
+                peer.read_exact(&mut syn).await.unwrap();
+                for (index, header) in syn.chunks_exact(8).enumerate() {
+                    assert_eq!(&header[..4], &[1, 0, 0, 0]);
+                    assert_eq!(
+                        u32::from_le_bytes(header[4..].try_into().unwrap()),
+                        3 + index as u32 * 2
+                    );
+                }
+                gate.mode.store(0, Ordering::Release);
+                // The physical driver is not spawned: all three logical
+                // writes are deterministically ready before it is polled.
+                for stream in &mut streams {
+                    stream.write_all(b"one").await.unwrap();
+                }
+                assert!(futures_util::poll!(driver.as_mut().unwrap().as_mut()).is_pending());
+                for stream in &mut streams {
+                    let flush = stream.flush();
+                    tokio::pin!(flush);
+                    assert!(futures_util::poll!(flush.as_mut()).is_pending());
+                }
+                assert_eq!(gate.flushes.load(Ordering::Acquire), 1);
+                let mut wire = [0; 33];
+                peer.read_exact(&mut wire).await.unwrap();
+                for (index, frame) in wire.chunks_exact(11).enumerate() {
+                    assert_eq!(&frame[..4], &[1, 2, 3, 0]);
+                    assert_eq!(
+                        u32::from_le_bytes(frame[4..8].try_into().unwrap()),
+                        3 + index as u32 * 2
+                    );
+                    assert_eq!(&frame[8..], b"one");
+                }
+                if outcome == 3 {
+                    drop(driver.take());
+                } else {
+                    gate.mode.store(outcome, Ordering::Release);
+                    gate.changed.wake();
+                    assert_eq!(
+                        futures_util::poll!(driver.as_mut().unwrap().as_mut()).is_ready(),
+                        outcome == 2
+                    );
+                }
+                for stream in &mut streams {
+                    assert_eq!(stream.flush().await.is_ok(), outcome == 1);
+                }
+                assert_eq!(
+                    gate.flushes.load(Ordering::Acquire),
+                    if outcome == 1 { 2 } else { 1 }
+                );
+                if outcome != 1 {
+                    assert!(client.open().await.is_err());
+                }
+                drop(streams);
+                drop(driver);
+            }
+        })
+        .await
+        .unwrap();
+    }
+
+    #[tokio::test]
+    async fn shutdown_flushes_the_pending_frame_before_fin() {
+        tokio::time::timeout(Duration::from_secs(2), async {
+            let (raw, mut peer) = tokio::io::duplex(16);
+            let (client, driver) = new(Box::new(raw));
+            let task = tokio::spawn(driver);
+            let mut stream = client.open().await.unwrap();
+            let mut syn = [0; 8];
+            peer.read_exact(&mut syn).await.unwrap();
+            let receive = tokio::spawn(async move {
+                let mut received = Vec::new();
+                loop {
+                    let mut header = [0; 8];
+                    peer.read_exact(&mut header).await.unwrap();
+                    assert_eq!(&header[4..], &syn[4..]);
+                    if header[1] == 1 {
+                        break;
+                    }
+                    assert_eq!(header[1], 2);
+                    let size = u16::from_le_bytes([header[2], header[3]]) as usize;
+                    let mut data = vec![0; size];
+                    peer.read_exact(&mut data).await.unwrap();
+                    received.extend(data);
+                }
+                received
+            });
+            let payload = vec![b'x'; 1024];
+            stream.write_all(&payload).await.unwrap();
+            stream.shutdown().await.unwrap();
+            let received = receive.await.unwrap();
+            task.await.unwrap();
+            assert_eq!(received.len(), payload.len());
+            assert_eq!(received, payload);
+        })
+        .await
+        .unwrap();
+    }
+
+    #[tokio::test]
+    async fn malformed_smux_headers_close_the_owned_driver_before_reading_a_body() {
+        for (version, command, length) in [(2, 2, 0), (1, 0, 0), (1, 4, 0), (1, 1, 1), (1, 3, 1)] {
+            tokio::time::timeout(Duration::from_secs(1), async {
+                let (raw, mut peer) = tokio::io::duplex(64);
+                let (client, driver) = new(Box::new(raw));
+                let task = tokio::spawn(driver);
+                let mut logical = client.open().await.unwrap();
+                let mut syn = [0; 8];
+                peer.read_exact(&mut syn).await.unwrap();
+                assert_eq!(syn, [1, 0, 0, 0, 3, 0, 0, 0]);
+                // No body is supplied: malformed control framing must terminate
+                // immediately rather than waiting for attacker-controlled data.
+                peer.write_all(&[version, command, length, 0, 3, 0, 0, 0])
+                    .await
+                    .unwrap();
+                task.await.unwrap();
+                assert_eq!(logical.read(&mut [0]).await.unwrap(), 0);
+                assert!(logical.write_all(b"closed").await.is_err());
+                assert!(client.open().await.is_err());
+            })
+            .await
+            .unwrap();
+        }
+    }
+}
+
+#[cfg(test)]
+mod version_two_tests {
+    use super::*;
+    #[tokio::test]
+    async fn v2_zero_credit_streams_leave_shared_send_capacity_available() {
+        use std::{future::poll_fn, time::Duration};
+        fn frame(command: u8, id: u32, data: &[u8]) -> Vec<u8> {
+            let mut wire = vec![2, command];
+            wire.extend_from_slice(&(data.len() as u16).to_le_bytes());
+            wire.extend_from_slice(&id.to_le_bytes());
+            wire.extend_from_slice(data);
+            wire
+        }
+        let (raw, mut peer) = tokio::io::duplex(64 * 1024);
+        let (client, driver) = with_options(
+            Box::new(raw),
+            Options {
+                version: 2,
+                ..Default::default()
+            },
+        )
+        .unwrap();
+        let mut driver = tokio::spawn(driver);
+        let result = tokio::time::timeout(Duration::from_secs(2), async {
+            let mut streams = Vec::new();
+            let mut ids = Vec::new();
+            for _ in 0..=crate::limits::SING_MUX_COMMAND_QUEUE {
+                streams.push(client.open().await?);
+                let mut syn = [0; 8];
+                peer.read_exact(&mut syn).await?;
+                ids.push(u32::from_le_bytes(syn[4..].try_into().unwrap()));
+            }
+            let mut healthy = streams.pop().unwrap();
+            let normal_id = *ids.last().unwrap();
+            for &id in &ids[..streams.len()] {
+                peer.write_all(&frame(4, id, &[0; 8])).await?;
+            }
+            // Reading a later PSH proves all preceding zero-window UPDs parsed.
+            peer.write_all(&frame(2, normal_id, b"r")).await?;
+            let mut marker = [0];
+            healthy.read_exact(&mut marker).await?;
+            let mut update = [0; 16];
+            peer.read_exact(&mut update).await?; // Drain the marker's own UPD.
+            let mut held: Vec<_> = streams
+                .iter_mut()
+                .map(|stream| Box::pin(stream.write_all(b"x")))
+                .collect();
+            let all_pending = poll_fn(|cx| {
+                Poll::Ready(
+                    held.iter_mut()
+                        .map(|write| write.as_mut().poll(cx).is_pending())
+                        .all(|p| p),
+                )
+            })
+            .await;
+            let normal = tokio::time::timeout(Duration::from_millis(150), async {
+                healthy.write_all(b"h").await?;
+                healthy.flush().await?;
+                let mut wire = [0; 9];
+                peer.read_exact(&mut wire).await?;
+                Ok::<_, io::Error>(wire)
+            })
+            .await;
+            // A real UPD must still wake and permit a previously blocked writer.
+            peer.write_all(&frame(4, ids[0], &[0, 0, 0, 0, 1, 0, 0, 0]))
+                .await?;
+            let restored = tokio::time::timeout(Duration::from_millis(150), async {
+                held[0].as_mut().await?;
+                let mut wire = [0; 9];
+                peer.read_exact(&mut wire).await?;
+                Ok::<_, io::Error>(wire)
+            })
+            .await;
+            // Invalid peer framing ends the actual driver and wakes zero-credit writers.
+            peer.write_all(&[9, 0, 0, 0, 0, 0, 0, 0]).await?;
+            let stopped = tokio::time::timeout(Duration::from_millis(150), held[1].as_mut()).await;
+            drop(held);
+            drop(streams);
+            drop(healthy);
+            Ok::<_, io::Error>((
+                all_pending,
+                marker,
+                update,
+                normal,
+                restored,
+                stopped,
+                frame(2, normal_id, b"h"),
+                frame(2, ids[0], b"x"),
+            ))
+        })
+        .await;
+        // Both timeout/error paths drop held writes and streams before joining.
+        drop(client);
+        drop(peer);
+        let joined = tokio::time::timeout(Duration::from_secs(1), &mut driver).await;
+        if joined.is_err() {
+            driver.abort();
+            let _ = driver.await;
+        }
+        assert!(
+            joined.is_ok_and(|result| result.is_ok()),
+            "smux driver did not join"
+        );
+        let (pending, marker, update, normal, restored, stopped, expected, resumed) = result
+            .expect("memory fixture timed out")
+            .expect("memory fixture IO failed");
+        assert!(pending, "zero-window writes were unexpectedly accepted");
+        assert_eq!(&marker, b"r");
+        assert_eq!(&update[..2], &[2, 4]);
+        assert_eq!(
+            normal
+                .expect("healthy stream blocked by zero-credit streams")
+                .unwrap()
+                .as_slice(),
+            expected
+        );
+        assert_eq!(
+            restored
+                .expect("UPD did not wake the blocked writer")
+                .unwrap()
+                .as_slice(),
+            resumed
+        );
+        assert!(
+            matches!(stopped, Ok(Err(error)) if error.kind() == io::ErrorKind::BrokenPipe),
+            "driver close did not reject a zero-credit write"
+        );
+    }
+    #[tokio::test]
+    async fn v2_updates_open_credit_and_acknowledge_consumed_bytes() {
+        tokio::time::timeout(std::time::Duration::from_secs(2), async {
+            let (raw, mut peer) = tokio::io::duplex(31);
+            let (client, driver) = with_options(
+                Box::new(raw),
+                Options {
+                    version: 2,
+                    ..Default::default()
+                },
+            )
+            .unwrap();
+            let driver = tokio::spawn(driver);
+            let mut stream = client.open().await.unwrap();
+            let mut syn = [0; 8];
+            peer.read_exact(&mut syn).await.unwrap();
+            assert_eq!(syn, [2, 0, 0, 0, 3, 0, 0, 0]);
+            peer.write_all(&[2, 4, 8, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0])
+                .await
+                .unwrap();
+            tokio::task::yield_now().await;
+            assert_eq!(stream.write(b"payload").await.unwrap(), 4);
+            let mut sent = [0; 12];
+            peer.read_exact(&mut sent).await.unwrap();
+            assert_eq!(&sent[8..], b"payl");
+            stream.flush().await.unwrap();
+            peer.write_all(&[2, 2, 3, 0, 3, 0, 0, 0, b'a', b'c', b'k'])
+                .await
+                .unwrap();
+            let mut read = [0; 3];
+            stream.read_exact(&mut read).await.unwrap();
+            assert_eq!(&read, b"ack");
+            let mut update = [0; 16];
+            peer.read_exact(&mut update).await.unwrap();
+            assert_eq!(&update[..8], &[2, 4, 8, 0, 3, 0, 0, 0]);
+            assert_eq!(&update[8..12], &3u32.to_le_bytes());
+            drop(stream);
+            drop(client);
+            drop(peer);
+            driver.await.unwrap();
+        })
+        .await
+        .unwrap();
+    }
+}
diff --git a/src/transport/ss_framed.rs b/src/transport/ss_framed.rs
new file mode 100644
index 0000000..d8b0d7b
--- /dev/null
+++ b/src/transport/ss_framed.rs
@@ -0,0 +1,474 @@
+//! Bounded adapters for simple-obfs and v2ray-plugin's single mux channel.
+//! These are protocol encoders, not full TLS or a general V2Ray multiplexer.
+use crate::dispatch::BoxStream;
+use bytes::{Buf, Bytes};
+use std::{
+    io,
+    pin::Pin,
+    task::{Context, Poll, ready},
+};
+use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+const CHUNK: usize = 16 * 1024;
+
+pub(crate) enum Kind {
+    Http { host: String, port: u16 },
+    Tls { host: String },
+    V2rayMux,
+}
+pub(crate) fn wrap(raw: BoxStream, kind: Kind) -> BoxStream {
+    Box::new(Framed {
+        raw,
+        kind,
+        first_write: true,
+        first_read: true,
+        write: Bytes::new(),
+        head: Vec::new(),
+        remaining: 0,
+        eof: false,
+        closing: false,
+    })
+}
+struct Framed {
+    raw: BoxStream,
+    kind: Kind,
+    first_write: bool,
+    first_read: bool,
+    write: Bytes,
+    head: Vec<u8>,
+    remaining: usize,
+    eof: bool,
+    closing: bool,
+}
+fn invalid() -> io::Error {
+    io::Error::new(
+        io::ErrorKind::InvalidData,
+        "invalid Shadowsocks plugin frame",
+    )
+}
+impl Framed {
+    fn drain(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        for _ in 0..crate::limits::IO_POLL_BUDGET {
+            if self.write.is_empty() {
+                return Poll::Ready(Ok(()));
+            }
+            let n = ready!(Pin::new(&mut self.raw).poll_write(cx, &self.write))?;
+            if n == 0 {
+                return Poll::Ready(Err(io::ErrorKind::WriteZero.into()));
+            }
+            self.write.advance(n);
+        }
+        cx.waker().wake_by_ref();
+        Poll::Pending
+    }
+    fn encode(&mut self, input: &[u8]) -> io::Result<usize> {
+        let n = input.len().min(CHUNK);
+        let input = &input[..n];
+        let mut wire = Vec::with_capacity(n + 512);
+        match &self.kind {
+            Kind::Http { host, port } if self.first_write => {
+                use base64::Engine;
+                let mut nonce = [0; 16];
+                rand::fill(&mut nonce);
+                let authority = if host.contains(':') {
+                    format!("[{host}]")
+                } else {
+                    host.clone()
+                };
+                let authority = if *port == 80 {
+                    authority
+                } else {
+                    format!("{authority}:{port}")
+                };
+                let key = base64::engine::general_purpose::URL_SAFE.encode(nonce);
+                wire.extend_from_slice(format!("GET / HTTP/1.1\r\nHost: {authority}\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Key: {key}\r\nContent-Length: {n}\r\n\r\n").as_bytes());
+            }
+            Kind::Http { .. } => {}
+            Kind::Tls { host } if self.first_write => {
+                wire = client_hello(input, host)?;
+            }
+            Kind::Tls { .. } => {
+                wire.extend_from_slice(&[23, 3, 3]);
+                wire.extend_from_slice(&(n as u16).to_be_bytes());
+            }
+            Kind::V2rayMux => {
+                if self.first_write {
+                    wire.extend_from_slice(&[0, 12, 0, 0, 1, 0, 1, 0, 0, 1, 127, 0, 0, 1]);
+                }
+                wire.extend_from_slice(&[0, 4, 0, 0, 2, 1]);
+                wire.extend_from_slice(&(n as u16).to_be_bytes());
+            }
+        }
+        if !matches!(self.kind, Kind::Tls { .. }) || !self.first_write {
+            wire.extend_from_slice(input);
+        }
+        self.first_write = false;
+        self.write = wire.into();
+        Ok(n)
+    }
+    fn read_head(&mut self, cx: &mut Context<'_>, target: usize) -> Poll<io::Result<bool>> {
+        if target > 16 * 1024 {
+            return Poll::Ready(Err(invalid()));
+        }
+        for _ in 0..crate::limits::IO_POLL_BUDGET {
+            if self.head.len() >= target {
+                return Poll::Ready(Ok(true));
+            }
+            let mut scratch = [0; 512];
+            let count = (target - self.head.len()).min(scratch.len());
+            let mut output = ReadBuf::new(&mut scratch[..count]);
+            ready!(Pin::new(&mut self.raw).poll_read(cx, &mut output))?;
+            if output.filled().is_empty() {
+                return if self.head.is_empty() {
+                    Poll::Ready(Ok(false))
+                } else {
+                    Poll::Ready(Err(io::ErrorKind::UnexpectedEof.into()))
+                };
+            }
+            self.head.extend_from_slice(output.filled());
+        }
+        cx.waker().wake_by_ref();
+        Poll::Pending
+    }
+    fn next_frame(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        match &self.kind {
+            Kind::Http { .. } => {
+                if !self.first_read {
+                    self.remaining = usize::MAX;
+                    return Poll::Ready(Ok(()));
+                }
+                for _ in 0..crate::limits::IO_POLL_BUDGET {
+                    let target = self.head.len() + 1;
+                    if !ready!(self.read_head(cx, target))? {
+                        return Poll::Ready(Err(io::ErrorKind::UnexpectedEof.into()));
+                    }
+                    if self.head.ends_with(b"\r\n\r\n") {
+                        let prefix = &self.head[..self.head.len().min(13)];
+                        if !prefix.starts_with(b"HTTP/1.1 101 ")
+                            && !prefix.starts_with(b"HTTP/1.0 101 ")
+                        {
+                            return Poll::Ready(Err(invalid()));
+                        }
+                        self.head.clear();
+                        self.first_read = false;
+                        self.remaining = usize::MAX;
+                        return Poll::Ready(Ok(()));
+                    }
+                }
+            }
+            Kind::Tls { .. } => {
+                let target = if self.first_read { 107 } else { 5 };
+                if !ready!(self.read_head(cx, target))? {
+                    self.eof = true;
+                    return Poll::Ready(Ok(()));
+                }
+                let h = &self.head;
+                if self.first_read {
+                    if h[..3] != [22, 3, 1]
+                        || h[96..102] != [20, 3, 3, 0, 1, 1]
+                        || h[102..105] != [22, 3, 3]
+                    {
+                        return Poll::Ready(Err(invalid()));
+                    }
+                } else if h[..3] != [23, 3, 3] {
+                    return Poll::Ready(Err(invalid()));
+                }
+                self.remaining =
+                    usize::from(u16::from_be_bytes(h[target - 2..].try_into().unwrap()));
+                if self.remaining > CHUNK {
+                    return Poll::Ready(Err(invalid()));
+                }
+                self.head.clear();
+                self.first_read = false;
+                return Poll::Ready(Ok(()));
+            }
+            Kind::V2rayMux => {
+                if !ready!(self.read_head(cx, 2))? {
+                    self.eof = true;
+                    return Poll::Ready(Ok(()));
+                }
+                let metadata = usize::from(u16::from_be_bytes(self.head[..2].try_into().unwrap()));
+                if !(4..=512).contains(&metadata) {
+                    return Poll::Ready(Err(invalid()));
+                }
+                if !ready!(self.read_head(cx, 2 + metadata))? {
+                    return Poll::Ready(Err(invalid()));
+                }
+                if self.head[2..4] != [0, 0]
+                    || !matches!(self.head[4], 1..=4)
+                    || self.head[5] & !3 != 0
+                {
+                    return Poll::Ready(Err(invalid()));
+                }
+                let end = self.head[4] == 3;
+                let error = self.head[5] & 2 != 0;
+                if self.head[5] & 1 != 0 {
+                    if !ready!(self.read_head(cx, 4 + metadata))? {
+                        return Poll::Ready(Err(invalid()));
+                    }
+                    self.remaining = usize::from(u16::from_be_bytes(
+                        self.head[2 + metadata..4 + metadata].try_into().unwrap(),
+                    ));
+                }
+                self.head.clear();
+                if error {
+                    return Poll::Ready(Err(io::ErrorKind::ConnectionAborted.into()));
+                }
+                self.eof = end;
+                return Poll::Ready(Ok(()));
+            }
+        }
+        cx.waker().wake_by_ref();
+        Poll::Pending
+    }
+}
+impl AsyncRead for Framed {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        output: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        let this = self.get_mut();
+        if output.remaining() == 0 {
+            return Poll::Ready(Ok(()));
+        }
+        // An accepted buffered write must progress when the peer waits for it;
+        // its backpressure never prevents consuming an already available reply.
+        if let Poll::Ready(result) = this.drain(cx) {
+            result?;
+        }
+        for _ in 0..crate::limits::IO_POLL_BUDGET {
+            if this.remaining == 0 && !this.eof {
+                ready!(this.next_frame(cx))?;
+            }
+            if this.eof && this.remaining == 0 {
+                return Poll::Ready(Ok(()));
+            }
+            if this.remaining == 0 {
+                continue;
+            }
+            let count = output.remaining().min(this.remaining);
+            let mut limited = ReadBuf::new(output.initialize_unfilled_to(count));
+            ready!(Pin::new(&mut this.raw).poll_read(cx, &mut limited))?;
+            let n = limited.filled().len();
+            if n == 0 && this.remaining != usize::MAX {
+                return Poll::Ready(Err(io::ErrorKind::UnexpectedEof.into()));
+            }
+            output.advance(n);
+            if this.remaining != usize::MAX {
+                this.remaining -= n;
+            }
+            return Poll::Ready(Ok(()));
+        }
+        cx.waker().wake_by_ref();
+        Poll::Pending
+    }
+}
+impl AsyncWrite for Framed {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        input: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        let this = self.get_mut();
+        if this.closing {
+            return Poll::Ready(Err(io::ErrorKind::BrokenPipe.into()));
+        }
+        ready!(this.drain(cx))?;
+        if input.is_empty() {
+            return Poll::Ready(Ok(0));
+        }
+        let n = this.encode(input)?;
+        if let Poll::Ready(result) = this.drain(cx) {
+            result?;
+        }
+        Poll::Ready(Ok(n))
+    }
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let this = self.get_mut();
+        ready!(this.drain(cx))?;
+        Pin::new(&mut this.raw).poll_flush(cx)
+    }
+    fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let this = self.get_mut();
+        ready!(this.drain(cx))?;
+        if !this.closing {
+            this.closing = true;
+            if matches!(this.kind, Kind::V2rayMux) {
+                this.write = Bytes::from_static(&[0, 4, 0, 0, 3, 0]);
+            }
+        }
+        ready!(this.drain(cx))?;
+        Pin::new(&mut this.raw).poll_shutdown(cx)
+    }
+}
+fn client_hello(data: &[u8], host: &str) -> io::Result<Vec<u8>> {
+    if host.len() > 255 || data.len() > CHUNK {
+        return Err(io::ErrorKind::InvalidInput.into());
+    }
+    let mut hello = vec![1, 0, 0, 0, 3, 3];
+    let timestamp = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map_err(io::Error::other)?
+        .as_secs() as u32;
+    hello.extend_from_slice(&timestamp.to_be_bytes());
+    let mut random = [0; 60];
+    rand::fill(&mut random);
+    hello.extend_from_slice(&random[..28]);
+    hello.push(32);
+    hello.extend_from_slice(&random[28..]);
+    // The simple-obfs server's first ticket starts at byte 142 of this fixed
+    // TLS-shaped envelope. All cipher/group/signature IDs are public IANA values.
+    hello.extend_from_slice(&56u16.to_be_bytes());
+    for _ in 0..2 {
+        for cipher in [
+            0xc02cu16, 0xc030, 0x009f, 0xcca9, 0xcca8, 0xc02b, 0xc02f, 0x009e, 0xc024, 0xc028,
+            0x006b, 0xc023, 0xc027, 0x0067,
+        ] {
+            hello.extend_from_slice(&cipher.to_be_bytes());
+        }
+    }
+    hello.extend_from_slice(&[1, 0]);
+    let mut extensions = Vec::new();
+    let mut extension = |id: u16, value: &[u8]| {
+        extensions.extend_from_slice(&id.to_be_bytes());
+        extensions.extend_from_slice(&(value.len() as u16).to_be_bytes());
+        extensions.extend_from_slice(value);
+    };
+    extension(35, data);
+    let mut sni = Vec::with_capacity(host.len() + 5);
+    sni.extend_from_slice(&((host.len() + 3) as u16).to_be_bytes());
+    sni.push(0);
+    sni.extend_from_slice(&(host.len() as u16).to_be_bytes());
+    sni.extend_from_slice(host.as_bytes());
+    extension(0, &sni);
+    extension(11, &[3, 1, 0, 2]);
+    extension(10, &[0, 8, 0, 29, 0, 23, 0, 25, 0, 24]);
+    let mut signatures = vec![0, 30];
+    for pair in [
+        (6, 1),
+        (6, 2),
+        (6, 3),
+        (5, 1),
+        (5, 2),
+        (5, 3),
+        (4, 1),
+        (4, 2),
+        (4, 3),
+        (3, 1),
+        (3, 2),
+        (3, 3),
+        (2, 1),
+        (2, 2),
+        (2, 3),
+    ] {
+        signatures.extend_from_slice(&[pair.0, pair.1]);
+    }
+    extension(13, &signatures);
+    extension(22, &[]);
+    extension(23, &[]);
+    hello.extend_from_slice(&(extensions.len() as u16).to_be_bytes());
+    hello.extend_from_slice(&extensions);
+    let size = (hello.len() - 4) as u32;
+    hello[1..4].copy_from_slice(&size.to_be_bytes()[1..]);
+    let mut wire = vec![22, 3, 1];
+    wire.extend_from_slice(&(hello.len() as u16).to_be_bytes());
+    wire.extend_from_slice(&hello);
+    Ok(wire)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+    #[tokio::test]
+    async fn http_obfs_preserves_fragmented_head_tail_and_half_close() {
+        tokio::time::timeout(std::time::Duration::from_secs(2), async {
+            let (raw, mut peer) = tokio::io::duplex(23);
+            let mut client = wrap(
+                Box::new(raw),
+                Kind::Http {
+                    host: "cover.invalid".into(),
+                    port: 443,
+                },
+            );
+            let peer = tokio::spawn(async move {
+                let mut header = Vec::new();
+                while !header.ends_with(b"\r\n\r\n") {
+                    header.push(peer.read_u8().await.unwrap());
+                }
+                let head = String::from_utf8(header).unwrap();
+                assert!(head.contains("Content-Length: 7\r\n"));
+                let mut body = [0; 7];
+                peer.read_exact(&mut body).await.unwrap();
+                assert_eq!(&body, b"payload");
+                for chunk in b"HTTP/1.1 101 Switching Protocols\r\n\r\nreply".chunks(3) {
+                    peer.write_all(chunk).await.unwrap();
+                }
+                let mut rest = Vec::new();
+                peer.read_to_end(&mut rest).await.unwrap();
+                assert_eq!(&rest, b"tail");
+                peer.write_all(b"after-fin").await.unwrap();
+            });
+            assert_eq!(client.write(&[]).await.unwrap(), 0);
+            client.write_all(b"payload").await.unwrap();
+            let mut reply = [0; 5];
+            client.read_exact(&mut reply).await.unwrap();
+            assert_eq!(&reply, b"reply");
+            client.write_all(b"tail").await.unwrap();
+            client.shutdown().await.unwrap();
+            let mut tail = Vec::new();
+            client.read_to_end(&mut tail).await.unwrap();
+            assert_eq!(&tail, b"after-fin");
+            peer.await.unwrap();
+        })
+        .await
+        .unwrap();
+    }
+    #[tokio::test]
+    async fn v2ray_mux_metadata_and_final_frame_keep_payload_boundaries() {
+        tokio::time::timeout(std::time::Duration::from_secs(2), async {
+            let (raw, mut peer) = tokio::io::duplex(31);
+            let mut client = wrap(Box::new(raw), Kind::V2rayMux);
+            let peer = tokio::spawn(async move {
+                let mut header = [0; 22];
+                peer.read_exact(&mut header).await.unwrap();
+                assert_eq!(
+                    &header[..14],
+                    &[0, 12, 0, 0, 1, 0, 1, 0, 0, 1, 127, 0, 0, 1]
+                );
+                assert_eq!(&header[14..], &[0, 4, 0, 0, 2, 1, 0, 4]);
+                let mut payload = [0; 4];
+                peer.read_exact(&mut payload).await.unwrap();
+                assert_eq!(&payload, b"data");
+                peer.write_all(&[0, 4, 0, 0, 4, 0, 0, 4, 0, 0, 2, 1, 0, 5])
+                    .await
+                    .unwrap();
+                peer.write_all(b"reply").await.unwrap();
+                let mut end = [0; 6];
+                peer.read_exact(&mut end).await.unwrap();
+                assert_eq!(end, [0, 4, 0, 0, 3, 0]);
+            });
+            client.write_all(b"data").await.unwrap();
+            let mut reply = [0; 5];
+            client.read_exact(&mut reply).await.unwrap();
+            assert_eq!(&reply, b"reply");
+            client.shutdown().await.unwrap();
+            peer.await.unwrap();
+        })
+        .await
+        .unwrap();
+    }
+    #[test]
+    fn tls_obfs_ticket_layout_is_fixed_but_nonces_are_fresh() {
+        let first = client_hello(b"payload", "cover.invalid").unwrap();
+        let second = client_hello(b"payload", "cover.invalid").unwrap();
+        assert_eq!(&first[..3], &[22, 3, 1]);
+        assert_eq!(&first[138..142], &[0, 35, 0, 7]);
+        assert_eq!(&first[142..149], b"payload");
+        assert_ne!(first, second);
+        assert_eq!(
+            usize::from(u16::from_be_bytes(first[3..5].try_into().unwrap())),
+            first.len() - 5
+        );
+    }
+}
diff --git a/src/transport/ws.rs b/src/transport/ws.rs
index e5ad623..7669e00 100644
--- a/src/transport/ws.rs
+++ b/src/transport/ws.rs
@@ -29,7 +29,7 @@ use tokio_tungstenite::{
 use super::{STREAM_BUFFER_BYTES as LIMIT, STREAM_CHUNK_BYTES as CHUNK};
 use crate::dispatch::BoxStream;
 
-pub const MAX_EARLY_DATA_BYTES: usize = 2048;
+pub const MAX_EARLY_DATA_BYTES: usize = (super::HTTP_HEAD_BYTES - 512) / 4 * 3;
 
 #[derive(Clone)]
 pub enum WebSocketEarlyData {
@@ -62,7 +62,7 @@ impl WebSocketOptions {
     pub fn new(
         uri: &str,
         headers: http::HeaderMap,
-        early_data: Option<WebSocketEarlyData>,
+        mut early_data: Option<WebSocketEarlyData>,
     ) -> io::Result<Self> {
         use super::http_head::{HTTP_HEAD_BYTES, HTTP_HEADER_COUNT};
         let uri: http::Uri = uri.parse().map_err(|_| invalid_options())?;
@@ -99,24 +99,29 @@ impl WebSocketOptions {
         if size > HTTP_HEAD_BYTES {
             return Err(invalid_options());
         }
-        if let Some(early) = &early_data {
-            let maximum = match early {
+        if let Some(early) = &mut early_data {
+            let (maximum, name_bytes) = match early {
                 WebSocketEarlyData::Header { name, max_bytes } => {
-                    if reserved(name) || name == "host" || headers.contains_key(name) {
+                    if reserved(name) || name == "host" || headers.contains_key(&*name) {
                         return Err(invalid_options());
                     }
-                    *max_bytes
+                    (max_bytes, name.as_str().len())
                 }
                 WebSocketEarlyData::Path { max_bytes } => {
                     if uri.query().is_some() {
                         return Err(invalid_options());
                     }
-                    *max_bytes
+                    (max_bytes, 0)
                 }
             };
-            if !(1..=MAX_EARLY_DATA_BYTES).contains(&maximum) {
+            // A configured limit is a ceiling, not a reservation. Keep the
+            // Base64 value inside this request's actual bounded head budget.
+            let capacity =
+                HTTP_HEAD_BYTES.saturating_sub(size.saturating_add(512 + name_bytes)) / 4 * 3;
+            if *maximum == 0 || capacity == 0 {
                 return Err(invalid_options());
             }
+            *maximum = (*maximum).min(capacity).min(MAX_EARLY_DATA_BYTES);
         }
         Ok(Self {
             uri,
diff --git a/src/transport/xhttp.rs b/src/transport/xhttp.rs
index 1acea97..919319d 100644
--- a/src/transport/xhttp.rs
+++ b/src/transport/xhttp.rs
@@ -12,6 +12,8 @@ use http::{Method, Request, StatusCode, Uri};
 use http_io::{
     Download as RecvStream, ResponseFuture, Sender as SendRequest, Upload as SendStream,
 };
+#[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+use std::sync::{Mutex, Weak};
 use tokio::{
     io::{AsyncRead, AsyncWrite, ReadBuf},
     task::JoinHandle,
@@ -21,7 +23,6 @@ use tokio::{
 use crate::dispatch::BoxStream;
 mod h2_driver;
 mod h3_driver;
-mod h3_upload;
 pub(crate) use h3_driver::QuicTransport;
 mod http_io;
 mod packet_up;
@@ -94,12 +95,32 @@ impl XHttpConfig {
     }
 }
 
+#[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+pub(crate) use h3_driver::UdpAssociationControl;
+#[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+#[derive(Clone, Debug, Default)]
+pub(crate) struct UdpAssociationCapture {
+    slot: Arc<Mutex<Option<Option<Weak<UdpAssociationControl>>>>>,
+}
+#[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+impl UdpAssociationCapture {
+    fn report(&self, control: Option<Weak<UdpAssociationControl>>) {
+        let mut slot = self.slot.lock().unwrap();
+        let value = if slot.is_none() { control } else { None };
+        *slot = Some(value);
+    }
+    pub(crate) fn take(&self) -> Option<Weak<UdpAssociationControl>> {
+        self.slot.lock().unwrap().take().flatten()
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct XHttpClient {
     mode: XHttpMode,
     request: RequestTemplate,
     send_buffer_size: usize,
     upload_chunk_size: usize,
+    shared_packet_up: bool,
     http_version: crate::config::XHttpVersion,
     owner: Arc<DriverOwner>,
     reuse: Option<Arc<crate::config::XHttpReuseConfig>>,
@@ -143,13 +164,65 @@ impl XHttpClient {
             },
             send_buffer_size: DEFAULT_H2_SEND_BUFFER_SIZE,
             upload_chunk_size: DEFAULT_UPLOAD_CHUNK_SIZE,
+            shared_packet_up: false,
             http_version,
             owner: Arc::default(),
-            pool: Arc::new(pool::Pool::new(reuse.clone())),
+            pool: Arc::new(pool::Pool::new(reuse.clone(), http_version)),
             reuse,
         }
     }
 
+    /// Immutable upload purpose, established before the first pool acquisition.
+    #[cfg(any(feature = "invoke", test))]
+    pub(crate) fn set_shared_packet_up_transport(&mut self, shared: bool) {
+        #[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+        let previous = self.udp_budget_qualified();
+        self.shared_packet_up = shared;
+        #[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+        if previous != self.udp_budget_qualified() {
+            // Eligibility isolates pools even while both initial budgets are64.
+            self.pool = Arc::new(pool::Pool::new(self.reuse.clone(), self.http_version));
+        }
+    }
+    #[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+    fn udp_budget_qualified(&self) -> bool {
+        self.shared_packet_up
+            && self.http_version == crate::config::XHttpVersion::Http3
+            && self.mode == XHttpMode::PacketUp
+            && matches!(
+                &self.request.options.data,
+                crate::config::xhttp::DataPlacement::Body
+            )
+    }
+
+    /// Opt-in only after the VLESS leg proves immutable physical/security scope.
+    #[cfg(feature = "outbound-vless")]
+    pub(crate) fn enable_active_h2_reuse(&mut self) {
+        if self.http_version == crate::config::XHttpVersion::Http2 && self.reuse.is_none() {
+            self.pool = Arc::new(pool::Pool::active_h2());
+        }
+    }
+
+    #[cfg(feature = "outbound-vless")]
+    pub(crate) fn uses_active_h2_reuse(&self) -> bool {
+        self.http_version == crate::config::XHttpVersion::Http2
+            && self.reuse.is_none()
+            && self.pool.shares_active()
+    }
+
+    /// A context requesting a fresh physical socket keeps the original owner
+    /// and request template, but cannot read or populate the active candidate pool.
+    #[cfg(feature = "outbound-vless")]
+    pub(crate) fn h2_lease(&self, allow_reuse: bool) -> std::borrow::Cow<'_, Self> {
+        if self.uses_active_h2_reuse() && !allow_reuse {
+            let mut independent = self.clone();
+            independent.pool = Arc::new(pool::Pool::new(None, self.http_version));
+            std::borrow::Cow::Owned(independent)
+        } else {
+            std::borrow::Cow::Borrowed(self)
+        }
+    }
+
     pub(crate) fn new_with_limits(
         config: XHttpConfig,
         send_buffer_size: usize,
@@ -240,9 +313,44 @@ impl XHttpClient {
     }
 
     pub(crate) async fn open_transport<F, Fut>(
+        &self,
+        deadline: tokio::time::Instant,
+        connect: F,
+    ) -> io::Result<BoxStream>
+    where
+        F: FnMut() -> Fut,
+        Fut: Future<Output = io::Result<TransportIo>>,
+    {
+        self.open_transport_inner(
+            deadline,
+            connect,
+            #[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+            None,
+        )
+        .await
+    }
+    #[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+    pub(crate) async fn open_transport_captured<F, Fut>(
+        &self,
+        deadline: tokio::time::Instant,
+        connect: F,
+        capture: &UdpAssociationCapture,
+    ) -> io::Result<BoxStream>
+    where
+        F: FnMut() -> Fut,
+        Fut: Future<Output = io::Result<TransportIo>>,
+    {
+        self.open_transport_inner(deadline, connect, Some(capture))
+            .await
+    }
+
+    async fn open_transport_inner<F, Fut>(
         &self,
         deadline: tokio::time::Instant,
         mut connect: F,
+        #[cfg(all(feature = "outbound-vless", feature = "sing-mux"))] capture: Option<
+            &UdpAssociationCapture,
+        >,
     ) -> io::Result<BoxStream>
     where
         F: FnMut() -> Fut,
@@ -250,6 +358,11 @@ impl XHttpClient {
     {
         let operation = async {
             let (sender, driver) = self.acquire(false, &mut connect).await?;
+            #[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+            let control = match &sender {
+                SendRequest::H3(sender) => sender.udp_control.as_ref().map(Arc::downgrade),
+                _ => None,
+            };
             if self.needs_separate_download() {
                 let (download, download_driver) =
                     self.handshake_transport(connect().await?).await?;
@@ -262,7 +375,12 @@ impl XHttpClient {
                     )
                     .await;
             }
-            self.connect_http(sender, driver).await
+            let connected = self.connect_http(sender, driver).await?;
+            #[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+            if let Some(capture) = capture {
+                capture.report(control);
+            }
+            Ok(connected)
         };
         tokio::select! {biased;
             () = self.owner.cancellation.cancelled() => Err(connection_closed()),
@@ -439,7 +557,10 @@ impl XHttpClient {
                 result = async {
                     match transport {
                         TransportIo::Stream(stream) if self.http_version != crate::config::XHttpVersion::Http3 => self.handshake_active(stream).await,
-                        TransportIo::Quic(transport) if self.http_version == crate::config::XHttpVersion::Http3 => h3_driver::connect(*transport, self.reuse.as_ref().map_or(0, |r| r.keep_alive_seconds), &self.owner).await,
+                        TransportIo::Quic(transport) if self.http_version == crate::config::XHttpVersion::Http3 => h3_driver::connect(*transport, self.reuse.as_ref().map_or(0, |r| r.keep_alive_seconds),
+                            #[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+                            self.udp_budget_qualified(),
+                            &self.owner).await,
                         _ => Err(request::invalid_request()),
                     }
                 } => result,
@@ -456,6 +577,10 @@ impl XHttpClient {
                 .await
                 .map(|(sender, guard)| (sender, Arc::new(guard)));
         }
+        #[cfg(feature = "outbound-vless")]
+        let private_active_h2 = self.uses_active_h2_reuse();
+        #[cfg(not(feature = "outbound-vless"))]
+        let private_active_h2 = false;
         h2_driver::connect(
             stream,
             self.send_buffer_size,
@@ -463,6 +588,7 @@ impl XHttpClient {
                 .as_ref()
                 .map_or(0, |options| options.keep_alive_seconds),
             &self.owner,
+            private_active_h2,
         )
         .await
     }
@@ -501,6 +627,37 @@ impl XHttpClient {
         })))
     }
 
+    fn packet_up_writer(
+        &self,
+        sender: SendRequest,
+        session: Arc<str>,
+    ) -> io::Result<packet_up::Writer> {
+        let overlap = self.shared_packet_up
+            && self.mode == XHttpMode::PacketUp
+            && matches!(&sender, SendRequest::H3(_))
+            && matches!(
+                &self.request.options.data,
+                crate::config::xhttp::DataPlacement::Body
+            );
+        if overlap {
+            packet_up::Writer::new_overlapping(
+                sender,
+                self.request.clone(),
+                session,
+                self.upload_chunk_size,
+                &self.owner,
+            )
+        } else {
+            packet_up::Writer::new(
+                sender,
+                self.request.clone(),
+                session,
+                self.upload_chunk_size,
+                &self.owner,
+            )
+        }
+    }
+
     async fn connect_packet_up_with_download(
         &self,
         upload_sender: SendRequest,
@@ -515,13 +672,7 @@ impl XHttpClient {
         let (response, _) = download_sender.send_request(request, true).await?;
 
         Ok(Box::new(XHttpStream::new(PacketUp {
-            upload: packet_up::Writer::new(
-                upload_sender,
-                self.request.clone(),
-                session_id,
-                self.upload_chunk_size,
-                &self.owner,
-            )?,
+            upload: self.packet_up_writer(upload_sender, session_id)?,
             download: Downlink::pending(response, "packet-up download", false),
             closed: false,
             _connections: connections,
@@ -2122,3 +2273,7 @@ mod tests {
             .unwrap();
     }
 }
+
+#[cfg(all(test, feature = "outbound-vless", feature = "sing-mux"))]
+#[path = "xhttp/h3_packet_overlap_memory_tests.rs"]
+mod h3_packet_overlap_memory_tests;
diff --git a/src/transport/xhttp/h2_driver.rs b/src/transport/xhttp/h2_driver.rs
index cbaf8f9..729631f 100644
--- a/src/transport/xhttp/h2_driver.rs
+++ b/src/transport/xhttp/h2_driver.rs
@@ -18,13 +18,21 @@ pub(super) async fn connect(
     send_buffer: usize,
     period: i32,
     owner: &DriverOwner,
+    private_active_h2: bool,
 ) -> io::Result<(SendRequest, Arc<ConnectionGuard>)> {
     let last_read = Arc::new(Mutex::new(Instant::now()));
     let (raw, writes) = Writes::wrap(raw);
-    let (sender, mut connection) = h2::client::Builder::new()
+    let mut builder = h2::client::Builder::new();
+    builder
         .max_header_list_size(super::MAX_H2_HEADER_LIST_SIZE)
         .max_send_buffer_size(send_buffer)
-        .enable_push(false)
+        .enable_push(false);
+    if private_active_h2 {
+        // Until the first peer SETTINGS is processed, do not borrow four
+        // logical streams against an unknown remote concurrency limit.
+        builder.initial_max_send_streams(1);
+    }
+    let (sender, mut connection) = builder
         .handshake(ActivityIo {
             raw: Box::new(raw),
             last_read: last_read.clone(),
diff --git a/src/transport/xhttp/h3_driver.rs b/src/transport/xhttp/h3_driver.rs
index 376596d..2a7c2ef 100644
--- a/src/transport/xhttp/h3_driver.rs
+++ b/src/transport/xhttp/h3_driver.rs
@@ -1,12 +1,14 @@
-//! HTTP/3 over the shared controlled datagram seam. No socket or DNS fallback.
+//! HTTP/3 over caller-owned Quinn and the controlled datagram seam.
 use super::{ConnectionGuard, DriverOwner, SendRequest, connection_closed};
 use crate::{
     dispatch::{DatagramBudget, DatagramTransport},
-    transport::quic,
+    transport::{
+        quic::{self, OwnedRuntime},
+        quinn_h3,
+    },
 };
-use bytes::Bytes;
 use std::{io, net::SocketAddr, sync::Arc, time::Duration};
-use tokio::sync::oneshot;
+use tokio::{sync::oneshot, time::Instant};
 use tokio_util::sync::CancellationToken;
 
 pub(crate) struct QuicTransport {
@@ -17,24 +19,50 @@ pub(crate) struct QuicTransport {
     pub server_name: String,
 }
 
-#[derive(Clone)]
+#[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+#[derive(Debug)]
+pub(crate) struct UdpAssociationControl {
+    connection: quinn::Connection,
+    cancel: CancellationToken,
+    raised: std::sync::atomic::AtomicBool,
+}
+#[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+impl UdpAssociationControl {
+    #[cfg(all(test, feature = "interop-test"))]
+    pub(super) fn was_raised(&self) -> bool {
+        self.raised.load(std::sync::atomic::Ordering::Acquire)
+    }
+    pub(crate) fn raise(&self) {
+        use std::sync::atomic::Ordering;
+        if self.cancel.is_cancelled() || self.connection.close_reason().is_some() {
+            return;
+        }
+        if self
+            .raised
+            .compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
+            .is_ok()
+            && !self.cancel.is_cancelled()
+        {
+            self.connection
+                .set_send_window(crate::limits::XHTTP_H3_UDP_SEND_WINDOW as u64);
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
 pub(super) struct Sender {
-    pub requests: h3::client::SendRequest<super::h3_upload::OpenStreams, Bytes>,
+    pub requests: quinn_h3::Client,
     pub runtime: Arc<OwnedRuntime>,
+    #[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+    pub udp_control: Option<Arc<UdpAssociationControl>>,
     #[cfg(feature = "interop-test")]
     pub observation: quinn::Connection,
 }
-impl std::fmt::Debug for Sender {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("Http3Sender").finish_non_exhaustive()
-    }
-}
-
-use crate::transport::quic::OwnedRuntime;
 
 pub(super) async fn connect(
     raw: QuicTransport,
     keepalive: i32,
+    #[cfg(all(feature = "outbound-vless", feature = "sing-mux"))] udp_qualified: bool,
     owner: &DriverOwner,
 ) -> io::Result<(SendRequest, Arc<ConnectionGuard>)> {
     let cancel = owner.cancellation.child_token();
@@ -42,23 +70,47 @@ pub(super) async fn connect(
     let (ready, response) = oneshot::channel();
     let guard = owner.spawn_managed(
         async move {
-            // Keep QUIC alive for the bounded close exchange after logical
-            // cancellation. Cancelling its runtime first loses CONNECTION_CLOSE.
+            // Native IO remains alive during retirement; only its owner cancels
+            // and joins it after the bounded close exchange.
             let runtime = Arc::new(OwnedRuntime::new(CancellationToken::new()));
+            let QuicTransport {
+                transport,
+                peer,
+                budget,
+                tls,
+                server_name,
+            } = raw;
+            let mut upstream = Some(transport);
             let mut ready = Some(ready);
-            let mut driver = None;
+            let mut datagram = None;
             let mut endpoint = None;
-            let connection = async {
+            let mut close_deadline = None;
+            let prepared = async {
+                let mut tls = (*tls).clone();
+                tls.resumption = rustls::client::Resumption::disabled();
+                tls.enable_early_data = false;
                 let crypto =
-                    quinn::crypto::rustls::QuicClientConfig::try_from(raw.tls).map_err(failure)?;
-                let (socket, datagram) = quic::attach(raw.transport, raw.peer, raw.budget)?;
-                driver = Some(datagram);
-                let mtu = socket.budget().quic_payload_limit()?;
+                    quinn::crypto::rustls::QuicClientConfig::try_from(tls).map_err(failure)?;
+                if peer.port() == 0 || peer.ip().is_unspecified() || peer.ip().is_multicast() {
+                    return Err(io::ErrorKind::InvalidInput.into());
+                }
+                // Validate before transferring upstream ownership to attach.
+                budget
+                    .intersect(upstream.as_ref().unwrap().payload_budget(&peer.into()))
+                    .quic_payload_limit()?;
+                let (socket, driver) =
+                    quic::attach_quinn(upstream.take().unwrap(), peer, budget).await?;
+                datagram = Some(driver);
+                let path = socket.budget();
+                path.quic_payload_limit()?;
+                let mut discovery = quinn::MtuDiscoveryConfig::default();
+                discovery.upper_bound(path.transmit());
                 let mut limits = quinn::TransportConfig::default();
+                socket.configure_transport(&mut limits);
                 limits
-                    .initial_mtu(mtu)
-                    .min_mtu(mtu)
-                    .mtu_discovery_config(None)
+                    .initial_mtu(crate::dispatch::QUIC_MIN_PAYLOAD_BYTES)
+                    .min_mtu(crate::dispatch::QUIC_MIN_PAYLOAD_BYTES)
+                    .mtu_discovery_config(Some(discovery))
                     .max_concurrent_bidi_streams(0_u8.into())
                     .max_concurrent_uni_streams((crate::limits::XHTTP_H3_UNI_STREAMS as u32).into())
                     .stream_receive_window((crate::limits::XHTTP_H3_STREAM_WINDOW as u32).into())
@@ -73,60 +125,101 @@ pub(super) async fn connect(
                 let mut client = quinn::ClientConfig::new(Arc::new(crypto));
                 client.transport_config(Arc::new(limits));
                 let mut config = quinn::EndpointConfig::default();
-                config.max_udp_payload_size(mtu).map_err(failure)?;
-                let mut peer = quinn::Endpoint::new_with_abstract_socket(
+                config
+                    .max_udp_payload_size(path.receive())
+                    .map_err(failure)?;
+                let mut native = quinn::Endpoint::new_with_abstract_socket(
                     config,
                     None,
-                    socket,
+                    socket.clone(),
                     runtime.clone(),
                 )?;
-                peer.set_default_client_config(client);
-                endpoint = Some(peer);
-                let connected = endpoint
+                native.set_default_client_config(client);
+                endpoint = Some(native);
+                let connection = endpoint
                     .as_ref()
                     .unwrap()
-                    .connect(raw.peer, &raw.server_name)
+                    .connect(peer, &server_name)
                     .map_err(failure)?
                     .await
                     .map_err(failure)?;
-                let (mut control, requests) = h3::client::builder()
-                    .max_field_section_size(u64::from(super::MAX_H2_HEADER_LIST_SIZE))
-                    .build(super::h3_upload::Connection::new(connected.clone()))
-                    .await
-                    .map_err(failure)?;
-                // h3 closes the connection when its last request sender is dropped,
-                // even while response/upload streams still exist. Keep one sender
-                // with the physical driver, whose lease owns the connection lifetime.
-                let keep_requests = requests.clone();
-                ready
-                    .take()
-                    .unwrap()
-                    .send(Ok(Sender {
-                        requests,
-                        runtime: runtime.clone(),
-                        #[cfg(feature = "interop-test")]
-                        observation: connected,
-                    }))
+                let handshake = connection
+                    .handshake_data()
+                    .ok_or_else(connection_closed)?
+                    .downcast::<quinn::crypto::rustls::HandshakeData>()
                     .map_err(|_| connection_closed())?;
-                let _ = control.wait_idle().await;
-                drop(keep_requests);
-                Ok::<_, io::Error>(())
+                if handshake.protocol.as_deref() != Some(b"h3") {
+                    return Err(io::ErrorKind::InvalidData.into());
+                }
+                // rustls rejects an unaccepted ECH offer at Finished processing.
+                let (requests, control) = quinn_h3::attach(
+                    connection.clone(),
+                    u64::from(super::MAX_H2_HEADER_LIST_SIZE),
+                )
+                .await
+                .map_err(failure)?;
+                Ok::<_, io::Error>((connection, requests, control, socket))
             };
-            let result = tokio::select! {biased;
+            let prepared = tokio::select! {biased;
                 () = stop.cancelled() => Err(connection_closed()),
-                result = connection => result,
+                result = prepared => result,
+            };
+            let error = match prepared {
+                Ok((connection, requests, mut control, socket)) => {
+                    // h3 closes native QUIC when its last sender is dropped.
+                    // Keep a sender until retirement IO has finished.
+                    let keep_requests = requests.clone();
+                    let published = ready
+                        .take()
+                        .unwrap()
+                        .send(Ok(Sender {
+                            requests,
+                            runtime: runtime.clone(),
+                            #[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+                            udp_control: udp_qualified.then(|| {
+                                Arc::new(UdpAssociationControl {
+                                    connection: connection.clone(),
+                                    cancel: stop.clone(),
+                                    raised: std::sync::atomic::AtomicBool::new(false),
+                                })
+                            }),
+                            #[cfg(feature = "interop-test")]
+                            observation: connection.clone(),
+                        }))
+                        .is_ok();
+                    if published {
+                        let retiring = tokio::select! {biased;
+                            () = stop.cancelled() => true,
+                            _ = control.wait_idle() => false,
+                        };
+                        if retiring {
+                            keep_requests.retire();
+                            let deadline = Instant::now() + quic::CLOSE_TIMEOUT;
+                            close_deadline = Some(deadline);
+                            retire_io(&mut control, &connection, &socket, deadline).await;
+                        }
+                    }
+                    drop(keep_requests);
+                    None
+                }
+                Err(error) => Some(error),
             };
-            if let Some(ready) = ready {
-                let _ = ready.send(Err(result.err().unwrap_or_else(connection_closed)));
-            }
             if let Some(endpoint) = endpoint {
+                let deadline =
+                    close_deadline.unwrap_or_else(|| Instant::now() + quic::CLOSE_TIMEOUT);
                 endpoint.close(0_u8.into(), b"");
-                let _ = tokio::time::timeout(quic::CLOSE_TIMEOUT, endpoint.wait_idle()).await;
+                let _ = tokio::time::timeout_at(deadline, endpoint.wait_idle()).await;
             }
             runtime.stop().await;
-            if let Some(driver) = driver {
+            if let Some(driver) = datagram {
                 let _ = driver.stop().await;
             }
+            if let Some(mut upstream) = upstream {
+                let _ = tokio::time::timeout(quic::CLOSE_TIMEOUT, upstream.close()).await;
+            }
+            if let Some(ready) = ready {
+                let _ = ready.send(Err(error.unwrap_or_else(connection_closed)));
+            }
         },
         cancel,
     )?;
@@ -137,3 +230,42 @@ pub(super) async fn connect(
 pub(super) fn failure(_: impl std::fmt::Display) -> io::Error {
     io::Error::other("XHTTP HTTP/3 exchange failed")
 }
+
+// Follow real upstream TX progress while retaining native/H3 ownership. Keep
+// room for CONNECTION_CLOSE within the original deadline; no ACK is inferred
+// from quiet time, and stalled/continuously busy paths still stop at that bound.
+async fn retire_io(
+    control: &mut quinn_h3::ControlDriver,
+    connection: &quinn::Connection,
+    socket: &quic::DatagramSocket,
+    deadline: Instant,
+) {
+    let grace = || {
+        connection
+            .rtt()
+            .saturating_mul(2)
+            .saturating_add(Duration::from_millis(25))
+            .min(quic::CLOSE_TIMEOUT)
+    };
+    let mut sent = socket.stats().sent;
+    let mut quiet = (Instant::now() + grace()).min(deadline);
+    loop {
+        let now = Instant::now();
+        let actual = socket.stats().sent;
+        if actual != sent {
+            sent = actual;
+            quiet = (now + grace()).min(deadline);
+        }
+        if now >= quiet || now >= deadline {
+            return;
+        }
+        // A local timer avoids replacing Quinn's writer AtomicWaker with a
+        // second poll_transmitted waiter; no extra task or packet queue.
+        let check = (now + Duration::from_millis(10)).min(quiet).min(deadline);
+        tokio::select! {biased;
+            _ = control.wait_idle() => return,
+            _ = connection.closed() => return,
+            () = tokio::time::sleep_until(check) => {},
+        }
+    }
+}
diff --git a/src/transport/xhttp/h3_packet_overlap_memory_tests.rs b/src/transport/xhttp/h3_packet_overlap_memory_tests.rs
new file mode 100644
index 0000000..ff2f5e9
--- /dev/null
+++ b/src/transport/xhttp/h3_packet_overlap_memory_tests.rs
@@ -0,0 +1,823 @@
+//! Production PacketUp factory over real H3 and bounded in-memory datagrams.
+//! This is a feedback/ownership fixture, not a process-RSS or TUN capacity test.
+use super::*;
+use crate::{
+    dispatch::{DatagramBudget, DatagramTransport, DispatchError},
+    outbound::{OutboundConnector, VlessOutbound},
+    session::{Datagram, Destination},
+    transport::{quic::OwnedRuntime, quinn_h3::tests::memory_socket},
+};
+use async_trait::async_trait;
+use base64::Engine as _;
+use futures_util::FutureExt;
+use std::{
+    future::Future,
+    net::SocketAddr,
+    panic::{AssertUnwindSafe, resume_unwind},
+    sync::atomic::{AtomicUsize, Ordering},
+};
+use tokio::{
+    io::AsyncWriteExt,
+    sync::{mpsc, oneshot},
+    task::JoinHandle,
+    time::timeout,
+};
+use tokio_util::sync::CancellationToken;
+
+const BATCH: usize = 128 * 1024;
+const LIMIT: Duration = Duration::from_secs(10);
+type Peer = h3::server::Connection<h3_quinn::Connection, Bytes>;
+type PeerStream = h3::server::RequestStream<h3_quinn::BidiStream<Bytes>, Bytes>;
+
+#[derive(Default)]
+struct AckGate {
+    held: std::sync::atomic::AtomicBool,
+    changed: tokio::sync::Notify,
+}
+impl AckGate {
+    fn set(&self, held: bool) {
+        self.held.store(held, Ordering::SeqCst);
+        self.changed.notify_one();
+    }
+}
+
+struct Packets {
+    send: mpsc::Sender<Bytes>,
+    receive: mpsc::Receiver<Bytes>,
+    pending: Option<Bytes>,
+    gate: Arc<AckGate>,
+    peer: SocketAddr,
+    closed: Arc<AtomicUsize>,
+}
+#[async_trait]
+impl DatagramTransport for Packets {
+    fn supports_shared_destinations(&self) -> bool {
+        false
+    }
+    fn payload_budget(&self, _: &Destination) -> DatagramBudget {
+        DatagramBudget::new(1400, 1400)
+    }
+    async fn send(&mut self, packet: Datagram) -> Result<(), DispatchError> {
+        assert_eq!(packet.remote, self.peer.into());
+        self.send
+            .send(packet.payload)
+            .await
+            .map_err(|_| DispatchError::NotAllowed)
+    }
+    async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+        if self.pending.is_none() {
+            self.pending = Some(self.receive.recv().await.ok_or(DispatchError::NotAllowed)?);
+        }
+        loop {
+            let changed = self.gate.changed.notified();
+            if !self.gate.held.load(Ordering::SeqCst) {
+                break;
+            }
+            changed.await;
+        }
+        Ok(Datagram {
+            remote: self.peer.into(),
+            payload: self.pending.take().unwrap(),
+            sniffed_domain: None,
+        })
+    }
+    async fn close(&mut self) -> Result<(), DispatchError> {
+        self.closed.fetch_add(1, Ordering::SeqCst);
+        self.pending = None;
+        self.receive.close();
+        Ok(())
+    }
+}
+
+struct Fixture {
+    client: XHttpClient,
+    raw: Option<QuicTransport>,
+    gate: Arc<AckGate>,
+    native_peer: Option<quinn::Connection>,
+    endpoint: quinn::Endpoint,
+    runtime: Arc<OwnedRuntime>,
+    sender: Option<SendRequest>,
+    lease: Option<ConnectionLease>,
+    cancel: CancellationToken,
+    tasks: Vec<JoinHandle<()>>,
+    closed: Arc<AtomicUsize>,
+    download: bool,
+}
+impl Fixture {
+    fn new(client: XHttpClient, download: bool, streams: u32, receive_window: u32) -> Self {
+        let identity = rcgen::generate_simple_self_signed(vec!["localhost".into()]).unwrap();
+        let provider = Arc::new(rustls::crypto::ring::default_provider());
+        let mut roots = rustls::RootCertStore::empty();
+        roots.add(identity.cert.der().clone()).unwrap();
+        let mut client_tls = rustls::ClientConfig::builder_with_provider(provider.clone())
+            .with_protocol_versions(&[&rustls::version::TLS13])
+            .unwrap()
+            .with_root_certificates(roots)
+            .with_no_client_auth();
+        client_tls.alpn_protocols = vec![b"h3".to_vec()];
+        let mut server_tls = rustls::ServerConfig::builder_with_provider(provider)
+            .with_protocol_versions(&[&rustls::version::TLS13])
+            .unwrap()
+            .with_no_client_auth()
+            .with_single_cert(
+                vec![identity.cert.der().clone()],
+                rustls::pki_types::PrivateKeyDer::Pkcs8(
+                    identity.signing_key.serialize_der().into(),
+                ),
+            )
+            .unwrap();
+        server_tls.alpn_protocols = vec![b"h3".to_vec()];
+        let mut server = quinn::ServerConfig::with_crypto(Arc::new(
+            quinn::crypto::rustls::QuicServerConfig::try_from(server_tls).unwrap(),
+        ));
+        Arc::get_mut(&mut server.transport)
+            .unwrap()
+            .max_concurrent_bidi_streams(streams.into())
+            .stream_receive_window(receive_window.into())
+            .receive_window((1024_u32 * 1024).into())
+            .mtu_discovery_config(None);
+        let peer: SocketAddr = "192.0.2.2:443".parse().unwrap();
+        let local: SocketAddr = "192.0.2.1:44001".parse().unwrap();
+        let (to_server, from_client) = mpsc::channel(32);
+        let (to_client, from_server) = mpsc::channel(32);
+        let runtime = Arc::new(OwnedRuntime::new(CancellationToken::new()));
+        let endpoint = quinn::Endpoint::new_with_abstract_socket(
+            quinn::EndpointConfig::default(),
+            Some(server),
+            memory_socket(to_client, from_client, peer, local),
+            runtime.clone(),
+        )
+        .unwrap();
+        let closed = Arc::new(AtomicUsize::new(0));
+        let gate = Arc::new(AckGate::default());
+        Self {
+            client,
+            gate: gate.clone(),
+            native_peer: None,
+            endpoint,
+            runtime,
+            download,
+            raw: Some(QuicTransport {
+                transport: Box::new(Packets {
+                    send: to_server,
+                    receive: from_server,
+                    pending: None,
+                    gate,
+                    peer,
+                    closed: closed.clone(),
+                }),
+                peer,
+                budget: DatagramBudget::new(1400, 1400),
+                tls: Arc::new(client_tls),
+                server_name: "localhost".into(),
+            }),
+            sender: None,
+            lease: None,
+            cancel: CancellationToken::new(),
+            tasks: Vec::new(),
+            closed,
+        }
+    }
+    async fn initialize(&mut self) -> Peer {
+        let raw = self.raw.take().unwrap();
+        let (connected, accepted) = tokio::join!(
+            self.client.acquire(self.download, || async move {
+                Ok(TransportIo::Quic(Box::new(raw)))
+            }),
+            async { self.endpoint.accept().await.unwrap().await.unwrap() }
+        );
+        let (sender, lease) = connected.unwrap();
+        assert!(
+            matches!(&sender, SendRequest::H3(_)),
+            "must use the production H3 driver"
+        );
+        self.sender = Some(sender);
+        self.lease = Some(lease);
+        self.native_peer = Some(accepted.clone());
+        h3::server::builder()
+            .max_field_section_size(16 * 1024)
+            .build::<_, Bytes>(h3_quinn::Connection::new(accepted))
+            .await
+            .unwrap()
+    }
+    fn writer(&self, session: &str) -> packet_up::Writer {
+        self.client
+            .packet_up_writer(self.sender.as_ref().unwrap().clone(), Arc::from(session))
+            .unwrap()
+    }
+    fn spawn(&mut self, future: impl Future<Output = ()> + Send + 'static) {
+        let cancel = self.cancel.clone();
+        self.tasks.push(tokio::spawn(async move {
+            tokio::select! { biased; () = cancel.cancelled() => {}, () = future => {} }
+        }));
+    }
+    async fn stop(&mut self) {
+        self.gate.set(false);
+        // Never abort the managed client driver: it owns nested endpoint,
+        // runtime and DatagramTransport retirement. Re-await a timed-out barrier.
+        let client_stop = timeout(Duration::from_secs(3), self.client.stop()).await;
+        self.cancel.cancel();
+        self.endpoint.close(0_u8.into(), b"");
+        let peer_idle = timeout(Duration::from_secs(2), self.endpoint.wait_idle()).await;
+        let peer_stop = timeout(Duration::from_secs(2), self.runtime.stop()).await;
+        self.client.stop().await;
+        self.runtime.stop().await;
+        let mut panic = None;
+        for task in self.tasks.drain(..) {
+            if let Err(error) = task.await {
+                if panic.is_none() {
+                    panic = Some(error);
+                }
+            }
+        }
+        self.lease.take();
+        self.sender.take();
+        if let Some(error) = panic {
+            resume_unwind(error.into_panic());
+        }
+        assert!(
+            client_stop.is_ok(),
+            "managed client Stop exceeded its original bound"
+        );
+        assert!(
+            peer_idle.is_ok() && peer_stop.is_ok(),
+            "peer retirement exceeded fixture bound"
+        );
+        assert_eq!(
+            self.closed.load(Ordering::SeqCst),
+            1,
+            "physical datagram owner must close exactly once"
+        );
+    }
+}
+
+fn node(smux: Option<serde_json::Value>, placement: &str, split: bool) -> VlessOutbound {
+    let mut raw = serde_json::json!({
+        "proxies":[{"name":"fixture", "type":"vless", "server":"example.com", "port":443,
+            "uuid":"00000000-0000-0000-0000-000000000001", "tls":true, "alpn":["h3"],
+            "network":"xhttp", "xhttp-opts":{"path":"/x", "mode":"packet-up",
+                "uplink-data-placement":placement}}], "rules":["MATCH,DIRECT"]
+    });
+    if let Some(smux) = smux {
+        raw["proxies"][0]["smux"] = smux;
+    }
+    if matches!(placement, "header" | "cookie") {
+        raw["proxies"][0]["xhttp-opts"]["uplink-data-key"] = "payload".into();
+    }
+    if split {
+        raw["proxies"][0]["xhttp-opts"]["download-settings"] = serde_json::json!({
+            "server":"download.example", "port":8443, "tls":true, "alpn":["h3"]});
+    }
+    let config = crate::config::Config::parse_yaml(raw.to_string().as_bytes()).unwrap();
+    let proxy = &config.proxies[0];
+    let crate::config::ProxyProtocol::Vless(settings) = &proxy.protocol else {
+        panic!("not VLESS")
+    };
+    let endpoint = |name: &str, port| crate::dialer::ResolvedEndpoint {
+        logical_host: name.into(),
+        port,
+        addresses: vec![SocketAddr::from(([192, 0, 2, 2], port))],
+    };
+    let mut node = VlessOutbound::new_with_endpoints(
+        settings,
+        endpoint("example.com", 443),
+        split.then(|| endpoint("download.example", 8443)),
+        crate::dialer::Dialer::default(),
+    )
+    .unwrap();
+    node.configure_shared_xhttp_transport(proxy.smux.as_ref());
+    node
+}
+fn shared_node(placement: &str) -> VlessOutbound {
+    node(
+        Some(
+            serde_json::json!({"enabled":true, "protocol":"h2mux", "only-tcp":false,
+        "padding":false}),
+        ),
+        placement,
+        false,
+    )
+}
+fn payload(sequence: usize) -> Vec<u8> {
+    payload_len(sequence, BATCH)
+}
+fn payload_len(sequence: usize, length: usize) -> Vec<u8> {
+    (0..length).map(|offset| byte(sequence, offset)).collect()
+}
+fn byte(sequence: usize, offset: usize) -> u8 {
+    ((offset + 17 * sequence) % 251) as u8
+}
+async fn accept(peer: &mut Peer, session: &str, sequence: usize) -> PeerStream {
+    let (request, stream) = peer
+        .accept()
+        .await
+        .unwrap()
+        .unwrap()
+        .resolve_request()
+        .await
+        .unwrap();
+    assert_eq!(request.method(), http::Method::POST);
+    assert_eq!(request.uri().path(), format!("/x/{session}/{sequence}"));
+    stream
+}
+async fn body(stream: &mut PeerStream, sequence: usize) {
+    body_len(stream, sequence, BATCH).await;
+}
+async fn body_len(stream: &mut PeerStream, sequence: usize, length: usize) {
+    let mut count = 0;
+    while let Some(mut data) = stream.recv_data().await.unwrap() {
+        while data.has_remaining() {
+            assert!(count < length, "body exceeded its one bounded batch");
+            assert_eq!(data.get_u8(), byte(sequence, count));
+            count += 1;
+        }
+    }
+    assert_eq!(count, length);
+    assert!(stream.recv_trailers().await.unwrap().is_none());
+}
+async fn respond(stream: &mut PeerStream, status: u16) {
+    stream
+        .send_response(http::Response::builder().status(status).body(()).unwrap())
+        .await
+        .unwrap();
+    stream.finish().await.unwrap();
+}
+async fn pending_write(writer: &mut packet_up::Writer) {
+    assert!(
+        std::future::poll_fn(|cx| Poll::Ready(Pin::new(&mut *writer).poll_write(cx, b"third")))
+            .await
+            .is_pending(),
+        "nonempty third write crossed the response bound"
+    );
+}
+async fn pending_flush(writer: &mut packet_up::Writer) {
+    assert!(
+        std::future::poll_fn(|cx| Poll::Ready(Pin::new(&mut *writer).poll_flush(cx)))
+            .await
+            .is_pending(),
+        "unacknowledged bytes crossed strong flush"
+    );
+}
+fn finish(result: Result<Result<(), tokio::time::error::Elapsed>, Box<dyn std::any::Any + Send>>) {
+    match result {
+        Ok(result) => result.expect("actual H3 feedback fixture timed out"),
+        Err(panic) => resume_unwind(panic),
+    }
+}
+
+#[tokio::test(start_paused = true)]
+async fn qualified_default_partial_post_reaches_h3_before_ten_ms_with_strong_receipt() {
+    let node = shared_node("body");
+    let (client, _) = node.test_xhttp_clients().unwrap();
+    let mut fixture = Fixture::new(client, false, 16, 256 * 1024);
+    let result = AssertUnwindSafe(timeout(LIMIT, async {
+        let mut peer = fixture.initialize().await;
+        let (arrived, arrival) = oneshot::channel();
+        let (release, released) = oneshot::channel();
+        fixture.spawn(async move {
+            let mut first = accept(&mut peer, "default-five", 0).await;
+            let at = tokio::time::Instant::now();
+            body_len(&mut first, 0, 64).await;
+            arrived.send(at).unwrap();
+            released.await.unwrap();
+            respond(&mut first, 200).await;
+            let _ = peer.accept().await;
+        });
+        let mut writer = fixture.writer("default-five");
+        let began = tokio::time::Instant::now();
+        writer.write_all(&payload_len(0, 64)).await.unwrap();
+        let at = arrival.await.unwrap();
+        // Real peer headers/body/FIN are observed, not the delay expression.
+        // Arrival may include transport service; the preceding 5 ms default
+        // cannot pass this bound even when its transport service is immediate.
+        let elapsed = at - began;
+        assert!(
+            elapsed >= Duration::from_millis(2),
+            "partial POST bypassed aggregation"
+        );
+        assert!(
+            elapsed < Duration::from_millis(5),
+            "qualified default still waited five ms"
+        );
+        assert_eq!(writer.snapshot().accepted, 64);
+        assert_eq!(writer.snapshot().committed, 0);
+        pending_flush(&mut writer).await;
+        release.send(()).unwrap();
+        writer.flush().await.unwrap();
+        assert_eq!(writer.snapshot().committed, 64);
+        writer.shutdown().await.unwrap();
+    }))
+    .catch_unwind()
+    .await;
+    fixture.stop().await;
+    node.shutdown().await;
+    finish(result);
+}
+
+#[tokio::test]
+async fn two_held_post_responses_reuse_one_body_backing_and_bound_the_third_write() {
+    for placement in ["body", "auto"] {
+        let node = shared_node(placement);
+        let (client, download) = node.test_xhttp_clients().unwrap();
+        assert!(download.is_none());
+        let mut fixture = Fixture::new(client, false, 16, 256 * 1024);
+        let result = AssertUnwindSafe(timeout(LIMIT, async {
+            let mut peer = fixture.initialize().await;
+            let (first, arrived_first) = oneshot::channel();
+            let (second, arrived_second) = oneshot::channel();
+            let (release, released) = oneshot::channel();
+            fixture.spawn(async move {
+                let mut a = accept(&mut peer, "two", 0).await;
+                body(&mut a, 0).await;
+                first.send(()).unwrap();
+                let mut b = accept(&mut peer, "two", 1).await;
+                body(&mut b, 1).await;
+                second.send(()).unwrap();
+                released.await.unwrap();
+                respond(&mut a, 200).await;
+                respond(&mut b, 200).await;
+                let _ = peer.accept().await;
+            });
+            let mut writer = fixture.writer("two");
+            writer.write_all(&payload(0)).await.unwrap();
+            // This immediate read occurs before yielding to the worker in the
+            // current-thread runtime. Do not inspect the taken/empty Vec later.
+            let first = writer.snapshot();
+            assert_eq!(first.buffer_len, BATCH);
+            assert_eq!(first.buffer_capacity, BATCH);
+            arrived_first.await.unwrap();
+            writer.write_all(&payload(1)).await.unwrap();
+            let second = writer.snapshot();
+            assert_eq!(second.buffer_len, BATCH);
+            assert_eq!(second.buffer_capacity, BATCH);
+            assert_eq!(
+                second.buffer_ptr, first.buffer_ptr,
+                "the body backing must be recovered, not copied into a parallel workspace"
+            );
+            arrived_second.await.unwrap();
+            pending_write(&mut writer).await;
+            pending_flush(&mut writer).await;
+            assert_eq!(writer.snapshot().accepted, (2 * BATCH) as u64);
+            assert_eq!(writer.snapshot().committed, 0);
+            release.send(()).unwrap();
+            writer.flush().await.unwrap();
+            writer.shutdown().await.unwrap();
+            assert_eq!(writer.snapshot().committed, (2 * BATCH) as u64);
+        }))
+        .catch_unwind()
+        .await;
+        fixture.stop().await;
+        node.shutdown().await;
+        finish(result);
+    }
+}
+
+#[tokio::test]
+async fn consumed_second_response_cannot_cross_a_failed_first_response_hole() {
+    let node = shared_node("body");
+    let (client, _) = node.test_xhttp_clients().unwrap();
+    let mut fixture = Fixture::new(client, false, 16, 256 * 1024);
+    let result = AssertUnwindSafe(timeout(LIMIT, async {
+        let mut peer = fixture.initialize().await;
+        let (second, arrived_second) = oneshot::channel();
+        let (fail_first, failed_first) = oneshot::channel();
+        fixture.spawn(async move {
+            let mut a = accept(&mut peer, "hole", 0).await;
+            body(&mut a, 0).await;
+            let mut b = accept(&mut peer, "hole", 1).await;
+            body(&mut b, 1).await;
+            respond(&mut b, 200).await;
+            second.send(()).unwrap();
+            failed_first.await.unwrap();
+            respond(&mut a, 500).await;
+            // A fresh writer on this same live H3 connection is a positive
+            // barrier: a replayed failed session would not match this request.
+            let mut control = accept(&mut peer, "control", 0).await;
+            body(&mut control, 0).await;
+            respond(&mut control, 200).await;
+            let _ = peer.accept().await;
+        });
+        let mut writer = fixture.writer("hole");
+        writer.write_all(&payload(0)).await.unwrap();
+        writer.write_all(&payload(1)).await.unwrap();
+        arrived_second.await.unwrap();
+        loop {
+            let seen = writer.snapshot();
+            if seen.ready_out_of_order {
+                assert_eq!(seen.occupied_responses, 2);
+                assert_eq!(seen.ready_responses, 1);
+                assert_eq!(seen.committed, 0);
+                break;
+            }
+            tokio::task::yield_now().await;
+        }
+        // These are checks after actual response consumption, not a race with
+        // an unpolled response future. Pending alone would be insufficient.
+        pending_write(&mut writer).await;
+        pending_flush(&mut writer).await;
+        fail_first.send(()).unwrap();
+        let failure = writer.flush().await.unwrap_err();
+        assert!(
+            failure.to_string().contains("HTTP status 500"),
+            "wrong failure: {failure}"
+        );
+        assert_eq!(writer.snapshot().committed, 0);
+        assert!(writer.write_all(b"no replay").await.is_err());
+        let mut control = fixture.writer("control");
+        control.write_all(&payload(0)).await.unwrap();
+        control.flush().await.unwrap();
+        control.shutdown().await.unwrap();
+    }))
+    .catch_unwind()
+    .await;
+    fixture.stop().await;
+    node.shutdown().await;
+    finish(result);
+}
+
+#[tokio::test]
+async fn one_peer_stream_credit_jointly_drives_old_response_and_next_open() {
+    let node = shared_node("body");
+    let (client, _) = node.test_xhttp_clients().unwrap();
+    let mut fixture = Fixture::new(client, false, 1, 256 * 1024);
+    let result = AssertUnwindSafe(timeout(LIMIT, async {
+        let mut peer = fixture.initialize().await;
+        let (first, arrived_first) = oneshot::channel();
+        let (release, released) = oneshot::channel();
+        let (second, arrived_second) = oneshot::channel();
+        fixture.spawn(async move {
+            let mut a = accept(&mut peer, "credit", 0).await;
+            body(&mut a, 0).await;
+            first.send(()).unwrap();
+            released.await.unwrap();
+            respond(&mut a, 200).await;
+            drop(a);
+            let mut b = accept(&mut peer, "credit", 1).await;
+            body(&mut b, 1).await;
+            second.send(()).unwrap();
+            respond(&mut b, 200).await;
+            let _ = peer.accept().await;
+        });
+        let mut writer = fixture.writer("credit");
+        writer.write_all(&payload(0)).await.unwrap();
+        arrived_first.await.unwrap();
+        writer.write_all(&payload(1)).await.unwrap();
+        pending_write(&mut writer).await;
+        pending_flush(&mut writer).await;
+        release.send(()).unwrap();
+        arrived_second.await.unwrap();
+        writer.flush().await.unwrap();
+        writer.shutdown().await.unwrap();
+        assert_eq!(writer.snapshot().committed, (2 * BATCH) as u64);
+    }))
+    .catch_unwind()
+    .await;
+    fixture.stop().await;
+    node.shutdown().await;
+    finish(result);
+}
+
+#[tokio::test]
+async fn early_rejection_of_a_credit_blocked_body_cancels_and_joins_stop() {
+    let node = shared_node("body");
+    let (client, _) = node.test_xhttp_clients().unwrap();
+    let mut fixture = Fixture::new(client, false, 16, 32 * 1024);
+    let result = AssertUnwindSafe(timeout(LIMIT, async {
+        let mut peer = fixture.initialize().await;
+        let (prefix, saw_prefix) = oneshot::channel();
+        let (reject, rejected) = oneshot::channel();
+        fixture.spawn(async move {
+            let mut a = accept(&mut peer, "early", 0).await;
+            let data = a.recv_data().await.unwrap().unwrap();
+            let count = data.remaining();
+            assert!(count > 0 && count < BATCH);
+            drop(data);
+            prefix.send(count).unwrap();
+            // No further request reads: the 32 KiB stream credit plus that
+            // one consumed prefix cannot deliver this full 128 KiB body/FIN.
+            rejected.await.unwrap();
+            respond(&mut a, 500).await;
+            let _ = peer.accept().await;
+            drop(a);
+        });
+        let mut writer = fixture.writer("early");
+        writer.write_all(&payload(0)).await.unwrap();
+        assert!(saw_prefix.await.unwrap() < BATCH);
+        assert!(writer.snapshot().in_flight);
+        pending_write(&mut writer).await;
+        pending_flush(&mut writer).await;
+        reject.send(()).unwrap();
+        let failure = writer.flush().await.unwrap_err();
+        assert!(
+            failure.to_string().contains("HTTP status 500"),
+            "early status must be consumed while body is blocked: {failure}"
+        );
+        fixture.client.stop().await;
+        assert!(writer.write_all(b"after Stop").await.is_err());
+    }))
+    .catch_unwind()
+    .await;
+    fixture.stop().await;
+    node.shutdown().await;
+    finish(result);
+}
+
+#[tokio::test]
+async fn dropping_a_completed_upload_preserves_its_fin_sibling_and_active_stop() {
+    let node = shared_node("body");
+    let (client, _) = node.test_xhttp_clients().unwrap();
+    let mut fixture = Fixture::new(client, false, 16, 256 * 1024);
+    let result = AssertUnwindSafe(timeout(LIMIT, async {
+        let mut peer = fixture.initialize().await;
+        let (first, arrived_first) = oneshot::channel();
+        let (check, checked) = oneshot::channel();
+        let (fin, fin_checked) = oneshot::channel();
+        let (active, arrived_active) = oneshot::channel();
+        fixture.spawn(async move {
+            let mut a = accept(&mut peer, "drop", 0).await;
+            body(&mut a, 0).await;
+            first.send(()).unwrap();
+            let mut b = accept(&mut peer, "sibling", 0).await;
+            body(&mut b, 0).await;
+            checked.await.unwrap();
+            assert!(
+                a.recv_data().await.unwrap().is_none(),
+                "completed request FIN became a reset/error"
+            );
+            fin.send(()).unwrap();
+            respond(&mut b, 200).await;
+            let mut c = accept(&mut peer, "active", 0).await;
+            body(&mut c, 0).await;
+            active.send(()).unwrap();
+            // Hold both pending responses until the owner's real Stop.
+            let _ = peer.accept().await;
+            drop((a, c));
+        });
+        let mut dropped = fixture.writer("drop");
+        dropped.write_all(&payload(0)).await.unwrap();
+        arrived_first.await.unwrap();
+        pending_flush(&mut dropped).await;
+        drop(dropped);
+        let mut sibling = fixture.writer("sibling");
+        sibling.write_all(&payload(0)).await.unwrap();
+        check.send(()).unwrap();
+        fin_checked.await.unwrap();
+        sibling.flush().await.unwrap();
+        sibling.shutdown().await.unwrap();
+        let mut active = fixture.writer("active");
+        active.write_all(&payload(0)).await.unwrap();
+        arrived_active.await.unwrap();
+        pending_flush(&mut active).await;
+        fixture.client.stop().await;
+        assert!(active.flush().await.is_err());
+        assert!(active.write_all(b"after Stop").await.is_err());
+    }))
+    .catch_unwind()
+    .await;
+    fixture.stop().await;
+    node.shutdown().await;
+    finish(result);
+}
+
+async fn serial_post(peer: &mut Peer, placement: &str, sequence: usize) -> PeerStream {
+    let (request, mut stream) = peer
+        .accept()
+        .await
+        .unwrap()
+        .unwrap()
+        .resolve_request()
+        .await
+        .unwrap();
+    assert_eq!(request.method(), http::Method::POST);
+    assert_eq!(request.uri().path(), format!("/x/serial/{sequence}"));
+    if placement == "body" {
+        body_len(&mut stream, sequence, 64).await;
+    } else {
+        let encoded = if placement == "header" {
+            request
+                .headers()
+                .get("payload-0")
+                .unwrap()
+                .to_str()
+                .unwrap()
+        } else {
+            request
+                .headers()
+                .get(http::header::COOKIE)
+                .unwrap()
+                .to_str()
+                .unwrap()
+                .split("; ")
+                .find_map(|entry| entry.strip_prefix("payload_0="))
+                .unwrap()
+        };
+        let bytes = base64::engine::general_purpose::URL_SAFE_NO_PAD
+            .decode(encoded)
+            .unwrap();
+        assert_eq!(bytes, payload_len(sequence, 64));
+        assert!(
+            stream.recv_data().await.unwrap().is_none(),
+            "metadata payload has no HTTP body"
+        );
+        assert!(stream.recv_trailers().await.unwrap().is_none());
+    }
+    stream
+}
+
+#[tokio::test]
+async fn normalized_ineligible_factories_keep_one_unacknowledged_body() {
+    // Small writes avoid conflating the header/cookie request budget with the
+    // serial-response gate. Full 128 KiB body geometry is tested separately.
+    let shared = || serde_json::json!({"enabled":true,"protocol":"h2mux","only-tcp":false});
+    let cases = [
+        (None, false, "body"),
+        (
+            Some(serde_json::json!({"enabled":true,"protocol":"h2mux","only-tcp":true})),
+            false,
+            "body",
+        ),
+        (
+            Some(serde_json::json!({"enabled":true,"protocol":"h2mux","padding":true})),
+            false,
+            "body",
+        ),
+        (
+            Some(serde_json::json!({"enabled":true,"protocol":"yamux","only-tcp":false})),
+            false,
+            "body",
+        ),
+        (
+            Some(serde_json::json!({"enabled":true,"protocol":"smux","only-tcp":false})),
+            false,
+            "body",
+        ),
+        (
+            Some(serde_json::json!({"enabled":false,"protocol":"h2mux","only-tcp":false})),
+            false,
+            "body",
+        ),
+        (Some(shared()), true, "body"),
+        (Some(shared()), false, "header"),
+        (Some(shared()), false, "cookie"),
+    ];
+    for (smux, split, placement) in cases {
+        let node = node(smux, placement, split);
+        let (upload, download) = node.test_xhttp_clients().unwrap();
+        for (client, is_download) in
+            std::iter::once((upload, false)).chain(download.map(|c| (c, true)))
+        {
+            let mut fixture = Fixture::new(client, is_download, 16, 256 * 1024);
+            let result = AssertUnwindSafe(timeout(LIMIT, async {
+                let mut peer = fixture.initialize().await;
+                if let SendRequest::H3(sender) = fixture.sender.as_ref().unwrap() {
+                    assert!(
+                        sender.udp_control.is_none(),
+                        "excluded physical got a UDP raise control"
+                    );
+                }
+                let (first, arrived_first) = oneshot::channel();
+                let (release, released) = oneshot::channel();
+                fixture.spawn(async move {
+                    let mut a = serial_post(&mut peer, placement, 0).await;
+                    first.send(()).unwrap();
+                    released.await.unwrap();
+                    respond(&mut a, 200).await;
+                    let mut b = serial_post(&mut peer, placement, 1).await;
+                    respond(&mut b, 200).await;
+                    let _ = peer.accept().await;
+                });
+                let mut writer = fixture.writer("serial");
+                writer.write_all(&payload_len(0, 64)).await.unwrap();
+                arrived_first.await.unwrap();
+                assert_eq!(writer.snapshot().accepted, 64);
+                assert_eq!(writer.snapshot().committed, 0);
+                assert!(
+                    std::future::poll_fn(|cx| Poll::Ready(
+                        Pin::new(&mut writer).poll_write(cx, &payload_len(1, 64))
+                    ))
+                    .await
+                    .is_pending(),
+                    "ineligible factory admitted a second write while first status was held"
+                );
+                pending_flush(&mut writer).await;
+                release.send(()).unwrap();
+                writer.write_all(&payload_len(1, 64)).await.unwrap();
+                writer.flush().await.unwrap();
+                writer.shutdown().await.unwrap();
+                assert_eq!(writer.snapshot().committed, 128);
+            }))
+            .catch_unwind()
+            .await;
+            fixture.stop().await;
+            if !matches!(&result, Ok(Ok(()))) {
+                node.shutdown().await;
+                finish(result);
+            }
+        }
+        node.shutdown().await;
+    }
+}
+
+#[cfg(feature = "interop-test")]
+#[path = "h3_udp_budget_memory_tests.rs"]
+mod udp_budget;
diff --git a/src/transport/xhttp/h3_udp_budget_memory_tests.rs b/src/transport/xhttp/h3_udp_budget_memory_tests.rs
new file mode 100644
index 0000000..69a78b2
--- /dev/null
+++ b/src/transport/xhttp/h3_udp_budget_memory_tests.rs
@@ -0,0 +1,469 @@
+//! Actual VLESS -> XHTTP/H3 -> inner h2mux over bounded in-memory datagrams.
+//! Raw native probes run only while the H3 acceptor is parked, never as HTTP data.
+use super::*;
+use crate::outbound::{
+    ConnectedStream, DatagramRequest, EstablishContext, SingMuxConnector, UpstreamPath,
+};
+use crate::session::{DatagramSession, InboundKind, StreamSession};
+use std::sync::atomic::AtomicU8;
+use tokio::io::AsyncReadExt;
+use tokio_util::task::TaskTracker;
+
+#[derive(Default)]
+struct NoNetwork {
+    calls: AtomicUsize,
+}
+#[async_trait]
+impl OutboundConnector for NoNetwork {
+    async fn connect_stream(
+        &self,
+        _: StreamSession,
+        context: &EstablishContext,
+    ) -> Result<ConnectedStream, DispatchError> {
+        assert!(
+            context.h3_udp_capture().is_none(),
+            "capture crossed a TCP proxy hop"
+        );
+        self.calls.fetch_add(1, Ordering::SeqCst);
+        Err(DispatchError::NotAllowed)
+    }
+    async fn open_datagram(
+        &self,
+        _: DatagramRequest,
+        context: &EstablishContext,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        assert!(
+            context.h3_udp_capture().is_none(),
+            "capture crossed a datagram proxy hop"
+        );
+        self.calls.fetch_add(1, Ordering::SeqCst);
+        Err(DispatchError::NotAllowed)
+    }
+}
+fn configured() -> (SingMuxConnector, XHttpClient, Arc<NoNetwork>) {
+    let config = crate::config::Config::parse_yaml(
+        br#"proxies:
+- name: fixture
+  type: vless
+  server: 192.0.2.2
+  port: 443
+  uuid: 00000000-0000-0000-0000-000000000001
+  tls: true
+  servername: localhost
+  network: xhttp
+  alpn: [h3]
+  smux: {enabled: true, protocol: h2mux, max-connections: 1, only-tcp: false}
+  xhttp-opts:
+    path: /x
+    mode: packet-up
+    reuse-settings: {h-max-request-times: '4'}
+rules: ['MATCH,DIRECT']
+"#,
+    )
+    .unwrap();
+    let proxy = &config.proxies[0];
+    let crate::config::ProxyProtocol::Vless(settings) = &proxy.protocol else {
+        panic!("not VLESS")
+    };
+    let upstream = Arc::new(NoNetwork::default());
+    let mut vless = VlessOutbound::new_with_upstream(settings, upstream.clone()).unwrap();
+    vless.configure_shared_xhttp_transport(proxy.smux.as_ref());
+    let client = vless.test_xhttp_clients().unwrap().0;
+    let mux = SingMuxConnector::new(Arc::new(vless), proxy.smux.clone().unwrap())
+        .with_autonomous_xhttp(proxy);
+    (mux, client, upstream)
+}
+fn tcp_session() -> StreamSession {
+    StreamSession {
+        metadata: Default::default(),
+        inbound: InboundKind::Tun,
+        source: "192.0.2.10:40000".parse().unwrap(),
+        destination: Destination::Ip("192.0.2.9:443".parse().unwrap()),
+        sniffed_domain: None,
+    }
+}
+fn udp_request() -> DatagramRequest {
+    DatagramRequest::new(DatagramSession::new(
+        InboundKind::Tun,
+        "192.0.2.10:40001".parse().unwrap(),
+    ))
+}
+#[derive(Default)]
+struct Behavior {
+    next_post: AtomicU8, //0=normal,1=reject,2=hold the genuine POST response.
+    entered: tokio::sync::Notify,
+    release: tokio::sync::Notify,
+}
+struct Bridge {
+    park: mpsc::Sender<oneshot::Sender<Peer>>,
+    resume: mpsc::Sender<Peer>,
+    behavior: Arc<Behavior>,
+}
+impl Bridge {
+    async fn park(&self) -> Peer {
+        let (send, receive) = oneshot::channel();
+        assert!(self.park.send(send).await.is_ok());
+        receive.await.unwrap()
+    }
+    async fn resume(&self, peer: Peer) {
+        assert!(self.resume.send(peer).await.is_ok());
+    }
+}
+fn tracked(
+    tasks: &TaskTracker,
+    cancel: &CancellationToken,
+    future: impl Future<Output = ()> + Send + 'static,
+) {
+    let cancel = cancel.clone();
+    tasks.spawn(async move {
+        tokio::select! { biased; ()=cancel.cancelled()=>{}, ()=future=>{} }
+    });
+}
+fn bridge(fixture: &mut Fixture, mut peer: Peer) -> Bridge {
+    let (client, mut server) = tokio::io::duplex(256 * 1024);
+    let (up, down) = tokio::io::split(client);
+    let write = Arc::new(tokio::sync::Mutex::new((0_u64, down)));
+    let advanced = Arc::new(tokio::sync::Notify::new());
+    let (park, mut parks) = mpsc::channel::<oneshot::Sender<Peer>>(1);
+    let (resume, mut resumes) = mpsc::channel(1);
+    let behavior = Arc::new(Behavior::default());
+    let behavior_task = behavior.clone();
+    let cancel = fixture.cancel.clone();
+    fixture.tasks.push(tokio::spawn(async move {
+        let children = TaskTracker::new();
+        let mut read = Some(up);
+        loop {
+            tokio::select! { biased;
+                ()=cancel.cancelled()=>break,
+                Some(reply)=parks.recv()=>{
+                    assert!(reply.send(peer).is_ok());
+                    let returned=tokio::select! { biased; ()=cancel.cancelled()=>None, returned=resumes.recv()=>returned }; let Some(returned)=returned else { break; };
+                    peer=returned;
+                },
+                accepted=peer.accept()=>{
+                    let Ok(Some(resolver))=accepted else { break; };
+                    let Ok((request,mut stream))=resolver.resolve_request().await else { break; };
+                    if request.method()==http::Method::GET {
+                        let mut read=read.take().expect("one genuine XHTTP carrier GET");
+                        tracked(&children,&cancel,async move {
+                            if stream.send_response(http::Response::new(())).await.is_err(){return;}
+                            let mut bytes=[0;16*1024];
+                            loop {
+                                let Ok(count)=read.read(&mut bytes).await else {return;};
+                                if count==0 {let _=stream.finish().await;return;}
+                                if stream.send_data(Bytes::copy_from_slice(&bytes[..count])).await.is_err(){return;}
+                            }
+                        });
+                    } else {
+                        assert_eq!(request.method(),http::Method::POST);
+                        let sequence=request.uri().path().rsplit('/').next().unwrap().parse::<u64>().unwrap();
+                        let write=write.clone(); let advanced=advanced.clone(); let behavior=behavior_task.clone();
+                        tracked(&children,&cancel,async move {
+                            // Request task scheduling is not a POST sequence oracle.
+                            // Fixed next_seq + the existing stream suffice: no map or
+                            // second payload buffer, and responses can still overlap.
+                            let mut ordered=loop {
+                                let changed=advanced.notified();tokio::pin!(changed);changed.as_mut().enable();
+                                let ordered=write.lock().await;
+                                assert!(sequence>=ordered.0,"duplicate POST sequence");
+                                if sequence==ordered.0 {break ordered;}
+                                drop(ordered);changed.await;
+                            };
+                            loop {
+                                let mut data=match stream.recv_data().await {
+                                    Ok(Some(data))=>data, Ok(None)=>break, Err(_)=>return,
+                                };
+                                while data.has_remaining() {
+                                    let bytes=data.copy_to_bytes(data.remaining());
+                                    if ordered.1.write_all(&bytes).await.is_err(){return;}
+                                }
+                            }
+                            if ordered.1.flush().await.is_err(){return;}
+                            ordered.0=ordered.0.checked_add(1).unwrap();
+                            drop(ordered);advanced.notify_waiters();
+                            let mode=behavior.next_post.swap(0,Ordering::SeqCst);
+                            if mode!=0 {behavior.entered.notify_one();}
+                            if mode==2 {behavior.release.notified().await;}
+                            let status=if mode==1 {500}else{200};
+                            if stream.send_response(http::Response::builder().status(status).body(()).unwrap()).await.is_ok(){let _=stream.finish().await;}
+                        });
+                    }
+                }
+            }
+        }
+        children.close();children.wait().await;
+    }));
+    // Real VLESS authentication bytes and mux protocol preface, then real h2.
+    let cancel = fixture.cancel.clone();
+    fixture.tasks.push(tokio::spawn(async move {
+        let children = TaskTracker::new();
+        let operation = async {
+            let destination = Destination::domain("sp.mux.sing-box.arpa", 444).unwrap();
+            let expected = crate::outbound::encode_request_header(
+                uuid::Uuid::from_u128(1),
+                crate::outbound::VlessCommand::Tcp,
+                Some(&destination),
+            )
+            .unwrap();
+            let mut header = vec![0; expected.len()];
+            server.read_exact(&mut header).await.unwrap();
+            assert_eq!(header.as_slice(), expected.as_ref());
+            server.write_all(&[0, 0]).await.unwrap();
+            server.flush().await.unwrap();
+            let mut protocol = [0; 2];
+            server.read_exact(&mut protocol).await.unwrap();
+            assert_eq!(protocol, [0, 2]);
+            let mut connection = h2::server::handshake(server).await.unwrap();
+            while let Some(Ok((request, mut response))) = connection.accept().await {
+                tracked(&children, &cancel, async move {
+                    let mut input = request.into_body();
+                    let Some(Ok(first)) = input.data().await else {
+                        return;
+                    };
+                    let mut metadata = first.to_vec();
+                    input.flow_control().release_capacity(first.len()).unwrap();
+                    assert!(metadata.len() >= 2);
+                    let udp = metadata[..2] == [0, 3];
+                    assert!(udp || metadata[..2] == [0, 0]);
+                    let target = if udp {
+                        Destination::domain("sp.mux.sing-box.arpa", 444).unwrap()
+                    } else {
+                        tcp_session().destination
+                    };
+                    let mut expected = vec![0, if udp { 3 } else { 0 }];
+                    crate::socks5::encode_address(&target, &mut expected).unwrap();
+                    while metadata.len() < expected.len() {
+                        let Some(Ok(bytes)) = input.data().await else {
+                            return;
+                        };
+                        metadata.extend_from_slice(&bytes);
+                        input.flow_control().release_capacity(bytes.len()).unwrap();
+                    }
+                    assert_eq!(metadata, expected);
+                    let Ok(mut output) = response.send_response(http::Response::new(()), false)
+                    else {
+                        return;
+                    };
+                    output.send_data(Bytes::from_static(&[0]), false).unwrap();
+                    while let Some(Ok(bytes)) = input.data().await {
+                        input.flow_control().release_capacity(bytes.len()).unwrap();
+                        if output.send_data(bytes, false).is_err() {
+                            return;
+                        }
+                    }
+                    let _ = output.send_data(Bytes::new(), true);
+                });
+            }
+        };
+        tokio::select! {biased;()=cancel.cancelled()=>{},()=operation=>{}}
+        children.close();
+        children.wait().await;
+    }));
+    Bridge {
+        park,
+        resume,
+        behavior,
+    }
+}
+fn native(fixture: &Fixture) -> quinn::Connection {
+    let SendRequest::H3(sender) = fixture.sender.as_ref().unwrap() else {
+        panic!("not H3")
+    };
+    sender.observation.clone()
+}
+async fn native_prefix(fixture: &Fixture, native: &quinn::Connection, raised: bool) {
+    let server = fixture.native_peer.as_ref().unwrap();
+    let mut warm = native.open_bi().await.unwrap().0;
+    warm.write_all(b"warm").await.unwrap();
+    warm.finish().unwrap();
+    let (_, mut receive) = server.accept_bi().await.unwrap();
+    assert_eq!(receive.read_to_end(4).await.unwrap(), b"warm");
+    assert_eq!(warm.stopped().await.unwrap(), None);
+    fixture.gate.set(true);
+    let (mut send, _) = native.open_bi().await.unwrap();
+    let bytes = vec![0xa5; 256 * 1024];
+    let prefix = send.write(&bytes).await.unwrap();
+    if raised {
+        assert!(
+            prefix > 160 * 1024 && prefix <= 192 * 1024,
+            "raised prefix={prefix}"
+        );
+    } else {
+        assert!(prefix > 0 && prefix <= 64 * 1024, "initial prefix={prefix}");
+    }
+    assert!(
+        std::future::poll_fn(|cx| Poll::Ready(Pin::new(&mut send).poll_write(cx, b"blocked")))
+            .await
+            .is_pending()
+    );
+    fixture.gate.set(false);
+    let (finished, delivered) = tokio::join!(
+        async {
+            send.write_all(&bytes[prefix..]).await.unwrap();
+            send.finish().unwrap();
+            send.stopped().await.unwrap()
+        },
+        async {
+            let (_, mut receive) = server.accept_bi().await.unwrap();
+            receive.read_to_end(bytes.len()).await.unwrap()
+        }
+    );
+    assert_eq!(finished, None);
+    assert_eq!(delivered, bytes);
+}
+#[tokio::test]
+async fn udp_metadata_flush_raises_only_its_live_carrier_after_outer_retirement() {
+    let (mux, client, upstream) = configured();
+    let mut a = Fixture::new(client.clone(), false, 32, 256 * 1024);
+    let mut b = Fixture::new(client.clone(), false, 32, 256 * 1024);
+    let result = AssertUnwindSafe(timeout(LIMIT, async {
+        let peer = a.initialize().await;
+        let service = bridge(&mut a, peer);
+        let native_a = native(&a);
+        let SendRequest::H3(sender) = a.sender.as_ref().unwrap() else {
+            panic!("not H3")
+        };
+        let weak = Arc::downgrade(sender.udp_control.as_ref().unwrap());
+        let mut tcp = mux
+            .connect_stream(tcp_session(), &EstablishContext::default())
+            .await
+            .unwrap()
+            .io;
+        tcp.write_all(b"tcp").await.unwrap();
+        tcp.flush().await.unwrap();
+        let mut echoed = [0; 3];
+        tcp.read_exact(&mut echoed).await.unwrap();
+        assert_eq!(&echoed, b"tcp");
+        let parked = service.park().await;
+        native_prefix(&a, &native_a, false).await;
+        service.resume(parked).await;
+        let mut leases = Vec::new();
+        for _ in 0..2 {
+            let (_, lease) = client
+                .acquire(false, || async { Err(io::Error::other("must reuse A")) })
+                .await
+                .unwrap();
+            leases.push(lease);
+        }
+        // Four acquisitions exhaust A's real request-retirement budget. B's
+        // actual acquire removes A from candidates while A's carrier is alive.
+        let _peer_b = b.initialize().await;
+        let native_b = native(&b);
+        assert_ne!(native_a.stable_id(), native_b.stable_id());
+        a.sender.take();
+        assert!(
+            weak.upgrade().is_some(),
+            "live PacketUp writer lost its physical control after outer retirement"
+        );
+        let mut udp = mux
+            .open_datagram(udp_request(), &EstablishContext::default())
+            .await
+            .unwrap();
+        let packet = Datagram {
+            remote: Destination::Ip("192.0.2.9:53".parse().unwrap()),
+            payload: Bytes::from_static(b"udp"),
+            sniffed_domain: None,
+        };
+        udp.send(packet.clone()).await.unwrap();
+        let echoed = udp.receive().await.unwrap();
+        assert_eq!(echoed.remote, packet.remote);
+        assert_eq!(echoed.payload, packet.payload);
+        let parked = service.park().await;
+        native_prefix(&a, &native_a, true).await;
+        native_prefix(&b, &native_b, false).await;
+        // A clone losing eligibility cannot inherit B's raise-capable pool.
+        let mut ordinary = client.clone();
+        ordinary.set_shared_packet_up_transport(false);
+        let called = AtomicUsize::new(0);
+        assert!(
+            ordinary
+                .acquire(false, || async {
+                    called.fetch_add(1, Ordering::SeqCst);
+                    Err(io::Error::other("new ordinary pool"))
+                })
+                .await
+                .is_err()
+        );
+        assert_eq!(called.load(Ordering::SeqCst), 1);
+        let mut blocked = native_a.open_bi().await.unwrap().0;
+        a.gate.set(true);
+        assert!(blocked.write(&vec![1; 256 * 1024]).await.unwrap() > 0);
+        let mut pending = Box::pin(blocked.write_all(&[1; 16]));
+        assert!(
+            std::future::poll_fn(|cx| Poll::Ready(pending.as_mut().poll(cx)))
+                .await
+                .is_pending()
+        );
+        drop(pending);
+        mux.shutdown().await;
+        assert!(blocked.write(b"late").await.is_err());
+        drop(parked);
+        drop(leases);
+        drop(udp);
+        drop(tcp);
+        drop(native_a);
+        drop(native_b);
+        a.stop().await;
+        b.stop().await;
+        assert!(
+            weak.upgrade().is_none(),
+            "Weak extended the stopped physical owner"
+        );
+        assert_eq!(upstream.calls.load(Ordering::SeqCst), 0);
+    }))
+    .catch_unwind()
+    .await;
+    mux.shutdown().await;
+    a.stop().await;
+    b.stop().await;
+    finish(result);
+}
+#[tokio::test]
+async fn failed_or_cancelled_udp_metadata_does_not_invoke_the_physical_raise() {
+    for mode in [1, 2] {
+        let (mux, client, _) = configured();
+        let mut fixture = Fixture::new(client, false, 32, 256 * 1024);
+        let result=AssertUnwindSafe(timeout(LIMIT,async {
+            let peer=fixture.initialize().await;let service=bridge(&mut fixture,peer);
+            let SendRequest::H3(sender)=fixture.sender.as_ref().unwrap() else {panic!("not H3")};
+            let control=sender.udp_control.as_ref().unwrap().clone();assert!(!control.was_raised());
+            let mut tcp=mux.connect_stream(tcp_session(),&EstablishContext::default()).await.unwrap().io;
+            tcp.write_all(b"tcp").await.unwrap();tcp.flush().await.unwrap();let mut echo=[0;3];tcp.read_exact(&mut echo).await.unwrap();
+            service.behavior.next_post.store(mode,Ordering::SeqCst);
+            let context=EstablishContext::default();let mut opening=Box::pin(mux.open_datagram(udp_request(),&context));
+            if mode==1 {assert!(opening.await.is_err());}
+            else {
+                tokio::select!{biased;result=&mut opening=>panic!("held metadata flush completed: {}",result.is_ok()),()=service.behavior.entered.notified()=>{}}
+                assert!(std::future::poll_fn(|cx|Poll::Ready(opening.as_mut().poll(cx))).await.is_pending());drop(opening);
+            }
+            // This is the real selected physical's production once flag. Native
+            // credit itself is observed before/after the genuine successful
+            // association in the sibling test; do not consume cancellation's
+            // still-queued legitimate H3 POST as an unrelated raw probe.
+            assert!(!control.was_raised());drop(control);drop(tcp);mux.shutdown().await;
+        })).catch_unwind().await;
+        mux.shutdown().await;
+        fixture.stop().await;
+        finish(result);
+    }
+}
+#[tokio::test]
+async fn proxy_hops_clear_the_carrier_h3_capture_for_tcp_and_datagrams() {
+    let upstream = Arc::new(NoNetwork::default());
+    let path = UpstreamPath::proxy(upstream.clone());
+    let capture = UdpAssociationCapture::default();
+    let context = EstablishContext::default().capture_h3_udp(capture.clone());
+    assert!(
+        path.connect_server(
+            tcp_session(),
+            &Destination::Ip("192.0.2.2:443".parse().unwrap()),
+            &context
+        )
+        .await
+        .is_err()
+    );
+    assert!(path.open_datagram(udp_request(), &context).await.is_err());
+    assert_eq!(upstream.calls.load(Ordering::SeqCst), 2);
+    assert!(context.h3_udp_capture().is_some());
+    assert!(capture.take().is_none());
+}
diff --git a/src/transport/xhttp/h3_upload.rs b/src/transport/xhttp/h3_upload.rs
deleted file mode 100644
index 8831384..0000000
--- a/src/transport/xhttp/h3_upload.rs
+++ /dev/null
@@ -1,274 +0,0 @@
-//! Request-stream adapter for acknowledged QUIC upload completion. h3-quinn
-//! still owns the HTTP/3 control streams; h3 owns all HTTP encoding. Quinn's
-//! finish only queues FIN, so a logical close must also wait for stopped(None)
-//! before its last lease can close the physical connection. The XHTTP wrapper
-//! retains its one-second deadline and node Stop can cancel every wait.
-use bytes::{Buf, Bytes};
-use h3::quic::{self, ConnectionErrorIncoming, StreamErrorIncoming, StreamId, WriteBuf};
-use std::{
-    future::Future,
-    pin::Pin,
-    sync::Arc,
-    task::{Context, Poll, ready},
-};
-use tokio::io::{AsyncRead, ReadBuf};
-
-type Operation<T> = Pin<Box<dyn Future<Output = Result<T, StreamErrorIncoming>> + Send>>;
-
-pub(super) struct Connection {
-    control: h3_quinn::Connection,
-    open: OpenStreams,
-}
-
-impl Connection {
-    pub fn new(connection: quinn::Connection) -> Self {
-        let control = h3_quinn::Connection::new(connection.clone());
-        let open = OpenStreams {
-            control: <h3_quinn::Connection as quic::Connection<Bytes>>::opener(&control),
-            connection,
-            pending: None,
-        };
-        Self { control, open }
-    }
-}
-
-impl quic::Connection<Bytes> for Connection {
-    type RecvStream = h3_quinn::RecvStream;
-    type OpenStreams = OpenStreams;
-
-    fn poll_accept_recv(
-        &mut self,
-        cx: &mut Context<'_>,
-    ) -> Poll<Result<Self::RecvStream, ConnectionErrorIncoming>> {
-        <h3_quinn::Connection as quic::Connection<Bytes>>::poll_accept_recv(&mut self.control, cx)
-    }
-    fn poll_accept_bidi(
-        &mut self,
-        cx: &mut Context<'_>,
-    ) -> Poll<Result<BidiStream, ConnectionErrorIncoming>> {
-        // Clients advertise a zero incoming-bidirectional-stream limit. Keep
-        // upstream's connection-error handling if the peer violates it.
-        let _unexpected = ready!(
-            <h3_quinn::Connection as quic::Connection<Bytes>>::poll_accept_bidi(
-                &mut self.control,
-                cx
-            )
-        )?;
-        Poll::Ready(Err(ConnectionErrorIncoming::InternalError(
-            "unexpected HTTP/3 request stream".into(),
-        )))
-    }
-    fn opener(&self) -> OpenStreams {
-        self.open.clone()
-    }
-}
-
-pub(super) struct OpenStreams {
-    control: h3_quinn::OpenStreams,
-    connection: quinn::Connection,
-    pending: Option<Operation<(quinn::SendStream, quinn::RecvStream)>>,
-}
-
-impl Clone for OpenStreams {
-    fn clone(&self) -> Self {
-        Self {
-            control: self.control.clone(),
-            connection: self.connection.clone(),
-            pending: None,
-        }
-    }
-}
-
-impl quic::OpenStreams<Bytes> for OpenStreams {
-    type BidiStream = BidiStream;
-    type SendStream = h3_quinn::SendStream<Bytes>;
-
-    fn poll_open_bidi(
-        &mut self,
-        cx: &mut Context<'_>,
-    ) -> Poll<Result<BidiStream, StreamErrorIncoming>> {
-        let pending = self.pending.get_or_insert_with(|| {
-            let connection = self.connection.clone();
-            Box::pin(async move {
-                connection.open_bi().await.map_err(|error| {
-                    StreamErrorIncoming::ConnectionErrorIncoming {
-                        connection_error: ConnectionErrorIncoming::Undefined(Arc::new(error)),
-                    }
-                })
-            })
-        });
-        let result = ready!(pending.as_mut().poll(cx));
-        self.pending = None;
-        let (send, recv) = result?;
-        Poll::Ready(Ok(BidiStream {
-            send: SendStream {
-                raw: send,
-                queued: None,
-                completion: None,
-                finished: false,
-            },
-            recv: RecvStream(recv),
-        }))
-    }
-    fn poll_open_send(
-        &mut self,
-        cx: &mut Context<'_>,
-    ) -> Poll<Result<Self::SendStream, StreamErrorIncoming>> {
-        self.control.poll_open_send(cx)
-    }
-    fn close(&mut self, code: h3::error::Code, reason: &[u8]) {
-        <h3_quinn::OpenStreams as quic::OpenStreams<Bytes>>::close(&mut self.control, code, reason);
-    }
-}
-
-impl quic::OpenStreams<Bytes> for Connection {
-    type BidiStream = BidiStream;
-    type SendStream = h3_quinn::SendStream<Bytes>;
-    fn poll_open_bidi(
-        &mut self,
-        cx: &mut Context<'_>,
-    ) -> Poll<Result<BidiStream, StreamErrorIncoming>> {
-        self.open.poll_open_bidi(cx)
-    }
-    fn poll_open_send(
-        &mut self,
-        cx: &mut Context<'_>,
-    ) -> Poll<Result<Self::SendStream, StreamErrorIncoming>> {
-        self.open.poll_open_send(cx)
-    }
-    fn close(&mut self, code: h3::error::Code, reason: &[u8]) {
-        self.open.close(code, reason);
-    }
-}
-
-pub(super) struct BidiStream {
-    send: SendStream,
-    recv: RecvStream,
-}
-pub(super) struct SendStream {
-    raw: quinn::SendStream,
-    queued: Option<WriteBuf<Bytes>>,
-    completion: Option<Operation<()>>,
-    finished: bool,
-}
-pub(super) struct RecvStream(quinn::RecvStream);
-
-fn stream_error(error: impl std::error::Error + Send + Sync + 'static) -> StreamErrorIncoming {
-    StreamErrorIncoming::Unknown(Box::new(error))
-}
-
-impl quic::SendStream<Bytes> for SendStream {
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), StreamErrorIncoming>> {
-        if let Some(data) = &mut self.queued {
-            while data.has_remaining() {
-                let count = ready!(Pin::new(&mut self.raw).poll_write(cx, data.chunk()))
-                    .map_err(stream_error)?;
-                data.advance(count);
-            }
-        }
-        self.queued = None;
-        Poll::Ready(Ok(()))
-    }
-    fn poll_finish(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), StreamErrorIncoming>> {
-        if self.finished {
-            return Poll::Ready(Ok(()));
-        }
-        ready!(self.poll_ready(cx))?;
-        if self.completion.is_none() {
-            self.raw.finish().map_err(stream_error)?;
-            let stopped = self.raw.stopped();
-            self.completion = Some(Box::pin(async move {
-                match stopped.await.map_err(stream_error)? {
-                    None => Ok(()),
-                    Some(code) => Err(StreamErrorIncoming::StreamTerminated {
-                        error_code: code.into_inner(),
-                    }),
-                }
-            }));
-        }
-        let result = ready!(self.completion.as_mut().unwrap().as_mut().poll(cx));
-        self.completion = None;
-        self.finished = result.is_ok();
-        Poll::Ready(result)
-    }
-    fn send_data<D: Into<WriteBuf<Bytes>>>(&mut self, data: D) -> Result<(), StreamErrorIncoming> {
-        if self.queued.is_some() || self.completion.is_some() || self.finished {
-            return Err(stream_error(std::io::Error::other(
-                "HTTP/3 upload is not writable",
-            )));
-        }
-        self.queued = Some(data.into());
-        Ok(())
-    }
-    fn reset(&mut self, code: u64) {
-        let _ = self
-            .raw
-            .reset(quinn::VarInt::from_u64(code).unwrap_or(quinn::VarInt::MAX));
-    }
-    fn send_id(&self) -> StreamId {
-        u64::from(self.raw.id()).try_into().expect("QUIC stream ID")
-    }
-}
-
-impl quic::RecvStream for RecvStream {
-    type Buf = Bytes;
-    fn poll_data(
-        &mut self,
-        cx: &mut Context<'_>,
-    ) -> Poll<Result<Option<Bytes>, StreamErrorIncoming>> {
-        let mut bytes = [0; 16384];
-        let mut output = ReadBuf::new(&mut bytes);
-        ready!(Pin::new(&mut self.0).poll_read(cx, &mut output)).map_err(stream_error)?;
-        Poll::Ready(Ok(
-            (!output.filled().is_empty()).then(|| Bytes::copy_from_slice(output.filled()))
-        ))
-    }
-    fn stop_sending(&mut self, code: u64) {
-        let _ = self
-            .0
-            .stop(quinn::VarInt::from_u64(code).unwrap_or(quinn::VarInt::MAX));
-    }
-    fn recv_id(&self) -> StreamId {
-        u64::from(self.0.id()).try_into().expect("QUIC stream ID")
-    }
-}
-
-impl quic::SendStream<Bytes> for BidiStream {
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), StreamErrorIncoming>> {
-        self.send.poll_ready(cx)
-    }
-    fn poll_finish(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), StreamErrorIncoming>> {
-        self.send.poll_finish(cx)
-    }
-    fn send_data<D: Into<WriteBuf<Bytes>>>(&mut self, data: D) -> Result<(), StreamErrorIncoming> {
-        self.send.send_data(data)
-    }
-    fn reset(&mut self, code: u64) {
-        self.send.reset(code);
-    }
-    fn send_id(&self) -> StreamId {
-        self.send.send_id()
-    }
-}
-impl quic::RecvStream for BidiStream {
-    type Buf = Bytes;
-    fn poll_data(
-        &mut self,
-        cx: &mut Context<'_>,
-    ) -> Poll<Result<Option<Bytes>, StreamErrorIncoming>> {
-        self.recv.poll_data(cx)
-    }
-    fn stop_sending(&mut self, code: u64) {
-        self.recv.stop_sending(code);
-    }
-    fn recv_id(&self) -> StreamId {
-        self.recv.recv_id()
-    }
-}
-impl quic::BidiStream<Bytes> for BidiStream {
-    type SendStream = SendStream;
-    type RecvStream = RecvStream;
-    fn split(self) -> (SendStream, RecvStream) {
-        (self.send, self.recv)
-    }
-}
diff --git a/src/transport/xhttp/http1_memory_tests.rs b/src/transport/xhttp/http1_memory_tests.rs
new file mode 100644
index 0000000..a264a41
--- /dev/null
+++ b/src/transport/xhttp/http1_memory_tests.rs
@@ -0,0 +1,130 @@
+//! Exercise the production HTTP/1 encoder over scalar, partially writable IO.
+use super::*;
+use std::sync::{
+    Arc,
+    atomic::{AtomicUsize, Ordering},
+};
+use tokio::io::{AsyncBufReadExt, AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt, ReadBuf};
+
+struct BodyIo {
+    inner: tokio::io::DuplexStream,
+    body: Bytes,
+    original_bytes_written: Arc<AtomicUsize>,
+    largest_body_write: Arc<AtomicUsize>,
+}
+
+impl AsyncRead for BodyIo {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        output: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.inner).poll_read(cx, output)
+    }
+}
+
+impl AsyncWrite for BodyIo {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        input: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        let written = std::task::ready!(Pin::new(&mut self.inner).poll_write(cx, input))?;
+        let start = input.as_ptr() as usize;
+        let original = self.body.as_ptr() as usize;
+        if start >= original && start + written <= original + self.body.len() {
+            self.original_bytes_written
+                .fetch_add(written, Ordering::Relaxed);
+            self.largest_body_write
+                .fetch_max(input.len(), Ordering::Relaxed);
+        }
+        Poll::Ready(Ok(written))
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.inner).poll_flush(cx)
+    }
+
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.inner).poll_shutdown(cx)
+    }
+}
+
+#[tokio::test]
+async fn http1_body_reaches_scalar_io_in_bounded_slices_without_copying() {
+    let body = Bytes::from(vec![0xa5; crate::limits::XHTTP_PACKET_BATCH_BYTES]);
+    let (client, server) = tokio::io::duplex(1024);
+    let original_bytes_written = Arc::<AtomicUsize>::default();
+    let largest_body_write = Arc::<AtomicUsize>::default();
+    let io = BodyIo {
+        inner: client,
+        body: body.clone(),
+        original_bytes_written: original_bytes_written.clone(),
+        largest_body_write: largest_body_write.clone(),
+    };
+    // Leave vectored IO at its scalar default, as required by TLS wrappers.
+    assert!(!io.is_write_vectored());
+    let expected = body.clone();
+    let peer = tokio::spawn(async move {
+        let mut server = tokio::io::BufReader::new(server);
+        let mut line = String::new();
+        loop {
+            line.clear();
+            assert!(server.read_line(&mut line).await.unwrap() > 0);
+            if line == "\r\n" {
+                break;
+            }
+        }
+        // Production packet-up streams use chunked bodies, not Content-Length.
+        let mut received = Vec::new();
+        loop {
+            line.clear();
+            assert!(server.read_line(&mut line).await.unwrap() > 0);
+            let size = usize::from_str_radix(line.trim_end(), 16).unwrap();
+            assert!(received.len() + size <= expected.len());
+            let start = received.len();
+            received.resize(start + size, 0);
+            server.read_exact(&mut received[start..]).await.unwrap();
+            let mut delimiter = [0; 2];
+            server.read_exact(&mut delimiter).await.unwrap();
+            assert_eq!(&delimiter, b"\r\n");
+            if size == 0 {
+                break;
+            }
+        }
+        assert_eq!(received, expected);
+        server
+            .write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n")
+            .await
+            .unwrap();
+        tokio::io::copy(&mut server, &mut tokio::io::sink())
+            .await
+            .unwrap();
+    });
+    let owner = DriverOwner::default();
+    let (sender, connection) = http1(Box::new(io), &owner).await.unwrap();
+    let request = Request::post("http://example.com/x").body(()).unwrap();
+    tokio::time::timeout(
+        std::time::Duration::from_secs(2),
+        super::super::post_packet(sender, request, body.clone()),
+    )
+    .await
+    .expect("memory HTTP/1 POST stalled")
+    .unwrap();
+    owner.cancellation.cancel();
+    owner.tasks.close();
+    owner.tasks.wait().await;
+    peer.await.unwrap();
+    assert!(owner.tasks.is_empty());
+    drop(connection);
+    assert_eq!(
+        original_bytes_written.load(Ordering::Relaxed),
+        body.len(),
+        "HTTP/1 copied the payload before reaching the supplied scalar IO"
+    );
+    assert!(
+        largest_body_write.load(Ordering::Relaxed) <= crate::limits::XHTTP_BODY_CHUNK,
+        "HTTP/1 presented {} plaintext bytes to one scalar write",
+        largest_body_write.load(Ordering::Relaxed),
+    );
+}
diff --git a/src/transport/xhttp/http_io.rs b/src/transport/xhttp/http_io.rs
index 9ac813d..1056045 100644
--- a/src/transport/xhttp/http_io.rs
+++ b/src/transport/xhttp/http_io.rs
@@ -28,7 +28,7 @@ pub(super) type ResponseFuture =
 pub(super) enum Sender {
     H2(h2_write::Sender),
     H1 {
-        requests: mpsc::Sender<H1Request>,
+        requests: mpsc::Sender<Box<H1Request>>,
         writes: Writes,
     },
     H3(super::h3_driver::Sender),
@@ -70,13 +70,13 @@ impl Sender {
                     H1Upload::new(send)
                 };
                 requests
-                    .send((
+                    .send(Box::new((
                         request.map(|_| UploadBody {
                             receive,
                             empty: end,
                         }),
                         reply,
-                    ))
+                    )))
                     .await
                     .map_err(|_| connection_closed())?;
                 Ok((
@@ -98,7 +98,10 @@ impl Sender {
                     .send_request(request)
                     .await
                     .map_err(super::h3_driver::failure)?;
-                let (mut send, mut receive) = request.split();
+                let (mut send, mut receive): (
+                    crate::transport::quinn_h3::SendStream,
+                    crate::transport::quinn_h3::RecvStream,
+                ) = request.split();
                 let cancel = sender.runtime.cancel.child_token();
                 let (upload, mut data) = mpsc::channel::<H3Chunk>(BODY_QUEUE);
                 let (finish, finished) = oneshot::channel();
@@ -135,7 +138,7 @@ impl Sender {
                             .recv_response()
                             .await
                             .map_err(super::h3_driver::failure)?;
-                        Ok(response.map(|_| Download::H3(H3Download(receive))))
+                        Ok(response.map(|_| Download::H3(Box::new(receive))))
                     }),
                     Upload {
                         inner: UploadKind::H3(H3Upload {
@@ -159,16 +162,19 @@ pub(super) async fn http1(
     let (mut sender, connection) = hyper::client::conn::http1::Builder::new()
         .max_headers(super::request::MAX_REQUEST_HEADERS)
         .max_buf_size(super::request::MAX_REQUEST_BYTES)
-        .writev(false)
+        // Keep body backings instead of flattening a full POST into the header
+        // buffer. Scalar TLS writers consume the queued slices incrementally.
+        .writev(true)
         .handshake(hyper_util::rt::TokioIo::new(io))
         .await
         .map_err(h1_failure)?;
-    let (commands, mut requests) = mpsc::channel::<H1Request>(BODY_QUEUE);
+    let (commands, mut requests) = mpsc::channel::<Box<H1Request>>(BODY_QUEUE);
     // Dispatch eagerly, so an upload is not dependent on the caller polling reads.
     // Both futures belong to the same cancellation/join barrier as the physical IO.
     let guard = owner.spawn(async move {
         let dispatch = async move {
-            while let Some((request, reply)) = requests.recv().await {
+            while let Some(command) = requests.recv().await {
+                let (request, reply) = *command;
                 if reply.is_closed() {
                     continue;
                 }
@@ -355,7 +361,12 @@ impl Upload {
         }
     }
     pub(super) fn send_data(&mut self, data: Bytes, end: bool) -> io::Result<()> {
-        if data.len() > crate::limits::XHTTP_PACKET_BATCH_BYTES {
+        let batch_limit = if matches!(&self.inner, UploadKind::H3(_)) {
+            crate::limits::XHTTP_H3_PACKET_BATCH_BYTES
+        } else {
+            crate::limits::XHTTP_PACKET_BATCH_BYTES
+        };
+        if data.len() > batch_limit {
             return Err(super::request::invalid_request());
         }
         // Writers drain each receipt before accepting another chunk. Packet-up
@@ -424,13 +435,12 @@ impl Upload {
 pub(super) enum Download {
     H2(h2::RecvStream),
     H1(Incoming),
-    H3(H3Download),
+    H3(Box<crate::transport::quinn_h3::RecvStream>),
 }
-pub(super) struct H3Download(h3::client::RequestStream<super::h3_upload::RecvStream, Bytes>);
 impl Download {
     pub(super) fn poll_data(&mut self, cx: &mut Context<'_>) -> Poll<Option<io::Result<Bytes>>> {
         match self {
-            Self::H3(stream) => stream.0.poll_recv_data(cx).map(|result| match result {
+            Self::H3(stream) => stream.poll_recv_data(cx).map(|result| match result {
                 Ok(Some(mut data)) => Some(Ok(data.copy_to_bytes(data.remaining()))),
                 Ok(None) => None,
                 Err(error) => Some(Err(super::h3_driver::failure(error))),
@@ -465,3 +475,7 @@ impl Download {
         }
     }
 }
+
+#[cfg(test)]
+#[path = "http1_memory_tests.rs"]
+mod memory_tests;
diff --git a/src/transport/xhttp/packet_up.rs b/src/transport/xhttp/packet_up.rs
index 2a73c4d..a388074 100644
--- a/src/transport/xhttp/packet_up.rs
+++ b/src/transport/xhttp/packet_up.rs
@@ -1,7 +1,9 @@
 //! Timer-driven bounded aggregation. Writes acknowledge admitted bytes; flush
 //! waits for their POST responses. The node owns and joins the timer/IO driver.
+#[path = "packet_up_overlap.rs"]
+mod overlap;
 use super::{ConnectionGuard, DriverOwner, RequestTemplate, SendRequest, connection_closed};
-use bytes::{Buf, BytesMut};
+use bytes::{Buf, Bytes};
 use futures_util::task::AtomicWaker;
 use std::{
     io,
@@ -13,14 +15,21 @@ use std::{
     task::{Context, Poll},
     time::Duration,
 };
-use tokio::{io::AsyncWrite, sync::Notify};
+use tokio::{io::AsyncWrite, sync::Notify, time::Instant};
 
 struct State {
-    buffer: BytesMut,
+    buffer: Vec<u8>,
     accepted: u64,
     committed: u64,
     error: Option<Arc<io::Error>>,
     closed: bool,
+    in_flight: bool,
+    #[cfg(test)]
+    occupied_responses: usize,
+    #[cfg(test)]
+    ready_responses: usize,
+    #[cfg(test)]
+    ready_out_of_order: bool,
 }
 struct Shared {
     state: Mutex<State>,
@@ -57,6 +66,19 @@ impl Drop for Lifetime {
     }
 }
 
+#[cfg(test)]
+pub(super) struct Snapshot {
+    pub(super) buffer_ptr: usize,
+    pub(super) buffer_len: usize,
+    pub(super) buffer_capacity: usize,
+    pub(super) accepted: u64,
+    pub(super) committed: u64,
+    pub(super) in_flight: bool,
+    pub(super) occupied_responses: usize,
+    pub(super) ready_responses: usize,
+    pub(super) ready_out_of_order: bool,
+}
+
 pub(super) struct Writer {
     shared: Arc<Shared>,
     capacity: usize,
@@ -70,21 +92,56 @@ impl Writer {
         session: Arc<str>,
         chunk: usize,
         owner: &DriverOwner,
+    ) -> io::Result<Self> {
+        Self::with_responses(sender, request, session, chunk, owner, false)
+    }
+
+    pub(super) fn new_overlapping(
+        sender: SendRequest,
+        request: RequestTemplate,
+        session: Arc<str>,
+        chunk: usize,
+        owner: &DriverOwner,
+    ) -> io::Result<Self> {
+        Self::with_responses(sender, request, session, chunk, owner, true)
+    }
+
+    fn with_responses(
+        sender: SendRequest,
+        request: RequestTemplate,
+        session: Arc<str>,
+        chunk: usize,
+        owner: &DriverOwner,
+        overlap_responses: bool,
     ) -> io::Result<Self> {
         // Mihomo samples this maximum once per logical writer. Never allocate
         // the configurable (up to 16 MiB) maximum per connection.
-        let capacity = request
-            .options
-            .post_bytes
-            .sample()
-            .min(crate::limits::XHTTP_PACKET_BATCH_BYTES);
+        let batch_limit = if matches!(&sender, SendRequest::H3(_)) {
+            if overlap_responses {
+                crate::limits::XHTTP_H3_PACKET_BATCH_BYTES
+            } else {
+                crate::limits::XHTTP_H3_SERIAL_PACKET_BATCH_BYTES
+            }
+        } else if matches!(&sender, SendRequest::H1 { .. }) {
+            crate::limits::XHTTP_H1_PACKET_BATCH_BYTES
+        } else {
+            crate::limits::XHTTP_PACKET_BATCH_BYTES
+        };
+        let capacity = request.options.post_bytes.sample().min(batch_limit);
         let shared = Arc::new(Shared {
             state: Mutex::new(State {
-                buffer: BytesMut::new(),
+                buffer: Vec::new(),
                 accepted: 0,
                 committed: 0,
                 error: None,
                 closed: false,
+                in_flight: false,
+                #[cfg(test)]
+                occupied_responses: 0,
+                #[cfg(test)]
+                ready_responses: 0,
+                #[cfg(test)]
+                ready_out_of_order: false,
             }),
             changed: Notify::new(),
             finishing: AtomicBool::new(false),
@@ -93,14 +150,29 @@ impl Writer {
             flush: AtomicWaker::new(),
             reader: AtomicWaker::new(),
         });
+        let eager_capacity = (!request.options.post_interval_explicit).then_some(capacity);
         let lifetime = Lifetime(shared.clone());
         let worker = shared.clone();
-        let task = owner.spawn(async move {
-            let _lifetime = lifetime;
-            if let Err(error) = transmit(&worker, sender, request, session).await {
-                worker.state.lock().unwrap().error = Some(Arc::new(error));
-            }
-        })?;
+        // Branch before spawning: ordinary writers keep the original future layout.
+        let task = if overlap_responses {
+            owner.spawn(async move {
+                let _lifetime = lifetime;
+                if let Err(error) =
+                    overlap::transmit(&worker, sender, request, session, eager_capacity).await
+                {
+                    worker.state.lock().unwrap().error = Some(Arc::new(error));
+                }
+            })?
+        } else {
+            owner.spawn(async move {
+                let _lifetime = lifetime;
+                if let Err(error) =
+                    transmit(&worker, sender, request, session, eager_capacity).await
+                {
+                    worker.state.lock().unwrap().error = Some(Arc::new(error));
+                }
+            })?
+        };
         Ok(Self {
             shared,
             capacity,
@@ -108,6 +180,22 @@ impl Writer {
             _task: task,
         })
     }
+    #[cfg(test)]
+    pub(super) fn snapshot(&self) -> Snapshot {
+        let state = self.shared.state.lock().unwrap();
+        Snapshot {
+            buffer_ptr: state.buffer.as_ptr() as usize,
+            buffer_len: state.buffer.len(),
+            buffer_capacity: state.buffer.capacity(),
+            accepted: state.accepted,
+            committed: state.committed,
+            in_flight: state.in_flight,
+            occupied_responses: state.occupied_responses,
+            ready_responses: state.ready_responses,
+            ready_out_of_order: state.ready_out_of_order,
+        }
+    }
+
     pub(super) fn check_read(&self, cx: &mut Context<'_>) -> io::Result<()> {
         self.shared.reader.register(cx.waker());
         self.shared.state.lock().unwrap().check()
@@ -128,6 +216,9 @@ impl AsyncWrite for Writer {
         if input.is_empty() {
             return Poll::Ready(Ok(0));
         }
+        if state.in_flight {
+            return Poll::Pending;
+        }
         let count = input
             .len()
             .min(self.chunk)
@@ -139,6 +230,15 @@ impl AsyncWrite for Writer {
             .accepted
             .checked_add(count as u64)
             .ok_or_else(connection_closed)?;
+        let needed = state.buffer.len() + count;
+        if state.buffer.capacity() < needed {
+            // Irregular packet sizes must not double the allocation past the
+            // batch limit. Keep amortized growth without reserving an idle
+            // writer's entire configured POST maximum.
+            let capacity = needed.next_power_of_two().min(self.capacity);
+            let additional = capacity - state.buffer.len();
+            state.buffer.reserve_exact(additional);
+        }
         state.buffer.extend_from_slice(&input[..count]);
         state.accepted = accepted;
         drop(state);
@@ -167,8 +267,10 @@ async fn transmit(
     sender: SendRequest,
     request: RequestTemplate,
     session: Arc<str>,
+    eager_capacity: Option<usize>,
 ) -> io::Result<()> {
     let mut sequence = 0_u64;
+    let mut last_post_started = None;
     loop {
         loop {
             let changed = shared.changed.notified();
@@ -178,14 +280,14 @@ async fn transmit(
             changed.await;
         }
         let delay = || Duration::from_millis(request.options.post_interval_ms.sample() as u64);
-        wait_interval(shared, delay()).await;
-        // One bounded batch in flight and one filling batch. Only this driver
-        // owns POST completion; read cannot acknowledge a pending caller write.
+        wait_interval(shared, last_post_started, delay(), eager_capacity).await;
+        // Only one bounded batch, including while HTTP owns its immutable body.
+        // Keep writes backpressured until the POSTs have acknowledged this batch.
         let mut batch = {
             let mut state = shared.state.lock().unwrap();
-            std::mem::take(&mut state.buffer).freeze()
+            state.in_flight = true;
+            Bytes::from(std::mem::take(&mut state.buffer))
         };
-        shared.writer.wake();
         while !batch.is_empty() {
             let headers =
                 request.build(http::Method::POST, Some(&session), Some(sequence), false)?;
@@ -193,22 +295,52 @@ async fn transmit(
                 super::request::packet_payload(headers, &batch, &request.options.data)?;
             sequence = sequence.checked_add(1).ok_or_else(connection_closed)?;
             batch.advance(count);
+            last_post_started = Some(Instant::now());
             super::post_packet(sender.clone(), headers, payload).await?;
             shared.state.lock().unwrap().committed += count as u64;
             shared.flush.wake();
             if !batch.is_empty() {
-                wait_interval(shared, delay()).await;
+                wait_interval(shared, last_post_started, delay(), None).await;
             }
         }
+        // The consumed Bytes retains its backing. Recover it only if HTTP has
+        // released every reference; never copy a still-shared body to recycle it.
+        let recycled = batch.try_into_mut().map(Vec::from).unwrap_or_default();
+        {
+            let mut state = shared.state.lock().unwrap();
+            state.buffer = recycled;
+            state.in_flight = false;
+        }
+        shared.writer.wake();
     }
 }
 
-async fn wait_interval(shared: &Shared, delay: Duration) {
-    let finish = shared.finish.notified();
-    if !shared.finishing.load(Ordering::Acquire) {
+async fn wait_interval(
+    shared: &Shared,
+    last_post_started: Option<Instant>,
+    delay: Duration,
+    eager_capacity: Option<usize>,
+) {
+    // A partial default batch keeps its original deadline; filling it need not
+    // pay another aggregation delay. Explicit user intervals remain unchanged.
+    let deadline = last_post_started.unwrap_or_else(Instant::now) + delay;
+    loop {
+        let finish = shared.finish.notified();
+        let changed = shared.changed.notified();
+        if shared.finishing.load(Ordering::Acquire)
+            || eager_capacity
+                .is_some_and(|capacity| shared.state.lock().unwrap().buffer.len() >= capacity)
+        {
+            return;
+        }
         tokio::select! { biased;
-            () = finish => {},
-            () = tokio::time::sleep(delay) => {},
+            () = finish => return,
+            () = changed, if eager_capacity.is_some() => {},
+            () = tokio::time::sleep_until(deadline) => return,
         }
     }
 }
+
+#[cfg(test)]
+#[path = "packet_up_timing_tests.rs"]
+mod timing_tests;
diff --git a/src/transport/xhttp/packet_up_overlap.rs b/src/transport/xhttp/packet_up_overlap.rs
new file mode 100644
index 0000000..42bd3a3
--- /dev/null
+++ b/src/transport/xhttp/packet_up_overlap.rs
@@ -0,0 +1,393 @@
+//! Serial Body uploads with two bounded, in-order response acknowledgements.
+use super::{RequestTemplate, SendRequest, Shared, connection_closed, wait_interval};
+use bytes::Bytes;
+use std::{
+    future::{Future, poll_fn},
+    io,
+    pin::Pin,
+    sync::{Arc, Weak},
+    task::{Context, Poll},
+    time::Duration,
+};
+use tokio::time::Instant;
+
+type Response = Pin<Box<dyn Future<Output = io::Result<()>> + Send>>;
+
+// Bytes owns this lease until the last body reference disappears. Returning the
+// Vec is an event, not a uniqueness retry or a second body allocation.
+struct BodyLease {
+    buffer: Vec<u8>,
+    shared: Weak<Shared>,
+}
+impl AsRef<[u8]> for BodyLease {
+    fn as_ref(&self) -> &[u8] {
+        &self.buffer
+    }
+}
+impl Drop for BodyLease {
+    fn drop(&mut self) {
+        if let Some(shared) = self.shared.upgrade() {
+            let mut buffer = std::mem::take(&mut self.buffer);
+            buffer.clear();
+            let mut state = shared.state.lock().unwrap();
+            // Cancellation may already have closed the writer. Never replace
+            // another workspace; live workers have taken its sole allocation.
+            if !state.closed && state.buffer.is_empty() && state.buffer.capacity() == 0 {
+                state.buffer = buffer;
+                drop(state);
+                shared.changed.notify_one();
+            }
+        }
+    }
+}
+
+struct Slot {
+    sequence: u64,
+    end: u64,
+    finished: bool,
+    complete: bool,
+    response: Option<Response>,
+}
+#[derive(Default)]
+struct Responses {
+    slots: [Option<Slot>; 2],
+}
+impl Responses {
+    fn full(&self) -> bool {
+        self.slots[1].is_some()
+    }
+
+    fn push(&mut self, sequence: u64, end: u64, response: super::super::ResponseFuture) {
+        let response = Box::pin(async move {
+            let response = response.await?;
+            super::super::ensure_success(response.status(), "packet-up upload", false)?;
+            let mut body = response.into_body();
+            let mut drained = 0usize;
+            while let Some(data) = poll_fn(|cx| body.poll_data(cx)).await {
+                let data = data?;
+                drained = drained.saturating_add(data.len());
+                if drained > super::super::request::MAX_REQUEST_BYTES {
+                    return Err(io::Error::new(
+                        io::ErrorKind::InvalidData,
+                        "XHTTP upload response exceeds its drain budget",
+                    ));
+                }
+                body.release_capacity(data.len())?;
+                tokio::task::yield_now().await;
+            }
+            Ok(())
+        });
+        let index = usize::from(self.slots[0].is_some());
+        debug_assert!(self.slots[index].is_none());
+        self.slots[index] = Some(Slot {
+            sequence,
+            end,
+            finished: false,
+            complete: false,
+            response: Some(response),
+        });
+    }
+
+    fn retire(&mut self, shared: &Shared) -> bool {
+        let mut committed = None;
+        while self.slots[0]
+            .as_ref()
+            .is_some_and(|slot| slot.finished && slot.complete)
+        {
+            committed = self.slots[0].take().map(|slot| slot.end);
+            self.slots[0] = self.slots[1].take();
+        }
+        if let Some(committed) = committed {
+            shared.state.lock().unwrap().committed = committed;
+            shared.flush.wake();
+            true
+        } else {
+            false
+        }
+    }
+
+    #[cfg(test)]
+    fn publish(&self, shared: &Shared) {
+        let mut state = shared.state.lock().unwrap();
+        state.occupied_responses = self.slots.iter().flatten().count();
+        state.ready_responses = self
+            .slots
+            .iter()
+            .flatten()
+            .filter(|slot| slot.complete)
+            .count();
+        state.ready_out_of_order = self.slots[0]
+            .as_ref()
+            .is_some_and(|slot| !slot.finished || !slot.complete)
+            && self.slots[1].as_ref().is_some_and(|slot| slot.complete);
+    }
+
+    fn poll(&mut self, shared: &Shared, cx: &mut Context<'_>) -> io::Result<()> {
+        let mut completed = false;
+        let mut failure = None;
+        for slot in self.slots.iter_mut().flatten() {
+            let Some(response) = &mut slot.response else {
+                continue;
+            };
+            if let Poll::Ready(result) = response.as_mut().poll(cx) {
+                // Dropping the completed future also releases its receive half.
+                slot.response = None;
+                match result {
+                    Ok(()) => {
+                        slot.complete = true;
+                        completed = true;
+                    }
+                    Err(error) => {
+                        failure.get_or_insert(error);
+                    }
+                }
+            }
+        }
+        let retired = self.retire(shared);
+        if completed || retired {
+            #[cfg(test)]
+            self.publish(shared);
+        }
+        if let Some(error) = failure {
+            Err(error)
+        } else {
+            Ok(())
+        }
+    }
+
+    fn finished(&mut self, shared: &Shared, sequence: u64) {
+        for slot in self.slots.iter_mut().flatten() {
+            if slot.sequence == sequence {
+                slot.finished = true;
+                break;
+            }
+        }
+        if self.retire(shared) {
+            #[cfg(test)]
+            self.publish(shared);
+        }
+    }
+
+    async fn drive<T>(
+        &mut self,
+        shared: &Shared,
+        operation: impl Future<Output = io::Result<T>>,
+    ) -> io::Result<T> {
+        let mut operation = std::pin::pin!(operation);
+        poll_fn(|cx| {
+            self.poll(shared, cx)?;
+            operation.as_mut().poll(cx)
+        })
+        .await
+    }
+
+    async fn wait_room(&mut self, shared: &Shared) -> io::Result<()> {
+        poll_fn(|cx| {
+            self.poll(shared, cx)?;
+            if self.full() {
+                Poll::Pending
+            } else {
+                Poll::Ready(Ok(()))
+            }
+        })
+        .await
+    }
+}
+
+pub(super) async fn transmit(
+    shared: &Arc<Shared>,
+    mut sender: SendRequest,
+    request: RequestTemplate,
+    session: Arc<str>,
+    eager_capacity: Option<usize>,
+) -> io::Result<()> {
+    let mut responses = Responses::default();
+    let mut sequence = 0_u64;
+    let mut last_post_started = None;
+    loop {
+        responses
+            .drive(shared, async {
+                loop {
+                    let changed = shared.changed.notified();
+                    if !shared.state.lock().unwrap().buffer.is_empty() {
+                        return Ok(());
+                    }
+                    changed.await;
+                }
+            })
+            .await?;
+        // Shorten only this shared-H3 writer's default partial-batch deadline.
+        let delay = if eager_capacity.is_some() {
+            Duration::from_millis(2)
+        } else {
+            Duration::from_millis(request.options.post_interval_ms.sample() as u64)
+        };
+        responses
+            .drive(shared, async {
+                wait_interval(shared, last_post_started, delay, eager_capacity).await;
+                Ok(())
+            })
+            .await?;
+        let (buffer, end) = {
+            let mut state = shared.state.lock().unwrap();
+            state.in_flight = true;
+            (std::mem::take(&mut state.buffer), state.accepted)
+        };
+        let batch = Bytes::from_owner(BodyLease {
+            buffer,
+            shared: Arc::downgrade(shared),
+        });
+        let current = sequence;
+        let headers = request.build(http::Method::POST, Some(&session), Some(current), false)?;
+        sequence = sequence.checked_add(1).ok_or_else(connection_closed)?;
+        last_post_started = Some(Instant::now());
+        let (response, mut upload) = responses
+            .drive(shared, sender.send_request(headers, false))
+            .await?;
+        responses.push(current, end, response);
+        // The factory only selects normalized Body. Transfer its lease outright;
+        // retaining a root Bytes here would prevent the final-owner handback.
+        responses
+            .drive(shared, async {
+                upload.send_data(batch, true)?;
+                poll_fn(|cx| upload.poll_finish(cx)).await
+            })
+            .await?;
+        drop(upload);
+        responses.finished(shared, current);
+        responses
+            .drive(shared, async {
+                loop {
+                    let changed = shared.changed.notified();
+                    if shared.state.lock().unwrap().buffer.capacity() != 0 {
+                        return Ok(());
+                    }
+                    changed.await;
+                }
+            })
+            .await?;
+        // A ready response behind a hole still occupies one of these two slots.
+        // Do not admit even a prefill until both the sole Vec and a slot are free.
+        responses.wait_room(shared).await?;
+        shared.state.lock().unwrap().in_flight = false;
+        shared.writer.wake();
+    }
+}
+
+#[cfg(test)]
+mod lease_memory_tests {
+    use super::super::State;
+    use super::{BodyLease, Shared};
+    use bytes::Bytes;
+    use futures_util::{poll, task::AtomicWaker};
+    use std::sync::{Arc, Mutex, atomic::AtomicBool};
+    use tokio::{
+        sync::Notify,
+        time::{Duration, timeout},
+    };
+
+    fn shared(closed: bool) -> Arc<Shared> {
+        Arc::new(Shared {
+            state: Mutex::new(State {
+                buffer: Vec::new(),
+                accepted: 0,
+                committed: 0,
+                error: None,
+                closed,
+                in_flight: true,
+                occupied_responses: 0,
+                ready_responses: 0,
+                ready_out_of_order: false,
+            }),
+            changed: Notify::new(),
+            finishing: AtomicBool::new(false),
+            finish: Notify::new(),
+            writer: AtomicWaker::new(),
+            flush: AtomicWaker::new(),
+            reader: AtomicWaker::new(),
+        })
+    }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn last_body_clone_returns_same_vec_and_notifies_existing_waiter() {
+        let shared = shared(false);
+        let buffer = vec![0x5a; 5000];
+        let pointer = buffer.as_ptr() as usize;
+        let capacity = buffer.capacity();
+        let bytes = Bytes::from_owner(BodyLease {
+            buffer,
+            shared: Arc::downgrade(&shared),
+        });
+        let last = bytes.clone();
+        let changed = shared.changed.notified();
+        tokio::pin!(changed);
+        assert!(poll!(changed.as_mut()).is_pending());
+        drop(bytes);
+        {
+            let state = shared.state.lock().unwrap();
+            assert_eq!(state.buffer.capacity(), 0);
+            assert!(state.buffer.is_empty());
+            assert!(state.in_flight);
+        }
+        assert!(poll!(changed.as_mut()).is_pending());
+        // No mutex guard is live at either final body Drop or Notify polling.
+        drop(last);
+        timeout(Duration::from_secs(5), changed.as_mut())
+            .await
+            .unwrap();
+        {
+            let state = shared.state.lock().unwrap();
+            assert_eq!(state.buffer.as_ptr() as usize, pointer);
+            assert_eq!(state.buffer.capacity(), capacity);
+            assert!(state.buffer.is_empty());
+            // Storage return alone neither acknowledges bytes nor opens admission.
+            assert!(state.in_flight);
+            assert_eq!(state.committed, 0);
+        }
+        assert_eq!(Arc::weak_count(&shared), 0);
+    }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn closed_or_destroyed_shared_does_not_retain_or_revive_body_owner() {
+        {
+            let shared = shared(true);
+            let bytes = Bytes::from_owner(BodyLease {
+                buffer: vec![0x7b; 5000],
+                shared: Arc::downgrade(&shared),
+            });
+            let last = bytes.clone();
+            let changed = shared.changed.notified();
+            tokio::pin!(changed);
+            assert!(poll!(changed.as_mut()).is_pending());
+            drop(bytes);
+            assert_eq!(Arc::weak_count(&shared), 1);
+            drop(last);
+            // The real owner was destroyed; closed storage received no buffer.
+            assert_eq!(Arc::weak_count(&shared), 0);
+            assert_eq!(Arc::strong_count(&shared), 1);
+            {
+                let state = shared.state.lock().unwrap();
+                assert!(state.closed);
+                assert!(state.buffer.is_empty());
+                assert_eq!(state.buffer.capacity(), 0);
+            }
+            assert!(poll!(changed.as_mut()).is_pending());
+        }
+        {
+            let shared = shared(false);
+            let weak = Arc::downgrade(&shared);
+            let bytes = Bytes::from_owner(BodyLease {
+                buffer: vec![0x7b; 5000],
+                shared: weak.clone(),
+            });
+            let last = bytes.clone();
+            drop(shared);
+            assert!(weak.upgrade().is_none());
+            drop(bytes);
+            assert!(weak.upgrade().is_none());
+            drop(last);
+            assert!(weak.upgrade().is_none());
+            assert_eq!(weak.strong_count(), 0);
+        }
+    }
+}
diff --git a/src/transport/xhttp/packet_up_timing_tests.rs b/src/transport/xhttp/packet_up_timing_tests.rs
new file mode 100644
index 0000000..d3e00d8
--- /dev/null
+++ b/src/transport/xhttp/packet_up_timing_tests.rs
@@ -0,0 +1,700 @@
+//! Packet-up scheduling against a memory HTTP/2 peer with paused Tokio time.
+use super::*;
+use crate::config::xhttp::XHttpRequestOptions;
+use bytes::{Buf, Bytes};
+use http::{Method, Response, StatusCode};
+use tokio::{
+    io::AsyncWriteExt,
+    sync::mpsc,
+    task::{JoinHandle, JoinSet},
+    time::{Instant, advance, timeout},
+};
+
+struct Packet {
+    arrived: Instant,
+    path: String,
+    body: Vec<u8>,
+    response: h2::server::SendResponse<Bytes>,
+}
+
+struct Fixture {
+    writer: Writer,
+    owner: Arc<DriverOwner>,
+    connection: Arc<ConnectionGuard>,
+    packets: mpsc::Receiver<Packet>,
+    server: JoinHandle<()>,
+}
+
+impl Fixture {
+    async fn new(interval_ms: usize) -> Self {
+        Self::with_limit(interval_ms, 4).await
+    }
+
+    async fn with_limit(interval_ms: usize, post_bytes: usize) -> Self {
+        Self::with_request_options(normalized_packet_options(
+            Some(&interval_ms.to_string()),
+            post_bytes,
+            false,
+        ))
+        .await
+    }
+
+    async fn with_request_options(options: XHttpRequestOptions) -> Self {
+        let chunk = options.post_bytes.max.min(crate::limits::XHTTP_BODY_CHUNK);
+        let (client_io, server_io) = tokio::io::duplex(64 * 1024);
+        let (packets, receiver) = mpsc::channel(2);
+        let server = tokio::spawn(async move {
+            let mut connection = h2::server::handshake(server_io).await.unwrap();
+            let mut handlers = JoinSet::new();
+            while let Some(incoming) = connection.accept().await {
+                let Ok((request, response)) = incoming else {
+                    break;
+                };
+                let arrived = Instant::now();
+                let packets = packets.clone();
+                handlers.spawn(async move {
+                    assert_eq!(request.method(), Method::POST);
+                    let path = request.uri().path().to_owned();
+                    let mut incoming = request.into_body();
+                    let mut body = Vec::new();
+                    while let Some(data) = incoming.data().await {
+                        let data = data.unwrap();
+                        body.extend_from_slice(&data);
+                        incoming
+                            .flow_control()
+                            .release_capacity(data.len())
+                            .unwrap();
+                    }
+                    packets
+                        .send(Packet {
+                            arrived,
+                            path,
+                            body,
+                            response,
+                        })
+                        .await
+                        .unwrap();
+                });
+            }
+            while let Some(handler) = handlers.join_next().await {
+                handler.unwrap();
+            }
+        });
+        let owner = Arc::new(DriverOwner::default());
+        let (sender, connection) =
+            super::super::h2_driver::connect(Box::new(client_io), 64 * 1024, -1, &owner, false)
+                .await
+                .unwrap();
+        let request = RequestTemplate {
+            host: Arc::from("example.com"),
+            path: Arc::from("/x"),
+            headers: Default::default(),
+            options: Arc::new(options),
+        };
+        let writer = Writer::new(sender, request, Arc::from("session"), chunk, &owner).unwrap();
+        Self {
+            writer,
+            owner,
+            connection,
+            packets: receiver,
+            server,
+        }
+    }
+
+    async fn next(&mut self) -> Packet {
+        timeout(Duration::from_secs(2), self.packets.recv())
+            .await
+            .expect("packet-up driver did not submit its owned POST")
+            .expect("memory HTTP peer exited")
+    }
+
+    async fn close(self) {
+        self.owner.cancellation.cancel();
+        self.owner.tasks.close();
+        self.owner.tasks.wait().await;
+        assert!(self.owner.tasks.is_empty());
+        drop(self.writer);
+        drop(self.connection);
+        drop(self.packets);
+        timeout(Duration::from_secs(1), self.server)
+            .await
+            .expect("owned memory HTTP peer survived Stop")
+            .unwrap();
+    }
+}
+
+fn acknowledge(packet: &mut Packet, status: StatusCode) {
+    packet
+        .response
+        .send_response(Response::builder().status(status).body(()).unwrap(), true)
+        .unwrap();
+}
+
+#[tokio::test(start_paused = true)]
+async fn irregular_writes_keep_allocation_within_the_batch_limit() {
+    for limit in [crate::limits::XHTTP_PACKET_BATCH_BYTES, 5000] {
+        let mut fixture = Fixture::with_limit(100, limit).await;
+        assert_eq!(
+            fixture
+                .writer
+                .shared
+                .state
+                .lock()
+                .unwrap()
+                .buffer
+                .capacity(),
+            0
+        );
+        let mut expected = Vec::new();
+        while expected.len() < limit {
+            let count = if expected.is_empty() { 17 } else { 1431 }.min(limit - expected.len());
+            let bytes = vec![(expected.len() % 251) as u8; count];
+            fixture.writer.write_all(&bytes).await.unwrap();
+            expected.extend_from_slice(&bytes);
+            let allocated = fixture
+                .writer
+                .shared
+                .state
+                .lock()
+                .unwrap()
+                .buffer
+                .capacity();
+            assert!(
+                allocated <= limit,
+                "allocated {allocated} bytes for a {limit}-byte batch",
+            );
+        }
+        assert!(
+            std::future::poll_fn(|cx| Poll::Ready(
+                Pin::new(&mut fixture.writer)
+                    .poll_write(cx, b"full")
+                    .is_pending()
+            ))
+            .await
+        );
+        let mut packet = fixture.next().await;
+        assert_eq!(packet.body, expected);
+        acknowledge(&mut packet, StatusCode::OK);
+        fixture.writer.flush().await.unwrap();
+        fixture.close().await;
+    }
+}
+
+#[tokio::test(start_paused = true)]
+async fn post_start_interval_credits_request_time_and_idle_time() {
+    // All scenarios use the actual production Writer and actual HTTP response.
+    // The memory fixture has no delayed send admission; frame-arrival times
+    // identify the scheduler's start deadline here, not a global wire guarantee.
+    for (request_ms, idle_ms) in [(80, 0), (150, 0), (80, 200)] {
+        let mut fixture = Fixture::new(100).await;
+        let began = Instant::now();
+        fixture.writer.write_all(b"one1").await.unwrap();
+        let mut first = fixture.next().await;
+        assert_eq!(first.arrived - began, Duration::from_millis(100));
+        assert_eq!(first.path, "/x/session/0");
+        assert_eq!(first.body, b"one1");
+        assert_eq!(fixture.writer.shared.state.lock().unwrap().committed, 0);
+
+        advance(Duration::from_millis(request_ms)).await;
+        acknowledge(&mut first, StatusCode::OK);
+        fixture.writer.flush().await.unwrap();
+        assert_eq!(fixture.writer.shared.state.lock().unwrap().committed, 4);
+        advance(Duration::from_millis(idle_ms)).await;
+        fixture.writer.write_all(b"two2").await.unwrap();
+        let mut second = fixture.next().await;
+        assert_eq!(
+            second.arrived - first.arrived,
+            Duration::from_millis((request_ms + idle_ms).max(100)),
+        );
+        assert_eq!(second.path, "/x/session/1");
+        assert_eq!(second.body, b"two2");
+        acknowledge(&mut second, StatusCode::OK);
+        fixture.writer.flush().await.unwrap();
+        assert_eq!(fixture.writer.shared.state.lock().unwrap().committed, 8);
+        fixture.close().await;
+    }
+}
+
+#[tokio::test(start_paused = true)]
+async fn pending_post_backpressures_writes_and_failure_does_not_acknowledge() {
+    let mut fixture = Fixture::new(100).await;
+    fixture.writer.write_all(b"one1").await.unwrap();
+    let mut first = fixture.next().await;
+    assert_eq!(first.path, "/x/session/0");
+    assert_eq!(first.body, b"one1");
+    assert!(
+        std::future::poll_fn(|cx| Poll::Ready(
+            Pin::new(&mut fixture.writer)
+                .poll_write(cx, b"two2")
+                .is_pending()
+        ))
+        .await
+    );
+    assert!(
+        std::future::poll_fn(|cx| Poll::Ready(
+            Pin::new(&mut fixture.writer).poll_flush(cx).is_pending()
+        ))
+        .await
+    );
+    advance(Duration::from_millis(150)).await;
+    assert!(matches!(
+        fixture.packets.try_recv(),
+        Err(mpsc::error::TryRecvError::Empty)
+    ));
+    assert_eq!(fixture.writer.shared.state.lock().unwrap().committed, 0);
+
+    acknowledge(&mut first, StatusCode::INTERNAL_SERVER_ERROR);
+    fixture.writer.flush().await.unwrap_err();
+    assert_eq!(fixture.writer.shared.state.lock().unwrap().committed, 0);
+    fixture.writer.write_all(b"late").await.unwrap_err();
+    std::future::poll_fn(|cx| Poll::Ready(fixture.writer.check_read(cx)))
+        .await
+        .unwrap_err();
+    assert!(matches!(
+        fixture.packets.try_recv(),
+        Err(mpsc::error::TryRecvError::Empty | mpsc::error::TryRecvError::Disconnected)
+    ));
+    fixture.close().await;
+}
+
+#[tokio::test(start_paused = true)]
+async fn acknowledged_post_reuses_its_batch_and_wakes_the_waiting_writer() {
+    let mut fixture = Fixture::with_limit(100, crate::limits::XHTTP_PACKET_BATCH_BYTES).await;
+    let body = vec![0xa5; crate::limits::XHTTP_PACKET_BATCH_BYTES];
+    fixture.writer.write_all(&body).await.unwrap();
+    let shared = fixture.writer.shared.clone();
+    let original = shared.state.lock().unwrap().buffer.as_ptr() as usize;
+    let mut first = fixture.next().await;
+    assert_eq!(first.body, body);
+
+    let mut waiting = Box::pin(fixture.writer.write_all(b"next"));
+    assert!(std::future::poll_fn(|cx| Poll::Ready(waiting.as_mut().poll(cx).is_pending())).await);
+    acknowledge(&mut first, StatusCode::OK);
+    timeout(Duration::from_secs(2), &mut waiting)
+        .await
+        .expect("POST completion did not wake the pending writer")
+        .unwrap();
+    drop(waiting);
+    let recycled = shared.state.lock().unwrap().buffer.as_ptr() as usize;
+    assert_eq!(recycled, original, "POST body storage was not reused");
+
+    let mut second = fixture.next().await;
+    assert_eq!(second.path, "/x/session/1");
+    assert_eq!(second.body, b"next");
+    acknowledge(&mut second, StatusCode::OK);
+    fixture.writer.flush().await.unwrap();
+    fixture.close().await;
+}
+
+#[tokio::test(start_paused = true)]
+async fn shutdown_skips_first_delay_and_stop_joins_pending_post() {
+    let mut fixture = Fixture::new(60_000).await;
+    let began = Instant::now();
+    fixture.writer.write_all(b"one1").await.unwrap();
+    assert!(
+        std::future::poll_fn(|cx| Poll::Ready(
+            Pin::new(&mut fixture.writer).poll_shutdown(cx).is_pending()
+        ))
+        .await
+    );
+    let first = fixture.next().await;
+    assert_eq!(first.arrived, began);
+    assert_eq!(first.path, "/x/session/0");
+    assert_eq!(first.body, b"one1");
+    fixture.writer.write_all(b"late").await.unwrap_err();
+    // Keep the real response unresolved. Cancellation must join the driver and
+    // wake its actual pending flush, without waiting for a new network event.
+    let owner = fixture.owner.clone();
+    let stop = tokio::spawn(async move {
+        owner.cancellation.cancel();
+        owner.tasks.close();
+        owner.tasks.wait().await;
+        assert!(owner.tasks.is_empty());
+    });
+    fixture.writer.flush().await.unwrap_err();
+    stop.await.unwrap();
+    assert_eq!(fixture.writer.shared.state.lock().unwrap().committed, 0);
+    drop(first);
+    fixture.close().await;
+}
+
+fn normalized_packet_options(
+    interval: Option<&str>,
+    post_bytes: usize,
+    download: bool,
+) -> XHttpRequestOptions {
+    let interval = interval
+        .map(|value| format!("      sc-min-posts-interval-ms: {value:?}\n"))
+        .unwrap_or_default();
+    let download = if download {
+        "      download-settings: {}\n"
+    } else {
+        ""
+    };
+    let yaml = format!(
+        "proxies:\n  - name: fixture\n    type: vless\n    server: 192.0.2.1\n    port: 443\n    uuid: 00000000-0000-0000-0000-000000000001\n    network: xhttp\n    xhttp-opts:\n      mode: packet-up\n      sc-max-each-post-bytes: {post_bytes}\n{interval}{download}rules: ['MATCH,DIRECT']\n"
+    );
+    let config = crate::config::Config::parse_yaml(yaml.as_bytes()).unwrap();
+    let crate::config::ProxyProtocol::Vless(node) = &config.proxies[0].protocol else {
+        panic!("fixture is not VLESS")
+    };
+    let xhttp = node.xhttp().unwrap();
+    if let Some(download) = &xhttp.download {
+        assert!(Arc::ptr_eq(&download.request, &xhttp.request));
+    }
+    (*xhttp.request).clone()
+}
+
+#[tokio::test(start_paused = true)]
+async fn default_full_batch_submits_without_timer_or_extra_buffer() {
+    const CAPACITY: usize = crate::limits::XHTTP_PACKET_BATCH_BYTES;
+    for interval in [None, Some("")] {
+        let options = normalized_packet_options(interval, 1_000_000, true);
+        let mut fixture = Fixture::with_request_options(options).await;
+        let began = Instant::now();
+        let payload = vec![0xa5; CAPACITY];
+        fixture.writer.write_all(&payload).await.unwrap();
+        let capacity = fixture
+            .writer
+            .shared
+            .state
+            .lock()
+            .unwrap()
+            .buffer
+            .capacity();
+        let mut first = fixture.next().await;
+        let first_arrived = first.arrived;
+        let first_payload = first.body == payload;
+        let committed_before_response = fixture.writer.shared.state.lock().unwrap().committed;
+        let blocked = std::future::poll_fn(|cx| {
+            Poll::Ready(
+                Pin::new(&mut fixture.writer)
+                    .poll_write(cx, b"next")
+                    .is_pending(),
+            )
+        })
+        .await;
+        acknowledge(&mut first, StatusCode::OK);
+        fixture.writer.flush().await.unwrap();
+        let committed_after_response = fixture.writer.shared.state.lock().unwrap().committed;
+        fixture.writer.write_all(&payload).await.unwrap();
+        let mut second = fixture.next().await;
+        let second_arrived = second.arrived;
+        let second_payload = second.body == payload;
+        acknowledge(&mut second, StatusCode::OK);
+        fixture.writer.flush().await.unwrap();
+        fixture.close().await;
+        assert_eq!(
+            first_arrived, began,
+            "a full default batch paid the aggregation timer"
+        );
+        assert_eq!(
+            second_arrived, first_arrived,
+            "consecutive full default batches were timer-limited"
+        );
+        assert!(first_payload && second_payload, "full POST payload changed");
+        assert!(
+            capacity <= CAPACITY,
+            "batch allocation exceeded the existing cap"
+        );
+        assert!(blocked, "an unresolved POST admitted a second batch");
+        assert_eq!(
+            committed_before_response, 0,
+            "admission was mistaken for a POST receipt"
+        );
+        assert_eq!(committed_after_response, CAPACITY as u64);
+    }
+}
+
+#[tokio::test(start_paused = true)]
+async fn default_partial_and_explicit_full_batches_keep_their_original_interval() {
+    for (interval, length, minimum_ms, maximum_ms) in [
+        (None, 3, 10, 10),
+        (Some(""), 3, 10, 10),
+        (Some("10"), crate::limits::XHTTP_PACKET_BATCH_BYTES, 10, 10),
+        (
+            Some("100-101"),
+            crate::limits::XHTTP_PACKET_BATCH_BYTES,
+            100,
+            101,
+        ),
+    ] {
+        let options = normalized_packet_options(interval, 1_000_000, true);
+        let mut fixture = Fixture::with_request_options(options).await;
+        let began = Instant::now();
+        let payload = vec![0x5a; length];
+        fixture.writer.write_all(&payload).await.unwrap();
+        let mut packet = fixture.next().await;
+        let elapsed = packet.arrived - began;
+        let correct = packet.body == payload;
+        acknowledge(&mut packet, StatusCode::OK);
+        fixture.writer.flush().await.unwrap();
+        fixture.close().await;
+        assert!(elapsed >= Duration::from_millis(minimum_ms));
+        assert!(elapsed <= Duration::from_millis(maximum_ms));
+        assert!(correct, "scheduled POST changed accepted bytes");
+    }
+}
+
+// Actual smux writes into the production PacketUp writer. Read remains pending:
+// this test observes upload scheduling, not a second protocol implementation.
+#[cfg(any(feature = "sing-mux", feature = "outbound-shadowsocks"))]
+struct PacketUploadOnly(Writer);
+#[cfg(any(feature = "sing-mux", feature = "outbound-shadowsocks"))]
+impl tokio::io::AsyncRead for PacketUploadOnly {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+        _: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        Poll::Pending
+    }
+}
+#[cfg(any(feature = "sing-mux", feature = "outbound-shadowsocks"))]
+impl AsyncWrite for PacketUploadOnly {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        bytes: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        Pin::new(&mut self.0).poll_write(cx, bytes)
+    }
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.0).poll_flush(cx)
+    }
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.0).poll_shutdown(cx)
+    }
+}
+
+#[cfg(any(feature = "sing-mux", feature = "outbound-shadowsocks"))]
+#[tokio::test(start_paused = true)]
+async fn autonomous_smux_really_fills_default_packet_batch_and_preserves_every_frame() {
+    let options = normalized_packet_options(None, 1_000_000, false);
+    let Fixture {
+        writer,
+        owner,
+        connection,
+        mut packets,
+        server,
+    } = Fixture::with_request_options(options).await;
+    let shared = writer.shared.clone();
+    let (client, driver) = crate::transport::smux::new_with_autonomous_writes(
+        Box::new(PacketUploadOnly(writer)),
+        true,
+    );
+    let driver = tokio::spawn(driver);
+    let mut opening = Box::pin(client.open());
+    assert!(futures_util::poll!(opening.as_mut()).is_pending());
+    let mut syn = timeout(Duration::from_secs(2), packets.recv())
+        .await
+        .unwrap()
+        .unwrap();
+    let stream_id = syn.body[4..8].to_vec();
+    assert_eq!(&syn.body[..4], &[1, 0, 0, 0]);
+    acknowledge(&mut syn, StatusCode::OK);
+    let mut stream = opening.await.unwrap();
+    let began = Instant::now();
+    let payload = vec![0x3c; crate::limits::XHTTP_PACKET_BATCH_BYTES];
+    stream.write_all(&payload).await.unwrap();
+    let mut flush = Box::pin(stream.flush());
+    assert!(futures_util::poll!(flush.as_mut()).is_pending());
+    let mut first = timeout(Duration::from_secs(2), packets.recv())
+        .await
+        .unwrap()
+        .unwrap();
+    let first_arrived = first.arrived;
+    let first_length = first.body.len();
+    let first_backpressure = shared.state.lock().unwrap().in_flight;
+    let mut wire = std::mem::take(&mut first.body);
+    acknowledge(&mut first, StatusCode::OK);
+    let mut tail = timeout(Duration::from_secs(2), packets.recv())
+        .await
+        .unwrap()
+        .unwrap();
+    wire.append(&mut tail.body);
+    acknowledge(&mut tail, StatusCode::OK);
+    flush.await.unwrap();
+    let committed = shared.state.lock().unwrap().committed;
+    // Stop owns every task. Do not add a FIN contract to this throughput test.
+    drop(stream);
+    driver.abort();
+    let _ = driver.await;
+    owner.cancellation.cancel();
+    owner.tasks.close();
+    owner.tasks.wait().await;
+    assert!(owner.tasks.is_empty());
+    drop(client);
+    drop(connection);
+    drop(packets);
+    timeout(Duration::from_secs(1), server)
+        .await
+        .unwrap()
+        .unwrap();
+    assert_eq!(
+        first_length,
+        crate::limits::XHTTP_PACKET_BATCH_BYTES,
+        "smux never filled the real batch"
+    );
+    assert_eq!(
+        first_arrived, began,
+        "a full smux batch still waited for the default timer"
+    );
+    assert!(
+        first_backpressure,
+        "the full POST lost single-batch backpressure"
+    );
+    let mut decoded = Vec::new();
+    let mut input = wire.as_slice();
+    while !input.is_empty() {
+        assert!(input.len() >= 8, "partial smux frame header");
+        assert_eq!(&input[..2], &[1, 2]);
+        assert_eq!(&input[4..8], stream_id.as_slice());
+        let length = u16::from_le_bytes(input[2..4].try_into().unwrap()) as usize;
+        assert!(input.len() >= 8 + length, "partial smux frame payload");
+        decoded.extend_from_slice(&input[8..8 + length]);
+        input = &input[8 + length..];
+    }
+    assert_eq!(
+        decoded, payload,
+        "smux accepted bytes were not fully committed"
+    );
+    assert_eq!(
+        committed as usize,
+        8 + wire.len(),
+        "POST accounting lost SYN or DATA"
+    );
+}
+
+#[tokio::test]
+async fn ordinary_h3_batch_boundary_keeps_eager_progress_receipts_and_owner_stop() {
+    use crate::transport::quinn_h3::tests::Pair;
+
+    for (post_limit, expected) in [
+        (1_000_000, crate::limits::XHTTP_H3_SERIAL_PACKET_BATCH_BYTES),
+        (5000, 5000),
+    ] {
+        let mut pair = Pair::new(128 * 1024).await;
+        let (requests, mut server) = pair.h3().await;
+        let (posts, mut packets) = mpsc::channel(2);
+        pair.spawn(async move {
+            while let Some(request) = server.accept().await.unwrap() {
+                let (headers, mut stream) = request.resolve_request().await.unwrap();
+                assert_eq!(headers.method(), Method::POST);
+                let path = headers.uri().path().to_owned();
+                let mut body = Vec::new();
+                while let Some(mut data) = stream.recv_data().await.unwrap() {
+                    body.extend_from_slice(&data.copy_to_bytes(data.remaining()));
+                }
+                posts.send((path, body, stream)).await.unwrap();
+            }
+        });
+        let owner = Arc::new(DriverOwner::default());
+        let sender = SendRequest::H3(super::super::h3_driver::Sender {
+            requests,
+            runtime: pair.client_runtime.clone(),
+            #[cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
+            udp_control: None,
+            #[cfg(feature = "interop-test")]
+            observation: pair.client.clone(),
+        });
+        let request = RequestTemplate {
+            host: Arc::from("example.com"),
+            path: Arc::from("/x"),
+            headers: Default::default(),
+            options: Arc::new(normalized_packet_options(None, post_limit, false)),
+        };
+        let mut writer = Writer::new(
+            sender,
+            request,
+            Arc::from("session"),
+            crate::limits::XHTTP_BODY_CHUNK,
+            &owner,
+        )
+        .unwrap();
+        assert_eq!(writer.capacity, expected);
+        let payload = vec![0xa5; expected];
+        // Pause only after the actual QUIC/H3 fixture exists. Observe the
+        // production aggregation boundary before letting native timers run.
+        tokio::time::pause();
+        let began = Instant::now();
+        writer.write_all(&payload).await.unwrap();
+        let allocated = writer.shared.state.lock().unwrap().buffer.capacity();
+        for _ in 0..64 {
+            if writer.shared.state.lock().unwrap().in_flight {
+                break;
+            }
+            tokio::task::yield_now().await;
+        }
+        let eager = writer.shared.state.lock().unwrap().in_flight;
+        let no_aggregation_tick = Instant::now() == began;
+        tokio::time::resume();
+        assert!(
+            eager && no_aggregation_tick,
+            "full H3 batch paid the aggregation timer"
+        );
+        assert!(
+            allocated <= expected,
+            "H3 backing exceeded its selected cap"
+        );
+        let (path, body, mut first) = timeout(Duration::from_secs(5), packets.recv())
+            .await
+            .unwrap()
+            .unwrap();
+        assert_eq!(path, "/x/session/0");
+        assert_eq!(body, payload);
+        assert_eq!(writer.shared.state.lock().unwrap().committed, 0);
+        assert!(
+            std::future::poll_fn(|cx| Poll::Ready(Pin::new(&mut writer).poll_write(cx, b"tail")))
+                .await
+                .is_pending()
+        );
+        assert!(
+            std::future::poll_fn(|cx| Poll::Ready(Pin::new(&mut writer).poll_flush(cx)))
+                .await
+                .is_pending()
+        );
+        first.send_response(Response::new(())).await.unwrap();
+        first.finish().await.unwrap();
+        timeout(Duration::from_secs(5), writer.flush())
+            .await
+            .unwrap()
+            .unwrap();
+        assert_eq!(
+            writer.shared.state.lock().unwrap().committed,
+            expected as u64
+        );
+        writer.write_all(&payload).await.unwrap();
+        let (path, body, second) = timeout(Duration::from_secs(5), packets.recv())
+            .await
+            .unwrap()
+            .unwrap();
+        assert_eq!(path, "/x/session/1");
+        assert_eq!(body, payload);
+        assert!(
+            std::future::poll_fn(|cx| Poll::Ready(Pin::new(&mut writer).poll_shutdown(cx)))
+                .await
+                .is_pending()
+        );
+        writer.write_all(b"late").await.unwrap_err();
+        owner.cancellation.cancel();
+        owner.tasks.close();
+        timeout(Duration::from_secs(2), owner.tasks.wait())
+            .await
+            .unwrap();
+        assert!(owner.tasks.is_empty());
+        timeout(Duration::from_secs(5), writer.flush())
+            .await
+            .unwrap()
+            .unwrap_err();
+        assert_eq!(
+            writer.shared.state.lock().unwrap().committed,
+            expected as u64
+        );
+        drop(second);
+        drop(first);
+        drop(writer);
+        drop(packets);
+        pair.stop().await;
+    }
+}
diff --git a/src/transport/xhttp/pool.rs b/src/transport/xhttp/pool.rs
index c094c85..88eaf6e 100644
--- a/src/transport/xhttp/pool.rs
+++ b/src/transport/xhttp/pool.rs
@@ -1,7 +1,7 @@
 //! Node-owned transport leases. Thresholds choose candidates, not admission.
 use super::{ConnectionGuard, ConnectionLease, SendRequest, connection_closed};
 use crate::{
-    config::XHttpReuseConfig,
+    config::{XHttpReuseConfig, XHttpVersion},
     resources::observation::{Guard, ResourceKind, track},
 };
 use std::{
@@ -25,6 +25,8 @@ pub(super) enum Policy {
 #[derive(Debug)]
 pub(super) struct Pool {
     options: Option<Arc<XHttpReuseConfig>>,
+    share_active: bool,
+    private_active_h2: bool,
     concurrency: usize,
     connections: usize,
     state: Arc<Mutex<State>>,
@@ -35,6 +37,7 @@ struct State {
     entries: Vec<Entry>,
     next_id: u64,
     closed: bool,
+    idle_limit: usize,
 }
 #[derive(Clone, Debug)]
 struct Physical {
@@ -58,8 +61,28 @@ struct Entry {
     _observation: Guard,
 }
 impl Entry {
+    // This is a conservative logical reservation check, not a fabricated
+    // "remaining stream credit" API. Only the private H2 pool calls it.
+    fn permits_private_h2_lease(&self) -> bool {
+        let Transport::Multiplexed(physical) = &self.transport else {
+            return false;
+        };
+        let SendRequest::H2(sender) = &physical.sender else {
+            return false;
+        };
+        if self.active >= sender.request.current_max_send_streams() {
+            return false;
+        }
+        // A clone has no pending request: this detects GOAWAY/connection
+        // errors without waiting or registering a capacity waiter. Capacity
+        // itself comes from the peer cap + logical reservations above.
+        let mut sender = sender.request.clone();
+        let mut cx = std::task::Context::from_waker(std::task::Waker::noop());
+        matches!(sender.poll_ready(&mut cx), std::task::Poll::Ready(Ok(())))
+    }
+
     fn retired(&self) -> bool {
-        matches!(&self.transport, Transport::Multiplexed(physical) if physical.driver.task.is_finished())
+        matches!(&self.transport, Transport::Multiplexed(physical) if physical.driver.task.is_finished() || matches!(&physical.sender, SendRequest::H3(sender) if !sender.requests.can_open_request()))
             || self.remaining == Some(0)
             || self.max_reuses > 0 && self.reuses >= self.max_reuses
             || self.expires.is_some_and(|at| Instant::now() >= at)
@@ -109,21 +132,51 @@ impl State {
                 return true;
             }
             idle += 1;
-            idle <= MAX_IDLE_ENTRIES
+            idle <= self.idle_limit
         });
     }
 }
 impl Pool {
-    pub(super) fn new(options: Option<Arc<XHttpReuseConfig>>) -> Self {
+    pub(super) fn new(options: Option<Arc<XHttpReuseConfig>>, version: XHttpVersion) -> Self {
+        Self::build(options, version, false)
+    }
+    #[cfg(feature = "outbound-vless")]
+    pub(super) fn active_h2() -> Self {
+        Self::build(None, XHttpVersion::Http2, true)
+    }
+    #[cfg(feature = "outbound-vless")]
+    pub(super) fn shares_active(&self) -> bool {
+        self.share_active
+    }
+    fn build(
+        options: Option<Arc<XHttpReuseConfig>>,
+        version: XHttpVersion,
+        active_h2: bool,
+    ) -> Self {
+        let share_active = options.is_none() && (version == XHttpVersion::Http3 || active_h2);
         Self {
-            concurrency: options
-                .as_ref()
-                .map_or(0, |options| options.concurrency.sample()),
+            concurrency: options.as_ref().map_or(
+                if share_active {
+                    if version == XHttpVersion::Http2 {
+                        crate::limits::XHTTP_ACTIVE_H2_LEASES
+                    } else {
+                        crate::limits::XHTTP_ACTIVE_H3_LEASES
+                    }
+                } else {
+                    0
+                },
+                |options| options.concurrency.sample(),
+            ),
             connections: options
                 .as_ref()
                 .map_or(0, |options| options.connections.sample()),
             options,
-            state: Arc::default(),
+            share_active,
+            private_active_h2: active_h2,
+            state: Arc::new(Mutex::new(State {
+                idle_limit: if share_active { 0 } else { MAX_IDLE_ENTRIES },
+                ..State::default()
+            })),
             opening: tokio::sync::Mutex::default(),
         }
     }
@@ -136,10 +189,11 @@ impl Pool {
         F: FnOnce() -> Fut,
         Fut: Future<Output = io::Result<(SendRequest, Arc<ConnectionGuard>)>>,
     {
-        let Some(options) = &self.options else {
+        if self.options.is_none() && !self.share_active {
             let (sender, driver) = make().await?;
             return Ok((sender, driver.into()));
-        };
+        }
+        let options = self.options.as_deref();
         let _opening = self.opening.lock().await;
         let existing = {
             let mut state = self.state.lock().unwrap();
@@ -152,6 +206,7 @@ impl Pool {
                     .entries
                     .iter_mut()
                     .filter(|entry| self.concurrency == 0 || entry.active < self.concurrency)
+                    .filter(|entry| !self.private_active_h2 || entry.permits_private_h2_lease())
                     .min_by_key(|entry| entry.active)
                     .map(|entry| -> io::Result<_> {
                         Ok((entry.take(policy), entry.reserve(&self.state, true)?))
@@ -187,11 +242,15 @@ impl Pool {
                 },
                 active: 0,
                 reuses: 0,
-                max_reuses: options.reuse_times.sample(),
-                remaining: (options.requests.max > 0).then(|| options.requests.sample()),
-                expires: (options.age_seconds.max > 0).then(|| {
-                    Instant::now() + Duration::from_secs(options.age_seconds.sample() as u64)
-                }),
+                max_reuses: options.map_or(0, |options| options.reuse_times.sample()),
+                remaining: options
+                    .filter(|options| options.requests.max > 0)
+                    .map(|options| options.requests.sample()),
+                expires: options
+                    .filter(|options| options.age_seconds.max > 0)
+                    .map(|options| {
+                        Instant::now() + Duration::from_secs(options.age_seconds.sample() as u64)
+                    }),
                 _observation: track(ResourceKind::Pool),
             };
             let usage = entry.reserve(&self.state, false)?;
@@ -267,3 +326,81 @@ impl Drop for Usage {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        config::XHttpVersion,
+        transport::xhttp::{XHttpClient, XHttpConfig, XHttpMode},
+    };
+    use std::sync::atomic::{AtomicUsize, Ordering};
+    use tokio_util::task::TaskTracker;
+
+    #[tokio::test]
+    async fn implicit_h3_shares_four_active_leases_and_reconnects_after_idle() {
+        tokio::time::timeout(Duration::from_secs(3), async {
+            let mut config = XHttpConfig::new("example.com", "/x", XHttpMode::StreamOne).unwrap();
+            config.http_version = XHttpVersion::Http3;
+            let client = XHttpClient::new(config);
+            let transport = XHttpClient::new(
+                XHttpConfig::new("example.com", "/x", XHttpMode::StreamOne).unwrap(),
+            );
+            let calls = AtomicUsize::new(0);
+            let peers = TaskTracker::new();
+            // Admission and leases are transport-independent. Real memory H2
+            // drivers expose factory calls and cleanup without QUIC scheduling.
+            let make = || async {
+                calls.fetch_add(1, Ordering::Relaxed);
+                let (io, remote) = tokio::io::duplex(8192);
+                peers.spawn(async move {
+                    let mut connection = h2::server::handshake(remote).await.unwrap();
+                    while let Some(request) = connection.accept().await {
+                        request.unwrap();
+                    }
+                });
+                transport.handshake(Box::new(io)).await
+            };
+            let mut leases = Vec::new();
+            for _ in 0..4 {
+                let (_, lease) = client
+                    .pool
+                    .acquire(Policy::Multiplexed, &make)
+                    .await
+                    .unwrap();
+                leases.push(lease);
+            }
+            let shared_calls = calls.load(Ordering::Relaxed);
+            let (_, fifth) = client
+                .pool
+                .acquire(Policy::Multiplexed, &make)
+                .await
+                .unwrap();
+            let overflow_calls = calls.load(Ordering::Relaxed);
+            drop(fifth);
+            drop(leases);
+            let (_, fresh) = client
+                .pool
+                .acquire(Policy::Multiplexed, &make)
+                .await
+                .unwrap();
+            let fresh_calls = calls.load(Ordering::Relaxed);
+            drop(fresh);
+            client.stop().await;
+            transport.stop().await;
+            peers.close();
+            peers.wait().await;
+            assert_eq!(
+                shared_calls, 1,
+                "active streams opened redundant transports"
+            );
+            assert_eq!(
+                overflow_calls, 2,
+                "active sharing threshold was not bounded"
+            );
+            assert_eq!(fresh_calls, 3, "idle physical transport was retained");
+        })
+        .await
+        .expect("active transport leases did not stop");
+    }
+}
diff --git a/src/transport/xhttp/request.rs b/src/transport/xhttp/request.rs
index 4e713cd..99a9867 100644
--- a/src/transport/xhttp/request.rs
+++ b/src/transport/xhttp/request.rs
@@ -28,12 +28,12 @@ pub(super) fn check_size(request: &Request<()>) -> io::Result<()> {
 
 pub(super) fn packet_payload(
     mut request: Request<()>,
-    data: &[u8],
+    data: &bytes::Bytes,
     placement: &DataPlacement,
 ) -> io::Result<(Request<()>, bytes::Bytes, usize)> {
     use base64::Engine as _;
     let DataPlacement::Chunks { key, cookie, size } = placement else {
-        return Ok((request, bytes::Bytes::copy_from_slice(data), data.len()));
+        return Ok((request, data.clone(), data.len()));
     };
     let base = request_size(&request);
     let fits = |raw: usize| {
@@ -227,3 +227,21 @@ fn tokenish(target: usize) -> String {
     }
     result
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn packet_body_shares_the_frozen_batch_without_a_second_payload_allocation() {
+        let batch = bytes::Bytes::from(vec![7; crate::limits::XHTTP_PACKET_BATCH_BYTES]);
+        let (request, payload, count) =
+            packet_payload(Request::new(()), &batch, &DataPlacement::Body).unwrap();
+        assert_eq!(count, batch.len());
+        assert!(request.headers().is_empty());
+        assert_eq!(payload.as_ptr(), batch.as_ptr());
+        drop(batch);
+        assert_eq!(payload.len(), count);
+        assert!(payload.iter().all(|byte| *byte == 7));
+    }
+}
diff --git a/src/tun_echo.rs b/src/tun_echo.rs
new file mode 100644
index 0000000..ce23ecc
--- /dev/null
+++ b/src/tun_echo.rs
@@ -0,0 +1,621 @@
+//! Bounded Linux real-Echo owner. DIRECT only; no rule graph or target tasks.
+use crate::{
+    config::IpCidr,
+    dialer::{Dialer, PhysicalPing, PingReceipt},
+    platform::TunIo,
+};
+use bytes::Bytes;
+use sha2::{Digest as _, Sha256};
+use std::{io, net::IpAddr, sync::Arc, time::Duration};
+use tokio::{
+    sync::{OwnedSemaphorePermit, Semaphore, mpsc},
+    time::{Instant, MissedTickBehavior},
+};
+use tokio_util::sync::CancellationToken;
+use vole_netstack::{
+    EchoPacketClass, EchoPacketView, Packet, classify_echo_request, encode_echo_reply_into,
+    parse_echo_reply_body,
+};
+
+pub(crate) const ECHO_QUEUE: usize = 8;
+const MAX_PENDING: usize = 64;
+const MAX_PACKET: usize = 2048;
+const HOUSEKEEPING: Duration = Duration::from_millis(250);
+const IDLE_SOCKET: Duration = Duration::from_secs(10);
+
+use super::{EchoOffer, QueuedEchoResponse};
+pub(crate) struct EchoOptions {
+    dialer: Dialer,
+    local_prefixes: Vec<IpCidr>,
+    fake_ranges: [Option<IpCidr>; 2],
+    timeout: Duration,
+    disabled: bool,
+}
+impl EchoOptions {
+    pub(crate) async fn prepare(
+        dialer: Dialer,
+        tun: Arc<TunIo>,
+        fake_ranges: [Option<IpCidr>; 2],
+        timeout: Duration,
+        disabled: bool,
+    ) -> io::Result<Self> {
+        // No query, permission test or socket creation for explicitly disabled forwarding.
+        let local_prefixes = if disabled {
+            Vec::new()
+        } else {
+            dialer.ping_tun_prefixes(tun).await?
+        };
+        Ok(Self {
+            dialer,
+            local_prefixes,
+            fake_ranges,
+            timeout,
+            disabled,
+        })
+    }
+}
+struct Request {
+    source: IpAddr,
+    destination: IpAddr,
+    identifier: u16,
+    sequence: u16,
+    payload: Vec<u8>,
+    deadline: Instant,
+    permit: OwnedSemaphorePermit,
+}
+pub(crate) struct EchoIngress {
+    sender: mpsc::Sender<Request>,
+    permits: Arc<Semaphore>,
+    local_prefixes: Vec<IpCidr>,
+    fake_ranges: [Option<IpCidr>; 2],
+    timeout: Duration,
+    disabled: bool,
+    max_packet: usize,
+}
+impl EchoIngress {
+    // Nonblocking: physical failures/pressure are consumed and cannot become
+    // synthetic successful replies. Recognized invalid Echo is consumed; genuine
+    // non-Echo/error packets keep the existing netstack path.
+    pub(crate) fn offer(&self, packet: &[u8]) -> EchoOffer {
+        let view = match classify_echo_request(packet) {
+            EchoPacketClass::NotEcho => return EchoOffer::NotEcho,
+            EchoPacketClass::Rejected => return EchoOffer::Consumed,
+            EchoPacketClass::Request(view) => view,
+        };
+        if self.disabled
+            || self
+                .local_prefixes
+                .iter()
+                .any(|p| p.contains(view.destination))
+            || self
+                .fake_ranges
+                .iter()
+                .flatten()
+                .any(|p| p.contains(view.destination))
+        {
+            return EchoOffer::LocalSynthetic;
+        }
+        if packet.len() > self.max_packet || self.sender.is_closed() {
+            return EchoOffer::Consumed;
+        }
+        let Ok(slot) = self.sender.try_reserve() else {
+            return EchoOffer::Consumed;
+        };
+        let Ok(permit) = self.permits.clone().try_acquire_owned() else {
+            return EchoOffer::Consumed;
+        };
+        let request = Request {
+            source: view.source,
+            destination: view.destination,
+            identifier: view.identifier,
+            sequence: view.sequence,
+            payload: view.payload.to_vec(),
+            deadline: match Instant::now().checked_add(self.timeout) {
+                Some(d) => d,
+                None => return EchoOffer::Consumed,
+            },
+            permit,
+        };
+        // A full queue drops the one bounded request and its permit here.
+        slot.send(request);
+        EchoOffer::Consumed
+    }
+}
+struct Pending {
+    family: usize,
+    wire_id: u16,
+    wire_sequence: u16,
+    source: IpAddr,
+    destination: IpAddr,
+    identifier: u16,
+    sequence: u16,
+    payload_len: usize,
+    payload_hash: [u8; 32],
+    deadline: Instant,
+    permit: OwnedSemaphorePermit,
+}
+struct Family {
+    socket: Option<PhysicalPing>,
+    loopback: bool,
+    next_identifier: u16,
+    identifiers_issued: u32,
+    next_sequence: u32,
+    used_at: Instant,
+}
+impl Family {
+    fn new() -> Self {
+        Self {
+            socket: None,
+            loopback: false,
+            next_identifier: rand::random::<u16>().max(1),
+            identifiers_issued: 0,
+            next_sequence: 0,
+            used_at: Instant::now(),
+        }
+    }
+    fn reserve_identifier(&mut self) -> Option<u16> {
+        if self.identifiers_issued == u32::from(u16::MAX) {
+            return None;
+        }
+        let id = self.next_identifier;
+        self.next_identifier = id.wrapping_add(1).max(1);
+        self.identifiers_issued += 1;
+        Some(id)
+    }
+}
+pub(crate) struct EchoDriver {
+    dialer: Dialer,
+    requests: mpsc::Receiver<Request>,
+    responses: mpsc::Sender<QueuedEchoResponse>,
+    families: [Family; 2],
+    pending: [Option<Pending>; MAX_PENDING],
+    max_packet: usize,
+}
+pub(crate) fn channel(
+    options: EchoOptions,
+    mtu: usize,
+) -> (EchoIngress, mpsc::Receiver<QueuedEchoResponse>, EchoDriver) {
+    let (sender, requests) = mpsc::channel(ECHO_QUEUE);
+    let (responses, receiver) = mpsc::channel(ECHO_QUEUE);
+    let max_packet = mtu.min(MAX_PACKET);
+    let ingress = EchoIngress {
+        sender,
+        permits: Arc::new(Semaphore::new(MAX_PENDING)),
+        local_prefixes: options.local_prefixes,
+        fake_ranges: options.fake_ranges,
+        timeout: options.timeout,
+        disabled: options.disabled,
+        max_packet,
+    };
+    let driver = EchoDriver {
+        dialer: options.dialer,
+        requests,
+        responses,
+        families: [Family::new(), Family::new()],
+        pending: std::array::from_fn(|_| None),
+        max_packet,
+    };
+    (ingress, receiver, driver)
+}
+enum Event {
+    Stop,
+    Tick,
+    Request(Option<Request>),
+    Received(usize, io::Result<PingReceipt>),
+}
+async fn receive(socket: Option<&PhysicalPing>, bytes: &mut [u8]) -> io::Result<PingReceipt> {
+    match socket {
+        Some(socket) => socket.recv(bytes).await,
+        None => std::future::pending().await,
+    }
+}
+impl EchoDriver {
+    pub(crate) async fn run(mut self, cancellation: CancellationToken) -> io::Result<()> {
+        let mut tick = tokio::time::interval(HOUSEKEEPING);
+        tick.set_missed_tick_behavior(MissedTickBehavior::Skip);
+        let mut v4 = [0u8; MAX_PACKET];
+        let mut v6 = [0u8; MAX_PACKET];
+        loop {
+            // Cancellation-safe recvmsg runs only when selected readiness is polled;
+            // the received bytes and metadata are consumed by this sole owner.
+            if cancellation.is_cancelled() {
+                return Ok(());
+            }
+            let event = tokio::select! {
+                () = cancellation.cancelled() => Event::Stop,
+                _ = tick.tick() => Event::Tick,
+                request = self.requests.recv() => Event::Request(request),
+                result = receive(self.families[0].socket.as_ref(), &mut v4) => Event::Received(0, result),
+                result = receive(self.families[1].socket.as_ref(), &mut v6) => Event::Received(1, result),
+            };
+            match event {
+                Event::Stop | Event::Request(None) => return Ok(()),
+                Event::Tick => self.expire(),
+                Event::Request(Some(request)) => self.send(request, &cancellation).await,
+                Event::Received(family, Ok(receipt)) => {
+                    let bytes = if family == 0 {
+                        &v4[..receipt.length]
+                    } else {
+                        &v6[..receipt.length]
+                    };
+                    self.reply(family, receipt, bytes);
+                }
+                Event::Received(_, Err(error)) if error.kind() == io::ErrorKind::InvalidData => {}
+                Event::Received(family, Err(error)) => {
+                    tracing::debug!(family, error = %error, "closing failed physical ICMP socket");
+                    self.close_family(family);
+                }
+            }
+            // Incoming Echo floods cannot monopolize ready sockets/queues.
+            tokio::task::consume_budget().await;
+        }
+    }
+    fn has_pending(&self, family: usize) -> bool {
+        self.pending.iter().flatten().any(|p| p.family == family)
+    }
+    fn close_family(&mut self, family: usize) {
+        self.families[family].socket = None;
+        for item in &mut self.pending {
+            if item.as_ref().is_some_and(|p| p.family == family) {
+                *item = None;
+            }
+        }
+    }
+    fn expire(&mut self) {
+        let now = Instant::now();
+        for item in &mut self.pending {
+            if item.as_ref().is_some_and(|p| now >= p.deadline) {
+                *item = None;
+            }
+        }
+        for family in 0..2 {
+            if !self.has_pending(family)
+                && now.duration_since(self.families[family].used_at) >= IDLE_SOCKET
+            {
+                self.families[family].socket = None;
+            }
+        }
+    }
+    async fn ensure_socket(&mut self, family: usize, destination: IpAddr) -> io::Result<()> {
+        self.dialer.permit_ping_destination(destination)?;
+        let change = self.families[family].loopback != destination.is_loopback()
+            || self.families[family].next_sequence > u32::from(u16::MAX);
+        if change {
+            // Never rebind/reconfigure a socket with unrelated in-flight probes.
+            if self.has_pending(family) {
+                return Err(io::ErrorKind::WouldBlock.into());
+            }
+            self.families[family].socket = None;
+        }
+        if self.families[family].socket.is_some() {
+            return Ok(());
+        }
+        for _ in 0..32 {
+            let identifier = self.families[family].reserve_identifier().ok_or_else(|| {
+                io::Error::new(
+                    io::ErrorKind::OutOfMemory,
+                    "ICMP wire identity space exhausted",
+                )
+            })?;
+            match self.dialer.bind_ping_for(destination, identifier).await {
+                Ok(socket) => {
+                    self.families[family].socket = Some(socket);
+                    self.families[family].loopback = destination.is_loopback();
+                    self.families[family].next_sequence = 0;
+                    return Ok(());
+                }
+                Err(error) if error.raw_os_error() == Some(libc::EADDRINUSE) => {}
+                Err(error) => return Err(error),
+            }
+        }
+        Err(io::ErrorKind::AddrInUse.into())
+    }
+    async fn send(&mut self, request: Request, cancellation: &CancellationToken) {
+        self.expire();
+        if Instant::now() >= request.deadline {
+            return;
+        }
+        let Some(slot) = self.pending.iter().position(Option::is_none) else {
+            return;
+        };
+        let family = usize::from(request.destination.is_ipv6());
+        let result = tokio::select! {
+            biased;
+            () = cancellation.cancelled() => return,
+            result = self.ensure_socket(family, request.destination) => result,
+        };
+        if let Err(error) = result {
+            // EPERM/EACCES are real installation-policy failures, not API absence
+            // and never a reason to forge a local success or raise privileges.
+            tracing::debug!(family, error = %error, "physical ICMP admission failed");
+            return;
+        }
+        if Instant::now() >= request.deadline {
+            return;
+        }
+        let state = &mut self.families[family];
+        let socket = state.socket.as_ref().expect("initialized ping socket");
+        let wire_id = socket.identifier;
+        let wire_sequence = state.next_sequence as u16;
+        state.next_sequence += 1;
+        state.used_at = Instant::now();
+        let mut body = Vec::with_capacity(8 + request.payload.len());
+        body.extend_from_slice(&[if family == 0 { 8 } else { 128 }, 0, 0, 0]);
+        body.extend_from_slice(&wire_id.to_be_bytes());
+        body.extend_from_slice(&wire_sequence.to_be_bytes());
+        body.extend_from_slice(&request.payload);
+        if family == 0 {
+            let checksum = checksum(&body);
+            body[2..4].copy_from_slice(&checksum.to_be_bytes());
+        }
+        // Linux ping-v6 computes the ICMPv6 pseudoheader checksum after selecting
+        // the physical source. The physical reply is independently checked below.
+        let sent = tokio::select! {
+            biased;
+            () = cancellation.cancelled() => return,
+            result = tokio::time::timeout_at(request.deadline, socket.send(request.destination, &body)) => result,
+        };
+        if !matches!(sent, Ok(Ok(()))) {
+            return;
+        }
+        self.pending[slot] = Some(Pending {
+            family,
+            wire_id,
+            wire_sequence,
+            source: request.source,
+            destination: request.destination,
+            identifier: request.identifier,
+            sequence: request.sequence,
+            payload_len: request.payload.len(),
+            payload_hash: Sha256::digest(&request.payload).into(),
+            deadline: request.deadline,
+            permit: request.permit,
+        });
+        // request.payload/body drop here: pending retains metadata/hash only.
+    }
+    fn reply(&mut self, family: usize, receipt: PingReceipt, bytes: &[u8]) {
+        if receipt.interface == 0 {
+            return;
+        }
+        let Some(view) = parse_echo_reply_body(receipt.peer, receipt.local, bytes) else {
+            return;
+        };
+        let Some(slot) = self.pending.iter().position(|p| {
+            p.as_ref().is_some_and(|p| {
+                p.family == family
+                    && p.wire_id == view.identifier
+                    && p.wire_sequence == view.sequence
+            })
+        }) else {
+            return;
+        };
+        let pending = self.pending[slot].as_ref().unwrap();
+        if Instant::now() >= pending.deadline
+            || view.source != pending.destination
+            || view.payload.len() != pending.payload_len
+            || <[u8; 32]>::from(Sha256::digest(view.payload)) != pending.payload_hash
+        {
+            return;
+        }
+        let pending = self.pending[slot].take().unwrap();
+        let reply = EchoPacketView {
+            source: pending.destination,
+            destination: pending.source,
+            identifier: pending.identifier,
+            sequence: pending.sequence,
+            payload: view.payload,
+        };
+        let mut frame = Vec::new();
+        if encode_echo_reply_into(&reply, self.max_packet, &mut frame).is_err() {
+            return;
+        }
+        let _ = self.responses.try_send(QueuedEchoResponse {
+            packet: Packet::new(Bytes::from(frame)),
+            permit: pending.permit,
+        });
+    }
+}
+fn checksum(bytes: &[u8]) -> u16 {
+    let mut sum = 0u32;
+    for word in bytes.chunks(2) {
+        sum += u32::from(u16::from_be_bytes([word[0], *word.get(1).unwrap_or(&0)]));
+    }
+    while sum >> 16 != 0 {
+        sum = (sum & 0xffff) + (sum >> 16);
+    }
+    !(sum as u16)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn setup() -> (EchoIngress, mpsc::Receiver<QueuedEchoResponse>, EchoDriver) {
+        channel(
+            EchoOptions {
+                dialer: Dialer::default(),
+                local_prefixes: vec![IpCidr {
+                    network: "10.0.0.0".parse().unwrap(),
+                    prefix_len: 24,
+                }],
+                fake_ranges: [
+                    Some(IpCidr {
+                        network: "198.18.0.0".parse().unwrap(),
+                        prefix_len: 16,
+                    }),
+                    None,
+                ],
+                timeout: Duration::from_secs(10),
+                disabled: false,
+            },
+            1500,
+        )
+    }
+    fn request(destination: [u8; 4]) -> Vec<u8> {
+        let mut packet = vec![0u8; 31];
+        packet[0] = 0x45;
+        packet[2..4].copy_from_slice(&31u16.to_be_bytes());
+        packet[8] = 64;
+        packet[9] = 1;
+        packet[12..16].copy_from_slice(&[10, 0, 0, 2]);
+        packet[16..20].copy_from_slice(&destination);
+        packet[20] = 8;
+        packet[24..26].copy_from_slice(&33u16.to_be_bytes());
+        packet[26..28].copy_from_slice(&9u16.to_be_bytes());
+        packet[28..].copy_from_slice(b"odd");
+        let icmp = checksum(&packet[20..]);
+        packet[22..24].copy_from_slice(&icmp.to_be_bytes());
+        let ip = checksum(&packet[..20]);
+        packet[10..12].copy_from_slice(&ip.to_be_bytes());
+        packet
+    }
+    fn response(payload: &[u8]) -> Vec<u8> {
+        let mut body = vec![0u8; 8 + payload.len()];
+        body[4..6].copy_from_slice(&17u16.to_be_bytes());
+        body[6..8].copy_from_slice(&3u16.to_be_bytes());
+        body[8..].copy_from_slice(payload);
+        let value = checksum(&body);
+        body[2..4].copy_from_slice(&value.to_be_bytes());
+        body
+    }
+    fn install_pending(ingress: &EchoIngress, driver: &mut EchoDriver) {
+        driver.pending[0] = Some(Pending {
+            family: 0,
+            wire_id: 17,
+            wire_sequence: 3,
+            source: "10.0.0.2".parse().unwrap(),
+            destination: "203.0.113.9".parse().unwrap(),
+            identifier: 33,
+            sequence: 9,
+            payload_len: 3,
+            payload_hash: Sha256::digest(b"odd").into(),
+            deadline: Instant::now() + Duration::from_secs(10),
+            permit: ingress.permits.clone().try_acquire_owned().unwrap(),
+        });
+    }
+    #[test]
+    fn bounded_admission_and_local_cases_do_not_open_sockets() {
+        let (mut ingress, _responses, mut driver) = setup();
+        assert_eq!(
+            ingress.offer(&request([10, 0, 0, 99])),
+            EchoOffer::LocalSynthetic
+        );
+        assert_eq!(
+            ingress.offer(&request([198, 18, 7, 99])),
+            EchoOffer::LocalSynthetic
+        );
+        for _ in 0..ECHO_QUEUE + 1 {
+            assert_eq!(
+                ingress.offer(&request([203, 0, 113, 9])),
+                EchoOffer::Consumed
+            );
+        }
+        assert_eq!(
+            ingress.permits.available_permits(),
+            MAX_PENDING - ECHO_QUEUE
+        );
+        for _ in 0..ECHO_QUEUE {
+            drop(driver.requests.try_recv().unwrap());
+        }
+        assert!(driver.requests.try_recv().is_err());
+        assert_eq!(ingress.permits.available_permits(), MAX_PENDING);
+        let mut bad = request([10, 0, 0, 99]);
+        *bad.last_mut().unwrap() ^= 1;
+        assert_eq!(ingress.offer(&bad), EchoOffer::Consumed);
+        ingress.disabled = true;
+        assert_eq!(
+            ingress.offer(&request([203, 0, 113, 9])),
+            EchoOffer::LocalSynthetic
+        );
+        assert!(driver.families.iter().all(|f| f.socket.is_none()));
+    }
+    #[test]
+    fn only_valid_origin_body_identity_and_unexpired_reply_owns_the_permit() {
+        let (ingress, mut responses, mut driver) = setup();
+        install_pending(&ingress, &mut driver);
+        let body = response(b"odd");
+        let receipt = PingReceipt {
+            length: body.len(),
+            peer: "203.0.113.9".parse().unwrap(),
+            local: "192.0.2.100".parse().unwrap(),
+            interface: 2,
+        };
+        driver.reply(
+            0,
+            PingReceipt {
+                peer: "203.0.113.10".parse().unwrap(),
+                ..receipt
+            },
+            &body,
+        );
+        let mut corrupt = body.clone();
+        *corrupt.last_mut().unwrap() ^= 1;
+        driver.reply(0, receipt, &corrupt);
+        driver.reply(0, receipt, &response(b"bad"));
+        assert!(driver.pending[0].is_some());
+        assert!(responses.try_recv().is_err());
+        driver.reply(0, receipt, &body);
+        assert!(driver.pending[0].is_none());
+        let reply = responses.try_recv().unwrap();
+        let decoded = parse_echo_reply_body(
+            "203.0.113.9".parse().unwrap(),
+            "10.0.0.2".parse().unwrap(),
+            &reply.packet.data()[20..],
+        )
+        .unwrap();
+        assert_eq!(
+            (decoded.identifier, decoded.sequence, decoded.payload),
+            (33, 9, &b"odd"[..])
+        );
+        assert_eq!(ingress.permits.available_permits(), MAX_PENDING - 1);
+        driver.reply(0, receipt, &body);
+        assert!(responses.try_recv().is_err());
+        drop(reply);
+        assert_eq!(ingress.permits.available_permits(), MAX_PENDING);
+        install_pending(&ingress, &mut driver);
+        driver.pending[0].as_mut().unwrap().deadline = Instant::now();
+        driver.reply(0, receipt, &body);
+        assert!(responses.try_recv().is_err());
+        driver.expire();
+        assert_eq!(ingress.permits.available_permits(), MAX_PENDING);
+    }
+    #[test]
+    fn wire_identifiers_do_not_repeat_on_rollover() {
+        let mut family = Family::new();
+        family.next_identifier = u16::MAX;
+        assert_eq!(family.reserve_identifier(), Some(u16::MAX));
+        assert_eq!(family.reserve_identifier(), Some(1));
+        family.identifiers_issued = u32::from(u16::MAX);
+        assert_eq!(family.reserve_identifier(), None);
+    }
+    #[tokio::test]
+    async fn cancelled_owner_drops_input_and_pending_without_creating_a_socket() {
+        let (ingress, _responses, mut driver) = setup();
+        install_pending(&ingress, &mut driver);
+        assert_eq!(
+            ingress.offer(&request([203, 0, 113, 9])),
+            EchoOffer::Consumed
+        );
+        let cancellation = CancellationToken::new();
+        cancellation.cancel();
+        driver.run(cancellation).await.unwrap();
+        assert_eq!(ingress.permits.available_permits(), MAX_PENDING);
+    }
+
+    #[test]
+    fn oversized_real_echo_drops_without_consuming_queue_or_pending_capacity() {
+        let (ingress, _responses, mut driver) = setup();
+        let mut packet = request([203, 0, 113, 9]);
+        packet.resize(1501, 0x35);
+        packet[2..4].copy_from_slice(&1501u16.to_be_bytes());
+        packet[22..24].fill(0);
+        let icmp = checksum(&packet[20..]);
+        packet[22..24].copy_from_slice(&icmp.to_be_bytes());
+        packet[10..12].fill(0);
+        let ip = checksum(&packet[..20]);
+        packet[10..12].copy_from_slice(&ip.to_be_bytes());
+        assert_eq!(ingress.offer(&packet), EchoOffer::Consumed);
+        assert!(driver.requests.try_recv().is_err());
+        assert_eq!(ingress.permits.available_permits(), MAX_PENDING);
+        assert!(driver.families.iter().all(|f| f.socket.is_none()));
+    }
+}
diff --git a/src/tun_runtime.rs b/src/tun_runtime.rs
index 6605be9..546ecc3 100644
--- a/src/tun_runtime.rs
+++ b/src/tun_runtime.rs
@@ -33,29 +33,55 @@ use crate::{
         runtime::{DnsQueryPermit, RuntimeDns},
     },
     platform::{TUN_PACKET_BATCH_SIZE, TunIo},
-    quic_sniffer::{
-        QuicConnectionKey, QuicSniffOutcome, QuicSniffer, quic_connection_key,
-        quic_has_unsupported_version,
-    },
+    quic_sniffer::QuicSniffer,
     resources::{
         ResourceActivity, ResourceActivityGuard, ResourceQueue, RuntimeResourceStats, observation,
     },
     session::{Datagram, DatagramSession, Destination, InboundKind, StreamSession},
-    tcp_sniffer::{SniffOutcome, SniffProtocol, TcpSniffer},
     traffic::TunTrafficStats,
 };
 
+#[cfg(target_os = "linux")]
+#[path = "tun_echo.rs"]
+mod echo;
+#[cfg(target_os = "linux")]
+use echo::EchoIngress;
+#[cfg(not(target_os = "linux"))]
+struct EchoIngress;
+#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum EchoOffer {
+    NotEcho,
+    LocalSynthetic,
+    Consumed,
+}
+#[cfg(not(target_os = "linux"))]
+impl EchoIngress {
+    fn offer(&self, _: &[u8]) -> EchoOffer {
+        EchoOffer::NotEcho
+    }
+}
+struct QueuedEchoResponse {
+    packet: Packet,
+    permit: tokio::sync::OwnedSemaphorePermit,
+}
+fn closed_echo_lane() -> mpsc::Receiver<QueuedEchoResponse> {
+    let (sender, receiver) = mpsc::channel(1);
+    drop(sender);
+    receiver
+}
+
 #[cfg(test)]
 use crate::dns::{ClassifiedDnsQuery, synthesize_servfail_response};
+#[cfg(test)]
+use crate::{
+    quic_sniffer::{QuicSniffOutcome, quic_connection_key, quic_has_unsupported_version},
+    tcp_sniffer::SniffProtocol,
+};
 
 #[cfg(test)]
 const TUN_MTU: usize = 1_500;
 const TCP_RELAY_BUFFER: usize = 4 * 1024;
-const QUIC_SNIFF_FLOW_MAX: usize = 4;
-const QUIC_SNIFF_PENDING_DATAGRAM_MAX: usize = 8;
-const QUIC_SNIFF_PENDING_BYTES_MAX: usize = 32 * 1024;
-const QUIC_SNIFF_READY_DATAGRAM_MAX: usize = QUIC_SNIFF_PENDING_DATAGRAM_MAX + 1;
-const QUIC_SNIFF_TIMEOUT: Duration = Duration::from_millis(500);
 const OUTBOUND_OPEN_TIMEOUT: Duration = Duration::from_secs(15);
 const OUTBOUND_SEND_TIMEOUT: Duration = Duration::from_secs(15);
 #[cfg(test)]
@@ -90,10 +116,13 @@ pub(crate) struct TunRuntime {
     config: TunConfig,
     dispatcher: Arc<dyn Dispatcher>,
     dns: Option<Arc<RuntimeDns>>,
+    resources: Option<Arc<dyn crate::resource::control::RuntimeResources>>,
     ipv6: bool,
     fake_icmp_echo: bool,
     sniffer: Option<Arc<SnifferConfig>>,
     traffic_stats: Arc<TunTrafficStats>,
+    #[cfg(target_os = "linux")]
+    echo_options: Option<echo::EchoOptions>,
 }
 
 impl TunRuntime {
@@ -151,14 +180,45 @@ impl TunRuntime {
             limits,
             config: config.clone(),
             dispatcher,
-            dns,
+            dns: dns.filter(|dns| dns.is_enabled()),
+            resources: None,
             ipv6,
             fake_icmp_echo,
             sniffer,
             traffic_stats,
+            #[cfg(target_os = "linux")]
+            echo_options: None,
         })
     }
 
+    pub(crate) fn with_resources(
+        mut self,
+        resources: Option<Arc<dyn crate::resource::control::RuntimeResources>>,
+    ) -> Self {
+        // The provider graph owns the live policy, including a disabled one.
+        // A startup fallback would otherwise revive sniffing after a reload.
+        if resources.is_some() {
+            self.sniffer = None;
+        }
+        self.resources = resources;
+        self
+    }
+
+    #[cfg(target_os = "linux")]
+    pub(crate) async fn with_real_echo(
+        mut self,
+        dialer: crate::dialer::Dialer,
+        fake_ranges: [Option<crate::config::IpCidr>; 2],
+        timeout: Duration,
+        disabled: bool,
+    ) -> io::Result<Self> {
+        self.echo_options = Some(
+            echo::EchoOptions::prepare(dialer, self.tun.clone(), fake_ranges, timeout, disabled)
+                .await?,
+        );
+        Ok(self)
+    }
+
     pub(crate) async fn run(self, cancellation: CancellationToken) -> io::Result<()> {
         let config = tun_netstack_config(self.limits, self.fake_icmp_echo);
         let resource_stats = RuntimeResourceStats::new("tun_runtime");
@@ -171,17 +231,28 @@ impl TunRuntime {
             dns_hijack = self.dns.is_some(),
             ipv6 = self.ipv6,
             fake_icmp_echo = self.fake_icmp_echo,
-            domain_sniffing = self.sniffer.is_some(),
             "TUN runtime starting"
         );
         let parts = NetStack::start_tcp(config).map_err(netstack_to_io)?;
         let control = parts.control.clone();
         let netstack_stats = parts.stats.clone();
         let mut tasks = JoinSet::new();
+        #[cfg(target_os = "linux")]
+        let (echo, echo_responses) = if let Some(options) = self.echo_options {
+            let (ingress, responses, driver) =
+                echo::channel(options, effective_tun_mtu(self.limits));
+            tasks.spawn(observation::task(driver.run(cancellation.clone())));
+            (Some(ingress), responses)
+        } else {
+            (None, closed_echo_lane())
+        };
+        #[cfg(not(target_os = "linux"))]
+        let (echo, echo_responses): (Option<EchoIngress>, _) = (None, closed_echo_lane());
         let (udp, responses, dns_responses) = UdpIngress::new(
             UdpIngressContext {
                 dispatcher: self.dispatcher.clone(),
                 dns: self.dns,
+                resources: self.resources,
                 sniffer: self.sniffer.clone(),
                 limits: self.limits,
                 config: self.config.clone(),
@@ -199,19 +270,21 @@ impl TunRuntime {
                 .clone()
                 .run_rate_clock(cancellation.clone()),
         ));
-        tasks.spawn(observation::task(tun_read_loop(
+        tasks.spawn(observation::task(tun_read_loop_with_echo(
             self.tun.clone(),
             parts.packet_sink,
             self.ipv6,
             udp,
+            echo,
             self.traffic_stats.clone(),
             cancellation.clone(),
         )));
-        tasks.spawn(observation::task(tun_write_loop(
+        tasks.spawn(observation::task(tun_write_loop_with_echo(
             self.tun,
             parts.packet_stream,
             responses,
             dns_responses,
+            echo_responses,
             effective_tun_mtu(self.limits),
             self.traffic_stats,
             cancellation.clone(),
@@ -309,11 +382,33 @@ fn tun_ingress_allowed(ipv6: bool, packet: &[u8]) -> bool {
     ipv6 || packet_ip_version(packet) != 6
 }
 
+#[cfg(test)]
 async fn tun_read_loop(
+    tun: Arc<TunIo>,
+    packet_sink: PacketSink,
+    ipv6: bool,
+    udp: UdpIngress,
+    traffic_stats: Arc<TunTrafficStats>,
+    cancellation: CancellationToken,
+) -> io::Result<()> {
+    tun_read_loop_with_echo(
+        tun,
+        packet_sink,
+        ipv6,
+        udp,
+        None,
+        traffic_stats,
+        cancellation,
+    )
+    .await
+}
+
+async fn tun_read_loop_with_echo(
     tun: Arc<TunIo>,
     packet_sink: PacketSink,
     ipv6: bool,
     mut udp: UdpIngress,
+    echo: Option<EchoIngress>,
     traffic_stats: Arc<TunTrafficStats>,
     cancellation: CancellationToken,
 ) -> io::Result<()> {
@@ -322,6 +417,7 @@ async fn tun_read_loop(
         packet_sink,
         ipv6,
         &mut udp,
+        echo.as_ref(),
         traffic_stats,
         cancellation,
     )
@@ -337,6 +433,7 @@ async fn tun_read_inner(
     packet_sink: PacketSink,
     ipv6: bool,
     udp: &mut UdpIngress,
+    echo: Option<&EchoIngress>,
     traffic_stats: Arc<TunTrafficStats>,
     cancellation: CancellationToken,
 ) -> io::Result<()> {
@@ -425,13 +522,23 @@ async fn tun_read_inner(
                 );
                 continue;
             }
+            if echo.is_some_and(|echo| echo.offer(packet) == EchoOffer::Consumed) {
+                continue;
+            }
             if let Some(datagram) = parse_udp_packet_view(packet) {
                 udp.offer(datagram);
                 continue;
             }
-            // A full TCP/ICMP handoff drops this complete IP packet. Awaiting
-            // capacity here would also stall unrelated UDP and DNS ingress.
-            match packet_sink.try_send(Packet::new(Bytes::copy_from_slice(packet))) {
+            // Give a transiently full handoff one scheduling turn to drain.
+            // Persistent pressure still drops this packet, keeping unrelated
+            // UDP and DNS ingress independent of TCP capacity.
+            match offer_netstack_packet(
+                &packet_sink,
+                Packet::new(Bytes::copy_from_slice(packet)),
+                &cancellation,
+            )
+            .await
+            {
                 Ok(()) => {
                     if !first_ingress_logged {
                         tracing::info!("netstack accepted first TUN packet");
@@ -459,17 +566,47 @@ async fn tun_read_inner(
             }
         }
         result.map_err(vole_to_io)?;
-        // try_send / borrowed UDP classification have no channel await. Charge
-        // actual packets, including locally dropped ones, after each <=8 batch.
+        // Fast-path packet and borrowed UDP offers have no channel await.
+        // Charge every packet, including drops, after each <=8 batch.
         for _ in 0..processed {
             tokio::task::consume_budget().await;
         }
     }
 }
 
+async fn offer_netstack_packet(
+    sink: &PacketSink,
+    packet: Packet,
+    cancellation: &CancellationToken,
+) -> Result<(), NetStackError> {
+    if cancellation.is_cancelled() {
+        return Err(NetStackError::Stopped);
+    }
+    match sink.try_send(packet.clone()) {
+        Err(NetStackError::Backpressure) => {}
+        result => return result,
+    }
+    // Reserve the next available slot without waiting indefinitely. Holding
+    // this one packet across a yield does not create another ingress queue.
+    let send = sink.send(packet);
+    tokio::pin!(send);
+    if let std::task::Poll::Ready(result) = futures_util::poll!(send.as_mut()) {
+        return result;
+    }
+    tokio::task::yield_now().await;
+    if cancellation.is_cancelled() {
+        return Err(NetStackError::Stopped);
+    }
+    match futures_util::poll!(send.as_mut()) {
+        std::task::Poll::Ready(result) => result,
+        std::task::Poll::Pending => Err(NetStackError::Backpressure),
+    }
+}
+
 enum TunOutput {
     Raw(Packet),
     Udp(QueuedUdpResponse),
+    Echo(QueuedEchoResponse),
 }
 
 /// One bounded scheduling owner, not another packet queue. The cursor persists
@@ -478,7 +615,8 @@ struct TunOutputMux {
     raw: PacketStream,
     ordinary: mpsc::Receiver<QueuedUdpResponse>,
     dns: mpsc::Receiver<QueuedUdpResponse>,
-    open: [bool; 3],
+    echo: mpsc::Receiver<QueuedEchoResponse>,
+    open: [bool; 4],
     next_lane: usize,
 }
 
@@ -487,30 +625,33 @@ impl TunOutputMux {
         raw: PacketStream,
         ordinary: mpsc::Receiver<QueuedUdpResponse>,
         dns: mpsc::Receiver<QueuedUdpResponse>,
+        echo: mpsc::Receiver<QueuedEchoResponse>,
     ) -> Self {
         Self {
             raw,
             ordinary,
             dns,
-            open: [true; 3],
+            echo,
+            open: [true; 4],
             next_lane: 0,
         }
     }
 
     fn try_next(&mut self) -> Option<TunOutput> {
-        for offset in 0..3 {
-            let lane = (self.next_lane + offset) % 3;
+        for offset in 0..4 {
+            let lane = (self.next_lane + offset) % 4;
             if !self.open[lane] {
                 continue;
             }
             let result = match lane {
                 0 => self.raw.try_recv().map(TunOutput::Raw),
                 1 => self.ordinary.try_recv().map(TunOutput::Udp),
-                _ => self.dns.try_recv().map(TunOutput::Udp),
+                2 => self.dns.try_recv().map(TunOutput::Udp),
+                _ => self.echo.try_recv().map(TunOutput::Echo),
             };
             match result {
                 Ok(output) => {
-                    self.next_lane = (lane + 1) % 3;
+                    self.next_lane = (lane + 1) % 4;
                     return Some(output);
                 }
                 Err(mpsc::error::TryRecvError::Disconnected) => self.open[lane] = false,
@@ -532,9 +673,10 @@ impl TunOutputMux {
                 packet = self.raw.recv(), if self.open[0] => (0, packet.map(TunOutput::Raw)),
                 response = self.ordinary.recv(), if self.open[1] => (1, response.map(TunOutput::Udp)),
                 response = self.dns.recv(), if self.open[2] => (2, response.map(TunOutput::Udp)),
+                response = self.echo.recv(), if self.open[3] => (3, response.map(TunOutput::Echo)),
             };
             if let Some(output) = output {
-                self.next_lane = (lane + 1) % 3;
+                self.next_lane = (lane + 1) % 4;
                 return Some(output);
             }
             self.open[lane] = false;
@@ -542,6 +684,7 @@ impl TunOutputMux {
     }
 }
 
+#[cfg(test)]
 #[allow(clippy::too_many_arguments)]
 async fn tun_write_loop(
     tun: Arc<TunIo>,
@@ -552,13 +695,39 @@ async fn tun_write_loop(
     traffic_stats: Arc<TunTrafficStats>,
     cancellation: CancellationToken,
 ) -> io::Result<()> {
-    let mut mux = TunOutputMux::new(packet_stream, responses, dns_responses);
+    tun_write_loop_with_echo(
+        tun,
+        packet_stream,
+        responses,
+        dns_responses,
+        closed_echo_lane(),
+        mtu,
+        traffic_stats,
+        cancellation,
+    )
+    .await
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn tun_write_loop_with_echo(
+    tun: Arc<TunIo>,
+    packet_stream: PacketStream,
+    responses: mpsc::Receiver<QueuedUdpResponse>,
+    dns_responses: mpsc::Receiver<QueuedUdpResponse>,
+    echo_responses: mpsc::Receiver<QueuedEchoResponse>,
+    mtu: usize,
+    traffic_stats: Arc<TunTrafficStats>,
+    cancellation: CancellationToken,
+) -> io::Result<()> {
+    let mut mux = TunOutputMux::new(packet_stream, responses, dns_responses, echo_responses);
     let mut first_write_logged = false;
     let mut frames: [Vec<u8>; TUN_PACKET_BATCH_SIZE] =
         std::array::from_fn(|_| Vec::with_capacity(mtu));
     let mut raw: [Option<Packet>; TUN_PACKET_BATCH_SIZE] = std::array::from_fn(|_| None);
     let mut permits: [Option<DnsQueryPermit>; TUN_PACKET_BATCH_SIZE] =
         std::array::from_fn(|_| None);
+    let mut echo_permits: [Option<tokio::sync::OwnedSemaphorePermit>; TUN_PACKET_BATCH_SIZE] =
+        std::array::from_fn(|_| None);
     let mut outcomes = Vec::with_capacity(TUN_PACKET_BATCH_SIZE);
     loop {
         let first = tokio::select! {
@@ -584,6 +753,10 @@ async fn tun_write_loop(
             processed += 1;
             match output {
                 TunOutput::Raw(packet) => raw[count] = Some(packet),
+                TunOutput::Echo(QueuedEchoResponse { packet, permit }) => {
+                    raw[count] = Some(packet);
+                    echo_permits[count] = Some(permit);
+                }
                 TunOutput::Udp(QueuedUdpResponse {
                     datagram,
                     dns_permit,
@@ -615,6 +788,7 @@ async fn tun_write_loop(
             let mut down_bytes = 0usize;
             for (index, outcome) in outcomes.drain(..).enumerate() {
                 permits[index].take();
+                echo_permits[index].take();
                 match outcome {
                     Ok(_) => {
                         down_bytes = down_bytes.saturating_add(slices[index].len());
@@ -647,6 +821,7 @@ async fn tun_write_loop(
         for index in 0..count {
             raw[index] = None;
             permits[index] = None;
+            echo_permits[index] = None;
         }
         for _ in 0..processed {
             tokio::task::consume_budget().await;
@@ -712,55 +887,51 @@ async fn relay_tcp(
     let destination = inbound.destination_addr();
     let destination_port = destination.port();
     let ip_version = if destination.is_ipv4() { 4 } else { 6 };
-    let protocol = sniffer
-        .as_deref()
-        .and_then(|config| configured_sniff_protocol(config, destination_port));
-    let (sniffed_domain, prefetched) = if let Some(protocol) = protocol {
-        let mut sniffer = TcpSniffer::new(protocol);
-        let outcome = tokio::select! {
-            biased;
-            () = cancellation.cancelled() => return,
-            outcome = sniffer.sniff(&mut inbound) => outcome,
-        };
-        let sniffed_domain = match outcome {
-            Ok(SniffOutcome::Matched { protocol, domain }) => {
-                tracing::debug!(
-                    session_id,
-                    ?protocol,
-                    destination_port,
-                    buffered_bytes = sniffer.buffered_len(),
-                    "TUN TCP domain sniffed"
-                );
-                Some(domain)
-            }
-            Ok(outcome) => {
-                tracing::debug!(
-                    session_id,
-                    ?outcome,
-                    destination_port,
-                    "TUN TCP domain sniffing completed without a domain"
-                );
-                None
-            }
-            Err(error) => {
-                tracing::debug!(
-                    session_id,
-                    error_kind = ?error.kind(),
-                    destination_port,
-                    "TUN TCP domain sniffing failed open"
-                );
-                None
-            }
-        };
-        (sniffed_domain, sniffer.into_buffered())
-    } else {
-        (None, Vec::new())
-    };
-    let session = StreamSession {
+    let mut session = StreamSession {
+        metadata: crate::session::InboundMetadata::new(destination_port),
         inbound: InboundKind::Tun,
         source: inbound.source_addr(),
-        destination: Destination::Ip(inbound.destination_addr()),
-        sniffed_domain,
+        destination: Destination::Ip(destination),
+        sniffed_domain: None,
+    };
+    #[cfg(feature = "inbound-http")]
+    let (mut inbound, dispatcher) = {
+        let mut prefix = Vec::new();
+        let mut selected = dispatcher;
+        if let Some(http) = selected.http_context()
+            && http.candidate_port(destination_port)
+        {
+            match http
+                .try_intercept(&mut inbound, session.clone(), cancellation.clone())
+                .await
+            {
+                Ok(crate::http_processing::Intercept::Handled) => return,
+                Ok(crate::http_processing::Intercept::Transparent { prefix: bytes }) => {
+                    prefix = bytes;
+                    selected = http.dispatcher().clone();
+                }
+                Err(_) => return,
+            }
+        }
+        (
+            crate::http_processing::io::Replay::new(prefix, inbound),
+            selected,
+        )
+    };
+    let plan = match dispatcher
+        .sniff_plan(session.source, &session.destination)
+        .await
+    {
+        Ok(plan) => plan,
+        Err(_) => return,
+    }
+    .or_else(|| sniffer.map(|config| crate::sniffing::Plan::standalone(config, destination_port)));
+    let prefetched = if let Some(plan) = plan {
+        let plan = plan.with_cancellation(cancellation.clone());
+        tokio::select! { biased; () = cancellation.cancelled() => return,
+        bytes = plan.sniff(&mut inbound, &mut session) => match bytes { Ok(bytes) => bytes, Err(_) => return } }
+    } else {
+        Vec::new()
     };
     let connected = tokio::select! {
         biased;
@@ -848,11 +1019,13 @@ async fn relay_tcp(
         Err(error) => tracing::warn!(
             session_id,
             error_kind = ?error.kind(),
+            error = %error,
             "TUN TCP relay failed"
         ),
     }
 }
 
+#[cfg(test)]
 fn configured_sniff_protocol(config: &SnifferConfig, port: u16) -> Option<SniffProtocol> {
     if config.matches_http_port(port) {
         Some(SniffProtocol::Http)
@@ -1001,6 +1174,7 @@ fn try_queue_association_input(
 struct UdpIngressContext {
     dispatcher: Arc<dyn Dispatcher>,
     dns: Option<Arc<RuntimeDns>>,
+    resources: Option<Arc<dyn crate::resource::control::RuntimeResources>>,
     sniffer: Option<Arc<SnifferConfig>>,
     limits: ResourceLimits,
     config: TunConfig,
@@ -1054,20 +1228,37 @@ impl UdpIngress {
             return;
         }
         if self.context.config.hijacks_dns(datagram.destination)
-            && let Some(dns) = &self.context.dns
+            && let Some(snapshot) = self
+                .context
+                .resources
+                .as_ref()
+                .and_then(|resources| resources.dns())
+                .or_else(|| {
+                    self.context
+                        .dns
+                        .clone()
+                        .map(|dns| crate::resource::control::DnsSnapshot {
+                            dns,
+                            _generation: None,
+                        })
+                })
+            && snapshot.dns.is_enabled()
         {
+            let dns = snapshot.dns.clone();
             if let Err(error) = classify_query(datagram.payload) {
                 tracing::debug!(%error, "dropping invalid TUN DNS datagram");
                 return;
             }
-            let permit = dns.begin_query();
+            let permit = dns
+                .begin_query()
+                .with_cancellation(self.cancellation.clone());
             let request = UdpDatagram::new(
                 datagram.source,
                 datagram.destination,
                 Bytes::copy_from_slice(datagram.payload),
             );
-            self.dns_tasks.spawn(observation::task(run_tun_dns_query(
-                dns.clone(),
+            self.dns_tasks.spawn(observation::task(run_tun_dns_snapshot(
+                snapshot,
                 permit,
                 request,
                 self.dns_responses.clone(),
@@ -1217,6 +1408,28 @@ impl Deref for QueuedUdpResponse {
     }
 }
 
+async fn run_tun_dns_snapshot(
+    snapshot: crate::resource::control::DnsSnapshot,
+    permit: DnsQueryPermit,
+    request: UdpDatagram,
+    responses: mpsc::Sender<QueuedUdpResponse>,
+    tun_mtu: usize,
+    resource_stats: RuntimeResourceStats,
+    cancellation: CancellationToken,
+) {
+    let _generation = snapshot._generation;
+    run_tun_dns_query(
+        snapshot.dns,
+        permit,
+        request,
+        responses,
+        tun_mtu,
+        resource_stats,
+        cancellation,
+    )
+    .await;
+}
+
 async fn run_tun_dns_query(
     dns: Arc<RuntimeDns>,
     permit: DnsQueryPermit,
@@ -1265,7 +1478,7 @@ fn try_queue_tun_dns_response(
 
 enum ResponseQueueResult {
     Queued,
-    Dropped,
+    Pending(UdpDatagram),
     Closed,
 }
 
@@ -1274,16 +1487,14 @@ fn try_queue_tun_udp_response(
     response: UdpDatagram,
     last_activity: &AtomicU64,
     now: u64,
-    resource_stats: &RuntimeResourceStats,
 ) -> ResponseQueueResult {
     match responses.try_send(QueuedUdpResponse::ordinary(response)) {
         Ok(()) => {
             last_activity.store(now, Ordering::Release);
             ResponseQueueResult::Queued
         }
-        Err(mpsc::error::TrySendError::Full(_)) => {
-            resource_stats.queue_drop(ResourceQueue::UdpResponse, responses.max_capacity());
-            ResponseQueueResult::Dropped
+        Err(mpsc::error::TrySendError::Full(response)) => {
+            ResponseQueueResult::Pending(response.datagram)
         }
         Err(mpsc::error::TrySendError::Closed(_)) => ResponseQueueResult::Closed,
     }
@@ -1319,518 +1530,24 @@ fn tun_dns_servfail_response(request: &UdpDatagram, query: &ClassifiedDnsQuery)
     )
 }
 
-enum AssociationEvent {
+enum AssociationEvent<'a> {
     Cancelled,
     SniffDeadline,
     ReadySend,
     Inbound(Option<UdpDatagram>),
     Outbound(Result<Datagram, DispatchError>),
+    ResponseCapacity(Result<mpsc::Permit<'a, QueuedUdpResponse>, mpsc::error::SendError<()>>),
 }
 
-trait QuicSniffEngine {
-    fn ingest(&mut self, packet: &[u8]) -> QuicSniffOutcome;
-
-    fn authenticated_initial_in_last_ingest(&self) -> bool;
-}
-
-impl QuicSniffEngine for QuicSniffer {
-    fn ingest(&mut self, packet: &[u8]) -> QuicSniffOutcome {
-        QuicSniffer::ingest(self, packet)
-    }
-
-    fn authenticated_initial_in_last_ingest(&self) -> bool {
-        QuicSniffer::authenticated_initial_in_last_ingest(self)
-    }
-}
-
-struct PreparedTunUdpDatagram {
-    datagram: UdpDatagram,
-    sniffed_domain: Option<Arc<str>>,
-    /// Carried once, on the first released datagram of an authenticated Initial flight.
-    flow_id: Option<QuicConnectionKey>,
-}
-
-impl PreparedTunUdpDatagram {
-    fn without_domain(datagram: UdpDatagram) -> Self {
-        Self {
-            datagram,
-            sniffed_domain: None,
-            flow_id: None,
-        }
-    }
-
-    fn with_domain(datagram: UdpDatagram, domain: Arc<str>) -> Self {
-        Self {
-            datagram,
-            sniffed_domain: Some(domain),
-            flow_id: None,
-        }
-    }
-
-    fn with_flow_id(mut self, flow_id: Option<QuicConnectionKey>) -> Self {
-        self.flow_id = flow_id;
-        self
-    }
-}
-
-struct PendingQuicFlow<S> {
-    sniffer: S,
-    connection_key: Option<QuicConnectionKey>,
-    datagrams: VecDeque<PreparedTunUdpDatagram>,
-    buffered_bytes: usize,
-    deadline: TokioInstant,
-}
-
-struct CompletedQuicFlow {
-    connection_key: Option<QuicConnectionKey>,
-    last_used: TokioInstant,
-}
-
-enum QuicFlowState<S> {
-    Pending(PendingQuicFlow<S>),
-    Matched {
-        domain: Arc<str>,
-        completed: CompletedQuicFlow,
-    },
-    NoDomain(CompletedQuicFlow),
-}
-
-enum QuicIngressResult {
-    Buffered,
-    Forward(PreparedTunUdpDatagram),
-    Replay(VecDeque<PreparedTunUdpDatagram>),
-}
-
-fn starts_new_quic_connection(
-    current: &Option<QuicConnectionKey>,
-    observed: &Option<QuicConnectionKey>,
-) -> bool {
-    observed
-        .as_ref()
-        .is_some_and(|observed| current.as_ref() != Some(observed))
-}
-
-fn prepend_quic_replay(
-    mut replay: VecDeque<PreparedTunUdpDatagram>,
-    next: QuicIngressResult,
-) -> QuicIngressResult {
-    if replay.is_empty() {
-        return next;
-    }
-    match next {
-        QuicIngressResult::Buffered => QuicIngressResult::Replay(replay),
-        QuicIngressResult::Forward(prepared) => {
-            replay.push_back(prepared);
-            QuicIngressResult::Replay(replay)
-        }
-        QuicIngressResult::Replay(mut next) => {
-            replay.append(&mut next);
-            QuicIngressResult::Replay(replay)
-        }
-    }
-}
-
-struct UdpQuicSniffState<S, F> {
-    flows: HashMap<SocketAddr, QuicFlowState<S>>,
-    pending_datagrams: usize,
-    pending_bytes: usize,
-    new_sniffer: F,
-    idle_timeout: Duration,
-}
-
-impl<S, F> UdpQuicSniffState<S, F>
-where
-    S: QuicSniffEngine,
-    F: FnMut() -> S,
-{
-    fn with_idle_timeout(new_sniffer: F, idle_timeout: Duration) -> Self {
-        Self {
-            flows: HashMap::new(),
-            pending_datagrams: 0,
-            pending_bytes: 0,
-            new_sniffer,
-            idle_timeout,
-        }
-    }
-
-    fn next_deadline(&self) -> Option<TokioInstant> {
-        self.flows
-            .values()
-            .filter_map(|state| match state {
-                QuicFlowState::Pending(pending) => Some(pending.deadline),
-                QuicFlowState::Matched { .. } | QuicFlowState::NoDomain(_) => None,
-            })
-            .min()
-    }
-
-    fn ingest_datagram(&mut self, datagram: UdpDatagram, now: TokioInstant) -> QuicIngressResult {
-        let destination = datagram.destination;
-        let connection_key = quic_connection_key(&datagram.payload);
-        let state = self.flows.remove(&destination).filter(|state| match state {
-            QuicFlowState::Matched { completed, .. } | QuicFlowState::NoDomain(completed) => {
-                now.saturating_duration_since(completed.last_used) < self.idle_timeout
-            }
-            QuicFlowState::Pending(_) => true,
-        });
-        if connection_key.is_none() && quic_has_unsupported_version(&datagram.payload) {
-            return self.fail_open_unsupported_version(datagram, state, now);
-        }
-        let Some(state) = state else {
-            return self.start_flow(datagram, connection_key, now);
-        };
-        match state {
-            QuicFlowState::Matched {
-                domain,
-                mut completed,
-            } => {
-                if starts_new_quic_connection(&completed.connection_key, &connection_key) {
-                    let mut candidate = (self.new_sniffer)();
-                    let outcome = candidate.ingest(&datagram.payload);
-                    if candidate.authenticated_initial_in_last_ingest() {
-                        return self.commit_started_flow(
-                            datagram,
-                            connection_key,
-                            now,
-                            candidate,
-                            outcome,
-                        );
-                    }
-                }
-                completed.last_used = now;
-                self.flows.insert(
-                    destination,
-                    QuicFlowState::Matched {
-                        domain: domain.clone(),
-                        completed,
-                    },
-                );
-                QuicIngressResult::Forward(PreparedTunUdpDatagram::with_domain(datagram, domain))
-            }
-            QuicFlowState::NoDomain(mut completed) => {
-                if starts_new_quic_connection(&completed.connection_key, &connection_key) {
-                    let mut candidate = (self.new_sniffer)();
-                    let outcome = candidate.ingest(&datagram.payload);
-                    if candidate.authenticated_initial_in_last_ingest() {
-                        return self.commit_started_flow(
-                            datagram,
-                            connection_key,
-                            now,
-                            candidate,
-                            outcome,
-                        );
-                    }
-                }
-                completed.last_used = now;
-                self.flows
-                    .insert(destination, QuicFlowState::NoDomain(completed));
-                QuicIngressResult::Forward(PreparedTunUdpDatagram::without_domain(datagram))
-            }
-            QuicFlowState::Pending(mut pending) => {
-                if starts_new_quic_connection(&pending.connection_key, &connection_key) {
-                    let outcome = pending.sniffer.ingest(&datagram.payload);
-                    if pending.sniffer.authenticated_initial_in_last_ingest() {
-                        // A non-Initial prefix can have entered the pending
-                        // state before any Initial keys existed. Adopt only
-                        // its first authenticated identity; a later header
-                        // DCID accepted by existing keys is the same flow.
-                        if pending.connection_key.is_none() {
-                            pending.connection_key = connection_key;
-                            if let Some(first) = pending.datagrams.front_mut() {
-                                first.flow_id = pending.connection_key.clone();
-                            }
-                        }
-                        return self.apply_pending_outcome(
-                            destination,
-                            pending,
-                            datagram,
-                            outcome,
-                            now,
-                        );
-                    }
-                    let mut candidate = (self.new_sniffer)();
-                    let outcome = candidate.ingest(&datagram.payload);
-                    if !candidate.authenticated_initial_in_last_ingest() {
-                        self.flows
-                            .insert(destination, QuicFlowState::Pending(pending));
-                        return QuicIngressResult::Forward(PreparedTunUdpDatagram::without_domain(
-                            datagram,
-                        ));
-                    }
-                    self.release_pending(&pending);
-                    let replay = pending.datagrams;
-                    let next =
-                        self.commit_started_flow(datagram, connection_key, now, candidate, outcome);
-                    return prepend_quic_replay(replay, next);
-                }
-                let outcome = pending.sniffer.ingest(&datagram.payload);
-                self.apply_pending_outcome(destination, pending, datagram, outcome, now)
-            }
-        }
-    }
-
-    fn fail_open_unsupported_version(
-        &mut self,
-        datagram: UdpDatagram,
-        state: Option<QuicFlowState<S>>,
-        now: TokioInstant,
-    ) -> QuicIngressResult {
-        let destination = datagram.destination;
-        match state {
-            Some(QuicFlowState::Pending(mut pending)) => {
-                self.release_pending(&pending);
-                pending
-                    .datagrams
-                    .push_back(PreparedTunUdpDatagram::without_domain(datagram));
-                self.flows.insert(
-                    destination,
-                    QuicFlowState::NoDomain(CompletedQuicFlow {
-                        connection_key: None,
-                        last_used: now,
-                    }),
-                );
-                QuicIngressResult::Replay(pending.datagrams)
-            }
-            Some(QuicFlowState::Matched { .. }) | Some(QuicFlowState::NoDomain(_)) => {
-                self.flows.insert(
-                    destination,
-                    QuicFlowState::NoDomain(CompletedQuicFlow {
-                        connection_key: None,
-                        last_used: now,
-                    }),
-                );
-                QuicIngressResult::Forward(PreparedTunUdpDatagram::without_domain(datagram))
-            }
-            None => {
-                if self.make_room_for_flow() {
-                    self.flows.insert(
-                        destination,
-                        QuicFlowState::NoDomain(CompletedQuicFlow {
-                            connection_key: None,
-                            last_used: now,
-                        }),
-                    );
-                }
-                QuicIngressResult::Forward(PreparedTunUdpDatagram::without_domain(datagram))
-            }
-        }
-    }
-
-    fn start_flow(
-        &mut self,
-        datagram: UdpDatagram,
-        connection_key: Option<QuicConnectionKey>,
-        now: TokioInstant,
-    ) -> QuicIngressResult {
-        if !self.make_room_for_flow() {
-            return QuicIngressResult::Forward(PreparedTunUdpDatagram::without_domain(datagram));
-        }
-        let mut sniffer = (self.new_sniffer)();
-        let outcome = sniffer.ingest(&datagram.payload);
-        self.commit_started_flow(datagram, connection_key, now, sniffer, outcome)
-    }
-
-    fn commit_started_flow(
-        &mut self,
-        datagram: UdpDatagram,
-        connection_key: Option<QuicConnectionKey>,
-        now: TokioInstant,
-        sniffer: S,
-        outcome: QuicSniffOutcome,
-    ) -> QuicIngressResult {
-        let destination = datagram.destination;
-        // A parseable header alone must not suppress a later authenticated
-        // Initial with the same DCID, or claim a connection identity.
-        let connection_key = sniffer
-            .authenticated_initial_in_last_ingest()
-            .then_some(connection_key)
-            .flatten();
-        let flow_id = connection_key.clone();
-        match outcome {
-            QuicSniffOutcome::NeedMoreData if self.can_buffer(datagram.payload.len()) => {
-                let buffered_bytes = datagram.payload.len();
-                let mut datagrams = VecDeque::new();
-                datagrams.push_back(
-                    PreparedTunUdpDatagram::without_domain(datagram).with_flow_id(flow_id),
-                );
-                self.pending_datagrams += 1;
-                self.pending_bytes += buffered_bytes;
-                self.flows.insert(
-                    destination,
-                    QuicFlowState::Pending(PendingQuicFlow {
-                        sniffer,
-                        connection_key,
-                        datagrams,
-                        buffered_bytes,
-                        deadline: now + QUIC_SNIFF_TIMEOUT,
-                    }),
-                );
-                QuicIngressResult::Buffered
-            }
-            QuicSniffOutcome::Matched(domain) => {
-                let domain: Arc<str> = Arc::from(domain);
-                self.flows.insert(
-                    destination,
-                    QuicFlowState::Matched {
-                        domain: domain.clone(),
-                        completed: CompletedQuicFlow {
-                            connection_key,
-                            last_used: now,
-                        },
-                    },
-                );
-                QuicIngressResult::Forward(
-                    PreparedTunUdpDatagram::with_domain(datagram, domain).with_flow_id(flow_id),
-                )
-            }
-            QuicSniffOutcome::NeedMoreData
-            | QuicSniffOutcome::EchExtensionPresent
-            | QuicSniffOutcome::NotMatched
-            | QuicSniffOutcome::LimitReached => {
-                self.flows.insert(
-                    destination,
-                    QuicFlowState::NoDomain(CompletedQuicFlow {
-                        connection_key,
-                        last_used: now,
-                    }),
-                );
-                QuicIngressResult::Forward(
-                    PreparedTunUdpDatagram::without_domain(datagram).with_flow_id(flow_id),
-                )
-            }
-        }
-    }
-
-    fn apply_pending_outcome(
-        &mut self,
-        destination: SocketAddr,
-        mut pending: PendingQuicFlow<S>,
-        datagram: UdpDatagram,
-        outcome: QuicSniffOutcome,
-        now: TokioInstant,
-    ) -> QuicIngressResult {
-        match outcome {
-            QuicSniffOutcome::NeedMoreData if self.can_buffer(datagram.payload.len()) => {
-                let payload_len = datagram.payload.len();
-                pending.buffered_bytes += payload_len;
-                pending
-                    .datagrams
-                    .push_back(PreparedTunUdpDatagram::without_domain(datagram));
-                self.pending_datagrams += 1;
-                self.pending_bytes += payload_len;
-                self.flows
-                    .insert(destination, QuicFlowState::Pending(pending));
-                QuicIngressResult::Buffered
-            }
-            QuicSniffOutcome::Matched(domain) => {
-                self.finish_pending(destination, pending, datagram, Some(Arc::from(domain)), now)
-            }
-            QuicSniffOutcome::NeedMoreData
-            | QuicSniffOutcome::EchExtensionPresent
-            | QuicSniffOutcome::NotMatched
-            | QuicSniffOutcome::LimitReached => {
-                self.finish_pending(destination, pending, datagram, None, now)
-            }
-        }
-    }
-
-    fn make_room_for_flow(&mut self) -> bool {
-        if self.flows.len() < QUIC_SNIFF_FLOW_MAX {
-            return true;
-        }
-        let oldest_completed = self
-            .flows
-            .iter()
-            .filter_map(|(destination, state)| match state {
-                QuicFlowState::Matched { completed, .. } | QuicFlowState::NoDomain(completed) => {
-                    Some((*destination, completed.last_used))
-                }
-                QuicFlowState::Pending(_) => None,
-            })
-            .min_by_key(|(_, last_used)| *last_used)
-            .map(|(destination, _)| destination);
-        if let Some(destination) = oldest_completed {
-            self.flows.remove(&destination);
-            true
-        } else {
-            false
-        }
-    }
-
-    fn can_buffer(&self, bytes: usize) -> bool {
-        self.pending_datagrams < QUIC_SNIFF_PENDING_DATAGRAM_MAX
-            && self
-                .pending_bytes
-                .checked_add(bytes)
-                .is_some_and(|total| total <= QUIC_SNIFF_PENDING_BYTES_MAX)
-    }
-
-    fn finish_pending(
-        &mut self,
-        destination: SocketAddr,
-        mut pending: PendingQuicFlow<S>,
-        datagram: UdpDatagram,
-        domain: Option<Arc<str>>,
-        now: TokioInstant,
-    ) -> QuicIngressResult {
-        self.release_pending(&pending);
-        pending
-            .datagrams
-            .push_back(PreparedTunUdpDatagram::without_domain(datagram));
-        if let Some(domain) = &domain {
-            for buffered in &mut pending.datagrams {
-                buffered.sniffed_domain = Some(domain.clone());
-            }
-        }
-        let completed = CompletedQuicFlow {
-            connection_key: pending.connection_key,
-            last_used: now,
-        };
-        self.flows.insert(
-            destination,
-            match domain {
-                Some(domain) => QuicFlowState::Matched { domain, completed },
-                None => QuicFlowState::NoDomain(completed),
-            },
-        );
-        QuicIngressResult::Replay(pending.datagrams)
-    }
-
-    fn expire(&mut self, now: TokioInstant) -> VecDeque<PreparedTunUdpDatagram> {
-        let destinations = self
-            .flows
-            .iter()
-            .filter_map(|(destination, state)| match state {
-                QuicFlowState::Pending(pending) if pending.deadline <= now => Some(*destination),
-                QuicFlowState::Pending(_)
-                | QuicFlowState::Matched { .. }
-                | QuicFlowState::NoDomain(_) => None,
-            })
-            .collect::<Vec<_>>();
-        let mut replay = VecDeque::new();
-        for destination in destinations {
-            let Some(QuicFlowState::Pending(mut pending)) = self.flows.remove(&destination) else {
-                continue;
-            };
-            self.release_pending(&pending);
-            replay.append(&mut pending.datagrams);
-            self.flows.insert(
-                destination,
-                QuicFlowState::NoDomain(CompletedQuicFlow {
-                    connection_key: pending.connection_key,
-                    last_used: now,
-                }),
-            );
-        }
-        replay
-    }
-
-    fn release_pending(&mut self, pending: &PendingQuicFlow<S>) {
-        self.pending_datagrams = self
-            .pending_datagrams
-            .saturating_sub(pending.datagrams.len());
-        self.pending_bytes = self.pending_bytes.saturating_sub(pending.buffered_bytes);
-    }
-}
+#[cfg(test)]
+use crate::udp_sniffing::{
+    QUIC_SNIFF_FLOW_MAX, QUIC_SNIFF_PENDING_BYTES_MAX, QUIC_SNIFF_PENDING_DATAGRAM_MAX,
+    QUIC_SNIFF_TIMEOUT,
+};
+use crate::udp_sniffing::{QUIC_SNIFF_READY_DATAGRAM_MAX, QuicSniffEngine};
+type PreparedTunUdpDatagram = crate::udp_sniffing::PreparedDatagram<UdpDatagram>;
+type QuicIngressResult = crate::udp_sniffing::IngressResult<UdpDatagram>;
+type UdpQuicSniffState<S, F> = crate::udp_sniffing::SniffState<S, F, UdpDatagram>;
 
 struct UdpAssociationTaskContext {
     association_id: u64,
@@ -1846,6 +1563,24 @@ struct UdpAssociationTaskContext {
     cancellation: CancellationToken,
 }
 
+// One uncommitted response per source, with no additional queue or task.
+// Cancellation discards it rather than waiting for a stopped TUN writer.
+struct PendingUdpResponse<'a> {
+    datagram: Option<UdpDatagram>,
+    context: &'a UdpAssociationTaskContext,
+}
+
+impl Drop for PendingUdpResponse<'_> {
+    fn drop(&mut self) {
+        if self.datagram.is_some() {
+            self.context.resource_stats.queue_drop(
+                ResourceQueue::UdpResponse,
+                self.context.responses.max_capacity(),
+            );
+        }
+    }
+}
+
 async fn run_udp_association(
     mut inbound: mpsc::Receiver<UdpDatagram>,
     _activity: ResourceActivityGuard,
@@ -1876,9 +1611,24 @@ async fn send_tun_udp_datagram(
 ) -> io::Result<bool> {
     let PreparedTunUdpDatagram {
         datagram,
-        sniffed_domain,
+        mut sniffed_domain,
         flow_id,
     } = prepared;
+    if let Some(plan) = context
+        .dispatcher
+        .sniff_plan(context.source, &Destination::Ip(datagram.destination))
+        .await
+        .map_err(dispatch_to_io)?
+        .or_else(|| {
+            context.sniffer.clone().map(|config| {
+                crate::sniffing::Plan::standalone(config, datagram.destination.port())
+            })
+        })
+        && let Some(host) = sniffed_domain.as_ref()
+        && !plan.accepts(host).map_err(io::Error::other)?
+    {
+        sniffed_domain = None;
+    }
     let datagram = Datagram {
         remote: Destination::Ip(datagram.destination),
         payload: datagram.payload,
@@ -1965,7 +1715,12 @@ where
     // The deque grows only for actual QUIC replay and keeps its existing bound.
     let mut ready = VecDeque::new();
     let mut pending_send = None;
+    let mut pending_response = PendingUdpResponse {
+        datagram: None,
+        context,
+    };
     let mut first_response_logged = false;
+    let mut received_in_burst = 0;
     loop {
         let sniff_deadline = quic_sniff.next_deadline();
         let event = tokio::select! {
@@ -1977,12 +1732,26 @@ where
             // Drain a ready response before accepting another datagram from
             // this same source. Fairness between the ordinary and DNS TUN
             // response queues is handled independently by the sole TUN writer.
-            datagram = transport.receive() => AssociationEvent::Outbound(datagram),
+            permit = context.responses.reserve(), if pending_response.datagram.is_some() => {
+                AssociationEvent::ResponseCapacity(permit)
+            }
+            datagram = async { transport.receive().await }, if pending_response.datagram.is_none() => AssociationEvent::Outbound(datagram),
             () = std::future::ready(()), if pending_send.is_some() || !ready.is_empty() => AssociationEvent::ReadySend,
             datagram = inbound.recv() => AssociationEvent::Inbound(datagram),
         };
         match event {
             AssociationEvent::Cancelled | AssociationEvent::Inbound(None) => break,
+            AssociationEvent::ResponseCapacity(Ok(permit)) => {
+                let response = pending_response
+                    .datagram
+                    .take()
+                    .expect("pending UDP response");
+                permit.send(QueuedUdpResponse::ordinary(response));
+                context
+                    .last_activity
+                    .store(context.association_clock.now(), Ordering::Release);
+            }
+            AssociationEvent::ResponseCapacity(Err(_)) => break,
             AssociationEvent::SniffDeadline => {
                 append_ready_datagrams(&mut ready, quic_sniff.expire(TokioInstant::now()))?;
             }
@@ -1996,10 +1765,19 @@ where
                 }
             }
             AssociationEvent::Inbound(Some(datagram)) => {
-                let sniff_quic = configured_quic_sniffing(
-                    context.sniffer.as_deref(),
-                    datagram.destination.port(),
-                );
+                let sniff_quic = if let Some(plan) = context
+                    .dispatcher
+                    .sniff_plan(context.source, &Destination::Ip(datagram.destination))
+                    .await
+                    .map_err(dispatch_to_io)?
+                {
+                    plan.quic_enabled()
+                } else {
+                    configured_quic_sniffing(
+                        context.sniffer.as_deref(),
+                        datagram.destination.port(),
+                    )
+                };
                 let result = if sniff_quic {
                     quic_sniff.ingest_datagram(datagram, TokioInstant::now())
                 } else {
@@ -2036,15 +1814,26 @@ where
                     response,
                     &context.last_activity,
                     context.association_clock.now(),
-                    &context.resource_stats,
                 ) {
                     ResponseQueueResult::Queued => {}
-                    ResponseQueueResult::Dropped => {}
+                    ResponseQueueResult::Pending(response) => {
+                        pending_response.datagram = Some(response);
+                    }
                     ResponseQueueResult::Closed => {
                         tracing::debug!(association_id, "TUN UDP response channel closed");
                         break;
                     }
                 }
+                received_in_burst += 1;
+                let capacity = context.responses.max_capacity();
+                let writer_backlog =
+                    context.responses.capacity() <= capacity - capacity.div_ceil(4);
+                if writer_backlog || received_in_burst == crate::limits::IO_POLL_BUDGET {
+                    received_in_burst = 0;
+                    // Nonblocking response handoff must give the sole writer
+                    // a turn before many ready sources fill its shared queue.
+                    tokio::task::yield_now().await;
+                }
             }
         }
     }
@@ -2091,6 +1880,7 @@ fn dispatch_to_io(error: DispatchError) -> io::Error {
         DispatchError::ConnectionRefused => io::Error::from(io::ErrorKind::ConnectionRefused),
         DispatchError::TimedOut => io::Error::from(io::ErrorKind::TimedOut),
         DispatchError::Other(message) => io::Error::other(message),
+        DispatchError::RuleEvaluation(failure) => io::Error::other(failure),
     }
 }
 
diff --git a/src/tun_runtime/tests.rs b/src/tun_runtime/tests.rs
index 40d1762..10a4d03 100644
--- a/src/tun_runtime/tests.rs
+++ b/src/tun_runtime/tests.rs
@@ -46,6 +46,10 @@ fn test_sniffer(
         http_ports: http_ports.into(),
         tls_ports: tls_ports.into(),
         quic_ports: quic_ports.into(),
+        http_override: false,
+        tls_override: false,
+        quic_override: false,
+        ..SnifferConfig::disabled()
     })
 }
 
@@ -72,7 +76,7 @@ async fn batch_tun_runtime_preserves_order_stats_and_invalid_packet_isolation()
     let (host, peer) = UnixDatagram::pair().unwrap();
     host.set_nonblocking(true).unwrap();
     peer.set_nonblocking(true).unwrap();
-    let tun = TunIo::new(
+    let tun = TunIo::new_mock(
         TunFd::duplicate_mock(host.as_raw_fd()).unwrap(),
         crate::TunFraming::RawIp,
     )
@@ -134,7 +138,7 @@ async fn batch_tun_read_loop_counts_consumed_prefix_before_eof() {
 
     let (host, mut peer) = UnixStream::pair().unwrap();
     host.set_nonblocking(true).unwrap();
-    let tun = TunIo::new(
+    let tun = TunIo::new_mock(
         TunFd::duplicate_mock(host.as_raw_fd()).unwrap(),
         crate::TunFraming::RawIp,
     )
@@ -184,7 +188,7 @@ async fn assert_effective_mtu_drops_oversized_udp(dns_query: bool) {
     let (host, peer) = UnixDatagram::pair().unwrap();
     host.set_nonblocking(true).unwrap();
     peer.set_nonblocking(true).unwrap();
-    let tun = TunIo::new(
+    let tun = TunIo::new_mock(
         TunFd::duplicate_mock(host.as_raw_fd()).unwrap(),
         crate::TunFraming::RawIp,
     )
@@ -734,6 +738,10 @@ async fn quic_prepared_datagrams_forward_flow_identity_only_on_the_marked_send()
 
     #[async_trait]
     impl DatagramTransport for RecordingFlowTransport {
+        fn supports_shared_destinations(&self) -> bool {
+            false
+        }
+
         async fn send(&mut self, datagram: Datagram) -> Result<(), DispatchError> {
             self.sent.push((datagram, None));
             Ok(())
@@ -1654,7 +1662,7 @@ fn quic_flow_state_is_isolated_by_destination_and_unconfigured_ports_are_skipped
 #[test]
 fn tun_response_capacities_are_independent_of_tcp_accept_and_each_other() {
     let tun = ResourceLimits::default();
-    assert_eq!(tun.tun_udp_response_queue_capacity, 4_096);
+    assert_eq!(tun.tun_udp_response_queue_capacity, 256);
     assert_eq!(tun.tun_dns_response_queue_capacity, 128);
     let altered = ResourceLimits {
         event_queue_capacity: 3,
@@ -1670,12 +1678,194 @@ fn tun_response_capacities_are_independent_of_tcp_accept_and_each_other() {
     assert_eq!(altered.tun_dns_response_queue_capacity, 7);
 }
 
+#[tokio::test]
+async fn ready_udp_receive_bursts_let_the_response_writer_run_without_drops() {
+    assert_ready_udp_receive_bursts(1, UdpBurstConsumer::Ready).await;
+}
+
+#[tokio::test]
+async fn concurrent_ready_udp_sources_let_the_response_writer_run_without_drops() {
+    assert_ready_udp_receive_bursts(8, UdpBurstConsumer::Ready).await;
+}
+
+#[tokio::test]
+async fn backpressured_udp_response_handoff_retains_one_packet_and_duplex_progress() {
+    assert_ready_udp_receive_bursts(8, UdpBurstConsumer::Delayed).await;
+}
+
+#[tokio::test]
+async fn backpressured_udp_response_handoff_stops_without_waiting_for_the_writer() {
+    assert_ready_udp_receive_bursts(8, UdpBurstConsumer::Stopped).await;
+}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum UdpBurstConsumer {
+    Ready,
+    Delayed,
+    Stopped,
+}
+
+async fn assert_ready_udp_receive_bursts(sources: usize, consumer: UdpBurstConsumer) {
+    const PACKETS: u32 = 512;
+    struct BurstDispatcher(SocketAddr, Arc<AtomicUsize>, Arc<AtomicUsize>);
+    struct BurstDatagrams {
+        remote: SocketAddr,
+        sequence: u32,
+        received: Arc<AtomicUsize>,
+        sent: Arc<AtomicUsize>,
+    }
+    #[async_trait]
+    impl Dispatcher for BurstDispatcher {
+        async fn connect_tcp(&self, _: StreamSession) -> Result<BoxStream, DispatchError> {
+            Err(DispatchError::Other("unused memory TCP path".into()))
+        }
+        async fn open_datagram(
+            &self,
+            _: DatagramSession,
+        ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+            Ok(Box::new(BurstDatagrams {
+                remote: self.0,
+                sequence: 0,
+                received: self.1.clone(),
+                sent: self.2.clone(),
+            }))
+        }
+    }
+    #[async_trait]
+    impl DatagramTransport for BurstDatagrams {
+        fn supports_shared_destinations(&self) -> bool {
+            false
+        }
+
+        async fn send(&mut self, _: Datagram) -> Result<(), DispatchError> {
+            self.sent.fetch_add(1, Ordering::Relaxed);
+            Ok(())
+        }
+        async fn receive(&mut self) -> Result<Datagram, DispatchError> {
+            if self.sequence == PACKETS {
+                std::future::pending::<()>().await;
+            }
+            // A real Tokio UDP readiness operation also charges cooperation.
+            // The native quantum alone can exceed this writer handoff queue.
+            tokio::task::consume_budget().await;
+            let payload = Bytes::copy_from_slice(&self.sequence.to_be_bytes());
+            self.sequence += 1;
+            self.received.fetch_add(1, Ordering::Relaxed);
+            Ok(Datagram {
+                remote: Destination::Ip(self.remote),
+                payload,
+                sniffed_domain: None,
+            })
+        }
+    }
+    let remote = "198.51.100.20:443".parse().unwrap();
+    let (responses, mut output) = mpsc::channel(64);
+    let cancellation = CancellationToken::new();
+    let stats = RuntimeResourceStats::new("udp_receive_burst_test");
+    let mut inbound = Vec::new();
+    let mut producers = Vec::new();
+    let read_count = Arc::new(AtomicUsize::new(0));
+    let send_count = Arc::new(AtomicUsize::new(0));
+    for index in 0..sources {
+        let source = SocketAddr::new("192.0.2.10".parse().unwrap(), 12000 + index as u16);
+        let (sender, mut input) = mpsc::channel(1);
+        inbound.push(sender);
+        let context = UdpAssociationTaskContext {
+            association_id: index as u64 + 1,
+            source,
+            responses: responses.clone(),
+            dispatcher: Arc::new(BurstDispatcher(
+                remote,
+                read_count.clone(),
+                send_count.clone(),
+            )),
+            resource_stats: stats.clone(),
+            association_clock: AssociationClock::realtime(),
+            last_activity: Arc::new(AtomicU64::new(0)),
+            tun_mtu: TUN_MTU,
+            udp_timeout: Duration::from_secs(30),
+            sniffer: None,
+            cancellation: cancellation.clone(),
+        };
+        producers.push(tokio::spawn(async move {
+            run_udp_association_inner(&mut input, &context).await
+        }));
+    }
+    if consumer != UdpBurstConsumer::Ready {
+        for _ in 0..32 {
+            tokio::task::yield_now().await;
+        }
+        assert_eq!(output.len(), output.max_capacity());
+        assert!(
+            read_count.load(Ordering::Relaxed) <= output.max_capacity() + sources,
+            "a blocked writer must retain at most one extra response per source"
+        );
+        for (index, sender) in inbound.iter().enumerate() {
+            let source = SocketAddr::new("192.0.2.10".parse().unwrap(), 12000 + index as u16);
+            sender
+                .try_send(UdpDatagram::new(source, remote, b"uplink".as_slice()))
+                .unwrap();
+        }
+        for _ in 0..8 {
+            tokio::task::yield_now().await;
+        }
+        assert_eq!(send_count.load(Ordering::Relaxed), sources);
+    }
+    let received = if consumer == UdpBurstConsumer::Stopped {
+        Ok(true)
+    } else {
+        timeout(Duration::from_millis(200), async {
+            let mut next = vec![0_u32; sources];
+            for _ in 0..PACKETS as usize * sources {
+                let response = output.recv().await.expect("memory UDP producer closed");
+                let index = usize::from(response.destination.port().saturating_sub(12000));
+                if response.source != remote
+                    || response.destination
+                        != SocketAddr::new("192.0.2.10".parse().unwrap(), 12000 + index as u16)
+                    || index >= sources
+                    || response.payload[..] != next[index].to_be_bytes()
+                {
+                    return false;
+                }
+                next[index] += 1;
+                // The real writer charges each emitted packet in addition to
+                // channel reception, even when all producers remain ready.
+                tokio::task::consume_budget().await;
+            }
+            true
+        })
+        .await
+    };
+    cancellation.cancel();
+    for producer in producers {
+        timeout(Duration::from_secs(1), producer)
+            .await
+            .unwrap()
+            .unwrap()
+            .unwrap();
+    }
+    drop(inbound);
+    assert!(
+        matches!(received, Ok(true)),
+        "ready receive burst starved the response writer"
+    );
+    assert_eq!(
+        stats.snapshot().udp_response_queue_drops,
+        if consumer == UdpBurstConsumer::Stopped {
+            sources as u64
+        } else {
+            0
+        }
+    );
+}
+
 #[tokio::test]
 async fn default_udp_response_queue_absorbs_bounded_bursts_without_blocking_dns() {
     let stats = RuntimeResourceStats::new("tun_response_capacity_test");
     let cancellation = CancellationToken::new();
     let (mut ingress, mut ordinary, mut dns) = UdpIngress::new(
         UdpIngressContext {
+            resources: None,
             config: test_tun_config(),
             dispatcher: Arc::new(MockDispatcher::default()),
             dns: None,
@@ -1685,43 +1875,37 @@ async fn default_udp_response_queue_absorbs_bounded_bursts_without_blocking_dns(
         },
         cancellation.clone(),
     );
-    assert_eq!(ordinary.max_capacity(), 4_096);
+    assert_eq!(ordinary.max_capacity(), 256);
     assert_eq!(dns.max_capacity(), 128);
     let source: SocketAddr = "192.0.2.10:12000".parse().unwrap();
     let server: SocketAddr = "198.51.100.20:443".parse().unwrap();
     let response =
         |sequence: u32| UdpDatagram::new(server, source, sequence.to_be_bytes().to_vec());
     let last_activity = AtomicU64::new(5);
-    for sequence in 0..4_096 {
+    for sequence in 0..256 {
         assert!(matches!(
             try_queue_tun_udp_response(
                 &ingress.responses,
                 response(sequence),
                 &last_activity,
                 u64::from(sequence) + 100,
-                &stats,
             ),
             ResponseQueueResult::Queued
         ));
     }
-    assert_eq!(ordinary.len(), 4_096);
-    assert!(matches!(
-        try_queue_tun_udp_response(
-            &ingress.responses,
-            response(4_096),
-            &last_activity,
-            5_000,
-            &stats,
-        ),
-        ResponseQueueResult::Dropped
-    ));
-    assert_eq!(last_activity.load(Ordering::Acquire), 4_195);
-    assert_eq!(stats.snapshot().udp_response_queue_drops, 1);
+    assert_eq!(ordinary.len(), 256);
+    let ResponseQueueResult::Pending(pending) =
+        try_queue_tun_udp_response(&ingress.responses, response(256), &last_activity, 5_000)
+    else {
+        panic!("full queue must return its uncommitted response")
+    };
+    assert_eq!(last_activity.load(Ordering::Acquire), 355);
+    assert_eq!(stats.snapshot().udp_response_queue_drops, 0);
     assert_eq!(stats.snapshot().udp_association_queue_drops, 0);
     assert_eq!(stats.snapshot().dns_queue_drops, 0);
 
     // Saturating the ordinary channel neither consumes DNS capacity nor
-    // overwrites any accepted response. Freeing one slot admits only new work.
+    // overwrites any accepted response. Freeing one slot admits the held packet.
     try_queue_tun_dns_response(&ingress.dns_responses, response(7), None, &stats);
     assert_eq!(&dns.try_recv().unwrap().payload[..], 7_u32.to_be_bytes());
     assert_eq!(
@@ -1729,16 +1913,10 @@ async fn default_udp_response_queue_absorbs_bounded_bursts_without_blocking_dns(
         0_u32.to_be_bytes()
     );
     assert!(matches!(
-        try_queue_tun_udp_response(
-            &ingress.responses,
-            response(4_097),
-            &last_activity,
-            5_001,
-            &stats,
-        ),
+        try_queue_tun_udp_response(&ingress.responses, pending, &last_activity, 5_001,),
         ResponseQueueResult::Queued
     ));
-    for sequence in 1_u32..4_096 {
+    for sequence in 1_u32..256 {
         assert_eq!(
             &ordinary.try_recv().unwrap().payload[..],
             sequence.to_be_bytes()
@@ -1746,7 +1924,7 @@ async fn default_udp_response_queue_absorbs_bounded_bursts_without_blocking_dns(
     }
     assert_eq!(
         &ordinary.try_recv().unwrap().payload[..],
-        4_097_u32.to_be_bytes()
+        256_u32.to_be_bytes()
     );
     assert!(matches!(
         ordinary.try_recv(),
@@ -1754,17 +1932,11 @@ async fn default_udp_response_queue_absorbs_bounded_bursts_without_blocking_dns(
     ));
     ordinary.close();
     assert!(matches!(
-        try_queue_tun_udp_response(
-            &ingress.responses,
-            response(4_098),
-            &last_activity,
-            6_000,
-            &stats,
-        ),
+        try_queue_tun_udp_response(&ingress.responses, response(258), &last_activity, 6_000,),
         ResponseQueueResult::Closed
     ));
     assert_eq!(last_activity.load(Ordering::Acquire), 5_001);
-    assert_eq!(stats.snapshot().udp_queue_drops, 1);
+    assert_eq!(stats.snapshot().udp_queue_drops, 0);
     assert_eq!(stats.snapshot().dns_queue_drops, 0);
     ingress.stop().await;
     assert!(!cancellation.is_cancelled());
@@ -1997,6 +2169,10 @@ impl Dispatcher for RecordingUdpDispatcher {
 
 #[async_trait]
 impl DatagramTransport for RecordingUdpTransport {
+    fn supports_shared_destinations(&self) -> bool {
+        false
+    }
+
     async fn send(&mut self, datagram: Datagram) -> Result<(), DispatchError> {
         self.datagrams.lock().unwrap().push(datagram);
         self.sent.notify_one();
@@ -2028,6 +2204,10 @@ impl Dispatcher for ReplayFairDispatcher {
 
 #[async_trait]
 impl DatagramTransport for ReplayFairDatagrams {
+    fn supports_shared_destinations(&self) -> bool {
+        false
+    }
+
     async fn send(&mut self, _datagram: Datagram) -> Result<(), DispatchError> {
         let send_index = self.send_count.fetch_add(1, Ordering::Relaxed);
         if send_index == 0 {
@@ -2104,6 +2284,10 @@ impl DnsReplyDatagrams {
 
 #[async_trait]
 impl DatagramTransport for DnsReplyDatagrams {
+    fn supports_shared_destinations(&self) -> bool {
+        false
+    }
+
     async fn send(&mut self, mut datagram: Datagram) -> Result<(), DispatchError> {
         let query = classify_query(&datagram.payload)
             .map_err(|error| DispatchError::Other(error.to_string()))?;
@@ -2176,6 +2360,10 @@ struct ResponseFirstDatagrams {
 
 #[async_trait]
 impl DatagramTransport for ResponseFirstDatagrams {
+    fn supports_shared_destinations(&self) -> bool {
+        false
+    }
+
     async fn send(&mut self, _datagram: Datagram) -> Result<(), DispatchError> {
         std::future::pending().await
     }
@@ -2190,6 +2378,10 @@ impl DatagramTransport for ResponseFirstDatagrams {
 
 #[async_trait]
 impl DatagramTransport for BlockingDatagrams {
+    fn supports_shared_destinations(&self) -> bool {
+        false
+    }
+
     async fn send(&mut self, _datagram: Datagram) -> Result<(), DispatchError> {
         if let Some(send_count) = &self.send_count {
             send_count.fetch_add(1, Ordering::Relaxed);
@@ -2216,6 +2408,10 @@ impl EchoDatagrams {
 
 #[async_trait]
 impl DatagramTransport for EchoDatagrams {
+    fn supports_shared_destinations(&self) -> bool {
+        false
+    }
+
     async fn send(&mut self, mut datagram: Datagram) -> Result<(), DispatchError> {
         if datagram.payload.as_ref() == b"oversize-response" {
             datagram.payload = Bytes::from(vec![0_u8; TUN_MTU]);
@@ -2244,12 +2440,16 @@ fn test_runtime_dns(dispatcher: Arc<dyn Dispatcher>) -> Arc<RuntimeDns> {
         enable: true,
         ipv6: true,
         nameservers: vec![DnsNameserver {
+            path: None,
+            http_auth: None,
+            options: Default::default(),
             transport: DnsTransport::Udp,
             address: Ipv4Addr::new(198, 51, 100, 53).into(),
             port: 53,
             route: DnsRoute::Direct,
         }],
         nameserver_policies: Vec::new(),
+        ..DnsConfig::default()
     };
     let proxies = ProxyDispatchers::new(vec![dispatcher.clone()]).unwrap();
     let rules = RuleSet::compile(vec![RuleSpec {
@@ -2276,7 +2476,7 @@ async fn synthetic_fd_with_dns_disabled_dispatches_tcp_and_reuses_udp_associatio
     host.set_nonblocking(true).unwrap();
     peer.set_nonblocking(true).unwrap();
     let fd = TunFd::duplicate_mock(host.as_raw_fd()).unwrap();
-    let tun = TunIo::new(fd, crate::TunFraming::RawIp).unwrap();
+    let tun = TunIo::new_mock(fd, crate::TunFraming::RawIp).unwrap();
     let peer = tokio::net::UnixDatagram::from_std(peer).unwrap();
     let dispatcher = Arc::new(MockDispatcher::default());
     let limits = ResourceLimits {
@@ -2382,6 +2582,16 @@ async fn synthetic_fd_with_dns_disabled_dispatches_tcp_and_reuses_udp_associatio
     assert_eq!(
         dispatcher.tcp_sessions.lock().unwrap()[0],
         StreamSession {
+            metadata: crate::session::InboundMetadata {
+                original: Some(Arc::new(crate::session::InboundSnapshot {
+                    source: tcp_source,
+                    destination: Destination::Ip(tcp_destination),
+                    socket_destination: Some(tcp_destination),
+                    inbound: InboundKind::Tun,
+                    user: None,
+                })),
+                ..crate::session::InboundMetadata::new(tcp_destination.port())
+            },
             inbound: InboundKind::Tun,
             source: tcp_source,
             destination: Destination::Ip(tcp_destination),
@@ -2422,7 +2632,7 @@ async fn unconfigured_tls_port_dispatches_without_reading_a_prefix() {
     host.set_nonblocking(true).unwrap();
     peer.set_nonblocking(true).unwrap();
     let fd = TunFd::duplicate_mock(host.as_raw_fd()).unwrap();
-    let tun = TunIo::new(fd, crate::TunFraming::RawIp).unwrap();
+    let tun = TunIo::new_mock(fd, crate::TunFraming::RawIp).unwrap();
     let peer = tokio::net::UnixDatagram::from_std(peer).unwrap();
     let dispatcher = Arc::new(MockDispatcher::default());
     let limits = ResourceLimits {
@@ -2487,9 +2697,20 @@ async fn unconfigured_tls_port_dispatches_without_reading_a_prefix() {
     })
     .await
     .expect("unconfigured TLS port delayed dispatch for a prefix read");
+    // The sniff plan captures original ingress facts even when it reads no prefix.
     assert_eq!(
         dispatcher.tcp_sessions.lock().unwrap()[0],
         StreamSession {
+            metadata: crate::session::InboundMetadata {
+                original: Some(Arc::new(crate::session::InboundSnapshot {
+                    source,
+                    destination: Destination::Ip(destination),
+                    socket_destination: Some(destination),
+                    inbound: InboundKind::Tun,
+                    user: None,
+                })),
+                ..crate::session::InboundMetadata::new(destination.port())
+            },
             inbound: InboundKind::Tun,
             source,
             destination: Destination::Ip(destination),
@@ -2511,7 +2732,7 @@ async fn enabled_dns_fast_path_replies_without_opening_a_tun_udp_association() {
     host.set_nonblocking(true).unwrap();
     peer.set_nonblocking(true).unwrap();
     let fd = TunFd::duplicate_mock(host.as_raw_fd()).unwrap();
-    let tun = TunIo::new(fd, crate::TunFraming::RawIp).unwrap();
+    let tun = TunIo::new_mock(fd, crate::TunFraming::RawIp).unwrap();
     let peer = tokio::net::UnixDatagram::from_std(peer).unwrap();
     let dispatcher = Arc::new(MockDispatcher::default());
     let dns_dispatcher = Arc::new(DnsReplyDispatcher::default());
@@ -2688,10 +2909,9 @@ async fn ordinary_and_dns_responses_have_independent_queue_capacity() {
 }
 
 #[tokio::test]
-async fn full_ordinary_response_queue_drops_without_refreshing_activity() {
+async fn full_ordinary_response_queue_returns_data_without_refreshing_activity() {
     let source: SocketAddr = "192.0.2.10:12000".parse().unwrap();
     let server: SocketAddr = "198.51.100.20:443".parse().unwrap();
-    let stats = RuntimeResourceStats::new("tun_runtime_test");
     let last_activity = AtomicU64::new(5);
     let (responses, mut queued) = mpsc::channel(1);
 
@@ -2701,26 +2921,26 @@ async fn full_ordinary_response_queue_drops_without_refreshing_activity() {
             UdpDatagram::new(server, source, b"queued".as_slice()),
             &last_activity,
             100,
-            &stats,
         ),
         ResponseQueueResult::Queued
     ));
     assert_eq!(last_activity.load(Ordering::Acquire), 100);
-    assert!(matches!(
-        try_queue_tun_udp_response(
-            &responses,
-            UdpDatagram::new(server, source, b"dropped".as_slice()),
-            &last_activity,
-            110,
-            &stats,
-        ),
-        ResponseQueueResult::Dropped
-    ));
+    let ResponseQueueResult::Pending(pending) = try_queue_tun_udp_response(
+        &responses,
+        UdpDatagram::new(server, source, b"held".as_slice()),
+        &last_activity,
+        110,
+    ) else {
+        panic!("full queue must return its uncommitted response")
+    };
     assert_eq!(last_activity.load(Ordering::Acquire), 100);
-    assert_eq!(stats.snapshot().udp_queue_drops, 1);
-    assert_eq!(stats.snapshot().udp_association_queue_drops, 0);
-    assert_eq!(stats.snapshot().udp_response_queue_drops, 1);
     assert_eq!(&queued.recv().await.unwrap().payload[..], b"queued");
+    assert!(matches!(
+        try_queue_tun_udp_response(&responses, pending, &last_activity, 120),
+        ResponseQueueResult::Queued
+    ));
+    assert_eq!(last_activity.load(Ordering::Acquire), 120);
+    assert_eq!(&queued.recv().await.unwrap().payload[..], b"held");
 }
 
 #[tokio::test]
@@ -2731,7 +2951,7 @@ async fn dns_fast_path_allows_sixteen_concurrent_sources_and_keeps_udp_responsiv
     host.set_nonblocking(true).unwrap();
     peer.set_nonblocking(true).unwrap();
     let fd = TunFd::duplicate_mock(host.as_raw_fd()).unwrap();
-    let tun = TunIo::new(fd, crate::TunFraming::RawIp).unwrap();
+    let tun = TunIo::new_mock(fd, crate::TunFraming::RawIp).unwrap();
     let peer = tokio::net::UnixDatagram::from_std(peer).unwrap();
     let dispatcher = Arc::new(MockDispatcher::default());
     let send_started = Arc::new(Notify::new());
@@ -2873,7 +3093,7 @@ async fn cancellation_interrupts_a_blocked_udp_send_and_completes_the_stop_barri
     host.set_nonblocking(true).unwrap();
     peer.set_nonblocking(true).unwrap();
     let fd = TunFd::duplicate_mock(host.as_raw_fd()).unwrap();
-    let tun = TunIo::new(fd, crate::TunFraming::RawIp).unwrap();
+    let tun = TunIo::new_mock(fd, crate::TunFraming::RawIp).unwrap();
     let peer = tokio::net::UnixDatagram::from_std(peer).unwrap();
     let send_started = Arc::new(Notify::new());
     let dispatcher = Arc::new(BlockingDispatcher {
@@ -2921,7 +3141,7 @@ async fn fresh_udp_source_beyond_the_old_sixty_four_limit_is_accepted() {
     host.set_nonblocking(true).unwrap();
     peer.set_nonblocking(true).unwrap();
     let fd = TunFd::duplicate_mock(host.as_raw_fd()).unwrap();
-    let tun = TunIo::new(fd, crate::TunFraming::RawIp).unwrap();
+    let tun = TunIo::new_mock(fd, crate::TunFraming::RawIp).unwrap();
     let peer = tokio::net::UnixDatagram::from_std(peer).unwrap();
     let send_started = Arc::new(Notify::new());
     let send_count = Arc::new(AtomicUsize::new(0));
@@ -3044,7 +3264,7 @@ async fn full_udp_association_queue_does_not_block_other_sources() {
     host.set_nonblocking(true).unwrap();
     peer.set_nonblocking(true).unwrap();
     let fd = TunFd::duplicate_mock(host.as_raw_fd()).unwrap();
-    let tun = TunIo::new(fd, crate::TunFraming::RawIp).unwrap();
+    let tun = TunIo::new_mock(fd, crate::TunFraming::RawIp).unwrap();
     let peer = tokio::net::UnixDatagram::from_std(peer).unwrap();
     let blocked_source: SocketAddr = "192.0.2.10:12000".parse().unwrap();
     let responsive_source: SocketAddr = "192.0.2.11:12001".parse().unwrap();
@@ -3112,7 +3332,7 @@ async fn blocked_udp_response_does_not_block_ingress_or_stop() {
     let (host, peer) = UnixDatagram::pair().unwrap();
     host.set_nonblocking(true).unwrap();
     peer.set_nonblocking(true).unwrap();
-    let tun = TunIo::new(
+    let tun = TunIo::new_mock(
         TunFd::duplicate_mock(host.as_raw_fd()).unwrap(),
         crate::TunFraming::RawIp,
     )
@@ -3205,13 +3425,62 @@ fn fill_tun_egress(host: &UnixDatagram, packet: &[u8]) -> usize {
     }
 }
 
+#[tokio::test]
+async fn transient_tcp_ingress_pressure_yields_once_and_retains_the_packet() {
+    let limits = ResourceLimits {
+        packet_queue_capacity: 1,
+        ..ResourceLimits::default()
+    };
+    let mut parts = NetStack::start_tcp(tun_netstack_config(limits, false)).unwrap();
+    let destination = "198.51.100.20:443".parse().unwrap();
+    let first = "192.0.2.20:13000".parse().unwrap();
+    let second = "192.0.2.21:13001".parse().unwrap();
+    parts
+        .packet_sink
+        .try_send(build_tcp_syn(first, destination))
+        .unwrap();
+    let cancellation = CancellationToken::new();
+    let mut offer = Box::pin(offer_netstack_packet(
+        &parts.packet_sink,
+        Packet::new(build_tcp_syn(second, destination)),
+        &cancellation,
+    ));
+    // No await has allowed the current-thread driver to drain the only slot.
+    let first_poll = futures_util::poll!(offer.as_mut());
+    let first_poll_pending = first_poll.is_pending();
+    let first_reply = timeout(Duration::from_secs(1), parts.packet_stream.recv()).await;
+    let sent = match first_poll {
+        Poll::Ready(result) => result,
+        Poll::Pending => offer.await,
+    };
+    let second_reply = if sent.is_ok() {
+        timeout(Duration::from_secs(1), parts.packet_stream.recv())
+            .await
+            .ok()
+            .flatten()
+    } else {
+        None
+    };
+    parts.control.stop().await;
+    assert!(
+        first_poll_pending,
+        "transient Full dropped the packet before yielding"
+    );
+    let first_reply = first_reply.unwrap().unwrap();
+    assert_eq!(first_reply.data()[22..24], first.port().to_be_bytes());
+    sent.unwrap();
+    let second_reply = second_reply.expect("retained SYN never reached the stack");
+    assert_eq!(second_reply.data()[22..24], second.port().to_be_bytes());
+    assert_eq!(second_reply.data()[33] & 0x12, 0x12);
+}
+
 #[tokio::test]
 async fn full_tcp_ingress_drops_only_that_packet_and_keeps_udp_and_dns_responsive() {
     let (host, peer) = UnixDatagram::pair().unwrap();
     host.set_nonblocking(true).unwrap();
     peer.set_nonblocking(true).unwrap();
     let tun = Arc::new(
-        TunIo::new(
+        TunIo::new_mock(
             TunFd::duplicate_mock(host.as_raw_fd()).unwrap(),
             crate::TunFraming::RawIp,
         )
@@ -3251,6 +3520,7 @@ async fn full_tcp_ingress_drops_only_that_packet_and_keeps_udp_and_dns_responsiv
     let cancellation = CancellationToken::new();
     let (udp, mut ordinary_rx, mut dns_rx) = UdpIngress::new(
         UdpIngressContext {
+            resources: None,
             config: test_tun_config(),
             dispatcher: dispatcher.clone(),
             dns: Some(test_runtime_dns(dns_dispatcher.clone())),
@@ -3270,6 +3540,11 @@ async fn full_tcp_ingress_drops_only_that_packet_and_keeps_udp_and_dns_responsiv
     ));
     let pending =
         std::future::poll_fn(|cx| Poll::Ready(reader.as_mut().poll(cx).is_pending())).await;
+    // Keep the driver unscheduled through the one allowed yield. Persistent
+    // Full must still leave ordinary UDP and DNS free to make progress.
+    let still_pending =
+        std::future::poll_fn(|cx| Poll::Ready(reader.as_mut().poll(cx).is_pending())).await;
+    assert!(still_pending);
     let dropped_packets = resources.snapshot().packet_queue_drops;
     let consumed_bytes = traffic.snapshot().up_total;
     let task = tokio::spawn(reader);
@@ -3340,7 +3615,7 @@ async fn tun_writer_drains_remaining_lanes_and_drops_only_invalid_datagrams() {
         host.set_nonblocking(true).unwrap();
         peer.set_nonblocking(true).unwrap();
         let tun = Arc::new(
-            TunIo::new(
+            TunIo::new_mock(
                 TunFd::duplicate_mock(host.as_raw_fd()).unwrap(),
                 crate::TunFraming::RawIp,
             )
@@ -3407,7 +3682,7 @@ async fn tun_writer_services_ready_raw_ordinary_and_dns_lanes_fairly_across_batc
     host.set_nonblocking(true).unwrap();
     peer.set_nonblocking(true).unwrap();
     let tun = Arc::new(
-        TunIo::new(
+        TunIo::new_mock(
             TunFd::duplicate_mock(host.as_raw_fd()).unwrap(),
             crate::TunFraming::RawIp,
         )
@@ -3516,7 +3791,7 @@ async fn tun_writer_retains_dns_permit_until_platform_completion_or_cancelled_se
         host.set_nonblocking(true).unwrap();
         peer.set_nonblocking(true).unwrap();
         let tun = Arc::new(
-            TunIo::new(
+            TunIo::new_mock(
                 TunFd::duplicate_mock(host.as_raw_fd()).unwrap(),
                 crate::TunFraming::RawIp,
             )
@@ -3628,6 +3903,7 @@ async fn udp_ingress_stop_releases_associations_without_cancelling_caller() {
     let probe = observation::ResourceProbe::default();
     let (mut udp, ordinary, dns) = UdpIngress::new(
         UdpIngressContext {
+            resources: None,
             config: test_tun_config(),
             dispatcher,
             dns: None,
@@ -3830,7 +4106,7 @@ async fn configured_jumbo_mtu_reaches_platform_io_and_udp_response_budget() {
         tun_max_datagram_size: 9000,
         ..ResourceLimits::default()
     };
-    let tun = TunIo::new_with_mtu(
+    let tun = TunIo::new_mock_with_mtu(
         TunFd::duplicate_mock(host.as_raw_fd()).unwrap(),
         crate::TunFraming::RawIp,
         config.mtu,
@@ -3901,6 +4177,7 @@ async fn configured_udp_idle_timeout_controls_real_association_cleanup() {
         let cancellation = CancellationToken::new();
         let (mut ingress, _ordinary, _dns) = UdpIngress::new(
             UdpIngressContext {
+                resources: None,
                 dispatcher: Arc::new(MockDispatcher::default()),
                 dns: None,
                 sniffer: None,
@@ -3936,6 +4213,7 @@ async fn configured_udp_dns_targets_match_exact_endpoints_and_empty_disables_hij
     let target = "192.0.2.53:5353".parse().unwrap();
     let (mut ingress, _ordinary, _dns) = UdpIngress::new(
         UdpIngressContext {
+            resources: None,
             dispatcher,
             dns: Some(dns),
             sniffer: None,
diff --git a/src/udp_sniffing.rs b/src/udp_sniffing.rs
new file mode 100644
index 0000000..e6327e2
--- /dev/null
+++ b/src/udp_sniffing.rs
@@ -0,0 +1,668 @@
+//! Shared bounded QUIC v1/v2 first-flight sniffing for UDP ingress adapters.
+use crate::{
+    quic_sniffer::{
+        QuicConnectionKey, QuicSniffOutcome, QuicSniffer, quic_connection_key,
+        quic_has_unsupported_version,
+    },
+    session::{Datagram, Destination},
+};
+use std::{
+    collections::{HashMap, VecDeque},
+    hash::Hash,
+    sync::Arc,
+    time::Duration,
+};
+use tokio::time::Instant as TokioInstant;
+
+pub(crate) const QUIC_SNIFF_FLOW_MAX: usize = 4;
+pub(crate) const QUIC_SNIFF_PENDING_DATAGRAM_MAX: usize = 8;
+pub(crate) const QUIC_SNIFF_PENDING_BYTES_MAX: usize = 32 * 1024;
+pub(crate) const QUIC_SNIFF_READY_DATAGRAM_MAX: usize = QUIC_SNIFF_PENDING_DATAGRAM_MAX + 1;
+pub(crate) const QUIC_SNIFF_TIMEOUT: Duration = Duration::from_millis(500);
+
+pub(crate) trait SniffPacket {
+    type Key: Clone + Eq + Hash;
+    fn destination_key(&self) -> Self::Key;
+    fn payload(&self) -> &[u8];
+}
+impl SniffPacket for Datagram {
+    type Key = Destination;
+    fn destination_key(&self) -> Destination {
+        self.remote.clone()
+    }
+    fn payload(&self) -> &[u8] {
+        &self.payload
+    }
+}
+#[cfg(feature = "tun")]
+impl SniffPacket for vole_netstack::UdpDatagram {
+    type Key = std::net::SocketAddr;
+    fn destination_key(&self) -> std::net::SocketAddr {
+        self.destination
+    }
+    fn payload(&self) -> &[u8] {
+        &self.payload
+    }
+}
+
+pub(crate) trait QuicSniffEngine {
+    fn ingest(&mut self, packet: &[u8]) -> QuicSniffOutcome;
+
+    fn authenticated_initial_in_last_ingest(&self) -> bool;
+}
+
+impl QuicSniffEngine for QuicSniffer {
+    fn ingest(&mut self, packet: &[u8]) -> QuicSniffOutcome {
+        QuicSniffer::ingest(self, packet)
+    }
+
+    fn authenticated_initial_in_last_ingest(&self) -> bool {
+        QuicSniffer::authenticated_initial_in_last_ingest(self)
+    }
+}
+
+pub(crate) struct PreparedDatagram<P> {
+    pub(crate) datagram: P,
+    pub(crate) sniffed_domain: Option<Arc<str>>,
+    /// Carried once, on the first released datagram of an authenticated Initial flight.
+    pub(crate) flow_id: Option<QuicConnectionKey>,
+}
+
+impl<P> PreparedDatagram<P> {
+    pub(crate) fn without_domain(datagram: P) -> Self {
+        Self {
+            datagram,
+            sniffed_domain: None,
+            flow_id: None,
+        }
+    }
+
+    pub(crate) fn with_domain(datagram: P, domain: Arc<str>) -> Self {
+        Self {
+            datagram,
+            sniffed_domain: Some(domain),
+            flow_id: None,
+        }
+    }
+
+    pub(crate) fn with_flow_id(mut self, flow_id: Option<QuicConnectionKey>) -> Self {
+        self.flow_id = flow_id;
+        self
+    }
+}
+
+pub(crate) struct PendingQuicFlow<S, P> {
+    sniffer: S,
+    connection_key: Option<QuicConnectionKey>,
+    datagrams: VecDeque<PreparedDatagram<P>>,
+    buffered_bytes: usize,
+    deadline: TokioInstant,
+}
+
+pub(crate) struct CompletedQuicFlow {
+    connection_key: Option<QuicConnectionKey>,
+    last_used: TokioInstant,
+}
+
+pub(crate) enum QuicFlowState<S, P> {
+    Pending(PendingQuicFlow<S, P>),
+    Matched {
+        domain: Arc<str>,
+        completed: CompletedQuicFlow,
+    },
+    NoDomain(CompletedQuicFlow),
+}
+
+pub(crate) enum IngressResult<P> {
+    Buffered,
+    Forward(PreparedDatagram<P>),
+    Replay(VecDeque<PreparedDatagram<P>>),
+}
+
+fn starts_new_quic_connection(
+    current: &Option<QuicConnectionKey>,
+    observed: &Option<QuicConnectionKey>,
+) -> bool {
+    observed
+        .as_ref()
+        .is_some_and(|observed| current.as_ref() != Some(observed))
+}
+
+fn prepend_quic_replay<P>(
+    mut replay: VecDeque<PreparedDatagram<P>>,
+    next: IngressResult<P>,
+) -> IngressResult<P> {
+    if replay.is_empty() {
+        return next;
+    }
+    match next {
+        IngressResult::Buffered => IngressResult::Replay(replay),
+        IngressResult::Forward(prepared) => {
+            replay.push_back(prepared);
+            IngressResult::Replay(replay)
+        }
+        IngressResult::Replay(mut next) => {
+            replay.append(&mut next);
+            IngressResult::Replay(replay)
+        }
+    }
+}
+
+pub(crate) struct SniffState<S, F, P: SniffPacket> {
+    pub(crate) flows: HashMap<P::Key, QuicFlowState<S, P>>,
+    pub(crate) pending_datagrams: usize,
+    pub(crate) pending_bytes: usize,
+    new_sniffer: F,
+    idle_timeout: Duration,
+}
+
+impl<S, F, P> SniffState<S, F, P>
+where
+    P: SniffPacket,
+    S: QuicSniffEngine,
+    F: FnMut() -> S,
+{
+    pub(crate) fn with_idle_timeout(new_sniffer: F, idle_timeout: Duration) -> Self {
+        Self {
+            flows: HashMap::new(),
+            pending_datagrams: 0,
+            pending_bytes: 0,
+            new_sniffer,
+            idle_timeout,
+        }
+    }
+
+    pub(crate) fn next_deadline(&self) -> Option<TokioInstant> {
+        self.flows
+            .values()
+            .filter_map(|state| match state {
+                QuicFlowState::Pending(pending) => Some(pending.deadline),
+                QuicFlowState::Matched { .. } | QuicFlowState::NoDomain(_) => None,
+            })
+            .min()
+    }
+
+    pub(crate) fn ingest_datagram(&mut self, datagram: P, now: TokioInstant) -> IngressResult<P> {
+        let destination = datagram.destination_key();
+        let connection_key = quic_connection_key(datagram.payload());
+        let state = self.flows.remove(&destination).filter(|state| match state {
+            QuicFlowState::Matched { completed, .. } | QuicFlowState::NoDomain(completed) => {
+                now.saturating_duration_since(completed.last_used) < self.idle_timeout
+            }
+            QuicFlowState::Pending(_) => true,
+        });
+        if connection_key.is_none() && quic_has_unsupported_version(datagram.payload()) {
+            return self.fail_open_unsupported_version(datagram, state, now);
+        }
+        let Some(state) = state else {
+            return self.start_flow(datagram, connection_key, now);
+        };
+        match state {
+            QuicFlowState::Matched {
+                domain,
+                mut completed,
+            } => {
+                if starts_new_quic_connection(&completed.connection_key, &connection_key) {
+                    let mut candidate = (self.new_sniffer)();
+                    let outcome = candidate.ingest(datagram.payload());
+                    if candidate.authenticated_initial_in_last_ingest() {
+                        return self.commit_started_flow(
+                            datagram,
+                            connection_key,
+                            now,
+                            candidate,
+                            outcome,
+                        );
+                    }
+                }
+                completed.last_used = now;
+                self.flows.insert(
+                    destination,
+                    QuicFlowState::Matched {
+                        domain: domain.clone(),
+                        completed,
+                    },
+                );
+                IngressResult::Forward(PreparedDatagram::with_domain(datagram, domain))
+            }
+            QuicFlowState::NoDomain(mut completed) => {
+                if starts_new_quic_connection(&completed.connection_key, &connection_key) {
+                    let mut candidate = (self.new_sniffer)();
+                    let outcome = candidate.ingest(datagram.payload());
+                    if candidate.authenticated_initial_in_last_ingest() {
+                        return self.commit_started_flow(
+                            datagram,
+                            connection_key,
+                            now,
+                            candidate,
+                            outcome,
+                        );
+                    }
+                }
+                completed.last_used = now;
+                self.flows
+                    .insert(destination, QuicFlowState::NoDomain(completed));
+                IngressResult::Forward(PreparedDatagram::without_domain(datagram))
+            }
+            QuicFlowState::Pending(mut pending) => {
+                if starts_new_quic_connection(&pending.connection_key, &connection_key) {
+                    let outcome = pending.sniffer.ingest(datagram.payload());
+                    if pending.sniffer.authenticated_initial_in_last_ingest() {
+                        // A non-Initial prefix can have entered the pending
+                        // state before any Initial keys existed. Adopt only
+                        // its first authenticated identity; a later header
+                        // DCID accepted by existing keys is the same flow.
+                        if pending.connection_key.is_none() {
+                            pending.connection_key = connection_key;
+                            if let Some(first) = pending.datagrams.front_mut() {
+                                first.flow_id = pending.connection_key.clone();
+                            }
+                        }
+                        return self.apply_pending_outcome(
+                            destination,
+                            pending,
+                            datagram,
+                            outcome,
+                            now,
+                        );
+                    }
+                    let mut candidate = (self.new_sniffer)();
+                    let outcome = candidate.ingest(datagram.payload());
+                    if !candidate.authenticated_initial_in_last_ingest() {
+                        self.flows
+                            .insert(destination, QuicFlowState::Pending(pending));
+                        return IngressResult::Forward(PreparedDatagram::without_domain(datagram));
+                    }
+                    self.release_pending(&pending);
+                    let replay = pending.datagrams;
+                    let next =
+                        self.commit_started_flow(datagram, connection_key, now, candidate, outcome);
+                    return prepend_quic_replay(replay, next);
+                }
+                let outcome = pending.sniffer.ingest(datagram.payload());
+                self.apply_pending_outcome(destination, pending, datagram, outcome, now)
+            }
+        }
+    }
+
+    fn fail_open_unsupported_version(
+        &mut self,
+        datagram: P,
+        state: Option<QuicFlowState<S, P>>,
+        now: TokioInstant,
+    ) -> IngressResult<P> {
+        let destination = datagram.destination_key();
+        match state {
+            Some(QuicFlowState::Pending(mut pending)) => {
+                self.release_pending(&pending);
+                pending
+                    .datagrams
+                    .push_back(PreparedDatagram::without_domain(datagram));
+                self.flows.insert(
+                    destination,
+                    QuicFlowState::NoDomain(CompletedQuicFlow {
+                        connection_key: None,
+                        last_used: now,
+                    }),
+                );
+                IngressResult::Replay(pending.datagrams)
+            }
+            Some(QuicFlowState::Matched { .. }) | Some(QuicFlowState::NoDomain(_)) => {
+                self.flows.insert(
+                    destination,
+                    QuicFlowState::NoDomain(CompletedQuicFlow {
+                        connection_key: None,
+                        last_used: now,
+                    }),
+                );
+                IngressResult::Forward(PreparedDatagram::without_domain(datagram))
+            }
+            None => {
+                if self.make_room_for_flow() {
+                    self.flows.insert(
+                        destination,
+                        QuicFlowState::NoDomain(CompletedQuicFlow {
+                            connection_key: None,
+                            last_used: now,
+                        }),
+                    );
+                }
+                IngressResult::Forward(PreparedDatagram::without_domain(datagram))
+            }
+        }
+    }
+
+    fn start_flow(
+        &mut self,
+        datagram: P,
+        connection_key: Option<QuicConnectionKey>,
+        now: TokioInstant,
+    ) -> IngressResult<P> {
+        if !self.make_room_for_flow() {
+            return IngressResult::Forward(PreparedDatagram::without_domain(datagram));
+        }
+        let mut sniffer = (self.new_sniffer)();
+        let outcome = sniffer.ingest(datagram.payload());
+        self.commit_started_flow(datagram, connection_key, now, sniffer, outcome)
+    }
+
+    fn commit_started_flow(
+        &mut self,
+        datagram: P,
+        connection_key: Option<QuicConnectionKey>,
+        now: TokioInstant,
+        sniffer: S,
+        outcome: QuicSniffOutcome,
+    ) -> IngressResult<P> {
+        let destination = datagram.destination_key();
+        // A parseable header alone must not suppress a later authenticated
+        // Initial with the same DCID, or claim a connection identity.
+        let connection_key = sniffer
+            .authenticated_initial_in_last_ingest()
+            .then_some(connection_key)
+            .flatten();
+        let flow_id = connection_key.clone();
+        match outcome {
+            QuicSniffOutcome::NeedMoreData if self.can_buffer(datagram.payload().len()) => {
+                let buffered_bytes = datagram.payload().len();
+                let mut datagrams = VecDeque::new();
+                datagrams
+                    .push_back(PreparedDatagram::without_domain(datagram).with_flow_id(flow_id));
+                self.pending_datagrams += 1;
+                self.pending_bytes += buffered_bytes;
+                self.flows.insert(
+                    destination,
+                    QuicFlowState::Pending(PendingQuicFlow {
+                        sniffer,
+                        connection_key,
+                        datagrams,
+                        buffered_bytes,
+                        deadline: now + QUIC_SNIFF_TIMEOUT,
+                    }),
+                );
+                IngressResult::Buffered
+            }
+            QuicSniffOutcome::Matched(domain) => {
+                let domain: Arc<str> = Arc::from(domain);
+                self.flows.insert(
+                    destination,
+                    QuicFlowState::Matched {
+                        domain: domain.clone(),
+                        completed: CompletedQuicFlow {
+                            connection_key,
+                            last_used: now,
+                        },
+                    },
+                );
+                IngressResult::Forward(
+                    PreparedDatagram::with_domain(datagram, domain).with_flow_id(flow_id),
+                )
+            }
+            QuicSniffOutcome::NeedMoreData
+            | QuicSniffOutcome::EchExtensionPresent
+            | QuicSniffOutcome::NotMatched
+            | QuicSniffOutcome::LimitReached => {
+                self.flows.insert(
+                    destination,
+                    QuicFlowState::NoDomain(CompletedQuicFlow {
+                        connection_key,
+                        last_used: now,
+                    }),
+                );
+                IngressResult::Forward(
+                    PreparedDatagram::without_domain(datagram).with_flow_id(flow_id),
+                )
+            }
+        }
+    }
+
+    fn apply_pending_outcome(
+        &mut self,
+        destination: P::Key,
+        mut pending: PendingQuicFlow<S, P>,
+        datagram: P,
+        outcome: QuicSniffOutcome,
+        now: TokioInstant,
+    ) -> IngressResult<P> {
+        match outcome {
+            QuicSniffOutcome::NeedMoreData if self.can_buffer(datagram.payload().len()) => {
+                let payload_len = datagram.payload().len();
+                pending.buffered_bytes += payload_len;
+                pending
+                    .datagrams
+                    .push_back(PreparedDatagram::without_domain(datagram));
+                self.pending_datagrams += 1;
+                self.pending_bytes += payload_len;
+                self.flows
+                    .insert(destination, QuicFlowState::Pending(pending));
+                IngressResult::Buffered
+            }
+            QuicSniffOutcome::Matched(domain) => {
+                self.finish_pending(destination, pending, datagram, Some(Arc::from(domain)), now)
+            }
+            QuicSniffOutcome::NeedMoreData
+            | QuicSniffOutcome::EchExtensionPresent
+            | QuicSniffOutcome::NotMatched
+            | QuicSniffOutcome::LimitReached => {
+                self.finish_pending(destination, pending, datagram, None, now)
+            }
+        }
+    }
+
+    fn make_room_for_flow(&mut self) -> bool {
+        if self.flows.len() < QUIC_SNIFF_FLOW_MAX {
+            return true;
+        }
+        let oldest_completed = self
+            .flows
+            .iter()
+            .filter_map(|(destination, state)| match state {
+                QuicFlowState::Matched { completed, .. } | QuicFlowState::NoDomain(completed) => {
+                    Some((destination.clone(), completed.last_used))
+                }
+                QuicFlowState::Pending(_) => None,
+            })
+            .min_by_key(|(_, last_used)| *last_used)
+            .map(|(destination, _)| destination);
+        if let Some(destination) = oldest_completed {
+            self.flows.remove(&destination);
+            true
+        } else {
+            false
+        }
+    }
+
+    fn can_buffer(&self, bytes: usize) -> bool {
+        self.pending_datagrams < QUIC_SNIFF_PENDING_DATAGRAM_MAX
+            && self
+                .pending_bytes
+                .checked_add(bytes)
+                .is_some_and(|total| total <= QUIC_SNIFF_PENDING_BYTES_MAX)
+    }
+
+    fn finish_pending(
+        &mut self,
+        destination: P::Key,
+        mut pending: PendingQuicFlow<S, P>,
+        datagram: P,
+        domain: Option<Arc<str>>,
+        now: TokioInstant,
+    ) -> IngressResult<P> {
+        self.release_pending(&pending);
+        pending
+            .datagrams
+            .push_back(PreparedDatagram::without_domain(datagram));
+        if let Some(domain) = &domain {
+            for buffered in &mut pending.datagrams {
+                buffered.sniffed_domain = Some(domain.clone());
+            }
+        }
+        let completed = CompletedQuicFlow {
+            connection_key: pending.connection_key,
+            last_used: now,
+        };
+        self.flows.insert(
+            destination,
+            match domain {
+                Some(domain) => QuicFlowState::Matched { domain, completed },
+                None => QuicFlowState::NoDomain(completed),
+            },
+        );
+        IngressResult::Replay(pending.datagrams)
+    }
+
+    pub(crate) fn expire(&mut self, now: TokioInstant) -> VecDeque<PreparedDatagram<P>> {
+        let destinations = self
+            .flows
+            .iter()
+            .filter_map(|(destination, state)| match state {
+                QuicFlowState::Pending(pending) if pending.deadline <= now => {
+                    Some(destination.clone())
+                }
+                QuicFlowState::Pending(_)
+                | QuicFlowState::Matched { .. }
+                | QuicFlowState::NoDomain(_) => None,
+            })
+            .collect::<Vec<_>>();
+        let mut replay = VecDeque::new();
+        for destination in destinations {
+            let Some(QuicFlowState::Pending(mut pending)) = self.flows.remove(&destination) else {
+                continue;
+            };
+            self.release_pending(&pending);
+            replay.append(&mut pending.datagrams);
+            self.flows.insert(
+                destination,
+                QuicFlowState::NoDomain(CompletedQuicFlow {
+                    connection_key: pending.connection_key,
+                    last_used: now,
+                }),
+            );
+        }
+        replay
+    }
+
+    fn release_pending(&mut self, pending: &PendingQuicFlow<S, P>) {
+        self.pending_datagrams = self
+            .pending_datagrams
+            .saturating_sub(pending.datagrams.len());
+        self.pending_bytes = self.pending_bytes.saturating_sub(pending.buffered_bytes);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use bytes::Bytes;
+
+    struct Script(VecDeque<QuicSniffOutcome>);
+    impl QuicSniffEngine for Script {
+        fn ingest(&mut self, _: &[u8]) -> QuicSniffOutcome {
+            self.0.pop_front().expect("scripted result")
+        }
+        fn authenticated_initial_in_last_ingest(&self) -> bool {
+            false
+        }
+    }
+    fn packet(host: &str, bytes: &'static [u8]) -> Datagram {
+        Datagram {
+            remote: Destination::domain(host, 443).unwrap(),
+            payload: Bytes::from_static(bytes),
+            sniffed_domain: None,
+        }
+    }
+
+    #[test]
+    fn socks_domain_keys_share_quic_reassembly_and_exact_fail_open_replay() {
+        let mut state = SniffState::with_idle_timeout(
+            || {
+                Script(VecDeque::from([
+                    QuicSniffOutcome::NeedMoreData,
+                    QuicSniffOutcome::Matched("sniff.example".into()),
+                ]))
+            },
+            Duration::from_secs(30),
+        );
+        let now = TokioInstant::now();
+        assert!(matches!(
+            state.ingest_datagram(packet("first.example", b"first fragment"), now),
+            IngressResult::Buffered
+        ));
+        assert!(matches!(
+            state.ingest_datagram(packet("second.example", b"isolated"), now),
+            IngressResult::Buffered
+        ));
+        let IngressResult::Replay(replay) =
+            state.ingest_datagram(packet("first.example", b"second fragment"), now)
+        else {
+            panic!("completed domain key releases its own flight")
+        };
+        assert_eq!(replay.len(), 2);
+        assert_eq!(replay[0].datagram.payload, b"first fragment".as_slice());
+        assert_eq!(replay[1].datagram.payload, b"second fragment".as_slice());
+        assert!(
+            replay
+                .iter()
+                .all(|item| item.sniffed_domain.as_deref() == Some("sniff.example"))
+        );
+        assert_eq!(state.pending_datagrams, 1);
+        let replay = state.expire(now + QUIC_SNIFF_TIMEOUT);
+        assert_eq!(replay.len(), 1);
+        assert_eq!(replay[0].datagram.payload, b"isolated".as_slice());
+        assert!(replay[0].sniffed_domain.is_none());
+        assert_eq!(state.pending_bytes, 0);
+    }
+
+    #[test]
+    fn socks_ech_and_shared_packet_budget_preserve_original_datagrams() {
+        let mut state = SniffState::with_idle_timeout(
+            || {
+                Script(VecDeque::from([
+                    QuicSniffOutcome::NeedMoreData,
+                    QuicSniffOutcome::EchExtensionPresent,
+                ]))
+            },
+            Duration::from_secs(30),
+        );
+        let now = TokioInstant::now();
+        assert!(matches!(
+            state.ingest_datagram(packet("ech.example", b"prefix"), now),
+            IngressResult::Buffered
+        ));
+        let IngressResult::Replay(replay) =
+            state.ingest_datagram(packet("ech.example", b"outer name"), now)
+        else {
+            panic!("ECH must release bytes without an outer hint")
+        };
+        assert!(replay.iter().all(|item| item.sniffed_domain.is_none()));
+        assert_eq!(replay[0].datagram.payload, b"prefix".as_slice());
+        assert_eq!(replay[1].datagram.payload, b"outer name".as_slice());
+        let mut state = SniffState::with_idle_timeout(
+            || {
+                Script(VecDeque::from(vec![
+                    QuicSniffOutcome::NeedMoreData;
+                    QUIC_SNIFF_PENDING_DATAGRAM_MAX + 1
+                ]))
+            },
+            Duration::from_secs(30),
+        );
+        for _ in 0..QUIC_SNIFF_PENDING_DATAGRAM_MAX {
+            assert!(matches!(
+                state.ingest_datagram(packet("full.example", b"payload"), now),
+                IngressResult::Buffered
+            ));
+        }
+        let IngressResult::Replay(replay) =
+            state.ingest_datagram(packet("full.example", b"overflow"), now)
+        else {
+            panic!("full shared budget must release the pending flight")
+        };
+        assert_eq!(replay.len(), QUIC_SNIFF_READY_DATAGRAM_MAX);
+        assert_eq!(
+            replay.back().unwrap().datagram.payload,
+            b"overflow".as_slice()
+        );
+        assert_eq!(state.pending_datagrams, 0);
+        assert_eq!(state.pending_bytes, 0);
+    }
+}
diff --git a/src/windows/host.rs b/src/windows/host.rs
index c723223..805afbe 100644
--- a/src/windows/host.rs
+++ b/src/windows/host.rs
@@ -4,7 +4,7 @@ use std::{
     panic::{AssertUnwindSafe, catch_unwind},
     path::PathBuf,
     ptr,
-    sync::{Mutex, TryLockError},
+    sync::{Mutex, OnceLock, TryLockError},
 };
 
 use serde::{Deserialize, Deserializer};
@@ -31,9 +31,15 @@ use super::{
     managed_processes::SessionBackend,
     policy::WindowsVpnPolicy,
     profile::{WindowsNetworkSettings, WindowsProfileConfiguration},
-    snapshot::SessionReference,
+    snapshot::{HttpSessionInput, SessionReference},
+};
+use crate::{
+    config::Config,
+    dialer::Dialer,
+    http_processing::providers::Store,
+    invoke::http::{HttpContextInput, download_context, prepare_candidate, source_context},
+    platform::validate_packet_channel_config,
 };
-use crate::{config::Config, platform::validate_packet_channel_config};
 
 const BRIDGE_VERSION: u32 = 3;
 const MAX_REQUEST_BYTES: usize = 1024 * 1024;
@@ -42,6 +48,7 @@ const DEFAULT_PROFILE_NAME: &str = "Vole";
 const MAX_PROFILE_NAME_BYTES: usize = 256;
 const STARTUP_TASK_ID: &str = "VoleStartup";
 static COMMAND: Mutex<()> = Mutex::new(());
+static HTTP_STORE: OnceLock<tokio::sync::Mutex<Store>> = OnceLock::new();
 // windows-rs caches agile WinRT factories for process lifetime. Keep one opaque
 // MTA usage cookie for the same lifetime, including gaps between caller threads.
 // Never decrement it per request or during DLL/process teardown: cached factories
@@ -99,6 +106,10 @@ struct StartPayload {
     #[serde(default)]
     profile_name: ProfileName,
     config_yaml: String,
+    #[serde(default)]
+    http_config_yaml: Option<String>,
+    #[serde(default)]
+    http_context: Option<HttpContextInput>,
     network_settings: WindowsNetworkSettings,
     policy: WindowsVpnPolicy,
     #[serde(default, deserialize_with = "deserialize_session_backend")]
@@ -227,11 +238,13 @@ fn start_vpn(payload: StartPayload) -> Result<Value, String> {
     let StartPayload {
         profile_name,
         config_yaml,
+        http_config_yaml,
+        http_context,
         network_settings,
         policy,
         session_backend,
     } = payload;
-    let config = Config::parse_yaml(config_yaml.as_bytes())
+    let mut config = Config::parse_yaml(config_yaml.as_bytes())
         .map_err(|_| "invalid Vole configuration".to_owned())?;
     if !config.tun.enable {
         return Err("Windows VPN configuration must enable TUN".to_owned());
@@ -246,11 +259,79 @@ fn start_vpn(payload: StartPayload) -> Result<Value, String> {
         .map_err(str::to_owned)?;
 
     let environment = package_environment()?;
+    let agent = VpnManagementAgent::new().map_err(display_error)?;
+    let existing = find_profile(&agent, &environment.family_name, &profile_name.0)?;
+    let connected = if let Some(existing) = &existing {
+        match existing.status {
+            VpnManagementConnectionStatus::Connected => true,
+            VpnManagementConnectionStatus::Disconnected => false,
+            VpnManagementConnectionStatus::Connecting
+            | VpnManagementConnectionStatus::Disconnecting => {
+                return Err("Windows VPN profile is busy".to_owned());
+            }
+            _ => return Err("unknown Windows VPN profile status".to_owned()),
+        }
+    } else {
+        false
+    };
+    let mut http_candidate = None;
+    let mut http_base_dir = None;
+    let mut private_ca = None;
+    if let Some(input) = http_config_yaml
+        .as_deref()
+        .filter(|input| !input.is_empty())
+    {
+        let (source, ca) =
+            source_context(http_context, environment.local_folder.join("vole"), None)
+                .map_err(|_| "invalid HTTP source context".to_owned())?;
+        http_base_dir = source.base_dir.clone();
+        // The frontend does not own the active Provider's PhysicalBinding.
+        // When connected it may reuse validated content, never create an
+        // unbound fallback socket through the VPN being configured.
+        let network = (!connected).then(|| download_context(&config, Dialer::default()));
+        let runtime = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .map_err(|_| "HTTP resource runtime creation failed".to_owned())?;
+        let result = runtime.block_on(prepare_candidate(
+            input,
+            source,
+            network.as_ref(),
+            HTTP_STORE.get_or_init(|| tokio::sync::Mutex::new(Store::default())),
+            false,
+        ));
+        runtime.shutdown_timeout(std::time::Duration::from_millis(100));
+        let candidate = result.map_err(|_| "HTTP resource preparation failed".to_owned())?;
+        private_ca = candidate.document.mitm.enabled.then_some(ca).flatten();
+        let policy = candidate
+            .bind_ca(private_ca.as_ref())
+            .map_err(|_| "invalid or missing private HTTP CA".to_owned())?;
+        config
+            .set_http_policy(Some(policy))
+            .map_err(|_| "invalid HTTP processing configuration".to_owned())?;
+        http_candidate = Some(candidate);
+    } else if http_context.is_some() {
+        return Err("httpContext requires httpConfigYaml".to_owned());
+    }
+    let http = http_candidate
+        .as_ref()
+        .map(|candidate| -> Result<HttpSessionInput<'_>, String> {
+            Ok(HttpSessionInput {
+                rules: candidate
+                    .export_snapshot()
+                    .map_err(|_| "HTTP snapshot preparation failed".to_owned())?,
+                base_dir: http_base_dir,
+                ca: private_ca.as_ref(),
+                package_family: &environment.family_name,
+            })
+        })
+        .transpose()?;
     let snapshot = SessionReference::publish(
         &environment.local_folder,
         &environment.installed_folder,
         config_yaml,
         session_backend,
+        http,
     )
     .map_err(display_error)?;
     let profile_configuration =
@@ -258,8 +339,6 @@ fn start_vpn(payload: StartPayload) -> Result<Value, String> {
     let profile_configuration_json = profile_configuration.to_json().map_err(display_error)?;
     let always_on = profile_configuration.policy().always_on();
     let token = snapshot.token();
-    let agent = VpnManagementAgent::new().map_err(display_error)?;
-    let existing = find_profile(&agent, &environment.family_name, &profile_name.0)?;
 
     if let Some(existing) = &existing {
         match existing.status {
diff --git a/src/windows/http_ca.rs b/src/windows/http_ca.rs
new file mode 100644
index 0000000..726a8de
--- /dev/null
+++ b/src/windows/http_ca.rs
@@ -0,0 +1,184 @@
+//! Current-user DPAPI handoff for one immutable Windows session snapshot.
+//! The ordinary snapshot stores only a public CA identity; this module never
+//! serializes a public input DTO or sends private material through packet IPC.
+use crate::http_processing::private_context::{CaMaterial, MAX_CA_INPUT};
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+use windows::{
+    Win32::{
+        Foundation::{E_FAIL, HLOCAL, LocalFree},
+        Security::Cryptography::{
+            CRYPT_INTEGER_BLOB, CRYPTPROTECT_UI_FORBIDDEN, CryptProtectData, CryptUnprotectData,
+        },
+    },
+    core::{Error, PCWSTR, Result},
+};
+use zeroize::{Zeroize, Zeroizing};
+
+pub(crate) const MAX_PROTECTED_CA_BYTES: usize = MAX_CA_INPUT + 16 * 1024;
+
+fn invalid() -> Error {
+    Error::new(E_FAIL, "invalid protected HTTP CA")
+}
+
+fn entropy(package_family: &str, snapshot_token: &str) -> Result<[u8; 32]> {
+    super::snapshot::SessionReference::parse(snapshot_token)?;
+    if package_family.is_empty()
+        || package_family.len() > 512
+        || package_family.chars().any(char::is_control)
+    {
+        return Err(invalid());
+    }
+    let mut digest = Sha256::new();
+    digest.update(b"Vole Windows HTTP CA\0");
+    digest.update(package_family.as_bytes());
+    digest.update([0]);
+    digest.update(snapshot_token.as_bytes());
+    Ok(digest.finalize().into())
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct PrivateEnvelope<'a> {
+    snapshot_token: &'a str,
+    ca: PrivateCa<'a>,
+}
+
+// A private, borrowed serialization boundary. CaMaterial deliberately has no
+// Serialize implementation and cannot accidentally enter an ordinary snapshot.
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct PrivateCa<'a> {
+    certificate: &'a str,
+    private_key: &'a str,
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+struct UnprotectedEnvelope {
+    snapshot_token: String,
+    ca: CaMaterial,
+}
+
+struct LocalBlob(CRYPT_INTEGER_BLOB);
+impl LocalBlob {
+    fn bytes(&self, maximum: usize) -> Result<&[u8]> {
+        let length = self.0.cbData as usize;
+        if self.0.pbData.is_null() || length == 0 || length > maximum {
+            return Err(invalid());
+        }
+        // DPAPI owns this successful allocation until LocalFree below.
+        Ok(unsafe { std::slice::from_raw_parts(self.0.pbData, length) })
+    }
+}
+impl Drop for LocalBlob {
+    fn drop(&mut self) {
+        if !self.0.pbData.is_null() {
+            // Zero plaintext DPAPI output before returning the native memory.
+            // Applying the same cleanup to ciphertext keeps a single owner.
+            unsafe {
+                std::slice::from_raw_parts_mut(self.0.pbData, self.0.cbData as usize).zeroize();
+                let _ = LocalFree(Some(HLOCAL(self.0.pbData.cast())));
+            }
+        }
+    }
+}
+
+fn blob(bytes: &[u8]) -> CRYPT_INTEGER_BLOB {
+    CRYPT_INTEGER_BLOB {
+        cbData: bytes.len() as u32,
+        pbData: bytes.as_ptr().cast_mut(),
+    }
+}
+
+pub(crate) fn seal(
+    material: &CaMaterial,
+    package_family: &str,
+    snapshot_token: &str,
+) -> Result<Vec<u8>> {
+    material.validate_size().map_err(|_| invalid())?;
+    let entropy_bytes = entropy(package_family, snapshot_token)?;
+    let envelope = PrivateEnvelope {
+        snapshot_token,
+        ca: PrivateCa {
+            certificate: &material.certificate,
+            private_key: &material.private_key,
+        },
+    };
+    let plaintext = Zeroizing::new(serde_json::to_vec(&envelope).map_err(|_| invalid())?);
+    if plaintext.len() > MAX_CA_INPUT {
+        return Err(invalid());
+    }
+    let mut output = CRYPT_INTEGER_BLOB::default();
+    let result = unsafe {
+        CryptProtectData(
+            &blob(&plaintext),
+            PCWSTR::null(),
+            Some(&blob(&entropy_bytes)),
+            None,
+            None,
+            CRYPTPROTECT_UI_FORBIDDEN,
+            &mut output,
+        )
+    };
+    let output = LocalBlob(output);
+    result?;
+    Ok(output.bytes(MAX_PROTECTED_CA_BYTES)?.to_vec())
+}
+
+pub(crate) fn open(
+    protected: &[u8],
+    package_family: &str,
+    snapshot_token: &str,
+    expected_identity: [u8; 32],
+) -> Result<CaMaterial> {
+    if protected.is_empty() || protected.len() > MAX_PROTECTED_CA_BYTES {
+        return Err(invalid());
+    }
+    let entropy_bytes = entropy(package_family, snapshot_token)?;
+    let mut output = CRYPT_INTEGER_BLOB::default();
+    let result = unsafe {
+        CryptUnprotectData(
+            &blob(protected),
+            None,
+            Some(&blob(&entropy_bytes)),
+            None,
+            None,
+            CRYPTPROTECT_UI_FORBIDDEN,
+            &mut output,
+        )
+    };
+    let output = LocalBlob(output);
+    result?;
+    let envelope: UnprotectedEnvelope =
+        serde_json::from_slice(output.bytes(MAX_CA_INPUT)?).map_err(|_| invalid())?;
+    if envelope.snapshot_token != snapshot_token
+        || envelope.ca.identity().map_err(|_| invalid())? != expected_identity
+    {
+        return Err(invalid());
+    }
+    Ok(envelope.ca)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn private_handoff_is_bound_to_session_package_and_ca() {
+        let ca = crate::http_processing::private_context::test_material();
+        let token = format!("vole-session-v2:{}", "0".repeat(64));
+        let identity = ca.identity().unwrap();
+        let protected = seal(&ca, "ExamplePackage", &token).unwrap();
+        let restored = open(&protected, "ExamplePackage", &token, identity).unwrap();
+        assert_eq!(restored.certificate, ca.certificate);
+        assert_eq!(restored.private_key.as_str(), ca.private_key.as_str());
+        assert!(open(&protected, "OtherPackage", &token, identity).is_err());
+        let other = format!("vole-session-v2:{}", "1".repeat(64));
+        assert!(open(&protected, "ExamplePackage", &other, identity).is_err());
+        assert!(open(&protected, "ExamplePackage", &token, [0; 32]).is_err());
+        let mut corrupt = protected;
+        corrupt[0] ^= 0x80;
+        assert!(open(&corrupt, "ExamplePackage", &token, identity).is_err());
+    }
+}
diff --git a/src/windows/mod.rs b/src/windows/mod.rs
index fcea1cf..6d44905 100644
--- a/src/windows/mod.rs
+++ b/src/windows/mod.rs
@@ -1,4 +1,5 @@
 pub(crate) mod host;
+pub(crate) mod http_ca;
 pub(crate) mod log;
 pub(crate) mod managed_processes;
 pub(crate) mod packet_channel;
diff --git a/src/windows/session.rs b/src/windows/session.rs
index da24f6d..38ba0e0 100644
--- a/src/windows/session.rs
+++ b/src/windows/session.rs
@@ -37,6 +37,11 @@ use crate::{
     config::Config,
     dialer::{Dialer, SystemResolver},
     geodata::GeoDataManager,
+    http_processing::{
+        Policy,
+        config::PolicyCandidate,
+        providers::{SourceContext, Store},
+    },
     platform::{TunIo, validate_packet_channel_config},
     runtime::{PreparedCore, RunningCore},
 };
@@ -237,15 +242,56 @@ async fn start_session(
     JoinSet<io::Result<()>>,
     Option<ManagedProcessSet>,
 )> {
-    let snapshot = SessionReference::parse(token)
-        .map_err(io::Error::other)?
+    let reference = SessionReference::parse(token).map_err(io::Error::other)?;
+    let snapshot = reference
         .read(local_folder, installed_folder)
         .map_err(io::Error::other)?;
+    let family = Package::Current()
+        .and_then(|package| package.Id())
+        .and_then(|id| id.FamilyName())
+        .map_err(io::Error::other)?
+        .to_string();
+    let ca = reference
+        .read_http_ca(local_folder, &family, &snapshot)
+        .map_err(io::Error::other)?;
+    let candidate = snapshot
+        .http_snapshot()
+        .map(PolicyCandidate::import_snapshot)
+        .transpose()?;
+    let policy = candidate
+        .as_ref()
+        .map(|candidate| candidate.bind_ca(ca.as_ref()))
+        .transpose()?;
+    let http_store = candidate
+        .map(|candidate| {
+            let mut store = Store::default();
+            store.adopt(
+                candidate,
+                &SourceContext {
+                    base_dir: snapshot.http_base_dir(),
+                    data_dir: Some(local_folder.join("vole")),
+                    config_path: None,
+                    ..Default::default()
+                },
+            )?;
+            Ok::<_, io::Error>(Arc::new(tokio::sync::Mutex::new(store)))
+        })
+        .transpose()?;
+    // The runtime retains the parsed Authority, never the transport PEM input.
+    drop(ca);
     let mut managed_processes = snapshot
         .session_backend()
         .map(|backend| ManagedProcessSet::start(installed_folder, backend))
         .transpose()?;
-    let started = start_vole(local_folder, snapshot.config_yaml(), binding, data).await;
+    let started = start_vole(
+        local_folder,
+        snapshot.config_yaml(),
+        policy,
+        http_store,
+        binding,
+        data,
+    )
+    .await;
     let (running, mut data_tasks) = match started {
         Ok(started) => started,
         Err(error) => {
@@ -272,11 +318,20 @@ async fn start_session(
 async fn start_vole(
     local_folder: &Path,
     config_yaml: &str,
+    http_policy: Option<Arc<Policy>>,
+    http_store: Option<Arc<tokio::sync::Mutex<Store>>>,
     binding: PhysicalBinding,
     data: NamedPipeClient,
 ) -> io::Result<(RunningCore, JoinSet<io::Result<()>>)> {
-    let config = Config::parse_yaml(config_yaml.as_bytes())
-        .map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error))?;
+    let mut config = Config::parse_yaml(config_yaml.as_bytes()).map_err(|_| {
+        io::Error::new(io::ErrorKind::InvalidInput, "invalid session configuration")
+    })?;
+    config.set_http_policy(http_policy).map_err(|_| {
+        io::Error::new(
+            io::ErrorKind::InvalidInput,
+            "invalid HTTP processing configuration",
+        )
+    })?;
     let mtu = validate_packet_channel_config(&config.tun)?;
     let geodata = GeoDataManager::open(
         local_folder.join("vole/geodata"),
@@ -324,9 +379,12 @@ async fn start_vole(
         }
     });
 
-    let running = prepared
-        .start_tun(tun, dialer_from_binding(&binding)?)
-        .await?;
+    let dialer =
+        dialer_from_binding(&binding)?.with_physical_adapter(binding.adapter_id.as_str().into());
+    let mut running = prepared.start_tun(tun, dialer).await?;
+    if let Some(store) = http_store {
+        running.maintain_http(store);
+    }
     Ok((running, tasks))
 }
 
diff --git a/src/windows/snapshot.rs b/src/windows/snapshot.rs
index 10adc97..5926b71 100644
--- a/src/windows/snapshot.rs
+++ b/src/windows/snapshot.rs
@@ -1,7 +1,8 @@
 use std::{
     fs::{self, OpenOptions},
-    io::Write as _,
-    os::windows::fs::MetadataExt as _,
+    io::{self, Read as _, Write as _},
+    os::windows::ffi::{OsStrExt as _, OsStringExt as _},
+    os::windows::fs::{MetadataExt as _, OpenOptionsExt as _},
     path::{Path, PathBuf},
     sync::atomic::{AtomicU64, Ordering},
 };
@@ -15,11 +16,26 @@ use windows::{
 
 use super::managed_processes::SessionBackend;
 use crate::config::MAX_CONFIG_BYTES;
+use crate::http_processing::{
+    config::{MAX_SNAPSHOT, PolicyCandidate},
+    private_context::CaMaterial,
+};
 
 pub(crate) const SESSION_DIRECTORY: &str = "vole/windows/sessions";
 const SESSION_TOKEN_PREFIX: &str = "vole-session-v2:";
 const SESSION_REVISION: u32 = 2;
-const MAX_SESSION_SNAPSHOT_BYTES: u64 = 1024 * 1024;
+const MAX_BASE_DIR_CODE_UNITS: usize = 32_768;
+// Backend validation limits paths to 8 KiB and arguments to 128 KiB in total.
+// Their worst-case JSON escaping, process fields and separators fit in 1 MiB.
+const MAX_BACKEND_SNAPSHOT_BYTES: usize = 1024 * 1024;
+// JSON strings expand by at most six bytes per UTF-8 source byte; each u16
+// path element uses at most five digits and a separator. The final 1 KiB
+// covers field names, revision, the public digest and container punctuation.
+// This is only a read ceiling: publication allocates the exact encoded size.
+const MAX_SESSION_SNAPSHOT_BYTES: usize = (MAX_CONFIG_BYTES + MAX_SNAPSHOT) * 6
+    + MAX_BASE_DIR_CODE_UNITS * 6
+    + MAX_BACKEND_SNAPSHOT_BYTES
+    + 1024;
 const FILE_ATTRIBUTE_REPARSE_POINT: u32 = 0x400;
 static STAGING_ID: AtomicU64 = AtomicU64::new(1);
 
@@ -28,11 +44,17 @@ pub(crate) struct SessionReference {
     digest: String,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub(crate) struct SessionSnapshot {
     revision: u32,
     config_yaml: String,
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        deserialize_with = "crate::http_processing::config::nonnull"
+    )]
+    http: Option<HttpSessionSnapshot>,
     #[serde(
         default,
         skip_serializing_if = "Option::is_none",
@@ -41,6 +63,33 @@ pub(crate) struct SessionSnapshot {
     session_backend: Option<SessionBackend>,
 }
 
+/// A transient publication input. The ordinary snapshot receives only the
+/// public certificate identity; the CA is sealed into a separate sidecar.
+pub(crate) struct HttpSessionInput<'a> {
+    pub(crate) rules: String,
+    pub(crate) base_dir: Option<PathBuf>,
+    pub(crate) ca: Option<&'a CaMaterial>,
+    pub(crate) package_family: &'a str,
+}
+
+#[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+struct HttpSessionSnapshot {
+    rules: String,
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        deserialize_with = "crate::http_processing::config::nonnull"
+    )]
+    base_dir: Option<Vec<u16>>,
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        deserialize_with = "crate::http_processing::config::nonnull"
+    )]
+    ca_identity: Option<[u8; 32]>,
+}
+
 fn deserialize_session_backend<'de, D>(
     deserializer: D,
 ) -> std::result::Result<Option<SessionBackend>, D::Error>
@@ -71,8 +120,28 @@ impl SessionReference {
         install_root: &Path,
         config_yaml: String,
         session_backend: Option<SessionBackend>,
+        http: Option<HttpSessionInput<'_>>,
     ) -> Result<Self> {
         validate_config_yaml(&config_yaml)?;
+        let public_http = http
+            .as_ref()
+            .map(|input| -> Result<HttpSessionSnapshot> {
+                let base_dir = input
+                    .base_dir
+                    .as_ref()
+                    .map(|path| path.as_os_str().encode_wide().collect());
+                Ok(HttpSessionSnapshot {
+                    rules: input.rules.clone(),
+                    base_dir,
+                    ca_identity: input
+                        .ca
+                        .map(CaMaterial::identity)
+                        .transpose()
+                        .map_err(|_| invalid_snapshot())?,
+                })
+            })
+            .transpose()?;
+        validate_http_snapshot(public_http.as_ref())?;
         if let Some(backend) = &session_backend {
             backend.validate(install_root).map_err(windows_error)?;
         }
@@ -80,15 +149,28 @@ impl SessionReference {
             revision: SESSION_REVISION,
             config_yaml,
             session_backend,
+            http: public_http,
         };
         let bytes = snapshot.to_canonical_json()?;
         let reference = Self {
             digest: snapshot_digest(&bytes),
         };
         let sessions = session_directory(local_folder, true)?;
+        let private_created = if let Some(input) = &http
+            && let Some(ca) = input.ca
+        {
+            reference.publish_http_ca(local_folder, input.package_family, ca)?
+        } else {
+            false
+        };
         let target = sessions.join(reference.file_name());
         if target.exists() {
-            reference.read(local_folder, install_root)?;
+            if let Err(error) = reference.read(local_folder, install_root) {
+                if private_created {
+                    _ = fs::remove_file(sessions.join(reference.private_file_name()));
+                }
+                return Err(error);
+            }
             return Ok(reference);
         }
 
@@ -113,8 +195,13 @@ impl SessionReference {
             }
         })();
         _ = fs::remove_file(staging);
-        result?;
-        reference.read(local_folder, install_root)?;
+        let result = result.and_then(|()| reference.read(local_folder, install_root).map(|_| ()));
+        if let Err(error) = result {
+            if private_created && reference.read(local_folder, install_root).is_err() {
+                _ = fs::remove_file(sessions.join(reference.private_file_name()));
+            }
+            return Err(error);
+        }
         Ok(reference)
     }
 
@@ -126,17 +213,81 @@ impl SessionReference {
         format!("{}.json", self.digest)
     }
 
-    pub(crate) fn read(&self, local_folder: &Path, install_root: &Path) -> Result<SessionSnapshot> {
-        let path = session_directory(local_folder, false)?.join(self.file_name());
-        let metadata = fs::symlink_metadata(&path).map_err(windows_error)?;
-        if !metadata.is_file()
-            || metadata.file_attributes() & FILE_ATTRIBUTE_REPARSE_POINT != 0
-            || metadata.len() == 0
-            || metadata.len() > MAX_SESSION_SNAPSHOT_BYTES
-        {
+    fn private_file_name(&self) -> String {
+        format!("{}.http-ca.dpapi", self.digest)
+    }
+
+    fn publish_http_ca(
+        &self,
+        local_folder: &Path,
+        package_family: &str,
+        ca: &CaMaterial,
+    ) -> Result<bool> {
+        let identity = ca.identity().map_err(|_| invalid_snapshot())?;
+        let sessions = session_directory(local_folder, true)?;
+        let target = sessions.join(self.private_file_name());
+        if target.exists() {
+            self.read_http_ca_file(local_folder, package_family, identity)?;
+            return Ok(false);
+        }
+        let protected = super::http_ca::seal(ca, package_family, &self.token())?;
+        let staging = sessions.join(format!(
+            "staging-{}-{}-ca",
+            std::process::id(),
+            STAGING_ID.fetch_add(1, Ordering::Relaxed)
+        ));
+        let result = (|| {
+            let mut file = OpenOptions::new()
+                .write(true)
+                .create_new(true)
+                .open(&staging)
+                .map_err(windows_error)?;
+            file.write_all(&protected).map_err(windows_error)?;
+            file.sync_all().map_err(windows_error)?;
+            drop(file);
+            match fs::rename(&staging, &target) {
+                Ok(()) => Ok(true),
+                Err(_) if target.exists() => self
+                    .read_http_ca_file(local_folder, package_family, identity)
+                    .map(|_| false),
+                Err(error) => Err(windows_error(error)),
+            }
+        })();
+        _ = fs::remove_file(staging);
+        result
+    }
+
+    fn read_http_ca_file(
+        &self,
+        local_folder: &Path,
+        package_family: &str,
+        identity: [u8; 32],
+    ) -> Result<CaMaterial> {
+        let path = session_directory(local_folder, false)?.join(self.private_file_name());
+        let bytes = read_regular_file(&path, super::http_ca::MAX_PROTECTED_CA_BYTES as u64)?;
+        super::http_ca::open(&bytes, package_family, &self.token(), identity)
+    }
+
+    pub(crate) fn read_http_ca(
+        &self,
+        local_folder: &Path,
+        package_family: &str,
+        snapshot: &SessionSnapshot,
+    ) -> Result<Option<CaMaterial>> {
+        if snapshot_digest(&snapshot.to_canonical_json()?) != self.digest {
             return Err(invalid_snapshot());
         }
-        let bytes = fs::read(path).map_err(windows_error)?;
+        snapshot
+            .http
+            .as_ref()
+            .and_then(|http| http.ca_identity)
+            .map(|identity| self.read_http_ca_file(local_folder, package_family, identity))
+            .transpose()
+    }
+
+    pub(crate) fn read(&self, local_folder: &Path, install_root: &Path) -> Result<SessionSnapshot> {
+        let path = session_directory(local_folder, false)?.join(self.file_name());
+        let bytes = read_regular_file(&path, MAX_SESSION_SNAPSHOT_BYTES as u64)?;
         if snapshot_digest(&bytes) != self.digest {
             return Err(Error::new(
                 E_FAIL,
@@ -158,14 +309,22 @@ impl SessionReference {
         previous: Option<&SessionReference>,
     ) -> Result<()> {
         let sessions = session_directory(local_folder, false)?;
-        let retained = [Some(self.file_name()), previous.map(Self::file_name)];
+        let retained = [
+            Some(self.file_name()),
+            Some(self.private_file_name()),
+            previous.map(Self::file_name),
+            previous.map(Self::private_file_name),
+        ];
         for entry in fs::read_dir(sessions).map_err(windows_error)? {
             let entry = entry.map_err(windows_error)?;
             let name = entry.file_name().to_string_lossy().into_owned();
             if retained.iter().flatten().any(|retained| retained == &name) {
                 continue;
             }
-            if name.starts_with("staging-") || is_session_file_name(&name) {
+            if name.starts_with("staging-")
+                || is_session_file_name(&name)
+                || is_private_file_name(&name)
+            {
                 _ = fs::remove_file(entry.path());
             }
         }
@@ -173,7 +332,27 @@ impl SessionReference {
     }
 }
 
+impl std::fmt::Debug for SessionSnapshot {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("SessionSnapshot")
+            .field("revision", &self.revision)
+            .field("config_bytes", &self.config_yaml.len())
+            .field("http_config_present", &self.http.is_some())
+            .field("backend_present", &self.session_backend.is_some())
+            .finish_non_exhaustive()
+    }
+}
 impl SessionSnapshot {
+    pub(crate) fn http_snapshot(&self) -> Option<&str> {
+        self.http.as_ref().map(|http| http.rules.as_str())
+    }
+
+    pub(crate) fn http_base_dir(&self) -> Option<PathBuf> {
+        self.http
+            .as_ref()
+            .and_then(|http| http.base_dir.as_deref())
+            .map(|wide| std::ffi::OsString::from_wide(wide).into())
+    }
     pub(crate) fn config_yaml(&self) -> &str {
         &self.config_yaml
     }
@@ -187,6 +366,7 @@ impl SessionSnapshot {
             return Err(invalid_snapshot());
         }
         validate_config_yaml(&self.config_yaml)?;
+        validate_http_snapshot(self.http.as_ref())?;
         if let Some(backend) = &self.session_backend {
             backend.validate(install_root).map_err(windows_error)?;
         }
@@ -194,14 +374,78 @@ impl SessionSnapshot {
     }
 
     fn to_canonical_json(&self) -> Result<Vec<u8>> {
-        let bytes = serde_json::to_vec(self).map_err(|_| invalid_snapshot())?;
-        if bytes.is_empty() || bytes.len() as u64 > MAX_SESSION_SNAPSHOT_BYTES {
+        validate_config_yaml(&self.config_yaml)?;
+        if let Some(http) = &self.http
+            && (http.rules.len() > MAX_SNAPSHOT
+                || http
+                    .base_dir
+                    .as_ref()
+                    .is_some_and(|path| path.len() > MAX_BASE_DIR_CODE_UNITS))
+        {
             return Err(invalid_snapshot());
         }
+        if let Some(backend) = &self.session_backend {
+            serialized_size(backend, MAX_BACKEND_SNAPSHOT_BYTES)?;
+        }
+        let size = serialized_size(self, MAX_SESSION_SNAPSHOT_BYTES)?;
+        let mut bytes = Vec::new();
+        bytes
+            .try_reserve_exact(size)
+            .map_err(|_| invalid_snapshot())?;
+        serde_json::to_writer(&mut bytes, self).map_err(|_| invalid_snapshot())?;
+        debug_assert_eq!(bytes.len(), size);
         Ok(bytes)
     }
 }
 
+fn serialized_size(value: &impl Serialize, maximum: usize) -> Result<usize> {
+    struct Counter {
+        size: usize,
+        maximum: usize,
+    }
+    impl io::Write for Counter {
+        fn write(&mut self, bytes: &[u8]) -> io::Result<usize> {
+            self.size = self
+                .size
+                .checked_add(bytes.len())
+                .filter(|size| *size <= self.maximum)
+                .ok_or_else(|| {
+                    io::Error::new(
+                        io::ErrorKind::InvalidInput,
+                        "session snapshot exceeds limit",
+                    )
+                })?;
+            Ok(bytes.len())
+        }
+
+        fn flush(&mut self) -> io::Result<()> {
+            Ok(())
+        }
+    }
+    let mut counter = Counter { size: 0, maximum };
+    serde_json::to_writer(&mut counter, value).map_err(|_| invalid_snapshot())?;
+    Ok(counter.size)
+}
+
+fn validate_http_snapshot(input: Option<&HttpSessionSnapshot>) -> Result<()> {
+    if let Some(input) = input {
+        if input.rules.len() > MAX_SNAPSHOT {
+            return Err(invalid_snapshot());
+        }
+        PolicyCandidate::import_snapshot(&input.rules).map_err(|_| invalid_snapshot())?;
+        if let Some(wide) = &input.base_dir {
+            let path = PathBuf::from(std::ffi::OsString::from_wide(wide));
+            if wide.is_empty()
+                || wide.len() > MAX_BASE_DIR_CODE_UNITS
+                || wide.contains(&0)
+                || !path.is_absolute()
+            {
+                return Err(invalid_snapshot());
+            }
+        }
+    }
+    Ok(())
+}
 fn validate_config_yaml(config_yaml: &str) -> Result<()> {
     if config_yaml.is_empty() || config_yaml.len() > MAX_CONFIG_BYTES {
         return Err(Error::new(
@@ -246,6 +490,42 @@ fn is_session_file_name(name: &str) -> bool {
             .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
 }
 
+fn is_private_file_name(name: &str) -> bool {
+    name.strip_suffix(".http-ca.dpapi").is_some_and(|digest| {
+        digest.len() == 64
+            && digest
+                .bytes()
+                .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
+    })
+}
+
+fn read_regular_file(path: &Path, maximum: u64) -> Result<Vec<u8>> {
+    // Inspect the opened object, not a path that could be replaced between a
+    // metadata lookup and the read. Never follow a final reparse point.
+    const FILE_FLAG_OPEN_REPARSE_POINT: u32 = 0x0020_0000;
+    let file = OpenOptions::new()
+        .read(true)
+        .custom_flags(FILE_FLAG_OPEN_REPARSE_POINT)
+        .open(path)
+        .map_err(windows_error)?;
+    let metadata = file.metadata().map_err(windows_error)?;
+    if !metadata.is_file()
+        || metadata.file_attributes() & FILE_ATTRIBUTE_REPARSE_POINT != 0
+        || metadata.len() == 0
+        || metadata.len() > maximum
+    {
+        return Err(invalid_snapshot());
+    }
+    let mut bytes = Vec::with_capacity(metadata.len() as usize);
+    file.take(maximum + 1)
+        .read_to_end(&mut bytes)
+        .map_err(windows_error)?;
+    if bytes.len() as u64 > maximum {
+        return Err(invalid_snapshot());
+    }
+    Ok(bytes)
+}
+
 fn snapshot_digest(bytes: &[u8]) -> String {
     use std::fmt::Write as _;
 
@@ -268,6 +548,56 @@ fn windows_error(error: impl std::fmt::Display) -> Error {
 mod tests {
     use super::*;
 
+    #[test]
+    fn snapshot_json_budget_counts_actual_escaping_before_allocation() {
+        let value = "\\\n\"\u{0000}é";
+        let expected = serde_json::to_vec(value).unwrap();
+        assert_eq!(
+            serialized_size(&value, expected.len()).unwrap(),
+            expected.len()
+        );
+        assert!(serialized_size(&value, expected.len() - 1).is_err());
+        let snapshot = SessionSnapshot {
+            revision: SESSION_REVISION,
+            config_yaml: "x".repeat(MAX_CONFIG_BYTES + 1),
+            http: None,
+            session_backend: None,
+        };
+        assert!(snapshot.to_canonical_json().is_err());
+    }
+
+    #[test]
+    fn snapshot_preserves_valid_http_content_expanded_beyond_one_mibibyte() {
+        let input = format!(
+            "rewrite:\n  enabled: true\n  rules:\n    - &rule {{url: '.', action: response-body-set, value: '{}'}}\n    - *rule\n    - *rule\n    - *rule\n    - *rule\n",
+            "x".repeat(256 * 1024)
+        );
+        assert!(input.len() < crate::http_processing::MAX_ADDENDUM);
+        let document = crate::http_processing::config::Document::parse(&input).unwrap();
+        let rules = document
+            .compile(&Default::default())
+            .unwrap()
+            .export_snapshot()
+            .unwrap();
+        assert!(rules.len() > 1024 * 1024);
+        let snapshot = SessionSnapshot {
+            revision: SESSION_REVISION,
+            config_yaml: "tun: {enable: true}".into(),
+            http: Some(HttpSessionSnapshot {
+                rules,
+                base_dir: None,
+                ca_identity: None,
+            }),
+            session_backend: None,
+        };
+        snapshot.validate(Path::new(".")).unwrap();
+        let encoded = snapshot.to_canonical_json().unwrap();
+        assert!(encoded.len() > 1024 * 1024);
+        let restored: SessionSnapshot = serde_json::from_slice(&encoded).unwrap();
+        restored.validate(Path::new(".")).unwrap();
+        assert_eq!(restored.to_canonical_json().unwrap(), encoded);
+    }
+
     fn install_root() -> tempfile::TempDir {
         let root = tempfile::tempdir().unwrap();
         fs::create_dir(root.path().join("bin")).unwrap();
@@ -312,6 +642,7 @@ mod tests {
             install.path(),
             "tun:\n  enable: true\n".to_owned(),
             Some(backend(&["run", "one"])),
+            None,
         )
         .unwrap();
         let same = SessionReference::publish(
@@ -319,6 +650,7 @@ mod tests {
             install.path(),
             "tun:\n  enable: true\n".to_owned(),
             Some(backend(&["run", "one"])),
+            None,
         )
         .unwrap();
         let changed = SessionReference::publish(
@@ -326,6 +658,7 @@ mod tests {
             install.path(),
             "tun:\n  enable: true\n".to_owned(),
             Some(backend(&["run", "two"])),
+            None,
         )
         .unwrap();
 
@@ -349,6 +682,7 @@ mod tests {
             install.path(),
             "tun:\n  enable: true\n".to_owned(),
             None,
+            None,
         )
         .unwrap();
         fs::write(
@@ -379,7 +713,8 @@ mod tests {
         let local = tempfile::tempdir().unwrap();
         let install = install_root();
         let publish = |yaml: &str| {
-            SessionReference::publish(local.path(), install.path(), yaml.to_owned(), None).unwrap()
+            SessionReference::publish(local.path(), install.path(), yaml.to_owned(), None, None)
+                .unwrap()
         };
         let first = publish("first");
         let second = publish("second");
@@ -397,4 +732,98 @@ mod tests {
         assert!(sessions.join(third.file_name()).exists());
         assert!(!sessions.join("staging-old").exists());
     }
+
+    #[test]
+    fn snapshot_identity_and_readback_include_the_http_addendum() {
+        let local = tempfile::tempdir().unwrap();
+        let install = install_root();
+        let main = "tun: {enable: true}".to_owned();
+        let initial =
+            SessionReference::publish(local.path(), install.path(), main.clone(), None, None)
+                .unwrap();
+        let document = crate::http_processing::config::Document::parse(
+            "rewrite: {enabled: true, rules: [{url: '.', action: reject}]}",
+        )
+        .unwrap();
+        let http = document
+            .compile(&Default::default())
+            .unwrap()
+            .export_snapshot()
+            .unwrap();
+        let updated = SessionReference::publish(
+            local.path(),
+            install.path(),
+            main,
+            None,
+            Some(HttpSessionInput {
+                rules: http.clone(),
+                base_dir: None,
+                ca: None,
+                package_family: "ExamplePackage",
+            }),
+        )
+        .unwrap();
+        assert_ne!(initial, updated);
+        let snapshot = updated.read(local.path(), install.path()).unwrap();
+        assert_eq!(snapshot.http_snapshot(), Some(http.as_str()));
+        assert!(!format!("{snapshot:?}").contains("action"));
+    }
+
+    #[test]
+    fn private_ca_stays_outside_snapshot_and_cannot_cross_session_tokens() {
+        let local = tempfile::tempdir().unwrap();
+        let install = install_root();
+        let ca = crate::http_processing::private_context::test_material();
+        let document = crate::http_processing::config::Document::parse(
+            "mitm: {enabled: true, domains: [{pattern: example.com}]}",
+        )
+        .unwrap();
+        let rules = document
+            .compile(&Default::default())
+            .unwrap()
+            .export_snapshot()
+            .unwrap();
+        let publish = |main: &str| {
+            SessionReference::publish(
+                local.path(),
+                install.path(),
+                main.to_owned(),
+                None,
+                Some(HttpSessionInput {
+                    rules: rules.clone(),
+                    base_dir: None,
+                    ca: Some(&ca),
+                    package_family: "ExamplePackage",
+                }),
+            )
+            .unwrap()
+        };
+        let first = publish("rules: [MATCH,DIRECT]");
+        assert_eq!(first, publish("rules: [MATCH,DIRECT]"));
+        let second = publish("rules: [MATCH,REJECT]");
+        assert_ne!(first, second);
+        let snapshot = first.read(local.path(), install.path()).unwrap();
+        let restored = first
+            .read_http_ca(local.path(), "ExamplePackage", &snapshot)
+            .unwrap()
+            .unwrap();
+        assert_eq!(restored.identity().unwrap(), ca.identity().unwrap());
+        let encoded = snapshot.to_canonical_json().unwrap();
+        let encoded = std::str::from_utf8(&encoded).unwrap();
+        assert!(!encoded.contains("PRIVATE KEY"));
+        assert!(!encoded.contains("privateKey"));
+        assert!(!encoded.contains("BEGIN CERTIFICATE"));
+        let sessions = local.path().join(SESSION_DIRECTORY);
+        fs::copy(
+            sessions.join(first.private_file_name()),
+            sessions.join(second.private_file_name()),
+        )
+        .unwrap();
+        let snapshot = second.read(local.path(), install.path()).unwrap();
+        assert!(
+            second
+                .read_http_ca(local.path(), "ExamplePackage", &snapshot)
+                .is_err()
+        );
+    }
 }
diff --git a/src/xudp.rs b/src/xudp.rs
index 1912e79..b0b5e7c 100644
--- a/src/xudp.rs
+++ b/src/xudp.rs
@@ -2,7 +2,7 @@
 
 use std::io;
 
-use bytes::{BufMut as _, Bytes, BytesMut};
+use bytes::{Buf as _, BufMut as _, Bytes, BytesMut};
 use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};
 
 use crate::{
@@ -28,12 +28,22 @@ pub struct XudpTransport {
     max_response_payload_size: u16,
     max_request_payload_size: u16,
     first_write: bool,
+    flush_each_frame: bool,
     last_remote: Option<Destination>,
+    multiple_remotes: bool,
+    pending_write: Option<PendingWrite>,
+    send_buffer: BytesMut,
     receive_buffer: BytesMut,
     max_receive_buffer_size: usize,
     closed: bool,
 }
 
+struct PendingWrite {
+    frame: BytesMut,
+    offset: usize,
+    remote: Destination,
+}
+
 impl std::fmt::Debug for XudpTransport {
     fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         formatter
@@ -77,15 +87,66 @@ impl XudpTransport {
             max_response_payload_size,
             max_request_payload_size: budget.transmit(),
             first_write: true,
+            flush_each_frame: true,
             last_remote: None,
+            multiple_remotes: false,
+            pending_write: None,
+            send_buffer: BytesMut::new(),
             receive_buffer: BytesMut::with_capacity(max_receive_buffer_size),
             max_receive_buffer_size,
             closed: false,
         }
     }
 
+    /// Only for a supplied transport whose owned driver independently advances
+    /// every accepted write. Ordinary buffered streams retain per-frame flush.
+    pub(crate) fn with_autonomous_writes(mut self) -> Self {
+        self.flush_each_frame = false;
+        self
+    }
+
+    // A cancelled logical target may have submitted a frame prefix. Retain
+    // exactly that frame and finish it before another send or receive, rather
+    // than corrupting a shared wire or retaining a per-target payload queue.
+    async fn flush_pending(&mut self) -> io::Result<()> {
+        if let Some(pending) = &mut self.pending_write {
+            let stream = self.stream.as_mut().expect("open XUDP stream");
+            while pending.offset < pending.frame.len() {
+                let written = stream.write(&pending.frame[pending.offset..]).await?;
+                if written == 0 {
+                    return Err(io::ErrorKind::WriteZero.into());
+                }
+                pending.offset += written;
+            }
+            if self.first_write || self.flush_each_frame {
+                stream.flush().await?;
+            }
+            self.first_write = false;
+            let PendingWrite {
+                mut frame, remote, ..
+            } = self.pending_write.take().expect("pending frame");
+            // No accepted frame shares this mutable backing. Keep one empty
+            // buffer only after the original flush boundary has completed.
+            frame.clear();
+            self.send_buffer = frame;
+            self.multiple_remotes |= self
+                .last_remote
+                .as_ref()
+                .is_some_and(|last| last != &remote);
+            self.last_remote = Some(remote);
+        }
+        Ok(())
+    }
+
+    fn fail(&mut self) {
+        self.closed = true;
+        self.pending_write = None;
+        self.send_buffer = BytesMut::new();
+        self.stream.take();
+    }
+
     /// Incrementally fills the persistent receive buffer using only
-    /// cancellation-safe `read` calls. Every successful partial read is
+    /// cancellation-safe `read_buf` calls. Every successful partial read is
     /// committed before the next await, so dropping `receive()` from a
     /// `tokio::select!` cannot lose bytes or parser progress.
     async fn fill_receive_buffer(&mut self, required: usize) -> io::Result<()> {
@@ -96,15 +157,17 @@ impl XudpTransport {
             ));
         }
 
-        let mut scratch = [0_u8; 1024];
         while self.receive_buffer.len() < required {
-            let missing = required - self.receive_buffer.len();
-            let chunk = missing.min(scratch.len());
+            // Consume available stream bytes within the existing one-frame
+            // byte budget. Reading exactly each small header field repeatedly
+            // enters TLS/H2 even when several complete packets are ready.
+            let remaining = self.max_receive_buffer_size - self.receive_buffer.len();
+            let mut destination = (&mut self.receive_buffer).limit(remaining);
             let read = self
                 .stream
                 .as_mut()
                 .expect("open XUDP stream")
-                .read(&mut scratch[..chunk])
+                .read_buf(&mut destination)
                 .await?;
             if read == 0 {
                 return Err(io::Error::new(
@@ -112,7 +175,6 @@ impl XudpTransport {
                     "XUDP stream ended in the middle of a frame",
                 ));
             }
-            self.receive_buffer.extend_from_slice(&scratch[..read]);
         }
         Ok(())
     }
@@ -174,7 +236,7 @@ impl XudpTransport {
                 (status, option)
             };
             if option & OPTION_DATA == 0 {
-                self.receive_buffer.clear();
+                self.receive_buffer.advance(metadata_end);
                 continue;
             }
 
@@ -200,6 +262,12 @@ impl XudpTransport {
                         }
                         Ok(destination)
                     } else {
+                        if self.multiple_remotes {
+                            return Err(io::Error::new(
+                                io::ErrorKind::InvalidData,
+                                "XUDP response omitted an ambiguous destination",
+                            ));
+                        }
                         self.last_remote.clone().ok_or_else(|| {
                             io::Error::new(
                                 io::ErrorKind::InvalidData,
@@ -234,12 +302,12 @@ impl XudpTransport {
             self.fill_receive_buffer(frame_end).await?;
 
             if status == STATUS_KEEP_ALIVE {
-                self.receive_buffer.clear();
+                self.receive_buffer.advance(frame_end);
                 continue;
             }
             let payload =
                 Bytes::copy_from_slice(&self.receive_buffer[payload_length_end..frame_end]);
-            self.receive_buffer.clear();
+            self.receive_buffer.advance(frame_end);
             return Ok(Datagram {
                 remote: remote.expect("non-keepalive XUDP data has a remote destination"),
                 payload,
@@ -251,6 +319,10 @@ impl XudpTransport {
 
 #[async_trait::async_trait]
 impl DatagramTransport for XudpTransport {
+    fn supports_shared_destinations(&self) -> bool {
+        true
+    }
+
     fn payload_budget(&self, _peer: &Destination) -> crate::dispatch::DatagramBudget {
         crate::dispatch::DatagramBudget::new(
             self.max_request_payload_size,
@@ -267,31 +339,31 @@ impl DatagramTransport for XudpTransport {
         if datagram.payload.len() > usize::from(self.max_request_payload_size) {
             return Err(io::Error::from(io::ErrorKind::InvalidInput).into());
         }
-        let frame = encode_data_frame(
-            &datagram,
-            self.first_write,
-            if self.first_write && self.global_id != [0; 8] {
-                Some(self.global_id)
-            } else {
-                None
-            },
-        )
-        .map_err(DispatchError::from)?;
-        // Own the stream across the non-cancellation-safe write. Dropping this
-        // future after a partial frame closes the wire rather than resuming at
-        // a new frame boundary on the next send.
-        self.closed = true;
-        let mut stream = self.stream.take().expect("open XUDP stream");
-        stream
-            .write_all(&frame)
-            .await
-            .map_err(DispatchError::from)?;
-        stream.flush().await.map_err(DispatchError::from)?;
-        self.stream = Some(stream);
-        self.closed = false;
-        self.first_write = false;
-        self.last_remote = Some(datagram.remote);
-        Ok(())
+        let result = async {
+            self.flush_pending().await?;
+            let mut frame = std::mem::take(&mut self.send_buffer);
+            encode_data_frame_into(
+                &mut frame,
+                &datagram,
+                self.first_write,
+                if self.first_write && self.global_id != [0; 8] {
+                    Some(self.global_id)
+                } else {
+                    None
+                },
+            )?;
+            self.pending_write = Some(PendingWrite {
+                frame,
+                offset: 0,
+                remote: datagram.remote,
+            });
+            self.flush_pending().await
+        }
+        .await;
+        if result.is_err() {
+            self.fail();
+        }
+        result.map_err(DispatchError::from)
     }
 
     async fn receive(&mut self) -> Result<Datagram, DispatchError> {
@@ -300,10 +372,13 @@ impl DatagramTransport for XudpTransport {
                 "XUDP association is closed".to_owned(),
             ));
         }
-        let result = self.read_frame().await;
+        let result = async {
+            self.flush_pending().await?;
+            self.read_frame().await
+        }
+        .await;
         if result.is_err() {
-            self.closed = true;
-            self.stream.take();
+            self.fail();
         }
         result.map_err(DispatchError::from)
     }
@@ -313,21 +388,38 @@ impl DatagramTransport for XudpTransport {
             return Ok(());
         }
         self.closed = true;
+        self.send_buffer = BytesMut::new();
         let mut stream = self.stream.take().expect("open XUDP stream");
-        stream
-            .write_all(&[0, 4, 0, 0, STATUS_END, 0])
-            .await
-            .map_err(DispatchError::from)?;
+        // A partial data frame cannot be followed by a mux END frame. Closing
+        // the last owner may discard it and terminate the underlying stream.
+        if self.pending_write.take().is_none() {
+            stream
+                .write_all(&[0, 4, 0, 0, STATUS_END, 0])
+                .await
+                .map_err(DispatchError::from)?;
+        }
         stream.shutdown().await.map_err(DispatchError::from)?;
         Ok(())
     }
 }
 
+#[cfg(test)]
 pub(crate) fn encode_data_frame(
     datagram: &Datagram,
     first: bool,
     global_id: Option<[u8; 8]>,
 ) -> io::Result<Bytes> {
+    let mut output = BytesMut::new();
+    encode_data_frame_into(&mut output, datagram, first, global_id)?;
+    Ok(output.freeze())
+}
+
+fn encode_data_frame_into(
+    output: &mut BytesMut,
+    datagram: &Datagram,
+    first: bool,
+    global_id: Option<[u8; 8]>,
+) -> io::Result<()> {
     if datagram.payload.is_empty() {
         return Err(io::Error::new(
             io::ErrorKind::InvalidInput,
@@ -341,39 +433,243 @@ pub(crate) fn encode_data_frame(
         )
     })?;
 
-    let mut destination = BytesMut::with_capacity(19);
-    encode_destination(&datagram.remote, &mut destination)?;
+    let destination_length = match &datagram.remote {
+        Destination::Ip(address) if address.is_ipv4() => 7,
+        Destination::Ip(_) => 19,
+        Destination::Domain { host, .. } => {
+            let length = u8::try_from(host.len()).map_err(|_| {
+                io::Error::new(io::ErrorKind::InvalidInput, "proxy domain is too long")
+            })?;
+            4 + usize::from(length)
+        }
+    };
     let global_id_length = global_id.map_or(0, |_| 8);
-    let metadata_length = 2 + 1 + 1 + 1 + destination.len() + global_id_length;
+    let metadata_length = 2 + 1 + 1 + 1 + destination_length + global_id_length;
     let metadata_length = u16::try_from(metadata_length).expect("XUDP metadata is bounded");
 
-    let mut output =
-        BytesMut::with_capacity(2 + usize::from(metadata_length) + 2 + datagram.payload.len());
+    let required = 2 + usize::from(metadata_length) + 2 + datagram.payload.len();
+    output.clear();
+    if output.capacity() < required {
+        // Drop a smaller old backing before allocating the next exact frame.
+        // The caller already applies the unchanged request payload budget.
+        *output = BytesMut::new();
+        *output = BytesMut::with_capacity(required);
+    }
     output.put_u16(metadata_length);
     output.put_u16(0); // one XUDP association uses mux session zero
     output.put_u8(if first { STATUS_NEW } else { STATUS_KEEP });
     output.put_u8(OPTION_DATA);
     output.put_u8(NETWORK_UDP);
-    output.extend_from_slice(&destination);
+    encode_destination(&datagram.remote, output)?;
     if let Some(global_id) = global_id {
         output.extend_from_slice(&global_id);
     }
     output.put_u16(payload_length);
     output.extend_from_slice(&datagram.payload);
-    Ok(output.freeze())
+    Ok(())
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    struct FlushGate {
+        inner: tokio::io::DuplexStream,
+        blocked: std::sync::Arc<std::sync::atomic::AtomicBool>,
+        reads: std::sync::Arc<std::sync::atomic::AtomicUsize>,
+    }
+    impl tokio::io::AsyncRead for FlushGate {
+        fn poll_read(
+            mut self: std::pin::Pin<&mut Self>,
+            cx: &mut std::task::Context<'_>,
+            buffer: &mut tokio::io::ReadBuf<'_>,
+        ) -> std::task::Poll<io::Result<()>> {
+            self.reads
+                .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+            std::pin::Pin::new(&mut self.inner).poll_read(cx, buffer)
+        }
+    }
+    impl tokio::io::AsyncWrite for FlushGate {
+        fn poll_write(
+            mut self: std::pin::Pin<&mut Self>,
+            cx: &mut std::task::Context<'_>,
+            buffer: &[u8],
+        ) -> std::task::Poll<io::Result<usize>> {
+            std::pin::Pin::new(&mut self.inner).poll_write(cx, buffer)
+        }
+        fn poll_flush(
+            mut self: std::pin::Pin<&mut Self>,
+            cx: &mut std::task::Context<'_>,
+        ) -> std::task::Poll<io::Result<()>> {
+            if self.blocked.load(std::sync::atomic::Ordering::Relaxed) {
+                std::task::Poll::Pending
+            } else {
+                std::pin::Pin::new(&mut self.inner).poll_flush(cx)
+            }
+        }
+        fn poll_shutdown(
+            mut self: std::pin::Pin<&mut Self>,
+            cx: &mut std::task::Context<'_>,
+        ) -> std::task::Poll<io::Result<()>> {
+            std::pin::Pin::new(&mut self.inner).poll_shutdown(cx)
+        }
+    }
+
     #[tokio::test]
-    async fn shared_xudp_receives_frames_without_a_vless_response_header() {
-        #[cfg(any(test, feature = "interop-test"))]
-        let mut _case = crate::resources::case_events::Case::new(
-            "FOUNDATIONS-XUDP",
-            "shared_xudp_receives_frames_without_a_vless_response_header",
+    async fn reusable_send_backing_preserves_wire_budget_and_clears_on_close() {
+        let (client, mut server) = tokio::io::duplex(4096);
+        let budget = crate::dispatch::DatagramBudget::new(1400, 1452);
+        let mut transport = XudpTransport::with_budget(Box::new(client), [7; 8], budget);
+        assert_eq!(transport.send_buffer.capacity(), 0);
+        let first = Datagram {
+            remote: "192.0.2.1:53"
+                .parse::<std::net::SocketAddr>()
+                .unwrap()
+                .into(),
+            payload: Bytes::from(vec![0x5a; 1200]),
+            sniffed_domain: None,
+        };
+        let mut second = first.clone();
+        second.remote = "192.0.2.2:53"
+            .parse::<std::net::SocketAddr>()
+            .unwrap()
+            .into();
+        let mut expected = encode_data_frame(&first, true, Some([7; 8]))
+            .unwrap()
+            .to_vec();
+        expected.extend_from_slice(&encode_data_frame(&second, false, None).unwrap());
+        expected.extend_from_slice(&[0, 4, 0, 0, STATUS_END, 0]);
+
+        transport.send(first).await.unwrap();
+        assert!(transport.pending_write.is_none());
+        assert!(transport.send_buffer.is_empty());
+        let backing = transport.send_buffer.as_ptr();
+        let capacity = transport.send_buffer.capacity();
+        assert!(capacity >= 1200);
+        assert!(capacity <= 2 + MAX_METADATA_LENGTH + 2 + usize::from(budget.transmit()));
+        transport.send(second.clone()).await.unwrap();
+        assert_eq!(transport.send_buffer.as_ptr(), backing);
+        assert_eq!(transport.send_buffer.capacity(), capacity);
+
+        second.payload = Bytes::from(vec![0; 1401]);
+        assert!(transport.send(second).await.is_err());
+        assert!(!transport.closed);
+        assert!(transport.pending_write.is_none());
+        assert_eq!(transport.send_buffer.as_ptr(), backing);
+        transport.close().await.unwrap();
+        assert!(transport.pending_write.is_none());
+        assert_eq!(transport.send_buffer.capacity(), 0);
+        let mut actual = Vec::new();
+        server.read_to_end(&mut actual).await.unwrap();
+        assert_eq!(actual, expected);
+    }
+
+    #[tokio::test]
+    async fn failed_send_releases_a_warmed_encode_backing() {
+        let (client, server) = tokio::io::duplex(4096);
+        let mut transport = XudpTransport::with_budget(
+            Box::new(client),
+            [0; 8],
+            crate::dispatch::DatagramBudget::new(1400, 1452),
         );
+        let packet = Datagram {
+            remote: "192.0.2.1:53"
+                .parse::<std::net::SocketAddr>()
+                .unwrap()
+                .into(),
+            payload: Bytes::from(vec![0x5a; 1200]),
+            sniffed_domain: None,
+        };
+        transport.send(packet.clone()).await.unwrap();
+        assert!(transport.send_buffer.capacity() > 0);
+        drop(server);
+        assert!(transport.send(packet).await.is_err());
+        assert!(transport.closed);
+        assert!(transport.pending_write.is_none());
+        assert_eq!(transport.send_buffer.capacity(), 0);
+        assert!(transport.stream.is_none());
+    }
+
+    #[tokio::test]
+    async fn autonomous_upload_skips_only_established_frame_flush_barriers() {
+        use std::sync::{
+            Arc,
+            atomic::{AtomicBool, Ordering},
+        };
+        for autonomous in [false, true] {
+            let (client, mut server) = tokio::io::duplex(256);
+            let blocked = Arc::new(AtomicBool::new(true));
+            let mut transport = XudpTransport::new(
+                Box::new(FlushGate {
+                    inner: client,
+                    blocked: blocked.clone(),
+                    reads: std::sync::Arc::default(),
+                }),
+                [0; 8],
+                1452,
+            );
+            if autonomous {
+                transport = transport.with_autonomous_writes();
+            }
+            let packet = Datagram {
+                remote: "192.0.2.1:53"
+                    .parse::<std::net::SocketAddr>()
+                    .unwrap()
+                    .into(),
+                payload: Bytes::from_static(b"packet"),
+                sniffed_domain: None,
+            };
+            assert!(
+                futures_util::poll!(transport.send(packet.clone())).is_pending(),
+                "first frame must retain its setup flush"
+            );
+            blocked.store(false, Ordering::Relaxed);
+            // Finish the cancelled first frame without introducing a duplicate.
+            transport.flush_pending().await.unwrap();
+            blocked.store(true, Ordering::Relaxed);
+            let sent = futures_util::poll!(transport.send(packet.clone()));
+            assert_eq!(sent.is_ready(), autonomous);
+            blocked.store(false, Ordering::Relaxed);
+            transport.flush_pending().await.unwrap();
+            let mut expected = encode_data_frame(&packet, true, None).unwrap().to_vec();
+            expected.extend_from_slice(&encode_data_frame(&packet, false, None).unwrap());
+            let mut actual = vec![0; expected.len()];
+            server.read_exact(&mut actual).await.unwrap();
+            assert_eq!(actual, expected);
+        }
+    }
+
+    #[tokio::test]
+    async fn mtu_sized_response_and_coalesced_tail_use_one_bounded_read() {
+        use std::sync::{
+            Arc,
+            atomic::{AtomicBool, AtomicUsize, Ordering},
+        };
+        let payload = vec![b'x'; 1452];
+        let mut wire = response_data_prefix(payload.len() as u16);
+        wire.extend_from_slice(&payload);
+        wire.extend_from_slice(&response_data_prefix(4));
+        wire.extend_from_slice(b"tail");
+        let (client, mut server) = tokio::io::duplex(4096);
+        server.write_all(&wire).await.unwrap();
+        let reads = Arc::new(AtomicUsize::new(0));
+        let mut transport = XudpTransport::new(
+            Box::new(FlushGate {
+                inner: client,
+                blocked: Arc::new(AtomicBool::new(false)),
+                reads: reads.clone(),
+            }),
+            [0; 8],
+            1452,
+        );
+        assert_eq!(transport.receive().await.unwrap().payload.as_ref(), payload);
+        assert_eq!(transport.receive().await.unwrap().payload.as_ref(), b"tail");
+        assert_eq!(reads.load(Ordering::Relaxed), 1);
+        assert!(transport.receive_buffer.capacity() <= transport.max_receive_buffer_size);
+    }
+
+    #[tokio::test]
+    async fn shared_xudp_receives_frames_without_a_vless_response_header() {
         let (client, mut peer) = tokio::io::duplex(64);
         peer.write_all(&[
             0, 12, 0, 0, 2, 1, 2, 0, 53, 1, 1, 2, 3, 4, 0, 3, b'a', b'b', b'c',
@@ -386,13 +682,64 @@ mod tests {
         assert_eq!(datagram.payload.as_ref(), b"abc");
     }
 
+    #[tokio::test]
+    async fn coalesced_data_and_keepalive_preserve_every_frame_within_the_receive_budget() {
+        let (client, mut server) = tokio::io::duplex(256);
+        let payloads = [b"first".as_slice(), b"second", b"third"];
+        let mut wire = Vec::new();
+        for payload in payloads {
+            // A metadata-only keepalive must not discard the following frame.
+            wire.extend_from_slice(&[0, 4, 0, 0, STATUS_KEEP_ALIVE, 0]);
+            wire.extend_from_slice(&response_data_prefix(payload.len() as u16));
+            wire.extend_from_slice(payload);
+        }
+        server.write_all(&wire).await.unwrap();
+        drop(server);
+        let mut transport = XudpTransport::new(Box::new(client), [0; 8], 1452);
+        for payload in payloads {
+            assert_eq!(transport.receive().await.unwrap().payload.as_ref(), payload);
+            assert!(transport.receive_buffer.len() <= transport.max_receive_buffer_size);
+        }
+        assert!(transport.receive().await.is_err());
+    }
+
+    #[tokio::test]
+    async fn omitted_response_destination_is_accepted_only_for_an_unambiguous_association() {
+        for destinations in [1, 2] {
+            let (client, mut server) = tokio::io::duplex(256);
+            let mut transport = XudpTransport::new(Box::new(client), [0; 8], 1452);
+            for last in 1..=destinations {
+                transport
+                    .send(Datagram {
+                        remote: format!("192.0.2.{last}:53")
+                            .parse::<std::net::SocketAddr>()
+                            .unwrap()
+                            .into(),
+                        payload: Bytes::from_static(b"q"),
+                        sniffed_domain: None,
+                    })
+                    .await
+                    .unwrap();
+            }
+            server
+                .write_all(&[0, 4, 0, 0, STATUS_KEEP, OPTION_DATA, 0, 1, b'a'])
+                .await
+                .unwrap();
+            let reply = transport.receive().await;
+            if destinations == 1 {
+                assert_eq!(reply.unwrap().remote.to_string(), "192.0.2.1:53");
+            } else {
+                assert!(
+                    reply.is_err(),
+                    "an omitted address must not select the last sender"
+                );
+                assert!(transport.closed);
+            }
+        }
+    }
+
     #[test]
     fn first_frame_matches_xray_mux_wire_format() {
-        #[cfg(any(test, feature = "interop-test"))]
-        let mut _case = crate::resources::case_events::Case::new(
-            "FOUNDATIONS-XUDP",
-            "first_frame_matches_xray_mux_wire_format",
-        );
         let datagram = Datagram {
             remote: "1.2.3.4:53".parse::<std::net::SocketAddr>().unwrap().into(),
             payload: Bytes::from_static(b"abc"),
@@ -414,29 +761,79 @@ mod tests {
 
     #[test]
     fn followup_frame_carries_each_datagrams_destination() {
-        #[cfg(any(test, feature = "interop-test"))]
-        let mut _case = crate::resources::case_events::Case::new(
-            "FOUNDATIONS-XUDP",
-            "followup_frame_carries_each_datagrams_destination",
-        );
-        let datagram = Datagram {
-            remote: Destination::domain("dns.example", 53).unwrap(),
-            payload: Bytes::from_static(b"q"),
+        let cases: [(Destination, &[u8]); 2] = [
+            (
+                Destination::domain("dns.example", 53).unwrap(),
+                b"\x00\x14\x00\x00\x02\x01\x02\x00\x35\x02\x0bdns.example\x00\x01q",
+            ),
+            (
+                "[2001:db8::1]:443"
+                    .parse::<std::net::SocketAddr>()
+                    .unwrap()
+                    .into(),
+                &[
+                    0, 24, 0, 0, 2, 1, 2, 1, 187, 3, // KEEP, UDP, port, IPv6
+                    0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, b'q',
+                ],
+            ),
+        ];
+        for (remote, expected) in cases {
+            let datagram = Datagram {
+                remote,
+                payload: Bytes::from_static(b"q"),
+                sniffed_domain: None,
+            };
+            assert_eq!(
+                encode_data_frame(&datagram, false, None).unwrap().as_ref(),
+                expected
+            );
+        }
+    }
+
+    #[test]
+    fn maximum_domain_and_payload_preserve_wire_lengths_and_reject_overflow() {
+        let mut datagram = Datagram {
+            remote: Destination::domain("x".repeat(255), 443).unwrap(),
+            payload: Bytes::from(vec![7; usize::from(u16::MAX)]),
             sniffed_domain: None,
         };
-        let frame = encode_data_frame(&datagram, false, None).unwrap();
-        assert_eq!(u16::from_be_bytes([frame[0], frame[1]]), 20);
-        assert_eq!(&frame[2..7], &[0, 0, STATUS_KEEP, OPTION_DATA, NETWORK_UDP]);
-        assert!(frame.ends_with(&[0, 1, b'q']));
+        let frame = encode_data_frame(&datagram, true, Some([9; 8])).unwrap();
+        assert_eq!(frame.len(), 65_811);
+        assert_eq!(&frame[..11], &[1, 16, 0, 0, 1, 1, 2, 1, 187, 2, 255]);
+        assert!(frame[11..266].iter().all(|byte| *byte == b'x'));
+        assert_eq!(&frame[266..274], &[9; 8]);
+        assert_eq!(&frame[274..276], &[255, 255]);
+        assert!(frame[276..].iter().all(|byte| *byte == 7));
+
+        datagram.payload = Bytes::from(vec![7; usize::from(u16::MAX) + 1]);
+        assert_eq!(
+            encode_data_frame(&datagram, false, None)
+                .unwrap_err()
+                .kind(),
+            io::ErrorKind::InvalidInput
+        );
+        datagram.payload = Bytes::new();
+        assert_eq!(
+            encode_data_frame(&datagram, false, None)
+                .unwrap_err()
+                .kind(),
+            io::ErrorKind::InvalidInput
+        );
+        datagram.payload = Bytes::from_static(b"q");
+        datagram.remote = Destination::Domain {
+            host: "x".repeat(256),
+            port: 443,
+        };
+        assert_eq!(
+            encode_data_frame(&datagram, false, None)
+                .unwrap_err()
+                .kind(),
+            io::ErrorKind::InvalidInput
+        );
     }
 
     #[test]
     fn destination_codec_round_trips_all_address_families() {
-        #[cfg(any(test, feature = "interop-test"))]
-        let mut _case = crate::resources::case_events::Case::new(
-            "FOUNDATIONS-XUDP",
-            "destination_codec_round_trips_all_address_families",
-        );
         for destination in [
             Destination::from("192.0.2.1:80".parse::<std::net::SocketAddr>().unwrap()),
             Destination::from("[2001:db8::1]:443".parse::<std::net::SocketAddr>().unwrap()),
@@ -452,11 +849,6 @@ mod tests {
 
     #[tokio::test]
     async fn normal_and_error_end_frames_are_distinguishable() {
-        #[cfg(any(test, feature = "interop-test"))]
-        let mut _case = crate::resources::case_events::Case::new(
-            "FOUNDATIONS-XUDP",
-            "normal_and_error_end_frames_are_distinguishable",
-        );
         let normal = receive_frame_error(&[0, 4, 0, 0, STATUS_END, 0]).await;
         let failed = receive_frame_error(&[0, 4, 0, 0, STATUS_END, OPTION_ERROR]).await;
 
@@ -474,11 +866,6 @@ mod tests {
 
     #[tokio::test]
     async fn oversized_response_is_rejected_before_payload_read() {
-        #[cfg(any(test, feature = "interop-test"))]
-        let mut _case = crate::resources::case_events::Case::new(
-            "FOUNDATIONS-XUDP",
-            "oversized_response_is_rejected_before_payload_read",
-        );
         let (client, mut server) = tokio::io::duplex(64);
         server
             .write_all(&response_data_prefix(u16::MAX))
@@ -514,11 +901,6 @@ mod tests {
 
     #[tokio::test]
     async fn fragmented_receive_survives_cancellation_and_resumes() {
-        #[cfg(any(test, feature = "interop-test"))]
-        let mut _case = crate::resources::case_events::Case::new(
-            "FOUNDATIONS-XUDP",
-            "fragmented_receive_survives_cancellation_and_resumes",
-        );
         let (client, mut server) = tokio::io::duplex(64);
         let mut frame = response_data_prefix(3);
         frame.extend_from_slice(b"abc");
@@ -553,13 +935,64 @@ mod tests {
         assert!(transport.receive_buffer.capacity() <= transport.max_receive_buffer_size);
     }
 
+    #[tokio::test]
+    async fn cancelled_partial_send_preserves_the_shared_frame_boundary() {
+        let (client, mut server) = tokio::io::duplex(1);
+        let first = Datagram {
+            remote: "192.0.2.1:53"
+                .parse::<std::net::SocketAddr>()
+                .unwrap()
+                .into(),
+            payload: Bytes::from_static(b"first"),
+            sniffed_domain: None,
+        };
+        let second = Datagram {
+            remote: "192.0.2.2:53"
+                .parse::<std::net::SocketAddr>()
+                .unwrap()
+                .into(),
+            payload: Bytes::from_static(b"second"),
+            sniffed_domain: None,
+        };
+        let mut expected = encode_data_frame(&first, true, None).unwrap().to_vec();
+        expected.extend_from_slice(&encode_data_frame(&second, false, None).unwrap());
+        let mut transport = XudpTransport::new(Box::new(client), [0; 8], 1452);
+        assert!(futures_util::poll!(transport.send(first)).is_pending());
+        let length = expected.len();
+        let reader = tokio::spawn(async move {
+            let mut received = vec![0; length];
+            server.read_exact(&mut received).await.unwrap();
+            received
+        });
+        transport.send(second).await.unwrap();
+        assert_eq!(reader.await.unwrap(), expected);
+    }
+
+    #[tokio::test]
+    async fn receive_finishes_a_cancelled_partial_send_without_another_packet() {
+        let (client, mut server) = tokio::io::duplex(1);
+        let request = Datagram {
+            remote: "1.2.3.4:53".parse::<std::net::SocketAddr>().unwrap().into(),
+            payload: Bytes::from_static(b"abc"),
+            sniffed_domain: None,
+        };
+        let expected = encode_data_frame(&request, true, None).unwrap();
+        let mut transport = XudpTransport::new(Box::new(client), [0; 8], 1452);
+        assert!(futures_util::poll!(transport.send(request)).is_pending());
+        let peer = tokio::spawn(async move {
+            let mut wire = vec![0; expected.len()];
+            server.read_exact(&mut wire).await.unwrap();
+            assert_eq!(wire, expected);
+            let mut response = response_data_prefix(3);
+            response.extend_from_slice(b"abc");
+            server.write_all(&response).await.unwrap();
+        });
+        assert_eq!(transport.receive().await.unwrap().payload.as_ref(), b"abc");
+        peer.await.unwrap();
+    }
+
     #[tokio::test]
     async fn keepalive_data_is_consumed_without_becoming_an_udp_response() {
-        #[cfg(any(test, feature = "interop-test"))]
-        let mut _case = crate::resources::case_events::Case::new(
-            "FOUNDATIONS-XUDP",
-            "keepalive_data_is_consumed_without_becoming_an_udp_response",
-        );
         let (client, mut server) = tokio::io::duplex(128);
         let mut wire = vec![
             0,
@@ -586,11 +1019,6 @@ mod tests {
 
     #[tokio::test]
     async fn full_wire_payload_remains_available_to_proxy_inbounds() {
-        #[cfg(any(test, feature = "interop-test"))]
-        let mut _case = crate::resources::case_events::Case::new(
-            "FOUNDATIONS-XUDP",
-            "full_wire_payload_remains_available_to_proxy_inbounds",
-        );
         let (client, mut server) = tokio::io::duplex(66_000);
         let mut frame = response_data_prefix(u16::MAX);
         frame.resize(frame.len() + usize::from(u16::MAX), 0x5a);
diff --git a/tests/README.md b/tests/README.md
index d7112bb..4f5159a 100644
--- a/tests/README.md
+++ b/tests/README.md
@@ -1,59 +1,287 @@
 # 测试
 
-核心配置、内存 I/O 和生命周期回归留在本仓库。网络互通与压力测试由
-[container-benchmark](https://github.com/YuanDevTeam/container-benchmark) 管理。
+本仓库维护配置、协议编解码、内存I/O、资源所有权和生命周期回归。
+网络互通与压力由独立容器工具管理，结果与结论统一保存在 benchmark 工程。
 
 ## 本地检查
 
+按[编译文档](../scripts/README.md)准备原生依赖后执行：
+
 ```sh
 cargo fmt --all -- --check
 cargo clippy --locked --all-features --lib --bins -- -D warnings
 cargo test --locked --all-features --all-targets --no-run
-cargo test --locked --no-default-features --features cli --bin vole cli::tests::
-cargo test --locked --no-default-features --features cli --lib invoke::foreground::tests::
-cargo test --locked --lib config::tests::
-cargo test --locked --lib geodata::tests::
 cargo test --manifest-path crates/vole-netstack/Cargo.toml --all-targets
 uv run --project scripts --locked python -m unittest discover -s scripts/tests
 uv run --project scripts --locked ruff check scripts
 uv run --project scripts --locked ruff format --check scripts
 ```
 
-Windows UWP bridge 的名称准入与匹配使用独立过滤器；下列测试仅处理 JSON、匹配策略
-和未注册的内存 `VpnPlugInProfile` 对象，不创建系统 VPN profile 或启动连接：
+宿主只运行明确的无网络对端回归，全目标测试仅编译。`invoke::tests::`包含监听器用例，
+不能整体在宿主执行。CI完整过滤器以[Tests workflow](../.github/workflows/test.yml)为准；
+CI使用Debug和继承Release优化的`ci-release`，正式产物使用标准`release`。
+Core Debug、Release 和 Quality 测试使用 Ubuntu 26.04；发布构建的 Linux runner 保持 Ubuntu 24.04。
+Windows的UWP/Wintun feature互斥，应明确选择后端，不使用`--all-features`。
+
+## 定向回归
+
+Unix TUN 适配器与数据面循环：`platform::tun_rs_io::tests::`、`tun_runtime::tests::` 使用 Unix socketpair 和内存 Dispatcher 检查包边界、批量收发、配置 MTU、取消与描述符所有权。Linux 仅在 `cfg(test)` 使用共享描述符适配，真实构造器仍拒绝非 TUN；Apple 保留 tun-rs 的包信息头路径。这些回归不代替真实 TUN 验收。
+
+Mieru UDP载体的TCP上传收尾：`outbound::mieru::udp::tests::mieru_udp_upload_`。
+五项纯内存回归使用真实编解码、可靠驱动与有界origin流，覆盖尾包首发成功后丢失、重传后EOF，
+以及待ACK时的Stop、取消shutdown future、同载体兄弟、立即Drop与对端Close；不代签真实TUN交付或RSS。
+
+关闭后的收包边界：`outbound::mieru::udp::tests::mieru_udp_closed_`，以实际首Close丢失、迟到ACK和origin EOF验证最后SID与同载体兄弟。
+`outbound::mieru::udp::balanced_driver_tests::mieru_udp_empty_sid_ready_invalid_preserves_idle_retirement_cancel_and_first_send_gate`
+覆盖首发前不收包、空会话持续无效输入下的原空闲退休及Stop；这些纯内存结果不替代真实TUN验收。
+`outbound::mieru::udp::tests::mieru_udp_first_close_loss_recovers_with_silent_peer_before_origin_eof`
+使用真实可靠驱动、codec与有界origin，覆盖首Close丢失且目标无后续DATA/ACK时的正常原站EOF；
+保留payload/hash与资源回收检查，不代签自然关闭故障归因或真实TUN压力表现。
+同模块的 `mieru_udp_close_retry_` 使用实际驱动验证无响应时最多两次补发，以及补发等待中的活动Stop与owner回收。
+同模块的 `mieru_udp_timeout_epoch_` 以真实codec验证TX拆批间ACK增长、旧flight超时惩罚归并、
+实际重发再次超时、fast/timeout优先级及未ACK许可回收；不代替真实TUN的丢失恢复和性能验收。
+`outbound::mieru::udp::tests::mieru_udp_saved_rto_` 通过同一物理owner的两类业务与真实codec，验证
+UDP发送时期限、TCP动态期限、失败发送不发布状态、快速重传及整write许可回收。
+
+smux 纯内存边界：`transport::smux::`，覆盖就绪 DATA 的单次 poll 预算、未读流与兄弟流、整帧分配预算、极小合法配额、本地关闭释放和远端 DATA→FIN 顺序。
+调度测试隔离 Tokio 的独立 cooperative allowance；这些测试不代替真实 TUN 性能验证。
+
+VMess／Trojan gRPC 延迟响应（纯内存 H2 duplex，Trojan 加内存 TLS）：启用
+`cli,interop-test` 后运行 `--test grpc_protocol_pool`。覆盖认证提交后跨越原期限的上传、
+迟到状态校验、Trojan 半关闭尾部，以及同一挂起读取的活动 Stop、对端自然退出和资源释放。
+Trojan-only 构建使用 `--no-default-features --features outbound-trojan --lib`；不代替真实 TUN 验证。
+
+VLESS 的同类边界使用 `--test vless_transports grpc_committed_vless_request_outlives_delayed_http_response`，
+同 target 的 `grpc_unresponsive_peer_keeps_original_setup_deadline` 检查未收到 SETTINGS 时仍受原期限约束；
+另以 `--test vless_lifecycle vless_all_handshakes_keep_the_original_deadline_and_join_cancelled_io`
+保留未完成建链的原期限；VLESS-only 编译使用 `--no-default-features --features outbound-vless --lib`，不添加 `cli`。
+
+客户端凭据与输入（纯内存）：`config::tests::client_uuid_`、
+`config::vmess::cipher_compatibility_tests::`、`config::hysteria2::p08_tests::hopping_`。
+实际映射凭据、端口跳跃和各协议数据面由真实 TUN 另验收。
+UDP 配置归一化（纯内存）：`config::mihomo_udp_tests::`，覆盖 VLESS `none` 使用
+XUDP 并保留 Vision、既有编码，以及 HY2/TUIC 的固有 UDP 能力和 SOCKS5 显式开启控制。
+仅经 `Config::parse_yaml` 检查公开配置与归一化结果，不初始化运行时，不代替真实 TUN 选路或协议互通。
+WS 查询和头预算：`config::vmess::websocket_query_tests::` 与内存 duplex 的
+`--test stream_foundations websocket_early_data_and_remaining_frames_keep_the_original_byte_order`；
+XHTTP 输入和自定义上行方法：`--test xhttp_config`、
+`--test xhttp_requests packet_metadata_and_upload_methods_are_sent_in_each_supported_location`。
+VLESS packetaddr 自主写使用实际 PacketUp Writer 的纯内存 H2 duplex：
+`--test vless_transports packetaddr_xhttp_memory::packetaddr_xhttp_keeps_first_flush_and_drives_last_datagram_without_post_ack`。
+覆盖请求头／首 DATA 的 POST 确认，以及最后单帧的独立推进、确认前接收和同步 Stop。
+已建立关联的部分写取消使用库过滤器
+`outbound::vless::datagram::tests::established_packetaddr_partial_write_resumes_by_send_or_receive_without_replay`，
+检查越过原建链期限后由 send／receive 恢复同帧、无重放及回复来源。
+这些内存 seam 不代替 H3、真实 TUN、进程 RSS 或压力验收。
+
+VLESS 私有 H2 split 活动租约：`--lib outbound::vless::outbound::active_h2_memory_tests::private_split_h2_shares_four_active_leases_and_stops_both_legs -- --exact`，以真实 duplex H2 两腿验证四租约共享、阈值扩容、兄弟关闭、末租约释放和同步 Stop/join；它不是实际 TUN 或 TLS wire 互通验收。
+REALITY 资格使用同模块的 `private_split_h2_reality_qualification_shares_four_active_leases_and_stops_both_legs`；
+`private_split_h2_reality_peer_stream_credit_opens_new_download_physicals` 检查低对端信用，
+Linux 的 `private_split_h2_reality_control_fallback_and_dialer_stop_do_not_take_cached_sender` 检查独立 TCP-control 与 Dialer/节点 Stop。
+这些纯内存测试从公开 REALITY 配置进入池选择，但测试 peer 不执行 REALITY/TLS 认证；真实 TUN 认证与 RSS 必须单独验证。
+
+Gun 增量读取（纯内存）：`transport::grpc::streaming_read_memory_tests::`。
+实际H2/有界duplex覆盖已校验前缀在消息尾到达前交付、拆分头与varint、空消息、
+取消恢复、原有合法编码、截断与trailers，以及半关闭尾读和Stop/join；不代表TUN压力结果。
+
+private h2mux PacketUp 两阶段写（纯内存）：
+`outbound::sing_mux::tests::private_packet_up_h2mux_hands_off_tail_and_keeps_strong_flush_fin_stop`
+经过真实私有包装器与 duplex H2，覆盖末块自主移交、强 flush、半关闭尾读和活动 Stop/join；
+`transport::h2_write::tests::coalesced_writer_bounds_markers_and_never_flushes_unencoded_or_failed_payloads`
+检查固定确认登记、未编码兄弟隔离及取消/失败唤醒。另保留既有 datagram 首帧强 flush/部分写取消回归。
+`transport::sing_mux::h2_driver::prequeued_flush_memory_tests::already_queued_large_data_progresses_before_pending_raw_flush_completes`
+检查真实 H2 已排队 DATA 在底层强 flush Pending 时继续推进；
+`transport::h2_write::productive_repoll_memory_tests::` 检查仅有正写入进度且有存活私有确认所有者时
+才重调度一次，以及普通写、零进度、失败、Drop 和强 flush 确认边界。
+这些测试不代替 XHTTP/H3、真实 TUN、内存或容量验收。
+
+共享 H3 PacketUp 有界响应重叠（纯内存）：`transport::xhttp::h3_packet_overlap_memory_tests::`，
+经过归一化节点和实际 factory／H3 driver，检查单正文回收、两响应槽、乱序确认缺口、低流信用、早错误、FIN／Drop 和同步 Stop。
+`transport::xhttp::packet_up::overlap::lease_memory_tests::` 检查真实 Bytes 最后引用释放的通知、同一 Vec 回收及 closed／Weak 所有权。
+这些检查不代替真实 TUN、RSS、吞吐或平台验收。
+
+规则输入与 selector 元数据（纯内存）：`config::name_regex::tests::`、
+`config::domain_regex::tests::`、`config::rule_provider::tests::classical_`、
+`routing::tests::in_name_`。覆盖命名/数字捕获编号、IN-NAME 和混合 classical 条件。
+
+TFO 纯内存策略与生命周期：
+`config::functional::tests::node_tfo_is_explicit_and_does_not_inherit_across_proxy_chain`、
+`config::providers::tests::provider_tfo_override_preserves_false_and_materializes_exact_node_policy`、
+Linux `dialer::server_tcp::tests::` 和 `dialer::fast_open::tests::`。
+`dialer::fast_open::gate::real_tun_private_tfo_gate` 为显式 ignored 容器驱动，
+实际 SYN-data、首读/空写/半关闭、源绑定/protect、建链期限与 Stop 须由 Linux 真实 TUN 验证。
+这些内存过滤器不证明内核 Fast Open 或其它平台行为。
+
+MPTCP / TCP Brutal 纯内存过滤器：`--lib mptcp`、`config::functional::tests::`、
+`config::sing_mux::tests::`、`transport::sing_mux::brutal::tests::`、
+Linux `dialer::tcp_control::tests::`；池与生命周期另用下方 sing_mux 集成回归。
+sing-mux 懒响应与首业务写入期限：`transport::sing_mux::tests::`，覆盖纯上传期间
+延迟 H2 headers/status、空/未完成写入保留原期限，以及迟到状态校验与半关闭。
+双子流、出口约束、TCP 回退、TFO、模块及真实参数/发送侧生效、对端协商与 Stop
+须在隔离 Linux 真实 TUN 中另验；1 / 3 Gbps 压力及平台、真机结果分别记录。
+
+TUN 网络计划（纯内存，不查询宿主路由或创建接口）：`config::tun_network::tests::`、
+`platform::linux_network::plan::tests::`、`platform::linux_network::tests::`；
+Linux 目标的报文编码：`platform::linux_network::netlink::tests::`。
+ICMP 配置的纯内存过滤器：`config::tests::tun_icmp_options_`；Linux 覆盖默认/零值、
+实际秒值、禁用与现有重连门禁，以及负值/时钟范围/整数溢出拒绝；其他平台验证未知字段拒绝。
+Linux Echo 所有权用 `tun_runtime::echo::tests::`，netstack 编解码用 `echo::tests::`；
+不打开物理 ping socket，不代替实际 TUN、物理源、校验和、权限与 Stop 验证。
+被动 TCP 的 PMTU 与兄弟流：netstack 集成过滤器
+`passive_tun_pmtu_resegments_only_live_sent_tcp_and_preserves_siblings`。
+
+Linux Unix Controller 的配置与共享鉴权（不绑定 socket）：
+`config::controller::tests::controller_unix_`、
+`controller::tests::local_context_shares_limits_and_bypasses_only_local_rest_and_websocket_auth`、
+`invoke::foreground::overrides::tests::unix_override_`、
+二进制 `cli::tests::unix_controller_flag_only_transports_the_explicit_text_value`。
+实际文件权限、绑定冲突、对象替换、drop/Stop 清理在隔离 Linux 真实 TUN 夹具验收。
+Linux socket 创建权限、路径替换与严格 umask 的内核回归使用 `controller::unix::tests:: -- --ignored --test-threads=1`，
+仅在隔离 Linux 容器运行；它们检查实际 Unix socket 与本地 IPC，不代替真实 TUN 或完整 Controller 业务验收。
+管理 mark 另选 `config::controller::tests::controller_mark_`、
+`invoke::foreground::overrides::tests::mark_override_` 和二进制
+`cli::tests::controller_mark_flag_`；实际管理回复包 mark 在同一 Linux 夹具核对。
+
+Controller 推送（纯内存 duplex，无网络监听）：`controller::websocket::tests::`；
+安全传输/CORS：`controller::secure_tests::`；DNS 展示：`controller::dns::tests::`；
+实例完整日志/动态级别过滤：`logging::tests::`。
+组固定清除：`routing::proxy_group::tests::automatic_fixed_clear_uses_existing_health_without_probe`。
+这些过滤器不代替真实 TUN 计数与 Stop 验证。
+临时规则控制另选 `routing::rule_disable::tests::`、`controller::rules::tests::`、
+`controller::tests::small_json_body_`、
+`routing::program::tests::disabled_main_rules_skip_subprograms_and_keep_the_decision_snapshot`、
+`routing::diagnostics::tests::rule_switch_view_shares_only_small_state_with_the_program` 和
+`runtime::providers::tests::file_refresh_publishes_valid_members_and_preserves_old_sessions`。
+
+规则重匹配的配置与失败关闭（纯内存）：`config::functional::tests::rematch_`、
+`config::measure::tests::measurement_rejects_routing_only_rematch_nodes`、
+`routing::tests::rematch_name_predicate_is_trimmed_nonempty_and_case_sensitive`、
+`outbound::control::tests::`。
+运行时消费者与续跑另选 `routing::program::tests::rematch_`、`routing::rematch::tests::`、
+`routing::dispatcher::tests::rematch_`、`dns::runtime::tests::rematch_`；这些用例只使用内存
+Dispatcher 和合成端点，不建立监听器或发送网络报文，不代替真实 TUN 组切换验收。
+
+功能出站（纯内存）：`config::functional::tests::`、`outbound::dns::tests::`、
+`outbound::reject::tests::`；直连解析角色接线：
+`dns::runtime::tests::runtime_dns_separates_bootstrap_proxy_direct_and_hosts`。
+
+进程规则与原始元信息（纯内存，无系统查询）：`config::process::tests::`、
+`process::tests::`、`process::linux::tests::`（Linux）、`process::macos::tests::`（macOS）、
+`routing::program::tests::process_cursor_is_lazy_once_and_keeps_dns_and_subrule_progress`、
+`routing::program::tests::classical_process_provider_resumes_without_selector_side_effects`、
+`dialer::tests::process_inspection_small_concurrency_preserves_identity_and_joins_stop`。
+共享 socket 初始化槽占满的身份查询截止：`dialer::tests::process_inspection_shared_socket_capacity_has_its_own_deadline`。
+
+Linux 原生 socket 初始化的许可、取消与 Stop（纯内存）：
+`dialer::native_init_memory_tests::typed_admission_bounds_cancelled_waiters_and_waits_for_stop`。
+`dialer::native_init_fd_tests::` 默认忽略，包含真实 socket 创建与 bind；仅在隔离 Linux
+容器内，借用真实 raw-IP TUN fd 后显式运行。它验证初始化调度、选项、回调与 fd 释放，
+不代表 TUN 业务或压力通过；后者使用普通 CLI 的独立真实 TUN 验证。
+
+对受影响范围选择过滤器，不逐次重跑整张表。下列库测试使用：
+
+```sh
+cargo test --locked --no-default-features --features cli,interop-test --lib <过滤器>
+```
+
+| 范围 | 过滤器 | 覆盖重点 |
+| --- | --- | --- |
+| 配置 | `config::tests::` | YAML准入、图、字段单位与边界 |
+| 物理出口 | `config::egress::tests::`、`config::dns::upstream_options_tests::`、`platform::linux_network::native::tests::`、`dialer::tests::egress_clones_keep_the_protection_and_stop_owner` | 全局/节点继承、Provider整数覆盖、DNS名称优先与池身份、auto-route标记共存和共同Stop owner |
+| GeoData | `geodata::tests::` | 合成DAT/MMDB、selector、更新发布和取消 |
+| 资源与Provider | `config::rule_provider::`、`runtime::providers::tests::`、`resource::cache::tests::`、`resource::provider_input::tests::`、`resource::http::tests::` | 域名紧凑索引、MRS、URI/Base64/AGE候选、流式gzip与认证隔离、失败保留与旧代资源 |
+| 策略组 | `routing::proxy_group::tests::`、`routing::balance::tests::` | 选择、容差、恢复和负载均衡 |
+| DNS | `dns::cache::tests::`、`dns::runtime::tests::stale_refresh_`、`dns::runtime::tests::dns_fallback_`、`dns::runtime::tests::resolve_ipv6_` | 缓存、过期答复/后台预算/退避/epoch/Stop、双栈、竞速和取消 |
+| 入口嗅探 | `tcp_sniffer::tests::`、`tcp_sniffer::http2::tests::`、`udp_sniffing::tests::`、`tun_runtime::tests::quic_` | HTTP1/HTTP2目标、HPACK与完整前缀回放；共享QUIC域名键、ECH、预算与重组 |
+| QUIC与H3 | `transport::quic::`、`transport::quinn_h3::tests::`、`transport::quiche_h3::tests::`、`dns_quic_` | 官方窗口、真实内存QUIC、DATA读取背压、请求取消、兄弟请求及Stop |
+| XHTTP与XUDP | `transport::xhttp::`、`transport::h2_write::tests::`、`xudp::tests::` | 正文缓冲共享、标量部分写入、flush确认、计时与Stop |
+| TLS与ECH | `security::context::tests::`、`security::ech::tests::`、`dns::runtime::ech_tests::` | 证书与身份、内存TLS、动态ECH来源 |
+| TrustTunnel／Mieru／MASQUE | `trusttunnel`、`mieru`、`masque_` | 真实编解码、信用/背压、复用、单流关闭及同步Stop |
+| 有界队列与内存策略 | `routing::datagram_ready::tests::`、`managed_udp_connections_`、`allocator_relief`、`platform::process_memory::tests::` | 就绪轮询、排空、取消和单次回收 |
+| UDP 共享与隔离 | `managed_udp_connections_`、`fake_ip_routing_preserves_tcp_names_and_distinct_udp_reply_addresses`、`quic_override_resolves_new_domain_and_restores_udp_response_target` | 同源多目标、固定目标、逐目标关闭与旧回复隔离，支持共享的底层仍保留 Fake-IP/嗅探还原隔离 |
+| TUN 响应背压 | `tun_runtime::tests::backpressured_udp_response_handoff` | 满队列下每源至多暂持一包、双向推进及取消 |
+| UoT | `outbound::uot::tests::` | 半帧取消后继续、v2首部、原期限、单槽响应与Stop |
+| VMess 响应边界 | `outbound::vmess::header::delayed_response_memory_tests::`、`outbound::vmess::stream::tests::`、`outbound::vmess::outbound::polled_datagram_memory_tests::`、`--test vmess_lifecycle` | 官方延迟响应向量、HTTP迟到响应与节点取消、提交前期限、响应认证、收发计数回绕、加密 packetaddr 多目标帧与回包来源、跨回绕连续交付、认证错误关闭、逐字节轮询、读写交错取消与关闭 |
+| SS2022 | `outbound::shadowsocks::datagram::tests::` | 官方内存对端、三种 cipher、空 UDP/EIH、认证后 cipher 准入、取消与轮换 ID、重放边界 |
+| Trojan UDP | `routing::dispatcher::tests::managed_trojan_udp_`、`--test trojan` | 真实内存帧、同源多目标共享、来源及关闭后旧回复隔离、取消与流释放 |
+| TUIC UDP | `outbound::tuic::wire::tests::`、`outbound::tuic::datagram::tests::` | 按声明长度交付、分片满表下新包前进、资源界限和来源隔离 |
+| SOCKS5 UDP | `outbound::socks5::tests::` | 真实内存握手与帧、同源多目标复用、异源隔离、关闭重建后旧回复隔离、relay 来源和嵌套预算 |
+| HTTP 编译与执行 | `http_processing::` | 严格规则与 provider、URL/头/正文、压缩与 JSON Patch、选择性 TLS、H1/H2 和有界回退 |
+| HTTP Invoke | `invoke::http::`、`resource::http_control::tests::` | 有界私密输入、离线演算、来源未准备、下载 dispatcher 接线、单一准入、取消与 Stop 收尾 |
+| HTTP 在线配置 | `runtime::providers::apply::http_tests::` | 活动快照继承、变更要求重连、旧候选保留 |
+| CLI前台 | `invoke::foreground::tests::`、`invoke::foreground::input::tests::` | 文件/stdin、原生路径、显式 HTTP 文件、CA 读取边界、信号取消及清理 |
+
+独立集成回归按目标运行，例如：
+
+```sh
+cargo test --locked --no-default-features --features cli,interop-test --test tuic_memory
+cargo test --locked --no-default-features --features cli,interop-test --test grpc_pool --test grpc_protocol_pool
+cargo test --locked --no-default-features --features cli,interop-test --test sing_mux
+cargo test --locked --no-default-features --features cli,interop-test --test shadowsocks_backpressure --test shadowsocks_uot
+cargo test --locked --no-default-features --features cli --bin vole cli::tests::
+cargo test --locked -p vole-blake3-raw --test derive
+```
+
+内存QUIC/H3对端通过受控DatagramTransport交换真实包，不绑定宿主监听器。
+`transport::quiche_h3::native_ready_batch_memory_tests::` 验证真实wire帧的共享排空额度、已轮询FIN/RESET、兄弟流和可靠body前缀；不代替完整driver与TUN验收。
+netstack的`active_tcp_shutdown_drains_accepted_tail_before_fin_without_prior_acks`与`active_tcp_drop_drains_accepted_tail_before_fin_without_prior_acks`使用既有缓冲和真实ACK，验证未确认写入的前缀、FIN排序及最终释放。
+`stack::tests::failed_fast_retransmit_survives_another_socket_filling_tx`使用两个真实内存TCP socket与重复ACK，
+验证兄弟socket占满输出后，失败的快速重传在容量恢复时仍可立即重试；不启动网络对端或TUN。
+SS2022 的严格官方 TCP codec 回归可单独选择 `official_tcp_codecs_all_ciphers_` 和
+`tcp_response_header_time_salt_auth_and_fragmentation_follow_official_codec`；不要在宿主整体运行
+`outbound::shadowsocks::tests::`，其中还包含监听器用例。
+Mieru回归保留TCP/UDP分池、慢读背压、单槽交接、终态传播、接收分配复用和未读响应下的Stop。
+`outbound::mieru::tcp::udp_send_credit_memory_tests::` 用实际Client::create与有生命周期计数的
+内存DatagramTransport验证默认LOW UDP Associate载体共享96 KiB发送信用；非默认预算、
+其他业务/模式/载体不变，并组接两个真实RawStream验证共享信用、原FIFO2及取消/Stop回收。
+两笔32 KiB写入后仍有32 KiB信用；第三笔写被原FIFO2阻塞，不冒充96 KiB已耗尽。
+`outbound::mieru::udp::tests::mieru_udp_send_credit96_two_sids_keep_fragment_leases_until_their_acks`
+通过原可靠分片与真实codec输出验证部分/重复ACK、first-send与独立SID许可退休，原TX8不变。
+这些用例不创建socket、DNS、监听器或网络对端，不证明真实TUN性能或RSS。
+
+`outbound::mieru::tcp::udp_admission_memory_tests::` 使用原命令通道、完成回执和字节许可，
+验证保守四写 UDP 准入、第五笔发送屏障、就绪错误、空写、部分记录取消和 NoWait 收尾；TCP 写入保留原等待边界。
+`outbound::mieru::udp::tests::mieru_udp_admission_depth4_` 另通过实际编解码与可靠驱动，验证 FIFO 分片、累计ACK许可释放和延迟Close拒绝。
+`outbound::mieru::tcp::udp_pool_memory_tests::` 使用真实池预留、RawStream、原有界命令通道与字节许可，
+覆盖繁忙TCP载体与UDP业务隔离、UDP同业务活动复用、许可未退休时背压及Stop释放；不启动物理驱动。
+同模块的 `least_load_` 检查真实State与Reservation对两载体复用选择的影响，保留随机tie起点、
+原新建桶及非LOW/非UDP载体行为；不测量网络负载或RSS。
+新增多目标真实 codec 回归使用 `outbound::mieru::packet_routing_tests::`、
+`outbound::trusttunnel::packet::tests::`、`outbound::vmess::header::datagram_memory_tests::`、
+`wireguard_memory_shared_udp_targets_cancel_and_close_independently` 与
+`masque_ip_memory_shared_udp_leases_cancel_and_close_independently`。
+HY2 透明混淆/pacer 传递使用
+`salamander_memory_and_pacer_preserve_address_sharing_owned_send_and_close`。
+它们覆盖逐包地址、取消与独立关闭，不以能力布尔断言替代真实帧和所有权验证。
+GeoData、AGE、Provider和缓存测试使用合成输入、公开固定向量、内存流及临时文件。
+fake-IP 热更新使用 `runtime::tests::live_dns_`，经实际运行时组装检查 DNS 停用／重开、
+A/AAAA 内存 wire，以及临时 redb 的映射、游标加载和持久 owner 复用，不创建网络 socket。
+这些局部预算与行为检查不证明进程RSS、网络吞吐或真机内存达标。
+命名指纹准入使用 `config::fingerprint_tests::`；标准 H2 SETTINGS/ACK 与 ALPS 可选性使用
+`selected_profiles_use_standard_h2_settings_when_the_server_supports_alps`（内存 TLS/H2）。
+REALITY 允许经典/混合协商的配置与两腿真实 share 使用
+`--test reality_config --test security_capabilities`（无网络 IO）。
+
+协议输入见[protocols](protocols/README.md)，ClientHello输入见[fingerprints](fingerprints/README.md)。
+脚本回归验证产物布局、后端/ABI选择和归档；真实编译与原生加载分别验证。
+
+## Windows原生检查
+
+名称选择只使用JSON和未注册的内存profile对象，不创建系统VPN或启动连接：
 
 ```sh
 cargo test --locked --no-default-features --features ffi,windows-uwp --lib windows::host::tests::
 ```
 
-构建 UWP DLL 后，可在未打包的 Windows 进程中执行真实 C ABI 的 COM 生命周期回归：
+构建UWP DLL后，在同架构Windows/Python上执行C ABI与COM所有权检查：
 
 ```sh
 python scripts/check_windows_com.py --dll dist/windows/arm64/uwp/vole.dll
 ```
 
-此命令只在原生 Windows ARM64 执行。原生 x64 主机使用本机的 Python 和
-`dist/windows/x64/uwp/vole.dll`。宿主、Python 和 DLL 必须同架构；不得通过模拟运行跨架构验证。
-该脚本只需 Python 标准库。CI 的各个 Windows job 通过 `actions/setup-python` 安装本架构的
-Python，直接运行此检查，仅验证各自构建的产物。
-四个独立子进程覆盖未初始化线程连续查询、调用方 MTA 的保留与释放、短线程退出/切换和 STA 拒绝，
-同时检查显式初始化计数与 `VoleFree` 响应所有权。测试先用 Win32 确认没有包身份，
-仅查询环境/状态并断言包身份错误，不读取 VPN profile、启动连接或访问网络。
-父进程为每个用例设置超时。UWP 发布构建在上传归档前执行这些检查；通过不代表包内验收。
-
-在 Windows 上，`windows-uwp` 与 `windows-wintun` 互斥，编译与 Clippy 应明确选择
-所测后端而非 `--all-features`。名称选择仍需已安装包验证，不以对象级测试代替。
-
-宿主只执行明确的纯内存过滤器；全目标使用 `--no-run`。
-`invoke::tests::` 含监听器用例，不可整体在宿主执行；可执行过滤器以
-[Tests workflow](../.github/workflows/test.yml) 为准。
-协议独立向量见 [protocols](protocols/README.md)，ClientHello 输入见 [fingerprints](fingerprints/README.md)。
-
-脚本测试保留平台文件输出、Windows 后端选择、Android ABI/runtime、Apple 切片、
-真实归档读写，以及 Android JNI 导出与 Apple 日志命名空间的源码契约检查。
-外部编译命令由夹具替代，原生编译由 CI 平台矩阵执行；源码检查不替代 JNI 加载或设备验证。
-CI 的核心回归分别使用 Debug 和 `ci-release`；后者继承 Release 优化并关闭 LTO，
-正式产物使用标准 `release`。Quality 负责格式、Clippy、feature 编译和依赖来源检查。
+x64使用`dist/windows/x64/uwp/vole.dll`。四个独立子进程覆盖线程初始化、MTA所有权、
+线程切换、STA拒绝和响应释放；仅查询未打包环境，不访问VPN或网络。
+通过不代表包内、Wintun或设备验证。
 
 ## 网络与压力
 
@@ -63,5 +291,126 @@ container-benchmark stress --source vole=/path/to/Vole
 container-benchmark compare --source vole=/path/to/Vole
 ```
 
-所有服务端遵守 [容器隔离规则](../docs/testing-isolation.md)。用例和测量参数由 benchmark
-维护，结果记录在对应运行或 PR 中；[验收边界](../docs/acceptance.md) 区分编译、互通与设备验证。
+所有网络业务经真实TUN，Controller仅作管理入口；服务端与原站遵守[容器隔离](../docs/testing-isolation.md)。
+`interop --list`可离线列举当前用例。测试工具维护负载、对端和计量，Vole不依赖其checkout编译。
+互通、压力、平台编译、原生调用与真机验证的结果分别记录，见[验收边界](../docs/acceptance.md)。
+
+
+在线配置的纯内存定向回归：`resource::config_apply::tests::`、`config::live_update::tests::`、`controller::configs::tests::`、`runtime::providers::apply::tests::`、`configuration_candidate_reads_bundle_without_persisting_body_or_metadata`、`configuration_publication_stops_late_old_tree_hint_refill`。覆盖单候选许可、异步／外部线程结果交付、取消后持许可至收尾、严格 API 字段、启动资源拒绝、坏候选保旧图、新 provider 模板延续、候选不写活动资源，以及退休 DNS 树不能回填活动提示。真实 TUN 见证由 benchmark 夹具执行，内存回归不代替平台或业务互通。
+
+共享流式安全身份的纯内存检查（不启动宿主监听器）：
+
+```shell
+cargo test --locked --lib config::security::tests::
+cargo test --locked --lib security::client_identity_tests::
+```
+
+配置检查覆盖具名协议的安全模式、传输限制、XHTTP 两腿继承和 cover mTLS 文件预算；
+内存 IO 检查共享连接器握手取消和每次握手的独立状态。真实对端互通另行验收。
+
+
+SS2022 流式插件的纯内存过滤器：`config::shadowsocks_plugin::tests::`、
+`transport::ss_framed::tests::`、`transport::smux::`。
+它们使用内存流，不启动网络对端；真实TUN互通与压力仍由外部夹具单独验收。
+
+HY2 共享握手的纯内存所有权/期限/同步 Stop：`outbound::hysteria2::outbound::shared_handshake_memory_tests::`。
+
+文件 mTLS 身份的纯内存 TLS/临时文件回归：
+`security::tls::tests::identity_rotation_memory_tests::`（启用 `outbound-http`；命名后端再启用 `tls-fingerprint`）、
+`security::identity::tests::` 与 `config::identity_files::tests::`。
+覆盖连续换代/旧连接与票据隔离、坏文件保留和读取失败恢复、来源独立、取消/Stop、输入预算及原生材料按需分配；
+不创建监听器，实际 TUN/QUIC 轮换仍由容器夹具验收。
+
+HY2 Gecko/Realm 的配置和内存wire回归按 `gecko_`、`realm_` 中列出的memory-only名称定向执行；
+TUIC ClientHello 使用 `tuic_disable_sni_changes_real_quic_hello_without_changing_verification_policy`。
+不得将包含网络peer的整个outbound模块直接作为宿主测试执行。
+
+## HTTP 处理与 Invoke
+
+`http_processing::` 使用合成规则、临时文件、内存 dispatcher 和 duplex，不创建宿主监听器。
+规则入口采用 `http-ports`、`mitm`、`rewrite-providers`、`rewrite` 四个顶层字段，
+覆盖严格类型与数值、URL 捕获与替换、请求／响应头、文本与 JSON Patch、压缩、正文预算及整阶段回退。
+provider 回归覆盖启用引用的有序展开、关闭引用零 I/O、来源身份、实际 payload 快照、
+失败保留、缓存原子发布与取消。规则与私密 CA 的完整合同见 [HTTP 处理](../docs/http-processing.md)。
+
+H1/H2 内存对端覆盖共享 TUN/mixed/CONNECT 适配、预读、最终目标单次选路、
+原始 URL 选择、跨 origin 凭据隔离、Expect 早响应、流式背压、半关闭、截断拒绝与取消。
+选择性 TLS 同时检查 CA/私钥匹配、叶证书 AKI、证书缓存计费与逐 authority 授权。
+未命中正文规则时不收集完整正文；命中后只在有界工作区完成处理，失败恢复原始阶段内容。
+
+`invoke::http::` 检查私密输入在 JSON Value 分配前的准入与 `testHttp` 离线演算。
+离线演算不下载、不读 provider、不生成证书；没有实际来源时报告未准备，
+没有方向样本时仅报告规则被选中，不声称正文已验证。重写总开关关闭仍可演算启用规则，
+真实 HTTPS 授权与 CA 条件单独判断。
+
+`resource::http_control::tests::` 检查指定 dispatcher 的传递、共享配置许可、
+Store 争用及取消后等待下载收尾；`invoke::http::` 同时检查 idle refresh 与实例创建互斥。
+`runtime::providers::apply::http_tests::` 检查普通路由更新保留活动 HTTP 快照，
+HTTP 内容或来源上下文变更要求显式重连。失败恢复的策略组选择另选
+`recovery_snapshot_keeps_current_group_member_without_selection_persistence`。
+
+显式配置传递另选 `main_config_and_provider_rebuild_preserve_the_addendum_until_explicit_clear`、
+`update_http_addendum_preserves_optional_clear_and_its_separate_byte_limit` 和二进制
+`cli::tests::http_addendum_option_only_transports_an_explicit_native_path`。
+`resource::paths::tests::` 与
+`resource::cache::tests::authorized_provider_roots_read_file_sources_and_write_only_http_caches`
+检查原生授权根、符号链接边界、file 读取与 HTTP 缓存写入分离；候选回归同时检查授权上下文继承。
+`resource::cache::tests::provider_metadata_requires_bounded_regular_files` 检查 sidecar 大小与 FIFO 拒绝，坏 metadata 不阻止有效正文读取。
+`invoke::foreground::overrides::tests::` 检查具体 Controller 覆盖、空值保留及沿用地址解析器；
+`invoke::foreground::input::tests::` 检查 Base64 来源优先、标准 padding、认证 AGE 固定向量、
+输入预算、取消、单份有效输入复用与主文件重读；
+`runtime::providers::apply::http_tests::routing_updates_keep_active_http_and_changed_http_requires_reconnect`
+同时检查 foreground 内部模板输入共用候选工作器、坏候选保留与启动资源变化拒绝。`invoke::tests::owned_invoke_uses_the_shared_strict_and_runtime_thread_boundaries`
+检查 CLI 的 owned 请求与借用请求共用严格准入和重入边界。
+`invoke::foreground::tests::` 检查显式文件与路径、校验不初始化、不自动加载 HTTP 文件、
+MITM 关闭不读 CA、无 HTTP 配置的 CA 参数提前拒绝，以及启动期信号取消后 join 清理。
+Windows 平台另编译 `snapshot_identity_and_readback_include_the_http_addendum`，
+`snapshot_preserves_valid_http_content_expanded_beyond_one_mibibyte` 和
+`snapshot_json_budget_counts_actual_escaping_before_allocation`，检查规则实际内容、
+独立展开预算、JSON 转义计数与私密材料的会话快照边界。
+无默认特性的纯内存回归选择
+`http_documents_without_adapter_are_rejected_before_resource_preparation`；
+`ca_identity_is_public_der_and_does_not_require_the_http_adapter` 检查公开证书身份不依赖 HTTP 适配器，
+启用 HTTP 后另选 `ca_identity_matches_runtime_authority_without_weakening_key_validation` 检查运行期密钥校验。
+
+HTTP/1 早响应与空正文 Upgrade 的定向内存回归：`inbound::http::server::early_final_memory_tests::`；不运行包含宿主 socket 的整个入站测试模块。
+上传完成后的响应等待、静默上限与首字节后绝对读头期限：`inbound::http::server::response_deadline_memory_tests::`；使用 paused Tokio clock 和内存 duplex。
+
+这些回归不证明真实 TUN 互通、进程 RSS、吞吐、设备信任安装、系统 VPN 或平台真机行为；
+对应验收分别由容器夹具、平台构建和设备测试完成。
+
+IP4P 纯解码与严格配置回归：`config::ip4p::tests::`；不创建 socket 或解析网络名称。
+
+IP4P 接点纯内存回归：`dns::resolution::ip4p_tests::`、
+`dialer::tests::connected_ip4p_conversion_precedes_family_and_source_binding_only_at_opted_in_seams`、
+`dialer::tests::ip4p_loopback_mapping_cannot_acquire_a_new_literal_exemption`、
+`outbound::connector::tests::ip4p_udp_node_endpoint_retains_chain_identity_and_uses_actual_reply_peer`。
+这些测试不建立网络 socket；真实 TUN 的 TCP/SS2022/SOCKS5/WireGuard 及 UWP 平台路径单独验收。
+
+TUIC 冷连接的公开 API 门禁（纯内存、无票据缓存或网络 socket）：
+`tuic_cold_connection_cannot_publish_an_early_quinn_handle_without_resumption`。
+它检查仅启用 early-data 不能取得 Quinn 的早期客户端连接，不代表恢复连接或服务端验收。
+
+Linux 受控物理 QUIC 的纯内存过滤器：`physical_quic_memory_` 与
+`physical_quic_switches_are_session_scoped_strict_and_keep_mihomo_defaults`。
+检查分段的逐包/总字节预算、来源与显式源覆盖拒绝、完整接收边界、默认值与严格字段；
+不创建 socket，不证明真实 ECN/GSO、protect、RSS、吞吐或设备行为。
+`transport::quic::physical::tests::physical_quic_memory_revocation_releases_io_with_retained_broadcast_pollers`
+在纯内存中检查多等待者广播、注册交错与持有已退役句柄时释放 IO。
+`physical_quic_memory_concurrent_read_leases_delay_retirement_until_both_release` 另验两个并发读者、
+退役等待双方释放及资源只析构一次。显式 ignored 的
+`transport::quic::physical::gate::real_tun_native_udp_retirement_gate` 仅供隔离 Linux
+容器以真实 TUN 验证适配器的 fd、资源计数和 Stop；常规内存回归不得执行该网络门禁。
+
+MASQUE H2 capsule已就绪合批的纯内存过滤器：
+`outbound::masque::ip::h2_output_batch_memory_tests::` 与
+`transport::masque_codec::tests::masque_capsule_append_fit_and_rejection_preserve_the_existing_wire_prefix`。
+使用实际pump、内存PacketStream与codec验证合并、单包及时提交、大包与单溢出帧顺序、
+TTL、取消安全、强flush背压及错误；不创建网络socket，不代替真实TUN与RSS验收。
+
+WireGuard 输出准入的纯内存过滤器：`outbound::wireguard::engine::full_handoff_memory_tests::`。
+使用真实 netstack 和原 32 槽队列，检查单 peer 保留满队列包至释放一槽、取消后资源释放，
+以及多 peer 的有界交接与兄弟 peer 进展。
+
+WireGuard 路由表的纯内存过滤器：`outbound::wireguard::routes::tests::`。
+经实际配置校验和路由表构造检查空表、单前缀、主机边界、双栈隔离、最长前缀及同前缀最后声明的所有者。
diff --git a/tests/datagram_foundations.rs b/tests/datagram_foundations.rs
index 82f5871..9745681 100644
--- a/tests/datagram_foundations.rs
+++ b/tests/datagram_foundations.rs
@@ -3,11 +3,6 @@ use vole::{dispatch::DatagramBudget, packet::IpVersion};
 #[cfg(feature = "outbound-shadowsocks")]
 #[tokio::test]
 async fn shadowsocks_budget_accounts_for_cipher_headers_and_identity_chain() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-DATAGRAM",
-        "shadowsocks_budget_accounts_for_cipher_headers_and_identity_chain",
-    );
     use base64::{Engine as _, engine::general_purpose::STANDARD};
     use bytes::Bytes;
     use vole::{
@@ -36,7 +31,7 @@ async fn shadowsocks_budget_accounts_for_cipher_headers_and_identity_chain() {
                 port: address.port(),
                 cipher,
                 password,
-                shadow_tls: None,
+                plugin: None,
                 udp_over_tcp: false,
             },
             UpstreamPath::direct(
@@ -85,11 +80,6 @@ async fn shadowsocks_budget_accounts_for_cipher_headers_and_identity_chain() {
 #[cfg(feature = "outbound-socks5")]
 #[tokio::test]
 async fn socks5_budget_retains_distinct_payload_and_envelope_limits() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-DATAGRAM",
-        "socks5_budget_retains_distinct_payload_and_envelope_limits",
-    );
     use bytes::Bytes;
     use tokio::io::{AsyncReadExt, AsyncWriteExt};
     use vole::{
@@ -126,6 +116,7 @@ async fn socks5_budget_retains_distinct_payload_and_envelope_limits() {
         });
         let outbound = Socks5Outbound::new(
             &Socks5OutboundConfig {
+                tls: None,
                 address: "127.0.0.1".into(),
                 port: endpoint.port(),
                 username: None,
@@ -177,11 +168,6 @@ async fn socks5_budget_retains_distinct_payload_and_envelope_limits() {
 
 #[tokio::test]
 async fn direct_budget_rejects_large_sends_and_drops_oversize_responses() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-DATAGRAM",
-        "direct_budget_rejects_large_sends_and_drops_oversize_responses",
-    );
     use bytes::Bytes;
     use vole::{
         dialer::Dialer,
@@ -224,11 +210,6 @@ async fn direct_budget_rejects_large_sends_and_drops_oversize_responses() {
 
 #[test]
 fn layered_directional_budgets_account_for_ip_headers_and_exact_minima() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-DATAGRAM",
-        "layered_directional_budgets_account_for_ip_headers_and_exact_minima",
-    );
     let ipv4 = DatagramBudget::from_path_mtu(1500, IpVersion::V4).unwrap();
     let ipv6 = DatagramBudget::from_path_mtu(1500, IpVersion::V6).unwrap();
     assert_eq!((ipv4.transmit(), ipv4.receive()), (1472, 1472));
diff --git a/tests/ech_config.rs b/tests/ech_config.rs
index e6cad82..9f74ad2 100644
--- a/tests/ech_config.rs
+++ b/tests/ech_config.rs
@@ -41,12 +41,7 @@ fn parse(node: serde_json::Value) -> vole::Result<VlessOutboundConfig> {
 
 #[test]
 fn static_ech_builds_both_tls_backends_without_dns_or_io() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "static_ech_builds_both_tls_backends_without_dns_or_io",
-    );
-    for profile in ["none", "chrome", "chrome120", "firefox", "safari"] {
+    for profile in ["none", "chrome", "firefox", "safari", "ios", "random"] {
         let mut input = node();
         input["client-fingerprint"] = json!(profile);
         let config = parse(input).expect("static ECH must normalize without a DNS entry point");
@@ -56,38 +51,31 @@ fn static_ech_builds_both_tls_backends_without_dns_or_io() {
 }
 
 #[test]
-fn static_ech_is_strict_and_never_enables_dynamic_lookup() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "static_ech_is_strict_and_never_enables_dynamic_lookup",
-    );
+fn ech_options_validate_types_and_static_configuration_takes_priority() {
     for ech in [
         json!(null),
         json!([]),
         json!("private-config"),
         json!({"enable":null}),
         json!({"enable":"true"}),
-        json!({"enable":true}),
-        json!({"enable":true,"config":""}),
         json!({"enable":true,"config":42}),
         json!({"enable":true,"config":"private-config"}),
-        json!({"enable":true,"config":STANDARD.encode(ech_list()),"query-server-name":"private.invalid"}),
-        json!({"enable":false,"config":STANDARD.encode(ech_list())}),
+        json!({"enable":true,"query-server-name":null}),
+        json!({"enable":true,"query-server-name":42}),
+        json!({"enable":true,"query-server-name":"invalid name"}),
     ] {
         let mut input = node();
         input["ech-opts"] = ech;
         let error = parse(input).unwrap_err().to_string();
         assert!(!error.contains("private-config"));
         assert!(!error.contains("private.invalid"));
-        let mut input = node();
-        input["network"] = json!("xhttp");
-        input["xhttp-opts"] = json!({"mode":"stream-up", "download-settings":{
-            "ech-opts":{"enable":true,"query-server-name":"private.invalid"}
-        }});
-        assert!(parse(input).is_err());
     }
-    for ech in [json!({}), json!({"enable":false}), json!({"config":""})] {
+    for ech in [
+        json!({}),
+        json!({"enable":false}),
+        json!({"config":""}),
+        json!({"enable":false,"config":"unused-invalid-Base64"}),
+    ] {
         let mut input = node();
         input["ech-opts"] = ech;
         let SecurityConfig::Tls(tls) = parse(input).unwrap().security else {
@@ -95,18 +83,26 @@ fn static_ech_is_strict_and_never_enables_dynamic_lookup() {
         };
         assert!(tls.ech.is_none());
     }
+    let baseline = parse(node()).unwrap();
+    let mut input = node();
+    input["ech-opts"]["query-server-name"] = json!("unused invalid name");
+    assert_eq!(parse(input).unwrap().security, baseline.security);
+    for ech in [
+        json!({"enable":true}),
+        json!({"enable":true,"config":""}),
+        json!({"enable":true,"query-server-name":"query.invalid"}),
+    ] {
+        let mut input = node();
+        input["ech-opts"] = ech;
+        SecurityClient::from_proxy(&parse(input).unwrap()).unwrap();
+    }
 }
 
 #[test]
 fn unsupported_ech_configs_fail_at_parse_before_a_client_can_emit_inner_sni() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "unsupported_ech_configs_fail_at_parse_before_a_client_can_emit_inner_sni",
-    );
     let valid = ech_list();
-    let mut invalid = vec![vec![], vec![0, 0], vec![0, 1, 0], vec![0; 65_538]];
-    for length in 0..valid.len() {
+    let mut invalid = vec![vec![0, 0], vec![0, 1, 0], vec![0; 65_538]];
+    for length in 1..valid.len() {
         invalid.push(valid[..length].to_vec());
     }
     let mut trailing = valid.clone();
@@ -125,23 +121,19 @@ fn unsupported_ech_configs_fail_at_parse_before_a_client_can_emit_inner_sni() {
         bytes[index] = value;
         invalid.push(bytes);
     }
-    for bytes in invalid {
+    for (case, bytes) in invalid.into_iter().enumerate() {
         let mut input = node();
+        input["client-fingerprint"] = json!("chrome");
         input["ech-opts"]["config"] = json!(STANDARD.encode(bytes));
         assert!(
             parse(input).is_err(),
-            "unsupported or malformed config must fail before IO"
+            "unsupported or malformed fixture {case} must fail before IO"
         );
     }
 }
 
 #[test]
 fn ech_selection_skips_unknown_or_mandatory_configs_and_keeps_exact_supported_bytes() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "ech_selection_skips_unknown_or_mandatory_configs_and_keeps_exact_supported_bytes",
-    );
     use vole::config::StaticEchConfig;
     let valid = ech_list();
     let expected = StaticEchConfig::from_config_list(&valid).unwrap();
@@ -180,11 +172,6 @@ fn ech_selection_skips_unknown_or_mandatory_configs_and_keeps_exact_supported_by
 
 #[test]
 fn download_ech_inherits_replaces_or_clears_as_a_whole() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "download_ech_inherits_replaces_or_clears_as_a_whole",
-    );
     let mut input = node();
     input["network"] = json!("xhttp");
     input["xhttp-opts"] = json!({"mode":"stream-up", "download-settings":{}});
@@ -198,10 +185,9 @@ fn download_ech_inherits_replaces_or_clears_as_a_whole() {
     assert_ne!(node.security, node.download().unwrap().security);
     SecurityClient::from_security(&node.download().unwrap().security).unwrap();
     input["xhttp-opts"]["download-settings"]["ech-opts"] = json!({"enable":true});
-    assert!(
-        parse(input.clone()).is_err(),
-        "replacement must not inherit the main key"
-    );
+    let dynamic = parse(input.clone()).unwrap();
+    assert_ne!(dynamic.security, dynamic.download().unwrap().security);
+    SecurityClient::from_security(&dynamic.download().unwrap().security).unwrap();
     for clear in [json!({}), json!({"enable":false})] {
         input["xhttp-opts"]["download-settings"]["ech-opts"] = clear;
         let node = parse(input.clone()).unwrap();
@@ -214,11 +200,6 @@ fn download_ech_inherits_replaces_or_clears_as_a_whole() {
 
 #[test]
 fn ech_is_standard_tls_only_with_explicit_download_clear_and_dns_inner_name() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "ech_is_standard_tls_only_with_explicit_download_clear_and_dns_inner_name",
-    );
     for extra in [
         json!({"tls":false}),
         json!({"server":"127.0.0.1"}),
@@ -254,3 +235,71 @@ fn ech_is_standard_tls_only_with_explicit_download_clear_and_dns_inner_name() {
     SecurityClient::from_proxy(&node).unwrap();
     SecurityClient::from_security(&node.download().unwrap().security).unwrap();
 }
+
+#[cfg(all(
+    feature = "outbound-anytls",
+    feature = "outbound-trojan",
+    feature = "outbound-vmess",
+    feature = "outbound-hysteria2"
+))]
+#[test]
+fn ech_is_consumed_by_every_reference_protocol_without_changing_the_tls_name() {
+    for protocol in ["anytls", "trojan", "vmess", "hysteria2"] {
+        for ech in [
+            json!({"enable":true,"config":STANDARD.encode(ech_list())}),
+            json!({"enable":true,"query-server-name":"query.invalid"}),
+        ] {
+            let mut input = node();
+            input["type"] = json!(protocol);
+            input["password"] = json!("fixture");
+            input["ech-opts"] = ech;
+            input.as_object_mut().unwrap().remove("uuid");
+            if protocol == "vmess" {
+                input.as_object_mut().unwrap().remove("password");
+                input["uuid"] = json!("07070707-0707-0707-0707-070707070707");
+                input["alterId"] = json!(0);
+                input["cipher"] = json!("auto");
+            }
+            if protocol != "vmess" {
+                input.as_object_mut().unwrap().remove("tls");
+            }
+            let config = Config::parse_yaml(
+                &serde_json::to_vec(&json!({"mixed-port":1080,"proxies":[input]})).unwrap(),
+            )
+            .unwrap();
+            match &config.proxies[0].protocol {
+                ProxyProtocol::AnyTls(p) => {
+                    assert!(p.security.as_tls().unwrap().ech.is_some());
+                    assert_eq!(p.server_name, "example.invalid");
+                }
+                ProxyProtocol::Trojan(p) => {
+                    assert!(p.security.as_tls().unwrap().ech.is_some());
+                    assert_eq!(p.server_name, "example.invalid");
+                }
+                ProxyProtocol::Vmess(p) => {
+                    assert!(p.security.as_tls().unwrap().ech.is_some());
+                    assert_eq!(p.server_name, "example.invalid");
+                }
+                ProxyProtocol::Hysteria2(p) => {
+                    assert!(p.tls.ech.is_some());
+                    assert_eq!(p.tls.server_name, "example.invalid");
+                }
+                _ => panic!(),
+            }
+        }
+    }
+}
+
+#[tokio::test]
+async fn dynamic_ech_without_bound_resolution_cannot_emit_a_clear_client_hello() {
+    use tokio::io::AsyncReadExt;
+    for profile in ["none", "ios"] {
+        let mut input = node();
+        input["client-fingerprint"] = json!(profile);
+        input["ech-opts"] = json!({"enable":true});
+        let client = SecurityClient::from_proxy(&parse(input).unwrap()).unwrap();
+        let (io, mut peer) = tokio::io::duplex(4096);
+        assert!(client.connect(Box::new(io)).await.is_err());
+        assert_eq!(peer.read(&mut [0; 1]).await.unwrap(), 0);
+    }
+}
diff --git a/tests/ech_tls.rs b/tests/ech_tls.rs
index bde9c58..a1ae39b 100644
--- a/tests/ech_tls.rs
+++ b/tests/ech_tls.rs
@@ -83,11 +83,6 @@ fn client_with(profile: &str, list: &[u8], pin: &str, extra: serde_json::Value)
 
 #[tokio::test]
 async fn rejected_or_wrong_key_ech_never_reaches_application_data_even_with_a_matching_pin() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "rejected_or_wrong_key_ech_never_reaches_application_data_even_with_a_matching_pin",
-    );
     let rcgen::CertifiedKey { cert, signing_key } =
         rcgen::generate_simple_self_signed(vec!["inner.invalid".into(), "public.invalid".into()])
             .unwrap();
@@ -113,7 +108,7 @@ async fn rejected_or_wrong_key_ech_never_reaches_application_data_even_with_a_ma
             server.set_ech_keys(&keys.build()).unwrap();
         }
         let server = server.build();
-        for profile in ["none", "chrome", "chrome120", "firefox", "safari"] {
+        for profile in ["none", "chrome", "firefox", "safari", "ios"] {
             let client = client(profile, &list, &pin);
             let (io, peer) = tokio::io::duplex(65_536);
             tokio::time::timeout(Duration::from_secs(3), async {
@@ -184,11 +179,6 @@ fn outer_sni(hello: &[u8]) -> &[u8] {
 
 #[tokio::test]
 async fn client_identity_is_sent_only_after_ech_acceptance() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "client_identity_is_sent_only_after_ech_acceptance",
-    );
     use boring::ssl::SslVerifyMode;
     use std::sync::{
         Arc,
@@ -203,7 +193,7 @@ async fn client_identity_is_sent_only_after_ech_acceptance() {
         .map(|b| format!("{b:02x}"))
         .collect();
     for accepted in [true, false] {
-        for profile in ["none", "chrome", "chrome120", "firefox", "safari"] {
+        for profile in ["none", "chrome", "firefox", "safari", "ios"] {
             let (config, key) = material(1);
             let mut list = (config.len() as u16).to_be_bytes().to_vec();
             list.extend_from_slice(&config);
@@ -272,15 +262,10 @@ async fn client_identity_is_sent_only_after_ech_acceptance() {
 
 #[tokio::test]
 async fn cancelled_ech_emits_only_public_sni_and_releases_io_for_every_backend() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "cancelled_ech_emits_only_public_sni_and_releases_io_for_every_backend",
-    );
     let (config, _) = material(1);
     let mut list = (config.len() as u16).to_be_bytes().to_vec();
     list.extend_from_slice(&config);
-    for profile in ["none", "chrome", "chrome120", "firefox", "safari"] {
+    for profile in ["none", "chrome", "firefox", "safari", "ios"] {
         let client = client(profile, &list, &"07".repeat(32));
         let mut previous = None;
         for _ in 0..20 {
@@ -316,11 +301,6 @@ async fn cancelled_ech_emits_only_public_sni_and_releases_io_for_every_backend()
 
 #[tokio::test]
 async fn each_backend_and_hpke_suite_requires_real_ech_acceptance_before_data() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "each_backend_and_hpke_suite_requires_real_ech_acceptance_before_data",
-    );
     let rcgen::CertifiedKey { cert, signing_key } =
         rcgen::generate_simple_self_signed(vec!["inner.invalid".into(), "public.invalid".into()])
             .unwrap();
@@ -346,7 +326,7 @@ async fn each_backend_and_hpke_suite_requires_real_ech_acceptance_before_data()
             .unwrap();
         server.set_ech_keys(&keys.build()).unwrap();
         let server = server.build();
-        for profile in ["none", "chrome", "chrome120", "firefox", "safari"] {
+        for profile in ["none", "chrome", "firefox", "safari", "ios"] {
             let client = client(profile, &list, &pin);
             for _round in 0..3 {
                 let (io, peer) = tokio::io::duplex(65_536);
diff --git a/tests/encryption_config.rs b/tests/encryption_config.rs
index d27f464..418516d 100644
--- a/tests/encryption_config.rs
+++ b/tests/encryption_config.rs
@@ -5,11 +5,6 @@ use vole::config::{Config, ProxyProtocol, VlessEncryption};
 
 #[test]
 fn public_encryption_accepts_all_six_modes_without_exposing_key_material() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "public_encryption_accepts_all_six_modes_without_exposing_key_material",
-    );
     let key = base64::engine::general_purpose::URL_SAFE_NO_PAD.encode([9; 32]);
     for appearance in ["native", "xorpub", "random"] {
         for rtt in ["1rtt", "0rtt"] {
@@ -32,11 +27,6 @@ fn public_encryption_accepts_all_six_modes_without_exposing_key_material() {
 
 #[test]
 fn vision_encryption_is_independent_of_outer_tls_but_keeps_transport_and_udp_limits() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "vision_encryption_is_independent_of_outer_tls_but_keeps_transport_and_udp_limits",
-    );
     let key = base64::engine::general_purpose::URL_SAFE_NO_PAD.encode([9; 32]);
     for tls in [false, true] {
         for appearance in ["native", "xorpub", "random"] {
@@ -56,9 +46,18 @@ fn vision_encryption_is_independent_of_outer_tls_but_keeps_transport_and_udp_lim
                 parse(node.clone()).is_ok(),
                 "Encryption must supply the Vision splice boundary"
             );
+            let mut alias = node.clone();
+            alias["packet-encoding"] = json!("none");
+            let config = parse(alias).expect("none must keep the Vision XUDP encoding");
+            let ProxyProtocol::Vless(vless) = &config.proxies[0].protocol else {
+                unreachable!()
+            };
+            assert_eq!(
+                vless.packet_encoding,
+                vole::config::VlessPacketEncoding::Xudp
+            );
             for (field, value) in [
                 ("network", json!("ws")),
-                ("packet-encoding", json!("none")),
                 ("packet-encoding", json!("packetaddr")),
                 ("smux", json!({"enabled":true})),
             ] {
diff --git a/tests/feature_foundations.rs b/tests/feature_foundations.rs
index 90fd823..5fa7e0d 100644
--- a/tests/feature_foundations.rs
+++ b/tests/feature_foundations.rs
@@ -1,15 +1,12 @@
 use vole::config::Config;
 
 #[test]
-fn feature_skeletons_do_not_open_unimplemented_yaml_or_measurement_protocols() {
-    // Keep the stable FOUNDATIONS assertion ID as a regression for the retired protocol.
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-SCHEMA",
-        "feature_skeletons_do_not_open_unimplemented_yaml_or_measurement_protocols",
+fn wireguard_yaml_follows_its_own_feature() {
+    let yaml = b"mixed-port: 1080\nproxies: [{name: wg, type: wireguard, server: 192.0.2.1, port: 51820, ip: 10.84.0.2, private-key: AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE=, public-key: AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI=}]\nrules: ['MATCH,wg']\n";
+    assert_eq!(
+        Config::parse_yaml(yaml).is_ok(),
+        cfg!(feature = "outbound-wireguard")
     );
-    let yaml = "proxies:\n  - name: node\n    type: wireguard\n    server: example.com\n    port: 443\nrules:\n  - MATCH,node\n";
-    assert!(Config::parse_yaml(yaml.as_bytes()).is_err());
 }
 
 #[test]
@@ -37,16 +34,10 @@ fn selected_fingerprints_follow_protocol_feature_admission() {
         ),
     ] {
         for name in [
-            "none",
-            "chrome",
-            "chrome120",
-            "firefox",
-            "firefox120",
-            "safari",
-            "safari16",
+            "none", "chrome", "firefox", "safari", "ios", "android", "edge", "360", "qq", "random",
         ] {
             let yaml = format!(
-                "mixed-port: 1080\nproxies: [{{name: node, type: {protocol}, server: localhost, port: 443, {authentication}, client-fingerprint: {name}}}]\nrules: ['MATCH,node']\n"
+                "mixed-port: 1080\nproxies: [{{name: node, type: {protocol}, server: localhost, port: 443, {authentication}, client-fingerprint: {name:?}}}]\nrules: ['MATCH,node']\n"
             );
             assert_eq!(
                 Config::parse_yaml(yaml.as_bytes()).is_ok(),
@@ -92,11 +83,6 @@ fn trojan_yaml_follows_its_own_feature() {
 
 #[test]
 fn future_fields_and_over_limit_documents_remain_rejected() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-SCHEMA",
-        "future_fields_and_over_limit_documents_remain_rejected",
-    );
     assert!(Config::parse_yaml(&vec![b'x'; vole::config::MAX_CONFIG_BYTES + 1]).is_err());
     assert!(Config::parse_yaml(b"listeners: []\n").is_err());
     assert!(Config::parse_yaml(b"proxies:\n  - name: s\n    type: socks4\n    server: example.com\n    port: 1080\nrules: [MATCH,s]\n").is_err());
diff --git a/tests/fingerprint_capture.rs b/tests/fingerprint_capture.rs
index c2f5250..f3c014d 100644
--- a/tests/fingerprint_capture.rs
+++ b/tests/fingerprint_capture.rs
@@ -1,9 +1,8 @@
-//! Capture the public configuration's real TLS adapter over bounded memory IO.
+//! Verify the public configuration's real TLS adapter over bounded memory IO.
 //! The observer aborts before authentication; proxy interoperability is separate.
 #![cfg(all(feature = "tls-fingerprint", feature = "outbound-vless"))]
 
-use base64::{Engine, engine::general_purpose::STANDARD};
-use serde_json::{Value, json};
+use serde_json::json;
 use std::time::Duration;
 use tokio::io::AsyncReadExt;
 use vole::{
@@ -100,15 +99,8 @@ async fn capture(client: &SecurityClient) -> Vec<u8> {
 
 #[tokio::test]
 async fn selected_public_profiles_emit_bounded_client_hellos() {
-    let mut cases: Vec<Value> = Vec::new();
-    for profile in [
-        "chrome",
-        "chrome120",
-        "firefox",
-        "firefox120",
-        "safari",
-        "safari16",
-    ] {
+    let mut cases = 0;
+    for profile in ["chrome", "firefox", "safari", "ios"] {
         for context in [
             "tcp", "ws", "grpc", "reality", "vision", "xhttp-h1", "xhttp-h2",
         ] {
@@ -117,15 +109,12 @@ async fn selected_public_profiles_emit_bounded_client_hellos() {
                 format!("{}.fingerprint.test", "f".repeat(63)),
             ] {
                 let client = configuration(profile, context, &sni);
-                for attempt in 0..2 {
-                    cases.push(json!({"profile": profile, "context": context, "sni": sni,
-                        "attempt": attempt, "records_b64": STANDARD.encode(capture(&client).await)}));
+                for _ in 0..2 {
+                    drop(capture(&client).await);
+                    cases += 1;
                 }
             }
         }
     }
-    assert_eq!(cases.len(), 168);
-    if let Ok(path) = std::env::var("VOLE_FINGERPRINT_CAPTURE") {
-        std::fs::write(path, serde_json::to_vec_pretty(&cases).unwrap()).unwrap();
-    }
+    assert_eq!(cases, 112);
 }
diff --git a/tests/fingerprints/README.md b/tests/fingerprints/README.md
index 3d7e35c..01e83bd 100644
--- a/tests/fingerprints/README.md
+++ b/tests/fingerprints/README.md
@@ -1,20 +1,13 @@
 # ClientHello 独立参考
 
-保留官方 Mihomo/uTLS 原始 ClientHello golden；开发阶段计划不再作为测试输入。
+保留官方 Mihomo/uTLS 原始 ClientHello golden，作为独立来源的测试输入。
 
 ## 验证分层
 
-| 历史报告标签 | 历史脚本入口 | 证明范围 |
-| --- | --- | --- |
-| FINGERPRINT-REFERENCE | protocol_fingerprint_reference | 官方客户端的独立基线，不是 Vole 互通 |
-| FINGERPRINT-WIRE | protocol_fingerprint_shape | 公开配置的内存 TLS 报文、恢复与过期 |
-| FINGERPRINT-INTEROP | protocol_fingerprint | 命名指纹在真实容器协议链路中的行为 |
-
-上述专用运行器可从 Git 历史查阅，未随当前精简 Mihomo 互通入口恢复；不得把它们
-当作现存命令。协议验证归 Vole，container-benchmark 只做性能评估；当前入口和
-范围见 [构建与验证](../../scripts/README.md)。golden 中的 `case_id` 是用例标签；原始 TLS
-字节、解析结果、来源版本及原报告 hash 保持独立采集时的值，不表示重新抓包。
-历史运行报告不改写，按其记录的 Git revision 复核；各层结果不能互相代替。
+独立官方基线、Vole 内存 TLS 报文及真实协议互通分别验证，结果不能互相代替。
+当前容器互通和压力测试由 container-benchmark 运行；入口和范围见
+[测试](../README.md)。golden 中的 `case_id` 是用例标签；原始 TLS 字节、解析结果、
+来源版本及原报告 hash 保持独立采集时的值，不表示重新抓包。
 
 ## Independent wire baseline
 
@@ -22,19 +15,16 @@
 four templates, ordinary TCP TLS and classic REALITY. The official latest Mihomo
 binary was downloaded, not compiled from the reference source. Binary identity,
 uTLS build dependency, raw record layout, handshake bytes and parsed fields are
-retained. The historical collector's `validate_capture` re-parsed raw bytes and
-detected altered derived data; that collector is not a current script entry.
+retained as source provenance.
 These are public ephemeral key shares and synthetic names, not private keys,
 proxy credentials, application traffic or user destinations.
 
-The historical independent baseline used 116 cases: six enabled names
-across TCP/WS/gRPC/REALITY, two SNI lengths and two successive connections; four
-`none` controls; four actual templates with TLS1.2/1.3 handshakes on a native
-OpenSSL observer. All server roles and the official client run in owned isolated
-containers. Generated run data is deleted after each test; the committed golden
-remains a source fixture. Success means **reference captured / baseline verified**, not Vole
-support, REALITY authentication or proxy interoperability. A capture-only observer
-intentionally aborts; OpenSSL handshake cases do not implement VLESS or HTTP.
+The committed golden is a source fixture, not generated run data. A verified
+reference does not establish Vole support, REALITY authentication or proxy
+interoperability.
+
+Chrome120 observations remain historical reference evidence. Vole's current
+supported templates are defined in the [TLS contract](../../docs/tls-client-fingerprint.md).
 
 ## Comparison rules
 
@@ -60,8 +50,9 @@ Sources: [Mihomo TLS connection path](https://github.com/MetaCubeX/mihomo/blob/a
 
 ## Intentional Vole differences
 
-Vole retains a TLS1.2 floor, transport-owned ALPN, h2-only ALPS advertisement,
-nonempty ALPS rejection and its bounded ordinary-TLS session cache. Safari's
+Vole retains a TLS1.2 floor, transport-owned ALPN, standard HTTP/2 SETTINGS
+without TLS ALPS advertisement, a guard for unexpected nonempty ALPS,
+and its bounded ordinary-TLS session cache. Safari's
 TLS1.0/1.1 declarations are trimmed; Mihomo's WS Chrome still advertises h2 ALPS
 when ALPN is only HTTP/1.1, which Vole deliberately does not do. Warm/resumed
 hellos have separate expectations; PSK is not ignored by the comparator. These
diff --git a/tests/fixtures/geodata/Country-Test.mmdb b/tests/fixtures/geodata/Country-Test.mmdb
new file mode 100644
index 0000000..d4b7699
Binary files /dev/null and b/tests/fixtures/geodata/Country-Test.mmdb differ
diff --git a/tests/fixtures/geodata/GeoLite2-ASN-Test.mmdb b/tests/fixtures/geodata/GeoLite2-ASN-Test.mmdb
new file mode 100644
index 0000000..ae4cb25
Binary files /dev/null and b/tests/fixtures/geodata/GeoLite2-ASN-Test.mmdb differ
diff --git a/tests/fixtures/geodata/LICENSE-MIT b/tests/fixtures/geodata/LICENSE-MIT
new file mode 100644
index 0000000..f85e365
--- /dev/null
+++ b/tests/fixtures/geodata/LICENSE-MIT
@@ -0,0 +1,17 @@
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/tests/fixtures/geodata/Meta-Test.mmdb b/tests/fixtures/geodata/Meta-Test.mmdb
new file mode 100644
index 0000000..12c86bc
Binary files /dev/null and b/tests/fixtures/geodata/Meta-Test.mmdb differ
diff --git a/tests/fixtures/geodata/README.md b/tests/fixtures/geodata/README.md
new file mode 100644
index 0000000..d61382f
--- /dev/null
+++ b/tests/fixtures/geodata/README.md
@@ -0,0 +1,17 @@
+# GeoData fixtures
+
+`GeoLite2-ASN-Test.mmdb` is the small official MaxMind test database from
+[MaxMind-DB](https://github.com/maxmind/MaxMind-DB/tree/6a690a705bc6962c0025a32e94a8f0dc8f86418c),
+commit `6a690a705bc6962c0025a32e94a8f0dc8f86418c`, path
+`test-data/GeoLite2-ASN-Test.mmdb`.
+
+Copyright © 2013–2026 MaxMind, Inc. Used under the upstream MIT option; the
+permission notice is preserved in [LICENSE-MIT](LICENSE-MIT). This source fixture
+is not part of Vole runtime or release packages.
+
+`Country-Test.mmdb`, `Sing-Test.mmdb`, and `Meta-Test.mmdb` are independently
+encoded Vole fixtures using the [MaxMind DB 2.0 format](https://maxmind.github.io/MaxMind-DB/).
+One 24-bit node maps the lower IPv6 half (including IPv4 lookups) to CN and the
+upper half to US. Records respectively use `country.iso_code`, a root string,
+and a root array (`cn`, `private`) or string (`us`). They contain synthetic
+data and no third-party database records.
diff --git a/tests/fixtures/geodata/Sing-Test.mmdb b/tests/fixtures/geodata/Sing-Test.mmdb
new file mode 100644
index 0000000..fa4392f
Binary files /dev/null and b/tests/fixtures/geodata/Sing-Test.mmdb differ
diff --git a/tests/fixtures/provider-age/README.md b/tests/fixtures/provider-age/README.md
new file mode 100644
index 0000000..2032f7f
--- /dev/null
+++ b/tests/fixtures/provider-age/README.md
@@ -0,0 +1,9 @@
+# AGE provider fixtures
+
+Synthetic X25519 and ML-KEM-768/X25519 Hybrid recipients were generated with
+the public `filippo.io/age` v1.3.2 API (`GenerateX25519Identity`,
+`GenerateHybridIdentity`, `Encrypt`, and `armor.NewWriter`). Both decrypt to
+`provider.yaml`. The public fixture keys are only for tests.
+
+These fixtures check compatibility against an independent implementation; no
+reference-client source or tests were copied.
diff --git a/tests/fixtures/provider-age/hybrid.age b/tests/fixtures/provider-age/hybrid.age
new file mode 100644
index 0000000..1db963a
--- /dev/null
+++ b/tests/fixtures/provider-age/hybrid.age
@@ -0,0 +1,39 @@
+-----BEGIN AGE ENCRYPTED FILE-----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+-----END AGE ENCRYPTED FILE-----
diff --git a/tests/fixtures/provider-age/hybrid.key b/tests/fixtures/provider-age/hybrid.key
new file mode 100644
index 0000000..ac02554
--- /dev/null
+++ b/tests/fixtures/provider-age/hybrid.key
@@ -0,0 +1 @@
+AGE-SECRET-KEY-PQ-1J9R3YQYVZXQ699CY0X8HV7R3RE3ANEH26ATF343P820WPUULYDDQ5REECX
diff --git a/tests/fixtures/provider-age/provider.yaml b/tests/fixtures/provider-age/provider.yaml
new file mode 100644
index 0000000..2a2dd4e
--- /dev/null
+++ b/tests/fixtures/provider-age/provider.yaml
@@ -0,0 +1,6 @@
+proxies:
+  - name: age-node
+    type: socks5
+    server: 192.0.2.9
+    port: 1080
+    udp: true
diff --git a/tests/fixtures/provider-age/x25519.age b/tests/fixtures/provider-age/x25519.age
new file mode 100644
index 0000000..670e6c4
--- /dev/null
+++ b/tests/fixtures/provider-age/x25519.age
@@ -0,0 +1,9 @@
+-----BEGIN AGE ENCRYPTED FILE-----
+YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSB5QlZFdk1RSEFITWhLQW5j
+bStCQUJYTzZwN0lPOHpDTlVoTElGQ0xxdDB3CkYyZGFoYnpEalNZTHFUMXlHNktn
+elo4enRmcjZsQzdwaVJDV3V2RGIxNHMKLS0tIFNwWnJhTXFuU2pjSmtabExOTUN2
+Slg4QTVSNm1WZHAyclNqRDlnbDhwbTgK5NbBvoKlT6jJcjgCysEPB6GebH7dMA9z
+FcYNKEYDBYpIWsS3qUHkPrWkJDJwpind4YdsCEAHQicmuf/0DHD9vrQSGKNZNt2j
+K3szUL85DnQmPmNEAKkK01k8wRC+X+jpF9GB660Jvq3xe+gr29TidiX+CV8oZrDo
+b79RR610cmA=
+-----END AGE ENCRYPTED FILE-----
diff --git a/tests/fixtures/provider-age/x25519.key b/tests/fixtures/provider-age/x25519.key
new file mode 100644
index 0000000..f8f1170
--- /dev/null
+++ b/tests/fixtures/provider-age/x25519.key
@@ -0,0 +1 @@
+AGE-SECRET-KEY-1VH0VLX6NFVM6Q0G2S0SZ8HJUUASJ2TTC64NPD458U3W82FGY0DMQQCL7CN
diff --git a/tests/fixtures/vmess-delayed-response.json b/tests/fixtures/vmess-delayed-response.json
new file mode 100644
index 0000000..9f6e9ec
--- /dev/null
+++ b/tests/fixtures/vmess-delayed-response.json
@@ -0,0 +1,16 @@
+{
+  "alter_id": 0,
+  "authenticated_length": false,
+  "cipher": "aes-128-gcm",
+  "global_padding": false,
+  "official_client_response_roundtrip": true,
+  "payload": [115, 121, 110, 116, 104, 101, 116, 105, 99, 32, 100, 101, 108, 97, 121, 101, 100, 32, 97, 117, 116, 104, 101, 110, 116, 105, 99, 97, 116, 101, 100, 32, 114, 101, 112, 108, 121],
+  "request": [29, 244, 52, 60, 61, 159, 73, 240, 92, 209, 74, 170, 51, 227, 38, 70, 64, 194, 99, 200, 11, 102, 42, 157, 82, 255, 172, 57, 192, 19, 10, 109, 184, 33, 3, 197, 145, 206, 84, 184, 205, 188, 171, 182, 252, 172, 156, 239, 146, 30, 146, 8, 79, 53, 18, 248, 255, 224, 27, 169, 188, 78, 135, 98, 230, 225, 4, 146, 167, 90, 191, 175, 127, 27, 47, 132, 177, 7, 141, 242, 189, 235, 207, 147, 186, 6, 211, 167, 155, 117, 92, 90, 237, 179, 20, 230, 123, 206, 36, 38, 189, 175, 34, 132, 240, 3, 112],
+  "request_iv": [212, 186, 134, 143, 182, 247, 44, 8, 21, 1, 32, 29, 146, 5, 1, 103],
+  "request_key": [166, 194, 68, 130, 119, 28, 53, 40, 39, 36, 87, 108, 79, 145, 44, 227],
+  "response": [96, 22, 216, 155, 26, 79, 173, 29, 125, 209, 39, 23, 165, 112, 98, 64, 93, 155, 117, 149, 222, 91, 235, 208, 188, 181, 160, 5, 174, 166, 42, 105, 72, 184, 208, 27, 241, 43, 152, 237, 82, 40, 238, 119, 245, 130, 212, 58, 203, 57, 36, 189, 111, 94, 159, 89, 184, 139, 73, 175, 195, 78, 202, 8, 3, 154, 88, 187, 109, 148, 182, 38, 172, 252, 109, 40, 9, 32, 51, 153, 70, 253, 78, 242, 19, 93, 133, 211, 156, 182, 36, 16, 92],
+  "response_empty_before_first_server_write": true,
+  "response_tag": 220,
+  "scope": "synthetic official sing-vmess client/Service memory codec vector",
+  "source": "MetaCubeX/sing-vmess v0.2.5 (9b7fdbf462a5cf6366628631ef426c1a91f5df82) client and Service; synthetic memory IO"
+}
diff --git a/tests/grpc_config.rs b/tests/grpc_config.rs
new file mode 100644
index 0000000..3fdd4ce
--- /dev/null
+++ b/tests/grpc_config.rs
@@ -0,0 +1,112 @@
+#![cfg(all(
+    feature = "outbound-trojan",
+    feature = "outbound-vmess",
+    feature = "outbound-vless"
+))]
+use serde_json::json;
+use vole::config::{Config, ProxyProtocol, StreamTransport, TrojanTransport, VlessTransport};
+
+#[test]
+fn grpc_protocols_share_defaults_signed_thresholds_and_normalization() {
+    for protocol in ["trojan", "vmess", "vless"] {
+        for (fields, path, ua, max, min, streams) in [
+            (json!({}), "/GunService/Tun", "grpc-go/1.36.0", 4, 0, 0),
+            (
+                json!({"grpc-opts":{"grpc-service-name":"","grpc-user-agent":""}}),
+                "/GunService/Tun",
+                "grpc-go/1.36.0",
+                4,
+                0,
+                0,
+            ),
+            (
+                json!({"grpc-opts":{"max-connections":1}}),
+                "/GunService/Tun",
+                "grpc-go/1.36.0",
+                1,
+                0,
+                0,
+            ),
+            (
+                json!({"grpc-opts":{"grpc-service-name":"edge","grpc-user-agent":"probe","ping-interval":1,"max-connections":2,"min-streams":3,"max-streams":4}}),
+                "/edge/Tun",
+                "probe",
+                2,
+                3,
+                4,
+            ),
+            (
+                json!({"grpc-opts":{"grpc-service-name":"/full/path","max-connections":-1,"min-streams":-1,"max-streams":2}}),
+                "/full/path",
+                "grpc-go/1.36.0",
+                0,
+                0,
+                2,
+            ),
+            (
+                json!({"grpc-opts":{"max-streams":-1}}),
+                "/GunService/Tun",
+                "grpc-go/1.36.0",
+                0,
+                0,
+                0,
+            ),
+        ] {
+            let mut node = json!({"name":"edge","type":protocol,"server":"example.com","port":443,"network":"grpc"});
+            if protocol == "trojan" {
+                node["password"] = json!("test");
+            } else {
+                node["uuid"] = json!("07070707-0707-0707-0707-070707070707");
+            }
+            node.as_object_mut()
+                .unwrap()
+                .extend(fields.as_object().unwrap().clone());
+            let config = Config::parse_yaml(
+                json!({"mixed-port":1080,"proxies":[node.clone()],"rules":["MATCH,edge"]})
+                    .to_string()
+                    .as_bytes(),
+            )
+            .unwrap();
+            let (uri, options) = match &config.proxies[0].protocol {
+                ProxyProtocol::Trojan(node) => match &node.transport {
+                    TrojanTransport::Grpc { uri, options } => (uri, options),
+                    _ => unreachable!(),
+                },
+                ProxyProtocol::Vmess(node) => match &node.transport {
+                    StreamTransport::Grpc { uri, options } => (uri, options),
+                    _ => unreachable!(),
+                },
+                ProxyProtocol::Vless(node) => match &node.transport {
+                    VlessTransport::Stream(StreamTransport::Grpc { uri, options }) => {
+                        (uri, options)
+                    }
+                    _ => unreachable!(),
+                },
+                _ => unreachable!(),
+            };
+            assert_eq!(uri.parse::<http::Uri>().unwrap().path(), path);
+            assert_eq!(options.user_agent, ua);
+            assert_eq!(
+                (
+                    options.max_connections,
+                    options.min_streams,
+                    options.max_streams
+                ),
+                (max, min, streams)
+            );
+            assert_eq!(options.ping_interval, u64::from(ua == "probe"));
+            if fields.as_object().unwrap().is_empty() {
+                let mut unsupported = node.clone();
+                unsupported["grpc-opts"] = json!({"ping-interval":-1});
+                assert!(
+                    Config::parse_yaml(
+                        json!({"mixed-port":1080,"proxies":[unsupported],"rules":["MATCH,edge"]})
+                            .to_string()
+                            .as_bytes()
+                    )
+                    .is_err()
+                );
+            }
+        }
+    }
+}
diff --git a/tests/grpc_pool.rs b/tests/grpc_pool.rs
index fb4f627..8b797f8 100644
--- a/tests/grpc_pool.rs
+++ b/tests/grpc_pool.rs
@@ -67,11 +67,6 @@ fn ping_count(wire: &[u8]) -> usize {
 }
 #[tokio::test]
 async fn grpc_idle_ping_is_observable_disabled_by_zero_and_joined_at_stop() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "VLESS-UNIT",
-        "grpc_idle_ping_is_observable_disabled_by_zero_and_joined_at_stop",
-    );
     for interval in [0, 1] {
         let (io, peer) = tokio::io::duplex(65536);
         let observed = Arc::new(std::sync::Mutex::new(Vec::new()));
@@ -151,15 +146,11 @@ async fn memory_peer(count: Arc<AtomicUsize>, tasks: TaskTracker) -> io::Result<
 }
 #[tokio::test]
 async fn grpc_pool_matches_both_threshold_policies_and_keeps_other_streams_alive() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "VLESS-UNIT",
-        "grpc_pool_matches_both_threshold_policies_and_keeps_other_streams_alive",
-    );
     tokio::time::timeout(Duration::from_secs(8), async {
         for (max, min, streams, expected) in [
             (1, 0, 0, vec![1, 1, 1, 1]),
             (2, 2, 0, vec![1, 1, 2, 2]),
+            (2, 2, 1, vec![1, 1, 2, 2]),
             (2, 0, 0, vec![1, 2, 2, 2]),
             (0, 0, 2, vec![1, 1, 2, 2, 3]),
             (0, 2, 0, vec![1, 2, 3, 4]),
diff --git a/tests/grpc_protocol_pool.rs b/tests/grpc_protocol_pool.rs
new file mode 100644
index 0000000..3fb4787
--- /dev/null
+++ b/tests/grpc_protocol_pool.rs
@@ -0,0 +1,595 @@
+#![cfg(feature = "outbound-vmess")]
+use std::{
+    sync::{
+        Arc,
+        atomic::{AtomicUsize, Ordering},
+    },
+    time::Duration,
+};
+use tokio::io::AsyncWriteExt;
+use tokio_util::task::TaskTracker;
+use vole::{
+    config::{Config, ProxyProtocol},
+    dispatch::{DatagramTransport, DispatchError},
+    outbound::{
+        ConnectedStream, DatagramRequest, EstablishContext, OutboundConnector, UpstreamPath,
+        vmess::VmessOutbound,
+    },
+    session::{InboundKind, StreamSession},
+};
+
+#[derive(Default)]
+struct DelayedResponse {
+    received: AtomicUsize,
+    changed: tokio::sync::Notify,
+    cancel: tokio_util::sync::CancellationToken,
+    reply: tokio::sync::Notify,
+    status: AtomicUsize,
+}
+
+struct MemoryUpstream {
+    physical: AtomicUsize,
+    tasks: TaskTracker,
+    requests: tokio::sync::mpsc::UnboundedSender<Vec<u8>>,
+    delayed: Option<Arc<DelayedResponse>>,
+    tls: Option<Arc<rustls::ServerConfig>>,
+}
+#[async_trait::async_trait]
+impl OutboundConnector for MemoryUpstream {
+    async fn connect_stream(
+        &self,
+        session: StreamSession,
+        _: &EstablishContext,
+    ) -> Result<ConnectedStream, DispatchError> {
+        self.physical.fetch_add(1, Ordering::SeqCst);
+        let (io, peer) = tokio::io::duplex(65536);
+        let sessions = self.tasks.clone();
+        let requests = self.requests.clone();
+        let delayed = self.delayed.clone();
+        let tls = self.tls.clone();
+        let cancel = delayed
+            .as_ref()
+            .map(|state| state.cancel.clone())
+            .unwrap_or_default();
+        self.tasks.spawn(async move {
+            let peer: vole::dispatch::BoxStream = if let Some(tls) = tls {
+                let accepted = tokio::select! {
+                    biased;
+                    () = cancel.cancelled() => return,
+                    accepted = tokio_rustls::TlsAcceptor::from(tls).accept(peer) => accepted,
+                };
+                let Ok(peer) = accepted else { return };
+                Box::new(peer)
+            } else {
+                Box::new(peer)
+            };
+            let mut connection = tokio::select! {
+                biased;
+                () = cancel.cancelled() => return,
+                result = h2::server::handshake(peer) => match result {
+                    Ok(connection) => connection,
+                    Err(_) => return,
+                },
+            };
+            loop {
+                let next = tokio::select! {
+                    biased;
+                    () = cancel.cancelled() => return,
+                    next = connection.accept() => next,
+                };
+                let Some(Ok((request, mut response))) = next else {
+                    break;
+                };
+                assert_eq!(request.uri().path(), "/edge/Tun");
+                assert_eq!(request.headers()["user-agent"], "vmess-memory");
+                let send = if delayed.is_some() {
+                    None
+                } else {
+                    Some(
+                        response
+                            .send_response(
+                                http::Response::builder()
+                                    .status(200)
+                                    .header("content-type", "application/grpc")
+                                    .body(())
+                                    .unwrap(),
+                                false,
+                            )
+                            .unwrap(),
+                    )
+                };
+                let mut receive = request.into_body();
+                let requests = requests.clone();
+                let delayed = delayed.clone();
+                let cancel = cancel.clone();
+                sessions.spawn(async move {
+                    // A delayed response remains live while request DATA advances.
+                    let mut response = Some(response);
+                    let mut send = send;
+                    let mut first = Vec::new();
+                    let mut sent = false;
+                    loop {
+                        let next = tokio::select! {
+                            biased;
+                            () = cancel.cancelled() => return,
+                            () = async {
+                                if let Some(progress) = &delayed {
+                                    progress.reply.notified().await;
+                                } else {
+                                    std::future::pending::<()>().await;
+                                }
+                            }, if delayed.is_some() && response.is_some() => {
+                                let status = delayed.as_ref().unwrap().status.load(Ordering::Acquire);
+                                let Ok(body) = response.take().unwrap().send_response(
+                                    http::Response::builder()
+                                        .status(status as u16)
+                                        .header("content-type", "application/grpc")
+                                        .body(()).unwrap(),
+                                    false,
+                                ) else { return };
+                                send = Some(body);
+                                continue;
+                            }
+                            next = receive.data() => next,
+                        };
+                        let Some(Ok(data)) = next else { break };
+                        receive.flow_control().release_capacity(data.len()).unwrap();
+                        if let Some(progress) = &delayed {
+                            progress.received.fetch_add(data.len(), Ordering::Release);
+                            progress.changed.notify_one();
+                        }
+                        if !sent {
+                            first.extend_from_slice(&data);
+                            if first.len() >= 5 {
+                                let length =
+                                    u32::from_be_bytes(first[1..5].try_into().unwrap()) as usize;
+                                assert!(length <= 16384);
+                                if first.len() >= 5 + length {
+                                    requests.send(first.clone()).unwrap();
+                                    sent = true;
+                                }
+                            }
+                        }
+                    }
+                    if delayed.is_some() {
+                        if let Some(mut send) = send {
+                            // The upload END_STREAM must not discard the response tail.
+                            if send.send_data(bytes::Bytes::from_static(b"\0\0\0\0\x06\x0a\x04tail"), false).is_ok() {
+                                let mut trailers = http::HeaderMap::new();
+                                trailers.insert("grpc-status", "0".parse().unwrap());
+                                let _ = send.send_trailers(trailers);
+                            }
+                        }
+                    }
+                });
+            }
+        });
+        Ok(ConnectedStream {
+            io: Box::new(io),
+            effective_peer: session.destination,
+        })
+    }
+    async fn open_datagram(
+        &self,
+        _: DatagramRequest,
+        _: &EstablishContext,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        Err(DispatchError::NotAllowed)
+    }
+}
+
+fn auth_id(record: &[u8]) -> &[u8] {
+    assert_eq!(record[0], 0);
+    assert_eq!(record[5], 0x0a);
+    let mut start = 6;
+    while record[start] & 0x80 != 0 {
+        start += 1;
+    }
+    &record[start + 1..start + 17]
+}
+
+#[tokio::test]
+async fn vmess_grpc_reuses_per_node_transport_with_fresh_authentication_and_joined_stop() {
+    tokio::time::timeout(Duration::from_secs(3),async {
+        let config=Config::parse_yaml(b"mixed-port: 1080\nproxies: [{name: edge, type: vmess, server: fixture.invalid, port: 443, uuid: 07070707-0707-0707-0707-070707070707, network: grpc, grpc-opts: {grpc-service-name: edge, grpc-user-agent: vmess-memory, max-connections: 1}}]\nrules: ['MATCH,edge']").unwrap();
+        let ProxyProtocol::Vmess(node)=&config.proxies[0].protocol else { unreachable!() };
+        let (requests,mut observed)=tokio::sync::mpsc::unbounded_channel();
+        let upstream=Arc::new(MemoryUpstream { physical:AtomicUsize::new(0), tasks:TaskTracker::new(), requests, delayed:None, tls:None });
+        let first=VmessOutbound::new_with_path(node,UpstreamPath::proxy(upstream.clone())).unwrap();
+        let second=VmessOutbound::new_with_path(node,UpstreamPath::proxy(upstream.clone())).unwrap();
+        let session=StreamSession { metadata:Default::default(), inbound:InboundKind::InternalMeasure, source:"127.0.0.1:1".parse().unwrap(), destination:"192.0.2.1:80".parse::<std::net::SocketAddr>().unwrap().into(), sniffed_domain:None };
+        let context=EstablishContext::with_timeout(Duration::from_secs(2));
+        let mut stream1=first.connect_stream(session.clone(),&context).await.unwrap().io;
+        let header1=observed.recv().await.unwrap();
+        let mut stream2=first.connect_stream(session.clone(),&context).await.unwrap().io;
+        let header2=observed.recv().await.unwrap();
+        assert_eq!(upstream.physical.load(Ordering::SeqCst),1,"logical reuse must not reselect or dial the upstream");
+        assert_ne!(auth_id(&header1),auth_id(&header2),"each logical stream needs fresh VMess AEAD authentication");
+        stream1.shutdown().await.unwrap();
+        stream2.write_all(b"sibling").await.unwrap();
+        stream2.flush().await.unwrap();
+        let mut independent=second.connect_stream(session,&context).await.unwrap().io;
+        let _=observed.recv().await.unwrap();
+        assert_eq!(upstream.physical.load(Ordering::SeqCst),2,"distinct node instances must not share a physical pool");
+        first.shutdown().await;
+        assert!(stream2.write_all(b"stopped").await.is_err());
+        independent.write_all(b"other-node").await.unwrap();
+        independent.flush().await.unwrap();
+        second.shutdown().await;
+        drop((stream1,stream2,independent));
+        upstream.tasks.close();
+        upstream.tasks.wait().await;
+    }).await.unwrap();
+}
+
+#[cfg(feature = "interop-test")]
+#[tokio::test(start_paused = true)]
+async fn vmess_grpc_committed_request_outlives_delayed_http_response() {
+    use tokio::io::AsyncReadExt;
+    use vole::resources::observation::ResourceProbe;
+
+    async fn received_after(progress: &DelayedResponse, before: usize) {
+        loop {
+            let changed = progress.changed.notified();
+            if progress.received.load(Ordering::Acquire) > before {
+                return;
+            }
+            changed.await;
+        }
+    }
+
+    let probe = ResourceProbe::default();
+    let (result, core_stopped, naturally_joined, joined) = probe
+        .scope(async {
+            let config = Config::parse_yaml(
+                br#"proxies:
+  - name: edge
+    type: vmess
+    server: fixture.invalid
+    port: 443
+    uuid: 07070707-0707-0707-0707-070707070707
+    network: grpc
+    grpc-opts: {grpc-service-name: edge, grpc-user-agent: vmess-memory}
+rules: ['MATCH,edge']
+"#,
+            )
+            .unwrap();
+            let ProxyProtocol::Vmess(node) = &config.proxies[0].protocol else {
+                unreachable!()
+            };
+            let (requests, mut observed) = tokio::sync::mpsc::unbounded_channel();
+            let progress = Arc::new(DelayedResponse::default());
+            let upstream = Arc::new(MemoryUpstream {
+                physical: AtomicUsize::new(0),
+                tasks: TaskTracker::new(),
+                requests,
+                delayed: Some(progress.clone()),
+                tls: None,
+            });
+            let outbound =
+                VmessOutbound::new_with_path(node, UpstreamPath::proxy(upstream.clone())).unwrap();
+            let session = StreamSession {
+                metadata: Default::default(),
+                inbound: InboundKind::InternalMeasure,
+                source: "127.0.0.1:1".parse().unwrap(),
+                destination: "192.0.2.1:80"
+                    .parse::<std::net::SocketAddr>()
+                    .unwrap()
+                    .into(),
+                sniffed_domain: None,
+            };
+            let context = EstablishContext::with_timeout(Duration::from_secs(2));
+            let result = tokio::time::timeout(Duration::from_secs(30), async {
+                let stream = outbound
+                    .connect_stream(session, &context)
+                    .await
+                    .map_err(std::io::Error::other)?
+                    .io;
+                // This event is emitted only after the peer has the complete
+                // first Gun record; connect_stream also finished auth flush.
+                let _authentication = observed
+                    .recv()
+                    .await
+                    .ok_or(std::io::ErrorKind::UnexpectedEof)?;
+                let (mut reader, mut writer) = tokio::io::split(stream);
+                let before_upload = progress.received.load(Ordering::Acquire);
+                writer.write_all(b"upload before delayed response").await?;
+                writer.flush().await?;
+                received_after(&progress, before_upload).await;
+                let before_late_upload = progress.received.load(Ordering::Acquire);
+                let mut byte = [0; 1];
+                let before_deadline = tokio::time::Instant::now() < context.deadline();
+                let (pending_before, pending_after, boundary_read) = {
+                    let read = reader.read(&mut byte);
+                    tokio::pin!(read);
+                    let initial = futures_util::poll!(read.as_mut());
+                    let pending_before = initial.is_pending();
+                    let expired = if pending_before {
+                        // No real sleep or fixed 10-second assumption. The
+                        // response gate stays closed while this clock advances.
+                        tokio::time::advance(
+                            context
+                                .deadline()
+                                .saturating_duration_since(tokio::time::Instant::now())
+                                + Duration::from_millis(1),
+                        )
+                        .await;
+                        futures_util::poll!(read.as_mut())
+                    } else {
+                        initial
+                    };
+                    let pending_after = expired.is_pending();
+                    // Keep EOF/Ok(n) distinct from an actual TimedOut error.
+                    let boundary_read = format!("{expired:?}");
+                    (pending_before, pending_after, boundary_read)
+                };
+                let continued = if pending_after {
+                    writer
+                        .write_all(b"upload after original setup deadline")
+                        .await?;
+                    writer.flush().await?;
+                    received_after(&progress, before_late_upload).await;
+                    true
+                } else {
+                    false
+                };
+                // Clean up even on the expected RED before asserting it. On
+                // GREEN, this stops an active stream with no HTTP response.
+                outbound.shutdown().await;
+                let stopped_read = match reader.read(&mut byte).await {
+                    Ok(0) | Err(_) => true,
+                    Ok(_) => false,
+                };
+                let stopped_write = writer.write_all(b"after Stop").await.is_err();
+                Ok::<_, std::io::Error>((
+                    before_deadline,
+                    pending_before,
+                    pending_after,
+                    boundary_read,
+                    continued,
+                    stopped_read && stopped_write,
+                ))
+            })
+            .await;
+            // Bound a broken Core Stop as well as the scenario itself.
+            let core_stopped = tokio::time::timeout(Duration::from_secs(1), outbound.shutdown())
+                .await
+                .is_ok();
+            drop(outbound);
+            upstream.tasks.close();
+            // First require the Core close to reach the peer naturally. A
+            // fallback cancellation must not turn a broken Stop into GREEN.
+            let naturally_joined =
+                tokio::time::timeout(Duration::from_secs(1), upstream.tasks.wait())
+                    .await
+                    .is_ok();
+            progress.cancel.cancel();
+            let joined = tokio::time::timeout(Duration::from_secs(1), upstream.tasks.wait())
+                .await
+                .is_ok();
+            let physical = upstream.physical.load(Ordering::SeqCst);
+            (
+                result.map(|outcome| outcome.map(|value| (value, physical))),
+                core_stopped,
+                naturally_joined,
+                joined,
+            )
+        })
+        .await;
+    assert!(joined, "memory H2 peer tasks must join even after failure");
+    assert!(
+        probe.snapshot().is_idle(),
+        "Core resources must be released"
+    );
+    assert!(core_stopped, "Core Stop must complete within its watchdog");
+    assert!(
+        naturally_joined,
+        "Core Stop must close the peer without fallback cancellation"
+    );
+    let (
+        (before_deadline, pending_before, pending_after, boundary_read, continued, stopped),
+        physical,
+    ) = result
+        .expect("memory scenario watchdog")
+        .expect("memory scenario IO");
+    assert!(
+        before_deadline,
+        "initial read must be polled before the original setup deadline"
+    );
+    assert!(
+        pending_before,
+        "peer has not sent HTTP response headers: {boundary_read}"
+    );
+    assert!(
+        pending_after,
+        "committed auth must not expire or EOF: {boundary_read}"
+    );
+    assert!(
+        continued,
+        "peer must receive upload after original setup deadline"
+    );
+    assert!(
+        stopped,
+        "Stop must end pending reads and reject later writes"
+    );
+    assert_eq!(physical, 1, "no reconnect or replay");
+}
+
+#[cfg(all(feature = "interop-test", feature = "outbound-trojan"))]
+#[tokio::test(start_paused = true)]
+async fn trojan_grpc_committed_auth_survives_setup_deadline_validates_late_status_and_stops() {
+    use std::{io, task::Poll};
+    use tokio::io::AsyncReadExt;
+    use vole::{outbound::trojan::TrojanOutbound, resources::observation::ResourceProbe};
+
+    async fn received_after(progress: &DelayedResponse, before: usize) {
+        loop {
+            let changed = progress.changed.notified();
+            if progress.received.load(Ordering::Acquire) > before {
+                return;
+            }
+            changed.await;
+        }
+    }
+
+    let probe = ResourceProbe::default();
+    let (result, core_stopped, naturally_joined, joined) = probe.scope(async {
+        let identity = rcgen::generate_simple_self_signed(vec!["fixture.invalid".into()]).unwrap();
+        let mut tls = rustls::ServerConfig::builder_with_provider(Arc::new(
+            rustls::crypto::ring::default_provider(),
+        ))
+        .with_protocol_versions(&[&rustls::version::TLS13]).unwrap()
+        .with_no_client_auth()
+        .with_single_cert(
+            vec![identity.cert.der().clone()],
+            rustls::pki_types::PrivateKeyDer::Pkcs8(
+                rustls::pki_types::PrivatePkcs8KeyDer::from(identity.signing_key.serialize_der()),
+            ),
+        ).unwrap();
+        tls.alpn_protocols = vec![b"h2".to_vec()];
+        let config = Config::parse_yaml(br#"proxies:
+  - name: edge
+    type: trojan
+    server: fixture.invalid
+    port: 443
+    password: password
+    skip-cert-verify: true
+    network: grpc
+    grpc-opts: {grpc-service-name: edge, grpc-user-agent: vmess-memory}
+rules: ['MATCH,edge']
+"#).unwrap();
+        let ProxyProtocol::Trojan(node) = &config.proxies[0].protocol else { unreachable!() };
+        let (requests, mut observed) = tokio::sync::mpsc::unbounded_channel();
+        let progress = Arc::new(DelayedResponse::default());
+        let upstream = Arc::new(MemoryUpstream {
+            physical: AtomicUsize::new(0), tasks: TaskTracker::new(), requests,
+            delayed: Some(progress.clone()), tls: Some(Arc::new(tls)),
+        });
+        let outbound = TrojanOutbound::new_with_path(node, UpstreamPath::proxy(upstream.clone())).unwrap();
+        let session = StreamSession {
+            metadata: Default::default(), inbound: InboundKind::InternalMeasure,
+            source: "127.0.0.1:1".parse().unwrap(),
+            destination: "192.0.2.1:80".parse::<std::net::SocketAddr>().unwrap().into(),
+            sniffed_domain: None,
+        };
+        let result = tokio::time::timeout(Duration::from_secs(30), async {
+            let mut checks = Vec::new();
+            // Reject a late error status; keep half-close; stop an unresolved read.
+            for status in [503u16, 200, 0] {
+                let context = EstablishContext::with_timeout(Duration::from_secs(2));
+                let stream = outbound.connect_stream(session.clone(), &context).await
+                    .map_err(io::Error::other)?.io;
+                let authentication = observed.recv().await.ok_or_else(|| io::Error::other("fixture auth event missing"))?;
+                // Independent Trojan password vector from tests/trojan.rs and IPv4 SOCKS address.
+                let mut expected = vec![0, 0, 0, 0, 70, 0x0a, 68];
+                expected.extend_from_slice(b"d63dc919e201d7bc4c825630d2cf25fdc93d4b2f0d46706d29038d01\r\n\x01\x01\xc0\x00\x02\x01\x00\x50\r\n");
+                if authentication != expected {
+                    return Err(io::Error::other("fixture did not observe the complete Trojan auth request"));
+                }
+                let (mut reader, mut writer) = tokio::io::split(stream);
+                let before = progress.received.load(Ordering::Acquire);
+                writer.write_all(b"before original setup deadline").await?;
+                writer.flush().await?;
+                received_after(&progress, before).await;
+                let mut byte = [0; 1];
+                let (pending_before, pending_after, boundary, check) = {
+                    let read = reader.read(&mut byte);
+                    tokio::pin!(read);
+                    if tokio::time::Instant::now() >= context.deadline() {
+                        return Err(io::Error::other("fixture first read started after setup deadline"));
+                    }
+                    let initial = futures_util::poll!(read.as_mut());
+                    let pending_before = initial.is_pending();
+                    let boundary = if pending_before {
+                        tokio::time::advance(context.deadline().saturating_duration_since(tokio::time::Instant::now()) + Duration::from_millis(1)).await;
+                        futures_util::poll!(read.as_mut())
+                    } else { initial };
+                    let pending_after = boundary.is_pending();
+                    let observed_boundary = match &boundary {
+                        Poll::Ready(Err(error)) => format!("Err({:?})", error.kind()),
+                        Poll::Ready(Ok(count)) => format!("Ok({count})"),
+                        Poll::Pending => "Pending".to_owned(),
+                    };
+                    let check = if pending_after {
+                        let before = progress.received.load(Ordering::Acquire);
+                        writer.write_all(b"upload after original setup deadline").await?;
+                        writer.flush().await?;
+                        received_after(&progress, before).await;
+                        if status == 0 {
+                            // Await the exact same read first polled before the deadline.
+                            tokio::time::timeout(Duration::from_secs(1), outbound.shutdown()).await
+                                .map_err(|_| io::Error::other("Core Stop watchdog"))?;
+                            let woke = matches!(read.await, Ok(0) | Err(_));
+                            woke && writer.write_all(b"after Stop").await.is_err()
+                        } else {
+                            progress.status.store(usize::from(status), Ordering::Release);
+                            progress.reply.notify_one();
+                            if status == 200 {
+                                writer.shutdown().await?;
+                                writer.shutdown().await?;
+                                let closed = writer.write_all(b"after upload shutdown").await.is_err();
+                                // Remaining bytes are read only after this pinned first-byte read ends.
+                                matches!(read.await, Ok(1)) && closed
+                            } else {
+                                matches!(read.await, Err(error) if error.kind() == io::ErrorKind::InvalidData)
+                            }
+                        }
+                    } else { false };
+                    (pending_before, pending_after, observed_boundary, check)
+                };
+                let check = if pending_after && status == 200 {
+                    let mut tail = Vec::new();
+                    reader.read_to_end(&mut tail).await?;
+                    check && byte == [b't'] && tail == b"ail"
+                } else { check };
+                checks.push((status, pending_before, pending_after, boundary, check));
+                drop((reader, writer));
+                if !pending_before || !pending_after || !check { break; }
+            }
+            Ok::<_, io::Error>(checks)
+        }).await;
+        let core_stopped = tokio::time::timeout(Duration::from_secs(1), outbound.shutdown()).await.is_ok();
+        drop(outbound);
+        upstream.tasks.close();
+        let naturally_joined = tokio::time::timeout(Duration::from_secs(1), upstream.tasks.wait()).await.is_ok();
+        progress.cancel.cancel();
+        let joined = tokio::time::timeout(Duration::from_secs(1), upstream.tasks.wait()).await.is_ok();
+        let physical = upstream.physical.load(Ordering::SeqCst);
+        (result.map(|io| io.map(|checks| (checks, physical))), core_stopped, naturally_joined, joined)
+    }).await;
+    assert!(joined, "memory TLS/H2 peer tasks must join even after RED");
+    assert!(
+        probe.snapshot().is_idle(),
+        "Core resources must be released before behavior assertions"
+    );
+    assert!(
+        core_stopped && naturally_joined,
+        "Core Stop must close the peer naturally without fallback cancellation"
+    );
+    let (checks, physical) = result
+        .expect("memory scenario watchdog")
+        .expect("memory fixture or scenario IO");
+    for (status, before, after, boundary, check) in &checks {
+        assert!(
+            before,
+            "HTTP response gate must be pending before deadline: status={status}, {boundary}"
+        );
+        assert!(
+            after,
+            "committed Trojan auth must outlive original setup deadline: status={status}, {boundary}"
+        );
+        assert!(
+            check,
+            "late status/half-close/same-read Stop contract: status={status}, {boundary}"
+        );
+    }
+    assert_eq!(
+        checks.len(),
+        3,
+        "all three response/lifecycle phases must complete"
+    );
+    assert_eq!(
+        physical, 1,
+        "the actual Trojan private pool must not reconnect or replay"
+    );
+}
diff --git a/tests/h2_stream_regression.rs b/tests/h2_stream_regression.rs
index 68b3738..e5bbe32 100644
--- a/tests/h2_stream_regression.rs
+++ b/tests/h2_stream_regression.rs
@@ -70,11 +70,6 @@ async fn response_followed_by_reset(end_stream: bool) -> std::io::Result<Vec<u8>
 
 #[tokio::test]
 async fn xhttp_keeps_complete_response_when_peer_resets_after_end_stream() {
-    #[cfg(feature = "interop-test")]
-    let _evidence = vole::resources::case_events::Case::new(
-        "VMESS-REGRESSION",
-        "xhttp_keeps_complete_response_when_peer_resets_after_end_stream",
-    );
     let response = response_followed_by_reset(true)
         .await
         .expect("END_STREAM must retain complete DATA despite a subsequent reset");
@@ -83,11 +78,6 @@ async fn xhttp_keeps_complete_response_when_peer_resets_after_end_stream() {
 
 #[tokio::test]
 async fn xhttp_does_not_hide_reset_before_end_stream() {
-    #[cfg(feature = "interop-test")]
-    let _evidence = vole::resources::case_events::Case::new(
-        "VMESS-REGRESSION",
-        "xhttp_does_not_hide_reset_before_end_stream",
-    );
     let error = response_followed_by_reset(false)
         .await
         .expect_err("a reset before END_STREAM must not become successful EOF");
diff --git a/tests/httpupgrade_config.rs b/tests/httpupgrade_config.rs
index 5789bdc..e0052b2 100644
--- a/tests/httpupgrade_config.rs
+++ b/tests/httpupgrade_config.rs
@@ -35,11 +35,9 @@ fn options(protocol: &str, value: Value) -> WebSocketOptions {
 
 #[test]
 fn httpupgrade_rejects_ambiguous_modes_and_early_data_before_io() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new("HTTPUPGRADE-UNIT", "config_bounds");
     for &protocol in PROTOCOLS {
         for fast in [false, true] {
-            for early in [0, 1, 2048] {
+            for early in [0, 1, 2048, 2049, 4096, u16::MAX] {
                 let opts = json!({"v2ray-http-upgrade":true,"v2ray-http-upgrade-fast-open":fast,"max-early-data":early});
                 assert!(Config::parse_yaml(&document(protocol, opts.clone())).is_ok());
                 if early > 0 {
@@ -55,7 +53,7 @@ fn httpupgrade_rejects_ambiguous_modes_and_early_data_before_io() {
             json!({"v2ray-http-upgrade":"true"}),
             json!({"v2ray-http-upgrade-fast-open":null}),
             json!({"v2ray-http-upgrade-fast-open":1}),
-            json!({"max-early-data":2049}),
+            json!({"max-early-data":65536}),
             json!({"max-early-data":-1}),
             json!({"max-early-data":null}),
             json!({"max-early-data":1,"early-data-header-name":""}),
@@ -65,7 +63,7 @@ fn httpupgrade_rejects_ambiguous_modes_and_early_data_before_io() {
             json!({"headers":{"Sec-WebSocket-Protocol":"override"}}),
             json!({"headers":{"Upgrade":"override"}}),
             json!({"headers":{"Host":"one.invalid","host":"two.invalid"}}),
-            json!({"path":"/bad#fragment"}),
+            json!({"path":"relative"}),
             json!({"unexpected":true}),
         ] {
             let mut opts = json!({"v2ray-http-upgrade":true});
@@ -89,14 +87,12 @@ fn httpupgrade_rejects_ambiguous_modes_and_early_data_before_io() {
 
 #[tokio::test]
 async fn httpupgrade_configuration_selects_raw_upgrade_and_commits_prefix_once() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new("HTTPUPGRADE-UNIT", "config_dispatch");
     for &protocol in PROTOCOLS {
         for fast in [false, true] {
             let options = options(
                 protocol,
                 json!({
-                    "path":"/upgrade?q=1","headers":{"Host":"cover.invalid:443"},
+                    "path":"/upgrade?q=1#client-only","headers":{"Host":"cover.invalid:443"},
                     "v2ray-http-upgrade":true,"v2ray-http-upgrade-fast-open":fast
                 }),
             );
diff --git a/tests/httpupgrade_memory.rs b/tests/httpupgrade_memory.rs
index c45b840..57ce6d6 100644
--- a/tests/httpupgrade_memory.rs
+++ b/tests/httpupgrade_memory.rs
@@ -25,8 +25,6 @@ async fn head(peer: &mut tokio::io::DuplexStream) -> Vec<u8> {
 
 #[tokio::test]
 async fn httpupgrade_early_data_partial_writes_and_response_tail_keep_byte_order() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new("HTTPUPGRADE-UNIT", "early_data");
     use base64::{Engine as _, engine::general_purpose::URL_SAFE_NO_PAD};
     tokio::time::timeout(Duration::from_secs(5), async {
         for fast in [false, true] {
@@ -79,8 +77,6 @@ async fn httpupgrade_early_data_partial_writes_and_response_tail_keep_byte_order
 
 #[tokio::test]
 async fn httpupgrade_rejects_invalid_oversized_and_truncated_responses_without_replay() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new("HTTPUPGRADE-UNIT", "invalid_response");
     let responses = [
         "HTTP/1.1 200 OK\r\nConnection: Upgrade\r\nUpgrade: websocket\r\n\r\n".to_owned(),
         "HTTP/1.0 101 OK\r\nConnection: Upgrade\r\nUpgrade: websocket\r\n\r\n".to_owned(),
@@ -132,8 +128,6 @@ async fn httpupgrade_rejects_invalid_oversized_and_truncated_responses_without_r
 
 #[tokio::test(start_paused = true)]
 async fn httpupgrade_waits_for_101_under_the_original_deadline_and_drops_cancelled_io() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new("HTTPUPGRADE-UNIT", "deadline_cancel");
     for fast in [false, true] {
         let start = Instant::now();
         let deadline = start + Duration::from_millis(100);
@@ -166,8 +160,6 @@ async fn httpupgrade_waits_for_101_under_the_original_deadline_and_drops_cancell
 
 #[tokio::test]
 async fn expired_httpupgrade_deadline_writes_no_prefix_or_head() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new("HTTPUPGRADE-UNIT", "expired_deadline");
     for fast in [false, true] {
         let (io, mut peer) = tokio::io::duplex(4096);
         let result = connect_websocket(
@@ -186,8 +178,6 @@ async fn expired_httpupgrade_deadline_writes_no_prefix_or_head() {
 
 #[tokio::test(start_paused = true)]
 async fn httpupgrade_rejects_ready_101_after_waiting_past_setup_deadline() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new("HTTPUPGRADE-UNIT", "late_response");
     for fast in [false, true] {
         let options = options(fast);
         let (io, mut peer) = tokio::io::duplex(4096);
@@ -221,8 +211,6 @@ async fn httpupgrade_rejects_ready_101_after_waiting_past_setup_deadline() {
 
 #[tokio::test(start_paused = true)]
 async fn httpupgrade_does_not_resume_a_blocked_prefix_after_setup_deadline() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new("HTTPUPGRADE-UNIT", "late_write");
     const RESPONSE: &[u8] =
         b"HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nUpgrade: websocket\r\n\r\n";
     tokio::time::timeout(Duration::from_secs(5), async {
@@ -272,8 +260,6 @@ async fn httpupgrade_does_not_resume_a_blocked_prefix_after_setup_deadline() {
 
 #[tokio::test(start_paused = true)]
 async fn established_httpupgrade_io_outlives_its_setup_deadline() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new("HTTPUPGRADE-UNIT", "established_io");
     for fast in [false, true] {
         let (io, mut peer) = tokio::io::duplex(4096);
         peer.write_all(b"HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nUpgrade: websocket\r\n\r\ntail")
diff --git a/tests/hysteria2_config.rs b/tests/hysteria2_config.rs
index 4349332..e147d30 100644
--- a/tests/hysteria2_config.rs
+++ b/tests/hysteria2_config.rs
@@ -2,32 +2,27 @@ use vole::config::Config;
 
 #[test]
 fn hysteria2_configuration_follows_its_protocol_feature() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "HYSTERIA2-CFG",
-        "hysteria2_configuration_follows_its_protocol_feature",
-    );
     let yaml = b"mixed-port: 1080\nproxies: [{name: edge, type: hysteria2, server: localhost, port: 443}]\nrules: ['MATCH,edge']\n";
     let result = Config::parse_yaml(yaml);
     assert_eq!(result.is_ok(), cfg!(feature = "outbound-hysteria2"));
     if let Ok(config) = result {
-        assert_eq!(config.proxies[0].address(), "localhost");
-        assert_eq!(config.proxies[0].port(), 443);
-        assert!(!config.proxies[0].udp);
+        assert_eq!(
+            config.proxies[0].server_endpoint(),
+            Some(("localhost", 443))
+        );
+        assert!(config.proxies[0].udp);
     }
 }
 
 #[cfg(feature = "outbound-hysteria2")]
 #[test]
 fn hysteria2_accepts_the_approved_tls_bandwidth_obfs_and_hopping_configuration() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "HYSTERIA2-CFG",
-        "hysteria2_accepts_the_approved_tls_bandwidth_obfs_and_hopping_configuration",
-    );
     let yaml = b"mixed-port: 1080\nproxies:\n  - name: edge\n    type: hysteria2\n    server: localhost\n    ports: 443,8443-8445,8443\n    password: ' credential '\n    udp: true\n    up: 2 Mbps\n    down: 125 KBps\n    udp-mtu: 1200\n    hop-interval: 5-7\n    obfs: salamander\n    obfs-password: ' independent secret '\n    sni: tls.example.com\n    alpn: [custom-h3]\n    skip-cert-verify: true\n    dialer-proxy: upstream\nproxy-groups: [{name: upstream, type: select, proxies: [DIRECT, REJECT]}]\nrules: ['MATCH,edge']\n";
     let config = Config::parse_yaml(yaml).expect("approved Hysteria2 fields");
-    assert_eq!(config.proxies[0].port(), 443);
+    assert_eq!(
+        config.proxies[0].server_endpoint(),
+        Some(("localhost", 443))
+    );
     assert!(config.proxies[0].udp);
     assert!(config.proxies[0].dialer_proxy.is_some());
     assert!(!format!("{config:?}").contains("credential"));
@@ -37,11 +32,6 @@ fn hysteria2_accepts_the_approved_tls_bandwidth_obfs_and_hopping_configuration()
 #[cfg(feature = "outbound-hysteria2")]
 #[test]
 fn hysteria2_fields_are_strict_normalized_and_credentials_are_not_trimmed() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "HYSTERIA2-CFG",
-        "hysteria2_fields_are_strict_normalized_and_credentials_are_not_trimmed",
-    );
     use serde_json::{Value, json};
     use vole::config::ProxyProtocol;
     let base = json!({"name":"edge", "type":"hysteria2", "server":"localhost", "port":443});
@@ -61,6 +51,23 @@ fn hysteria2_fields_are_strict_normalized_and_credentials_are_not_trimmed() {
         node
     };
     let defaults = normalized(base.clone());
+    for field in ["obfs", "ports"] {
+        let mut raw = base.clone();
+        raw[field] = json!("");
+        assert_eq!(normalized(raw), defaults, "empty {field} uses defaults");
+    }
+    let mut wildcard = base.clone();
+    wildcard["ports"] = json!("*");
+    assert_eq!(normalized(wildcard), defaults);
+    for (ports, expected) in [
+        ("1,,2", vec![1, 2]),
+        ("2-1", vec![1, 2]),
+        ("8445-8443/443,,8444", vec![443, 8443, 8444, 8445]),
+    ] {
+        let mut raw = base.clone();
+        raw["ports"] = json!(ports);
+        assert_eq!(normalized(raw).hopping.unwrap().ports, expected);
+    }
     for field in [
         "name",
         "server",
@@ -70,6 +77,7 @@ fn hysteria2_fields_are_strict_normalized_and_credentials_are_not_trimmed() {
         "sni",
         "alpn",
         "skip-cert-verify",
+        "name-cert-verify",
         "fingerprint",
         "certificate",
         "private-key",
@@ -91,11 +99,22 @@ fn hysteria2_fields_are_strict_normalized_and_credentials_are_not_trimmed() {
             );
         }
     }
-    assert_eq!((defaults.up, defaults.down, defaults.udp_mtu), (0, 0, 1197));
+    assert_eq!((defaults.up, defaults.down, defaults.udp_mtu), (0, 0, 1400));
     assert_eq!(defaults.password, "");
     assert_eq!(defaults.tls.server_name, "localhost");
     assert_eq!(defaults.tls.alpn, vec![b"h3".to_vec()]);
     assert!(defaults.tls.tls13_only);
+    let mut raw = base.clone();
+    raw["sni"] = json!("public.example.com");
+    raw["name-cert-verify"] = json!("verified.example.com");
+    let node = normalized(raw.clone());
+    assert_eq!(node.tls.server_name, "public.example.com");
+    assert_eq!(
+        node.tls.certificate.verification_name.as_deref(),
+        Some("verified.example.com")
+    );
+    raw["name-cert-verify"] = json!("bad\nname");
+    assert!(parse(raw).is_err());
     for (value, expected) in [
         (json!(2), 250000),
         (json!("2"), 250000),
@@ -123,15 +142,23 @@ fn hysteria2_fields_are_strict_normalized_and_credentials_are_not_trimmed() {
     let node = normalized(raw.clone());
     assert_eq!(node.password, "  raw credential  ");
     assert_eq!(node.port, 443);
-    assert_eq!(node.udp_mtu, 1197);
+    assert_eq!(node.udp_mtu, 1400);
     let hopping = node.hopping.unwrap();
     assert_eq!(hopping.ports, vec![443, 8443, 8444, 8445]);
     assert_eq!((hopping.min_seconds, hopping.max_seconds), (5, 7));
     raw.as_object_mut().unwrap().remove("port");
     assert!(parse(raw.clone()).is_ok());
-    for interval in [json!(5), json!("5"), json!("4294967295")] {
+    for (interval, expected) in [
+        (json!(0), (30, 30)),
+        (json!(4), (5, 5)),
+        (json!("7-5"), (5, 7)),
+        (json!(5), (5, 5)),
+        (json!("5"), (5, 5)),
+        (json!("4294967295"), (u32::MAX, u32::MAX)),
+    ] {
         raw["hop-interval"] = interval;
-        assert!(parse(raw.clone()).is_ok());
+        let hopping = normalized(raw.clone()).hopping.unwrap();
+        assert_eq!((hopping.min_seconds, hopping.max_seconds), expected);
     }
     for mtu in [64, 65535] {
         let mut raw = base.clone();
@@ -157,16 +184,7 @@ fn hysteria2_fields_are_strict_normalized_and_credentials_are_not_trimmed() {
         ),
         (
             "ports",
-            vec![
-                json!(""),
-                json!("1,,2"),
-                json!("2-1"),
-                json!("0"),
-                json!("65536"),
-                json!("*"),
-                json!([443]),
-                Value::Null,
-            ],
+            vec![json!("0"), json!("65536"), json!([443]), Value::Null],
         ),
         (
             "alpn",
@@ -199,7 +217,6 @@ fn hysteria2_fields_are_strict_normalized_and_credentials_are_not_trimmed() {
         ("tls", json!(false)),
         ("network", json!("tcp")),
         ("client-fingerprint", json!("chrome")),
-        ("name-cert-verify", json!("localhost")),
         ("certificate", json!("bad")),
         ("private-key", json!("bad")),
         ("obfs", json!("salamander")),
@@ -210,23 +227,80 @@ fn hysteria2_fields_are_strict_normalized_and_credentials_are_not_trimmed() {
         raw[field] = value;
         assert!(parse(raw).is_err(), "{field}");
     }
-    for value in [
-        json!(0),
-        json!(4),
-        json!("7-5"),
-        json!("5s"),
-        json!("4294967296"),
-        Value::Null,
-    ] {
+    for value in [json!("5s"), json!("4294967296"), Value::Null] {
         let mut raw = base.clone();
         raw["ports"] = json!("443");
         raw["hop-interval"] = value;
         assert!(parse(raw).is_err());
     }
-    for value in [json!(""), json!("gecko")] {
+    for value in [json!("")] {
         let mut raw = base.clone();
         raw["obfs"] = value;
         raw["obfs-password"] = json!("secret");
         assert!(parse(raw).is_err());
     }
 }
+
+#[cfg(feature = "outbound-hysteria2")]
+#[test]
+fn receive_windows_are_independent_and_preserve_initial_above_maximum() {
+    use vole::config::{ProxyProtocol, QuicReceiveWindow};
+    let parse = |fields: &str| {
+        let yaml = format!(
+            "mixed-port: 1080\nproxies:\n  - name: edge\n    type: hysteria2\n    server: localhost\n    port: 443\n{fields}rules: ['MATCH,edge']\n"
+        );
+        let c = Config::parse_yaml(yaml.as_bytes()).unwrap();
+        let ProxyProtocol::Hysteria2(config) = c.proxies.into_iter().next().unwrap().protocol
+        else {
+            panic!("HY2")
+        };
+        config
+    };
+    let defaults = parse("");
+    assert_eq!(
+        defaults.stream_window,
+        QuicReceiveWindow {
+            initial: 64 * 1024,
+            maximum: 64 * 1024
+        }
+    );
+    assert_eq!(
+        defaults.connection_window,
+        QuicReceiveWindow {
+            initial: 4 * 1024 * 1024,
+            maximum: 4 * 1024 * 1024
+        }
+    );
+    let large = parse(
+        "    initial-connection-receive-window: 20971520\n    max-connection-receive-window: 16777216\n",
+    );
+    assert_eq!(
+        large.connection_window,
+        QuicReceiveWindow {
+            initial: 20 * 1024 * 1024,
+            maximum: 16 * 1024 * 1024,
+        }
+    );
+    let config = parse(
+        "    initial-stream-receive-window: 400\n    max-stream-receive-window: 200\n    initial-connection-receive-window: 600\n    max-connection-receive-window: 1200\n    handshake-timeout: 2\n",
+    );
+    assert_eq!(
+        config.stream_window,
+        QuicReceiveWindow {
+            initial: 400,
+            maximum: 200
+        }
+    );
+    assert_eq!(
+        config.connection_window,
+        QuicReceiveWindow {
+            initial: 600,
+            maximum: 1200
+        }
+    );
+    assert_eq!(config.handshake_timeout, std::time::Duration::from_secs(2));
+    let config =
+        parse("    max-stream-receive-window: 18446744073709551615\n    handshake-timeout: -1\n");
+    assert_eq!(config.stream_window.maximum, (1_u64 << 62) - 1);
+    assert!(config.handshake_timeout.is_zero());
+}
diff --git a/tests/hysteria2_packet_ids.rs b/tests/hysteria2_packet_ids.rs
index 77325a2..d609ab2 100644
--- a/tests/hysteria2_packet_ids.rs
+++ b/tests/hysteria2_packet_ids.rs
@@ -4,7 +4,10 @@ use bytes::Bytes;
 use std::{
     io::IoSliceMut,
     net::SocketAddr,
-    sync::{Arc, Mutex},
+    sync::{
+        Arc, Mutex,
+        atomic::{AtomicUsize, Ordering},
+    },
     task::{Context, Poll},
     time::Duration,
 };
@@ -64,17 +67,12 @@ fn memory_udp_peer_shutdown_is_not_a_local_socket_failure() {
     ));
 }
 
-#[tokio::test]
-async fn completed_fragment_id_can_be_reused_without_losing_the_next_datagram() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "INTEGRATION-ADAPTER",
-        "hysteria2_fragment_id_reuse",
-    );
+fn memory_fixture() -> (MemoryPackets, quinn::Endpoint, mpsc::Sender<Bytes>) {
     let server_address: SocketAddr = "192.0.2.1:443".parse().unwrap();
     let client_address: SocketAddr = "192.0.2.2:1234".parse().unwrap();
     let (to_server, from_client) = mpsc::channel(32);
     let (to_client, from_server) = mpsc::channel(32);
+    let client_link = to_client.clone();
     let client_io = MemoryPackets {
         send: to_server,
         receive: from_server,
@@ -88,10 +86,14 @@ async fn completed_fragment_id_can_be_reused_without_losing_the_next_datagram()
     });
     let certificate = rcgen::generate_simple_self_signed(vec!["fixture.invalid".into()]).unwrap();
     let key = rustls::pki_types::PrivatePkcs8KeyDer::from(certificate.signing_key.serialize_der());
-    let mut tls = rustls::ServerConfig::builder()
-        .with_no_client_auth()
-        .with_single_cert(vec![certificate.cert.der().clone()], key.into())
-        .unwrap();
+    let mut tls = rustls::ServerConfig::builder_with_provider(Arc::new(
+        rustls::crypto::ring::default_provider(),
+    ))
+    .with_protocol_versions(&[&rustls::version::TLS13])
+    .unwrap()
+    .with_no_client_auth()
+    .with_single_cert(vec![certificate.cert.der().clone()], key.into())
+    .unwrap();
     tls.alpn_protocols = vec![b"h3".to_vec()];
     let crypto = quinn::crypto::rustls::QuicServerConfig::try_from(tls).unwrap();
     let mut server_config = quinn::ServerConfig::with_crypto(Arc::new(crypto));
@@ -106,6 +108,15 @@ async fn completed_fragment_id_can_be_reused_without_losing_the_next_datagram()
         Arc::new(quinn::TokioRuntime),
     )
     .unwrap();
+    (client_io, endpoint, client_link)
+}
+
+#[tokio::test]
+async fn completed_fragment_id_can_be_reused_without_losing_the_next_datagram() {
+    let client_address = "192.0.2.2:1234".parse().unwrap();
+    let (client_io, endpoint, _) = memory_fixture();
+    let queued_packets = Arc::new(AtomicUsize::new(0));
+    let peer_queued_packets = queued_packets.clone();
     let peer = tokio::spawn(async move {
         let connection = endpoint.accept().await.unwrap().await.unwrap();
         let mut h3 = h3::server::builder()
@@ -135,17 +146,45 @@ async fn completed_fragment_id_can_be_reused_without_losing_the_next_datagram()
         response.finish().await.unwrap();
         // Native Hysteria randomizes its 16-bit Packet ID. A completed ID can
         // recur, including immediately; Mihomo releases the completed pieces.
+        let mut sibling_packet_ids = Vec::new();
         for (sequence, id) in [17_u16, 18, 17, 17].into_iter().enumerate() {
-            let Ok(request) = connection.read_datagram().await else {
-                break;
+            let request = loop {
+                let Ok(request) = connection.read_datagram().await else {
+                    break None;
+                };
+                if request[..4] != [0; 4] {
+                    sibling_packet_ids.push(u16::from_be_bytes([request[4], request[5]]));
+                    continue;
+                }
+                // Saturation traffic is deliberately fragmented. The
+                // cancelled admission must not consume another Packet ID.
+                if request[7] > 1 {
+                    continue;
+                }
+                break Some(request);
             };
-            assert_eq!(&request[6..], &[0, 1, 3, b'x', b':', b'1', sequence as u8]);
+            let Some(request) = request else { break };
+            let target = format!("192.0.2.{}:53", sequence + 10);
+            assert_eq!(
+                u16::from_be_bytes([request[4], request[5]]),
+                (sequence
+                    + if sequence > 0 {
+                        peer_queued_packets.load(Ordering::Relaxed)
+                    } else {
+                        0
+                    }) as u16
+            );
+            assert_eq!(&request[6..8], &[0, 1]);
+            assert_eq!(usize::from(request[8]), target.len());
+            assert_eq!(&request[9..request.len() - 1], target.as_bytes());
+            assert_eq!(request[request.len() - 1], sequence as u8);
             // Literal protocol fixtures, independent of Vole's wire encoder.
             // Out of order plus a duplicate within the unfinished assembly.
             for index in [1, 1, 0] {
                 let mut frame = request[..4].to_vec();
                 frame.extend_from_slice(&id.to_be_bytes());
-                frame.extend_from_slice(&[index, 2, 3, b'x', b':', b'1']);
+                frame.extend_from_slice(&[index, 2, target.len() as u8]);
+                frame.extend_from_slice(target.as_bytes());
                 frame.extend_from_slice(&[sequence as u8; 50]);
                 connection.send_datagram_wait(frame.into()).await.unwrap();
             }
@@ -154,8 +193,9 @@ async fn completed_fragment_id_can_be_reused_without_losing_the_next_datagram()
         drop(h3);
         endpoint.close(0_u32.into(), b"");
         endpoint.wait_idle().await;
+        sibling_packet_ids
     });
-    let config = Config::parse_yaml(br#"{"mixed-port":1080,"proxies":[{"name":"peer","type":"hysteria2","server":"192.0.2.1","port":443,"udp":true,"skip-cert-verify":true,"sni":"fixture.invalid"}],"rules":["MATCH,peer"]}"#).unwrap();
+    let config = Config::parse_yaml(br#"{"mixed-port":1080,"proxies":[{"name":"peer","type":"hysteria2","server":"192.0.2.1","port":443,"udp":true,"udp-mtu":64,"skip-cert-verify":true,"sni":"fixture.invalid"}],"rules":["MATCH,peer"]}"#).unwrap();
     let ProxyProtocol::Hysteria2(config) = &config.proxies[0].protocol else {
         panic!("protocol")
     };
@@ -177,34 +217,540 @@ async fn completed_fragment_id_can_be_reused_without_losing_the_next_datagram()
     .await
     .expect("memory peer must authenticate")
     .unwrap();
+    let mut sibling = outbound
+        .open_datagram(
+            DatagramRequest::new(DatagramSession::new(
+                InboundKind::InternalMeasure,
+                client_address,
+            )),
+            &EstablishContext::default(),
+        )
+        .await
+        .unwrap();
+    let shareable = udp.supports_shared_destinations();
     let mut delivered = Vec::new();
+    let mut shared_sender_blocked = false;
+    let mut shutdown_rejected_admission = false;
+    let mut shutdown_queued = 0;
     let outcome = tokio::time::timeout(Duration::from_secs(2), async {
-        let target = Destination::domain("x", 1).unwrap();
         for sequence in 0..4 {
-            udp.send(Datagram {
+            assert!(futures_util::poll!(udp.receive()).is_pending());
+            let target = Destination::Ip(format!("192.0.2.{}:53", sequence + 10).parse().unwrap());
+            let request = Datagram {
                 remote: target.clone(),
                 payload: vec![sequence].into(),
                 sniffed_domain: None,
-            })
-            .await
-            .unwrap();
+            };
+            if sequence == 1 {
+                let large = Datagram {
+                    payload: vec![sequence; 4096].into(),
+                    ..request.clone()
+                };
+                loop {
+                    let mut pending = Box::pin(tokio::task::unconstrained(udp.send(large.clone())));
+                    if let Poll::Ready(result) = futures_util::poll!(pending.as_mut()) {
+                        result.unwrap();
+                        drop(pending);
+                        let accepted = queued_packets.fetch_add(1, Ordering::Relaxed) + 1;
+                        assert!(accepted <= vole::limits::HY2_SUBMISSION_QUEUE);
+                        continue;
+                    }
+                    let probe = Datagram {
+                        remote: target.clone(),
+                        payload: vec![255].into(),
+                        sniffed_domain: None,
+                    };
+                    let mut waiting =
+                        Box::pin(tokio::task::unconstrained(sibling.send(probe.clone())));
+                    shared_sender_blocked = match futures_util::poll!(waiting.as_mut()) {
+                        Poll::Pending => true,
+                        Poll::Ready(result) => {
+                            result.unwrap();
+                            false
+                        }
+                    };
+                    drop(waiting);
+                    drop(pending);
+                    if shared_sender_blocked {
+                        sibling.send(probe).await.unwrap();
+                    }
+                    break;
+                }
+            }
+            udp.send(request).await.unwrap();
             let reply = udp.receive().await.unwrap();
             assert_eq!(reply.remote, target);
             assert_eq!(reply.payload, vec![sequence; 100]);
             delivered.push(sequence);
         }
+        let mut admitted = 0;
+        loop {
+            let mut pending = Box::pin(tokio::task::unconstrained(udp.send(Datagram {
+                remote: Destination::Ip("192.0.2.13:53".parse().unwrap()),
+                payload: vec![0; 4096].into(),
+                sniffed_domain: None,
+            })));
+            if let Poll::Ready(result) = futures_util::poll!(pending.as_mut()) {
+                result.unwrap();
+                drop(pending);
+                admitted += 1;
+                assert!(admitted <= vole::limits::HY2_SUBMISSION_QUEUE);
+                continue;
+            }
+            outbound.begin_shutdown();
+            shutdown_queued = admitted;
+            shutdown_rejected_admission = matches!(
+                pending.await,
+                Err(vole::dispatch::DispatchError::NotAllowed)
+            );
+            break;
+        }
+        sibling.close().await.unwrap();
         udp.close().await.unwrap();
     })
     .await;
     outbound.shutdown().await;
-    tokio::time::timeout(Duration::from_secs(2), peer)
+    let sibling_packet_ids = tokio::time::timeout(Duration::from_secs(2), peer)
         .await
         .unwrap()
         .unwrap();
+    assert!(
+        shared_sender_blocked,
+        "a sibling bypassed the saturated connection queue"
+    );
+    assert_eq!(
+        queued_packets.load(Ordering::Relaxed),
+        vole::limits::HY2_SUBMISSION_QUEUE
+    );
+    assert_eq!(shutdown_queued, vole::limits::HY2_SUBMISSION_QUEUE);
+    assert!(
+        shutdown_rejected_admission,
+        "Stop admitted a queued UDP send"
+    );
+    assert_eq!(
+        sibling_packet_ids,
+        [0],
+        "a cancelled writer reserved a Packet ID"
+    );
     assert_eq!(
         delivered,
         [0, 1, 2, 3],
         "completed Packet IDs are not replay nonces"
     );
     outcome.expect("all legal replies, including completed ID reuse, must be delivered");
+    assert!(
+        shareable,
+        "multi-target HY2 must not allocate a receiver per IP target"
+    );
+}
+
+#[tokio::test(start_paused = true)]
+async fn configured_handshake_timeout_bounds_quic_and_auth_but_not_ready_sessions() {
+    use std::sync::atomic::{AtomicBool, Ordering};
+    use tokio_util::sync::CancellationToken;
+    use vole::dispatch::DispatchError;
+
+    // Field seconds are parsed from actual configuration. Tokio and Quinn use
+    // the same controlled monotonic clock; no socket or alternate TLS provider.
+    // Failed offers publish after the bounded QUIC close barrier. An accepted
+    // peer can acknowledge close early; a shorter caller deadline is independent.
+    for (phase, timeout, parent_ms, minimum_ms, maximum_ms) in [
+        ("quic", 0, 2000, 1800, 1800),
+        ("quic", 1, 3000, 2000, 2000),
+        ("quic", 1, 500, 300, 300),
+        ("auth", 1, 3000, 1000, 2000),
+        ("ready", 1, 3000, 0, 0),
+    ] {
+        let (client_io, endpoint, client_link) = memory_fixture();
+        let initial_observed = Arc::new(AtomicBool::new(false));
+        let auth_observed = Arc::new(AtomicBool::new(false));
+        let stop_peer = CancellationToken::new();
+        let peer = {
+            let endpoint = endpoint.clone();
+            let initial_observed = initial_observed.clone();
+            let auth_observed = auth_observed.clone();
+            let stop = stop_peer.clone();
+            tokio::spawn(async move {
+                let initial = endpoint.accept().await.unwrap();
+                initial_observed.store(true, Ordering::Release);
+                if phase == "quic" {
+                    // A real parsed QUIC Initial is retained without accepting
+                    // its handshake. The configured field must end this wait.
+                    stop.cancelled().await;
+                    drop(initial);
+                    return;
+                }
+                let connection = initial.await.unwrap();
+                let mut h3 = h3::server::builder()
+                    .build::<_, Bytes>(h3_quinn::Connection::new(connection.clone()))
+                    .await
+                    .unwrap();
+                let (request, mut response) = h3
+                    .accept()
+                    .await
+                    .unwrap()
+                    .unwrap()
+                    .resolve_request()
+                    .await
+                    .unwrap();
+                assert_eq!(request.method(), http::Method::POST);
+                assert_eq!(request.uri().path(), "/auth");
+                auth_observed.store(true, Ordering::Release);
+                if phase == "ready" {
+                    response
+                        .send_response(
+                            http::Response::builder()
+                                .status(233)
+                                .header("Hysteria-UDP", "true")
+                                .header("Hysteria-CC-RX", "0")
+                                .body(())
+                                .unwrap(),
+                        )
+                        .await
+                        .unwrap();
+                    response.finish().await.unwrap();
+                    let packet = connection.read_datagram().await.unwrap();
+                    connection.send_datagram_wait(packet).await.unwrap();
+                }
+                // In the auth case no response is sent: QUIC/TLS succeeded,
+                // but this second real establishment stage is still bounded.
+                connection.closed().await;
+                drop((h3, response));
+            })
+        };
+        let raw = serde_json::json!({
+            "proxies": [{"name":"peer", "type":"hysteria2", "server":"192.0.2.1",
+                "port":443, "udp":true, "skip-cert-verify":true, "sni":"fixture.invalid",
+                "handshake-timeout":timeout}],
+            "rules":["MATCH,peer"]
+        });
+        let parsed = Config::parse_yaml(raw.to_string().as_bytes()).unwrap();
+        let ProxyProtocol::Hysteria2(config) = &parsed.proxies[0].protocol else {
+            panic!("Hysteria2")
+        };
+        let outbound = Hysteria2Outbound::new_with_path(
+            config,
+            UpstreamPath::proxy(Arc::new(MemoryUpstream(Mutex::new(Some(client_io))))),
+        )
+        .unwrap();
+        let context = EstablishContext::with_timeout(Duration::from_millis(parent_ms));
+        tokio::time::sleep(Duration::from_millis(200)).await;
+        let started = tokio::time::Instant::now();
+        let request = || {
+            DatagramRequest::new(DatagramSession::new(
+                InboundKind::InternalMeasure,
+                "192.0.2.2:1234".parse().unwrap(),
+            ))
+        };
+        let result = outbound.open_datagram(request(), &context).await;
+        let elapsed = started.elapsed();
+        assert!(initial_observed.load(Ordering::Acquire));
+        if phase == "ready" {
+            let first = result.unwrap();
+            assert!(auth_observed.load(Ordering::Acquire));
+            tokio::time::sleep(Duration::from_secs(2)).await;
+            // A new logical UDP owner reuses the ready physical connection
+            // after its one-second handshake-only deadline has elapsed.
+            let mut reused = outbound
+                .open_datagram(request(), &EstablishContext::default())
+                .await
+                .unwrap();
+            let payload = Datagram {
+                remote: Destination::domain("x", 1).unwrap(),
+                payload: Bytes::from_static(b"after-handshake-deadline"),
+                sniffed_domain: None,
+            };
+            reused.send(payload.clone()).await.unwrap();
+            let echo = reused.receive().await.unwrap();
+            assert_eq!(echo.remote, payload.remote);
+            assert_eq!(echo.payload, payload.payload);
+            outbound.shutdown().await;
+            assert!(reused.receive().await.is_err());
+            drop((first, reused));
+        } else {
+            assert!(
+                matches!(result, Err(DispatchError::TimedOut)),
+                "{phase}: handshake={timeout}s caller={parent_ms}ms"
+            );
+            assert!(
+                (Duration::from_millis(minimum_ms)..=Duration::from_millis(maximum_ms))
+                    .contains(&elapsed),
+                "{phase}: handshake={timeout}s caller={parent_ms}ms elapsed={elapsed:?}"
+            );
+            assert_eq!(
+                auth_observed.load(Ordering::Acquire),
+                phase == "auth",
+                "{phase}: handshake={timeout}s caller={parent_ms}ms"
+            );
+            outbound.shutdown().await;
+        }
+        assert!(
+            client_link.is_closed(),
+            "Stop must join the controlled raw path"
+        );
+        stop_peer.cancel();
+        endpoint.close(0_u8.into(), b"");
+        tokio::time::timeout(Duration::from_secs(2), peer)
+            .await
+            .unwrap()
+            .unwrap();
+        tokio::time::timeout(Duration::from_secs(2), endpoint.wait_idle())
+            .await
+            .unwrap();
+    }
+}
+
+#[tokio::test]
+async fn authenticated_sessions_preserve_source_budget_and_join_together() {
+    use futures_util::FutureExt;
+    use std::{collections::VecDeque, panic::AssertUnwindSafe};
+    use vole::{
+        dispatch::{DatagramBudget, DatagramTransport, DispatchError},
+        outbound::ConnectedStream,
+        session::StreamSession,
+    };
+    struct Links(Mutex<VecDeque<MemoryPackets>>);
+    #[async_trait::async_trait]
+    impl OutboundConnector for Links {
+        async fn connect_stream(
+            &self,
+            _: StreamSession,
+            _: &EstablishContext,
+        ) -> Result<ConnectedStream, DispatchError> {
+            Err(DispatchError::NotAllowed)
+        }
+        async fn open_datagram(
+            &self,
+            _: DatagramRequest,
+            _: &EstablishContext,
+        ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+            self.0
+                .lock()
+                .unwrap()
+                .pop_front()
+                .map(|link| Box::new(link) as Box<dyn DatagramTransport>)
+                .ok_or(DispatchError::NotAllowed)
+        }
+    }
+    for (down, expected) in [(0, vec![0_u64, 0]), (5, vec![2, 3]), (1, vec![1])] {
+        let rates = if down == 0 {
+            String::new()
+        } else {
+            format!(r#", "up":"1 Mbps", "down":"{down} Bps""#)
+        };
+        let yaml = format!(
+            r#"{{"proxies":[{{"name":"peer","type":"hysteria2","server":"192.0.2.1","port":443,"udp":true{rates},"skip-cert-verify":true,"sni":"fixture.invalid"}}],"rules":["MATCH,peer"]}}"#
+        );
+        // Parse before starting peers, including the actual omitted-field auto case.
+        let config = Config::parse_yaml(yaml.as_bytes()).unwrap();
+        let ProxyProtocol::Hysteria2(config) = &config.proxies[0].protocol else {
+            panic!("protocol")
+        };
+        let mut links = VecDeque::new();
+        let mut servers = Vec::new();
+        let mut client_links = Vec::new();
+        for _ in &expected {
+            let (link, endpoint, client_link) = memory_fixture();
+            links.push_back(link);
+            servers.push(endpoint);
+            client_links.push(client_link);
+        }
+        let upstream = Arc::new(Links(Mutex::new(links)));
+        let outbound =
+            Hysteria2Outbound::new_with_path(config, UpstreamPath::proxy(upstream.clone()))
+                .unwrap();
+        let mut peers = Vec::new();
+        for (slot, endpoint) in servers.iter().cloned().enumerate() {
+            peers.push(tokio::spawn(async move {
+                // Closing an unused peer after a RED must also terminate accept.
+                let Some(incoming) = endpoint.accept().await else {
+                    return None;
+                };
+                let connection = incoming.await.unwrap();
+                let mut h3 = h3::server::builder()
+                    .build::<_, Bytes>(h3_quinn::Connection::new(connection.clone()))
+                    .await
+                    .unwrap();
+                let (request, mut response) = h3
+                    .accept()
+                    .await
+                    .unwrap()
+                    .unwrap()
+                    .resolve_request()
+                    .await
+                    .unwrap();
+                let declared: u64 = request.headers()["Hysteria-CC-RX"]
+                    .to_str()
+                    .unwrap()
+                    .parse()
+                    .unwrap();
+                response
+                    .send_response(
+                        http::Response::builder()
+                            .status(233)
+                            .header("Hysteria-UDP", "true")
+                            .header("Hysteria-CC-RX", "0")
+                            .body(())
+                            .unwrap(),
+                    )
+                    .await
+                    .unwrap();
+                response.finish().await.unwrap();
+                while let Ok(packet) = connection.read_datagram().await {
+                    // A label from the actual authenticated peer, not a copy of
+                    // the production source hash or slot-count formula.
+                    let mut reply = packet.to_vec();
+                    reply.push(slot as u8);
+                    if connection.send_datagram_wait(reply.into()).await.is_err() {
+                        break;
+                    }
+                }
+                drop(h3);
+                endpoint.close(0_u32.into(), b"");
+                endpoint.wait_idle().await;
+                Some(declared)
+            }));
+        }
+        let budget = DatagramBudget::new(1, 2);
+        let remote = Destination::Ip("192.0.2.10:53".parse().unwrap());
+        let mut assignment = [None; 32];
+        let mut retained: Vec<Option<Box<dyn DatagramTransport>>> =
+            expected.iter().map(|_| None).collect();
+        let mut correct = Vec::new();
+        let outcome = AssertUnwindSafe(tokio::time::timeout(Duration::from_secs(3), async {
+            for _ in 0..2 {
+                for index in 0..32_u8 {
+                    let mut udp = outbound
+                        .open_datagram(
+                            DatagramRequest::new(DatagramSession::new(
+                                InboundKind::InternalMeasure,
+                                SocketAddr::from(([192, 0, 2, 2], 20000 + u16::from(index))),
+                            ))
+                            .with_budget(budget),
+                            &EstablishContext::default(),
+                        )
+                        .await?;
+                    let oversized = udp
+                        .send(Datagram {
+                            remote: remote.clone(),
+                            payload: Bytes::from_static(&[0, 0]),
+                            sniffed_domain: None,
+                        })
+                        .await
+                        .is_err();
+                    udp.send(Datagram {
+                        remote: remote.clone(),
+                        payload: vec![index].into(),
+                        sniffed_domain: None,
+                    })
+                    .await?;
+                    let reply = udp.receive().await?;
+                    let slot = reply
+                        .payload
+                        .get(1)
+                        .copied()
+                        .filter(|slot| usize::from(*slot) < retained.len());
+                    correct.push(
+                        oversized
+                            && udp.supports_shared_destinations()
+                            && udp.payload_budget(&remote) == budget
+                            && reply.remote == remote
+                            && reply.payload.first() == Some(&index)
+                            && reply.payload.len() == 2
+                            && slot.is_some()
+                            && assignment[usize::from(index)].is_none_or(|old| Some(old) == slot),
+                    );
+                    if let Some(slot) = slot {
+                        assignment[usize::from(index)] = Some(slot);
+                        if retained[usize::from(slot)].is_none() {
+                            retained[usize::from(slot)] = Some(udp);
+                            continue;
+                        }
+                    }
+                    udp.close().await?;
+                }
+            }
+            // Closing sibling associations did not close their shared carrier.
+            for (slot, udp) in retained.iter_mut().enumerate() {
+                let Some(udp) = udp else { continue };
+                udp.send(Datagram {
+                    remote: remote.clone(),
+                    payload: Bytes::from_static(&[0xa5]),
+                    sniffed_domain: None,
+                })
+                .await?;
+                let reply = udp.receive().await?;
+                correct.push(reply.remote == remote && reply.payload == [0xa5, slot as u8][..]);
+            }
+            Ok::<_, DispatchError>(())
+        }))
+        .catch_unwind()
+        .await;
+        let owners = retained.len();
+        let all_used = retained.iter().all(Option::is_some);
+        let stop = AssertUnwindSafe(tokio::time::timeout(Duration::from_secs(3), async {
+            outbound.shutdown().await;
+            let mut closed = true;
+            for udp in retained.iter_mut().flatten() {
+                closed &= udp.receive().await.is_err();
+            }
+            closed
+        }))
+        .catch_unwind()
+        .await;
+        let physical_closed = client_links.iter().all(mpsc::Sender::is_closed);
+        let all_opened = upstream.0.lock().unwrap().is_empty();
+        // Cleanup is unconditional, including an unused auto slot on the RED,
+        // a business panic/error, and every individual peer's failed join.
+        retained.clear();
+        for server in &servers {
+            server.close(0_u32.into(), b"");
+        }
+        upstream.0.lock().unwrap().clear();
+        let mut declared = Vec::new();
+        let mut peer_ok = true;
+        for mut peer in peers {
+            match tokio::time::timeout(Duration::from_secs(2), &mut peer).await {
+                Ok(Ok(value)) => declared.push(value),
+                Ok(Err(_)) => peer_ok = false,
+                Err(_) => {
+                    peer.abort();
+                    let _ = peer.await;
+                    peer_ok = false;
+                }
+            }
+        }
+        let mut drained = true;
+        for server in &servers {
+            drained &= tokio::time::timeout(Duration::from_secs(2), server.wait_idle())
+                .await
+                .is_ok();
+        }
+        // If the first bounded Stop failed, closing all peer paths above gives
+        // its cancelled drivers a final chance to join before any assertion.
+        let cleanup = AssertUnwindSafe(tokio::time::timeout(
+            Duration::from_secs(3),
+            outbound.shutdown(),
+        ))
+        .catch_unwind()
+        .await;
+        drop(servers);
+        drop(outbound);
+        drop(upstream);
+        declared.sort_unstable();
+        assert!(peer_ok && drained, "every memory peer must join and drain");
+        assert!(matches!(cleanup, Ok(Ok(()))), "node cleanup must join");
+        assert_eq!(declared, expected.into_iter().map(Some).collect::<Vec<_>>());
+        outcome.unwrap().unwrap().unwrap();
+        assert_eq!(correct, vec![true; 64 + owners]);
+        assert!(all_used && all_opened, "every real carrier must be used");
+        assert!(
+            matches!(stop, Ok(Ok(true))),
+            "Stop must terminate logical owners"
+        );
+        assert!(
+            physical_closed,
+            "Stop must close every controlled physical receiver"
+        );
+    }
 }
diff --git a/tests/hysteria2_paths.rs b/tests/hysteria2_paths.rs
index 2e7e716..382af7c 100644
--- a/tests/hysteria2_paths.rs
+++ b/tests/hysteria2_paths.rs
@@ -25,6 +25,10 @@ struct Packets {
 }
 #[async_trait]
 impl DatagramTransport for Packets {
+    fn supports_shared_destinations(&self) -> bool {
+        false
+    }
+
     fn payload_budget(&self, _: &Destination) -> DatagramBudget {
         DatagramBudget::new(1400, 1400)
     }
@@ -48,11 +52,6 @@ impl DatagramTransport for Packets {
 
 #[tokio::test]
 async fn controlled_path_maps_only_its_authorized_source_and_stops_without_replay() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "HYSTERIA2-UNIT",
-        "controlled_path_maps_only_its_authorized_source_and_stops_without_replay",
-    );
     let logical = "192.0.2.1:443".parse().unwrap();
     let physical = "192.0.2.1:8443".parse().unwrap();
     let packet = |remote, payload| Datagram {
diff --git a/tests/jls_config.rs b/tests/jls_config.rs
index 0d3a86f..c536a72 100644
--- a/tests/jls_config.rs
+++ b/tests/jls_config.rs
@@ -8,11 +8,6 @@ use vole::{
 
 #[test]
 fn public_jls_builds_an_authenticated_security_client_without_exposing_credentials() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "public_jls_builds_an_authenticated_security_client_without_exposing_credentials",
-    );
     let config = Config::parse_yaml(
         &serde_json::to_vec(&json!({
             "mixed-port":1080,
@@ -55,11 +50,6 @@ fn parse(node: serde_json::Value) -> vole::Result<VlessOutboundConfig> {
 
 #[test]
 fn independent_download_inherits_jls_identity_and_applies_its_own_tls_fields() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "independent_download_inherits_jls_identity_and_applies_its_own_tls_fields",
-    );
     let mut input = node();
     input["network"] = json!("xhttp");
     input["xhttp-opts"] = json!({"mode":"stream-up", "download-settings":{
@@ -78,11 +68,6 @@ fn independent_download_inherits_jls_identity_and_applies_its_own_tls_fields() {
 
 #[test]
 fn download_jls_credentials_are_replaced_as_a_whole_or_explicitly_cleared() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "download_jls_credentials_are_replaced_as_a_whole_or_explicitly_cleared",
-    );
     let mut input = node();
     input["network"] = json!("xhttp");
     input["xhttp-opts"] = json!({"mode":"stream-up", "download-settings":{
@@ -108,11 +93,6 @@ fn download_jls_credentials_are_replaced_as_a_whole_or_explicitly_cleared() {
 
 #[test]
 fn malformed_or_partial_credentials_never_inherit_a_missing_secret() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "malformed_or_partial_credentials_never_inherit_a_missing_secret",
-    );
     for replacement in [
         json!(null),
         json!([]),
@@ -155,11 +135,6 @@ fn malformed_or_partial_credentials_never_inherit_a_missing_secret() {
 
 #[test]
 fn invalid_jls_objects_do_not_echo_credentials_in_public_configuration_errors() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "invalid_jls_objects_do_not_echo_credentials_in_public_configuration_errors",
-    );
     for credential in ["username", "password"] {
         let mut input = node();
         input["jls-opts"][credential] = json!(98765432198765_u64);
@@ -193,11 +168,6 @@ fn invalid_jls_objects_do_not_echo_credentials_in_public_configuration_errors()
 
 #[test]
 fn jls_rejects_incompatible_security_at_configuration_time() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "jls_rejects_incompatible_security_at_configuration_time",
-    );
     for overrides in [
         json!({"tls":false}),
         json!({"flow":"xtls-rprx-vision"}),
@@ -232,11 +202,6 @@ fn jls_rejects_incompatible_security_at_configuration_time() {
 
 #[test]
 fn download_security_switch_requires_explicit_clearing_of_inherited_identity() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "download_security_switch_requires_explicit_clearing_of_inherited_identity",
-    );
     let reality = json!({"public-key":"BwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwc"});
     let mut input = node();
     input["network"] = json!("xhttp");
@@ -272,21 +237,7 @@ fn download_security_switch_requires_explicit_clearing_of_inherited_identity() {
 #[cfg(feature = "tls-fingerprint")]
 #[test]
 fn selected_profiles_build_jls_without_changing_its_identity() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "selected_profiles_build_jls_without_changing_its_identity",
-    );
-    for profile in [
-        "none",
-        "",
-        "chrome",
-        "chrome120",
-        "firefox",
-        "firefox120",
-        "safari",
-        "safari16",
-    ] {
+    for profile in ["none", "", "chrome", "firefox", "safari", "ios", "random"] {
         let mut input = node();
         input["client-fingerprint"] = json!(profile);
         input["network"] = json!("xhttp");
@@ -312,11 +263,6 @@ fn selected_profiles_build_jls_without_changing_its_identity() {
 
 #[tokio::test]
 async fn cancelled_jls_handshakes_release_supplied_io_and_never_reuse_randoms() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "cancelled_jls_handshakes_release_supplied_io_and_never_reuse_randoms",
-    );
     use std::time::Duration;
     use tokio::io::AsyncReadExt;
     let client = SecurityClient::from_proxy(&parse(node()).unwrap()).unwrap();
@@ -352,11 +298,6 @@ async fn cancelled_jls_handshakes_release_supplied_io_and_never_reuse_randoms()
 
 #[tokio::test]
 async fn jls_security_client_rejects_ordinary_tls_before_application_data() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "jls_security_client_rejects_ordinary_tls_before_application_data",
-    );
     use boring::{
         pkey::PKey,
         ssl::{SslAcceptor, SslMethod, SslVersion},
diff --git a/tests/limit_foundations.rs b/tests/limit_foundations.rs
index 86a9385..7f07826 100644
--- a/tests/limit_foundations.rs
+++ b/tests/limit_foundations.rs
@@ -9,21 +9,12 @@ use std::collections::BTreeMap;
 
 #[test]
 fn registry_matches_live_production_constants_and_has_owned_boundary_cases() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-LIMITS",
-        "registry_matches_live_production_constants_and_has_owned_boundary_cases",
-    );
     use vole::{ResourceLimits, dispatch, transport};
     let defaults = ResourceLimits::default();
     let expected = BTreeMap::from([
         ("tuic-quic-payload", vole::limits::TUIC_QUIC_PAYLOAD),
-        ("tuic-uni-streams", vole::limits::TUIC_UNI_STREAMS),
-        ("tuic-stream-window", vole::limits::TUIC_STREAM_WINDOW),
-        (
-            "tuic-connection-window",
-            vole::limits::TUIC_CONNECTION_WINDOW,
-        ),
+        ("tuic-control-readers", vole::limits::TUIC_CONTROL_READERS),
+        ("tuic-send-window", vole::limits::TUIC_SEND_WINDOW),
         ("tuic-datagram-buffer", vole::limits::TUIC_DATAGRAM_BUFFER),
         ("tuic-udp-queue", vole::limits::TUIC_UDP_QUEUE),
         ("tuic-pending-packets", vole::limits::TUIC_PENDING_PACKETS),
@@ -36,15 +27,23 @@ fn registry_matches_live_production_constants_and_has_owned_boundary_cases() {
         ),
         ("hy2-udp-payload", vole::limits::HY2_UDP_PAYLOAD),
         ("hy2-udp-queue", vole::limits::HY2_UDP_QUEUE),
+        ("hy2-submission-queue", vole::limits::HY2_SUBMISSION_QUEUE),
+        ("hy2-auth-sessions", vole::limits::HY2_AUTH_SESSIONS),
         ("hy2-pending-packets", vole::limits::HY2_PENDING_PACKETS),
         ("hy2-pending-bytes", vole::limits::HY2_PENDING_BYTES),
         ("hy2-fragment-ttl", vole::limits::HY2_FRAGMENT_TTL_SECONDS),
         ("hy2-path-retire", vole::limits::HY2_PATH_RETIRE_SECONDS),
         ("hy2-quic-payload", vole::limits::HY2_QUIC_PAYLOAD),
         ("hy2-uni-streams", vole::limits::HY2_UNI_STREAMS),
-        ("hy2-stream-window", vole::limits::HY2_STREAM_WINDOW),
-        ("hy2-connection-window", vole::limits::HY2_CONNECTION_WINDOW),
-        ("hy2-datagram-buffer", vole::limits::HY2_DATAGRAM_BUFFER),
+        ("hy2-send-window", vole::limits::HY2_SEND_WINDOW),
+        (
+            "hy2-datagram-send-buffer",
+            vole::limits::HY2_DATAGRAM_SEND_BUFFER,
+        ),
+        (
+            "hy2-datagram-receive-buffer",
+            vole::limits::HY2_DATAGRAM_RECEIVE_BUFFER,
+        ),
         ("hy2-auth-headers", vole::limits::HY2_AUTH_HEADERS),
         ("hy2-response-message", vole::limits::HY2_RESPONSE_MESSAGE),
         ("hy2-response-padding", vole::limits::HY2_RESPONSE_PADDING),
@@ -118,6 +117,10 @@ fn registry_matches_live_production_constants_and_has_owned_boundary_cases() {
         ("xhttp-padding", vole::limits::XHTTP_PADDING_BYTES),
         ("xhttp-post", vole::limits::XHTTP_POST_BYTES),
         ("xhttp-packet-batch", vole::limits::XHTTP_PACKET_BATCH_BYTES),
+        (
+            "xhttp-h3-packet-batch",
+            vole::limits::XHTTP_H3_PACKET_BATCH_BYTES,
+        ),
         ("xhttp-request-bytes", vole::limits::XHTTP_REQUEST_BYTES),
         ("xhttp-request-headers", vole::limits::XHTTP_REQUEST_HEADERS),
         ("xhttp-idle-entries", vole::limits::XHTTP_IDLE_ENTRIES),
@@ -134,6 +137,10 @@ fn registry_matches_live_production_constants_and_has_owned_boundary_cases() {
             vole::limits::XHTTP_H3_CONNECTION_WINDOW,
         ),
         ("xhttp-h3-send-window", vole::limits::XHTTP_H3_SEND_WINDOW),
+        (
+            "xhttp-h3-udp-send-window",
+            vole::limits::XHTTP_H3_UDP_SEND_WINDOW,
+        ),
         ("sing-mux-idle", vole::limits::SING_MUX_IDLE_CONNECTIONS),
         (
             "sing-mux-command-queue",
diff --git a/tests/protocols/README.md b/tests/protocols/README.md
index 6c7ec3d..e84a177 100644
--- a/tests/protocols/README.md
+++ b/tests/protocols/README.md
@@ -10,15 +10,13 @@ Vole 纯核心回归直接使用的独立输入，不包含容器 catalog、消
   不能从待测实现重生成期望；历史生成来源可在 Git 中追溯。
 
 核心离线回归见 [tests](../README.md)，平台编译见 [scripts](../../scripts/README.md)。
-互通消费者、官方对端下载与编排位于公开的
-[container-benchmark](https://github.com/YuanDevTeam/container-benchmark)，入口为
+互通消费者、官方对端下载与编排由独立容器测试工具维护，结果与结论保存在 benchmark 工程，入口为
 `container-benchmark interop --source vole=PATH`，默认使用 Mihomo、Xray-core、
-Hysteria2、V2Ray 与 Caddy/Xray 的 64 个代表用例；Mihomo listener 的缺口保留原生
+Hysteria2、V2Ray 与 Caddy/Xray，以及 TrustTunnel、Mieru 和 MASQUE 的代表用例；Mihomo listener 的缺口保留原生
 或明确分层验证。`--backend` / `--protocol` 可筛选，`--list` 离线列举。
 原生 TUN 压力与两核性能比较使用该工程的 `stress` / `compare`；真实执行均显式
 提供 Vole checkout，不推断工程路径。网络互通不混入离线检查或平台构建。
-此入口不恢复历史全部字段、代理链、长测或 ClientHello golden 的网络矩阵，
-本目录独立输入的离线回归也不能冒充当前网络通过。
+本目录独立输入的离线回归不代替实际网络互通。
 
 输入文件属于受版本控制的测试源，不是每轮产生的测试数据。每轮容器实验仅保留
 脱敏文字结论，清理规则见[测试隔离](../../docs/testing-isolation.md)；
diff --git a/tests/protocols/limits.json b/tests/protocols/limits.json
index 16e8c7b..7f42e6b 100644
--- a/tests/protocols/limits.json
+++ b/tests/protocols/limits.json
@@ -10,7 +10,9 @@
       "owner": "limits::TUIC_FIN_GRACE_SECONDS",
       "saturation": "retain TCP send ownership until FIN acknowledgement or bounded grace before retiring the physical connection",
       "cancellation": "node Stop cancels and joins the owned FIN waiter without waiting out the grace",
-      "boundary_cases": ["TUIC-MEMORY"]
+      "boundary_cases": [
+        "TUIC-MEMORY"
+      ]
     },
     {
       "id": "tuic-quic-payload",
@@ -24,33 +26,22 @@
       ]
     },
     {
-      "id": "tuic-uni-streams",
+      "id": "tuic-control-readers",
       "value": 32,
       "unit": "streams",
-      "owner": "limits::TUIC_UNI_STREAMS",
-      "saturation": "withhold incoming credit and expire partial parsers after five seconds",
-      "cancellation": "node Stop cancels and joins all owned QUIC, parser, heartbeat and upstream tasks",
-      "boundary_cases": [
-        "TUIC-MEMORY"
-      ]
-    },
-    {
-      "id": "tuic-stream-window",
-      "value": 262144,
-      "unit": "bytes",
-      "owner": "limits::TUIC_STREAM_WINDOW",
-      "saturation": "QUIC receive flow control applies backpressure to unread logical streams",
+      "owner": "limits::TUIC_CONTROL_READERS",
+      "saturation": "limit active control decoders independently of fixed incoming QUIC credit; expire admitted partial parsers after five seconds",
       "cancellation": "node Stop cancels and joins all owned QUIC, parser, heartbeat and upstream tasks",
       "boundary_cases": [
         "TUIC-MEMORY"
       ]
     },
     {
-      "id": "tuic-connection-window",
+      "id": "tuic-send-window",
       "value": 1048576,
-      "unit": "bytes-per-direction",
-      "owner": "limits::TUIC_CONNECTION_WINDOW",
-      "saturation": "bound QUIC receive credit and unacknowledged send buffering per connection",
+      "unit": "bytes",
+      "owner": "limits::TUIC_SEND_WINDOW",
+      "saturation": "bound retained unacknowledged send bytes per physical connection; receive credit follows configured initial/max",
       "cancellation": "node Stop cancels and joins all owned QUIC, parser, heartbeat and upstream tasks",
       "boundary_cases": [
         "TUIC-MEMORY"
@@ -118,7 +109,10 @@
       "owner": "limits::SHADOWSOCKS_WRITE_CHUNK",
       "saturation": "partial write then backpressure while the bounded owned chunk drains",
       "cancellation": "stream drop releases plaintext and codec; flush and shutdown drain the exact accepted chunk",
-      "boundary_cases": ["INTEGRATION-DEBUG", "INTEGRATION-RELEASE"]
+      "boundary_cases": [
+        "INTEGRATION-DEBUG",
+        "INTEGRATION-RELEASE"
+      ]
     },
     {
       "id": "xhttp-custom-header-bytes",
@@ -169,7 +163,18 @@
       "value": 65536,
       "unit": "bytes-per-batch",
       "owner": "limits::XHTTP_PACKET_BATCH_BYTES",
-      "saturation": "backpressure one filling batch and one in-flight batch; never allocate the configured POST maximum",
+      "saturation": "H1/H2 backpressure one batch including the in-flight POST; never allocate the configured POST maximum",
+      "cancellation": "logical drop cancels the timer/upload; node Stop joins the owned driver",
+      "boundary_cases": [
+        "XHTTP-UNIT"
+      ]
+    },
+    {
+      "id": "xhttp-h3-packet-batch",
+      "value": 131072,
+      "unit": "bytes-per-batch",
+      "owner": "limits::XHTTP_H3_PACKET_BATCH_BYTES",
+      "saturation": "H3 backpressure one batch including the in-flight POST; use the smaller sampled POST limit without a second batch",
       "cancellation": "logical drop cancels the timer/upload; node Stop joins the owned driver",
       "boundary_cases": [
         "XHTTP-UNIT"
@@ -235,7 +240,7 @@
       "value": 16384,
       "unit": "bytes",
       "owner": "limits::XHTTP_BODY_CHUNK",
-      "saturation": "split streaming writes; a packet-up body uses the separately bounded xhttp-packet-batch limit",
+      "saturation": "split streaming writes; a packet-up body uses xhttp-packet-batch for H1/H2 or xhttp-h3-packet-batch for H3",
       "cancellation": "runtime Stop cancels and joins node-owned drivers; drops queues and retained IO",
       "boundary_cases": [
         "XHTTP-UNIT"
@@ -285,6 +290,15 @@
         "XHTTP-UNIT"
       ]
     },
+    {
+      "id": "xhttp-h3-udp-send-window",
+      "value": 196608,
+      "unit": "bytes",
+      "owner": "limits::XHTTP_H3_UDP_SEND_WINDOW",
+      "saturation": "qualified physical starts64KiB; successful local mux UDP metadata flush raises shared retained-write admission192KiB once",
+      "cancellation": "failed/cancelled metadata does not raise; Weak does not own native lifecycle; original Stop joins drivers",
+      "boundary_cases": ["XHTTP-UNIT"]
+    },
     {
       "id": "sing-mux-idle",
       "value": 16,
@@ -367,7 +381,7 @@
     },
     {
       "id": "config-bytes",
-      "value": 262144,
+      "value": 8388608,
       "unit": "bytes",
       "owner": "config::MAX_CONFIG_BYTES",
       "saturation": "reject oversized YAML",
@@ -467,10 +481,10 @@
     },
     {
       "id": "ws-early-data",
-      "value": 2048,
+      "value": 11904,
       "unit": "bytes",
       "owner": "transport::MAX_EARLY_DATA_BYTES",
-      "saturation": "reject invalid option, put excess initial bytes in data frames",
+      "saturation": "cap initial bytes by the actual HTTP head budget and this maximum; put excess bytes in data frames",
       "cancellation": "no separate task",
       "boundary_cases": [
         "FOUNDATIONS-STREAM"
@@ -634,10 +648,10 @@
     },
     {
       "id": "tun-udp-response",
-      "value": 4096,
+      "value": 256,
       "unit": "items",
       "owner": "ResourceLimits::tun_udp_response_queue_capacity",
-      "saturation": "drop only the current ordinary UDP response without refreshing association activity",
+      "saturation": "one pending response per source pauses that association until writeback capacity; cancellation discards pending data",
       "cancellation": "existing runtime-owned cancellation and Stop barrier",
       "boundary_cases": [
         "FOUNDATIONS-REGRESSION"
@@ -802,12 +816,34 @@
         "HYSTERIA2-OWNED"
       ]
     },
+    {
+      "id": "hy2-submission-queue",
+      "value": 32,
+      "unit": "messages-per-connection",
+      "owner": "limits::HY2_SUBMISSION_QUEUE",
+      "saturation": "wait before reserving a Packet ID or encoding fragments",
+      "cancellation": "cancel pending admission; connection Stop drops queued messages and joins its existing owner",
+      "boundary_cases": [
+        "INTEGRATION-ADAPTER"
+      ]
+    },
+    {
+      "id": "hy2-auth-sessions",
+      "value": 2,
+      "unit": "current-connections-per-node",
+      "owner": "limits::HY2_AUTH_SESSIONS",
+      "saturation": "reuse the source-selected slot; replace only a closed session",
+      "cancellation": "close admission and cancel/join every authenticated session",
+      "boundary_cases": [
+        "INTEGRATION-ADAPTER"
+      ]
+    },
     {
       "id": "hy2-pending-packets",
       "value": 64,
       "unit": "partial-packets-per-connection",
       "owner": "limits::HY2_PENDING_PACKETS",
-      "saturation": "drop excess partial packets; retain bounded completion tombstones",
+      "saturation": "evict oldest incomplete packet to admit new fragments; completed IDs are immediately released",
       "cancellation": "owned logical close or physical session Stop releases retained state and joins drivers",
       "boundary_cases": [
         "HYSTERIA2-UNIT",
@@ -875,11 +911,11 @@
       ]
     },
     {
-      "id": "hy2-stream-window",
-      "value": 262144,
+      "id": "hy2-send-window",
+      "value": 1048576,
       "unit": "bytes",
-      "owner": "limits::HY2_STREAM_WINDOW",
-      "saturation": "QUIC receive flow control",
+      "owner": "limits::HY2_SEND_WINDOW",
+      "saturation": "bound retained unacknowledged send bytes per physical connection; receive credit follows configured initial/max",
       "cancellation": "owned logical close or physical session Stop releases retained state and joins drivers",
       "boundary_cases": [
         "HYSTERIA2-UNIT",
@@ -887,11 +923,11 @@
       ]
     },
     {
-      "id": "hy2-connection-window",
-      "value": 1048576,
-      "unit": "bytes",
-      "owner": "limits::HY2_CONNECTION_WINDOW",
-      "saturation": "QUIC aggregate send and receive flow control",
+      "id": "hy2-datagram-send-buffer",
+      "value": 4194304,
+      "unit": "bytes-per-node",
+      "owner": "limits::HY2_DATAGRAM_SEND_BUFFER",
+      "saturation": "bound retained outgoing QUIC datagrams; sends wait for capacity",
       "cancellation": "owned logical close or physical session Stop releases retained state and joins drivers",
       "boundary_cases": [
         "HYSTERIA2-UNIT",
@@ -899,11 +935,11 @@
       ]
     },
     {
-      "id": "hy2-datagram-buffer",
-      "value": 262144,
-      "unit": "bytes-per-direction",
-      "owner": "limits::HY2_DATAGRAM_BUFFER",
-      "saturation": "QUIC bounds retained datagram queues",
+      "id": "hy2-datagram-receive-buffer",
+      "value": 2097152,
+      "unit": "bytes-per-node",
+      "owner": "limits::HY2_DATAGRAM_RECEIVE_BUFFER",
+      "saturation": "bound retained incoming QUIC datagrams; Quinn drops old frames when full",
       "cancellation": "owned logical close or physical session Stop releases retained state and joins drivers",
       "boundary_cases": [
         "HYSTERIA2-UNIT",
diff --git a/tests/proxy_group_compat.rs b/tests/proxy_group_compat.rs
index ff303c6..049af4a 100644
--- a/tests/proxy_group_compat.rs
+++ b/tests/proxy_group_compat.rs
@@ -56,7 +56,10 @@ rules:
         config.proxy_groups[1].members[1].target,
         ProxyGroupMemberTarget::Route(RouteTargetId::Group(backup))
     );
-    assert_eq!(config.default_route_target, RouteTargetId::Group(primary));
+    assert_eq!(
+        config.rules.last().unwrap().action,
+        RuleAction::Route(RouteTargetId::Group(primary))
+    );
     assert_eq!(
         config.rules[0].action,
         RuleAction::Route(RouteTargetId::Group(backup))
@@ -68,31 +71,56 @@ rules:
 }
 
 #[test]
-fn keeps_vole_stricter_than_mihomo_at_the_documented_boundaries() {
-    for groups in [
-        r#"
-proxy-groups:
-  - name: primary
-    type: select
-    proxies: [node-a]
-    default-selected: missing
-"#,
-        r#"
-proxy-groups:
-  - name: primary
-    type: select
-    proxies: [node-a]
-    url: https://example.com/generate_204
-"#,
-        r#"
-proxy-groups:
-  - name: primary
-    type: url-test
-    proxies: [node-a]
-"#,
+fn validates_group_selection_and_health_defaults() {
+    let providers = r#"
+proxy-providers:
+  nodes:
+    type: inline
+    payload:
+      - {name: provider-a, type: socks5, server: 192.0.2.3, port: 1080}
+      - {name: provider-b, type: socks5, server: 192.0.2.4, port: 1080}
+"#;
+    for (members, first, second, provider_config) in [
+        ("proxies: [node-a, node-b]", "node-a", "node-b", ""),
+        ("use: [nodes]", "provider-a", "provider-b", providers),
+    ] {
+        for (selection, expected) in [
+            (String::new(), 0),
+            ("    default-selected: \"\"\n".to_owned(), 0),
+            ("    default-selected: missing\n".to_owned(), 0),
+            (format!("    default-selected: {second}\n"), 1),
+        ] {
+            let yaml = format!(
+                "{COMMON_PREFIX}{provider_config}proxy-groups:\n  - name: primary\n    type: select\n    {members}\n{selection}rules: ['MATCH,primary']\n"
+            );
+            let config = Config::parse_yaml(yaml.as_bytes()).unwrap();
+            let group = &config.proxy_groups[0];
+            assert_eq!(group.initial_member, expected, "{yaml}");
+            assert_eq!(
+                group.members[expected].name,
+                if expected == 0 { first } else { second }
+            );
+        }
+        let yaml = format!(
+            "{COMMON_PREFIX}{provider_config}proxy-groups:\n  - name: primary\n    type: select\n    {members}\n    default-selected: {first}\n    exclude-filter: '^{first}$'\nrules: ['MATCH,primary']\n"
+        );
+        let config = Config::parse_yaml(yaml.as_bytes()).unwrap();
+        assert_eq!(config.proxy_groups[0].initial_member, 0);
+        assert_eq!(config.proxy_groups[0].members[0].name, second);
+    }
+    for (kind, url, expected) in [
+        (
+            "select",
+            "    url: https://example.com/generate_204\n",
+            "https://example.com/generate_204",
+        ),
+        ("url-test", "", "https://www.gstatic.com/generate_204"),
     ] {
-        let yaml = format!("{COMMON_PREFIX}{groups}rules:\n  - MATCH,primary\n");
-        assert!(Config::parse_yaml(yaml.as_bytes()).is_err(), "{yaml}");
+        let yaml = format!(
+            "{COMMON_PREFIX}proxy-groups:\n  - name: primary\n    type: {kind}\n    proxies: [node-a]\n{url}rules: ['MATCH,primary']\n"
+        );
+        let config = Config::parse_yaml(yaml.as_bytes()).unwrap();
+        assert_eq!(config.proxy_groups[0].health.url, expected);
     }
 }
 
diff --git a/tests/quic_datagram_foundations.rs b/tests/quic_datagram_foundations.rs
index f2890c6..4a591a3 100644
--- a/tests/quic_datagram_foundations.rs
+++ b/tests/quic_datagram_foundations.rs
@@ -12,11 +12,6 @@ use vole::{
 
 #[tokio::test]
 async fn quic_minimum_budget_is_checked_before_io_and_exact_minimum_connects() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-QUIC",
-        "quic_minimum_budget_is_checked_before_io_and_exact_minimum_connects",
-    );
     use std::sync::Arc;
     tokio::time::timeout(Duration::from_secs(10), async {
         let certificate = rcgen::generate_simple_self_signed(vec!["localhost".into()]).unwrap();
@@ -103,6 +98,10 @@ struct PendingSend {
 }
 #[async_trait::async_trait]
 impl vole::dispatch::DatagramTransport for PendingSend {
+    fn supports_shared_destinations(&self) -> bool {
+        false
+    }
+
     async fn send(
         &mut self,
         _: vole::session::Datagram,
@@ -124,11 +123,6 @@ impl vole::dispatch::DatagramTransport for PendingSend {
 
 #[tokio::test]
 async fn pending_send_is_not_restarted_and_stop_cancels_without_waiting_for_writable() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-QUIC",
-        "pending_send_is_not_restarted_and_stop_cancels_without_waiting_for_writable",
-    );
     use std::sync::{
         Arc,
         atomic::{AtomicUsize, Ordering},
@@ -176,11 +170,6 @@ async fn pending_send_is_not_restarted_and_stop_cancels_without_waiting_for_writ
 
 #[tokio::test]
 async fn controlled_quic_datagram_seam_roundtrips_and_stop_closes_owned_io() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-QUIC",
-        "controlled_quic_datagram_seam_roundtrips_and_stop_closes_owned_io",
-    );
     tokio::time::timeout(Duration::from_secs(3), async {
         let peer = tokio::net::UdpSocket::bind("127.0.0.1:0").await.unwrap();
         let address = peer.local_addr().unwrap();
@@ -237,11 +226,6 @@ async fn controlled_quic_datagram_seam_roundtrips_and_stop_closes_owned_io() {
 }
 #[tokio::test]
 async fn mapped_peer_sends_to_one_physical_port_and_reports_the_logical_peer() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-QUIC",
-        "mapped_peer_sends_to_one_physical_port_and_reports_the_logical_peer",
-    );
     tokio::time::timeout(Duration::from_secs(5), async {
         let logical = tokio::net::UdpSocket::bind("127.0.0.1:0").await.unwrap();
         let physical = tokio::net::UdpSocket::bind("127.0.0.1:0").await.unwrap();
@@ -297,11 +281,6 @@ async fn mapped_peer_sends_to_one_physical_port_and_reports_the_logical_peer() {
 
 #[tokio::test]
 async fn incoming_queue_backpressures_without_discarding_a_controlled_burst() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-QUIC",
-        "incoming_queue_backpressures_without_discarding_a_controlled_burst",
-    );
     tokio::time::timeout(Duration::from_secs(5), async {
         let echo = tokio::net::UdpSocket::bind("127.0.0.1:0").await.unwrap();
         let peer = echo.local_addr().unwrap();
@@ -351,11 +330,6 @@ async fn incoming_queue_backpressures_without_discarding_a_controlled_burst() {
 
 #[tokio::test]
 async fn controlled_direct_datagrams_roundtrip_and_stop() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-QUIC",
-        "controlled_direct_datagrams_roundtrip_and_stop",
-    );
     tokio::time::timeout(Duration::from_secs(5), async {
         let echo = tokio::net::UdpSocket::bind("127.0.0.1:0").await.unwrap();
         let peer = echo.local_addr().unwrap();
diff --git a/tests/reality_config.rs b/tests/reality_config.rs
index 61b9486..aee9e1d 100644
--- a/tests/reality_config.rs
+++ b/tests/reality_config.rs
@@ -25,12 +25,17 @@ fn parse(proxy: Value) -> vole::Result<Config> {
 
 #[test]
 fn public_reality_accepts_explicit_hybrid_without_replacing_the_fingerprint() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "public_reality_accepts_explicit_hybrid_without_replacing_the_fingerprint",
-    );
-    for profile in [None, Some("none"), Some(""), Some("chrome")] {
+    for profile in [
+        None,
+        Some("none"),
+        Some(""),
+        Some("chrome"),
+        Some("firefox"),
+        Some("safari"),
+        Some("ios"),
+        Some("edge"),
+        Some("qq"),
+    ] {
         let mut node = proxy();
         if let Some(profile) = profile {
             node["client-fingerprint"] = json!(profile);
@@ -43,13 +48,8 @@ fn public_reality_accepts_explicit_hybrid_without_replacing_the_fingerprint() {
 }
 
 #[test]
-fn public_reality_rejects_profiles_without_the_required_hybrid_share() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "public_reality_rejects_profiles_without_the_required_hybrid_share",
-    );
-    for profile in ["chrome120", "firefox", "firefox120", "safari", "safari16"] {
+fn public_reality_rejects_profiles_that_cannot_negotiate_tls13() {
+    for profile in ["android", "360"] {
         let mut node = proxy();
         node["client-fingerprint"] = json!(profile);
         assert!(
@@ -79,11 +79,6 @@ fn split_proxy() -> Value {
 
 #[test]
 fn download_inherits_or_replaces_the_entire_reality_object_without_leaf_merging() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "download_inherits_or_replaces_the_entire_reality_object_without_leaf_merging",
-    );
     let node = split_proxy();
     let (main, download) = securities(node.clone());
     assert_eq!(main, download);
@@ -116,11 +111,6 @@ fn download_inherits_or_replaces_the_entire_reality_object_without_leaf_merging(
 
 #[test]
 fn hybrid_flag_is_a_strict_nonnullable_boolean_on_both_legs() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "hybrid_flag_is_a_strict_nonnullable_boolean_on_both_legs",
-    );
     for value in [Value::Null, json!("true"), json!(1), json!([]), json!({})] {
         let mut main = proxy();
         main["reality-opts"]["support-x25519mlkem768"] = value.clone();
@@ -145,19 +135,8 @@ fn hybrid_flag_is_a_strict_nonnullable_boolean_on_both_legs() {
 
 #[test]
 fn classic_default_and_explicit_false_preserve_all_existing_profiles() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "classic_default_and_explicit_false_preserve_all_existing_profiles",
-    );
     for profile in [
-        "none",
-        "chrome",
-        "chrome120",
-        "firefox",
-        "firefox120",
-        "safari",
-        "safari16",
+        "none", "chrome", "firefox", "safari", "ios", "edge", "qq", "random",
     ] {
         for explicit in [false, true] {
             let mut node = split_proxy();
@@ -183,31 +162,23 @@ fn classic_default_and_explicit_false_preserve_all_existing_profiles() {
 
 #[test]
 fn inherited_profile_is_validated_after_download_reality_replacement() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "inherited_profile_is_validated_after_download_reality_replacement",
-    );
     let mut node = split_proxy();
     node["client-fingerprint"] = json!("firefox");
     node["reality-opts"]["support-x25519mlkem768"] = json!(false);
     node["xhttp-opts"]["download-settings"]["reality-opts"] = proxy()["reality-opts"].clone();
-    assert!(parse(node.clone()).is_err());
+    assert!(parse(node.clone()).is_ok());
     node["xhttp-opts"]["download-settings"]["client-fingerprint"] = json!("chrome");
     assert!(parse(node).is_ok());
 
     let mut inherited = split_proxy();
     inherited["xhttp-opts"]["download-settings"]["client-fingerprint"] = json!("safari");
+    assert!(parse(inherited.clone()).is_ok());
+    inherited["xhttp-opts"]["download-settings"]["client-fingerprint"] = json!("android");
     assert!(parse(inherited).is_err());
 }
 
 #[test]
 fn hybrid_reality_cannot_be_combined_with_h3_or_plaintext_on_either_leg() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "SECURITY-CONFIG-TLS",
-        "hybrid_reality_cannot_be_combined_with_h3_or_plaintext_on_either_leg",
-    );
     for download in [false, true] {
         for patch in [json!({"tls":false}), json!({"alpn":["h3"]})] {
             let mut node = split_proxy();
diff --git a/tests/resolution_foundations.rs b/tests/resolution_foundations.rs
index 63d0c66..0c97ba9 100644
--- a/tests/resolution_foundations.rs
+++ b/tests/resolution_foundations.rs
@@ -49,11 +49,6 @@ impl vole::outbound::OutboundConnector for IpBoundary {
 
 #[tokio::test]
 async fn measurement_domain_resolution_reaches_both_final_and_upstream_ip_boundaries() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-RESOLUTION",
-        "measurement_domain_resolution_reaches_both_final_and_upstream_ip_boundaries",
-    );
     use vole::{
         dispatch::Dispatcher,
         outbound::{ConnectorDispatcher, UpstreamPath},
@@ -67,6 +62,7 @@ async fn measurement_domain_resolution_reaches_both_final_and_upstream_ip_bounda
         ConnectorDispatcher::new(connector.clone()).with_resolution(resolution.clone());
     let target = Destination::domain("controlled.example", 443).unwrap();
     let session = StreamSession {
+        metadata: Default::default(),
         inbound: InboundKind::InternalMeasure,
         source: "127.0.0.1:0".parse().unwrap(),
         destination: target.clone(),
@@ -112,11 +108,6 @@ impl Resolver for ChainedBootstrap {
 
 #[tokio::test]
 async fn resolver_dependency_depth_is_bounded_independently_of_concurrent_lookups() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-RESOLUTION",
-        "resolver_dependency_depth_is_bounded_independently_of_concurrent_lookups",
-    );
     let calls = Arc::new(AtomicUsize::new(0));
     let resolution =
         ResolutionContext::measurement(Arc::new(ChainedBootstrap(calls.clone())), true);
@@ -147,11 +138,6 @@ impl Resolver for Bootstrap {
 
 #[tokio::test]
 async fn runtime_uses_configured_dns_and_weak_binding_releases_owner() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-RESOLUTION",
-        "runtime_uses_configured_dns_and_weak_binding_releases_owner",
-    );
     use vole::{
         config::{DnsConfig, DnsNameserver, DnsRoute, DnsTransport},
         dialer::Dialer,
@@ -180,12 +166,16 @@ async fn runtime_uses_configured_dns_and_weak_binding_releases_owner() {
         enable: true,
         ipv6: false,
         nameservers: vec![DnsNameserver {
+            path: None,
+            http_auth: None,
+            options: Default::default(),
             transport: DnsTransport::Udp,
-            address: address.ip(),
+            address: address.ip().into(),
             port: address.port(),
             route: DnsRoute::Direct,
         }],
         nameserver_policies: vec![],
+        ..DnsConfig::default()
     };
     let dns = Arc::new(RuntimeDns::new(
         &config,
@@ -244,11 +234,6 @@ impl vole::dispatch::Dispatcher for RecursiveEgress {
 
 #[tokio::test]
 async fn recursive_dns_dependency_fails_before_connecting_or_joining_its_own_flight() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-RESOLUTION",
-        "recursive_dns_dependency_fails_before_connecting_or_joining_its_own_flight",
-    );
     use vole::{
         config::{DnsConfig, DnsNameserver, DnsRoute, DnsTransport},
         dns::runtime::RuntimeDns,
@@ -263,12 +248,16 @@ async fn recursive_dns_dependency_fails_before_connecting_or_joining_its_own_fli
         enable: true,
         ipv6: false,
         nameservers: vec![DnsNameserver {
+            path: None,
+            http_auth: None,
+            options: Default::default(),
             transport: DnsTransport::Udp,
             address: "192.0.2.1".parse().unwrap(),
             port: 53,
             route: DnsRoute::Direct,
         }],
         nameserver_policies: vec![],
+        ..DnsConfig::default()
     };
     let dns = Arc::new(RuntimeDns::new(&config, egress));
     resolution.bind_runtime(Some(&dns)).unwrap();
@@ -305,11 +294,6 @@ impl Resolver for PendingBootstrap {
 
 #[tokio::test]
 async fn lookup_deadline_and_stop_cancel_pending_resolver_without_retaining_waiters() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-RESOLUTION",
-        "lookup_deadline_and_stop_cancel_pending_resolver_without_retaining_waiters",
-    );
     let active = Arc::new(AtomicUsize::new(0));
     let entered = Arc::new(tokio::sync::Notify::new());
     let resolution = ResolutionContext::measurement(
@@ -339,11 +323,6 @@ async fn lookup_deadline_and_stop_cancel_pending_resolver_without_retaining_wait
 
 #[tokio::test]
 async fn standalone_measurement_resolves_only_at_ip_boundary_with_address_policy_and_stop() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-RESOLUTION",
-        "standalone_measurement_resolves_only_at_ip_boundary_with_address_policy_and_stop",
-    );
     let bootstrap = Arc::new(Bootstrap(AtomicUsize::new(0)));
     let resolution = ResolutionContext::measurement(bootstrap.clone(), false);
     let context = EstablishContext::with_resolution(Duration::from_secs(10), resolution.clone());
@@ -365,11 +344,6 @@ async fn standalone_measurement_resolves_only_at_ip_boundary_with_address_policy
 
 #[tokio::test]
 async fn unbound_and_disabled_runtime_resolution_never_fall_back_to_system_dns() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-RESOLUTION",
-        "unbound_and_disabled_runtime_resolution_never_fall_back_to_system_dns",
-    );
     let resolution = ResolutionContext::runtime(false);
     let context = EstablishContext::with_resolution(Duration::from_secs(10), resolution.clone());
     let target = Destination::domain("localhost", 443).unwrap();
diff --git a/tests/resource_foundations.rs b/tests/resource_foundations.rs
index d53dc1a..080080d 100644
--- a/tests/resource_foundations.rs
+++ b/tests/resource_foundations.rs
@@ -12,13 +12,7 @@ use vole::{
 
 #[tokio::test]
 async fn twenty_quic_lifetimes_return_owned_resources_to_zero_then_remain_quiet() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-RESOURCES",
-        "twenty_quic_lifetimes_return_owned_resources_to_zero_then_remain_quiet",
-    );
     let probe = ResourceProbe::default();
-    _case.checkpoint("baseline", probe.snapshot());
     for _ in 0..20 {
         probe
             .scope(async {
@@ -58,22 +52,13 @@ async fn twenty_quic_lifetimes_return_owned_resources_to_zero_then_remain_quiet(
     let stopped = probe.snapshot();
     assert_eq!(stopped.peak(ResourceKind::Task), 1);
     assert_eq!(stopped.peak(ResourceKind::Socket), 1);
-    _case.checkpoint("after-stop", stopped.clone());
     tokio::time::sleep(Duration::from_secs(5)).await;
     assert_eq!(probe.snapshot(), stopped);
-    _case.checkpoint("quiet", probe.snapshot());
-    _case.resources(stopped);
 }
 
 #[tokio::test]
 async fn physical_tcp_guard_survives_connect_and_releases_on_stream_drop() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-RESOURCES",
-        "physical_tcp_guard_survives_connect_and_releases_on_stream_drop",
-    );
     let probe = Arc::new(ResourceProbe::default());
-    _case.checkpoint("baseline", probe.snapshot());
     probe
         .scope(async {
             let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
@@ -89,20 +74,13 @@ async fn physical_tcp_guard_survives_connect_and_releases_on_stream_drop() {
             assert!(probe.snapshot().is_idle());
         })
         .await;
-    _case.checkpoint("after-stop", probe.snapshot());
-    _case.resources(probe.snapshot());
 }
 
 #[cfg(feature = "stream-transport")]
 #[tokio::test]
 async fn twenty_stream_lifetimes_and_cancelled_setups_remain_quiet() {
     use tokio::io::{AsyncReadExt, AsyncWriteExt};
-    let mut case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-RESOURCES",
-        "twenty_stream_lifetimes_and_cancelled_setups_remain_quiet",
-    );
     let probe = ResourceProbe::default();
-    case.checkpoint("baseline", probe.snapshot());
     for _ in 0..20 {
         for is_grpc in [true, false] {
             tokio::time::timeout(
@@ -179,9 +157,6 @@ async fn twenty_stream_lifetimes_and_cancelled_setups_remain_quiet() {
     let stopped = probe.snapshot();
     assert_eq!(stopped.peak(ResourceKind::Task), 1);
     assert_eq!(stopped.peak(ResourceKind::Session), 1);
-    case.checkpoint("after-stop", stopped.clone());
     tokio::time::sleep(Duration::from_secs(5)).await;
     assert_eq!(probe.snapshot(), stopped);
-    case.checkpoint("quiet", probe.snapshot());
-    case.resources(stopped);
 }
diff --git a/tests/security_capabilities.rs b/tests/security_capabilities.rs
index ab1d17d..56912d2 100644
--- a/tests/security_capabilities.rs
+++ b/tests/security_capabilities.rs
@@ -1,4 +1,4 @@
-//! Public configuration must produce the required REALITY shares on both legs.
+//! Public configuration preserves real REALITY key shares on both legs.
 //! Pure memory IO; no protocol peer or host listener.
 #![cfg(all(feature = "tls-fingerprint", feature = "outbound-vless"))]
 
@@ -61,14 +61,14 @@ fn key_shares(records: &[u8]) -> Vec<(u16, usize)> {
 }
 
 #[tokio::test]
-async fn public_hybrid_reality_emits_required_shares_on_both_transport_legs() {
+async fn public_hybrid_reality_preserves_real_shares_on_both_transport_legs() {
     use serde_json::json;
     use vole::{
         config::{Config, ProxyProtocol},
         security::SecurityClient,
     };
 
-    for profile in ["none", "chrome"] {
+    for profile in ["none", "chrome", "firefox", "safari", "ios", "edge", "qq"] {
         let yaml = serde_json::to_vec(&json!({
             "mixed-port": 1080,
             "proxies": [{
@@ -110,10 +110,10 @@ async fn public_hybrid_reality_emits_required_shares_on_both_transport_legs() {
             let shares = key_shares(&wire);
             handshake.abort();
             assert!(matches!(handshake.await, Err(error) if error.is_cancelled()));
-            let expected = if profile == "chrome" {
-                vec![(X25519_MLKEM768, 1216), (X25519, 32)]
-            } else {
-                vec![(X25519_MLKEM768, 1216)]
+            let expected = match profile {
+                "none" | "chrome" => vec![(X25519_MLKEM768, 1216), (X25519, 32)],
+                "firefox" => vec![(X25519, 32), (23, 65)],
+                _ => vec![(X25519, 32)],
             };
             assert_eq!(shares, expected, "public {profile} REALITY");
             assert_eq!(
diff --git a/tests/shadowsocks_backpressure.rs b/tests/shadowsocks_backpressure.rs
index 7aa59e9..5b9740f 100644
--- a/tests/shadowsocks_backpressure.rs
+++ b/tests/shadowsocks_backpressure.rs
@@ -6,18 +6,21 @@ use shadowsocks::{
     config::ServerType,
     context::Context,
     relay::tcprelay::{
-        crypto_io::{CryptoRead, CryptoStream, CryptoWrite, StreamType},
-        proxy_stream::{ProxyServerStream, protocol::TcpRequestHeader},
+        crypto_io::{CryptoStream, CryptoWrite, StreamType},
+        proxy_stream::ProxyServerStream,
     },
 };
 use std::{
     future::poll_fn,
     pin::Pin,
-    sync::{Arc, Mutex},
+    sync::{
+        Arc, Mutex,
+        atomic::{AtomicUsize, Ordering},
+    },
     task::Poll,
     time::Duration,
 };
-use tokio::io::{AsyncReadExt, AsyncWrite, AsyncWriteExt, BufWriter};
+use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt, BufWriter, ReadBuf};
 use vole::{
     config::{ShadowsocksCipher, ShadowsocksOutboundConfig},
     dispatch::{BoxStream, DatagramTransport, DispatchError},
@@ -29,6 +32,49 @@ use vole::{
 };
 
 struct MemoryUpstream(Mutex<Option<BoxStream>>);
+
+struct RecordedIo {
+    inner: tokio::io::DuplexStream,
+    written: Arc<AtomicUsize>,
+}
+
+impl AsyncRead for RecordedIo {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+        out: &mut ReadBuf<'_>,
+    ) -> Poll<std::io::Result<()>> {
+        Pin::new(&mut self.inner).poll_read(cx, out)
+    }
+}
+
+impl AsyncWrite for RecordedIo {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+        bytes: &[u8],
+    ) -> Poll<std::io::Result<usize>> {
+        let result = Pin::new(&mut self.inner).poll_write(cx, bytes);
+        if let Poll::Ready(Ok(written)) = result {
+            self.written.fetch_add(written, Ordering::Relaxed);
+        }
+        result
+    }
+
+    fn poll_flush(
+        mut self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> Poll<std::io::Result<()>> {
+        Pin::new(&mut self.inner).poll_flush(cx)
+    }
+
+    fn poll_shutdown(
+        mut self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> Poll<std::io::Result<()>> {
+        Pin::new(&mut self.inner).poll_shutdown(cx)
+    }
+}
 #[async_trait]
 impl OutboundConnector for MemoryUpstream {
     async fn connect_stream(
@@ -50,11 +96,88 @@ impl OutboundConnector for MemoryUpstream {
     }
 }
 
+#[tokio::test]
+async fn empty_writes_after_first_payload_emit_no_extra_encrypted_chunks() {
+    for cipher in [
+        ShadowsocksCipher::Aes128Gcm,
+        ShadowsocksCipher::Aes256Gcm,
+        ShadowsocksCipher::Chacha20Poly1305,
+    ] {
+        let key = vec![7; cipher.key_len()];
+        let config = ShadowsocksOutboundConfig {
+            address: "fixture.invalid".into(),
+            port: 443,
+            cipher,
+            password: STANDARD.encode(&key),
+            plugin: None,
+            udp_over_tcp: false,
+        };
+        let (client, peer) = tokio::io::duplex(4096);
+        let written = Arc::new(AtomicUsize::new(0));
+        let outbound = ShadowsocksOutbound::new_with_path(
+            &config,
+            UpstreamPath::proxy(Arc::new(MemoryUpstream(Mutex::new(Some(Box::new(
+                RecordedIo {
+                    inner: client,
+                    written: written.clone(),
+                },
+            )))))),
+        )
+        .unwrap();
+        let target = Destination::domain("target.invalid", 80).unwrap();
+        let mut stream = outbound
+            .connect_stream(
+                StreamSession {
+                    metadata: Default::default(),
+                    inbound: InboundKind::Socks5,
+                    source: "127.0.0.1:1234".parse().unwrap(),
+                    destination: target,
+                    sniffed_domain: None,
+                },
+                &EstablishContext::default(),
+            )
+            .await
+            .unwrap()
+            .io;
+        assert!(
+            poll_fn(|cx| Poll::Ready(
+                Pin::new(&mut stream).poll_read(cx, &mut ReadBuf::new(&mut []))
+            ))
+            .await
+            .is_ready()
+        );
+        stream.flush().await.unwrap();
+        assert_eq!(written.load(Ordering::Relaxed), 0);
+        stream.write_all(b"first").await.unwrap();
+        stream.flush().await.unwrap();
+        let before = written.load(Ordering::Relaxed);
+        for _ in 0..2 {
+            assert_eq!(stream.write(&[]).await.unwrap(), 0);
+            stream.flush().await.unwrap();
+            assert_eq!(
+                written.load(Ordering::Relaxed),
+                before,
+                "{cipher:?}: an empty write emitted another encrypted chunk"
+            );
+        }
+        let mut decoder = ProxyServerStream::from_stream(
+            Context::new_shared(ServerType::Server),
+            peer,
+            cipher.as_str().parse().unwrap(),
+            &key,
+        );
+        assert_eq!(
+            decoder.handshake().await.unwrap(),
+            ("target.invalid".to_owned(), 80).into()
+        );
+        let mut payload = [0; 5];
+        decoder.read_exact(&mut payload).await.unwrap();
+        assert_eq!(&payload, b"first");
+    }
+}
+
 #[tokio::test]
 async fn growing_caller_buffer_after_backpressure_never_loses_plaintext() {
-    #[cfg(feature = "interop-test")]
-    let _case =
-        vole::resources::case_events::Case::new("INTEGRATION-ADAPTER", "growing_caller_buffer");
     for (cipher, initial) in [
         ShadowsocksCipher::Aes128Gcm,
         ShadowsocksCipher::Aes256Gcm,
@@ -69,7 +192,7 @@ async fn growing_caller_buffer_after_backpressure_never_loses_plaintext() {
             port: 443,
             cipher,
             password: STANDARD.encode(&key),
-            shadow_tls: None,
+            plugin: None,
             udp_over_tcp: false,
         };
         let (client, peer) = tokio::io::duplex(4096);
@@ -80,6 +203,7 @@ async fn growing_caller_buffer_after_backpressure_never_loses_plaintext() {
         .unwrap();
         let target = Destination::domain("target.invalid", 80).unwrap();
         let session = StreamSession {
+            metadata: Default::default(),
             inbound: InboundKind::Socks5,
             source: "127.0.0.1:1234".parse().unwrap(),
             destination: target,
@@ -136,11 +260,6 @@ async fn growing_caller_buffer_after_backpressure_never_loses_plaintext() {
 
 #[tokio::test]
 async fn read_first_flushes_the_official_header_over_a_buffered_upstream() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "INTEGRATION-ADAPTER",
-        "server_first_buffered_upstream",
-    );
     for cipher in [
         ShadowsocksCipher::Aes128Gcm,
         ShadowsocksCipher::Aes256Gcm,
@@ -152,7 +271,7 @@ async fn read_first_flushes_the_official_header_over_a_buffered_upstream() {
             port: 443,
             cipher,
             password: STANDARD.encode(&key),
-            shadow_tls: None,
+            plugin: None,
             udp_over_tcp: false,
         };
         let (client, peer) = tokio::io::duplex(4096);
@@ -168,6 +287,7 @@ async fn read_first_flushes_the_official_header_over_a_buffered_upstream() {
         let mut stream = outbound
             .connect_stream(
                 StreamSession {
+                    metadata: Default::default(),
                     inbound: InboundKind::Socks5,
                     source: "127.0.0.1:1234".parse().unwrap(),
                     destination: Destination::domain("target.invalid", 80).unwrap(),
@@ -178,11 +298,9 @@ async fn read_first_flushes_the_official_header_over_a_buffered_upstream() {
             .await
             .unwrap()
             .io;
-        let context = Context::new_shared(ServerType::Server);
-        let mut decoder = CryptoStream::from_stream(
-            &context,
+        let mut decoder = ProxyServerStream::from_stream(
+            Context::new_shared(ServerType::Server),
             peer,
-            StreamType::Server,
             cipher.as_str().parse().unwrap(),
             &key,
         );
@@ -194,32 +312,12 @@ async fn read_first_flushes_the_official_header_over_a_buffered_upstream() {
                     assert_eq!(&greeting, b"hello");
                 },
                 async {
-                    // Exercise only the adapter's flush contract. The official
-                    // client randomly chooses zero padding for an empty request,
-                    // which its strict server rejects. Parse with its codec here;
-                    // the deterministic test below separately locks that rejection.
-                    let mut bytes = [0; 1024];
-                    let mut buffer = tokio::io::ReadBuf::new(&mut bytes);
-                    poll_fn(|cx| {
-                        Pin::new(&mut decoder).poll_read_decrypted(cx, &context, &mut buffer)
-                    })
-                    .await
-                    .unwrap();
-                    let mut plaintext = buffer.filled();
-                    let header = TcpRequestHeader::read_from(
-                        cipher.as_str().parse().unwrap(),
-                        &mut plaintext,
-                    )
-                    .await
-                    .unwrap();
-                    assert_eq!(header.addr(), ("target.invalid".to_owned(), 80).into());
-                    assert!(plaintext.is_empty());
-                    let request_nonce = decoder.received_nonce().unwrap().to_vec();
-                    decoder.set_request_nonce(&request_nonce);
-                    poll_fn(|cx| Pin::new(&mut decoder).poll_write_encrypted(cx, b"hello"))
-                        .await
-                        .unwrap();
-                    poll_fn(|cx| decoder.poll_flush(cx)).await.unwrap();
+                    assert_eq!(
+                        decoder.handshake().await.unwrap(),
+                        ("target.invalid".to_owned(), 80).into()
+                    );
+                    decoder.write_all(b"hello").await.unwrap();
+                    decoder.flush().await.unwrap();
                 }
             );
         })
diff --git a/tests/shadowsocks_uot.rs b/tests/shadowsocks_uot.rs
index 10a74ee..9f8f2ef 100644
--- a/tests/shadowsocks_uot.rs
+++ b/tests/shadowsocks_uot.rs
@@ -99,8 +99,6 @@ const CIPHERS: [&str; 3] = [
 
 #[tokio::test]
 async fn never_sent_close_drop_and_stop_release_io_without_an_empty_ss_write() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new("UOT-SS", "never_sent");
     for cipher in CIPHERS {
         for ending in ["close", "drop", "stop"] {
             let (outbound, mut peer) = fixture(cipher, 64);
@@ -137,8 +135,6 @@ async fn never_sent_close_drop_and_stop_release_io_without_an_empty_ss_write() {
 
 #[tokio::test(start_paused = true)]
 async fn late_first_packet_uses_original_deadline_but_established_io_does_not() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new("UOT-SS", "deadline");
     let (outbound, mut peer) = fixture(CIPHERS[0], 4096);
     let context = EstablishContext::with_timeout(Duration::from_secs(2));
     let mut association = outbound.open_datagram(request(), &context).await.unwrap();
@@ -173,43 +169,70 @@ async fn late_first_packet_uses_original_deadline_but_established_io_does_not()
 }
 
 #[tokio::test]
-async fn cancelled_partial_send_poisoning_and_stop_release_a_blocked_writer() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new("UOT-SS", "cancel_write");
+async fn cancelled_partial_send_resumes_and_stop_releases_a_blocked_writer() {
     for stop in [false, true] {
-        let (outbound, mut peer) = fixture(CIPHERS[0], 64);
+        let (outbound, peer) = fixture(CIPHERS[0], 64);
         let mut association = outbound
             .open_datagram(request(), &EstablishContext::default())
             .await
             .unwrap();
+        assert!(association.supports_shared_destinations());
         if stop {
             let (sent, ()) = tokio::join!(association.send(packet(65_535)), async {
                 tokio::task::yield_now().await;
                 outbound.shutdown().await;
             });
             assert!(sent.is_err());
+            let mut peer = peer;
+            let mut bytes = Vec::new();
+            tokio::time::timeout(Duration::from_secs(1), peer.read_to_end(&mut bytes))
+                .await
+                .unwrap()
+                .unwrap();
+            assert!(bytes.len() <= 64);
         } else {
             assert!(
                 tokio::time::timeout(Duration::from_millis(10), association.send(packet(65_535)))
                     .await
                     .is_err()
             );
-            assert!(association.send(packet(0)).await.is_err());
+            let decoding = tokio::spawn(async move {
+                let mut decoded = decoder(peer, CIPHERS[0]);
+                assert_eq!(
+                    decoded.handshake().await.unwrap(),
+                    ("sp.v2.udp-over-tcp.arpa".to_owned(), 0).into()
+                );
+                let mut header = [0; 17];
+                decoded.read_exact(&mut header).await.unwrap();
+                assert_eq!(
+                    header,
+                    [0, 1, 127, 0, 0, 1, 0, 53, 0, 127, 0, 0, 1, 0, 53, 255, 255]
+                );
+                let mut payload = vec![0; 65_535];
+                decoded.read_exact(&mut payload).await.unwrap();
+                assert!(payload.iter().all(|byte| *byte == 7));
+                let mut next = [0; 9];
+                decoded.read_exact(&mut next).await.unwrap();
+                assert_eq!(next, [0, 127, 0, 0, 2, 0, 54, 0, 0]);
+                assert_eq!(decoded.read(&mut [0]).await.unwrap(), 0);
+            });
+            let mut next = packet(0);
+            next.remote = Destination::Ip("127.0.0.2:54".parse().unwrap());
+            tokio::time::timeout(Duration::from_secs(2), association.send(next))
+                .await
+                .unwrap()
+                .unwrap();
             outbound.shutdown().await;
+            tokio::time::timeout(Duration::from_secs(1), decoding)
+                .await
+                .unwrap()
+                .unwrap();
         }
-        let mut bytes = Vec::new();
-        tokio::time::timeout(Duration::from_secs(1), peer.read_to_end(&mut bytes))
-            .await
-            .unwrap()
-            .unwrap();
-        assert!(bytes.len() <= 64);
     }
 }
 
 #[tokio::test]
 async fn all_ciphers_preserve_budget_edges_and_fragmented_receive_cancellation() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new("UOT-SS", "budget_read_cancel");
     for cipher in CIPHERS {
         let (outbound, peer) = fixture(cipher, 4096);
         let mut association = outbound
@@ -219,6 +242,7 @@ async fn all_ciphers_preserve_budget_edges_and_fragmented_receive_cancellation()
             )
             .await
             .unwrap();
+        assert!(association.supports_shared_destinations());
         assert!(association.send(packet(65_536)).await.is_err());
         let (ready, arrived) = tokio::sync::oneshot::channel();
         let (resume, proceed) = tokio::sync::oneshot::channel();
@@ -305,8 +329,6 @@ impl vole::dialer::Resolver for ControlledResolver {
 
 #[tokio::test]
 async fn domains_use_only_the_supplied_resolver_and_stop_cancels_pending_dns() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new("UOT-SS", "dns");
     use std::sync::atomic::{AtomicUsize, Ordering};
     use vole::dns::resolution::ResolutionContext;
     let mut datagram = packet(0);
@@ -365,7 +387,6 @@ async fn domains_use_only_the_supplied_resolver_and_stop_cancels_pending_dns() {
 #[cfg(feature = "interop-test")]
 #[tokio::test]
 async fn stop_joins_a_full_receiver_and_releases_io_with_the_association_retained() {
-    let _case = vole::resources::case_events::Case::new("UOT-SS", "stop_full_queue");
     let probe = vole::resources::observation::ResourceProbe::default();
     let (outbound, peer) = fixture(CIPHERS[0], 4096);
     let mut association = probe
@@ -420,8 +441,6 @@ async fn stop_joins_a_full_receiver_and_releases_io_with_the_association_retaine
 
 #[tokio::test]
 async fn zero_length_first_datagram_initializes_ss_once_without_an_empty_write() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new("UOT-SS", "first_packet");
     let config = Config::parse_yaml(br#"
 mixed-port: 1080
 proxies:
diff --git a/tests/shadowtls_config.rs b/tests/shadowtls_config.rs
index 7456b0c..f18abb5 100644
--- a/tests/shadowtls_config.rs
+++ b/tests/shadowtls_config.rs
@@ -35,35 +35,64 @@ fn policy(node: Value) -> ShadowTlsConfig {
     let ProxyProtocol::Shadowsocks(ss) = &config.proxies[0].protocol else {
         panic!()
     };
-    ss.shadow_tls.clone().unwrap()
+    match ss.plugin.clone().unwrap() {
+        vole::config::ShadowsocksPlugin::ShadowTls(config) => config,
+        _ => panic!("expected ShadowTLS"),
+    }
 }
 
 #[cfg(feature = "shadow-tls-v3")]
 #[test]
-fn shadowtls_preserves_policy_values_and_shared_profile_aliases() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new("SHADOWTLS-CFG", "policy");
+fn shadowtls_preserves_policy_values_and_shared_profiles() {
     let config = policy(node());
+    let mut disabled = node();
+    disabled.as_object_mut().unwrap().remove("plugin-opts");
+    disabled["plugin"] = json!("");
+    let disabled = parse(disabled).unwrap();
+    let ProxyProtocol::Shadowsocks(plain) = &disabled.proxies[0].protocol else {
+        panic!()
+    };
+    assert!(plain.plugin.is_none());
+    assert_eq!(plain.address, "fixture.invalid");
+    assert_eq!(plain.port, 443);
     assert_eq!(config.password, " synthetic-private-marker ");
     assert_eq!(config.alpn, [b"h2".to_vec(), b"http/1.1".to_vec()]);
     assert!(!config.certificate.skip_cert_verify);
     assert!(config.certificate.fingerprint.is_none());
     assert!(config.certificate.verification_name.is_none());
     assert_eq!(config.client_fingerprint, None);
+    let mut empty_overrides = node();
+    empty_overrides["plugin-opts"]["fingerprint"] = json!("");
+    empty_overrides["plugin-opts"]["name-cert-verify"] = json!("");
+    let defaults = policy(empty_overrides);
+    assert_eq!(defaults.certificate, config.certificate);
+    assert_eq!(defaults.server_name, config.server_name);
+    assert_eq!(defaults.password, config.password);
     for (name, expected) in [
         ("", None),
         ("none", None),
         ("chrome", Some(ClientFingerprint::Chrome133)),
-        ("chrome120", Some(ClientFingerprint::Chrome120)),
         ("firefox", Some(ClientFingerprint::Firefox120)),
-        ("firefox120", Some(ClientFingerprint::Firefox120)),
         ("safari", Some(ClientFingerprint::Safari16)),
-        ("safari16", Some(ClientFingerprint::Safari16)),
+        ("ios", Some(ClientFingerprint::Ios14)),
     ] {
         let mut n = node();
         n["client-fingerprint"] = json!(name);
         assert_eq!(policy(n).client_fingerprint, expected);
     }
+    let mut random = node();
+    random["client-fingerprint"] = json!("random");
+    let selected = policy(random.clone()).client_fingerprint;
+    assert!(matches!(
+        selected,
+        Some(
+            ClientFingerprint::Chrome133
+                | ClientFingerprint::Safari16
+                | ClientFingerprint::Ios14
+                | ClientFingerprint::Firefox120
+        )
+    ));
+    assert_eq!(policy(random).client_fingerprint, selected);
     for alpn in [
         vec![],
         vec!["custom".to_owned(), "h2".to_owned()],
@@ -76,6 +105,9 @@ fn shadowtls_preserves_policy_values_and_shared_profile_aliases() {
             alpn.into_iter().map(String::into_bytes).collect::<Vec<_>>()
         );
     }
+    let mut null_alpn = node();
+    null_alpn["plugin-opts"]["alpn"] = Value::Null;
+    assert!(policy(null_alpn).alpn.is_empty());
     for host in ["cover.invalid", "192.0.2.7", "2001:db8::7"] {
         let mut n = node();
         let o = &mut n["plugin-opts"];
@@ -104,29 +136,26 @@ fn shadowtls_preserves_policy_values_and_shared_profile_aliases() {
 #[cfg(feature = "shadow-tls-v3")]
 #[test]
 fn shadowtls_rejects_invalid_types_bounds_unknown_fields_and_nulls_without_secrets() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new("SHADOWTLS-CFG", "reject");
-    let assert_rejected = |n| {
-        let error = parse(n).expect_err("must reject before IO").to_string();
+    let assert_rejected = |n, case: &str| {
+        let error = parse(n).expect_err(case).to_string();
         assert!(!error.contains("synthetic-private-marker"), "{error}");
     };
     for key in ["plugin", "plugin-opts", "client-fingerprint"] {
         let mut n = node();
         n[key] = Value::Null;
-        assert_rejected(n);
+        assert_rejected(n, &format!("{key}: null must reject before IO"));
     }
     for key in [
         "version",
         "host",
         "password",
-        "alpn",
         "skip-cert-verify",
         "fingerprint",
         "name-cert-verify",
     ] {
         let mut n = node();
         n["plugin-opts"][key] = Value::Null;
-        assert_rejected(n);
+        assert_rejected(n, &format!("plugin-opts.{key}: null must reject before IO"));
     }
     for (key, values) in [
         (
@@ -166,37 +195,39 @@ fn shadowtls_rejects_invalid_types_bounds_unknown_fields_and_nulls_without_secre
         ("skip-cert-verify", vec![json!(1), json!("true")]),
         (
             "fingerprint",
-            vec![json!(""), json!("ff"), json!("z".repeat(64)), json!(true)],
-        ),
-        (
-            "name-cert-verify",
-            vec![json!(""), json!("bad name"), json!(false)],
+            vec![json!("ff"), json!("z".repeat(64)), json!(true)],
         ),
+        ("name-cert-verify", vec![json!("bad name"), json!(false)]),
         ("strict-mode", vec![json!(true), json!(false)]),
         ("unknown", vec![json!("synthetic-private-marker")]),
     ] {
         for value in values {
             let mut n = node();
+            let case = format!("plugin-opts.{key}: {value} must reject before IO");
             n["plugin-opts"][key] = value;
-            assert_rejected(n);
+            assert_rejected(n, &case);
         }
     }
-    for value in [json!("chrome133"), json!("random"), json!(true), json!([])] {
+    for value in [
+        json!("chrome133"),
+        json!("randomized"),
+        json!(true),
+        json!([]),
+    ] {
         let mut n = node();
+        let case = format!("client-fingerprint: {value} must reject before IO");
         n["client-fingerprint"] = value;
-        assert_rejected(n);
+        assert_rejected(n, &case);
     }
     for key in ["plugin", "plugin-opts"] {
         let mut n = node();
         n.as_object_mut().unwrap().remove(key);
-        assert_rejected(n);
+        assert_rejected(n, &format!("missing {key} must reject before IO"));
     }
 }
 
 #[test]
 fn shadowtls_requires_explicit_v3_and_a_complete_plugin_policy() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new("SHADOWTLS-CFG", "feature");
     let fields = "    plugin: shadow-tls\n    plugin-opts: {version: 3, host: cover.invalid, password: ' secret '}";
     let result = Config::parse_yaml(yaml(fields).as_bytes());
     // This protocol is independently removable even when boring is present.
diff --git a/tests/shadowtls_stream.rs b/tests/shadowtls_stream.rs
index deb424d..b7da54f 100644
--- a/tests/shadowtls_stream.rs
+++ b/tests/shadowtls_stream.rs
@@ -16,6 +16,8 @@ fn options(profile: Option<ClientFingerprint>) -> ShadowTlsConfig {
         server_name: "cover.invalid".into(),
         password: PASSWORD.into(),
         alpn: vec![b"h2".to_vec(), b"http/1.1".to_vec()],
+        required_alpn: None,
+        identity: None,
         certificate: Default::default(),
         client_fingerprint: profile,
     }
@@ -23,17 +25,15 @@ fn options(profile: Option<ClientFingerprint>) -> ShadowTlsConfig {
 
 #[tokio::test]
 async fn cancelled_shadowtls_handshakes_release_io_and_never_reuse_authenticated_hellos() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new("SHADOWTLS-STREAM", "cancelled_hello");
     use ClientFingerprint::*;
     tokio::time::timeout(Duration::from_secs(10), async {
         let mut seen = HashSet::new();
         for profile in [
             None,
-            Some(Chrome120),
             Some(Chrome133),
             Some(Firefox120),
             Some(Safari16),
+            Some(Ios14),
         ] {
             let client = ShadowTlsClient::new(&SecurityContext::new(), &options(profile)).unwrap();
             for _ in 0..4 {
@@ -68,8 +68,6 @@ async fn cancelled_shadowtls_handshakes_release_io_and_never_reuse_authenticated
 
 #[tokio::test]
 async fn truncated_or_oversized_shadowtls_handshake_records_never_create_a_business_stream() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new("SHADOWTLS-STREAM", "invalid_record");
     tokio::time::timeout(Duration::from_secs(10), async {
         for record in [
             vec![],
diff --git a/tests/sing_mux.rs b/tests/sing_mux.rs
index feded63..4441dbb 100644
--- a/tests/sing_mux.rs
+++ b/tests/sing_mux.rs
@@ -1,4 +1,4 @@
-#![cfg(feature = "outbound-vless")]
+#![cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
 use async_trait::async_trait;
 use bytes::Bytes;
 use std::{
@@ -14,7 +14,8 @@ use vole::{
     config::{Config, ProxyProtocol},
     dispatch::{BoxStream, DatagramTransport, DispatchError},
     outbound::{
-        ConnectedStream, DatagramRequest, EstablishContext, OutboundConnector, VlessOutbound,
+        ConnectedStream, DatagramRequest, EstablishContext, OutboundConnector, SingMuxConnector,
+        VlessOutbound,
     },
     session::{Destination, InboundKind, StreamSession},
 };
@@ -24,6 +25,7 @@ struct MemoryPeer {
     tasks: Mutex<Vec<tokio::task::JoinHandle<()>>>,
     udp: bool,
     protocol: u8,
+    brutal_exchanges: Option<Arc<AtomicUsize>>,
 }
 #[async_trait]
 impl OutboundConnector for MemoryPeer {
@@ -36,6 +38,7 @@ impl OutboundConnector for MemoryPeer {
         let (client, mut server) = tokio::io::duplex(65536);
         let udp = self.udp;
         let protocol = self.protocol;
+        let brutal_exchanges = self.brutal_exchanges.clone();
         self.tasks.lock().unwrap().push(tokio::spawn(async move {
             let mut header = [0; 23];
             server.read_exact(&mut header).await.unwrap();
@@ -74,8 +77,14 @@ impl OutboundConnector for MemoryPeer {
                         }
                         2 => {
                             if opened.insert(id) {
-                                assert_eq!(data, [0, 0, 1, 192, 0, 2, 1, 1, 187]);
-                                data = b"\x00hello".to_vec();
+                                if let Some(response) =
+                                    brutal_response(&data, brutal_exchanges.as_deref())
+                                {
+                                    data = response;
+                                } else {
+                                    assert_eq!(data, [0, 0, 1, 192, 0, 2, 1, 1, 187]);
+                                    data = b"\x00hello".to_vec();
+                                }
                             }
                             head[2..4].copy_from_slice(&(data.len() as u16).to_le_bytes());
                             server.write_all(&head).await.unwrap();
@@ -98,16 +107,33 @@ impl OutboundConnector for MemoryPeer {
                 while let Some(Ok(stream)) =
                     futures_util::future::poll_fn(|cx| connection.poll_next_inbound(cx)).await
                 {
+                    let brutal_exchanges = brutal_exchanges.clone();
                     tasks.spawn(async move {
                         let mut io = stream.compat();
-                        let mut request = [0; 9];
-                        io.read_exact(&mut request).await.unwrap();
-                        assert_eq!(request, [0, 0, 1, 192, 0, 2, 1, 1, 187]);
+                        let mut prefix = [0; 4];
+                        io.read_exact(&mut prefix).await.unwrap();
+                        if prefix == [0, 0, 3, 17] {
+                            let mut request = prefix.to_vec();
+                            let mut rest = [0; 27];
+                            io.read_exact(&mut rest).await.unwrap();
+                            request.extend_from_slice(&rest);
+                            let response =
+                                brutal_response(&request, brutal_exchanges.as_deref()).unwrap();
+                            io.write_all(&response).await.unwrap();
+                            io.flush().await.unwrap();
+                            return;
+                        }
+                        let mut rest = [0; 5];
+                        io.read_exact(&mut rest).await.unwrap();
+                        assert_eq!(prefix, [0, 0, 1, 192]);
+                        assert_eq!(rest, [0, 2, 1, 1, 187]);
                         io.write_all(b"\x00hello").await.unwrap();
                         io.flush().await.unwrap();
                         let mut scratch = [0; 1024];
                         while let Ok(n) = io.read(&mut scratch).await {
                             if n == 0 {
+                                let _ = io.write_all(b"tail").await;
+                                let _ = io.shutdown().await;
                                 break;
                             }
                             io.write_all(&scratch[..n]).await.unwrap();
@@ -124,9 +150,27 @@ impl OutboundConnector for MemoryPeer {
             let mut streams = tokio::task::JoinSet::new();
             while let Some(Ok((request, mut response))) = connection.accept().await {
                 assert_eq!(request.method(), "CONNECT");
+                let brutal_exchanges = brutal_exchanges.clone();
                 streams.spawn(async move {
                     let mut input = request.into_body();
                     let first = input.data().await.unwrap().unwrap();
+                    if let Some(reply) = brutal_response(&first, brutal_exchanges.as_deref()) {
+                        input.flow_control().release_capacity(first.len()).unwrap();
+                        let mut output = response
+                            .send_response(http::Response::new(()), false)
+                            .unwrap();
+                        output.send_data(Bytes::from(reply), true).unwrap();
+                        // send_data only queues DATA. Keep the request and
+                        // response references until the client closes its
+                        // control stream, so h2 cannot reset it before the
+                        // reply is driven onto the supplied IO. Mihomo's
+                        // server flushes its writer before closing this stream.
+                        while let Some(Ok(data)) = input.data().await {
+                            input.flow_control().release_capacity(data.len()).unwrap();
+                        }
+                        drop(output);
+                        return;
+                    }
                     if udp {
                         assert_eq!(&first[..2], &[0, 3]);
                     } else {
@@ -142,9 +186,20 @@ impl OutboundConnector for MemoryPeer {
                             false,
                         )
                         .unwrap();
-                    while let Some(Ok(data)) = input.data().await {
-                        input.flow_control().release_capacity(data.len()).unwrap();
-                        output.send_data(data, false).unwrap();
+                    loop {
+                        match input.data().await {
+                            Some(Ok(data)) => {
+                                input.flow_control().release_capacity(data.len()).unwrap();
+                                if output.send_data(data, false).is_err() {
+                                    break;
+                                }
+                            }
+                            None => {
+                                let _ = output.send_data(Bytes::from_static(b"tail"), true);
+                                break;
+                            }
+                            Some(Err(_)) => break,
+                        }
                     }
                 });
             }
@@ -165,20 +220,45 @@ impl OutboundConnector for MemoryPeer {
         Err(DispatchError::NotAllowed)
     }
 }
-fn outbound(peer: Arc<MemoryPeer>, options: &str) -> VlessOutbound {
+fn brutal_response(request: &[u8], exchanges: Option<&AtomicUsize>) -> Option<Vec<u8>> {
+    if !request.starts_with(&[0, 0, 3, 17]) {
+        return None;
+    }
+    assert_eq!(&request[4..23], b"_BrutalBwExchange\0\0");
+    assert_eq!(
+        u64::from_be_bytes(request[23..].try_into().unwrap()),
+        12_500_000
+    );
+    exchanges
+        .expect("unexpected Brutal exchange")
+        .fetch_add(1, Ordering::SeqCst);
+    let mut reply = vec![0, 1];
+    reply.extend_from_slice(&8_000_000_u64.to_be_bytes());
+    Some(reply)
+}
+
+fn outbound(peer: Arc<MemoryPeer>, options: &str) -> SingMuxConnector {
     let raw = format!(
         "mixed-port: 1080\nproxies:\n- name: edge\n  type: vless\n  server: example.com\n  port: 443\n  uuid: 07070707-0707-0707-0707-070707070707\n  smux: {{enabled: true, {options}}}\nrules: [MATCH,edge]\n"
     );
     let raw = raw.replace("rules: [MATCH,edge]", "rules: ['MATCH,edge']");
     let config = Config::parse_yaml(raw.as_bytes()).unwrap();
+    let options = config.proxies[0].smux.clone().unwrap();
     let ProxyProtocol::Vless(config) = &config.proxies[0].protocol else {
         unreachable!()
     };
-    VlessOutbound::new_with_upstream(config, peer).unwrap()
+    SingMuxConnector::new(
+        Arc::new(VlessOutbound::new_with_upstream(config, peer).unwrap()),
+        options,
+    )
+}
+async fn open(node: &SingMuxConnector) -> BoxStream {
+    try_open(node).await.unwrap()
 }
-async fn open(node: &VlessOutbound) -> BoxStream {
+async fn try_open(node: &SingMuxConnector) -> Result<BoxStream, DispatchError> {
     node.connect_stream(
         StreamSession {
+            metadata: Default::default(),
             inbound: InboundKind::InternalMeasure,
             source: "127.0.0.1:1".parse().unwrap(),
             destination: Destination::Ip("192.0.2.1:443".parse().unwrap()),
@@ -187,27 +267,182 @@ async fn open(node: &VlessOutbound) -> BoxStream {
         &EstablishContext::default(),
     )
     .await
-    .unwrap()
-    .io
+    .map(|connected| connected.io)
 }
 async fn hello(io: &mut BoxStream) {
     let mut greeting = [0; 5];
     io.read_exact(&mut greeting).await.unwrap();
     assert_eq!(&greeting, b"hello");
 }
+
+#[tokio::test]
+async fn brutal_negotiates_once_and_reuses_one_session_for_all_mux_protocols() {
+    tokio::time::timeout(Duration::from_secs(5), async {
+        for (protocol, wire) in [("h2mux", 2), ("smux", 0), ("yamux", 1)] {
+            let exchanges = Arc::new(AtomicUsize::new(0));
+            let peer = Arc::new(MemoryPeer {
+                count: AtomicUsize::new(0),
+                tasks: Mutex::new(vec![]),
+                udp: false,
+                protocol: wire,
+                brutal_exchanges: Some(exchanges.clone()),
+            });
+            let node = outbound(peer.clone(), &format!(
+                "protocol: {protocol}, max-connections: 4, min-streams: 0, brutal-opts: {{enabled: true, up: 100, down: 100}}"
+            ));
+            let mut streams = Vec::new();
+            for index in 0..4 {
+                let mut stream = try_open(&node).await.unwrap_or_else(|error|
+                    panic!("Brutal {protocol} logical stream {index}: {error:?}; physical={}, exchanges={}",
+                        peer.count.load(Ordering::SeqCst), exchanges.load(Ordering::SeqCst)));
+                hello(&mut stream).await;
+                streams.push(stream);
+            }
+            assert_eq!(peer.count.load(Ordering::SeqCst), 1, "{protocol}");
+            assert_eq!(exchanges.load(Ordering::SeqCst), 1, "{protocol}");
+            drop(streams);
+            node.shutdown().await;
+            let tasks = std::mem::take(&mut *peer.tasks.lock().unwrap());
+            for task in tasks {
+                task.await.unwrap();
+            }
+        }
+    }).await.unwrap();
+}
+
+#[tokio::test]
+async fn brutal_yamux_retirement_waits_for_siblings_and_obeys_deadline_and_stop() {
+    tokio::time::timeout(Duration::from_secs(10), async {
+        let exchanges = Arc::new(AtomicUsize::new(0));
+        let peer = Arc::new(MemoryPeer {
+            count: AtomicUsize::new(0),
+            tasks: Mutex::new(vec![]),
+            udp: false,
+            protocol: 1,
+            brutal_exchanges: Some(exchanges.clone()),
+        });
+        let node = outbound(
+            peer.clone(),
+            "protocol: yamux, brutal-opts: {enabled: true, up: 100, down: 100}",
+        );
+        let mut streams = Vec::new();
+        // The negotiation consumes the first of the 64 transport IDs.
+        for _ in 0..63 {
+            let mut stream = open(&node).await;
+            hello(&mut stream).await;
+            streams.push(stream);
+        }
+        let session = StreamSession {
+            metadata: Default::default(),
+            inbound: InboundKind::InternalMeasure,
+            source: "127.0.0.1:1".parse().unwrap(),
+            destination: Destination::Ip("192.0.2.1:443".parse().unwrap()),
+            sniffed_domain: None,
+        };
+        let short = EstablishContext::with_timeout(Duration::from_millis(20));
+        assert!(matches!(
+            node.connect_stream(session.clone(), &short).await,
+            Err(DispatchError::TimedOut)
+        ));
+        assert_eq!(peer.count.load(Ordering::SeqCst), 1);
+
+        let waiting = open(&node);
+        tokio::pin!(waiting);
+        assert!(futures_util::poll!(&mut waiting).is_pending());
+        streams[0].write_all(b"alive").await.unwrap();
+        streams[0].flush().await.unwrap();
+        let mut reply = [0; 5];
+        streams[0].read_exact(&mut reply).await.unwrap();
+        assert_eq!(&reply, b"alive");
+        assert_eq!(peer.count.load(Ordering::SeqCst), 1);
+        drop(streams);
+        let mut replacement = waiting.await;
+        hello(&mut replacement).await;
+        assert_eq!(peer.count.load(Ordering::SeqCst), 2);
+        assert_eq!(exchanges.load(Ordering::SeqCst), 2);
+
+        let mut streams = vec![replacement];
+        for _ in 1..63 {
+            let mut stream = open(&node).await;
+            hello(&mut stream).await;
+            streams.push(stream);
+        }
+        let context = EstablishContext::default();
+        let waiting = node.connect_stream(session, &context);
+        tokio::pin!(waiting);
+        assert!(futures_util::poll!(&mut waiting).is_pending());
+        node.shutdown().await;
+        assert!(waiting.await.is_err());
+        drop(streams);
+        let tasks = std::mem::take(&mut *peer.tasks.lock().unwrap());
+        for task in tasks {
+            task.await.unwrap();
+        }
+    })
+    .await
+    .unwrap();
+}
+
+#[tokio::test]
+async fn shared_mux_preserves_h2mux_yamux_tail_and_smux_whole_close() {
+    tokio::time::timeout(Duration::from_secs(3), async {
+        for (protocol, wire) in [("h2mux", 2), ("yamux", 1), ("smux", 0)] {
+            let peer = Arc::new(MemoryPeer {
+                count: AtomicUsize::new(0),
+                tasks: Mutex::new(vec![]),
+                udp: false,
+                protocol: wire,
+                brutal_exchanges: None,
+            });
+            let node = outbound(
+                peer.clone(),
+                &format!("protocol: {protocol}, max-connections: 1"),
+            );
+            let mut first = open(&node).await;
+            let mut sibling = open(&node).await;
+            hello(&mut first).await;
+            hello(&mut sibling).await;
+            assert_eq!(peer.count.load(Ordering::SeqCst), 1);
+            first.write_all(b"upload").await.unwrap();
+            first.shutdown().await.unwrap();
+            first.shutdown().await.unwrap();
+            assert!(first.write_all(b"closed").await.is_err());
+            let mut tail = Vec::new();
+            first.read_to_end(&mut tail).await.unwrap();
+            assert_eq!(
+                tail,
+                if protocol == "smux" {
+                    &b""[..]
+                } else {
+                    &b"uploadtail"[..]
+                },
+                "{protocol}"
+            );
+            sibling.write_all(b"alive").await.unwrap();
+            sibling.flush().await.unwrap();
+            let mut response = [0; 5];
+            sibling.read_exact(&mut response).await.unwrap();
+            assert_eq!(&response, b"alive");
+            node.shutdown().await;
+            drop((first, sibling));
+            let tasks = std::mem::take(&mut *peer.tasks.lock().unwrap());
+            for task in tasks {
+                task.await.unwrap();
+            }
+        }
+    })
+    .await
+    .unwrap();
+}
 #[tokio::test]
 async fn yamux_replacing_dropped_streams_at_capacity_keeps_the_sibling_alive() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "yamux_replacing_dropped_streams_at_capacity_keeps_the_sibling_alive",
-    );
     tokio::time::timeout(Duration::from_secs(10), async {
         let peer = Arc::new(MemoryPeer {
             count: AtomicUsize::new(0),
             tasks: Mutex::new(vec![]),
             udp: false,
             protocol: 1,
+            brutal_exchanges: None,
         });
         let node = outbound(peer.clone(), "protocol: yamux, max-connections: 1");
         let mut streams = Vec::new();
@@ -238,11 +473,6 @@ async fn yamux_replacing_dropped_streams_at_capacity_keeps_the_sibling_alive() {
 
 #[tokio::test]
 async fn sing_mux_scheduling_uses_the_selected_branch_not_a_global_stream_quota() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "sing_mux_scheduling_uses_the_selected_branch_not_a_global_stream_quota",
-    );
     tokio::time::timeout(Duration::from_secs(5), async {
         for (protocol, wire) in [("h2mux", 2), ("smux", 0), ("yamux", 1)] {
             for (settings, counts) in [
@@ -256,6 +486,7 @@ async fn sing_mux_scheduling_uses_the_selected_branch_not_a_global_stream_quota(
                     tasks: Mutex::new(vec![]),
                     udp: false,
                     protocol: wire,
+                    brutal_exchanges: None,
                 });
                 let node = outbound(peer.clone(), &format!("protocol: {protocol}, {settings}"));
                 let mut streams = Vec::new();
@@ -313,20 +544,20 @@ impl OutboundConnector for CapturePeer {
 
 #[tokio::test]
 async fn h2mux_sends_idle_ping_and_retires_a_peer_that_never_acknowledges() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "h2mux_sends_idle_ping_and_retires_a_peer_that_never_acknowledges",
-    );
     let raw = serde_json::json!({"mixed-port":1080,"proxies":[{"name":"edge","type":"vless","server":"example.com","port":443,"uuid":"07070707-0707-0707-0707-070707070707","smux":{"enabled":true,"max-connections":1}}],"rules":["MATCH,edge"]});
     let config = Config::parse_yaml(raw.to_string().as_bytes()).unwrap();
+    let options = config.proxies[0].smux.clone().unwrap();
     let ProxyProtocol::Vless(config) = &config.proxies[0].protocol else {
         unreachable!()
     };
     let (io, mut peer) = tokio::io::duplex(4096);
-    let node =
-        VlessOutbound::new_with_upstream(config, Arc::new(CapturePeer(Mutex::new(Some(io)))))
-            .unwrap();
+    let node = SingMuxConnector::new(
+        Arc::new(
+            VlessOutbound::new_with_upstream(config, Arc::new(CapturePeer(Mutex::new(Some(io)))))
+                .unwrap(),
+        ),
+        options,
+    );
     let (ping, mut received) = tokio::sync::oneshot::channel();
     let peer = tokio::spawn(async move {
         let mut preface = [0; 45];
@@ -378,21 +609,18 @@ async fn h2mux_sends_idle_ping_and_retires_a_peer_that_never_acknowledges() {
 }
 
 #[tokio::test]
-async fn only_tcp_preserves_all_three_vless_udp_wire_commands() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "only_tcp_preserves_all_three_vless_udp_wire_commands",
-    );
+async fn only_tcp_preserves_vless_udp_wire_commands() {
     use vole::session::{Datagram, DatagramSession};
     tokio::time::timeout(Duration::from_secs(3), async {
         for protocol in ["h2mux", "smux", "yamux"] {
-            for (codec, command) in [("xudp", 3), ("none", 2), ("packetaddr", 2)] {
+            // `none` normalizes to XUDP; neither encoding uses sing-mux TCP.
+            for (codec, command) in [("xudp", 3), ("none", 3), ("packetaddr", 2)] {
                 let raw = serde_json::json!({"mixed-port":1080,"proxies":[{"name":"edge","type":"vless","server":"example.com","port":443,"uuid":"07070707-0707-0707-0707-070707070707","udp":true,"packet-encoding":codec,"smux":{"enabled":true,"protocol":protocol,"padding":true,"only-tcp":true}}],"rules":["MATCH,edge"]});
                 let config = Config::parse_yaml(raw.to_string().as_bytes()).unwrap();
-                let ProxyProtocol::Vless(config) = &config.proxies[0].protocol else { unreachable!() };
+                let options=config.proxies[0].smux.clone().unwrap();
+    let ProxyProtocol::Vless(config) = &config.proxies[0].protocol else { unreachable!() };
                 let (io, mut peer) = tokio::io::duplex(4096);
-                let node = VlessOutbound::new_with_upstream(config, Arc::new(CapturePeer(Mutex::new(Some(io))))).unwrap();
+                let node = SingMuxConnector::new(Arc::new(VlessOutbound::new_with_upstream(config, Arc::new(CapturePeer(Mutex::new(Some(io))))).unwrap()),options);
                 let mut association = node.open_datagram(
                     DatagramRequest::new(DatagramSession::new(InboundKind::InternalMeasure, "127.0.0.1:1".parse().unwrap())),
                     &EstablishContext::default(),
@@ -414,29 +642,14 @@ async fn only_tcp_preserves_all_three_vless_udp_wire_commands() {
 }
 #[tokio::test]
 async fn h2mux_reuses_physical_vless_and_cancels_only_one_logical_stream() -> io::Result<()> {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "h2mux_reuses_physical_vless_and_cancels_only_one_logical_stream",
-    );
     siblings("h2mux", 2).await
 }
 #[tokio::test]
 async fn yamux_reuses_physical_vless_and_cancels_only_one_logical_stream() -> io::Result<()> {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "yamux_reuses_physical_vless_and_cancels_only_one_logical_stream",
-    );
     siblings("yamux", 1).await
 }
 #[tokio::test]
 async fn smux_reuses_physical_vless_and_cancels_only_one_logical_stream() -> io::Result<()> {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "smux_reuses_physical_vless_and_cancels_only_one_logical_stream",
-    );
     siblings("smux", 0).await
 }
 async fn siblings(protocol: &str, wire: u8) -> io::Result<()> {
@@ -446,6 +659,7 @@ async fn siblings(protocol: &str, wire: u8) -> io::Result<()> {
             tasks: Mutex::new(vec![]),
             udp: false,
             protocol: wire,
+            brutal_exchanges: None,
         });
         let node = outbound(
             peer.clone(),
@@ -476,11 +690,6 @@ async fn siblings(protocol: &str, wire: u8) -> io::Result<()> {
 
 #[tokio::test]
 async fn sing_mux_udp_preserves_addresses_and_cancellation_safe_partial_frames() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "sing_mux_udp_preserves_addresses_and_cancellation_safe_partial_frames",
-    );
     use vole::{
         dispatch::DatagramBudget,
         session::{Datagram, DatagramSession},
@@ -491,6 +700,7 @@ async fn sing_mux_udp_preserves_addresses_and_cancellation_safe_partial_frames()
             tasks: Mutex::new(vec![]),
             udp: true,
             protocol: 2,
+            brutal_exchanges: None,
         });
         let node = outbound(peer.clone(), "max-connections: 1");
         let mut io = node
diff --git a/tests/sing_mux_config.rs b/tests/sing_mux_config.rs
index 842c57d..6b1baad 100644
--- a/tests/sing_mux_config.rs
+++ b/tests/sing_mux_config.rs
@@ -1,4 +1,4 @@
-#![cfg(feature = "outbound-vless")]
+#![cfg(all(feature = "outbound-vless", feature = "sing-mux"))]
 use serde_json::json;
 use vole::config::Config;
 
@@ -18,12 +18,7 @@ fn parse(options: serde_json::Value, vision: bool) -> bool {
 
 #[test]
 fn sing_mux_accepts_three_protocols_and_rejects_invalid_or_ignored_options() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "sing_mux_accepts_three_protocols_and_rejects_invalid_or_ignored_options",
-    );
-    for protocol in ["h2mux", "smux", "yamux"] {
+    for protocol in ["", "h2mux", "smux", "yamux"] {
         for enabled in [false, true] {
             assert!(parse(
                 json!({"enabled":enabled,"protocol":protocol,"padding":true,
@@ -34,6 +29,10 @@ fn sing_mux_accepts_three_protocols_and_rejects_invalid_or_ignored_options() {
     }
     assert!(parse(json!({"enabled":true,"max-streams":3}), false));
     assert!(parse(json!({}), false));
+    assert!(parse(
+        json!({"enabled":true,"max-connections":2,"max-streams":3}),
+        false
+    ));
     assert!(!parse(json!([]), false));
     for field in [
         "enabled",
@@ -49,24 +48,84 @@ fn sing_mux_accepts_three_protocols_and_rejects_invalid_or_ignored_options() {
         }
     }
     for field in ["max-connections", "min-streams", "max-streams"] {
-        for value in [0, 1, 2147483647_u64] {
+        for value in [-1, 0, 1, 2147483647_i64] {
             assert!(parse(json!({field:value}), false));
         }
-        assert!(!parse(json!({field:2147483648_u64}), false));
     }
     for options in [
         json!(null),
         json!({"enabled":null}),
         json!({"protocol":"mux"}),
-        json!({"protocol":""}),
         json!({"padding":1}),
         json!({"only-tcp":null}),
-        json!({"enabled":true,"max-connections":2,"max-streams":3}),
-        json!({"max-streams":-1}),
-        json!({"min-streams":2147483648_u64}),
         json!({"enabled":true,"brutal":true}),
     ] {
         assert!(!parse(options, false));
     }
     assert!(!parse(json!({"enabled":true}), true));
 }
+
+#[cfg(all(
+    feature = "outbound-http",
+    feature = "outbound-socks5",
+    feature = "outbound-trojan",
+    feature = "outbound-vmess",
+    feature = "outbound-shadowsocks",
+    feature = "outbound-anytls",
+    feature = "outbound-hysteria2",
+    feature = "outbound-tuic"
+))]
+#[test]
+fn shared_smux_wraps_all_protocols_and_computes_effective_udp_capability() {
+    for (protocol, fields) in [
+        ("http", json!({})),
+        ("socks5", json!({"udp":false})),
+        ("trojan", json!({"password":"test","udp":false})),
+        (
+            "vmess",
+            json!({"uuid":"07070707-0707-0707-0707-070707070707","udp":false}),
+        ),
+        (
+            "vless",
+            json!({"uuid":"07070707-0707-0707-0707-070707070707","udp":false}),
+        ),
+        ("anytls", json!({"password":"test","udp":false})),
+        (
+            "ss",
+            json!({"cipher":"2022-blake3-aes-128-gcm","password":"BwcHBwcHBwcHBwcHBwcHBw==","udp":false}),
+        ),
+        ("hysteria2", json!({"password":"test"})),
+        (
+            "tuic",
+            json!({"uuid":"07070707-0707-0707-0707-070707070707","password":"test"}),
+        ),
+    ] {
+        let mut node = json!({"name":"edge","type":protocol,"server":"example.com","port":443});
+        node.as_object_mut()
+            .unwrap()
+            .extend(fields.as_object().unwrap().clone());
+        let parse_node = |node: serde_json::Value| {
+            Config::parse_yaml(
+                json!({"mixed-port":1080,"proxies":[node],"rules":["MATCH,edge"]})
+                    .to_string()
+                    .as_bytes(),
+            )
+            .unwrap()
+        };
+        let native_udp = parse_node(node.clone()).proxies[0].udp;
+        for only_tcp in [false, true] {
+            node["smux"] = json!({"enabled":true,"protocol":"","only-tcp":only_tcp,"max-connections":2,"min-streams":3,"max-streams":1});
+            let parsed = parse_node(node.clone());
+            assert_eq!(parsed.proxies[0].udp, !only_tcp || native_udp, "{protocol}");
+            let options = parsed.proxies[0].smux.as_ref().unwrap();
+            assert_eq!(
+                (
+                    options.max_connections,
+                    options.min_streams,
+                    options.max_streams
+                ),
+                (2, 3, 1)
+            );
+        }
+    }
+}
diff --git a/tests/stream_foundations.rs b/tests/stream_foundations.rs
index fc16730..d1e4fbe 100644
--- a/tests/stream_foundations.rs
+++ b/tests/stream_foundations.rs
@@ -2,11 +2,6 @@
 
 #[test]
 fn transport_options_reject_ambiguous_headers_before_io() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-STREAM",
-        "transport_options_reject_ambiguous_headers_before_io",
-    );
     use vole::transport::{HttpObfsOptions, WebSocketEarlyData, WebSocketOptions};
     for name in ["host", "x-custom"] {
         let mut headers = http::HeaderMap::new();
@@ -15,7 +10,7 @@ fn transport_options_reject_ambiguous_headers_before_io() {
         assert!(WebSocketOptions::new("ws://example.com/", headers.clone(), None).is_err());
         assert!(HttpObfsOptions::new(http::Method::GET, "http://example.com/", headers).is_err());
     }
-    for maximum in [0, 2049] {
+    for maximum in [0] {
         assert!(
             WebSocketOptions::new(
                 "ws://example.com/",
@@ -49,11 +44,6 @@ fn transport_options_reject_ambiguous_headers_before_io() {
 
 #[tokio::test]
 async fn http_first_header_preserves_prefix_raw_continuation_and_half_close_tail() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-STREAM",
-        "http_first_header_preserves_prefix_raw_continuation_and_half_close_tail",
-    );
     timeout(Duration::from_secs(3), async {
         let (client, mut peer) = tokio::io::duplex(128);
         let peer = tokio::spawn(async move {
@@ -111,11 +101,6 @@ async fn http_first_header_preserves_prefix_raw_continuation_and_half_close_tail
 
 #[tokio::test]
 async fn legacy_h2_keeps_unframed_bytes_server_first_and_owned_whole_close() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-STREAM",
-        "legacy_h2_keeps_unframed_bytes_server_first_and_owned_whole_close",
-    );
     timeout(Duration::from_secs(3), async {
         let (client, peer) = tokio::io::duplex(128);
         let peer = tokio::spawn(async move {
@@ -178,11 +163,6 @@ async fn legacy_h2_keeps_unframed_bytes_server_first_and_owned_whole_close() {
 
 #[tokio::test]
 async fn websocket_rejects_invalid_upgrade_responses_and_bounded_header_overflows() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-STREAM",
-        "websocket_rejects_invalid_upgrade_responses_and_bounded_header_overflows",
-    );
     for change in [
         "version",
         "accept",
@@ -253,17 +233,12 @@ async fn websocket_rejects_invalid_upgrade_responses_and_bounded_header_overflow
 // The official handshake callback fixes its error type to Response<Option<String>>.
 #[allow(clippy::result_large_err)]
 async fn websocket_early_data_and_remaining_frames_keep_the_original_byte_order() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-STREAM",
-        "websocket_early_data_and_remaining_frames_keep_the_original_byte_order",
-    );
     use base64::{Engine as _, engine::general_purpose::URL_SAFE_NO_PAD};
     use vole::transport::{WebSocketEarlyData, WebSocketOptions, connect_websocket};
-    for maximum in [1, 2048] {
+    for maximum in [1, 2048, 4096] {
         timeout(Duration::from_secs(3), async {
             let (client, peer) = tokio::io::duplex(128);
-            let input: Vec<u8> = (0..3000).map(|value| (value % 251) as u8).collect();
+            let input: Vec<u8> = (0..6000).map(|value| (value % 251) as u8).collect();
             let expected = input.clone();
             let peer = tokio::spawn(async move {
                 let observed = Arc::new(std::sync::Mutex::new(Vec::new()));
@@ -286,7 +261,7 @@ async fn websocket_early_data_and_remaining_frames_keep_the_original_byte_order(
                 .unwrap();
                 let mut received = observed.lock().unwrap().clone();
                 assert_eq!(received.len(), maximum);
-                while received.len() < 3000 {
+                while received.len() < 6000 {
                     if let Message::Binary(data) = ws.next().await.unwrap().unwrap() {
                         received.extend_from_slice(&data);
                     }
@@ -352,8 +327,10 @@ async fn stalled_handshake(kind: &str, raw: Observed, deadline: Instant) -> io::
                 "http://fixture.invalid/",
                 Default::default(),
             )?;
+            // This fixture tests incomplete request submission, not a valid
+            // one-way upload whose first HTTP response legitimately arrives late.
             let mut stream =
-                vole::transport::http_obfs(Box::new(raw), &options, &[], deadline).await?;
+                vole::transport::http_obfs(Box::new(raw), &options, &[0; 4096], deadline).await?;
             stream.read_u8().await?;
         }
         _ => unreachable!(),
@@ -363,11 +340,6 @@ async fn stalled_handshake(kind: &str, raw: Observed, deadline: Instant) -> io::
 
 #[tokio::test]
 async fn setup_deadline_releases_supplied_io_in_stream_adapters() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-STREAM",
-        "setup_deadline_releases_supplied_io_in_stream_adapters",
-    );
     for kind in ["ws", "grpc", "h2", "http"] {
         let (outgoing, mut incoming) = tokio::io::duplex(128);
         let dropped = Arc::new(AtomicBool::new(false));
@@ -376,7 +348,13 @@ async fn setup_deadline_releases_supplied_io_in_stream_adapters() {
             shutdown: Arc::new(AtomicBool::new(false)),
             dropped: dropped.clone(),
         };
+        let (release, released) = tokio::sync::oneshot::channel();
         let peer = tokio::spawn(async move {
+            if kind == "http" {
+                // Hold the bounded pipe full until setup expires, then drain
+                // naturally to EOF so deadline ownership remains observable.
+                released.await.unwrap();
+            }
             let mut sink = Vec::new();
             incoming.read_to_end(&mut sink).await.unwrap();
             assert!(sink.len() < 4096);
@@ -387,6 +365,7 @@ async fn setup_deadline_releases_supplied_io_in_stream_adapters() {
         )
         .await
         .unwrap();
+        let _ = release.send(());
         assert_eq!(
             result.unwrap_err().kind(),
             io::ErrorKind::TimedOut,
@@ -509,11 +488,6 @@ async fn http2_lazy_response_obeys_setup_deadline_but_established_reads_do_not()
 
 #[tokio::test]
 async fn cancelled_setup_releases_supplied_io_without_a_detached_task() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-STREAM",
-        "cancelled_setup_releases_supplied_io_without_a_detached_task",
-    );
     for kind in ["ws", "grpc", "h2", "http"] {
         let (outgoing, mut incoming) = tokio::io::duplex(128);
         let dropped = Arc::new(AtomicBool::new(false));
@@ -544,11 +518,6 @@ async fn cancelled_setup_releases_supplied_io_without_a_detached_task() {
 
 #[tokio::test]
 async fn ws_rejects_oversized_and_truncated_frames_instead_of_reporting_eof() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-STREAM",
-        "ws_rejects_oversized_and_truncated_frames_instead_of_reporting_eof",
-    );
     for frame in [
         vec![0x82, 0x7f, 0, 0, 0, 0, 0, 1, 0, 1],
         vec![0x82, 3, b'x'],
@@ -583,11 +552,6 @@ async fn ws_rejects_oversized_and_truncated_frames_instead_of_reporting_eof() {
 
 #[tokio::test]
 async fn ws_accepts_mihomo_clean_underlay_eof_only_at_complete_message_boundaries() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-STREAM",
-        "ws_accepts_mihomo_clean_underlay_eof_only_at_complete_message_boundaries",
-    );
     for frame in [
         b"\x82\x04tail".as_slice(),
         b"\x02\x02ta\x80\x02il".as_slice(),
@@ -617,11 +581,6 @@ async fn ws_accepts_mihomo_clean_underlay_eof_only_at_complete_message_boundarie
 
 #[tokio::test]
 async fn dropping_an_established_ws_releases_its_only_io_owner() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-STREAM",
-        "dropping_an_established_ws_releases_its_only_io_owner",
-    );
     let (outgoing, incoming) = tokio::io::duplex(128);
     let dropped = Arc::new(AtomicBool::new(false));
     let raw = Observed {
@@ -655,16 +614,11 @@ async fn dropping_an_established_ws_releases_its_only_io_owner() {
 
 #[tokio::test]
 async fn grpc_rejects_oversized_truncated_and_invalid_records() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-STREAM",
-        "grpc_rejects_oversized_truncated_and_invalid_records",
-    );
-    for wire in [
-        b"\x00\x00\x10\x00\x00".to_vec(),
-        b"\x00\x00\x00\x00\x06\x0a\x04x".to_vec(),
-        b"\x01\x00\x00\x00\x02\x0a\x00".to_vec(),
-        b"\x00\x00\x00\x00\x02\x0b\x00".to_vec(),
+    for (wire, prefix) in [
+        (b"\x00\x00\x10\x00\x00".to_vec(), &b""[..]),
+        (b"\x00\x00\x00\x00\x06\x0a\x04x".to_vec(), &b"x"[..]),
+        (b"\x01\x00\x00\x00\x02\x0a\x00".to_vec(), &b""[..]),
+        (b"\x00\x00\x00\x00\x02\x0b\x00".to_vec(), &b""[..]),
     ] {
         let (outgoing, incoming) = tokio::io::duplex(128);
         let peer = tokio::spawn(async move {
@@ -689,14 +643,16 @@ async fn grpc_rejects_oversized_truncated_and_invalid_records() {
         )
         .await
         .unwrap();
+        let mut received = Vec::new();
         assert_eq!(
-            timeout(Duration::from_secs(1), stream.read_u8())
+            timeout(Duration::from_secs(1), stream.read_to_end(&mut received))
                 .await
                 .unwrap()
                 .unwrap_err()
                 .kind(),
             io::ErrorKind::InvalidData
         );
+        assert_eq!(received, prefix);
         drop(stream);
         owner.stop().await.unwrap();
         timeout(Duration::from_secs(1), peer)
@@ -708,11 +664,6 @@ async fn grpc_rejects_oversized_truncated_and_invalid_records() {
 
 #[tokio::test]
 async fn grpc_large_writes_obey_small_http2_windows_and_keep_byte_integrity() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-STREAM",
-        "grpc_large_writes_obey_small_http2_windows_and_keep_byte_integrity",
-    );
     let (outgoing, incoming) = tokio::io::duplex(128);
     let expected: Vec<_> = (0..65536).map(|n| (n % 251) as u8).collect();
     let peer = tokio::spawn(async move {
@@ -788,11 +739,6 @@ async fn grpc_large_writes_obey_small_http2_windows_and_keep_byte_integrity() {
 
 #[tokio::test]
 async fn ws_partial_writes_empty_frames_ping_and_half_close_preserve_every_byte() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-STREAM",
-        "ws_partial_writes_empty_frames_ping_and_half_close_preserve_every_byte",
-    );
     let (outgoing, incoming) = tokio::io::duplex(128);
     let expected: Vec<_> = (0..65536).map(|n| (n % 251) as u8).collect();
     let request = expected.clone();
@@ -897,11 +843,6 @@ impl AsyncWrite for Observed {
 
 #[tokio::test]
 async fn grpc_handles_response_after_upload_fragmented_records_and_owned_stop() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-STREAM",
-        "grpc_handles_response_after_upload_fragmented_records_and_owned_stop",
-    );
     let (outgoing, incoming) = tokio::io::duplex(128);
     let dropped = Arc::new(AtomicBool::new(false));
     let raw = Observed {
@@ -992,11 +933,6 @@ use tokio_tungstenite::tungstenite::Message;
 
 #[tokio::test]
 async fn websocket_supplied_io_preserves_server_first_and_partial_writes() {
-    #[cfg(feature = "interop-test")]
-    let mut _case = vole::resources::case_events::Case::new(
-        "FOUNDATIONS-STREAM",
-        "websocket_supplied_io_preserves_server_first_and_partial_writes",
-    );
     let (client, peer) = tokio::io::duplex(128);
     let task = tokio::spawn(async move {
         let mut ws = tokio_tungstenite::accept_async(peer).await.unwrap();
diff --git a/tests/support/memory_quic.rs b/tests/support/memory_quic.rs
index b170fe7..4bd66f3 100644
--- a/tests/support/memory_quic.rs
+++ b/tests/support/memory_quic.rs
@@ -22,9 +22,26 @@ pub struct MemoryPackets {
 }
 #[async_trait]
 impl DatagramTransport for MemoryPackets {
+    fn supports_shared_destinations(&self) -> bool {
+        false
+    }
+
     fn payload_budget(&self, _: &Destination) -> DatagramBudget {
         DatagramBudget::new(1400, 1400)
     }
+    fn send_owned(
+        &mut self,
+        packet: Datagram,
+    ) -> Result<vole::dispatch::OwnedDatagramSend, Datagram> {
+        assert_eq!(packet.remote, self.remote.into());
+        let sender = self.send.clone();
+        Ok(Box::pin(async move {
+            sender
+                .send(packet.payload)
+                .await
+                .map_err(|_| DispatchError::NotAllowed)
+        }))
+    }
     async fn send(&mut self, packet: Datagram) -> Result<(), DispatchError> {
         assert_eq!(packet.remote, self.remote.into());
         self.send
diff --git a/tests/trojan.rs b/tests/trojan.rs
index f05f3aa..a1225e7 100644
--- a/tests/trojan.rs
+++ b/tests/trojan.rs
@@ -7,11 +7,6 @@ use vole::{
 
 #[test]
 fn request_matches_the_official_sha224_and_socks_address_wire_format() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "TROJAN-CODEC",
-        "request_matches_the_official_sha224_and_socks_address_wire_format",
-    );
     // SHA-224 independently checked with OpenSSL, not the production codec.
     let auth = TrojanAuth::new("password").unwrap();
     let destination = Destination::domain("example.com", 443).unwrap();
@@ -24,11 +19,6 @@ fn request_matches_the_official_sha224_and_socks_address_wire_format() {
 
 #[test]
 fn authentication_and_requests_are_strict_and_never_debug_credentials() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "TROJAN-CODEC",
-        "authentication_and_requests_are_strict_and_never_debug_credentials",
-    );
     assert!(TrojanAuth::new("").is_err());
     let auth = TrojanAuth::new(" password ").unwrap();
     let plain = TrojanAuth::new("password").unwrap();
@@ -55,11 +45,6 @@ fn authentication_and_requests_are_strict_and_never_debug_credentials() {
 
 #[tokio::test]
 async fn invalid_truncated_and_oversized_frames_fail_closed_without_payload_leaks() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "TROJAN-CODEC",
-        "invalid_truncated_and_oversized_frames_fail_closed_without_payload_leaks",
-    );
     use tokio::io::AsyncWriteExt;
     use vole::{
         dispatch::{DatagramBudget, DatagramTransport},
@@ -87,11 +72,6 @@ async fn invalid_truncated_and_oversized_frames_fail_closed_without_payload_leak
 
 #[tokio::test]
 async fn datagram_limits_preserve_messages_and_drain_over_budget_responses() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "TROJAN-CODEC",
-        "datagram_limits_preserve_messages_and_drain_over_budget_responses",
-    );
     use bytes::Bytes;
     use tokio::io::{AsyncReadExt, AsyncWriteExt};
     use vole::{
@@ -140,11 +120,6 @@ async fn datagram_limits_preserve_messages_and_drain_over_budget_responses() {
 
 #[tokio::test]
 async fn datagram_sends_one_frame_and_receives_fragmented_consecutive_frames() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "TROJAN-CODEC",
-        "datagram_sends_one_frame_and_receives_fragmented_consecutive_frames",
-    );
     use bytes::Bytes;
     use tokio::io::{AsyncReadExt, AsyncWriteExt};
     use vole::{
@@ -185,11 +160,6 @@ async fn datagram_sends_one_frame_and_receives_fragmented_consecutive_frames() {
 
 #[tokio::test]
 async fn cancelled_receive_preserves_partial_frames_and_does_not_block_send() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "TROJAN-CODEC",
-        "cancelled_receive_preserves_partial_frames_and_does_not_block_send",
-    );
     use bytes::Bytes;
     use tokio::io::{AsyncReadExt, AsyncWriteExt};
     use vole::{
@@ -229,11 +199,6 @@ async fn cancelled_receive_preserves_partial_frames_and_does_not_block_send() {
 
 #[tokio::test]
 async fn cancelled_partial_send_poison_closes_without_replaying_or_waiting() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "TROJAN-CODEC",
-        "cancelled_partial_send_poison_closes_without_replaying_or_waiting",
-    );
     use bytes::Bytes;
     use tokio::io::AsyncReadExt;
     use vole::{
@@ -263,3 +228,76 @@ async fn cancelled_partial_send_poison_closes_without_replaying_or_waiting() {
     transport.close().await.unwrap();
     transport.close().await.unwrap();
 }
+
+#[tokio::test]
+async fn receive_future_keeps_packet_scratch_out_of_its_dynamic_frame() {
+    use std::{
+        future::poll_fn,
+        io,
+        pin::Pin,
+        sync::{
+            Arc,
+            atomic::{AtomicUsize, Ordering},
+        },
+        task::{Context, Poll},
+    };
+    use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+    use vole::{
+        dispatch::{DatagramBudget, DatagramTransport},
+        outbound::trojan::TrojanDatagram,
+    };
+
+    struct PendingRead {
+        capacity: Arc<AtomicUsize>,
+    }
+    impl AsyncRead for PendingRead {
+        fn poll_read(
+            self: Pin<&mut Self>,
+            _: &mut Context<'_>,
+            output: &mut ReadBuf<'_>,
+        ) -> Poll<io::Result<()>> {
+            self.capacity.store(output.remaining(), Ordering::Relaxed);
+            Poll::Pending
+        }
+    }
+    impl AsyncWrite for PendingRead {
+        fn poll_write(
+            self: Pin<&mut Self>,
+            _: &mut Context<'_>,
+            input: &[u8],
+        ) -> Poll<io::Result<usize>> {
+            Poll::Ready(Ok(input.len()))
+        }
+        fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Poll::Ready(Ok(()))
+        }
+        fn poll_shutdown(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Poll::Ready(Ok(()))
+        }
+    }
+
+    let capacity = Arc::new(AtomicUsize::new(0));
+    let mut transport = TrojanDatagram::new(
+        Box::new(PendingRead {
+            capacity: capacity.clone(),
+        }),
+        DatagramBudget::new(8192, 8192),
+    );
+    let mut receive = transport.receive();
+    // Query the concrete async_trait future through its dynamic vtable, not
+    // the size of the Box/Pin pointer. The resource threshold is not a wire bug.
+    let frame_bytes = std::mem::size_of_val(receive.as_ref().get_ref());
+    poll_fn(|cx| {
+        assert!(receive.as_mut().poll(cx).is_pending());
+        Poll::Ready(())
+    })
+    .await;
+    drop(receive);
+    transport.close().await.unwrap();
+    assert!(transport.receive().await.is_err());
+    assert_eq!(capacity.load(Ordering::Relaxed), 2048);
+    assert!(
+        frame_bytes < 2048,
+        "TROJAN_RECEIVE_FUTURE_SCRATCH_FOOTPRINT: {frame_bytes}"
+    );
+}
diff --git a/tests/trojan_config.rs b/tests/trojan_config.rs
index c537224..3156db7 100644
--- a/tests/trojan_config.rs
+++ b/tests/trojan_config.rs
@@ -13,26 +13,18 @@ fn document(extra: Value) -> Vec<u8> {
 
 #[test]
 fn trojan_tcp_configuration_and_node_graph_accept_the_approved_fields() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "TROJAN-CFG",
-        "trojan_tcp_configuration_and_node_graph_accept_the_approved_fields",
-    );
     let yaml = b"mixed-port: 1080\nproxies:\n  - name: edge\n    type: trojan\n    server: example.com\n    port: 443\n    password: ' password '\n    udp: true\n    sni: tls.example.com\n    alpn: [h2, http/1.1]\n    skip-cert-verify: false\n    fingerprint: '0000000000000000000000000000000000000000000000000000000000000000'\n    dialer-proxy: upstream\nproxy-groups:\n  - name: upstream\n    type: select\n    proxies: [DIRECT, REJECT]\nrules: ['MATCH,edge']\n";
     let config = Config::parse_yaml(yaml).expect("TROJAN Trojan TCP configuration");
-    assert_eq!(config.proxies[0].address(), "example.com");
-    assert_eq!(config.proxies[0].port(), 443);
+    assert_eq!(
+        config.proxies[0].server_endpoint(),
+        Some(("example.com", 443))
+    );
     assert!(config.proxies[0].udp);
     assert!(!format!("{config:?}").contains(" password "));
 }
 
 #[test]
 fn trojan_tcp_defaults_preserve_credentials_and_address_policy() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "TROJAN-CFG",
-        "trojan_tcp_defaults_preserve_credentials_and_address_policy",
-    );
     let parsed = Config::parse_yaml(&document(json!({}))).unwrap();
     let ProxyProtocol::Trojan(node) = &parsed.proxies[0].protocol else {
         panic!("wrong protocol")
@@ -40,9 +32,12 @@ fn trojan_tcp_defaults_preserve_credentials_and_address_policy() {
     assert_eq!(node.password, " 密码 ");
     assert_eq!(node.server_name, "localhost");
     assert!(!parsed.proxies[0].udp);
-    assert!(node.tls.alpn.is_empty());
-    assert!(!node.tls.skip_cert_verify);
-    assert_eq!(node.tls.fingerprint, None);
+    assert!(node.security.as_tls().unwrap().alpn.is_empty());
+    assert!(!node.security.as_tls().unwrap().certificate.skip_cert_verify);
+    assert_eq!(
+        node.security.as_tls().unwrap().certificate.fingerprint,
+        None
+    );
     for server in ["127.0.0.1", "::1", "example.com"] {
         assert!(Config::parse_yaml(&document(json!({"server":server, "network":"tcp"}))).is_ok());
     }
@@ -50,18 +45,19 @@ fn trojan_tcp_defaults_preserve_credentials_and_address_policy() {
     let ProxyProtocol::Trojan(node) = &config.proxies[0].protocol else {
         unreachable!()
     };
-    assert_eq!(node.tls.alpn, [b"second".to_vec(), b"first".to_vec()]);
-    assert!(node.tls.skip_cert_verify);
-    assert_eq!(node.tls.fingerprint, Some([0xab; 32]));
+    assert_eq!(
+        node.security.as_tls().unwrap().alpn,
+        [b"second".to_vec(), b"first".to_vec()]
+    );
+    assert!(node.security.as_tls().unwrap().certificate.skip_cert_verify);
+    assert_eq!(
+        node.security.as_tls().unwrap().certificate.fingerprint,
+        Some([0xab; 32])
+    );
 }
 
 #[test]
 fn trojan_invalid_configuration_is_rejected_without_exposing_credentials() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "TROJAN-CFG",
-        "trojan_invalid_configuration_is_rejected_without_exposing_credentials",
-    );
     for extra in [
         json!({"name":null}),
         json!({"name":3}),
@@ -81,7 +77,6 @@ fn trojan_invalid_configuration_is_rejected_without_exposing_credentials() {
         json!({"server":null}),
         json!({"network":"invalid"}),
         json!({"network":null}),
-        json!({"sni":""}),
         json!({"sni":"https://localhost"}),
         json!({"sni":null}),
         json!({"alpn":null}),
@@ -129,17 +124,16 @@ fn trojan_invalid_configuration_is_rejected_without_exposing_credentials() {
 
 #[test]
 fn trojan_ws_and_grpc_configuration_applies_transport_specific_defaults() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "TROJAN-CFG",
-        "trojan_ws_and_grpc_configuration_applies_transport_specific_defaults",
-    );
     let config = Config::parse_yaml(&document(json!({"network":"ws"}))).unwrap();
     let ProxyProtocol::Trojan(node) = &config.proxies[0].protocol else {
         unreachable!()
     };
-    assert_eq!(node.tls.alpn, [b"http/1.1".to_vec()]);
+    assert_eq!(node.security.as_tls().unwrap().alpn, [b"http/1.1".to_vec()]);
     assert_eq!(node.server_name, "localhost");
+    let vole::config::TrojanTransport::WebSocket { uri, .. } = &node.transport else {
+        unreachable!()
+    };
+    assert_eq!(uri, "wss://localhost/");
     let config = Config::parse_yaml(&document(json!({"network":"ws","ws-opts":{"path":"/edge?q=1","headers":{"Host":"cover.example:443","X-Fixture":"yes"},"max-early-data":2048}}))).unwrap();
     let ProxyProtocol::Trojan(node) = &config.proxies[0].protocol else {
         unreachable!()
@@ -155,7 +149,11 @@ fn trojan_ws_and_grpc_configuration_applies_transport_specific_defaults() {
     let ProxyProtocol::Trojan(node) = &config.proxies[0].protocol else {
         unreachable!()
     };
-    assert_eq!(node.tls.alpn, [b"h2".to_vec()]);
+    assert_eq!(node.security.as_tls().unwrap().alpn, [b"h2".to_vec()]);
+    let vole::config::TrojanTransport::Grpc { uri, .. } = &node.transport else {
+        unreachable!()
+    };
+    assert_eq!(uri, "https://localhost/edge/Tun");
     for service in ["Edge", "/custom/Tun"] {
         assert!(
             Config::parse_yaml(&document(
@@ -167,20 +165,76 @@ fn trojan_ws_and_grpc_configuration_applies_transport_specific_defaults() {
 }
 
 #[test]
-fn trojan_transport_boundaries_fail_before_runtime_io() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "TROJAN-CFG",
-        "trojan_transport_boundaries_fail_before_runtime_io",
+fn trojan_empty_defaults_and_grpc_authority_match_the_reference() {
+    use vole::config::TrojanTransport;
+    let config = Config::parse_yaml(&document(json!({"network":"","sni":""}))).unwrap();
+    let ProxyProtocol::Trojan(node) = &config.proxies[0].protocol else {
+        unreachable!()
+    };
+    assert!(matches!(node.transport, TrojanTransport::Tcp));
+    assert_eq!(node.server_name, "localhost");
+    for (path, expected) in [
+        ("", "wss://localhost/"),
+        ("/bad#fragment", "wss://localhost/bad"),
+    ] {
+        let config =
+            Config::parse_yaml(&document(json!({"network":"ws","ws-opts":{"path":path}}))).unwrap();
+        let ProxyProtocol::Trojan(node) = &config.proxies[0].protocol else {
+            unreachable!()
+        };
+        let TrojanTransport::WebSocket { uri, .. } = &node.transport else {
+            unreachable!()
+        };
+        assert_eq!(uri, expected);
+    }
+    for (server, sni, authority) in [
+        ("127.0.0.1", "", "127.0.0.1"),
+        ("::1", "", "[::1]"),
+        ("127.0.0.1", "cover.invalid", "cover.invalid"),
+        ("127.0.0.1", "2001:db8::1", "[2001:db8::1]"),
+    ] {
+        let config = Config::parse_yaml(&document(json!({
+            "server":server, "sni":sni, "network":"grpc",
+            "name-cert-verify":"verify.invalid", "grpc-opts":{"grpc-service-name":"edge"}
+        })))
+        .unwrap();
+        let ProxyProtocol::Trojan(node) = &config.proxies[0].protocol else {
+            unreachable!()
+        };
+        let TrojanTransport::Grpc { uri, .. } = &node.transport else {
+            unreachable!()
+        };
+        assert_eq!(uri, &format!("https://{authority}/edge/Tun"));
+        assert_eq!(node.server_name, if sni.is_empty() { server } else { sni });
+        assert_eq!((node.address.as_str(), node.port), (server, 443));
+    }
+    let config = Config::parse_yaml(&document(json!({
+        "server":"127.0.0.1", "port":8443, "sni":"cover.invalid", "network":"ws",
+        "ws-opts":{"headers":{"Host":"request.invalid:7443"}}
+    })))
+    .unwrap();
+    let ProxyProtocol::Trojan(node) = &config.proxies[0].protocol else {
+        unreachable!()
+    };
+    let TrojanTransport::WebSocket { uri, headers, .. } = &node.transport else {
+        unreachable!()
+    };
+    assert_eq!(uri, "wss://cover.invalid/");
+    assert_eq!(
+        headers.get("Host").map(String::as_str),
+        Some("request.invalid:7443")
     );
+    assert_eq!(node.server_name, "cover.invalid");
+    assert_eq!((node.address.as_str(), node.port), ("127.0.0.1", 8443));
+}
+
+#[test]
+fn trojan_transport_boundaries_fail_before_runtime_io() {
     for fields in [
         json!({"ws-opts":null}),
         json!({"grpc-opts":null}),
-        json!({"network":"grpc"}),
-        json!({"network":"grpc","grpc-opts":{"grpc-service-name":""}}),
         json!({"network":"grpc","grpc-opts":{"grpc-service-name":"edge?query=1"}}),
         json!({"network":"grpc","grpc-opts":{"grpc-service-name":null}}),
-        json!({"network":"grpc","grpc-opts":{"grpc-service-name":"edge","max-connections":1}}),
         json!({"network":"ws","grpc-opts":{"grpc-service-name":"edge"}}),
         json!({"network":"grpc","ws-opts":{},"grpc-opts":{"grpc-service-name":"edge"}}),
         json!({"network":"ws","alpn":[]}),
@@ -196,7 +250,6 @@ fn trojan_transport_boundaries_fail_before_runtime_io() {
         json!({"path":"relative"}),
         json!({"path":null}),
         json!({"path":"/bad\r\nheader"}),
-        json!({"path":"/bad#fragment"}),
         json!({"path":"/".repeat(16385)}),
         json!({"headers":null}),
         json!({"headers":{"Host":"user:secret@example.com"}}),
@@ -208,7 +261,7 @@ fn trojan_transport_boundaries_fail_before_runtime_io() {
         json!({"headers":{"Sec-WebSocket-Key":"override"}}),
         json!({"headers":{"Sec-WebSocket-Protocol":"override"}}),
         json!({"headers":{"Content-Length":"1"}}),
-        json!({"max-early-data":2049}),
+        json!({"max-early-data":65536}),
         json!({"max-early-data":-1}),
         json!({"max-early-data":null}),
         json!({"early-data-header-name":"x-ed"}),
@@ -224,7 +277,7 @@ fn trojan_transport_boundaries_fail_before_runtime_io() {
             "accepted WS options {opts}"
         );
     }
-    for max in [0, 1, 2048] {
+    for max in [0, 1, 2048, 2049] {
         for header in [None, Some("x-vole-ed"), Some("")] {
             if max == 0 && header.is_some() {
                 continue;
diff --git a/tests/tuic_config.rs b/tests/tuic_config.rs
index 3e73914..418ace5 100644
--- a/tests/tuic_config.rs
+++ b/tests/tuic_config.rs
@@ -15,27 +15,34 @@ fn parse(node: Value) -> vole::Result<Config> {
 }
 
 #[test]
-fn explicit_v5_identity_accepts_empty_password_without_enabling_business_udp() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new("TUIC-CFG", "identity");
+fn v5_identity_defaults_password_and_keeps_business_udp_enabled() {
     if !cfg!(feature = "outbound-tuic") {
         assert!(parse(node()).is_err());
         return;
     }
     let c = parse(node()).unwrap();
-    assert!(!c.proxies[0].udp);
-    assert_eq!(c.proxies[0].address(), "peer.invalid");
-    for field in ["uuid", "password"] {
+    assert!(c.proxies[0].udp);
+    assert_eq!(c.proxies[0].server_endpoint(), Some(("peer.invalid", 443)));
+    for enabled in [false, true] {
         let mut n = node();
-        n.as_object_mut().unwrap().remove(field);
-        assert!(parse(n).is_err());
+        n["udp"] = json!(enabled);
+        assert!(parse(n).unwrap().proxies[0].udp);
     }
+    let mut n = node();
+    n.as_object_mut().unwrap().remove("password");
+    let c = parse(n).unwrap();
+    let vole::config::ProxyProtocol::Tuic(t) = &c.proxies[0].protocol else {
+        panic!("protocol");
+    };
+    assert_eq!(t.password, "");
+    assert!(c.proxies[0].udp);
+    let mut n = node();
+    n.as_object_mut().unwrap().remove("uuid");
+    assert!(parse(n).is_err());
 }
 
 #[test]
 fn malformed_tuic_values_do_not_leak_input_in_errors() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new("TUIC-CFG", "redaction");
     for field in ["uuid", "port", "alpn", "congestion-controller"] {
         let mut n = node();
         n[field] = json!("synthetic-private-marker");
@@ -47,8 +54,6 @@ fn malformed_tuic_values_do_not_leak_input_in_errors() {
 #[cfg(feature = "outbound-tuic")]
 #[test]
 fn v5_business_udp_accepts_exactly_native_or_quic() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new("TUIC-CFG", "udp");
     let mut n = node();
     n["udp"] = json!(true);
     assert!(parse(n.clone()).is_ok());
@@ -73,8 +78,6 @@ fn v5_business_udp_accepts_exactly_native_or_quic() {
 #[test]
 fn strict_v5_tls_and_identity_bounds_preserve_values() {
     use vole::config::{ProxyProtocol, TuicCongestion};
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new("TUIC-CFG", "bounds");
     let extract = |n| {
         let c = parse(n).unwrap();
         let ProxyProtocol::Tuic(t) = c.proxies.into_iter().next().unwrap().protocol else {
@@ -87,6 +90,14 @@ fn strict_v5_tls_and_identity_bounds_preserve_values() {
     assert_eq!(t.tls.alpn, [b"h3".to_vec()]);
     assert!(t.tls.tls13_only);
     assert_eq!(t.congestion, TuicCongestion::Cubic);
+    let mut n = node();
+    n["sni"] = json!("");
+    n["name-cert-verify"] = json!("");
+    n["fingerprint"] = json!("");
+    let t = extract(n);
+    assert_eq!(t.tls.server_name, "peer.invalid");
+    assert_eq!(t.tls.certificate.verification_name, None);
+    assert_eq!(t.tls.certificate.fingerprint, None);
     for password in [String::new(), " 原样\t\0 ".to_string(), "x".repeat(65535)] {
         let mut n = node();
         n["password"] = json!(password);
@@ -129,7 +140,6 @@ fn strict_v5_tls_and_identity_bounds_preserve_values() {
         ("port", json!(0)),
         ("port", json!(65536)),
         ("server", json!("")),
-        ("sni", json!("")),
         ("name-cert-verify", json!("bad\nname")),
         ("alpn", json!([])),
         ("alpn", json!([""])),
@@ -166,3 +176,135 @@ fn strict_v5_tls_and_identity_bounds_preserve_values() {
         assert!(parse(n).is_err(), "{field}");
     }
 }
+
+#[cfg(feature = "outbound-tuic")]
+#[test]
+fn quic_fields_consume_defaults_and_reversed_fixed_windows() {
+    use vole::config::{ProxyProtocol, QuicReceiveWindow};
+    let extract = |n| {
+        let c = parse(n).unwrap();
+        let ProxyProtocol::Tuic(config) = c.proxies.into_iter().next().unwrap().protocol else {
+            panic!("TUIC")
+        };
+        config
+    };
+    let defaults = extract(node());
+    assert_eq!(
+        defaults.stream_window,
+        QuicReceiveWindow {
+            initial: 15 * 1024 * 1024 / 10,
+            maximum: 15 * 1024 * 1024
+        }
+    );
+    assert_eq!(
+        defaults.connection_window,
+        QuicReceiveWindow {
+            initial: 2 * 1024 * 1024,
+            maximum: 64 * 1024 * 1024
+        }
+    );
+    let mut zero = node();
+    zero["recv-window-conn"] = json!(0);
+    zero["recv-window"] = json!(0);
+    let zero = extract(zero);
+    assert_eq!(zero.stream_window, defaults.stream_window);
+    assert_eq!(zero.connection_window, defaults.connection_window);
+    let mut larger = node();
+    larger["recv-window"] = json!(8 * 1024 * 1024);
+    let larger = extract(larger);
+    assert_eq!(larger.stream_window, defaults.stream_window);
+    assert_eq!(
+        larger.connection_window,
+        QuicReceiveWindow {
+            initial: 8 * 1024 * 1024,
+            maximum: 8 * 1024 * 1024
+        }
+    );
+    assert_eq!(defaults.max_open_streams, 89);
+    assert!(!defaults.udp_over_stream);
+    assert_eq!(
+        defaults.heartbeat_interval,
+        std::time::Duration::from_secs(10)
+    );
+    assert_eq!(defaults.max_datagram_frame_size, 1281);
+    assert_eq!(defaults.max_udp_relay_packet_size, 1252);
+    let mut n = node();
+    n["ip"] = json!("192.0.2.1");
+    n["heartbeat-interval"] = json!(12);
+    n["recv-window-conn"] = json!(17);
+    n["recv-window"] = json!(29);
+    n["max-open-streams"] = json!(3);
+    n["max-datagram-frame-size"] = json!(80);
+    n["max-udp-relay-packet-size"] = json!(999);
+    n["disable-mtu-discovery"] = json!(true);
+    n["udp-over-stream"] = json!(true);
+    n["udp-over-stream-version"] = json!(2);
+    let t = extract(n.clone());
+    assert_eq!(t.address, "peer.invalid");
+    assert_eq!(t.tls.server_name, "peer.invalid");
+    assert_eq!(t.ip.as_deref(), Some("192.0.2.1"));
+    assert_eq!(t.heartbeat_interval, std::time::Duration::from_millis(12));
+    assert_eq!(
+        t.stream_window,
+        QuicReceiveWindow {
+            initial: 17,
+            maximum: 17
+        }
+    );
+    assert_eq!(
+        t.connection_window,
+        QuicReceiveWindow {
+            initial: 29,
+            maximum: 29
+        }
+    );
+    assert_eq!(t.max_open_streams, 2);
+    assert_eq!(t.max_datagram_frame_size, 80);
+    assert_eq!(t.max_udp_relay_packet_size, 51);
+    assert!(t.disable_mtu_discovery);
+    assert!(t.udp_over_stream);
+    n["max-datagram-frame-size"] = json!(1);
+    let tiny = extract(n.clone());
+    assert_eq!(tiny.max_datagram_frame_size, 1);
+    assert_eq!(tiny.max_udp_relay_packet_size, 0);
+    n["max-open-streams"] = json!(1);
+    assert_eq!(extract(n.clone()).max_open_streams, 0);
+    n["max-open-streams"] = json!(-1);
+    assert_eq!(extract(n.clone()).max_open_streams, 0);
+    n["max-open-streams"] = json!(i64::MAX);
+    assert_eq!(extract(n.clone()).max_open_streams, i64::MAX as usize - 1);
+}
+
+#[cfg(feature = "outbound-tuic")]
+#[test]
+fn uot_is_opt_in_and_accepts_only_explicit_or_default_v2() {
+    for enabled in [false, true] {
+        let mut n = node();
+        n["udp-over-stream"] = json!(enabled);
+        for version in [None, Some(json!(2))] {
+            if let Some(version) = version {
+                n["udp-over-stream-version"] = version;
+            }
+            let c = parse(n.clone()).unwrap();
+            let vole::config::ProxyProtocol::Tuic(t) = &c.proxies[0].protocol else {
+                panic!("TUIC");
+            };
+            assert_eq!(t.udp_over_stream, enabled);
+        }
+        for bad in [
+            json!(0),
+            json!(1),
+            json!(3),
+            json!(-1),
+            json!(256),
+            json!(2.0),
+            json!("2"),
+            Value::Null,
+            json!(true),
+            json!({}),
+        ] {
+            n["udp-over-stream-version"] = bad;
+            assert!(parse(n.clone()).is_err());
+        }
+    }
+}
diff --git a/tests/tuic_memory.rs b/tests/tuic_memory.rs
index b78e327..10cc608 100644
--- a/tests/tuic_memory.rs
+++ b/tests/tuic_memory.rs
@@ -16,10 +16,7 @@ use vole::{
         ConnectedStream, DatagramRequest, EstablishContext, OutboundConnector, UpstreamPath,
         tuic::TuicOutbound,
     },
-    resources::{
-        case_events::Case,
-        observation::{ResourceKind, ResourceProbe},
-    },
+    resources::observation::{ResourceKind, ResourceProbe},
     session::{Datagram, DatagramSession, Destination, InboundKind, StreamSession},
 };
 #[path = "support/memory_quic.rs"]
@@ -29,6 +26,10 @@ use memory_quic::{MemoryPackets, MemoryUpstream, PeerSocket};
 struct BudgetPackets(MemoryPackets, u16);
 #[async_trait::async_trait]
 impl DatagramTransport for BudgetPackets {
+    fn supports_shared_destinations(&self) -> bool {
+        false
+    }
+
     fn payload_budget(&self, _: &Destination) -> DatagramBudget {
         DatagramBudget::new(self.1, self.1)
     }
@@ -60,7 +61,19 @@ fn fixture_mode(
     congestion: &str,
     mode: &str,
 ) -> (Arc<TuicOutbound>, quinn::Endpoint) {
-    let (config, packets, endpoint) = fixture_parts(budget, datagrams, credit, congestion, mode);
+    let (mut config, packets, endpoint) =
+        fixture_parts(budget, datagrams, credit, congestion, mode);
+    // These existing pressure/credit fixtures intentionally use small fixed
+    // receive credit; the fixed-window policies behave identically here.
+    config.stream_window = vole::config::QuicReceiveWindow {
+        initial: 256 * 1024,
+        maximum: 256 * 1024,
+    };
+    config.connection_window = vole::config::QuicReceiveWindow {
+        initial: 1024 * 1024,
+        maximum: 1024 * 1024,
+    };
+    config.disable_mtu_discovery = true;
     let outbound = TuicOutbound::new_with_path(
         &config,
         UpstreamPath::proxy(Arc::new(MemoryUpstream(Mutex::new(Some(packets))))),
@@ -133,6 +146,7 @@ fn fixture_parts(
 
 fn request() -> StreamSession {
     StreamSession {
+        metadata: Default::default(),
         inbound: InboundKind::Socks5,
         source: "127.0.0.1:1".parse().unwrap(),
         destination: Destination::domain("x", 80).unwrap(),
@@ -175,7 +189,6 @@ async fn finish(endpoint: quinn::Endpoint, peer: tokio::task::JoinHandle<()>) {
 
 #[tokio::test]
 async fn authenticates_current_session_without_ack_and_preserves_stream_isolation() {
-    let _case = Case::new("TUIC-UNIT", "tcp_owner");
     for (algorithm, expected) in [
         ("cubic", TuicCongestion::Cubic),
         ("new_reno", TuicCongestion::NewReno),
@@ -183,6 +196,7 @@ async fn authenticates_current_session_without_ack_and_preserves_stream_isolatio
     ] {
         let probe = ResourceProbe::default();
         let (outbound, endpoint) = fixture(1200, true, 8, algorithm);
+        assert_eq!(outbound.congestion_observation().await, None);
         let ep = endpoint.clone();
         let peer = tokio::spawn(async move {
             let connection = authenticated(&ep).await;
@@ -246,7 +260,6 @@ async fn authenticates_current_session_without_ack_and_preserves_stream_isolatio
 
 #[tokio::test]
 async fn stream_credit_wait_keeps_original_deadline_and_leaves_sibling_alive() {
-    let _case = Case::new("TUIC-UNIT", "credit_deadline");
     let (outbound, endpoint) = fixture(1400, true, 1, "cubic");
     let ep = endpoint.clone();
     let peer = tokio::spawn(async move {
@@ -281,7 +294,6 @@ async fn stream_credit_wait_keeps_original_deadline_and_leaves_sibling_alive() {
 
 #[tokio::test]
 async fn insufficient_path_budget_and_missing_datagrams_never_fall_back() {
-    let _case = Case::new("TUIC-UNIT", "path_requirements");
     for (budget, datagrams) in [(1199, true), (1400, false)] {
         let (outbound, endpoint) = fixture(budget, datagrams, 8, "cubic");
         let ep = endpoint.clone();
@@ -314,7 +326,6 @@ async fn insufficient_path_budget_and_missing_datagrams_never_fall_back() {
 
 #[tokio::test]
 async fn stalled_quic_handshake_obeys_setup_deadline_and_stop_barrier() {
-    let _case = Case::new("TUIC-UNIT", "handshake_stop");
     for stop in [false, true] {
         // Do not accept the QUIC handshake. It can never reach TUIC auth.
         let (outbound, endpoint) = fixture(1400, true, 8, "cubic");
@@ -339,9 +350,24 @@ async fn stalled_quic_handshake_obeys_setup_deadline_and_stop_barrier() {
     }
 }
 
+fn udp_wire_target(index: usize) -> (Destination, &'static [u8]) {
+    match index % 3 {
+        0 => (Destination::domain("x", 80).unwrap(), b"\0\x01x\0\x50"),
+        1 => (
+            Destination::Ip("198.51.100.7:443".parse().unwrap()),
+            &[1, 198, 51, 100, 7, 1, 187],
+        ),
+        _ => (
+            Destination::Ip("[2001:db8::7]:8443".parse().unwrap()),
+            &[
+                2, 32, 1, 13, 184, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 32, 251,
+            ],
+        ),
+    }
+}
+
 #[tokio::test]
 async fn both_udp_modes_preserve_empty_and_u16_packets_and_dissociate() {
-    let _case = Case::new("TUIC-UNIT", "udp_wire");
     const SIZES: &[usize] = &[0, 1, 1400, 4096, 65535];
     for mode in ["native", "quic"] {
         let (outbound, endpoint) = fixture_mode(1400, true, 8, "cubic", mode);
@@ -367,9 +393,9 @@ async fn both_udp_modes_preserve_empty_and_u16_packets_and_dissociate() {
                     assert_eq!(&raw[..4], &[5, 2, 0, 0]);
                     assert_eq!(u16::from_be_bytes([raw[4], raw[5]]), packet as u16);
                     let start = if raw[7] == 0 {
-                        assert_eq!(&raw[10..14], b"\0\x01x\0");
-                        assert_eq!(raw[14], 80);
-                        15
+                        let (_, address) = udp_wire_target(packet);
+                        assert_eq!(&raw[10..10 + address.len()], address);
+                        10 + address.len()
                     } else {
                         assert_eq!(raw[10], 255);
                         11
@@ -428,6 +454,7 @@ async fn both_udp_modes_preserve_empty_and_u16_packets_and_dissociate() {
                         &EstablishContext::default(),
                     )
                     .await?;
+                assert!(udp.supports_shared_destinations());
                 assert!(
                     udp.send(Datagram {
                         remote: Destination::domain("x", 80).unwrap(),
@@ -445,7 +472,7 @@ async fn both_udp_modes_preserve_empty_and_u16_packets_and_dissociate() {
                 let result = tokio::time::timeout(Duration::from_secs(5), async {
                     for (packet, size) in SIZES.iter().copied().enumerate() {
                         let request = Datagram {
-                            remote: Destination::domain("x", 80).unwrap(),
+                            remote: udp_wire_target(packet).0,
                             payload: vec![packet as u8; size].into(),
                             sniffed_domain: None,
                         };
@@ -472,9 +499,114 @@ async fn both_udp_modes_preserve_empty_and_u16_packets_and_dissociate() {
     }
 }
 
+#[tokio::test(flavor = "current_thread")]
+async fn quic_declared_payload_peeks_only_ready_fin_and_never_waits_for_it() {
+    let mut observed = Vec::new();
+    for finish_before_send in [true, false] {
+        let (outbound, endpoint) = fixture_mode(1400, true, 8, "cubic", "quic");
+        let ep = endpoint.clone();
+        let (reported, report) = tokio::sync::oneshot::channel();
+        let peer = tokio::spawn(async move {
+            let connection = authenticated(&ep).await;
+            // Echo the actual production encoder's Packet, not a test codec.
+            let response = connection
+                .accept_uni()
+                .await
+                .unwrap()
+                .read_to_end(64)
+                .await
+                .unwrap();
+            assert_eq!(&response[response.len() - 1..], b"a");
+            let before = connection.stats().frame_rx.stop_sending;
+            let mut send = connection.open_uni().await.unwrap();
+            let sent = connection.stats().frame_tx.stream;
+            send.write_all(&response).await.unwrap();
+            if finish_before_send {
+                send.finish().unwrap();
+            }
+            // This current-thread task has not let the endpoint driver send
+            // a STREAM frame before the small body and optional FIN are ready.
+            assert_eq!(connection.stats().frame_tx.stream, sent);
+            // A second production Packet is a return-path barrier: the first
+            // payload has already reached its owner before we inspect frames.
+            let barrier = connection
+                .accept_uni()
+                .await
+                .unwrap()
+                .read_to_end(64)
+                .await
+                .unwrap();
+            assert!(barrier.ends_with(b"barrier"));
+            let stopped = if finish_before_send {
+                None
+            } else {
+                // Keep FIN absent until payload delivery and the barrier. The
+                // original Drop must still request cancellation in this case.
+                Some(
+                    tokio::time::timeout(Duration::from_secs(2), send.stopped())
+                        .await
+                        .unwrap()
+                        .unwrap(),
+                )
+            };
+            let stops = connection.stats().frame_rx.stop_sending - before;
+            drop(send);
+            reported.send((stops, stopped)).unwrap();
+            connection.closed().await;
+        });
+        let probe = ResourceProbe::default();
+        let result = probe
+            .scope(async {
+                let mut udp = outbound
+                    .open_datagram(udp_request(), &EstablishContext::default())
+                    .await
+                    .unwrap();
+                udp.send(Datagram {
+                    remote: request().destination,
+                    payload: bytes::Bytes::from_static(b"a"),
+                    sniffed_domain: None,
+                })
+                .await
+                .unwrap();
+                let response = tokio::time::timeout(Duration::from_secs(2), udp.receive())
+                    .await
+                    .expect("complete payload waited for FIN")
+                    .unwrap();
+                assert_eq!(response.remote, request().destination);
+                assert_eq!(response.payload, b"a"[..]);
+                udp.send(Datagram {
+                    remote: request().destination,
+                    payload: bytes::Bytes::from_static(b"barrier"),
+                    sniffed_domain: None,
+                })
+                .await
+                .unwrap();
+                let result = tokio::time::timeout(Duration::from_secs(2), report)
+                    .await
+                    .unwrap()
+                    .unwrap();
+                udp.close().await.unwrap();
+                drop(udp);
+                outbound.shutdown().await;
+                assert!(probe.snapshot().is_idle(), "{:?}", probe.snapshot());
+                result
+            })
+            .await;
+        finish(endpoint, peer).await;
+        observed.push(result);
+    }
+    // Check the candidate's control-frame benefit only after both fixtures
+    // have shut down and joined, including the expected old-code RED run.
+    assert_eq!(observed[0].0, 0, "ready FIN still caused STOP_SENDING");
+    assert!(
+        observed[1].0 > 0,
+        "missing FIN bypassed the original stop path"
+    );
+    assert_eq!(observed[1].1, Some(Some(0_u8.into())));
+}
+
 #[tokio::test]
 async fn unused_association_close_does_not_create_peer_state_or_control_tasks() {
-    let _case = Case::new("TUIC-UNIT", "unused_association");
     let (outbound, endpoint) = fixture(1400, true, 8, "cubic");
     let ep = endpoint.clone();
     let peer = tokio::spawn(async move {
@@ -534,9 +666,145 @@ fn udp_request() -> DatagramRequest {
     ))
 }
 
+#[tokio::test]
+async fn native_source_stripes_hold_64_owners_reuse_source_and_stop_both_paths() {
+    use std::sync::atomic::{AtomicUsize, Ordering};
+    // 65 held business owners fit the old configured threshold and these
+    // peer credits. RED must be actual path count, not blocked stream credit.
+    let (config, first_path, first_ep) = fixture_parts(1400, true, 128, "cubic", "native");
+    let (_, next_path, next_ep) = fixture_parts(1400, true, 128, "cubic", "native");
+    assert!(config.max_open_streams > 65);
+    let paths = Arc::new(Paths(Mutex::new(VecDeque::from([first_path, next_path]))));
+    let outbound =
+        TuicOutbound::new_with_path(&config, UpstreamPath::proxy(paths.clone())).unwrap();
+    let counts = [Arc::new(AtomicUsize::new(0)), Arc::new(AtomicUsize::new(0))];
+    let (done, stop) = tokio::sync::watch::channel(false);
+    let serve = |endpoint: quinn::Endpoint,
+                 count: Arc<AtomicUsize>,
+                 tag: u8,
+                 mut stop: tokio::sync::watch::Receiver<bool>| {
+        tokio::spawn(async move {
+            let connection = tokio::select! {
+                biased;
+                _ = stop.wait_for(|done| *done) => return,
+                connection = authenticated(&endpoint) => connection,
+            };
+            let mut streams = tokio::task::JoinSet::new();
+            loop {
+                tokio::select! {
+                    _ = connection.closed() => break,
+                    _ = stop.wait_for(|done| *done) => break,
+                    stream = connection.accept_bi() => {
+                        let Ok((mut send, mut recv)) = stream else { break; };
+                        assert!(count.fetch_add(1, Ordering::Relaxed) < 65);
+                        streams.spawn(async move {
+                            let mut header = [0; 7];
+                            if recv.read_exact(&mut header).await.is_err() { return; }
+                            assert_eq!(&header, b"\x05\x01\x00\x01x\x00\x50");
+                            let mut byte = [0; 1];
+                            while let Ok(Some(1)) = recv.read(&mut byte).await {
+                                if send.write_all(&[tag, byte[0]]).await.is_err() { break; }
+                            }
+                        });
+                    }
+                }
+            }
+            while let Some(result) = streams.join_next().await {
+                result.unwrap();
+            }
+        })
+    };
+    let first_peer = serve(first_ep.clone(), counts[0].clone(), 0, stop.clone());
+    let next_peer = serve(next_ep.clone(), counts[1].clone(), 1, stop);
+    let probe = ResourceProbe::default();
+    let evidence = probe
+        .scope(async {
+            let mut held = Vec::new();
+            let mut tags = Vec::new();
+            for index in 0..64_u8 {
+                let mut owner = request();
+                owner.source.set_port(10000 + u16::from(index));
+                let mut stream = outbound
+                    .connect_stream(
+                        owner,
+                        &EstablishContext::with_timeout(Duration::from_secs(2)),
+                    )
+                    .await
+                    .unwrap()
+                    .io;
+                stream.write_all(&[index]).await.unwrap();
+                let mut echo = [0; 2];
+                tokio::time::timeout(Duration::from_secs(2), stream.read_exact(&mut echo))
+                    .await
+                    .unwrap()
+                    .unwrap();
+                assert_eq!(echo[1], index);
+                assert!(echo[0] < 2);
+                tags.push(echo[0]);
+                held.push(stream);
+            }
+            let opened_before_reuse = 2 - paths.0.lock().unwrap().len();
+            let mut same_source = request();
+            same_source.source.set_port(10000);
+            let mut reused = outbound
+                .connect_stream(
+                    same_source,
+                    &EstablishContext::with_timeout(Duration::from_secs(2)),
+                )
+                .await
+                .unwrap()
+                .io;
+            reused.write_all(b"r").await.unwrap();
+            let mut echo = [0; 2];
+            tokio::time::timeout(Duration::from_secs(2), reused.read_exact(&mut echo))
+                .await
+                .unwrap()
+                .unwrap();
+            assert_eq!(echo, [tags[0], b'r']);
+            held.push(reused);
+            // Held old and new owners keep their actual peer and byte identity.
+            for index in [0, 63] {
+                held[index].write_all(b"z").await.unwrap();
+                tokio::time::timeout(Duration::from_secs(2), held[index].read_exact(&mut echo))
+                    .await
+                    .unwrap()
+                    .unwrap();
+                assert_eq!(echo, [tags[index], b'z']);
+            }
+            let evidence = (
+                opened_before_reuse,
+                2 - paths.0.lock().unwrap().len(),
+                counts[0].load(Ordering::Relaxed),
+                counts[1].load(Ordering::Relaxed),
+                probe.snapshot().current(ResourceKind::Pool),
+            );
+            outbound.shutdown().await;
+            assert!(held[0].read_u8().await.is_err());
+            assert!(held[64].read_u8().await.is_err());
+            drop(held);
+            assert!(probe.snapshot().is_idle(), "{:?}", probe.snapshot());
+            evidence
+        })
+        .await;
+    let _ = done.send(true); // Release the unused second endpoint in old-code RED.
+    finish(first_ep, first_peer).await;
+    finish(next_ep, next_peer).await;
+    // All owners and both endpoint tasks are clean before the intended RED.
+    assert_eq!(
+        evidence.0, 2,
+        "native default kept all distinct sources on one path"
+    );
+    assert_eq!(
+        evidence.1, 2,
+        "same source opened an additional physical path"
+    );
+    assert!(evidence.2 > 0 && evidence.3 > 0);
+    assert_eq!(evidence.2 + evidence.3, 65);
+    assert_eq!(evidence.4, 2);
+}
+
 #[tokio::test]
 async fn association_id_exhaustion_retires_without_reuse_or_migrating_old_streams() {
-    let _case = Case::new("TUIC-UNIT", "session_retirement");
     let (config, first_path, first_ep) = fixture_parts(1400, true, 8, "cubic", "native");
     let (_, next_path, next_ep) = fixture_parts(1400, true, 8, "cubic", "native");
     let paths = Arc::new(Paths(Mutex::new(VecDeque::from([first_path, next_path]))));
@@ -643,8 +911,19 @@ async fn association_id_exhaustion_retires_without_reuse_or_migrating_old_stream
 
 #[tokio::test]
 async fn quic_partial_control_streams_have_a_credit_bound_and_expire_without_blocking_tcp() {
-    let _case = Case::new("TUIC-UNIT", "partial_control_expiry");
-    let (outbound, endpoint) = fixture_mode(1400, true, 8, "cubic", "quic");
+    let (mut config, udp_path, endpoint) = fixture_parts(1400, true, 8, "cubic", "quic");
+    let (_, tcp_path, tcp_endpoint) = fixture_parts(1400, true, 8, "cubic", "quic");
+    config.stream_window = vole::config::QuicReceiveWindow {
+        initial: 256 * 1024,
+        maximum: 256 * 1024,
+    };
+    config.connection_window = vole::config::QuicReceiveWindow {
+        initial: 1024 * 1024,
+        maximum: 1024 * 1024,
+    };
+    config.disable_mtu_discovery = true;
+    let paths = Arc::new(Paths(Mutex::new(VecDeque::from([udp_path, tcp_path]))));
+    let outbound = TuicOutbound::new_with_path(&config, UpstreamPath::proxy(paths)).unwrap();
     let ep = endpoint.clone();
     let (ready, wait) = tokio::sync::oneshot::channel();
     let peer = tokio::spawn(async move {
@@ -671,11 +950,6 @@ async fn quic_partial_control_streams_have_a_credit_bound_and_expire_without_blo
                 .is_err()
         );
         ready.send(()).unwrap();
-        let (mut send, mut recv) = connection.accept_bi().await.unwrap();
-        let mut request = [0; 8];
-        recv.read_exact(&mut request).await.unwrap();
-        assert_eq!(request[7], b'a');
-        send.write_all(b"a").await.unwrap();
         for stream in &partial {
             assert_eq!(
                 tokio::time::timeout(Duration::from_secs(6), stream.stopped())
@@ -700,6 +974,16 @@ async fn quic_partial_control_streams_have_a_credit_bound_and_expire_without_blo
         available.finish().unwrap();
         connection.closed().await;
     });
+    let tcp_ep = tcp_endpoint.clone();
+    let tcp_peer = tokio::spawn(async move {
+        let connection = authenticated(&tcp_ep).await;
+        let (mut send, mut recv) = connection.accept_bi().await.unwrap();
+        let mut request = [0; 8];
+        recv.read_exact(&mut request).await.unwrap();
+        assert_eq!(request[7], b'a');
+        send.write_all(b"a").await.unwrap();
+        connection.closed().await;
+    });
     let probe = ResourceProbe::default();
     probe
         .scope(async {
@@ -746,12 +1030,26 @@ async fn quic_partial_control_streams_have_a_credit_bound_and_expire_without_blo
         })
         .await;
     finish(endpoint, peer).await;
+    finish(tcp_endpoint, tcp_peer).await;
 }
 
 #[tokio::test]
 async fn cancelled_uni_credit_wait_does_not_replay_or_close_sibling_tcp() {
-    let _case = Case::new("TUIC-UNIT", "udp_credit_cancel");
-    let (outbound, endpoint) = fixture_mode(1400, true, 8, "cubic", "quic");
+    let (mut config, udp_path, endpoint) = fixture_parts(1400, true, 8, "cubic", "quic");
+    let (_, tcp_path, tcp_endpoint) = fixture_parts(1400, true, 8, "cubic", "quic");
+    // Keep the original fixed windows, MTU policy and two unread uni credits.
+    config.stream_window = vole::config::QuicReceiveWindow {
+        initial: 256 * 1024,
+        maximum: 256 * 1024,
+    };
+    config.connection_window = vole::config::QuicReceiveWindow {
+        initial: 1024 * 1024,
+        maximum: 1024 * 1024,
+    };
+    config.disable_mtu_discovery = true;
+    let paths = Arc::new(Paths(Mutex::new(VecDeque::from([udp_path, tcp_path]))));
+    let outbound =
+        TuicOutbound::new_with_path(&config, UpstreamPath::proxy(paths.clone())).unwrap();
     let ep = endpoint.clone();
     let (ready, wait) = tokio::sync::oneshot::channel();
     let peer = tokio::spawn(async move {
@@ -762,13 +1060,18 @@ async fn cancelled_uni_credit_wait_does_not_replay_or_close_sibling_tcp() {
             unread.push(connection.accept_uni().await.unwrap());
         }
         ready.send(()).unwrap();
+        connection.closed().await;
+        drop(unread);
+    });
+    let tcp_ep = tcp_endpoint.clone();
+    let tcp_peer = tokio::spawn(async move {
+        let connection = authenticated(&tcp_ep).await;
         let (mut send, mut recv) = connection.accept_bi().await.unwrap();
         let mut request = [0; 8];
         recv.read_exact(&mut request).await.unwrap();
         assert_eq!(request[7], b'a');
         send.write_all(b"a").await.unwrap();
         connection.closed().await;
-        drop(unread);
     });
     let probe = ResourceProbe::default();
     probe
@@ -810,6 +1113,9 @@ async fn cancelled_uni_credit_wait_does_not_replay_or_close_sibling_tcp() {
                     .unwrap(),
                 b'a'
             );
+            // Both business lanes were established; the cancelled third UDP
+            // send must not redirect TCP to the old UDP peer.
+            assert!(paths.0.lock().unwrap().is_empty());
             let before = tokio::time::Instant::now();
             outbound.shutdown().await;
             assert!(before.elapsed() < Duration::from_secs(2));
@@ -819,6 +1125,7 @@ async fn cancelled_uni_credit_wait_does_not_replay_or_close_sibling_tcp() {
         })
         .await;
     finish(endpoint, peer).await;
+    finish(tcp_endpoint, tcp_peer).await;
 }
 
 #[cfg(unix)]
@@ -836,7 +1143,6 @@ async fn physical_protection_failure_stops_before_udp_or_tcp_fallback() {
             ))
         }
     }
-    let _case = Case::new("TUIC-UNIT", "protect_fail_closed");
     let (config, _, endpoint) = fixture_parts(1400, true, 8, "cubic", "native");
     let reject = Arc::new(Reject(AtomicUsize::new(0)));
     let path = UpstreamPath::direct(
@@ -868,7 +1174,6 @@ async fn physical_protection_failure_stops_before_udp_or_tcp_fallback() {
 
 #[tokio::test]
 async fn heartbeat_and_full_delivery_queue_remain_owned_until_synchronous_stop() {
-    let _case = Case::new("TUIC-UNIT", "heartbeat_full_queue_stop");
     for mode in ["native", "quic"] {
         let (outbound, endpoint) = fixture_mode(1400, true, 8, "cubic", mode);
         let ep = endpoint.clone();
@@ -947,7 +1252,6 @@ async fn heartbeat_and_full_delivery_queue_remain_owned_until_synchronous_stop()
 
 #[tokio::test]
 async fn receive_flow_control_bounds_unread_streams_and_connection_then_stop_releases_them() {
-    let _case = Case::new("TUIC-UNIT", "receive_windows");
     for streams in [1, 8] {
         let (outbound, endpoint) = fixture(1400, true, 8, "cubic");
         let ep = endpoint.clone();
@@ -1025,6 +1329,10 @@ async fn blocked_outer_path_bounds_stream_and_datagram_send_buffers_and_stop() {
     struct Blockable(BudgetPackets, Arc<AtomicBool>);
     #[async_trait::async_trait]
     impl DatagramTransport for Blockable {
+        fn supports_shared_destinations(&self) -> bool {
+            false
+        }
+
         fn payload_budget(&self, peer: &Destination) -> DatagramBudget {
             self.0.payload_budget(peer)
         }
@@ -1041,7 +1349,6 @@ async fn blocked_outer_path_bounds_stream_and_datagram_send_buffers_and_stop() {
             self.0.close().await
         }
     }
-    let _case = Case::new("TUIC-UNIT", "send_buffers");
     let (config, packets, endpoint) = fixture_parts(1400, true, 8, "cubic", "native");
     let blocked = Arc::new(AtomicBool::new(false));
     let outbound = TuicOutbound::new_with_path(
@@ -1117,3 +1424,545 @@ async fn blocked_outer_path_bounds_stream_and_datagram_send_buffers_and_stop() {
         .await;
     finish(endpoint, peer).await;
 }
+
+#[tokio::test]
+async fn configured_ip_sni_millisecond_heartbeat_and_uot_v2_are_consumed() {
+    let (mut config, packets, endpoint) = fixture_parts(1400, true, 8, "cubic", "native");
+    config.address = "logical.invalid".into();
+    config.ip = Some("192.0.2.1".into());
+    config.heartbeat_interval = Duration::from_millis(12);
+    config.udp_over_stream = true;
+    config.disable_mtu_discovery = true;
+    let outbound = Arc::new(
+        TuicOutbound::new_with_path(
+            &config,
+            UpstreamPath::proxy(Arc::new(MemoryUpstream(Mutex::new(Some(packets))))),
+        )
+        .unwrap(),
+    );
+    let ep = endpoint.clone();
+    let peer = tokio::spawn(async move {
+        let connection = authenticated(&ep).await;
+        let handshake = connection
+            .handshake_data()
+            .unwrap()
+            .downcast::<quinn::crypto::rustls::HandshakeData>()
+            .unwrap();
+        assert_eq!(handshake.server_name.as_deref(), Some("fixture.invalid"));
+        let (mut send, mut recv) = connection.accept_bi().await.unwrap();
+        let magic = "sp.v2.udp-over-tcp.arpa";
+        let mut header = vec![0; 4 + magic.len() + 2];
+        recv.read_exact(&mut header).await.unwrap();
+        assert_eq!(&header[..4], &[5, 1, 0, magic.len() as u8]);
+        assert_eq!(&header[4..4 + magic.len()], magic.as_bytes());
+        assert_eq!(&header[4 + magic.len()..], &[0, 0]);
+        let expected: &[u8] = &[0, 1, 1, 2, 3, 4, 0, 53, 0, 1, 2, 3, 4, 0, 53, 0, 1, b'q'];
+        let mut packet = vec![0; expected.len()];
+        recv.read_exact(&mut packet).await.unwrap();
+        assert_eq!(packet, expected);
+        send.write_all(&[0, 8, 8, 8, 8, 0, 53, 0, 1, b'a'])
+            .await
+            .unwrap();
+        let heartbeat =
+            tokio::time::timeout(Duration::from_millis(250), connection.read_datagram())
+                .await
+                .unwrap()
+                .unwrap();
+        assert_eq!(heartbeat.as_ref(), &[5, 4]);
+        connection.closed().await;
+    });
+    let probe = ResourceProbe::default();
+    probe
+        .scope(async {
+            let mut transport = outbound
+                .open_datagram(udp_request(), &EstablishContext::default())
+                .await
+                .unwrap();
+            transport
+                .send(Datagram {
+                    remote: Destination::Ip("1.2.3.4:53".parse().unwrap()),
+                    payload: bytes::Bytes::from_static(b"q"),
+                    sniffed_domain: None,
+                })
+                .await
+                .unwrap();
+            assert_eq!(transport.receive().await.unwrap().payload.as_ref(), b"a");
+            tokio::time::sleep(Duration::from_millis(15)).await;
+            outbound.shutdown().await;
+            assert!(transport.receive().await.is_err());
+            drop(transport);
+        })
+        .await;
+    assert!(probe.snapshot().is_idle(), "{:?}", probe.snapshot());
+    finish(endpoint, peer).await;
+}
+
+#[tokio::test(start_paused = true)]
+async fn configured_mtu_discovery_changes_native_probes_and_path_mtu() {
+    for disabled in [false, true] {
+        let (mut config, packets, endpoint) = fixture_parts(1400, true, 8, "cubic", "native");
+        config.disable_mtu_discovery = disabled;
+        let outbound = TuicOutbound::new_with_path(
+            &config,
+            UpstreamPath::proxy(Arc::new(MemoryUpstream(Mutex::new(Some(packets))))),
+        )
+        .unwrap();
+        let ep = endpoint.clone();
+        let peer = tokio::spawn(async move {
+            let connection = authenticated(&ep).await;
+            let (mut send, mut recv) = connection.accept_bi().await.unwrap();
+            let mut header = [0; 7];
+            recv.read_exact(&mut header).await.unwrap();
+            assert_eq!(&header, b"\x05\x01\x00\x01x\x00\x50");
+            send.write_all(b"ready").await.unwrap();
+            let payload = recv.read_u8().await.unwrap();
+            send.write_all(&[payload]).await.unwrap();
+            connection.closed().await;
+        });
+        let probe = ResourceProbe::default();
+        probe
+            .scope(async {
+                let mut stream = outbound
+                    .connect_stream(request(), &EstablishContext::default())
+                    .await
+                    .unwrap()
+                    .io;
+                let mut ready = [0; 5];
+                stream.read_exact(&mut ready).await.unwrap();
+                if disabled {
+                    // Same observation interval as enabled, long before the
+                    // default ten-second keepalive or discovery re-run.
+                    tokio::time::sleep(Duration::from_secs(1)).await;
+                } else {
+                    tokio::time::timeout(Duration::from_secs(1), async {
+                        loop {
+                            let path = outbound.path_observation().await.unwrap();
+                            if path.sent_plpmtud_probes > 0 && path.current_mtu > 1200 {
+                                break;
+                            }
+                            tokio::time::sleep(Duration::from_millis(10)).await;
+                        }
+                    })
+                    .await
+                    .expect("real native probe ACK must increase the current path MTU");
+                }
+                let path = outbound.path_observation().await.unwrap();
+                if disabled {
+                    assert_eq!(path.sent_plpmtud_probes, 0);
+                    assert_eq!(path.current_mtu, 1400);
+                } else {
+                    assert!(path.sent_plpmtud_probes > 0);
+                    assert_eq!(path.lost_plpmtud_probes, 0);
+                    assert!(1200 < path.current_mtu && path.current_mtu <= 1400);
+                }
+                // Real business still traverses the measured path after its
+                // probe result, rather than only inspecting construction.
+                stream.write_all(b"a").await.unwrap();
+                assert_eq!(stream.read_u8().await.unwrap(), b'a');
+                outbound.shutdown().await;
+                drop(stream);
+            })
+            .await;
+        assert!(probe.snapshot().is_idle(), "{:?}", probe.snapshot());
+        finish(endpoint, peer).await;
+    }
+}
+
+#[tokio::test]
+async fn official_quinn_credit_is_bounded_and_replenished_independent_of_owner_threshold() {
+    let (mut config, packets, endpoint) = fixture_parts(1400, true, 8, "cubic", "quic");
+    config.max_open_streams = i64::MAX as usize - 1;
+    let outbound = TuicOutbound::new_with_path(
+        &config,
+        UpstreamPath::proxy(Arc::new(MemoryUpstream(Mutex::new(Some(packets))))),
+    )
+    .unwrap();
+    let ep = endpoint.clone();
+    let (ready, wait) = tokio::sync::oneshot::channel();
+    let peer = tokio::spawn(async move {
+        let connection = authenticated(&ep).await;
+        assert!(
+            tokio::time::timeout(Duration::from_millis(50), connection.open_bi())
+                .await
+                .is_err()
+        );
+        let mut held = VecDeque::new();
+        for _ in 0..32 {
+            let send = connection.open_uni().await.unwrap();
+            held.push_back(send);
+        }
+        // Receiving the highest permitted ID implicitly opens the preceding
+        // gaps. They must fit the same 32 slots even without their own data.
+        held.back_mut().unwrap().write_all(&[5]).await.unwrap();
+        assert!(
+            tokio::time::timeout(Duration::from_millis(100), connection.open_uni())
+                .await
+                .is_err()
+        );
+        // EOF ends each partial decoder. Official Quinn batches MAX_STREAMS
+        // updates until more than 1/8 of the 32-slot window has been released;
+        // a single completed stream need not immediately grant peer credit.
+        for _ in 0..4 {
+            held.pop_front().unwrap().finish().unwrap();
+        }
+        assert!(
+            tokio::time::timeout(Duration::from_millis(100), connection.open_uni())
+                .await
+                .is_err()
+        );
+        held.pop_front().unwrap().finish().unwrap();
+        for _ in 0..5 {
+            let mut next = tokio::time::timeout(Duration::from_secs(2), connection.open_uni())
+                .await
+                .unwrap()
+                .unwrap();
+            next.write_all(&[5]).await.unwrap();
+            held.push_back(next);
+        }
+        for _ in 0..8 {
+            assert!(
+                tokio::time::timeout(Duration::from_millis(100), connection.open_uni())
+                    .await
+                    .is_err()
+            );
+            for _ in 0..5 {
+                held.pop_front().unwrap().finish().unwrap();
+            }
+            for _ in 0..5 {
+                let mut next = tokio::time::timeout(Duration::from_secs(2), connection.open_uni())
+                    .await
+                    .unwrap()
+                    .unwrap();
+                next.write_all(&[5]).await.unwrap();
+                held.push_back(next);
+            }
+        }
+        // Stream IDs above the first concurrency window work through automatic
+        // recycling; cumulative accepts do not increase concurrent permission.
+        assert!(
+            tokio::time::timeout(Duration::from_millis(100), connection.open_uni())
+                .await
+                .is_err()
+        );
+        ready.send(()).unwrap();
+        connection.closed().await;
+    });
+    let probe = ResourceProbe::default();
+    probe
+        .scope(async {
+            let udp = outbound
+                .open_datagram(udp_request(), &EstablishContext::default())
+                .await
+                .unwrap();
+            tokio::time::timeout(Duration::from_secs(4), wait)
+                .await
+                .unwrap()
+                .unwrap();
+            outbound.shutdown().await;
+            drop(udp);
+            assert!(probe.snapshot().is_idle(), "{:?}", probe.snapshot());
+        })
+        .await;
+    finish(endpoint, peer).await;
+}
+
+#[tokio::test]
+async fn official_quinn_receive_budget_is_independent_of_send_frame_limit() {
+    for receive_budget in [60, 64] {
+        let (mut config, packets, endpoint) = fixture_parts(1400, true, 8, "cubic", "native");
+        config.max_datagram_frame_size = 80;
+        config.max_udp_relay_packet_size = 51;
+        let outbound = TuicOutbound::new_with_path(
+            &config,
+            UpstreamPath::proxy(Arc::new(MemoryUpstream(Mutex::new(Some(packets))))),
+        )
+        .unwrap();
+        let ep = endpoint.clone();
+        let peer = tokio::spawn(async move {
+            let connection = authenticated(&ep).await;
+            // An outbound packet proves association registration completed before
+            // the peer sends its responses; authentication alone precedes it.
+            connection.read_datagram().await.unwrap();
+            // These peer messages fit the physical path. The 61-byte response
+            // exceeds our configured send frame limit but fits a 64-byte source
+            // receive budget; a 60-byte receive budget must reject it.
+            for size in [61_u16, 60] {
+                let mut raw = vec![5, 2, 0, 0, 0, 0, 1, 0];
+                raw.extend_from_slice(&size.to_be_bytes());
+                raw.extend_from_slice(&[1, 192, 0, 2, 1, 0, 53]);
+                raw.resize(raw.len() + usize::from(size), size as u8);
+                connection.send_datagram_wait(raw.into()).await.unwrap();
+            }
+            connection.closed().await;
+        });
+        let probe = ResourceProbe::default();
+        probe
+            .scope(async {
+                let mut udp = outbound
+                    .open_datagram(
+                        udp_request().with_budget(DatagramBudget::new(u16::MAX, receive_budget)),
+                        &EstablishContext::default(),
+                    )
+                    .await
+                    .unwrap();
+                udp.send(Datagram {
+                    remote: request().destination,
+                    payload: bytes::Bytes::from_static(b"start"),
+                    sniffed_domain: None,
+                })
+                .await
+                .unwrap();
+                let packet = tokio::time::timeout(Duration::from_secs(2), udp.receive())
+                    .await
+                    .unwrap()
+                    .unwrap();
+                if receive_budget == 64 {
+                    assert_eq!(packet.payload, vec![61; 61]);
+                    let packet = tokio::time::timeout(Duration::from_secs(2), udp.receive())
+                        .await
+                        .unwrap()
+                        .unwrap();
+                    assert_eq!(packet.payload, vec![60; 60]);
+                } else {
+                    assert_eq!(packet.payload, vec![60; 60]);
+                }
+                assert!(
+                    tokio::time::timeout(Duration::from_millis(50), udp.receive())
+                        .await
+                        .is_err()
+                );
+                outbound.shutdown().await;
+                drop(udp);
+                assert!(probe.snapshot().is_idle(), "{:?}", probe.snapshot());
+            })
+            .await;
+        finish(endpoint, peer).await;
+    }
+}
+
+async fn echo_lane_udp(connection: &quinn::Connection, native: bool, payload: &[u8]) {
+    let raw = if native {
+        connection.read_datagram().await.unwrap().to_vec()
+    } else {
+        connection
+            .accept_uni()
+            .await
+            .unwrap()
+            .read_to_end(65535)
+            .await
+            .unwrap()
+    };
+    assert_eq!(&raw[raw.len() - payload.len()..], payload);
+    if native {
+        connection.send_datagram_wait(raw.into()).await.unwrap();
+    } else {
+        let mut send = connection.open_uni().await.unwrap();
+        send.write_all(&raw).await.unwrap();
+        send.finish().unwrap();
+    }
+}
+
+#[tokio::test]
+async fn native_tcp_and_udp_keep_one_physical_session_and_stop() {
+    let (config, path, endpoint) = fixture_parts(1400, true, 8, "cubic", "native");
+    let paths = Arc::new(Paths(Mutex::new(VecDeque::from([path]))));
+    let outbound =
+        TuicOutbound::new_with_path(&config, UpstreamPath::proxy(paths.clone())).unwrap();
+    let ep = endpoint.clone();
+    let peer = tokio::spawn(async move {
+        let connection = authenticated(&ep).await;
+        let (mut send, mut recv) = connection.accept_bi().await.unwrap();
+        let mut header = [0; 7];
+        recv.read_exact(&mut header).await.unwrap();
+        assert_eq!(&header, b"\x05\x01\x00\x01x\x00\x50");
+        assert_eq!(recv.read_u8().await.unwrap(), b'a');
+        send.write_all(b"a").await.unwrap();
+        echo_lane_udp(&connection, true, b"u").await;
+        assert_eq!(recv.read_u8().await.unwrap(), b'b');
+        send.write_all(b"b").await.unwrap();
+        connection.closed().await;
+    });
+    let probe = ResourceProbe::default();
+    probe
+        .scope(async {
+            let mut tcp = outbound
+                .connect_stream(request(), &EstablishContext::default())
+                .await
+                .unwrap()
+                .io;
+            tcp.write_all(b"a").await.unwrap();
+            assert_eq!(tcp.read_u8().await.unwrap(), b'a');
+            let mut udp = outbound
+                .open_datagram(udp_request(), &EstablishContext::default())
+                .await
+                .unwrap();
+            udp.send(Datagram {
+                remote: request().destination,
+                payload: bytes::Bytes::from_static(b"u"),
+                sniffed_domain: None,
+            })
+            .await
+            .unwrap();
+            assert_eq!(udp.receive().await.unwrap().payload, b"u"[..]);
+            assert!(paths.0.lock().unwrap().is_empty());
+            assert_eq!(probe.snapshot().current(ResourceKind::Pool), 1);
+            udp.close().await.unwrap();
+            drop(udp);
+            tcp.write_all(b"b").await.unwrap();
+            assert_eq!(tcp.read_u8().await.unwrap(), b'b');
+            outbound.shutdown().await;
+            assert!(tcp.read_u8().await.is_err());
+            drop(tcp);
+            assert!(probe.snapshot().is_idle(), "{:?}", probe.snapshot());
+        })
+        .await;
+    finish(endpoint, peer).await;
+}
+
+#[tokio::test]
+async fn quic_business_lanes_retire_only_udp_while_tcp_is_held_and_stop_all() {
+    let (mut config, tcp_path, tcp_endpoint) = fixture_parts(1400, true, 8, "cubic", "quic");
+    let (_, udp_path, udp_endpoint) = fixture_parts(1400, true, 8, "cubic", "quic");
+    let (_, fresh_path, fresh_endpoint) = fixture_parts(1400, true, 8, "cubic", "quic");
+    config.max_open_streams = 2;
+    let paths = Arc::new(Paths(Mutex::new(VecDeque::from([
+        tcp_path, udp_path, fresh_path,
+    ]))));
+    let outbound =
+        TuicOutbound::new_with_path(&config, UpstreamPath::proxy(paths.clone())).unwrap();
+    let ep = tcp_endpoint.clone();
+    let tcp_peer = tokio::spawn(async move {
+        let connection = authenticated(&ep).await;
+        let (mut send, mut recv) = connection.accept_bi().await.unwrap();
+        let mut header = [0; 7];
+        recv.read_exact(&mut header).await.unwrap();
+        assert_eq!(&header, b"\x05\x01\x00\x01x\x00\x50");
+        assert_eq!(recv.read_u8().await.unwrap(), b'a');
+        send.write_all(b"a").await.unwrap();
+        // The second stream must reuse this original TCP lane after UDP retires.
+        let (mut sibling_send, mut sibling_recv) = connection.accept_bi().await.unwrap();
+        sibling_recv.read_exact(&mut header).await.unwrap();
+        assert_eq!(sibling_recv.read_u8().await.unwrap(), b'x');
+        sibling_send.write_all(b"x").await.unwrap();
+        for expected in [b'b', b'c'] {
+            assert_eq!(recv.read_u8().await.unwrap(), expected);
+            send.write_all(&[expected]).await.unwrap();
+        }
+        connection.closed().await;
+    });
+    let ep = udp_endpoint.clone();
+    let udp_peer = tokio::spawn(async move {
+        let connection = authenticated(&ep).await;
+        for payload in [b"p".as_slice(), b"q".as_slice(), b"s".as_slice()] {
+            echo_lane_udp(&connection, false, payload).await;
+        }
+        connection.closed().await;
+    });
+    let ep = fresh_endpoint.clone();
+    let fresh_peer = tokio::spawn(async move {
+        let connection = authenticated(&ep).await;
+        echo_lane_udp(&connection, false, b"r").await;
+        connection.closed().await;
+    });
+    let probe = ResourceProbe::default();
+    probe
+        .scope(async {
+            let mut tcp = outbound
+                .connect_stream(request(), &EstablishContext::default())
+                .await
+                .unwrap()
+                .io;
+            tcp.write_all(b"a").await.unwrap();
+            assert_eq!(tcp.read_u8().await.unwrap(), b'a');
+            assert_eq!(outbound.datagram_buffer_space().await, None);
+            assert!(outbound.congestion_observation().await.is_some());
+            assert!(outbound.path_observation().await.is_some());
+            let mut first = outbound
+                .open_datagram(udp_request(), &EstablishContext::default())
+                .await
+                .unwrap();
+            first
+                .send(Datagram {
+                    remote: request().destination,
+                    payload: bytes::Bytes::from_static(b"p"),
+                    sniffed_domain: None,
+                })
+                .await
+                .unwrap();
+            assert_eq!(first.receive().await.unwrap().payload, b"p"[..]);
+            assert!(outbound.datagram_buffer_space().await.is_some());
+            assert_eq!(probe.snapshot().current(ResourceKind::Pool), 2);
+            let mut held = outbound
+                .open_datagram(udp_request(), &EstablishContext::default())
+                .await
+                .unwrap();
+            held.send(Datagram {
+                remote: request().destination,
+                payload: bytes::Bytes::from_static(b"q"),
+                sniffed_domain: None,
+            })
+            .await
+            .unwrap();
+            assert_eq!(held.receive().await.unwrap().payload, b"q"[..]);
+            assert_eq!(paths.0.lock().unwrap().len(), 1);
+            let mut fresh = outbound
+                .open_datagram(udp_request(), &EstablishContext::default())
+                .await
+                .unwrap();
+            fresh
+                .send(Datagram {
+                    remote: request().destination,
+                    payload: bytes::Bytes::from_static(b"r"),
+                    sniffed_domain: None,
+                })
+                .await
+                .unwrap();
+            assert_eq!(fresh.receive().await.unwrap().payload, b"r"[..]);
+            assert_eq!(probe.snapshot().current(ResourceKind::Pool), 3);
+            assert!(paths.0.lock().unwrap().is_empty());
+            let mut sibling = outbound
+                .connect_stream(request(), &EstablishContext::default())
+                .await
+                .unwrap()
+                .io;
+            sibling.write_all(b"x").await.unwrap();
+            assert_eq!(sibling.read_u8().await.unwrap(), b'x');
+            drop(sibling);
+            tcp.write_all(b"b").await.unwrap();
+            assert_eq!(tcp.read_u8().await.unwrap(), b'b');
+            first
+                .send(Datagram {
+                    remote: request().destination,
+                    payload: bytes::Bytes::from_static(b"s"),
+                    sniffed_domain: None,
+                })
+                .await
+                .unwrap();
+            assert_eq!(first.receive().await.unwrap().payload, b"s"[..]);
+            held.close().await.unwrap();
+            drop(held);
+            assert_eq!(probe.snapshot().current(ResourceKind::Pool), 3);
+            first.close().await.unwrap();
+            drop(first);
+            tokio::time::timeout(Duration::from_secs(2), async {
+                while probe.snapshot().current(ResourceKind::Pool) != 2 {
+                    tokio::task::yield_now().await;
+                }
+            })
+            .await
+            .unwrap();
+            tcp.write_all(b"c").await.unwrap();
+            assert_eq!(tcp.read_u8().await.unwrap(), b'c');
+            let before = tokio::time::Instant::now();
+            outbound.shutdown().await;
+            assert!(before.elapsed() < Duration::from_secs(2));
+            assert!(fresh.receive().await.is_err());
+            assert!(tcp.read_u8().await.is_err());
+            drop((tcp, fresh));
+            assert!(probe.snapshot().is_idle(), "{:?}", probe.snapshot());
+        })
+        .await;
+    finish(tcp_endpoint, tcp_peer).await;
+    finish(udp_endpoint, udp_peer).await;
+    finish(fresh_endpoint, fresh_peer).await;
+}
diff --git a/tests/uot_config.rs b/tests/uot_config.rs
index 1e71df1..3b68ddb 100644
--- a/tests/uot_config.rs
+++ b/tests/uot_config.rs
@@ -16,8 +16,6 @@ fn parse(node: Value) -> vole::Result<Config> {
 
 #[test]
 fn ss_uot_is_opt_in_and_accepts_only_explicit_or_default_v2() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new("UOT-CFG", "strict_v2");
     if !cfg!(feature = "outbound-shadowsocks") {
         let mut n = node();
         n["udp-over-tcp"] = json!(true);
diff --git a/tests/vless_codec.rs b/tests/vless_codec.rs
index 1315341..88982aa 100644
--- a/tests/vless_codec.rs
+++ b/tests/vless_codec.rs
@@ -5,7 +5,7 @@ use std::{
 };
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use vole::{
-    config::{Config, ProxyProtocol},
+    config::{Config, ProxyProtocol, VlessOutboundConfig, VlessPacketEncoding},
     dispatch::{BoxStream, DatagramTransport, DispatchError},
     outbound::{
         ConnectedStream, DatagramRequest, EstablishContext, OutboundConnector, UpstreamPath,
@@ -35,17 +35,29 @@ impl OutboundConnector for Supplied {
         Err(DispatchError::NotAllowed)
     }
 }
-fn node(io: BoxStream, encoding: &str) -> VlessOutbound {
+fn node_config(encoding: &str) -> VlessOutboundConfig {
     let config=Config::parse_yaml(format!("mixed-port: 1080\nproxies: [{{name: edge, type: vless, server: example.com, port: 443, uuid: 07070707-0707-0707-0707-070707070707, udp: true, packet-encoding: {encoding}}}]\nrules: ['MATCH,edge']").as_bytes()).unwrap();
     let ProxyProtocol::Vless(config) = &config.proxies[0].protocol else {
         unreachable!()
     };
+    config.clone()
+}
+fn node_with_config(io: BoxStream, config: &VlessOutboundConfig) -> VlessOutbound {
     VlessOutbound::new_with_path(
         config,
         UpstreamPath::proxy(Arc::new(Supplied(Mutex::new(Some(io))))),
     )
     .unwrap()
 }
+fn node(io: BoxStream, encoding: &str) -> VlessOutbound {
+    node_with_config(io, &node_config(encoding))
+}
+fn internal_raw_node(io: BoxStream) -> VlessOutbound {
+    let mut config = node_config("xudp");
+    // Keep the internal fixed-target codec covered through the typed API.
+    config.packet_encoding = VlessPacketEncoding::Raw;
+    node_with_config(io, &config)
+}
 fn session() -> DatagramSession {
     DatagramSession::new(InboundKind::InternalMeasure, "127.0.0.1:1".parse().unwrap())
 }
@@ -59,14 +71,18 @@ fn packet() -> Datagram {
 
 #[tokio::test]
 async fn stopping_before_first_udp_send_wakes_receive_and_releases_io() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "VLESS-UNIT",
-        "stopping_before_first_udp_send_wakes_receive_and_releases_io",
-    );
-    for encoding in ["none", "packetaddr"] {
+    for encoding in [
+        None,
+        Some("none"),
+        Some("xudp"),
+        Some("packetaddr"),
+        Some("packet"),
+    ] {
         let (io, mut peer) = tokio::io::duplex(1024);
-        let outbound = node(Box::new(io), encoding);
+        let outbound = match encoding {
+            Some(encoding) => node(Box::new(io), encoding),
+            None => internal_raw_node(Box::new(io)),
+        };
         let mut client = outbound
             .open_datagram(
                 DatagramRequest::new(session()),
@@ -74,6 +90,20 @@ async fn stopping_before_first_udp_send_wakes_receive_and_releases_io() {
             )
             .await
             .unwrap();
+        if matches!(encoding, Some("none" | "xudp")) {
+            let header = vole::outbound::encode_request_header(
+                uuid::Uuid::from_bytes([7; 16]),
+                vole::outbound::VlessCommand::Mux,
+                None,
+            )
+            .unwrap();
+            let mut received = vec![0; header.len()];
+            tokio::time::timeout(Duration::from_millis(100), peer.read_exact(&mut received))
+                .await
+                .expect("XUDP must submit its Mux header before the first datagram")
+                .unwrap();
+            assert_eq!(received, header);
+        }
         outbound.shutdown().await;
         assert!(
             tokio::time::timeout(Duration::from_millis(100), client.receive())
@@ -88,14 +118,13 @@ async fn stopping_before_first_udp_send_wakes_receive_and_releases_io() {
 
 #[tokio::test]
 async fn raw_and_packetaddr_consume_wire_and_keep_cancelled_receive_progress() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "VLESS-UNIT",
-        "raw_and_packetaddr_consume_wire_and_keep_cancelled_receive_progress",
-    );
-    for encoding in ["none", "packetaddr", "packet"] {
+    // None selects the typed internal codec; the YAML value `none` uses XUDP.
+    for encoding in [None, Some("packetaddr"), Some("packet")] {
         let (io, mut peer) = tokio::io::duplex(1024);
-        let outbound = node(Box::new(io), encoding);
+        let outbound = match encoding {
+            Some(encoding) => node(Box::new(io), encoding),
+            None => internal_raw_node(Box::new(io)),
+        };
         let mut client = outbound
             .open_datagram(
                 DatagramRequest::new(session()),
@@ -105,7 +134,7 @@ async fn raw_and_packetaddr_consume_wire_and_keep_cancelled_receive_progress() {
             .unwrap();
         let datagram = packet();
         client.send(datagram.clone()).await.unwrap();
-        let target = if encoding == "none" {
+        let target = if encoding.is_none() {
             datagram.remote.clone()
         } else {
             Destination::domain("sp.packet-addr.v2fly.arpa", 443).unwrap()
@@ -123,7 +152,7 @@ async fn raw_and_packetaddr_consume_wire_and_keep_cancelled_receive_progress() {
         let mut frame = vec![0; length];
         peer.read_exact(&mut frame).await.unwrap();
         let mut expected = bytes::BytesMut::new();
-        if encoding != "none" {
+        if encoding.is_some() {
             vole::outbound::address::encode_packet_addr(&datagram.remote, &mut expected).unwrap();
         }
         expected.extend_from_slice(&datagram.payload);
@@ -145,7 +174,7 @@ async fn raw_and_packetaddr_consume_wire_and_keep_cancelled_receive_progress() {
         let response = client.receive().await.unwrap();
         assert_eq!(response.remote, datagram.remote);
         assert_eq!(response.payload, datagram.payload);
-        if encoding == "none" {
+        if encoding.is_none() {
             let mut other = datagram.clone();
             other.remote = Destination::Ip("192.0.2.2:53".parse().unwrap());
             assert!(client.send(other).await.is_err());
@@ -156,15 +185,102 @@ async fn raw_and_packetaddr_consume_wire_and_keep_cancelled_receive_progress() {
 }
 
 #[tokio::test]
-async fn udp_cancelled_send_and_bad_response_header_close_owned_io() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "VLESS-UNIT",
-        "udp_cancelled_send_and_bad_response_header_close_owned_io",
-    );
-    for encoding in ["none", "packetaddr", "xudp"] {
-        let (io, mut peer) = tokio::io::duplex(if encoding == "xudp" { 20 } else { 1 });
+async fn none_and_xudp_keep_mux_wire_targets_and_cancelled_receive_progress() {
+    for encoding in ["none", "xudp"] {
+        let (io, mut peer) = tokio::io::duplex(1024);
         let outbound = node(Box::new(io), encoding);
+        let mut client = outbound
+            .open_datagram(
+                DatagramRequest::new(session()),
+                &EstablishContext::default(),
+            )
+            .await
+            .unwrap();
+        let header = vole::outbound::encode_request_header(
+            uuid::Uuid::from_bytes([7; 16]),
+            vole::outbound::VlessCommand::Mux,
+            None,
+        )
+        .unwrap();
+        let mut received = vec![0; header.len()];
+        tokio::time::timeout(Duration::from_millis(100), peer.read_exact(&mut received))
+            .await
+            .expect("none and xudp must both submit the VLESS Mux header")
+            .unwrap();
+        assert_eq!(received, header);
+
+        let datagram = packet();
+        client.send(datagram.clone()).await.unwrap();
+        // Session zero, NEW/DATA/UDP, port-first IPv4; no GlobalID extension.
+        let mut first = vec![0, 12, 0, 0, 1, 1, 2, 0, 53, 1, 192, 0, 2, 1, 0, 7];
+        first.extend_from_slice(b"payload");
+        let mut received = vec![0; first.len()];
+        peer.read_exact(&mut received).await.unwrap();
+        assert_eq!(received, first);
+
+        // Split both the response prefix and an XUDP DATA body across cancellation.
+        first[4] = 2; // Server responses carry KEEP.
+        peer.write_all(&[0, 0, first[0]]).await.unwrap();
+        assert!(
+            tokio::time::timeout(Duration::from_millis(10), client.receive())
+                .await
+                .is_err()
+        );
+        peer.write_all(&first[1..first.len() - 2]).await.unwrap();
+        assert!(
+            tokio::time::timeout(Duration::from_millis(10), client.receive())
+                .await
+                .is_err()
+        );
+        peer.write_all(&first[first.len() - 2..]).await.unwrap();
+        let response = client.receive().await.unwrap();
+        assert_eq!(response.remote, datagram.remote);
+        assert_eq!(response.payload, datagram.payload);
+
+        let other = Datagram {
+            remote: Destination::domain("dns.example", 5353).unwrap(),
+            payload: bytes::Bytes::from_static(b"other"),
+            sniffed_domain: None,
+        };
+        client.send(other.clone()).await.unwrap();
+        // KEEP/DATA/UDP carries the new domain and port on the same association.
+        let mut second = vec![0, 20, 0, 0, 2, 1, 2, 0x14, 0xe9, 2, 11];
+        second.extend_from_slice(b"dns.example");
+        second.extend_from_slice(&[0, 5]);
+        second.extend_from_slice(b"other");
+        let mut received = vec![0; second.len()];
+        peer.read_exact(&mut received).await.unwrap();
+        assert_eq!(received, second);
+        peer.write_all(&second).await.unwrap();
+        let response = client.receive().await.unwrap();
+        assert_eq!(response.remote, other.remote);
+        assert_eq!(response.payload, other.payload);
+        client.close().await.unwrap();
+        let mut end = [0; 6];
+        peer.read_exact(&mut end).await.unwrap();
+        assert_eq!(end, [0, 4, 0, 0, 3, 0]);
+        assert_eq!(peer.read(&mut [0; 1]).await.unwrap(), 0);
+    }
+}
+
+#[tokio::test]
+async fn udp_send_cancellation_and_bad_header_ownership() {
+    for encoding in [
+        None,
+        Some("none"),
+        Some("xudp"),
+        Some("packetaddr"),
+        Some("packet"),
+    ] {
+        let (io, mut peer) = tokio::io::duplex(if matches!(encoding, Some("none" | "xudp")) {
+            20
+        } else {
+            1
+        });
+        let outbound = match encoding {
+            Some(encoding) => node(Box::new(io), encoding),
+            None => internal_raw_node(Box::new(io)),
+        };
         let mut client = outbound
             .open_datagram(
                 DatagramRequest::new(session()),
@@ -177,18 +293,32 @@ async fn udp_cancelled_send_and_bad_response_header_close_owned_io() {
                 .await
                 .is_err()
         );
+        if encoding.is_some() {
+            let mut prefix = Vec::new();
+            assert!(
+                tokio::time::timeout(Duration::from_millis(10), peer.read_to_end(&mut prefix),)
+                    .await
+                    .is_err(),
+                "framed cancellation must retain its recoverable IO owner",
+            );
+            assert!(!prefix.is_empty());
+            client.close().await.unwrap();
+        }
         tokio::time::timeout(
             Duration::from_millis(100),
             peer.read_to_end(&mut Vec::new()),
         )
         .await
-        .expect("send cancellation retained IO")
+        .expect("closed or failed send retained IO")
         .unwrap();
         assert!(client.send(packet()).await.is_err());
         assert!(client.receive().await.is_err());
 
         let (io, mut peer) = tokio::io::duplex(1024);
-        let outbound = node(Box::new(io), encoding);
+        let outbound = match encoding {
+            Some(encoding) => node(Box::new(io), encoding),
+            None => internal_raw_node(Box::new(io)),
+        };
         let mut client = outbound
             .open_datagram(
                 DatagramRequest::new(session()),
@@ -210,13 +340,8 @@ async fn udp_cancelled_send_and_bad_response_header_close_owned_io() {
     }
 }
 
-#[tokio::test]
-async fn tcp_bad_response_header_poisoning_and_absolute_response_deadline() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "VLESS-UNIT",
-        "tcp_bad_response_header_poisoning_and_absolute_response_deadline",
-    );
+#[tokio::test(start_paused = true)]
+async fn tcp_bad_header_fails_closed_and_committed_request_outlives_setup_deadline() {
     for invalid_header in [true, false] {
         let (io, mut peer) = tokio::io::duplex(1024);
         let outbound = node(Box::new(io), "xudp");
@@ -224,6 +349,7 @@ async fn tcp_bad_response_header_poisoning_and_absolute_response_deadline() {
         let mut connected = outbound
             .connect_stream(
                 StreamSession {
+                    metadata: Default::default(),
                     inbound: session().inbound,
                     source: session().source,
                     destination: packet().remote,
@@ -236,13 +362,35 @@ async fn tcp_bad_response_header_poisoning_and_absolute_response_deadline() {
         connected.io.write_all(b"request").await.unwrap();
         if invalid_header {
             peer.write_all(&[1, 0]).await.unwrap();
+            assert!(
+                tokio::time::timeout(Duration::from_millis(100), connected.io.read(&mut [0; 1]))
+                    .await
+                    .expect("invalid response header remained pending")
+                    .is_err()
+            );
+            assert!(connected.io.write_all(b"after failure").await.is_err());
+        } else {
+            tokio::time::advance(Duration::from_millis(100)).await;
+            {
+                let mut pending_byte = [0; 1];
+                let pending_read = connected.io.read(&mut pending_byte);
+                tokio::pin!(pending_read);
+                assert!(futures_util::poll!(pending_read.as_mut()).is_pending());
+            }
+            peer.write_all(&[0, 0, b'x']).await.unwrap();
+            let mut response = [0; 1];
+            tokio::time::timeout(
+                Duration::from_millis(100),
+                connected.io.read_exact(&mut response),
+            )
+            .await
+            .expect("late response remained pending")
+            .unwrap();
+            assert_eq!(response, [b'x']);
+            connected.io.write_all(b"after response").await.unwrap();
+            drop(connected);
+            outbound.shutdown().await;
         }
-        let result =
-            tokio::time::timeout(Duration::from_millis(100), connected.io.read(&mut [0; 1]))
-                .await
-                .expect("response did not retain setup deadline");
-        assert!(result.is_err());
-        assert!(connected.io.write_all(b"after failure").await.is_err());
         tokio::time::timeout(
             Duration::from_millis(100),
             peer.read_to_end(&mut Vec::new()),
diff --git a/tests/vless_config.rs b/tests/vless_config.rs
index 76fc4c9..7ab1a0d 100644
--- a/tests/vless_config.rs
+++ b/tests/vless_config.rs
@@ -4,11 +4,6 @@ use vole::config::Config;
 
 #[test]
 fn inline_client_identity_is_validated_and_redacted_before_io() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "VLESS-UNIT",
-        "inline_client_identity_is_validated_and_redacted_before_io",
-    );
     use base64::Engine as _;
     let pem = |kind: &str, der: &[u8]| {
         format!(
@@ -39,11 +34,6 @@ fn document(extra: Value) -> Vec<u8> {
 
 #[test]
 fn vision_requires_tcp_tls13_and_xudp_before_any_io() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "VLESS-UNIT",
-        "vision_requires_tcp_tls13_and_xudp_before_any_io",
-    );
     use vole::config::{ProxyProtocol, SecurityConfig};
     let config =
         Config::parse_yaml(&document(json!({"flow":"xtls-rprx-vision","tls":true}))).unwrap();
@@ -56,7 +46,6 @@ fn vision_requires_tcp_tls13_and_xudp_before_any_io() {
     assert!(tls.tls13_only);
     for fields in [
         json!({"flow":"xtls-rprx-vision"}),
-        json!({"flow":"xtls-rprx-vision","tls":true,"packet-encoding":"none"}),
         json!({"flow":"xtls-rprx-vision","tls":true,"packet-encoding":"packetaddr"}),
         json!({"flow":"xtls-rprx-vision","tls":true,"network":"ws"}),
         json!({"flow":"xtls-rprx-vision","tls":true,"network":"grpc","grpc-opts":{"grpc-service-name":"test"}}),
@@ -68,12 +57,7 @@ fn vision_requires_tcp_tls13_and_xudp_before_any_io() {
 }
 
 #[test]
-fn default_tcp_and_three_udp_encodings_are_accepted_without_io() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "VLESS-UNIT",
-        "default_tcp_and_three_udp_encodings_are_accepted_without_io",
-    );
+fn default_tcp_and_supported_udp_encodings_are_accepted_without_io() {
     let config = Config::parse_yaml(&document(json!({}))).expect("default plaintext TCP");
     assert!(!config.proxies[0].udp);
     assert!(!format!("{config:?}").contains("07070707"));
@@ -88,12 +72,46 @@ fn default_tcp_and_three_udp_encodings_are_accepted_without_io() {
 }
 
 #[test]
-fn tcp_and_existing_xhttp_reject_mismatched_and_future_options() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "VLESS-UNIT",
-        "tcp_and_existing_xhttp_reject_mismatched_and_future_options",
+fn omitted_null_and_empty_flow_use_plain_grpc() {
+    use vole::config::{ProxyProtocol, StreamTransport, VlessTransport};
+    let mut documents = [json!({}), json!({"flow": null}), json!({"flow": ""})]
+        .into_iter()
+        .map(|mut fields| {
+            fields["network"] = json!("grpc");
+            fields["grpc-opts"] = json!({"grpc-service-name": "edge"});
+            document(fields)
+        })
+        .collect::<Vec<_>>();
+    documents.push(
+        br#"mixed-port: 1080
+proxies:
+  - name: edge
+    type: vless
+    server: example.com
+    port: 443
+    uuid: 07070707-0707-0707-0707-070707070707
+    flow:
+    network: grpc
+    grpc-opts: {grpc-service-name: edge}
+rules: ['MATCH,edge']
+"#
+        .to_vec(),
     );
+    for yaml in documents {
+        let config = Config::parse_yaml(&yaml).unwrap();
+        let ProxyProtocol::Vless(node) = &config.proxies[0].protocol else {
+            unreachable!()
+        };
+        assert!(node.flow.is_empty());
+        assert!(matches!(
+            node.transport,
+            VlessTransport::Stream(StreamTransport::Grpc { .. })
+        ));
+    }
+}
+
+#[test]
+fn tcp_and_existing_xhttp_reject_mismatched_and_future_options() {
     for fields in [
         json!({"network":"tcp","xhttp-opts":{}}),
         json!({"network":"xhttp","tls":false,"fingerprint":"ab".repeat(32)}),
@@ -102,6 +120,7 @@ fn tcp_and_existing_xhttp_reject_mismatched_and_future_options() {
         json!({"packet-encoding":""}),
         json!({"packet-encoding":"raw"}),
         json!({"flow":"invalid-flow"}),
+        json!({"flow":false}),
         json!({"encryption":"auto"}),
         json!({"future":true}),
     ] {
@@ -115,7 +134,6 @@ fn tcp_and_existing_xhttp_reject_mismatched_and_future_options() {
         "network",
         "tls",
         "udp",
-        "flow",
         "encryption",
         "packet-encoding",
         "servername",
@@ -137,11 +155,6 @@ fn tcp_and_existing_xhttp_reject_mismatched_and_future_options() {
 
 #[test]
 fn stream_transports_and_explicit_tls_policy_have_strict_public_fields() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "VLESS-UNIT",
-        "stream_transports_and_explicit_tls_policy_have_strict_public_fields",
-    );
     for transport in [
         json!({"network":"ws","ws-opts":{"path":"/vless","headers":{"Host":"localhost:443"},"max-early-data":64}}),
         json!({"network":"grpc","grpc-opts":{"grpc-service-name":"vless"}}),
@@ -174,25 +187,77 @@ fn stream_transports_and_explicit_tls_policy_have_strict_public_fields() {
     }
     for fields in [
         json!({"skip-cert-verify":false}),
+        json!({"tls":false,"servername":"","fingerprint":"","certificate":"","private-key":""}),
+        json!({"tls":true,"reality-opts":{},"client-fingerprint":""}),
         json!({"tls":true,"fingerprint":"invalid"}),
-        json!({"tls":true,"name-cert-verify":""}),
+        json!({"tls":true,"name-cert-verify":"bad\nname"}),
         json!({"tls":true,"certificate":"bad"}),
         json!({"tls":true,"certificate":"bad","private-key":"bad"}),
         json!({"network":"tcp","ws-opts":{}}),
-        json!({"network":"h2","h2-opts":{"host":[]}}),
         json!({"network":"grpc","grpc-opts":{"grpc-service-name":"vless","future":1}}),
     ] {
         assert!(Config::parse_yaml(&document(fields)).is_err());
     }
 }
 
+#[test]
+fn empty_network_and_servername_keep_transport_fallbacks_and_grpc_authority() {
+    use vole::config::{ProxyProtocol, SecurityConfig, StreamTransport, VlessTransport};
+    let config =
+        Config::parse_yaml(&document(json!({"network":"","tls":true,"servername":""}))).unwrap();
+    let ProxyProtocol::Vless(node) = &config.proxies[0].protocol else {
+        unreachable!()
+    };
+    assert!(matches!(
+        node.transport,
+        VlessTransport::Stream(StreamTransport::Tcp)
+    ));
+    for (server, servername, authority) in [
+        ("127.0.0.1", "", "127.0.0.1:443"),
+        ("::1", "", "[::1]:443"),
+        ("127.0.0.1", "cover.invalid", "cover.invalid"),
+        ("127.0.0.1", "2001:db8::1", "[2001:db8::1]"),
+    ] {
+        let config = Config::parse_yaml(&document(json!({
+            "server":server, "servername":servername, "tls":true, "network":"grpc",
+            "name-cert-verify":"verify.invalid", "grpc-opts":{"grpc-service-name":"edge"}
+        })))
+        .unwrap();
+        let ProxyProtocol::Vless(node) = &config.proxies[0].protocol else {
+            unreachable!()
+        };
+        let VlessTransport::Stream(StreamTransport::Grpc { uri, .. }) = &node.transport else {
+            unreachable!()
+        };
+        let SecurityConfig::Tls(tls) = &node.security else {
+            unreachable!()
+        };
+        assert_eq!(uri, &format!("https://{authority}/edge/Tun"));
+        assert_eq!(
+            tls.server_name,
+            if servername.is_empty() {
+                server
+            } else {
+                servername
+            }
+        );
+        assert_eq!((node.address.as_str(), node.port), (server, 443));
+    }
+    let config = Config::parse_yaml(&document(json!({
+        "tls":true,"servername":"","network":"ws","ws-opts":{"headers":{"Host":"cover.invalid:443"}}
+    })))
+    .unwrap();
+    let ProxyProtocol::Vless(node) = &config.proxies[0].protocol else {
+        unreachable!()
+    };
+    let SecurityConfig::Tls(tls) = &node.security else {
+        unreachable!()
+    };
+    assert_eq!(tls.server_name, "cover.invalid");
+}
+
 #[test]
 fn extended_ws_and_grpc_fields_are_scoped_and_bounded() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "VLESS-UNIT",
-        "extended_ws_and_grpc_fields_are_scoped_and_bounded",
-    );
     for fields in [
         json!({"network":"ws","ws-opts":{"v2ray-http-upgrade":true,"v2ray-http-upgrade-fast-open":true,"max-early-data":1}}),
         json!({"network":"grpc","grpc-opts":{"grpc-service-name":"test","grpc-user-agent":"probe","ping-interval":1,"max-connections":2,"min-streams":3}}),
@@ -204,10 +269,38 @@ fn extended_ws_and_grpc_fields_are_scoped_and_bounded() {
         json!({"network":"ws","ws-opts":{"v2ray-http-upgrade-fast-open":true}}),
         json!({"network":"ws","ws-opts":{"v2ray-http-upgrade":true,"max-early-data":1,"early-data-header-name":"x-ed"}}),
         json!({"network":"ws","ws-opts":{"v2ray-http-upgrade":null}}),
-        json!({"network":"grpc","grpc-opts":{"grpc-service-name":"test","max-connections":1,"max-streams":2}}),
-        json!({"network":"grpc","grpc-opts":{"grpc-service-name":"test","ping-interval":-1}}),
         json!({"network":"grpc","grpc-opts":{"grpc-service-name":"test","grpc-user-agent":"bad\r\nvalue"}}),
     ] {
         assert!(Config::parse_yaml(&document(fields)).is_err());
     }
 }
+
+#[test]
+fn h2_omitted_and_empty_options_use_the_reference_authority() {
+    use vole::config::{ProxyProtocol, StreamTransport, VlessTransport};
+    for tls in [false, true] {
+        for options in [
+            json!({}),
+            json!({"h2-opts":{}}),
+            json!({"h2-opts":{"host":[],"path":""}}),
+        ] {
+            let mut fields = options;
+            fields["network"] = json!("h2");
+            fields["tls"] = json!(tls);
+            let config = Config::parse_yaml(&document(fields)).unwrap();
+            let ProxyProtocol::Vless(node) = &config.proxies[0].protocol else {
+                unreachable!()
+            };
+            let VlessTransport::Stream(StreamTransport::H2 { uris }) = &node.transport else {
+                unreachable!()
+            };
+            assert_eq!(
+                uris,
+                &[format!(
+                    "{}://www.example.com/",
+                    if tls { "https" } else { "http" }
+                )]
+            );
+        }
+    }
+}
diff --git a/tests/vless_lifecycle.rs b/tests/vless_lifecycle.rs
index 37fdd01..ca9b39c 100644
--- a/tests/vless_lifecycle.rs
+++ b/tests/vless_lifecycle.rs
@@ -41,11 +41,6 @@ impl OutboundConnector for SuppliedStream {
 
 #[tokio::test]
 async fn vless_all_handshakes_keep_the_original_deadline_and_join_cancelled_io() {
-    #[cfg(feature = "interop-test")]
-    let _evidence = vole::resources::case_events::Case::new(
-        "VLESS-CANCEL",
-        "vless_all_handshakes_keep_the_original_deadline_and_join_cancelled_io",
-    );
     use tokio::io::{AsyncReadExt, AsyncWriteExt};
     for mode in ["tcp", "tls", "ws", "grpc", "http", "h2", "vision", "xhttp"] {
         let mut node = serde_json::json!({"name":"edge","type":"vless","server":"fixture.invalid","port":443,"uuid":"07070707-0707-0707-0707-070707070707","network":if mode=="tls" || mode=="vision" {"tcp"}else{mode}});
@@ -69,7 +64,9 @@ async fn vless_all_handshakes_keep_the_original_deadline_and_join_cancelled_io()
         let ProxyProtocol::Vless(node) = &parsed.proxies[0].protocol else {
             unreachable!()
         };
-        let (io, mut peer) = tokio::io::duplex(65536);
+        // Keep request submission blocked; a fully committed request may wait
+        // for application data beyond the setup deadline.
+        let (io, mut peer) = tokio::io::duplex(1);
         let outbound = VlessOutbound::new_with_path(
             node,
             UpstreamPath::proxy(Arc::new(SuppliedStream {
@@ -78,6 +75,7 @@ async fn vless_all_handshakes_keep_the_original_deadline_and_join_cancelled_io()
         )
         .unwrap();
         let session = StreamSession {
+            metadata: Default::default(),
             inbound: InboundKind::InternalMeasure,
             source: "127.0.0.1:1".parse().unwrap(),
             destination: "192.0.2.2:80"
@@ -92,23 +90,28 @@ async fn vless_all_handshakes_keep_the_original_deadline_and_join_cancelled_io()
             if let Ok(mut connected) = outbound.connect_stream(session, &context).await {
                 let _ = connected.io.write_all(b"first").await;
                 let _ = connected.io.flush().await;
-                assert!(connected.io.read(&mut [0; 1]).await.is_err());
+                connected.io.read(&mut [0; 1]).await.is_err()
+            } else {
+                true
             }
         };
-        tokio::time::timeout(Duration::from_millis(325), task)
-            .await
-            .expect("consumer reset the original deadline");
-        assert!(start.elapsed() >= Duration::from_millis(240));
-        tokio::time::timeout(Duration::from_secs(1), outbound.shutdown())
-            .await
-            .unwrap();
+        let result = tokio::time::timeout(Duration::from_millis(325), task).await;
+        let elapsed = start.elapsed();
+        let stopped = tokio::time::timeout(Duration::from_secs(1), outbound.shutdown()).await;
         let mut observed = Vec::new();
-        tokio::time::timeout(Duration::from_secs(1), peer.read_to_end(&mut observed))
-            .await
-            .unwrap()
-            .unwrap();
+        let joined =
+            tokio::time::timeout(Duration::from_secs(1), peer.read_to_end(&mut observed)).await;
+        assert!(stopped.is_ok(), "{mode}: Core Stop did not join");
+        joined.expect("memory peer did not finish").unwrap();
+        let failed =
+            result.unwrap_or_else(|_| panic!("{mode}: consumer reset the original deadline"));
+        assert!(failed, "{mode}: unfinished setup accepted application data");
+        assert!(
+            elapsed >= Duration::from_millis(240),
+            "{mode}: setup ended early"
+        );
         assert!(!observed.is_empty());
-        assert!(observed.len() <= 65536);
+        assert!(observed.len() <= 1);
     }
 }
 
@@ -133,7 +136,7 @@ fn split_xhttp_construction_uses_default_stack_and_protect_failure_has_no_fallba
                 let protect=Arc::new(RejectProtect(AtomicUsize::new(0)));
                 let endpoint=ResolvedEndpoint {logical_host:"192.0.2.1".into(),port:443,addresses:vec!["192.0.2.1:443".parse().unwrap()]};
                 let outbound=VlessOutbound::new(config, endpoint, Dialer::default().with_protector(protect.clone())).unwrap();
-                let session=StreamSession {inbound:InboundKind::InternalMeasure,source:"127.0.0.1:1".parse().unwrap(),destination:"192.0.2.2:80".parse::<std::net::SocketAddr>().unwrap().into(),sniffed_domain:None};
+                let session=StreamSession {metadata: Default::default(),inbound:InboundKind::InternalMeasure,source:"127.0.0.1:1".parse().unwrap(),destination:"192.0.2.2:80".parse::<std::net::SocketAddr>().unwrap().into(),sniffed_domain:None};
                 assert!(outbound.connect_stream(session, &EstablishContext::default()).await.is_err());
                 assert!((1..=2).contains(&protect.0.load(Ordering::SeqCst)));
                 outbound.shutdown().await;
@@ -144,11 +147,6 @@ fn split_xhttp_construction_uses_default_stack_and_protect_failure_has_no_fallba
 
 #[tokio::test]
 async fn vless_expired_deadline_and_protect_failure_never_fall_back() {
-    #[cfg(feature = "interop-test")]
-    let _evidence = vole::resources::case_events::Case::new(
-        "VLESS-CANCEL",
-        "vless_expired_deadline_and_protect_failure_never_fall_back",
-    );
     let parsed = Config::parse_yaml(b"mixed-port: 1080\nproxies: [{name: edge, type: vless, server: 192.0.2.1, port: 443, uuid: 07070707-0707-0707-0707-070707070707}]\nrules: ['MATCH,edge']").unwrap();
     let ProxyProtocol::Vless(config) = &parsed.proxies[0].protocol else {
         unreachable!()
@@ -165,6 +163,7 @@ async fn vless_expired_deadline_and_protect_failure_never_fall_back() {
     )
     .unwrap();
     let session = StreamSession {
+        metadata: Default::default(),
         inbound: InboundKind::InternalMeasure,
         source: "127.0.0.1:1".parse().unwrap(),
         destination: "192.0.2.2:80"
diff --git a/tests/vless_transports.rs b/tests/vless_transports.rs
index 9b94cbe..430543b 100644
--- a/tests/vless_transports.rs
+++ b/tests/vless_transports.rs
@@ -13,6 +13,135 @@ use vole::{
     },
     session::{Destination, InboundKind, StreamSession},
 };
+
+#[cfg(feature = "interop-test")]
+#[tokio::test(start_paused = true)]
+async fn grpc_unresponsive_peer_keeps_original_setup_deadline() {
+    use std::io;
+    use vole::resources::observation::ResourceProbe;
+
+    fn preface_only(wire: &[u8]) -> bool {
+        if !wire.starts_with(b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n") {
+            return false;
+        }
+        let mut offset = 24;
+        while offset + 9 <= wire.len() {
+            let length = (usize::from(wire[offset]) << 16)
+                | (usize::from(wire[offset + 1]) << 8)
+                | usize::from(wire[offset + 2]);
+            let end = offset + 9 + length;
+            if end > wire.len() || matches!(wire[offset + 3], 0 | 1) {
+                return false;
+            }
+            offset = end;
+        }
+        offset == wire.len()
+    }
+
+    for first_operation in ["flush", "read"] {
+        let probe = ResourceProbe::default();
+        let (outcome, elapsed, deadline, stopped, joined) = probe
+            .scope(async {
+                let (io, mut peer) = tokio::io::duplex(4096);
+                let outbound = node(
+                    Box::new(io),
+                    serde_json::json!({"network":"grpc","grpc-opts":{"grpc-service-name":"service"}}),
+                );
+                // Consume continuously, but never send peer SETTINGS or EOF.
+                // Write backpressure cannot stand in for the H2 setup gate.
+                let mut remote = tokio::spawn(async move {
+                    let mut wire = Vec::new();
+                    let mut first_preface = None;
+                    let mut input = [0; 1024];
+                    loop {
+                        let count = peer.read(&mut input).await?;
+                        if count == 0 {
+                            return Ok::<_, io::Error>((wire, first_preface));
+                        }
+                        if wire.len() + count > 16 * 1024 {
+                            return Err(io::ErrorKind::InvalidData.into());
+                        }
+                        wire.extend_from_slice(&input[..count]);
+                        if wire.len() >= 24 && first_preface.is_none() {
+                            first_preface = Some(tokio::time::Instant::now());
+                        }
+                    }
+                });
+                let start = tokio::time::Instant::now();
+                let context = EstablishContext::with_timeout(Duration::from_secs(2));
+                let deadline = context.deadline();
+                let outcome = tokio::time::timeout(Duration::from_secs(3), async {
+                    match outbound.connect_stream(session(), &context).await {
+                        Err(error) => (
+                            "connect",
+                            matches!(error, DispatchError::TimedOut),
+                            format!("{error:?}"),
+                        ),
+                        Ok(mut connected) => {
+                            let result = if first_operation == "flush" {
+                                connected.io.flush().await
+                            } else {
+                                connected.io.read(&mut [0; 1]).await.map(|_| ())
+                            };
+                            (
+                                first_operation,
+                                result.as_ref().is_err_and(|error| error.kind() == io::ErrorKind::TimedOut),
+                                format!("{result:?}"),
+                            )
+                        }
+                    }
+                })
+                .await;
+                let elapsed = start.elapsed();
+                let stopped = tokio::time::timeout(Duration::from_secs(1), outbound.shutdown()).await;
+                let joined = match tokio::time::timeout(Duration::from_secs(1), &mut remote).await {
+                    Ok(result) => Some(result),
+                    Err(_) => {
+                        remote.abort();
+                        let _ = remote.await;
+                        None
+                    }
+                };
+                drop(outbound);
+                (outcome, elapsed, deadline, stopped, joined)
+            })
+            .await;
+        assert!(
+            stopped.is_ok(),
+            "{first_operation}: Core Stop watchdog expired"
+        );
+        assert!(
+            probe.snapshot().is_idle(),
+            "{first_operation}: resources retained after Stop: {:?}",
+            probe.snapshot()
+        );
+        assert!(
+            matches!(&joined, Some(Ok(Ok(_)))),
+            "{first_operation}: memory peer did not join naturally: {joined:?}"
+        );
+        let (wire, preface_at) = joined.unwrap().unwrap().unwrap();
+        assert!(
+            preface_at.is_some_and(|at| at < deadline),
+            "{first_operation}: peer did not drain the client preface before the deadline"
+        );
+        assert!(
+            preface_only(&wire),
+            "{first_operation}: logical request was sent without peer SETTINGS"
+        );
+        let (stage, timed_out, detail) =
+            outcome.expect("no-SETTINGS scenario reached its three-second watchdog");
+        assert!(
+            timed_out,
+            "{first_operation}: {stage} did not report the original setup timeout: {detail}"
+        );
+        assert_eq!(
+            elapsed,
+            Duration::from_secs(2),
+            "{first_operation}: setup deadline was changed; stage={stage}, outcome={detail}"
+        );
+    }
+}
+
 struct Supplied(Mutex<Option<BoxStream>>);
 #[async_trait::async_trait]
 impl OutboundConnector for Supplied {
@@ -57,6 +186,7 @@ fn node(io: BoxStream, extra: serde_json::Value) -> VlessOutbound {
 }
 fn session() -> StreamSession {
     StreamSession {
+        metadata: Default::default(),
         inbound: InboundKind::InternalMeasure,
         source: "127.0.0.1:1".parse().unwrap(),
         destination: Destination::Ip("192.0.2.1:80".parse().unwrap()),
@@ -66,11 +196,6 @@ fn session() -> StreamSession {
 
 #[tokio::test]
 async fn http_camouflage_shutdown_releases_both_directions_without_waiting_for_peer_eof() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "VLESS-UNIT",
-        "http_camouflage_shutdown_releases_both_directions_without_waiting_for_peer_eof",
-    );
     tokio::time::timeout(Duration::from_secs(2), async {
         let (io, mut peer) = tokio::io::duplex(4096);
         let node = node(Box::new(io), serde_json::json!({"network":"http"}));
@@ -118,11 +243,6 @@ async fn http_camouflage_shutdown_releases_both_directions_without_waiting_for_p
 
 #[tokio::test]
 async fn grpc_server_first_flushes_vless_request_without_an_application_write() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "VLESS-UNIT",
-        "grpc_server_first_flushes_vless_request_without_an_application_write",
-    );
     let (io, peer) = tokio::io::duplex(4096);
     let node = node(
         Box::new(io),
@@ -180,13 +300,231 @@ async fn grpc_server_first_flushes_vless_request_without_an_application_write()
         .expect("VLESS request was not flushed before waiting for the response");
     assert_eq!(&result.1, b"hello");
 }
+#[cfg(feature = "interop-test")]
+#[tokio::test(start_paused = true)]
+async fn grpc_committed_vless_request_outlives_delayed_http_response() {
+    use std::{
+        io,
+        sync::atomic::{AtomicUsize, Ordering},
+        task::{Context, Poll, Wake, Waker},
+    };
+    use vole::resources::observation::ResourceProbe;
+
+    #[derive(Default)]
+    struct ReadWake(AtomicUsize);
+    impl Wake for ReadWake {
+        fn wake(self: Arc<Self>) {
+            self.0.fetch_add(1, Ordering::SeqCst);
+        }
+        fn wake_by_ref(self: &Arc<Self>) {
+            self.0.fetch_add(1, Ordering::SeqCst);
+        }
+    }
+
+    let probe = ResourceProbe::default();
+    let (result, core_stopped, peer_joined) = probe
+        .scope(async {
+            let (io, peer) = tokio::io::duplex(4096);
+            let outbound = node(
+                Box::new(io),
+                serde_json::json!({"network":"grpc","grpc-opts":{"grpc-service-name":"service"}}),
+            );
+            let (records, mut observed) = tokio::sync::mpsc::unbounded_channel();
+            let mut remote = tokio::spawn(async move {
+                let mut connection = h2::server::handshake(peer)
+                    .await
+                    .map_err(io::Error::other)?;
+                let (request, response) = connection
+                    .accept()
+                    .await
+                    .ok_or(io::ErrorKind::UnexpectedEof)?
+                    .map_err(io::Error::other)?;
+                let receive = async move {
+                    // Hold the HTTP response open without sending headers.
+                    let _response = response;
+                    let mut receive = request.into_body();
+                    let mut wire = Vec::new();
+                    while let Some(Ok(data)) = receive.data().await {
+                        receive
+                            .flow_control()
+                            .release_capacity(data.len())
+                            .map_err(io::Error::other)?;
+                        wire.extend_from_slice(&data);
+                        while wire.len() >= 5 {
+                            let length =
+                                u32::from_be_bytes(wire[1..5].try_into().unwrap()) as usize;
+                            // This fixture sends only small, one-byte protobuf lengths.
+                            if wire[0] != 0 || !(2..=256).contains(&length) {
+                                return Err(io::ErrorKind::InvalidData.into());
+                            }
+                            if wire.len() < 5 + length {
+                                break;
+                            }
+                            if wire[5] != 0x0a || wire[6] >= 128 || wire[6] as usize + 2 != length {
+                                return Err(io::ErrorKind::InvalidData.into());
+                            }
+                            records
+                                .send(wire[7..5 + length].to_vec())
+                                .map_err(|_| io::ErrorKind::BrokenPipe)?;
+                            wire.drain(..5 + length);
+                        }
+                    }
+                    Ok::<_, io::Error>(())
+                };
+                tokio::pin!(receive);
+                // accept() drives H2 DATA while the handler waits for uploads.
+                tokio::select! {
+                    result = &mut receive => result,
+                    extra = connection.accept() => match extra {
+                        None | Some(Err(_)) => Ok(()),
+                        Some(Ok(_)) => Err(io::ErrorKind::InvalidData.into()),
+                    },
+                }
+            });
+            let context = EstablishContext::with_timeout(Duration::from_secs(2));
+            let result = tokio::time::timeout(Duration::from_secs(30), async {
+                let mut stream = outbound
+                    .connect_stream(session(), &context)
+                    .await
+                    .map_err(io::Error::other)?
+                    .io;
+                // The first operation commits the request, with no application payload.
+                stream.flush().await?;
+                let header = observed.recv().await.ok_or(io::ErrorKind::UnexpectedEof)?;
+                let expected = [
+                    b"\0".as_slice(),
+                    &[7; 16],
+                    b"\0\x01\0\x50\x01\xc0\0\x02\x01",
+                ]
+                .concat();
+                if header != expected {
+                    return Err(io::ErrorKind::InvalidData.into());
+                }
+                let (mut reader, mut writer) = tokio::io::split(stream);
+                writer.write_all(b"before").await?;
+                writer.flush().await?;
+                if observed.recv().await.as_deref() != Some(b"before".as_slice()) {
+                    return Err(io::ErrorKind::InvalidData.into());
+                }
+                let before_deadline = tokio::time::Instant::now() < context.deadline();
+                let mut byte = [0; 1];
+                let read = reader.read(&mut byte);
+                tokio::pin!(read);
+                let first = futures_util::poll!(read.as_mut());
+                let pending_before = matches!(first, Poll::Pending);
+                let after = if pending_before {
+                    tokio::time::advance(
+                        context
+                            .deadline()
+                            .saturating_duration_since(tokio::time::Instant::now())
+                            + Duration::from_millis(1),
+                    )
+                    .await;
+                    futures_util::poll!(read.as_mut())
+                } else {
+                    first
+                };
+                let pending_after = after.is_pending();
+                let boundary = format!("{after:?}");
+                let continued = if pending_after {
+                    writer.write_all(b"after").await?;
+                    writer.flush().await?;
+                    observed.recv().await.as_deref() == Some(b"after".as_slice())
+                } else {
+                    false
+                };
+                // Retain this exact read future across Stop. A separate waker
+                // distinguishes notification from a fresh post-Stop poll.
+                let wakes = Arc::new(ReadWake::default());
+                let stop_pending = pending_after && {
+                    let wake = Waker::from(wakes.clone());
+                    let mut cx = Context::from_waker(&wake);
+                    std::future::Future::poll(read.as_mut(), &mut cx).is_pending()
+                };
+                let wake_before = wakes.0.load(Ordering::SeqCst);
+                // Run Stop before assertions, including the expected RED path.
+                outbound.shutdown().await;
+                let read_woken = wakes.0.load(Ordering::SeqCst) > wake_before;
+                // Never poll a future that already completed on the RED path.
+                let stopped_read = if stop_pending {
+                    matches!(read.as_mut().await, Ok(0) | Err(_))
+                } else {
+                    !pending_after
+                };
+                let stopped_write = writer.write_all(b"after Stop").await.is_err();
+                Ok::<_, io::Error>((
+                    before_deadline,
+                    pending_before,
+                    pending_after,
+                    continued,
+                    stop_pending,
+                    read_woken,
+                    stopped_read,
+                    stopped_write,
+                    boundary,
+                ))
+            })
+            .await;
+            let core_stopped = tokio::time::timeout(Duration::from_secs(1), outbound.shutdown())
+                .await
+                .is_ok();
+            let peer_joined = match tokio::time::timeout(Duration::from_secs(1), &mut remote).await
+            {
+                Ok(result) => Some(result),
+                Err(_) => {
+                    remote.abort();
+                    let _ = remote.await;
+                    None
+                }
+            };
+            drop(outbound);
+            (result, core_stopped, peer_joined)
+        })
+        .await;
+    assert!(core_stopped, "Core Stop did not join its drivers");
+    assert!(
+        matches!(peer_joined, Some(Ok(Ok(())))),
+        "memory H2 peer did not join naturally: {peer_joined:?}"
+    );
+    assert!(
+        probe.snapshot().is_idle(),
+        "resources retained after cleanup: {:?}",
+        probe.snapshot()
+    );
+    let (
+        before_deadline,
+        pending_before,
+        pending_after,
+        continued,
+        stop_pending,
+        read_woken,
+        stopped_read,
+        stopped_write,
+        boundary,
+    ) = result
+        .expect("memory exchange timed out")
+        .expect("memory exchange failed");
+    assert!(stopped_read && stopped_write, "Stop left active gRPC IO");
+    assert!(
+        !pending_after || stop_pending,
+        "gRPC read completed before Stop"
+    );
+    assert!(
+        !pending_after || read_woken,
+        "Stop did not notify the pending gRPC read"
+    );
+    assert!(
+        before_deadline && pending_before,
+        "request was not established before the original deadline"
+    );
+    assert!(
+        pending_after && continued,
+        "committed VLESS gRPC expired at delayed response: {boundary}"
+    );
+}
+
 #[tokio::test]
 async fn http_upgrade_consumes_early_prefix_and_requires_valid_101_even_fast_open() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "VLESS-UNIT",
-        "http_upgrade_consumes_early_prefix_and_requires_valid_101_even_fast_open",
-    );
     use base64::Engine as _;
     for fast in [false, true] {
         for accept in [false, true] {
@@ -266,3 +604,315 @@ async fn http_upgrade_consumes_early_prefix_and_requires_valid_101_even_fast_ope
         }
     }
 }
+
+mod packetaddr_xhttp_memory {
+    use super::*;
+    use std::{future::Future, io, pin::Pin, task::Poll};
+    use tokio::sync::{mpsc, oneshot};
+    use tokio_util::sync::CancellationToken;
+    use vole::session::{Datagram, DatagramSession};
+
+    struct Post {
+        body: Vec<u8>,
+        acknowledge: oneshot::Sender<()>,
+    }
+
+    // Actual H2 request/response bodies drive the production PacketUp writer.
+    // Delaying this response is stronger than mocking poll_flush or a bool.
+    async fn peer(
+        raw: tokio::io::DuplexStream,
+        posts: mpsc::Sender<Post>,
+        mut replies: mpsc::Receiver<bytes::Bytes>,
+        mut stop: oneshot::Receiver<()>,
+    ) -> io::Result<()> {
+        let mut connection = h2::server::handshake(raw).await.map_err(io::Error::other)?;
+        let cancel = CancellationToken::new();
+        let mut handlers = tokio::task::JoinSet::new();
+        let mut download: Option<h2::SendStream<bytes::Bytes>> = None;
+        let result = async {
+            loop {
+                tokio::select! {
+                    _ = &mut stop => break,
+                    reply = replies.recv() => {
+                        let Some(reply) = reply else { break; };
+                        download.as_mut()
+                            .ok_or(io::ErrorKind::NotConnected)?
+                            .send_data(reply, false)
+                            .map_err(io::Error::other)?;
+                    }
+                    incoming = connection.accept() => {
+                        let Some(incoming) = incoming else { break; };
+                        let (request, mut response) = incoming.map_err(io::Error::other)?;
+                        if request.method() == http::Method::GET {
+                            if download.is_some() {
+                                return Err(io::ErrorKind::InvalidData.into());
+                            }
+                            download = Some(response
+                                .send_response(http::Response::new(()), false)
+                                .map_err(io::Error::other)?);
+                            continue;
+                        }
+                        if request.method() != http::Method::POST {
+                            return Err(io::ErrorKind::InvalidData.into());
+                        }
+                        let posts = posts.clone();
+                        let cancel = cancel.clone();
+                        handlers.spawn(async move {
+                            let mut input = request.into_body();
+                            let mut body = Vec::new();
+                            loop {
+                                let next = tokio::select! {
+                                    _ = cancel.cancelled() => return Ok::<(), io::Error>(()),
+                                    next = input.data() => next,
+                                };
+                                let Some(next) = next else { break; };
+                                let next = next.map_err(io::Error::other)?;
+                                if body.len() + next.len() > 8192 {
+                                    return Err(io::ErrorKind::InvalidData.into());
+                                }
+                                body.extend_from_slice(&next);
+                                input.flow_control().release_capacity(next.len())
+                                    .map_err(io::Error::other)?;
+                            }
+                            let (acknowledge, accepted) = oneshot::channel();
+                            tokio::select! {
+                                _ = cancel.cancelled() => return Ok(()),
+                                result = posts.send(Post {body, acknowledge}) => {
+                                    result.map_err(|_| io::ErrorKind::BrokenPipe)?;
+                                }
+                            }
+                            tokio::select! {
+                                _ = cancel.cancelled() => return Ok(()),
+                                result = accepted => {
+                                    if result.is_err() { return Ok(()); }
+                                }
+                            }
+                            response.send_response(http::Response::new(()), true)
+                                .map_err(io::Error::other)?;
+                            Ok(())
+                        });
+                    }
+                }
+            }
+            Ok::<(), io::Error>(())
+        }
+        .await;
+        cancel.cancel();
+        drop(download);
+        drop(connection);
+        while let Some(joined) = handlers.join_next().await {
+            joined.map_err(io::Error::other)??;
+        }
+        result
+    }
+
+    async fn next_post<F>(
+        send: &mut Pin<Box<F>>,
+        completed: &mut Option<Result<(), DispatchError>>,
+        posts: &mut mpsc::Receiver<Post>,
+    ) -> Result<Post, String>
+    where
+        F: Future<Output = Result<(), DispatchError>>,
+    {
+        tokio::time::timeout(Duration::from_secs(2), async {
+            if completed.is_none() {
+                tokio::select! {
+                    result = send.as_mut() => {
+                        *completed = Some(result);
+                        posts.recv().await
+                    }
+                    post = posts.recv() => post,
+                }
+            } else {
+                posts.recv().await
+            }
+        })
+        .await
+        .map_err(|_| "actual packet-up POST did not arrive".to_owned())?
+        .ok_or_else(|| "memory HTTP peer ended".to_owned())
+    }
+
+    fn packet(port: u16, data: &'static [u8]) -> Datagram {
+        Datagram {
+            remote: Destination::Ip(std::net::SocketAddr::from(([192, 0, 2, 1], port))),
+            payload: bytes::Bytes::from_static(data),
+            sniffed_domain: None,
+        }
+    }
+
+    fn wire(packet: &Datagram) -> Vec<u8> {
+        use bytes::BufMut;
+        let mut frame = bytes::BytesMut::new();
+        frame.put_u16(0);
+        vole::outbound::address::encode_packet_addr(&packet.remote, &mut frame).unwrap();
+        frame.extend_from_slice(&packet.payload);
+        let length = (frame.len() - 2) as u16;
+        frame[..2].copy_from_slice(&length.to_be_bytes());
+        frame.to_vec()
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn packetaddr_xhttp_keeps_first_flush_and_drives_last_datagram_without_post_ack() {
+        let (io, raw_peer) = tokio::io::duplex(64 * 1024);
+        let outbound = node(
+            Box::new(io),
+            serde_json::json!({
+                "network":"xhttp", "packet-encoding":"packetaddr",
+                "xhttp-opts":{
+                    "path":"/packetaddr-memory", "mode":"packet-up",
+                    "sc-min-posts-interval-ms":"10", "x-padding-bytes":"64"
+                }
+            }),
+        );
+        let (post_tx, mut posts) = mpsc::channel(4);
+        let (replies, reply_rx) = mpsc::channel(1);
+        let (stop, stopped) = oneshot::channel();
+        let mut remote = tokio::spawn(peer(raw_peer, post_tx, reply_rx, stopped));
+        let mut transport = None;
+        let observed = async {
+            let request = DatagramRequest::new(DatagramSession::new(
+                InboundKind::InternalMeasure,
+                "127.0.0.1:1".parse().unwrap(),
+            ));
+            transport = Some(
+                outbound
+                    .open_datagram(
+                        request,
+                        &EstablishContext::with_timeout(Duration::from_secs(30)),
+                    )
+                    .await
+                    .map_err(|error| format!("open_datagram: {error:?}"))?,
+            );
+            let client = transport.as_mut().unwrap();
+            let first = packet(53, b"first");
+            let last = packet(54, b"last");
+            let mut first_send = Box::pin(client.send(first.clone()));
+            let mut first_done = None;
+            let header = next_post(&mut first_send, &mut first_done, &mut posts).await?;
+            let expected_header = vole::outbound::encode_request_header(
+                uuid::Uuid::from_bytes([7; 16]),
+                vole::outbound::VlessCommand::Udp,
+                Some(&Destination::domain("sp.packet-addr.v2fly.arpa", 443).unwrap()),
+            )
+            .unwrap();
+            let header_exact = header.body.as_slice() == expected_header.as_ref();
+            let waits_for_header_ack = first_done.is_none();
+            header
+                .acknowledge
+                .send(())
+                .map_err(|_| "header POST disappeared")?;
+
+            let first_data = next_post(&mut first_send, &mut first_done, &mut posts).await?;
+            if first_done.is_none()
+                && let Poll::Ready(done) = futures_util::poll!(first_send.as_mut())
+            {
+                first_done = Some(done);
+            }
+            let first_exact = first_data.body == wire(&first);
+            let waits_for_first_data_ack = first_done.is_none();
+            first_data
+                .acknowledge
+                .send(())
+                .map_err(|_| "first data POST disappeared")?;
+            if first_done.is_none() {
+                first_done = Some(first_send.as_mut().await);
+            }
+            first_done
+                .unwrap()
+                .map_err(|error| format!("first send: {error:?}"))?;
+            drop(first_send);
+
+            // Exactly one final datagram follows the established first frame.
+            // No subsequent send/flush may accidentally drive its last bytes.
+            let mut last_send = Box::pin(client.send(last.clone()));
+            let mut last_done = None;
+            let final_post = next_post(&mut last_send, &mut last_done, &mut posts).await?;
+            if last_done.is_none()
+                && let Poll::Ready(done) = futures_util::poll!(last_send.as_mut())
+            {
+                last_done = Some(done);
+            }
+            let last_admitted_before_ack = matches!(&last_done, Some(Ok(())));
+            let last_exact = final_post.body == wire(&last);
+            drop(last_send);
+
+            // The synthetic server replies on the real GET response only after
+            // its actual POST body has arrived, while withholding that POST's
+            // HTTP acknowledgement. This detects a receive-side flush stall.
+            let mut response = vec![0, 0];
+            response.extend(wire(&last));
+            replies
+                .send(bytes::Bytes::from(response))
+                .await
+                .map_err(|_| "download stream disappeared")?;
+            let received = tokio::time::timeout(Duration::from_millis(100), client.receive()).await;
+            let reply_before_post_ack = matches!(&received, Ok(Ok(packet))
+                if packet.remote == last.remote && packet.payload == last.payload);
+            // A cancelled send must resume its pending frame and consume
+            // the already-present reply after the acknowledgement.
+            final_post
+                .acknowledge
+                .send(())
+                .map_err(|_| "final POST disappeared")?;
+            let recovered = match received {
+                Ok(Ok(packet)) => Some(packet),
+                Ok(Err(error)) => return Err(format!("receive: {error:?}")),
+                Err(_) => Some(
+                    tokio::time::timeout(Duration::from_secs(1), client.receive())
+                        .await
+                        .map_err(|_| "pending frame could not resume after POST ack")?
+                        .map_err(|error| format!("resumed receive: {error:?}"))?,
+                ),
+            };
+            let recovery_exact = recovered.is_some_and(|packet| {
+                packet.remote == last.remote && packet.payload == last.payload
+            });
+            Ok::<_, String>((
+                header_exact,
+                waits_for_header_ack,
+                first_exact,
+                waits_for_first_data_ack,
+                last_exact,
+                last_admitted_before_ack,
+                reply_before_post_ack,
+                recovery_exact,
+            ))
+        }
+        .await;
+
+        // Finish owned tasks before asserting the observed IO guarantees.
+        let core_stopped = tokio::time::timeout(Duration::from_secs(1), outbound.shutdown()).await;
+        drop(transport);
+        let _ = stop.send(());
+        let joined = match tokio::time::timeout(Duration::from_secs(1), &mut remote).await {
+            Ok(result) => Some(result),
+            Err(_) => {
+                remote.abort();
+                let _ = remote.await;
+                None
+            }
+        };
+        assert!(
+            core_stopped.is_ok(),
+            "Core Stop did not join its real PacketUp tasks"
+        );
+        assert!(
+            matches!(joined, Some(Ok(Ok(())))),
+            "owned memory HTTP peer failed/joined late"
+        );
+        let (header, header_flush, first, first_flush, last, admitted, reply, recovered) =
+            observed.unwrap();
+        assert!(
+            header && first && last && recovered,
+            "actual packetaddr bytes/source changed"
+        );
+        assert!(
+            header_flush && first_flush,
+            "setup/first frame bypassed real POST acknowledgement"
+        );
+        assert!(
+            admitted && reply,
+            "real POST body was received; send_before_ack={admitted}, reply_before_ack={reply}; established packetaddr still waits for POST acknowledgement"
+        );
+    }
+}
diff --git a/tests/vmess_codec.rs b/tests/vmess_codec.rs
index 2e5805b..a97098a 100644
--- a/tests/vmess_codec.rs
+++ b/tests/vmess_codec.rs
@@ -8,12 +8,7 @@ use vole::{
 };
 
 #[tokio::test]
-async fn xudp_cancelled_send_and_bad_frame_release_io_and_cannot_resume() {
-    #[cfg(feature = "interop-test")]
-    let _evidence = vole::resources::case_events::Case::new(
-        "VMESS-CODEC",
-        "xudp_cancelled_send_and_bad_frame_release_io_and_cannot_resume",
-    );
+async fn xudp_explicit_close_after_cancel_and_bad_frame_release_io() {
     use tokio::io::{AsyncReadExt, AsyncWriteExt};
     use vole::{dispatch::DatagramTransport, session::Datagram, xudp::XudpTransport};
     let (io, mut peer) = tokio::io::duplex(1);
@@ -34,6 +29,9 @@ async fn xudp_cancelled_send_and_bad_frame_release_io_and_cannot_resume() {
         .await
         .is_err()
     );
+    // Cancellation retains the pending XUDP frame for a later send/receive.
+    // Explicit close abandons it without inserting END into the partial frame.
+    client.close().await.unwrap();
     let mut wire = Vec::new();
     tokio::time::timeout(
         std::time::Duration::from_millis(100),
@@ -71,11 +69,7 @@ async fn xudp_cancelled_send_and_bad_frame_release_io_and_cannot_resume() {
             BodyOptions::new(BodyCipher::None, false, false).unwrap(),
         )
         .unwrap();
-        let stream = VmessStream::new(
-            Box::new(io),
-            handshake,
-            tokio::time::Instant::now() + std::time::Duration::from_secs(1),
-        );
+        let stream = VmessStream::new(Box::new(io), handshake);
         let budget = DatagramBudget::new(32, 32);
         let mut client = if packetaddr {
             VmessDatagram::packet_addr(stream, budget, ResolutionContext::default())
@@ -112,11 +106,6 @@ async fn xudp_cancelled_send_and_bad_frame_release_io_and_cannot_resume() {
 
 #[tokio::test]
 async fn xudp_zero_global_id_omits_the_optional_extension_like_mihomo() {
-    #[cfg(feature = "interop-test")]
-    let _evidence = vole::resources::case_events::Case::new(
-        "VMESS-CODEC",
-        "xudp_zero_global_id_omits_the_optional_extension_like_mihomo",
-    );
     use tokio::io::AsyncReadExt;
     use vole::{dispatch::DatagramTransport, session::Datagram, xudp::XudpTransport};
     let (io, mut peer) = tokio::io::duplex(128);
@@ -136,11 +125,6 @@ async fn xudp_zero_global_id_omits_the_optional_extension_like_mihomo() {
 
 #[test]
 fn packetaddr_has_ip_only_address_first_wire_and_rejects_truncation() {
-    #[cfg(feature = "interop-test")]
-    let _evidence = vole::resources::case_events::Case::new(
-        "VMESS-CODEC",
-        "packetaddr_has_ip_only_address_first_wire_and_rejects_truncation",
-    );
     use vole::outbound::address::{decode_packet_addr, encode_packet_addr};
     let peer = Destination::Ip("1.2.3.4:53".parse().unwrap());
     let mut wire = bytes::BytesMut::new();
@@ -171,11 +155,6 @@ fn packetaddr_has_ip_only_address_first_wire_and_rejects_truncation() {
 
 #[test]
 fn vmess_aead_requests_are_fresh_bounded_and_redacted() {
-    #[cfg(feature = "interop-test")]
-    let _evidence = vole::resources::case_events::Case::new(
-        "VMESS-CODEC",
-        "vmess_aead_requests_are_fresh_bounded_and_redacted",
-    );
     let identity = VmessIdentity::new(uuid::Uuid::from_bytes([7; 16]));
     let target = Destination::domain("fixture.invalid", 443).unwrap();
     let options = BodyOptions::new(BodyCipher::None, false, false).unwrap();
@@ -192,11 +171,6 @@ fn vmess_aead_requests_are_fresh_bounded_and_redacted() {
 
 #[tokio::test]
 async fn vmess_response_authentication_cannot_be_skipped_by_none_cipher() {
-    #[cfg(feature = "interop-test")]
-    let _evidence = vole::resources::case_events::Case::new(
-        "VMESS-CODEC",
-        "vmess_response_authentication_cannot_be_skipped_by_none_cipher",
-    );
     use tokio::io::{AsyncReadExt, AsyncWriteExt};
     let identity = VmessIdentity::new(uuid::Uuid::from_bytes([7; 16]));
     let target = Destination::domain("fixture.invalid", 443).unwrap();
@@ -208,11 +182,7 @@ async fn vmess_response_authentication_cannot_be_skipped_by_none_cipher() {
     )
     .unwrap();
     let (client, mut peer) = tokio::io::duplex(1024);
-    let mut stream = VmessStream::new(
-        Box::new(client),
-        handshake,
-        tokio::time::Instant::now() + std::time::Duration::from_secs(1),
-    );
+    let mut stream = VmessStream::new(Box::new(client), handshake);
     peer.write_all(&[0; 18]).await.unwrap();
     let mut data = [0; 1];
     assert_eq!(
@@ -224,11 +194,6 @@ async fn vmess_response_authentication_cannot_be_skipped_by_none_cipher() {
 
 #[tokio::test]
 async fn vmess_whole_close_wakes_reader_and_releases_io_before_response() {
-    #[cfg(feature = "interop-test")]
-    let _evidence = vole::resources::case_events::Case::new(
-        "VMESS-CODEC",
-        "vmess_whole_close_wakes_reader_and_releases_io_before_response",
-    );
     use tokio::io::{AsyncReadExt, AsyncWriteExt};
     let handshake = ClientHandshake::new(
         &VmessIdentity::new(uuid::Uuid::from_bytes([7; 16])),
@@ -238,12 +203,7 @@ async fn vmess_whole_close_wakes_reader_and_releases_io_before_response() {
     )
     .unwrap();
     let (io, mut peer) = tokio::io::duplex(1024);
-    let stream = VmessStream::new(
-        Box::new(io),
-        handshake,
-        tokio::time::Instant::now() + std::time::Duration::from_secs(1),
-    )
-    .with_whole_close();
+    let stream = VmessStream::new(Box::new(io), handshake).with_whole_close();
     let (mut reader, mut writer) = tokio::io::split(stream);
     let mut byte = [0; 1];
     let read = reader.read(&mut byte);
@@ -263,11 +223,6 @@ async fn vmess_whole_close_wakes_reader_and_releases_io_before_response() {
 }
 #[tokio::test]
 async fn xudp_explicit_budget_rejects_max_plus_one_before_writing() {
-    #[cfg(feature = "interop-test")]
-    let _evidence = vole::resources::case_events::Case::new(
-        "VMESS-CODEC",
-        "xudp_explicit_budget_rejects_max_plus_one_before_writing",
-    );
     use vole::{
         dispatch::{DatagramBudget, DatagramTransport},
         session::Datagram,
diff --git a/tests/vmess_config.rs b/tests/vmess_config.rs
index a50023a..217728d 100644
--- a/tests/vmess_config.rs
+++ b/tests/vmess_config.rs
@@ -12,14 +12,11 @@ fn document(extra: Value) -> Vec<u8> {
 
 #[test]
 fn vmess_default_node_and_explicit_cipher_aliases_are_accepted_without_io() {
-    #[cfg(feature = "interop-test")]
-    let _evidence = vole::resources::case_events::Case::new(
-        "VMESS-CFG",
-        "vmess_default_node_and_explicit_cipher_aliases_are_accepted_without_io",
-    );
     let parsed = Config::parse_yaml(&document(json!({}))).expect("VMess default node");
-    assert_eq!(parsed.proxies[0].address(), "example.com");
-    assert_eq!(parsed.proxies[0].port(), 443);
+    assert_eq!(
+        parsed.proxies[0].server_endpoint(),
+        Some(("example.com", 443))
+    );
     assert!(!parsed.proxies[0].udp);
     for cipher in ["auto", "aes-128-gcm", "chacha20-poly1305", "none", "zero"] {
         assert!(
@@ -27,15 +24,31 @@ fn vmess_default_node_and_explicit_cipher_aliases_are_accepted_without_io() {
         );
     }
     assert!(!format!("{parsed:?}").contains("07070707"));
+    for (input, expected) in [
+        (
+            "07070707070707070707070707070707",
+            "07070707-0707-0707-0707-070707070707",
+        ),
+        (
+            "{07070707-0707-0707-0707-070707070707}",
+            "07070707-0707-0707-0707-070707070707",
+        ),
+        (
+            "urn:uuid:07070707-0707-0707-0707-070707070707",
+            "07070707-0707-0707-0707-070707070707",
+        ),
+        ("invalid-secret", "29a5f9ec-d914-56e3-a82c-19b9150f2a91"),
+    ] {
+        let parsed = Config::parse_yaml(&document(json!({"uuid":input}))).unwrap();
+        let vole::config::ProxyProtocol::Vmess(node) = &parsed.proxies[0].protocol else {
+            unreachable!()
+        };
+        assert_eq!(node.id.hyphenated().to_string(), expected);
+    }
 }
 
 #[test]
 fn vmess_transport_and_security_combinations_are_strict() {
-    #[cfg(feature = "interop-test")]
-    let _evidence = vole::resources::case_events::Case::new(
-        "VMESS-CFG",
-        "vmess_transport_and_security_combinations_are_strict",
-    );
     for tls in [false, true] {
         for (network, options) in [
             ("tcp", json!({})),
@@ -66,25 +79,20 @@ fn vmess_transport_and_security_combinations_are_strict() {
     }
     for fields in [
         json!({"alterId":1}),
-        json!({"uuid":"invalid-secret"}),
         json!({"cipher":"none","global-padding":true}),
         json!({"cipher":"zero","authenticated-length":true}),
         json!({"network":"bogus"}),
-        json!({"network":"h2"}),
-        json!({"network":"grpc"}),
         json!({"tls":false,"servername":"secret.invalid"}),
         json!({"tls":false,"skip-cert-verify":false}),
         json!({"tls":false,"alpn":[]}),
         json!({"packet-encoding":"packet"}),
         json!({"ws-opts":{}}),
         json!({"http-opts":{}}),
-        json!({"network":"h2","h2-opts":{"host":[]}}),
         json!({"network":"http","http-opts":{"method":"GET\r\n"}}),
         json!({"network":"http","http-opts":{"headers":{"Content-Length":["1"]}}}),
         json!({"network":"http","http-opts":{"headers":{"X-Test":[]}}}),
-        json!({"network":"ws","ws-opts":{"max-early-data":2049}}),
+        json!({"network":"ws","ws-opts":{"max-early-data":65536}}),
         json!({"network":"ws","tls":true,"alpn":["h2"]}),
-        json!({"network":"grpc","grpc-opts":{"grpc-service-name":""}}),
     ] {
         assert!(
             Config::parse_yaml(&document(fields.clone())).is_err(),
@@ -124,17 +132,11 @@ fn vmess_transport_and_security_combinations_are_strict() {
 
 #[tokio::test]
 async fn vmess_field_boundaries_and_normalized_transport_values() {
-    #[cfg(feature = "interop-test")]
-    let _evidence = vole::resources::case_events::Case::new(
-        "VMESS-CFG",
-        "vmess_field_boundaries_and_normalized_transport_values",
-    );
     use vole::config::{ProxyProtocol, VmessTransport};
     for fields in [
         json!({"server":""}),
         json!({"port":0}),
         json!({"port":65536}),
-        json!({"uuid":"07070707070707070707070707070707"}),
         json!({"network":"ws","ws-opts":{"headers":{"Host":"cover.example:bogus"}}}),
         json!({"network":"h2","h2-opts":{"host":["cover.example:"]}}),
         json!({"network":"http","http-opts":{"headers":{"Host":["cover.example:65536"]}}}),
@@ -229,11 +231,6 @@ async fn vmess_field_boundaries_and_normalized_transport_values() {
 
 #[tokio::test]
 async fn vmess_normalized_websocket_fields_preserve_headers_and_early_data_order() {
-    #[cfg(feature = "interop-test")]
-    let _evidence = vole::resources::case_events::Case::new(
-        "VMESS-CFG",
-        "vmess_normalized_websocket_fields_preserve_headers_and_early_data_order",
-    );
     use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD};
     use futures_util::StreamExt;
     use tokio::io::AsyncWriteExt;
@@ -241,6 +238,7 @@ async fn vmess_normalized_websocket_fields_preserve_headers_and_early_data_order
         (0, None),
         (1, None),
         (2048, None),
+        (2049, None),
         (2048, Some("X-Early")),
         (2048, Some("")),
     ] {
@@ -311,3 +309,66 @@ async fn vmess_normalized_websocket_fields_preserve_headers_and_early_data_order
         reader.await.unwrap();
     }
 }
+
+#[test]
+fn stream_defaults_and_grpc_authority_match_the_reference() {
+    use vole::config::{ProxyProtocol, StreamTransport};
+    for tls in [false, true] {
+        for options in [
+            json!({}),
+            json!({"h2-opts":{}}),
+            json!({"h2-opts":{"host":[],"path":""}}),
+        ] {
+            let mut fields = options;
+            fields["network"] = json!("h2");
+            fields["tls"] = json!(tls);
+            let config = Config::parse_yaml(&document(fields)).unwrap();
+            let ProxyProtocol::Vmess(node) = &config.proxies[0].protocol else {
+                unreachable!()
+            };
+            let StreamTransport::H2 { uris } = &node.transport else {
+                unreachable!()
+            };
+            assert_eq!(
+                uris,
+                &[format!(
+                    "{}://www.example.com/",
+                    if tls { "https" } else { "http" }
+                )]
+            );
+        }
+    }
+    for (name, authority) in [
+        (None, "example.com:443"),
+        (Some(""), "example.com:443"),
+        (Some("cover.example"), "cover.example"),
+        (Some("2001:db8::1"), "[2001:db8::1]"),
+    ] {
+        let mut fields = json!({"network":"grpc","tls":true,"name-cert-verify":"verified.example"});
+        if let Some(name) = name {
+            fields["servername"] = json!(name);
+        }
+        let config = Config::parse_yaml(&document(fields)).unwrap();
+        let ProxyProtocol::Vmess(node) = &config.proxies[0].protocol else {
+            unreachable!()
+        };
+        let StreamTransport::Grpc { uri, .. } = &node.transport else {
+            unreachable!()
+        };
+        assert_eq!(
+            uri.parse::<http::Uri>()
+                .unwrap()
+                .authority()
+                .unwrap()
+                .as_str(),
+            authority
+        );
+    }
+    for fields in [
+        json!({"network":""}),
+        json!({"network":"ws","ws-opts":{"path":""}}),
+        json!({"network":"http","http-opts":{"method":""}}),
+    ] {
+        Config::parse_yaml(&document(fields)).unwrap();
+    }
+}
diff --git a/tests/vmess_lifecycle.rs b/tests/vmess_lifecycle.rs
index 932c824..8ce2fb4 100644
--- a/tests/vmess_lifecycle.rs
+++ b/tests/vmess_lifecycle.rs
@@ -41,22 +41,10 @@ impl OutboundConnector for SuppliedStream {
 
 #[tokio::test]
 async fn vmess_all_handshakes_keep_the_original_deadline_and_join_cancelled_io() {
-    #[cfg(feature = "interop-test")]
-    let _evidence = vole::resources::case_events::Case::new(
-        "VMESS-CANCEL",
-        "vmess_all_handshakes_keep_the_original_deadline_and_join_cancelled_io",
-    );
     use tokio::io::{AsyncReadExt, AsyncWriteExt};
-    for mode in [
-        "tcp",
-        "tls",
-        "ws",
-        "grpc",
-        "http",
-        "h2",
-        "upgrade",
-        "upgrade-fast",
-    ] {
+    // Plain TCP has already submitted its request before business IO;
+    // a delayed VMess response is not an unfinished transport handshake.
+    for mode in ["tls", "ws", "grpc", "http", "h2", "upgrade", "upgrade-fast"] {
         let network = if mode == "tls" {
             "tcp"
         } else if mode.starts_with("upgrade") {
@@ -85,7 +73,10 @@ async fn vmess_all_handshakes_keep_the_original_deadline_and_join_cancelled_io()
         let ProxyProtocol::Vmess(node) = &parsed.proxies[0].protocol else {
             unreachable!()
         };
-        let (io, mut peer) = tokio::io::duplex(65536);
+        // HTTP's request prefix stays unsubmitted. The other transports still
+        // reach their original handshake-response or HTTP/2 SETTINGS wait.
+        let capacity = if mode == "http" { 1 } else { 65536 };
+        let (io, mut peer) = tokio::io::duplex(capacity);
         let outbound = VmessOutbound::new_with_path(
             node,
             UpstreamPath::proxy(Arc::new(SuppliedStream {
@@ -94,6 +85,7 @@ async fn vmess_all_handshakes_keep_the_original_deadline_and_join_cancelled_io()
         )
         .unwrap();
         let session = StreamSession {
+            metadata: Default::default(),
             inbound: InboundKind::InternalMeasure,
             source: "127.0.0.1:1".parse().unwrap(),
             destination: "192.0.2.2:80"
@@ -111,20 +103,18 @@ async fn vmess_all_handshakes_keep_the_original_deadline_and_join_cancelled_io()
                 assert!(connected.io.read(&mut [0; 1]).await.is_err());
             }
         };
-        tokio::time::timeout(Duration::from_millis(325), task)
-            .await
-            .expect("consumer reset the original deadline");
-        assert!(start.elapsed() >= Duration::from_millis(240));
-        tokio::time::timeout(Duration::from_secs(1), outbound.shutdown())
-            .await
-            .unwrap();
+        let result = tokio::time::timeout(Duration::from_millis(325), task).await;
+        let elapsed = start.elapsed();
+        let stopped = tokio::time::timeout(Duration::from_secs(1), outbound.shutdown()).await;
         let mut observed = Vec::new();
-        tokio::time::timeout(Duration::from_secs(1), peer.read_to_end(&mut observed))
-            .await
-            .unwrap()
-            .unwrap();
+        let joined =
+            tokio::time::timeout(Duration::from_secs(1), peer.read_to_end(&mut observed)).await;
+        stopped.expect("Core Stop did not join");
+        joined.expect("memory peer did not finish").unwrap();
+        result.expect("consumer reset the original deadline");
+        assert!(elapsed >= Duration::from_millis(240));
         assert!(!observed.is_empty());
-        assert!(observed.len() <= 65536);
+        assert!(observed.len() <= capacity);
     }
 }
 
@@ -138,11 +128,6 @@ impl SocketProtector for RejectProtect {
 
 #[tokio::test]
 async fn vmess_expired_deadline_and_protect_failure_never_fall_back() {
-    #[cfg(feature = "interop-test")]
-    let _evidence = vole::resources::case_events::Case::new(
-        "VMESS-CANCEL",
-        "vmess_expired_deadline_and_protect_failure_never_fall_back",
-    );
     let parsed = Config::parse_yaml(b"mixed-port: 1080\nproxies: [{name: edge, type: vmess, server: 192.0.2.1, port: 443, uuid: 07070707-0707-0707-0707-070707070707}]\nrules: ['MATCH,edge']").unwrap();
     let ProxyProtocol::Vmess(config) = &parsed.proxies[0].protocol else {
         unreachable!()
@@ -159,6 +144,7 @@ async fn vmess_expired_deadline_and_protect_failure_never_fall_back() {
     )
     .unwrap();
     let session = StreamSession {
+        metadata: Default::default(),
         inbound: InboundKind::InternalMeasure,
         source: "127.0.0.1:1".parse().unwrap(),
         destination: "192.0.2.2:80"
@@ -193,3 +179,54 @@ async fn vmess_expired_deadline_and_protect_failure_never_fall_back() {
     );
     assert_eq!(protect.0.load(Ordering::SeqCst), 1);
 }
+
+// This tests the actual outbound call site and complete-request submission,
+// rather than retaining a post-establishment response-header timeout.
+#[tokio::test(start_paused = true)]
+async fn vmess_unsubmitted_request_keeps_original_deadline_and_releases_partial_io() {
+    use tokio::io::AsyncReadExt;
+
+    let parsed = Config::parse_yaml(br#"proxies:
+  - {name: edge, type: vmess, server: fixture.invalid, port: 443, uuid: 07070707-0707-0707-0707-070707070707}
+rules: ['MATCH,edge']
+"#).unwrap();
+    let ProxyProtocol::Vmess(node) = &parsed.proxies[0].protocol else {
+        unreachable!()
+    };
+    // A complete authenticated VMess request cannot fit this unread pipe.
+    let (io, mut peer) = tokio::io::duplex(1);
+    let outbound = VmessOutbound::new_with_path(
+        node,
+        UpstreamPath::proxy(Arc::new(SuppliedStream {
+            io: std::sync::Mutex::new(Some(io)),
+        })),
+    )
+    .unwrap();
+    let session = StreamSession {
+        metadata: Default::default(),
+        inbound: InboundKind::InternalMeasure,
+        source: "127.0.0.1:1".parse().unwrap(),
+        destination: "192.0.2.2:80"
+            .parse::<std::net::SocketAddr>()
+            .unwrap()
+            .into(),
+        sniffed_domain: None,
+    };
+    let context = EstablishContext::with_timeout(Duration::from_millis(250));
+    {
+        let connect = outbound.connect_stream(session, &context);
+        tokio::pin!(connect);
+        assert!(futures_util::poll!(connect.as_mut()).is_pending());
+        tokio::time::advance(Duration::from_millis(151)).await;
+        assert!(futures_util::poll!(connect.as_mut()).is_pending());
+        tokio::time::advance(Duration::from_millis(100)).await;
+        assert!(
+            connect.await.is_err(),
+            "request-prefix timeout cannot be released before successful submission"
+        );
+    }
+    outbound.shutdown().await;
+    let mut prefix = Vec::new();
+    peer.read_to_end(&mut prefix).await.unwrap();
+    assert_eq!(prefix.len(), 1);
+}
diff --git a/tests/xhttp_budget.rs b/tests/xhttp_budget.rs
index 45ec597..a573054 100644
--- a/tests/xhttp_budget.rs
+++ b/tests/xhttp_budget.rs
@@ -26,6 +26,10 @@ struct Transport {
 }
 #[async_trait::async_trait]
 impl DatagramTransport for Transport {
+    fn supports_shared_destinations(&self) -> bool {
+        false
+    }
+
     async fn send(&mut self, _: Datagram) -> Result<(), DispatchError> {
         self.sends.fetch_add(1, Ordering::SeqCst);
         Err(io::Error::from(io::ErrorKind::NotConnected).into())
@@ -67,11 +71,6 @@ impl OutboundConnector for Upstream {
 }
 #[tokio::test]
 async fn h3_rejects_incapable_or_small_budget_upstreams_before_any_datagram() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "h3_rejects_incapable_or_small_budget_upstreams_before_any_datagram",
-    );
     let config=Config::parse_yaml(b"mixed-port: 1080\nproxies: [{name: edge, type: vless, server: 192.0.2.1, port: 443, uuid: 07070707-0707-0707-0707-070707070707, tls: true, network: xhttp, alpn: [h3]}]\nrules: ['MATCH,edge']").unwrap();
     let ProxyProtocol::Vless(config) = &config.proxies[0].protocol else {
         unreachable!()
@@ -86,6 +85,7 @@ async fn h3_rejects_incapable_or_small_budget_upstreams_before_any_datagram() {
         let result = outbound
             .connect_stream(
                 StreamSession {
+                    metadata: Default::default(),
                     inbound: InboundKind::InternalMeasure,
                     source: "127.0.0.1:1".parse().unwrap(),
                     destination: "192.0.2.2:80"
diff --git a/tests/xhttp_config.rs b/tests/xhttp_config.rs
index 4e5b339..1a64b34 100644
--- a/tests/xhttp_config.rs
+++ b/tests/xhttp_config.rs
@@ -1,7 +1,7 @@
 #![cfg(feature = "outbound-vless")]
 
 use serde_json::{Value, json};
-use vole::config::{Config, ProxyProtocol};
+use vole::config::{Config, ProxyProtocol, XHttpMode};
 
 fn document(options: Value) -> Vec<u8> {
     serde_json::to_vec(&json!({
@@ -52,11 +52,6 @@ fn xhttp_authorities_reject_userinfo_on_both_legs_without_echoing_it() {
 
 #[test]
 fn xhttp_fields_reject_wrong_types_null_and_every_range_boundary_before_io() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "xhttp_fields_reject_wrong_types_null_and_every_range_boundary_before_io",
-    );
     let fields = [
         "host",
         "path",
@@ -85,7 +80,7 @@ fn xhttp_fields_reject_wrong_types_null_and_every_range_boundary_before_io() {
         "download-settings",
     ];
     for field in fields {
-        for value in [Value::Null, json!([]), json!(42)] {
+        for value in [Value::Null, json!([]), json!(42.5)] {
             assert!(
                 Config::parse_yaml(&document(json!({field:value}))).is_err(),
                 "accepted invalid type for {field}: {value}"
@@ -131,7 +126,13 @@ fn xhttp_fields_reject_wrong_types_null_and_every_range_boundary_before_io() {
         ),
         ("session-length", 10, 128, json!({"session-table":"number"})),
     ] {
-        for value in [low.to_string(), high.to_string(), format!("{low}-{high}")] {
+        for value in [
+            low.to_string(),
+            high.to_string(),
+            format!("{low}-{high}"),
+            format!(" +{low} "),
+            format!(" +{low} - +{high} "),
+        ] {
             let mut options = extra.clone();
             options[field] = json!(value);
             assert!(
@@ -144,9 +145,7 @@ fn xhttp_fields_reject_wrong_types_null_and_every_range_boundary_before_io() {
             "-1".into(),
             "1-0".into(),
             "1.0".into(),
-            " 1".into(),
             "1-2-3".into(),
-            String::new(),
         ] {
             let mut options = extra.clone();
             options[field] = json!(value);
@@ -201,12 +200,143 @@ fn xhttp_fields_reject_wrong_types_null_and_every_range_boundary_before_io() {
 }
 
 #[test]
-fn empty_http_authority_falls_back_to_each_legs_authentication_name() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "empty_http_authority_falls_back_to_each_legs_authentication_name",
+fn xhttp_numeric_upload_fields_match_strings_and_retain_bounds() {
+    let numeric = json!({
+        "uplink-data-placement": "header", "uplink-data-key": "data",
+        "uplink-chunk-size": 1024,
+        "sc-max-each-post-bytes": 4096,
+        "sc-min-posts-interval-ms": 1
+    });
+    let fields = [
+        "uplink-chunk-size",
+        "sc-max-each-post-bytes",
+        "sc-min-posts-interval-ms",
+    ];
+    let mut quoted = numeric.clone();
+    for field in fields {
+        quoted[field] = json!(quoted[field].as_u64().unwrap().to_string());
+    }
+    let numeric_config = Config::parse_yaml(&document(numeric.clone())).unwrap();
+    let quoted_config = Config::parse_yaml(&document(quoted)).unwrap();
+    assert_eq!(
+        numeric_config.proxies[0].protocol,
+        quoted_config.proxies[0].protocol
     );
+
+    for (field, low, high) in [
+        ("uplink-chunk-size", 0, 8192),
+        ("sc-max-each-post-bytes", 1, 16 * 1024 * 1024),
+        ("sc-min-posts-interval-ms", 1, 60000),
+    ] {
+        for value in [low, high] {
+            let mut options = numeric.clone();
+            options[field] = json!(value);
+            assert!(Config::parse_yaml(&document(options)).is_ok());
+        }
+        for value in [
+            json!(low - 1),
+            json!(high + 1),
+            json!(-1),
+            json!(u64::MAX),
+            json!(true),
+        ] {
+            let mut options = numeric.clone();
+            options[field] = value;
+            assert!(Config::parse_yaml(&document(options)).is_err());
+        }
+    }
+    let mut adaptive = numeric;
+    adaptive["uplink-chunk-size"] = json!(0);
+    assert!(Config::parse_yaml(&document(adaptive)).is_ok());
+}
+
+#[test]
+fn xhttp_empty_mode_path_and_download_name_use_each_legs_defaults() {
+    let config = Config::parse_yaml(&document(json!({"mode":"", "path":""}))).unwrap();
+    let ProxyProtocol::Vless(node) = &config.proxies[0].protocol else {
+        unreachable!()
+    };
+    assert_eq!(node.xhttp().unwrap().mode, XHttpMode::PacketUp);
+    assert_eq!(node.xhttp().unwrap().path, "/");
+
+    let mut input: Value = serde_json::from_slice(&document(json!({
+        "path":"/upload",
+        "download-settings":{"server":"download.example.com", "path":"", "servername":""}
+    })))
+    .unwrap();
+    input["proxies"][0]["servername"] = json!("parent.invalid");
+    let config = Config::parse_yaml(&serde_json::to_vec(&input).unwrap()).unwrap();
+    let ProxyProtocol::Vless(node) = &config.proxies[0].protocol else {
+        unreachable!()
+    };
+    assert_eq!(node.xhttp().unwrap().path, "/upload");
+    assert_eq!(node.xhttp().unwrap().host, "parent.invalid");
+    let download = node.download().unwrap();
+    assert_eq!(download.path, "/");
+    assert_eq!(download.security.server_name(), "download.example.com");
+    assert_eq!(download.host, "download.example.com");
+}
+
+#[test]
+fn xhttp_empty_request_and_pool_fields_restore_their_defaults() {
+    let expected = Config::parse_yaml(&document(json!({}))).unwrap();
+    let ProxyProtocol::Vless(expected_node) = &expected.proxies[0].protocol else {
+        unreachable!()
+    };
+    let actual = Config::parse_yaml(&document(json!({
+        "uplink-http-method":"",
+        "session-placement":"", "session-key":"", "session-length":" \t ",
+        "seq-placement":"", "seq-key":"",
+        "uplink-data-placement":"", "uplink-data-key":"", "uplink-chunk-size":" \t ",
+        "x-padding-bytes":" \t ", "x-padding-key":"", "x-padding-header":"",
+        "x-padding-placement":"", "x-padding-method":"",
+        "sc-max-each-post-bytes":" \t ", "sc-min-posts-interval-ms":""
+    })))
+    .unwrap();
+    let ProxyProtocol::Vless(actual_node) = &actual.proxies[0].protocol else {
+        unreachable!()
+    };
+    assert_eq!(
+        expected_node.xhttp().unwrap().request,
+        actual_node.xhttp().unwrap().request
+    );
+    for download in [false, true] {
+        let expected_options = if download {
+            json!({"download-settings":{"reuse-settings":{}}})
+        } else {
+            json!({"reuse-settings":{}})
+        };
+        let mut options = json!({"reuse-settings":{
+            "max-concurrency":"", "max-connections":" \t ", "c-max-reuse-times":"",
+            "h-max-request-times":"", "h-max-reusable-secs":" \t "
+        }});
+        if download {
+            options = json!({"download-settings":options});
+        }
+        let expected = Config::parse_yaml(&document(expected_options)).unwrap();
+        let actual = Config::parse_yaml(&document(options)).unwrap();
+        let (ProxyProtocol::Vless(expected), ProxyProtocol::Vless(actual)) =
+            (&expected.proxies[0].protocol, &actual.proxies[0].protocol)
+        else {
+            unreachable!()
+        };
+        let (expected, actual) = if download {
+            (
+                &expected.download().unwrap().reuse,
+                &actual.download().unwrap().reuse,
+            )
+        } else {
+            (
+                &expected.xhttp().unwrap().reuse,
+                &actual.xhttp().unwrap().reuse,
+            )
+        };
+        assert_eq!(expected, actual);
+    }
+}
+
+#[test]
+fn empty_http_authority_falls_back_to_each_legs_authentication_name() {
     for (host, down_host, up, down) in [
         ("", None, "example.com", "download.example.com"),
         (
@@ -238,11 +368,6 @@ fn empty_http_authority_falls_back_to_each_legs_authentication_name() {
 
 #[test]
 fn download_security_changes_do_not_silently_discard_inherited_certificate_policy() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "download_security_changes_do_not_silently_discard_inherited_certificate_policy",
-    );
     for download in [
         json!({"tls":false}),
         json!({"reality-opts":{"public-key":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"}}),
@@ -269,11 +394,6 @@ fn download_security_changes_do_not_silently_discard_inherited_certificate_polic
 
 #[test]
 fn h3_requires_exclusive_alpn_and_standard_tls_on_each_leg() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "h3_requires_exclusive_alpn_and_standard_tls_on_each_leg",
-    );
     let mut value: Value =
         serde_json::from_slice(&document(json!({"download-settings":{"alpn":["h3"]}}))).unwrap();
     value["proxies"][0]["alpn"] = json!(["h3"]);
@@ -305,11 +425,6 @@ fn h3_requires_exclusive_alpn_and_standard_tls_on_each_leg() {
 
 #[test]
 fn custom_headers_inherit_replace_clear_and_do_not_leak_values() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "custom_headers_inherit_replace_clear_and_do_not_leak_values",
-    );
     for (download, expected) in [
         (json!({}), Some("private-upload-value")),
         (
@@ -347,11 +462,6 @@ fn custom_headers_inherit_replace_clear_and_do_not_leak_values() {
 
 #[test]
 fn conflicting_request_fields_are_rejected_on_both_legs_before_io() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "conflicting_request_fields_are_rejected_on_both_legs_before_io",
-    );
     for options in [
         json!({"session-placement":"header","download-settings":{"headers":{"x-session":"override"}}}),
         json!({"x-padding-obfs-mode":true,"x-padding-placement":"header","x-padding-header":"X-Pad","download-settings":{"headers":{"x-pad":"override"}}}),
@@ -370,11 +480,6 @@ fn conflicting_request_fields_are_rejected_on_both_legs_before_io() {
 
 #[test]
 fn http_version_selects_h1_only_for_its_single_alpn_and_supports_plaintext() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "http_version_selects_h1_only_for_its_single_alpn_and_supports_plaintext",
-    );
     use vole::config::{SecurityConfig, XHttpVersion};
     for tls in [true, false] {
         for (alpn, version) in [
@@ -411,11 +516,6 @@ fn http_version_selects_h1_only_for_its_single_alpn_and_supports_plaintext() {
 
 #[test]
 fn download_certificate_policy_inherits_and_explicit_false_or_empty_clears() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "download_certificate_policy_inherits_and_explicit_false_or_empty_clears",
-    );
     use vole::config::SecurityConfig;
     for clear in [false, true] {
         let download = if clear {
@@ -459,11 +559,6 @@ fn download_certificate_policy_inherits_and_explicit_false_or_empty_clears() {
 
 #[test]
 fn download_mtls_identity_is_inherited_or_replaced_and_cleared_as_a_pair() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "download_mtls_identity_is_inherited_or_replaced_and_cleared_as_a_pair",
-    );
     use base64::Engine as _;
     use vole::config::SecurityConfig;
     let identity = |name: &str| {
@@ -519,11 +614,6 @@ fn download_mtls_identity_is_inherited_or_replaced_and_cleared_as_a_pair() {
 
 #[test]
 fn download_reality_object_replaces_inherits_or_clears_without_merging_keys() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "download_reality_object_replaces_inherits_or_clears_without_merging_keys",
-    );
     use base64::Engine as _;
     use vole::config::SecurityConfig;
     let key = base64::engine::general_purpose::URL_SAFE_NO_PAD.encode([7; 32]);
@@ -572,11 +662,6 @@ fn download_reality_object_replaces_inherits_or_clears_without_merging_keys() {
 
 #[test]
 fn reuse_object_presence_and_download_whole_object_replacement_are_preserved() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "reuse_object_presence_and_download_whole_object_replacement_are_preserved",
-    );
     for (options, upload, down) in [
         (json!({"download-settings":{}}), false, false),
         (
diff --git a/tests/xhttp_h3_shutdown.rs b/tests/xhttp_h3_shutdown.rs
index 990d4ba..c51d1f6 100644
--- a/tests/xhttp_h3_shutdown.rs
+++ b/tests/xhttp_h3_shutdown.rs
@@ -18,14 +18,17 @@ use std::{
     time::Duration,
 };
 use tokio::{
-    io::{AsyncWrite, AsyncWriteExt},
+    io::{AsyncRead, AsyncWrite, AsyncWriteExt, DuplexStream, ReadBuf},
     sync::mpsc,
     task::JoinSet,
 };
 use vole::{
     config::{Config, ProxyProtocol},
     dispatch::{DatagramBudget, DatagramTransport, DispatchError},
-    outbound::{EstablishContext, OutboundConnector, UpstreamPath, VlessOutbound},
+    outbound::{
+        ConnectedStream, DatagramRequest, EstablishContext, OutboundConnector, UpstreamPath,
+        VlessOutbound,
+    },
     session::{Datagram, Destination, InboundKind, StreamSession},
 };
 
@@ -86,6 +89,10 @@ struct SlowPackets {
 }
 #[async_trait::async_trait]
 impl DatagramTransport for SlowPackets {
+    fn supports_shared_destinations(&self) -> bool {
+        false
+    }
+
     fn payload_budget(&self, target: &Destination) -> DatagramBudget {
         self.inner.payload_budget(target)
     }
@@ -121,6 +128,31 @@ enum Closing {
     Stop,
 }
 
+struct MixedUpstream {
+    datagram: Mutex<Option<SlowPackets>>,
+    stream: Mutex<Option<DuplexStream>>,
+}
+#[async_trait::async_trait]
+impl OutboundConnector for MixedUpstream {
+    async fn connect_stream(
+        &self,
+        session: StreamSession,
+        _: &EstablishContext,
+    ) -> Result<ConnectedStream, DispatchError> {
+        Ok(ConnectedStream {
+            io: Box::new(self.stream.lock().unwrap().take().unwrap()),
+            effective_peer: session.destination,
+        })
+    }
+    async fn open_datagram(
+        &self,
+        _: DatagramRequest,
+        _: &EstablishContext,
+    ) -> Result<Box<dyn DatagramTransport>, DispatchError> {
+        Ok(Box::new(self.datagram.lock().unwrap().take().unwrap()))
+    }
+}
+
 #[tokio::test]
 async fn h3_shutdown_does_not_cancel_the_last_upload() {
     for mode in ["stream-one", "stream-up"] {
@@ -144,13 +176,31 @@ async fn h3_stalled_upload_is_bounded_and_owner_stop_joins_it() {
     }
 }
 
+#[tokio::test]
+async fn h3_first_upload_precedes_responses_and_mixed_download_cancel_joins_owners() {
+    tokio::time::timeout(
+        Duration::from_secs(6),
+        run("stream-up", Closing::Stop, None, true),
+    )
+    .await
+    .expect("mixed H3/H2 owners did not join");
+}
+
 async fn exercise(mode: &str, closing: Closing, handshake_delay: Option<Duration>) {
-    tokio::time::timeout(Duration::from_secs(6), run(mode, closing, handshake_delay))
-        .await
-        .expect("memory QUIC fixture exceeded its cleanup bound");
+    tokio::time::timeout(
+        Duration::from_secs(6),
+        run(mode, closing, handshake_delay, false),
+    )
+    .await
+    .expect("memory QUIC fixture exceeded its cleanup bound");
 }
 
-async fn run(mode: &str, closing: Closing, handshake_delay: Option<Duration>) {
+async fn run(
+    mode: &str,
+    closing: Closing,
+    handshake_delay: Option<Duration>,
+    mixed_first_bytes: bool,
+) {
     let server_address: SocketAddr = "192.0.2.1:443".parse().unwrap();
     let client_address: SocketAddr = "192.0.2.2:1234".parse().unwrap();
     let (to_server, from_client) = mpsc::channel(32);
@@ -188,6 +238,7 @@ async fn run(mode: &str, closing: Closing, handshake_delay: Option<Duration>) {
     .unwrap();
     let (started, ready) = tokio::sync::oneshot::channel();
     let (cleanup, cleaned) = tokio::sync::oneshot::channel();
+    let (uploaded, first_upload) = tokio::sync::oneshot::channel();
     let reader = tokio::spawn(async move {
         let connection = endpoint.accept().await.unwrap().await.unwrap();
         let mut h3 = h3::server::builder()
@@ -204,7 +255,9 @@ async fn run(mode: &str, closing: Closing, handshake_delay: Option<Duration>) {
                 .resolve_request()
                 .await
                 .unwrap();
-            stream.send_response(http::Response::new(())).await.unwrap();
+            if !mixed_first_bytes {
+                stream.send_response(http::Response::new(())).await.unwrap();
+            }
             if headers.method() == http::Method::POST {
                 break stream;
             }
@@ -213,17 +266,35 @@ async fn run(mode: &str, closing: Closing, handshake_delay: Option<Duration>) {
         };
         started.send(()).unwrap();
         let mut received = Vec::new();
+        let mut uploaded = Some(uploaded);
         while let Ok(Ok(Some(mut data))) =
             tokio::time::timeout(Duration::from_secs(1), request.recv_data()).await
         {
             received.extend_from_slice(&data.copy_to_bytes(data.remaining()));
+            if received.ends_with(&[b'x'; 16384])
+                && let Some(uploaded) = uploaded.take()
+            {
+                let _ = uploaded.send(());
+            }
         }
         let _ = cleaned.await;
+        if mixed_first_bytes || closing == Closing::Normal && handshake_delay.is_none() {
+            let closed = tokio::time::timeout(Duration::from_secs(2), connection.closed())
+                .await
+                .expect("quiet client retirement never sent CONNECTION_CLOSE");
+            let quinn::ConnectionError::ApplicationClosed(error) = closed else {
+                panic!("quiet retirement failed its close exchange: {closed}");
+            };
+            assert!(
+                error.error_code == 0_u8.into()
+                    || error.error_code.into_inner() == h3::error::Code::H3_NO_ERROR.value()
+            );
+        }
         drop(h3);
         endpoint.close(0_u32.into(), b"");
         received
     });
-    let config = serde_json::json!({
+    let mut config = serde_json::json!({
         "mixed-port":1080,
         "proxies":[{
             "name":"peer", "type":"vless", "server":"192.0.2.1", "port":443,
@@ -233,22 +304,51 @@ async fn run(mode: &str, closing: Closing, handshake_delay: Option<Duration>) {
         }],
         "rules":["MATCH,peer"]
     });
+    let (h2_client, h2_peer, h2_ready) = if mixed_first_bytes {
+        config["proxies"][0]["xhttp-opts"]["download-settings"] = serde_json::json!({
+            "port":8443, "tls":false, "skip-cert-verify":false, "alpn":["h2"]
+        });
+        let (client, server) = tokio::io::duplex(4096);
+        let (seen, ready) = tokio::sync::oneshot::channel();
+        let peer = tokio::spawn(async move {
+            let mut connection = h2::server::handshake(server).await.unwrap();
+            let (request, response) = connection.accept().await.unwrap().unwrap();
+            assert_eq!(request.method(), http::Method::GET);
+            let _held = (request, response); // Keep HEADERS pending until client cancellation.
+            seen.send(()).unwrap();
+            while let Some(result) = connection.accept().await {
+                if result.is_err() {
+                    break;
+                }
+                panic!("unexpected second download request");
+            }
+        });
+        (Some(client), Some(peer), Some(ready))
+    } else {
+        (None, None, None)
+    };
     let config = Config::parse_yaml(config.to_string().as_bytes()).unwrap();
     let ProxyProtocol::Vless(config) = &config.proxies[0].protocol else {
         panic!("protocol")
     };
     let state = Arc::new(AtomicU8::new(0));
-    let outbound = VlessOutbound::new_with_path(
-        config,
-        UpstreamPath::proxy(Arc::new(MemoryUpstream(Mutex::new(Some(SlowPackets {
-            inner: client_io,
-            state: state.clone(),
-            handshake_delay,
-            delayed_receive: None,
-        }))))),
-    )
-    .unwrap();
+    let packets = SlowPackets {
+        inner: client_io,
+        state: state.clone(),
+        handshake_delay,
+        delayed_receive: None,
+    };
+    let upstream: Arc<dyn OutboundConnector> = if let Some(stream) = h2_client {
+        Arc::new(MixedUpstream {
+            datagram: Mutex::new(Some(packets)),
+            stream: Mutex::new(Some(stream)),
+        })
+    } else {
+        Arc::new(MemoryUpstream(Mutex::new(Some(packets))))
+    };
+    let outbound = VlessOutbound::new_with_path(config, UpstreamPath::proxy(upstream)).unwrap();
     let session = StreamSession {
+        metadata: Default::default(),
         inbound: InboundKind::InternalMeasure,
         source: client_address,
         destination: Destination::domain("target.invalid", 443).unwrap(),
@@ -260,12 +360,40 @@ async fn run(mode: &str, closing: Closing, handshake_delay: Option<Duration>) {
         .unwrap()
         .io;
     ready.await.unwrap();
+    if let Some(ready) = h2_ready {
+        ready.await.unwrap();
+    }
     state.store(
-        if closing == Closing::Normal { 1 } else { 2 },
+        if mixed_first_bytes {
+            0
+        } else if closing == Closing::Normal {
+            1
+        } else {
+            2
+        },
         Ordering::SeqCst,
     );
     stream.write_all(&[b'x'; 16384]).await.unwrap();
-    stream.flush().await.unwrap();
+    if closing == Closing::Normal || mixed_first_bytes {
+        stream.flush().await.unwrap();
+    }
+    if mixed_first_bytes {
+        tokio::time::timeout(Duration::from_secs(1), first_upload)
+            .await
+            .expect("upload waited for an HTTP response")
+            .unwrap();
+        let mut bytes = [0; 1];
+        let mut output = ReadBuf::new(&mut bytes);
+        assert!(
+            poll_fn(|cx| Poll::Ready(Pin::new(&mut stream).poll_read(cx, &mut output)))
+                .await
+                .is_pending(),
+            "download unexpectedly received response HEADERS"
+        );
+    }
+    // A stalled controlled transport can exhaust native QUIC send capacity.
+    // Shutdown must bound this outstanding flush instead of the fixture
+    // waiting indefinitely for flush before it even requests shutdown.
     assert!(
         poll_fn(|cx| Poll::Ready(Pin::new(&mut stream).poll_shutdown(cx)))
             .await
@@ -286,13 +414,19 @@ async fn run(mode: &str, closing: Closing, handshake_delay: Option<Duration>) {
     let _ = cleanup.send(());
     let received = reader.await.unwrap();
     outbound.shutdown().await;
+    if let Some(peer) = h2_peer {
+        tokio::time::timeout(Duration::from_secs(1), peer)
+            .await
+            .expect("mixed H2 peer did not join")
+            .unwrap();
+    }
     // QUIC retains closed connections for 3 * PTO, which depends on RTT and
     // can legitimately exceed two seconds. After the upload and client Stop,
     // reclaim the fixture's tasks explicitly instead of timing its draining.
     tokio::time::timeout(Duration::from_secs(2), peer_runtime.stop())
         .await
         .expect("memory QUIC peer tasks did not join");
-    if closing == Closing::Normal {
+    if closing == Closing::Normal || mixed_first_bytes {
         assert!(
             received.ends_with(&[b'x'; 16384]),
             "mode={mode}: only {} upload bytes reached the peer",
diff --git a/tests/xhttp_requests.rs b/tests/xhttp_requests.rs
index f7bb7a9..180ea23 100644
--- a/tests/xhttp_requests.rs
+++ b/tests/xhttp_requests.rs
@@ -10,11 +10,6 @@ use vole::{
 
 #[tokio::test(start_paused = true)]
 async fn packet_up_coalesces_small_writes_and_flushes_without_more_caller_io() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "packet_up_coalesces_small_writes_and_flushes_without_more_caller_io",
-    );
     use std::{pin::Pin, task::Poll};
     use tokio::io::AsyncWrite;
     let client =
@@ -84,11 +79,6 @@ async fn packet_up_coalesces_small_writes_and_flushes_without_more_caller_io() {
 
 #[tokio::test(start_paused = true)]
 async fn packet_up_backpressures_bounded_batches_and_stop_cancels_the_timer() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "packet_up_backpressures_bounded_batches_and_stop_cancels_the_timer",
-    );
     use std::{pin::Pin, task::Poll};
     use tokio::io::AsyncWrite;
     let client =
@@ -132,11 +122,6 @@ async fn packet_up_backpressures_bounded_batches_and_stop_cancels_the_timer() {
 
 #[tokio::test]
 async fn first_vless_read_never_acknowledges_or_replays_a_concurrent_packet_write() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "first_vless_read_never_acknowledges_or_replays_a_concurrent_packet_write",
-    );
     use std::{pin::Pin, task::Poll};
     use tokio::io::AsyncWrite;
     tokio::time::timeout(Duration::from_secs(3), async {
@@ -209,11 +194,6 @@ async fn first_vless_read_never_acknowledges_or_replays_a_concurrent_packet_writ
 
 #[tokio::test]
 async fn response_codes_follow_mihomo_streaming_and_packet_rules() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "response_codes_follow_mihomo_streaming_and_packet_rules",
-    );
     tokio::time::timeout(Duration::from_secs(3), async {
         for (mode, get_status, post_status, read_ok, write_ok) in [
             (XHttpMode::StreamOne, 200, 201, true, true),
@@ -314,11 +294,6 @@ async fn observe_stream_request(options: serde_json::Value) -> http::Request<()>
 
 #[tokio::test]
 async fn streaming_content_type_can_be_disabled_without_disabling_padding() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "streaming_content_type_can_be_disabled_without_disabling_padding",
-    );
     let request =
         observe_stream_request(serde_json::json!({"mode":"stream-one","no-grpc-header":true}))
             .await;
@@ -333,11 +308,6 @@ async fn streaming_content_type_can_be_disabled_without_disabling_padding() {
 
 #[tokio::test]
 async fn custom_semantic_headers_are_allowed_when_no_generated_field_overwrites_them() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "custom_semantic_headers_are_allowed_when_no_generated_field_overwrites_them",
-    );
     let request = observe_stream_request(serde_json::json!({
         "mode":"stream-one", "no-grpc-header":true,
         "headers":{"Content-Type":"application/octet-stream","Referer":"https://example.com/custom"},
@@ -352,11 +322,6 @@ async fn custom_semantic_headers_are_allowed_when_no_generated_field_overwrites_
 
 #[tokio::test]
 async fn padding_uses_the_configured_http_location_and_encoding() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "padding_uses_the_configured_http_location_and_encoding",
-    );
     for placement in ["queryInHeader", "header", "query", "cookie"] {
         for method in ["repeat-x", "tokenish"] {
             let mut options = serde_json::json!({"mode":"stream-one", "x-padding-obfs-mode":true,
@@ -478,16 +443,12 @@ async fn observe_packet(
 
 #[tokio::test]
 async fn packet_metadata_and_upload_methods_are_sent_in_each_supported_location() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "packet_metadata_and_upload_methods_are_sent_in_each_supported_location",
-    );
     for (placement, method) in [
         ("path", "POST"),
         ("query", "PUT"),
         ("header", "PATCH"),
         ("cookie", "DELETE"),
+        ("path", "PROPFIND"),
     ] {
         let mut options = serde_json::json!({"mode":"packet-up","session-placement":placement,
             "seq-placement":placement,"session-table":"number","session-length":"10","uplink-http-method":method});
@@ -540,11 +501,6 @@ async fn packet_metadata_and_upload_methods_are_sent_in_each_supported_location(
 
 #[tokio::test]
 async fn packet_upload_can_move_payload_into_bounded_header_or_cookie_chunks() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "packet_upload_can_move_payload_into_bounded_header_or_cookie_chunks",
-    );
     use base64::Engine as _;
     for placement in ["body", "auto", "header", "cookie"] {
         let mut options = serde_json::json!({"mode":"packet-up","uplink-data-placement":placement,
@@ -600,11 +556,6 @@ async fn packet_upload_can_move_payload_into_bounded_header_or_cookie_chunks() {
 
 #[tokio::test]
 async fn http1_stream_one_is_chunked_duplex_and_shutdown_closes_both_directions() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "http1_stream_one_is_chunked_duplex_and_shutdown_closes_both_directions",
-    );
     tokio::time::timeout(Duration::from_secs(2), async {
         let (io, mut peer) = tokio::io::duplex(4096);
         let peer = tokio::spawn(async move {
@@ -656,11 +607,6 @@ async fn http1_stream_one_is_chunked_duplex_and_shutdown_closes_both_directions(
 
 #[tokio::test]
 async fn http1_packet_up_shares_a_session_across_two_connections() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "http1_packet_up_shares_a_session_across_two_connections",
-    );
     tokio::time::timeout(Duration::from_secs(2), async {
         async fn head(peer: &mut tokio::io::DuplexStream) -> String {
             let mut head = Vec::new();
@@ -751,11 +697,6 @@ async fn http1_packet_up_shares_a_session_across_two_connections() {
 
 #[tokio::test]
 async fn http1_response_body_can_arrive_after_the_response_headers() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "http1_response_body_can_arrive_after_the_response_headers",
-    );
     tokio::time::timeout(Duration::from_secs(2), async {
         let (io, mut peer) = tokio::io::duplex(4096);
         let peer = tokio::spawn(async move {
@@ -789,11 +730,6 @@ async fn http1_response_body_can_arrive_after_the_response_headers() {
 
 #[tokio::test]
 async fn custom_request_headers_reach_the_http_peer_without_changing_body() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "custom_request_headers_reach_the_http_peer_without_changing_body",
-    );
     tokio::time::timeout(Duration::from_secs(2), async {
         let document = serde_json::json!({"mixed-port":1080,"proxies":[{
             "name":"edge","type":"vless","server":"example.com","port":443,
diff --git a/tests/xhttp_reuse.rs b/tests/xhttp_reuse.rs
index 4008e40..04e5833 100644
--- a/tests/xhttp_reuse.rs
+++ b/tests/xhttp_reuse.rs
@@ -67,11 +67,6 @@ async fn peer(
 
 #[tokio::test]
 async fn enabled_reuse_shares_physical_h2_without_one_close_killing_its_sibling() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "enabled_reuse_shares_physical_h2_without_one_close_killing_its_sibling",
-    );
     tokio::time::timeout(Duration::from_secs(3), async {
         let probe = vole::resources::observation::ResourceProbe::default();
         probe
@@ -116,11 +111,6 @@ async fn enabled_reuse_shares_physical_h2_without_one_close_killing_its_sibling(
 
 #[tokio::test]
 async fn reuse_thresholds_expand_and_retire_without_closing_active_sessions() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "reuse_thresholds_expand_and_retire_without_closing_active_sessions",
-    );
     use serde_json::json;
     tokio::time::timeout(Duration::from_secs(5), async {
         for (settings, counts) in [
@@ -166,11 +156,6 @@ async fn reuse_thresholds_expand_and_retire_without_closing_active_sessions() {
 
 #[tokio::test]
 async fn expired_transport_is_not_assigned_again_while_old_session_stays_live() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "expired_transport_is_not_assigned_again_while_old_session_stays_live",
-    );
     tokio::time::timeout(Duration::from_secs(3), async {
         let tasks = TaskTracker::new();
         let calls = AtomicUsize::new(0);
@@ -205,11 +190,6 @@ async fn expired_transport_is_not_assigned_again_while_old_session_stays_live()
 
 #[tokio::test]
 async fn pooled_packet_posts_do_not_each_consume_a_transport_lease() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "pooled_packet_posts_do_not_each_consume_a_transport_lease",
-    );
     tokio::time::timeout(Duration::from_secs(3), async {
         let tasks = TaskTracker::new();
         let calls = AtomicUsize::new(0);
@@ -290,11 +270,6 @@ async fn pooled_packet_posts_do_not_each_consume_a_transport_lease() {
 
 #[tokio::test(start_paused = true)]
 async fn h2_keepalive_uses_default_explicit_and_disabled_idle_periods() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "h2_keepalive_uses_default_explicit_and_disabled_idle_periods",
-    );
     for (seconds, expected) in [(0, Some(45)), (2, Some(2)), (-1, None)] {
         let (io, mut remote) = tokio::io::duplex(16384);
         let (sent, received) = tokio::sync::oneshot::channel();
@@ -350,11 +325,6 @@ async fn h2_keepalive_uses_default_explicit_and_disabled_idle_periods() {
 
 #[tokio::test]
 async fn download_uses_its_own_reuse_counters_and_keeps_shared_sessions_alive() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "download_uses_its_own_reuse_counters_and_keeps_shared_sessions_alive",
-    );
     tokio::time::timeout(Duration::from_secs(3), async {
         let tasks = TaskTracker::new();
         let uploads = AtomicUsize::new(0);
@@ -393,11 +363,6 @@ async fn download_uses_its_own_reuse_counters_and_keeps_shared_sessions_alive()
 
 #[tokio::test]
 async fn h1_packet_upload_reuses_its_idle_connection_but_reopens_the_cancelled_get() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "h1_packet_upload_reuses_its_idle_connection_but_reopens_the_cancelled_get",
-    );
     tokio::time::timeout(Duration::from_secs(3), async {
         let tasks = TaskTracker::new();
         let calls = AtomicUsize::new(0);
@@ -477,11 +442,6 @@ async fn h1_packet_upload_reuses_its_idle_connection_but_reopens_the_cancelled_g
 
 #[tokio::test]
 async fn stopping_during_handshake_prevents_late_driver_admission() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "stopping_during_handshake_prevents_late_driver_admission",
-    );
     tokio::time::timeout(Duration::from_secs(2), async {
         let client =
             XHttpClient::new(XHttpConfig::new("example.com", "/x", XHttpMode::StreamOne).unwrap());
@@ -513,11 +473,6 @@ async fn stopping_during_handshake_prevents_late_driver_admission() {
 
 #[tokio::test]
 async fn stop_wakes_a_handshake_even_when_the_peer_never_responds() {
-    #[cfg(feature = "interop-test")]
-    let _case = vole::resources::case_events::Case::new(
-        "XHTTP-UNIT",
-        "stop_wakes_a_handshake_even_when_the_peer_never_responds",
-    );
     let client =
         XHttpClient::new(XHttpConfig::new("example.com", "/x", XHttpMode::StreamOne).unwrap());
     let (io, _remote) = tokio::io::duplex(1);